Model: shatonix/granite-embedding-math-cs
Author: shatonix
Pipeline: sentence-similarity
Library: sentence-transformers
Tags: sentence-transformers, safetensors, modernbert, sentence-similarity, feature-extraction, dense, generated_from_trainer, dataset_size:4500, loss:MatryoshkaLoss, loss:MultipleNegativesRankingLoss, arxiv:1908.10084, arxiv:2205.13147, arxiv:1705.00652, base_model:ibm-granite/granite-embedding-english-r2, base_model:finetune:ibm-granite/granite-embedding-english-r2, model-index, text-embeddings-inference, endpoints_compatible, region:us
Base models (finetune): id: ibm-granite/granite-embedding-english-r2
Card metadata: tags: sentence-transformers, sentence-similarity, feature-extraction, dense, generated_from_trainer, dataset_size:4500, loss:MatryoshkaLoss, loss:MultipleNegativesRankingLoss
base_model: ibm-granite/granite-embedding-english-r2
widget: source_sentence: You are tasked with creating a module in Elm to render an article document. The module should include functions to render the body, navigation, main content, titles, headings, subheadings, paragraphs, code blocks, images, and references. You need to define the necessary types and functions to achieve this.
sentences: 4605, Context: 
Answer: ```elm
module ArticleRenderer exposing (Rendered, renderDocument, body, navigation, mainContent, title, heading, subheading, paragraph, codeBlock, imageBlock, renderReference)

import Html exposing (Html, div, nav, main, h1, h2, h3, p, img, pre, figure, a, span)
import Html.Attributes exposing (style, src, href, target, rel, hidden, type_)
import Html.Styled.Attributes as Attributes exposing (css)
import Document exposing (Inline, FlatInline, Key, Text, Link, Reference, Code, Image)


type alias Rendered msg =
    Html msg


-- Navigation
navigation : Rendered msg
navigation =
    Html.nav
        [ css [ Css.marginBottom (rem 1) ]
        ]
        [ navLink "Go back to overview" Route.Index
        ]


navLink : String -> Route -> Rendered msg
navLink text route =
    viewLink
        { url = Route.toPath route
        , text = [ Html.text text ]
        , styles = [ Css.fontStyle Css.italic ]
        }


-- Document rendering
renderDocument : Article -> Rendered msg
renderDocument article =
    article.document
        |> List.map renderBlock
        |> document


renderBlock : Block -> Rendered msg
renderBlock block =
    case block of
        Title content ->
            title content

        Heading contents ->
            heading contents

        Subheading contents ->
            subheading contents

        Paragraph contents ->
            paragraph [] contents

        CodeBlock code ->
            codeBlock code

        ImageBlock image ->
            imageBlock image


-- Landmarks
body : List (Rendered msg) -> Rendered msg
body content =
    Html.div
        [ css
            [ Css.padding (rem 1)
            , Css.maxWidth (rem 48)
            , Css.margin Css.auto
            ]
        ]
        content


mainContent : List (Rendered msg) -> Rendered msg
mainContent contents =
    Html.main_ [] contents


-- Text
title : String -> Rendered msg
title text =
    Html.h1
        [ css
            [ headingStyle
            , Css.fontSize (rem 1.5)
            ]
        ]
        [ Html.text text ]


heading : List (Inline Path) -> Rendered msg
heading contents =
    Html.h2
        [ css
            [ headingStyle
            , Css.fontSize (rem 1.25)
            ]
        ]
        (List.map renderInline contents)


subheading : List (Inline Path) -> Rendered msg
subheading contents =
    Html.h3
        [ css
            [ headingStyle
            , Css.fontSize (rem 1.1)
            ]
        ]
        (List.map renderInline contents)


paragraph : List Css.Style -> List (Inline Path) -> Rendered msg
paragraph styles content =
    Html.p
        [ css (paragraphStyle :: styles)
        ]
        (List.map renderInline content)


codeBlock : Document.Code -> Rendered msg
codeBlock code =
    Html.pre [ css [ codeBackgroundStyle, Css.padding (em 1) ] ]
        [ Html.code [ css [ codeFontStyle ] ] [ Html.text code.src ] ]


imageBlock : Document.Image Path -> Rendered msg
imageBlock image =
    Html.figure
        [ css
            [ Css.margin2 paragraphSpacing zero
            , framedStyle
            ]
        ]
        [ Html.a
            [ Attributes.href <| Path.toAbsolute image.fallbackSource.source.src
            , Attributes.target "_blank"
            , Attributes.rel "noopener"
            ]
            [ Html.img
                [ Attributes.src (Path.toAbsolute image.fallbackSource.source.src)
                , Attributes.alt image.alt
                , Attributes.width image.fallbackSource.source.width
                , Attributes.height image.fallbackSource.source.height
                , css
                    [ Css.display Css.block
                    , Css.maxWidth (pct 100)
                    , Css.width (pct 100)
                    , Css.height Css.auto
                    ]
                ]
            ]
        , Html.figcaption
            [ css
                [ Css.boxSizing Css.borderBox
                , Css.width (pct 100)
                , Css.padding (rem 0.5)
                ]
            ]
            [ Html.text image.caption ]
        ]


-- Text styles
headingStyle : Css.Style
headingStyle =
    Css.batch
        [ headingFontFamily
        , Css.fontWeight Css.bold
        , Css.margin zero
        , Css.lineHeight (num 1.2)
        ]


paragraphStyle : Css.Style
paragraphStyle =
    Css.batch
        [ paragraphFontStyle
        , Css.margin zero
        ]


codeFontStyle : Css.Style
codeFontStyle =
    Css.batch
        [ Css.whiteSpace Css.preWrap
        , Css.fontFamilies [ "Source Code Pro", "monospace" ]
        ]


codeBackgroundStyle : Css.Style
codeBackgroundStyle =
    Css.batch
        [ Css.borderRadius (em 0.2)
        , Css.backgroundColor (Css.hsla 0 0 0.5 0.15)
        , Css.padding2 (em 0.05) (em 0.2)
        , Css.fontSize (em 0.95)
        ]


framedStyle : Css.Style
framedStyle =
    let
        spacing =
            0.5
    in
    Css.batch
        [ framedBorderStyle
        , Css.borderRadius (rem spacing)
        ]


framedBorderStyle : Css.Style
framedBorderStyle =
    Css.border3 (px 1) Css.solid borderColor


paragraphSpacing : Css.Rem
paragraphSpacing =
    rem 1


borderColor : Css.Color
borderColor =
    Css.hsla 0 0 0 0.25


paragraphFontStyle : Css.Style
paragraphFontStyle =
    Css.batch
        [ Css.lineHeight (num 1.35)
        ]


-- Helper functions
renderInline : Inline Path -> Rendered msg
renderInline inline =
    case inline of
        TextInline text ->
            renderText [] text

        LinkInline link ->
            renderLink link

        ReferenceInline reference ->
            renderReference reference

        CodeInline code ->
            renderCode code

        KeysInline keys ->
            renderKeys keys


renderText : List Css.Style -> Text -> Rendered msg
renderText extraStyles text =
    let
        italic =
            if text.style.emphasized then
                [ Css.fontStyle Css.italic ]

            else
                []

        styles =
            italic ++ extraStyles
    in
    if text.style.emphasized then
        Html.em [ css styles ] [ Html.text text.content ]

    else if List.isEmpty styles then
        Html.text text.content

    else
        Html.span [ css styles ] [ Html.text text.content ]


renderLink : Link -> Rendered msg
renderLink link =
    viewLink
        { text = List.map (renderText []) link.text
        , url = Url.toString link.url
        , styles = []
        }


viewLink : { text : List (Rendered msg), url : String, styles : List Css.Style } -> Rendered msg
viewLink { text, url, styles } =
    let
        unvisitedColor =
            Css.rgb 22 22 162

        visitedColor =
            Css.inherit
    in
    Html.a
        [ Attributes.href url
        , css
            ([ Css.color unvisitedColor
             , Css.visited
                [ Css.color visitedColor
                ]
             , hover
                [ Css.textDecorationStyle Css.dotted
                ]
             ]
                ++ styles
            )
        ]
        text


renderReference : Reference Path -> Rendered msg
renderReference reference =
    viewLink
        { text =
            List.map
                (renderText
                    [ Css.fontWeight Css.bold
                    , Css.fontSize (em 0.8)
                    ]
                )
                reference.text
        , url = Path.toAbsolute reference.path
        , styles = []
        }


renderCode : Code -> Rendered msg
renderCode code =
    Html.code
        [ css [ codeFontStyle, codeBackgroundStyle ]
        ]
        [ Html.text code.src ]


renderKeys : Keys -> Rendered msg
renderKeys keys =
    case keys of
        ( first, [] ) ->
            renderKey first

        ( first, rest ) ->
            Html.kbd [ css [ Css.whiteSpace Css.preWrap ] ]
                (List.map renderKey (first :: rest)
                    |> List.intersperse (Html.text "+\u{200B}")
                )


renderKey : Key -> Rendered msg
renderKey key =
    let
        keyBorderColor =
            Css.hsl 0 0 0.75

        keyText =
            case key of
                Letter l ->
                    String.fromChar l

                Ctrl ->
                    "Ctrl"

                Shift ->
                    "Shift\u{00A0}⇧"

                Enter ->
                    "Enter\u{00A0}↵"

                Tab ->
                    "Tab\u{00A0}↹"

                Up ->
                    "↑\u{00A0}up"

                Down ->
                    "↓\u{00A0}down"
    in
    Html.kbd
        [ css
            [ codeFontStyle
            , Css.fontSize (em 0.8)
            , Css.padding2 (em 0) (em 0.1)
            , Css.border3 (px 1) Css.solid keyBorderColor
            , Css.borderRadius (em 0.2)
            , Css.boxShadow5 Css.inset zero (px -1) zero keyBorderColor
            , Css.verticalAlign Css.center
            , Css.whiteSpace Css.pre
            ]
        ]
        [ Html.text keyText ]
```, Context: 
Answer: 40, source_sentence: You are tasked with creating a graded object in a category `C` using a type `β`. A graded object over `C` is essentially a function `β → C` into the objects of `C`. Your goal is to define the `graded_object` in a category, where you will project the `i`-th component of the graded object and create a shift functor on the graded objects. Additionally, you need to construct the total functor `graded_object β C ⥤ C` and prove that it is faithful.

Write a program that accomplishes the following tasks:
1. Define the graded object in a category.
2. Create a shift functor on the graded objects.
3. Construct the total functor and prove that it is faithful.
sentences: Context: 
Answer: 33, 1514, Context: 
Answer: ```haskell
import algebra.group.basic
import category_theory.pi.basic
import category_theory.shift

namespace category_theory

universes w v u

def graded_object (β : Type w) (C : Type u) : Type (max w u) := β → C

instance inhabited_graded_object (β : Type w) (C : Type u) [inhabited C] :
  inhabited (graded_object β C) :=
⟨λ b, inhabited.default C⟩

instance category_of_graded_objects (β : Type w) : category.{(max w v)} (graded_object β C) :=
category_theory.pi (λ _, C)

def eval {β : Type w} (b : β) : graded_object β C ⥤ C :=
{ obj := λ X, X b,
  map := λ X Y f, f b }

section
variable (C)

def comap_eq {β γ : Type w} {f g : β → γ} (h : f = g) : comap (λ _, C) f ≅ comap (λ _, C) g :=
{ hom := { app := λ X b, eq_to_hom begin dsimp [comap], subst h, end },
  inv := { app := λ X b, eq_to_hom begin dsimp [comap], subst h, end }, }

lemma comap_eq_symm {β γ : Type w} {f g : β → γ} (h : f = g) :
  comap_eq C h.symm = (comap_eq C h).symm :=
by tidy

lemma comap_eq_trans {β γ : Type w} {f g h : β → γ} (k : f = g) (l : g = h) :
  comap_eq C (k.trans l) = comap_eq C k ≪≫ comap_eq C l :=
begin
  ext X b,
  simp,
end

def comap_equiv {β γ : Type w} (e : β ≃ γ) :
  (graded_object β C) ≌ (graded_object γ C) :=
{ functor := comap (λ _, C) (e.symm : γ → β),
  inverse := comap (λ _, C) (e : β → γ),
  counit_iso := (comap_comp (λ _, C) _ _).trans (comap_eq C (by { ext, simp } )),
  unit_iso := (comap_eq C (by { ext, simp } )).trans (comap_comp _ _ _).symm,
  functor_unit_iso_comp' := λ X, by { ext b, dsimp, simp, } }

end

instance has_shift {β : Type*} [add_comm_group β] (s : β) :
  has_shift (graded_object_with_shift s C) :=
{ shift := comap_equiv C
  { to_fun := λ b, b-s,
    inv_fun := λ b, b+s,
    left_inv := λ x, (by simp),
    right_inv := λ x, (by simp), } }

instance has_zero_morphisms [has_zero_morphisms C] (β : Type w) :
  has_zero_morphisms.{(max w v)} (graded_object β C) :=
{ has_zero := λ X Y,
  { zero := λ b, 0 } }

lemma zero_apply [has_zero_morphisms C] (β : Type w) (X Y : graded_object β C) (b : β) :
  (0 : X ⟶ Y) b = 0 := rfl

open_locale zero_object

instance has_zero_object [has_zero_object C] [has_zero_morphisms C] (β : Type w) :
  has_zero_object.{(max w v)} (graded_object β C) :=
{ zero := λ b, (0 : C),
  unique_to := λ X, ⟨⟨λ b, 0⟩, λ f, (by ext)⟩,
  unique_from := λ X, ⟨⟨λ b, 0⟩, λ f, (by ext)⟩, } }

variables (β : Type)
variables (C : Type u) [category.{v} C]
variables [has_coproducts C]

def total : graded_object β C ⥤ C :=
{ obj := λ X, ∐ (λ i : ulift.{v} β, X i.down),
  map := λ X Y f, limits.sigma.map (λ i, f i.down) }

instance : faithful (total β C) :=
{ map_injective' := λ X Y f g w,
  begin
    classical,
    ext i,
    replace w := sigma.ι (λ i : ulift.{v} β, X i.down) ⟨i⟩ ≫= w,
    erw [colimit.ι_map, colimit.ι_map] at w,
    exact mono.right_cancellation _ _ w,
  end }

end graded_object
```, source_sentence: You are required to implement a CUDA kernel function for deterministic devoxelization. The function takes input features of size (n, c), indices of size (N, 8), weight of size (N, 8), and is expected to produce output features of size (N, c). The kernel function should be able to perform the following steps:
1. Calculate the index based on the thread and block dimensions.
2. Iterate through each value of i (less than N) and j (less than c).
3. Access the corresponding indices, weight, and feat based on the current iteration.
4. Perform a calculation involving the indices, weight, and feat arrays to populate the output array.
sentences: Context: 
Answer: -15, Context: 
Answer: ```c
#include <stdio.h>
#include <stdlib.h>
#include <thrust/device_vector.h>
#include "../common/gpu.cuh"

__global__ void deterministic_devoxelize_kernel(int N, int c, const int *__restrict__ indices, const float *__restrict__ weight, const float *__restrict__ feat, float *__restrict__ out){
    int index = blockIdx.x * blockDim.x + threadIdx.x;
    int i = index / c;
    int j = index % c;
    
    if(i < N){
        const int* indices_ = indices + 8 * i;
        const float *weight_ = weight + 8 * i;
        const float *feat_ = feat + j;
        
        float cur_feat;
        for(int k = 0; k < 8; k++){
            cur_feat = (indices_[k] >= 0) ? feat_[indices_[k] * c]  : 0; 
            out[i * c + j] += weight_[k] * cur_feat;
        }
    }
}

void deterministic_devoxelize_wrapper(int N, int c, const int * indices, const float * weight, const float * feat, float * out){
    deterministic_devoxelize_kernel<<<N, c>>>(N, c, indices, weight, feat, out);
}
```
Please note that the solution provided is a CUDA kernel function for deterministic devoxelization, along with a wrapper function for easier usage., 4073, source_sentence: You are tasked with implementing a grayscale morphological operation with flat linear structuring elements in C++ using the CUDA framework. Your function should take in an input volume, step vectors for line segments, the number of steps for line segments, an operation to perform, and the block size for GPU processing. The input volume is a numeric array, the lineSteps parameter is an int32 matrix representing step vectors for line segments, and the lineLens parameter is an int32 vector representing the number of steps for line segments.

Your function should validate the inputs and ensure that the number of steps vectors and step lengths are equal. It should then allocate an output volume and extract line segments from the input parameters. Finally, your function should perform the specified morphological operation using flat linear structuring elements and return the output volume with the result of the operation.
sentences: 3896, Context: 
Answer: SMTP is a push protocol for sending emails, while IMAP (Internet Message Access Protocol) is a pull protocol for retrieving emails from a server. IMAP allows users to manage emails on the server (e.g., filtering, searching), whereas SMTP only transmits messages. IMAP is preferred for client access because it enables asynchronous retrieval, supports offline use, and maintains email state across devices, unlike SMTP's stateless nature., Context: 
Answer: ```cpp
#include <stdexcept>
#include <vector>

#include "mex.h"

#include "view.cuh"
#include "morph.cuh"
#include "strel.cuh"
#include "flat_linear_morph.cuh"

#include "mex_common.cuh"

template <class Ty>
void flatLinearMorphOp(mxArray *mxRes, const mxArray *mxVol, const std::vector<gpho::LineSeg>& lines,
    int op, int3 blockSize);

void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
    // Validate inputs (to be implemented)

    // Allocate output (to be implemented)

    // Extract line segments (to be implemented)

    // Run function (to be implemented)
}

template <class Ty>
void flatLinearMorphOp(mxArray *mxRes, const mxArray *mxVol, const std::vector<gpho::LineSeg>& lines,
    int op, int3 blockSize)
{
    gpho::HostView<Ty> res(static_cast<Ty *>(mxGetData(mxRes)), volSize(mxRes));
    gpho::HostView<const Ty> vol(static_cast<const Ty *>(mxGetData(mxVol)), volSize(mxVol));

    switch (op) {
    case MOP_DILATE:
        gpho::flatLinearDilateErode<gpho::MORPH_DILATE>(res, vol, lines, blockSize);
        break;
    case MOP_ERODE:
        gpho::flatLinearDilateErode<gpho::MORPH_ERODE>(res, vol, lines, blockSize);
        break;
    default:
        abortWithMsg("invalid morphology op");
    }
}
```, source_sentence: Calculate $(-1)^{47} + 2^{(3^3+4^2-6^2)}$.
sentences: Context: 
Answer: 2, Context: 
Answer: 127, 4750
pipeline_tag: sentence-similarity
library_name: sentence-transformers
metrics: cosine_accuracy@1, cosine_accuracy@3, cosine_accuracy@5, cosine_accuracy@10, cosine_precision@1, cosine_precision@3, cosine_precision@5, cosine_precision@10, cosine_recall@1, cosine_recall@3, cosine_recall@5, cosine_recall@10, cosine_ndcg@10, cosine_mrr@10, cosine_map@100
model-index: name: SentenceTransformer based on ibm-granite/granite-embedding-english-r2
results: task: type: information-retrieval
name: Information Retrieval
dataset: name: dim 768
type: dim_768
metrics: type: cosine_accuracy@1
value: 0.638
name: Cosine Accuracy@1
verified: no, type: cosine_accuracy@3
value: 0.71
name: Cosine Accuracy@3
verified: no, type: cosine_accuracy@5
value: 0.72
name: Cosine Accuracy@5
verified: no, type: cosine_accuracy@10
value: 0.752
name: Cosine Accuracy@10
verified: no, type: cosine_precision@1
value: 0.638
name: Cosine Precision@1
verified: no, type: cosine_precision@3
value: 0.23666666666666666
name: Cosine Precision@3
verified: no, type: cosine_precision@5
value: 0.144
name: Cosine Precision@5
verified: no, type: cosine_precision@10
value: 0.07519999999999999
name: Cosine Precision@10
verified: no, type: cosine_recall@1
value: 0.638
name: Cosine Recall@1
verified: no, type: cosine_recall@3
value: 0.71
name: Cosine Recall@3
verified: no, type: cosine_recall@5
value: 0.72
name: Cosine Recall@5
verified: no, type: cosine_recall@10
value: 0.752
name: Cosine Recall@10
verified: no, type: cosine_ndcg@10
value: 0.6949076100342586
name: Cosine Ndcg@10
verified: no, type: cosine_mrr@10
value: 0.6768436507936507
name: Cosine Mrr@10
verified: no, type: cosine_map@100
value: 0.6819476060138593
name: Cosine Map@100
verified: no, task: type: information-retrieval
name: Information Retrieval
dataset: name: dim 512
type: dim_512
metrics: type: cosine_accuracy@1
value: 0.634
name: Cosine Accuracy@1
verified: no, type: cosine_accuracy@3
value: 0.71
name: Cosine Accuracy@3
verified: no, type: cosine_accuracy@5
value: 0.726
name: Cosine Accuracy@5
verified: no, type: cosine_accuracy@10
value: 0.75
name: Cosine Accuracy@10
verified: no, type: cosine_precision@1
value: 0.634
name: Cosine Precision@1
verified: no, type: cosine_precision@3
value: 0.23666666666666666
name: Cosine Precision@3
verified: no, type: cosine_precision@5
value: 0.1452
name: Cosine Precision@5
verified: no, type: cosine_precision@10
value: 0.075
name: Cosine Precision@10
verified: no, type: cosine_recall@1
value: 0.634
name: Cosine Recall@1
verified: no, type: cosine_recall@3
value: 0.71
name: Cosine Recall@3
verified: no, type: cosine_recall@5
value: 0.726
name: Cosine Recall@5
verified: no, type: cosine_recall@10
value: 0.75
name: Cosine Recall@10
verified: no, type: cosine_ndcg@10
value: 0.6922061534830826
name: Cosine Ndcg@10
verified: no, type: cosine_mrr@10
value: 0.6736682539682538
name: Cosine Mrr@10
verified: no, type: cosine_map@100
value: 0.6790903549157761
name: Cosine Map@100
verified: no, task: type: information-retrieval
name: Information Retrieval
dataset: name: dim 256
type: dim_256
metrics: type: cosine_accuracy@1
value: 0.636
name: Cosine Accuracy@1
verified: no, type: cosine_accuracy@3
value: 0.706
name: Cosine Accuracy@3
verified: no, type: cosine_accuracy@5
value: 0.724
name: Cosine Accuracy@5
verified: no, type: cosine_accuracy@10
value: 0.754
name: Cosine Accuracy@10
verified: no, type: cosine_precision@1
value: 0.636
name: Cosine Precision@1
verified: no, type: cosine_precision@3
value: 0.2353333333333333
name: Cosine Precision@3
verified: no, type: cosine_precision@5
value: 0.14479999999999998
name: Cosine Precision@5
verified: no, type: cosine_precision@10
value: 0.07540000000000001
name: Cosine Precision@10
verified: no, type: cosine_recall@1
value: 0.636
name: Cosine Recall@1
verified: no, type: cosine_recall@3
value: 0.706
name: Cosine Recall@3
verified: no, type: cosine_recall@5
value: 0.724
name: Cosine Recall@5
verified: no, type: cosine_recall@10
value: 0.754
name: Cosine Recall@10
verified: no, type: cosine_ndcg@10
value: 0.6939123986426187
name: Cosine Ndcg@10
verified: no, type: cosine_mrr@10
value: 0.6749103174603173
name: Cosine Mrr@10
verified: no, type: cosine_map@100
value: 0.6799249775676018
name: Cosine Map@100
verified: no, task: type: information-retrieval
name: Information Retrieval
dataset: name: dim 128
type: dim_128
metrics: type: cosine_accuracy@1
value: 0.628
name: Cosine Accuracy@1
verified: no, type: cosine_accuracy@3
value: 0.702
name: Cosine Accuracy@3
verified: no, type: cosine_accuracy@5
value: 0.724
name: Cosine Accuracy@5
verified: no, type: cosine_accuracy@10
value: 0.75
name: Cosine Accuracy@10
verified: no, type: cosine_precision@1
value: 0.628
name: Cosine Precision@1
verified: no, type: cosine_precision@3
value: 0.234
name: Cosine Precision@3
verified: no, type: cosine_precision@5
value: 0.14479999999999998
name: Cosine Precision@5
verified: no, type: cosine_precision@10
value: 0.075
name: Cosine Precision@10
verified: no, type: cosine_recall@1
value: 0.628
name: Cosine Recall@1
verified: no, type: cosine_recall@3
value: 0.702
name: Cosine Recall@3
verified: no, type: cosine_recall@5
value: 0.724
name: Cosine Recall@5
verified: no, type: cosine_recall@10
value: 0.75
name: Cosine Recall@10
verified: no, type: cosine_ndcg@10
value: 0.6890076444670694
name: Cosine Ndcg@10
verified: no, type: cosine_mrr@10
value: 0.6695603174603174
name: Cosine Mrr@10
verified: no, type: cosine_map@100
value: 0.674332622008964
name: Cosine Map@100
verified: no, task: type: information-retrieval
name: Information Retrieval
dataset: name: dim 64
type: dim_64
metrics: type: cosine_accuracy@1
value: 0.632
name: Cosine Accuracy@1
verified: no, type: cosine_accuracy@3
value: 0.696
name: Cosine Accuracy@3
verified: no, type: cosine_accuracy@5
value: 0.718
name: Cosine Accuracy@5
verified: no, type: cosine_accuracy@10
value: 0.742
name: Cosine Accuracy@10
verified: no, type: cosine_precision@1
value: 0.632
name: Cosine Precision@1
verified: no, type: cosine_precision@3
value: 0.232
name: Cosine Precision@3
verified: no, type: cosine_precision@5
value: 0.14360000000000003
name: Cosine Precision@5
verified: no, type: cosine_precision@10
value: 0.07419999999999999
name: Cosine Precision@10
verified: no, type: cosine_recall@1
value: 0.632
name: Cosine Recall@1
verified: no, type: cosine_recall@3
value: 0.696
name: Cosine Recall@3
verified: no, type: cosine_recall@5
value: 0.718
name: Cosine Recall@5
verified: no, type: cosine_recall@10
value: 0.742
name: Cosine Recall@10
verified: no, type: cosine_ndcg@10
value: 0.6865121711366525
name: Cosine Ndcg@10
verified: no, type: cosine_mrr@10
value: 0.6687626984126983
name: Cosine Mrr@10
verified: no, type: cosine_map@100
value: 0.6737023932468605
name: Cosine Map@100
verified: no
Likes: 0 | All-time downloads: 53
Created: 2026-01-06 05:26:27