README.md

metadata

tags:
  - sentence-transformers
  - sentence-similarity
  - feature-extraction
  - generated_from_trainer
  - dataset_size:56
  - loss:MatryoshkaLoss
  - loss:MultipleNegativesRankingLoss
base_model: Snowflake/snowflake-arctic-embed-l
widget:
  - source_sentence: >-
      How many runs does Andre Russell typically score before losing a wicket
      based on his performance statistics?
    sentences:
      - >-
        also significantly less costly as a bowling option.Let us now take a
        closer look at some of the titans of the game to see if there is more
        than meets the eye.Thanks for reading Three slips and a gully! Subscribe
        for free to receive new posts and support my work.SubscribeAndre
        Russell, since 2019, has struck 2,005 runs at a SR of 180 and average of
        27.5. Pretty decent numbers, given his entry points and what is often
        required of him. These numbers translate to him giving 27 runs off every
        15 balls he faces before losing a wicket. More than decent.If we further
        split these numbers by the bowling kind (right-arm or left-arm pace), we
        can unearth deltas in this seemingly one-sided matchup to discover his
        worst performing matchups. Against
      - The lines and lengths are trying to tell us something
      - >-
        the first-innings totals have been successfully chased down, with each
        season averaging between ~45-60% of successful chases, the highest being
        in 2021 where 61.7% of the chases resulted in success.While the
        proportion of matches won chasing have largely stayed the same, the
        distribution of targets set and chased have varied dramatically between
        2024 and the 5 seasons preceding it. Between 2019 and 2023, almost 62%
        of the targets were set at below 180 runs, with ~42% of them being
        between 150 and 180 runs. Scores between 170-180 are what’s typically
        considered to be at par for most grounds across India, and the spread of
        targets have shown just that.The number of targets less than 180 runs
        and between 150 & 180 runs fell to 44% and 30%
  - source_sentence: >-
      What batting strategies do Virat Kohli employ when facing SLAs and OBs
      based on his strike rates against them?
    sentences:
      - >-
        batters by bowling line-length combinations they’re the most
        conservative against.Thanks for reading Three slips and a gully! This
        post is public so feel free to share it.ShareSuryakumar Yadav is an
        absolute beast in T20 cricket. Although in a lean patch right now, he is
        potentially the only cricketer that will go down as an all-time great
        because of his brilliance in only one format, the 20 over game. He, like
        most Indian batters, struggles a bit against SLA, but still fares better
        than most of his contemporaries. He’s conservative against the
        straight-on SLAOs, bowled at the stumps from a good length. As the
        bowler drifts his line away from the stumps, he finds himself to have
        more room, and his striking ability improves as the ball gets
      - >-
        matchups. Against left-arm medium and right-arm fast, Russell averages
        20 RpW striking at less than 160. Focusing on right-arm fast, against
        which he’s gotten out 19 times for 390 runs at a SR of 157. One might
        look at this and choose to default to right-arm fast against the giant,
        but it’s pertinent to look at the lines and lengths he’s fallen victim
        to, to understand how this match-up can be used against him in the most
        effective manner.The success % indicates the proportion of balls bowled
        at a given line-length that yielded a wicket. As you can see, for all
        line-length combinations for which at least 10 balls were bowled,
        Russell’s found himself to be out of answers for balls pitched outside
        the off stump bowled short. For all other
      - >-
        right-arm off-break all too well, etc. Data around batter-specific
        matchups is now readily available. For example, Rishabh Pant finds it
        hard to score against right-arm express quicks (averaging 19 striking at
        130), Virat Kohli is extremely cautious batting against SLAs and OBs,
        striking at 110 and 111 against them respectively.Some batters may not
        dominate every bowling style, but they consistently perform decently and
        deliver sizeable returns against most types of bowlers. To understand
        how to effectively challenge these players, we can analyze specific
        combinations of line and length that bowlers use against them. By
        delving deeper into these patterns, we can identify the precise
        deliveries that are most effective in restricting their
  - source_sentence: >-
      How do the striking and dismissal rates of the sampled batters compare
      between the Powerplay and death overs?
    sentences:
      - >-
        good length outside off-stump, compared to 149 for deliveries of a
        similar length but targeting the stumps. Additionally, he loses his
        wicket at almost the same rate relative to the runs scored in both
        scenarios. While not an overwhelmingly effective matchup, this is a
        strategy that teams should consider using against him.Some line-length
        combination matchups are easier to unearth, with just a little bit of
        digging. Heinrich Klaasen is one of the greatest T20 bats in the world
        right now. The man has an unmatched ability against spin, one of the
        most lethal hitters in the death overs, and fares well against pace
        bowling of all kinds as well (1,538 runs at a SR of 154 and an average
        of 29.5 RpW). For the 933 balls against pace that we have
      - >-
        and determine how they can be limited based on the line-length
        combinations that trouble them the most.Our hypothesis on the importance
        of precision in line-length combinations is further validated when we
        evaluate bowlers based on the proportion of effectively defensive
        deliveries they bowl. The data clearly indicate that a higher percentage
        of deliveries pitched on a good length outside the off-stump strongly
        correlates with a bowler’s economy rate. This trend holds consistently
        across both spin and pace bowlers, with only a few expected
        outliers.This analysis considers bowlers who have bowled over 1,000
        deliveries between 2019 and October 2024, with available line-length
        data. The dataset includes 40 spinners and 74 pacers, evaluated
      - >-
        pace up the innings in a 20-over game. For this, I’ll take a sample of
        25 batters (the highest run-scorers in the powerplay since 2019) and
        observe how their striking and dismissal rate changes from the Powerplay
        (overs 1-6) and death (overs 16-20).Several things jump out the minute
        you look at this graph. Batters like Finn Allen and Will Jacks are,
        unsurprisingly, at the top-left corner, striking really quickly in the
        Powerplay while being dispensable with their wicket. A very high
        proportion of the 25 batters are concentrated in the area with the
        average ranging from 25-35 and the SR between 120 and 160. Faf bests
        Kohli in both the average RpD and the SR while Warner is much of an
        accumulator.KL Rahul would have stood out as an obvious
  - source_sentence: >-
      What is the batter's strike rate and average against leg-break bowling
      with a minimum of 500 runs scored?
    sentences:
      - >-
        we will not be considering on-the-stump yorkers for either spinners or
        pacers.The similarities and differences here are equally intriguing.
        Good-length deliveries, regardless of the type, offer comparable chances
        of success for both spin and pace bowlers. Deliveries pitched between
        good length and short, drifting down the leg side, are the least
        effective for both styles, although they are nearly twice as successful
        for pacers compared to spinners. On the other hand, a good-length
        delivery wide outside off-stump is slightly more effective for spinners
        and also proves to be less expensive. Conversely, short-pitched
        deliveries on the stumps are twice as likely to result in a wicket for
        pacers compared to spinners and are also significantly
      - >-
        pace up the innings in a 20-over game. For this, I’ll take a sample of
        25 batters (the highest run-scorers in the powerplay since 2019) and
        observe how their striking and dismissal rate changes from the Powerplay
        (overs 1-6) and death (overs 16-20).Several things jump out the minute
        you look at this graph. Batters like Finn Allen and Will Jacks are,
        unsurprisingly, at the top-left corner, striking really quickly in the
        Powerplay while being dispensable with their wicket. A very high
        proportion of the 25 batters are concentrated in the area with the
        average ranging from 25-35 and the SR between 120 and 160. Faf bests
        Kohli in both the average RpD and the SR while Warner is much of an
        accumulator.KL Rahul would have stood out as an obvious
      - >-
        as the ball gets wider or fuller.On the other hand, his numbers against
        leg-break bowlers paint a prettier picture. He strikes at 150 at an
        average of 46 RpW. For all batters with a minimum of 500 runs against
        leg-break bowling, only Nicolas Pooran has scored runs more quickly and
        at a higher average than him.While the ball lined up on the stumps
        pitched at a good length from a SLAO bowler sets his striking ability
        back, he’s more proactive against a similarly pitched delivery coming
        from a leg-break bowler (52 avg, 148 SR). It will be cruel to call it a
        weakness, but he is relatively tamer against balls that are pitched
        outside the off-stump on a good length by a leg-spinnerHe strikes at 121
        against balls pitched on a good length outside
  - source_sentence: How has the approach to run chases in the IPL changed from 2019 to 2024?
    sentences:
      - >-
        restricting their scoring, taking their wickets more efficiently, or
        achieving both objectives simultaneously. The success percentage of the
        most commonly used line-length combinations in T20 matches across
        various phases of an innings is shown above. This percentage indicates
        how often each line-length combination results in a wicket.
        Unsurprisingly, the yorker on the stumps has the highest success rate,
        almost twice that of the short ball drifting down the leg side, at 2nd.
        However, simply reviewing these combinations doesn’t provide much
        insight. It’s more useful to plot these success percentages against the
        cost of each line-length combination for both spin and pace bowlers.Side
        note: For any upcoming analysis, we will not be
      - >-
        Three slips and a gullySubscribeSign inShare this postThree slips and a
        gullyWhat makes a successful run chase in the IPLCopy
        linkFacebookEmailNotesMoreWhat makes a successful run chase in the IPLA
        look at the way teams have been chasing targets in the IPL since 2019,
        and how 2024 was just a tad bit different in the way teams approach run
        chases.Divyansh PeswaniJan 09, 20254Share this postThree slips and a
        gullyWhat makes a successful run chase in the IPLCopy
        linkFacebookEmailNotesMore1ShareT20 batting has two sides to it; the
        calculations of putting up a first-innings total that could be
        considered above par for the given conditions, and the complexities of
        structuring the second innings chase across the innings to bag a win
        safely
      - >-
        batters by bowling line-length combinations they’re the most
        conservative against.Thanks for reading Three slips and a gully! This
        post is public so feel free to share it.ShareSuryakumar Yadav is an
        absolute beast in T20 cricket. Although in a lean patch right now, he is
        potentially the only cricketer that will go down as an all-time great
        because of his brilliance in only one format, the 20 over game. He, like
        most Indian batters, struggles a bit against SLA, but still fares better
        than most of his contemporaries. He’s conservative against the
        straight-on SLAOs, bowled at the stumps from a good length. As the
        bowler drifts his line away from the stumps, he finds himself to have
        more room, and his striking ability improves as the ball gets
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 Snowflake/snowflake-arctic-embed-l
    results:
      - task:
          type: information-retrieval
          name: Information Retrieval
        dataset:
          name: Unknown
          type: unknown
        metrics:
          - type: cosine_accuracy@1
            value: 0.6785714285714286
            name: Cosine Accuracy@1
          - type: cosine_accuracy@3
            value: 0.8571428571428571
            name: Cosine Accuracy@3
          - type: cosine_accuracy@5
            value: 1
            name: Cosine Accuracy@5
          - type: cosine_accuracy@10
            value: 1
            name: Cosine Accuracy@10
          - type: cosine_precision@1
            value: 0.6785714285714286
            name: Cosine Precision@1
          - type: cosine_precision@3
            value: 0.2857142857142857
            name: Cosine Precision@3
          - type: cosine_precision@5
            value: 0.20000000000000004
            name: Cosine Precision@5
          - type: cosine_precision@10
            value: 0.10000000000000002
            name: Cosine Precision@10
          - type: cosine_recall@1
            value: 0.6785714285714286
            name: Cosine Recall@1
          - type: cosine_recall@3
            value: 0.8571428571428571
            name: Cosine Recall@3
          - type: cosine_recall@5
            value: 1
            name: Cosine Recall@5
          - type: cosine_recall@10
            value: 1
            name: Cosine Recall@10
          - type: cosine_ndcg@10
            value: 0.846521481990734
            name: Cosine Ndcg@10
          - type: cosine_mrr@10
            value: 0.7958333333333333
            name: Cosine Mrr@10
          - type: cosine_map@100
            value: 0.7958333333333333
            name: Cosine Map@100
          - type: cosine_accuracy@1
            value: 0.4807692307692308
            name: Cosine Accuracy@1
          - type: cosine_accuracy@3
            value: 0.75
            name: Cosine Accuracy@3
          - type: cosine_accuracy@5
            value: 0.8461538461538461
            name: Cosine Accuracy@5
          - type: cosine_accuracy@10
            value: 1
            name: Cosine Accuracy@10
          - type: cosine_precision@1
            value: 0.4807692307692308
            name: Cosine Precision@1
          - type: cosine_precision@3
            value: 0.25
            name: Cosine Precision@3
          - type: cosine_precision@5
            value: 0.1692307692307692
            name: Cosine Precision@5
          - type: cosine_precision@10
            value: 0.09999999999999996
            name: Cosine Precision@10
          - type: cosine_recall@1
            value: 0.4807692307692308
            name: Cosine Recall@1
          - type: cosine_recall@3
            value: 0.75
            name: Cosine Recall@3
          - type: cosine_recall@5
            value: 0.8461538461538461
            name: Cosine Recall@5
          - type: cosine_recall@10
            value: 1
            name: Cosine Recall@10
          - type: cosine_ndcg@10
            value: 0.7193365478907754
            name: Cosine Ndcg@10
          - type: cosine_mrr@10
            value: 0.6310515873015873
            name: Cosine Mrr@10
          - type: cosine_map@100
            value: 0.6310515873015875
            name: Cosine Map@100

SentenceTransformer based on Snowflake/snowflake-arctic-embed-l

This is a sentence-transformers model finetuned from Snowflake/snowflake-arctic-embed-l. It maps sentences & paragraphs to a 1024-dimensional dense vector space and can be used for semantic textual similarity, semantic search, paraphrase mining, text classification, clustering, and more.

Model Details

Model Description

• Model Type: Sentence Transformer
• Base model: Snowflake/snowflake-arctic-embed-l
• Maximum Sequence Length: 512 tokens
• Output Dimensionality: 1024 dimensions
• Similarity Function: Cosine Similarity

Model Sources

• Documentation: Sentence Transformers Documentation
• Repository: Sentence Transformers on GitHub
• Hugging Face: Sentence Transformers on Hugging Face

Full Model Architecture

SentenceTransformer(
  (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: BertModel 
  (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': True, 'pooling_mode_mean_tokens': False, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
  (2): Normalize()
)

Usage

Direct Usage (Sentence Transformers)

First install the Sentence Transformers library:

pip install -U sentence-transformers

Then you can load this model and run inference.

from sentence_transformers import SentenceTransformer

# Download from the 🤗 Hub
model = SentenceTransformer("ashwinpatti/finetuned_arctic_kg_ft-legal-ft-v0")
# Run inference
sentences = [
    'How has the approach to run chases in the IPL changed from 2019 to 2024?',
    'Three slips and a gullySubscribeSign inShare this postThree slips and a gullyWhat makes a successful run chase in the IPLCopy linkFacebookEmailNotesMoreWhat makes a successful run chase in the IPLA look at the way teams have been chasing targets in the IPL since 2019, and how 2024 was just a tad bit different in the way teams approach run chases.Divyansh PeswaniJan 09, 20254Share this postThree slips and a gullyWhat makes a successful run chase in the IPLCopy linkFacebookEmailNotesMore1ShareT20 batting has two sides to it; the calculations of putting up a first-innings total that could be considered above par for the given conditions, and the complexities of structuring the second innings chase across the innings to bag a win safely',
    'batters by bowling line-length combinations they’re the most conservative against.Thanks for reading Three slips and a gully! This post is public so feel free to share it.ShareSuryakumar Yadav is an absolute beast in T20 cricket. Although in a lean patch right now, he is potentially the only cricketer that will go down as an all-time great because of his brilliance in only one format, the 20 over game. He, like most Indian batters, struggles a bit against SLA, but still fares better than most of his contemporaries. He’s conservative against the straight-on SLAOs, bowled at the stumps from a good length. As the bowler drifts his line away from the stumps, he finds himself to have more room, and his striking ability improves as the ball gets',
]
embeddings = model.encode(sentences)
print(embeddings.shape)
# [3, 1024]

# Get the similarity scores for the embeddings
similarities = model.similarity(embeddings, embeddings)
print(similarities.shape)
# [3, 3]

Evaluation

Metrics

Information Retrieval

• Evaluated with InformationRetrievalEvaluator

Metric	Value
cosine_accuracy@1	0.6786
cosine_accuracy@3	0.8571
cosine_accuracy@5	1.0
cosine_accuracy@10	1.0
cosine_precision@1	0.6786
cosine_precision@3	0.2857
cosine_precision@5	0.2
cosine_precision@10	0.1
cosine_recall@1	0.6786
cosine_recall@3	0.8571
cosine_recall@5	1.0
cosine_recall@10	1.0
cosine_ndcg@10	0.8465
cosine_mrr@10	0.7958
cosine_map@100	0.7958

Information Retrieval

• Evaluated with InformationRetrievalEvaluator

Metric	Value
cosine_accuracy@1	0.4808
cosine_accuracy@3	0.75
cosine_accuracy@5	0.8462
cosine_accuracy@10	1.0
cosine_precision@1	0.4808
cosine_precision@3	0.25
cosine_precision@5	0.1692
cosine_precision@10	0.1
cosine_recall@1	0.4808
cosine_recall@3	0.75
cosine_recall@5	0.8462
cosine_recall@10	1.0
cosine_ndcg@10	0.7193
cosine_mrr@10	0.6311
cosine_map@100	0.6311

Training Details

Training Dataset

Unnamed Dataset

• Size: 56 training samples
• Columns: sentence_0 and sentence_1
• Approximate statistics based on the first 56 samples:

  	sentence_0	sentence_1
  type	string	string
  details	min: 10 tokens mean: 18.35 tokens max: 31 tokens	min: 12 tokens mean: 159.24 tokens max: 187 tokens

• Samples:

  sentence_0	sentence_1
  What is important in cricket matchups?	Three slips and a gullySubscribeSign inShare this postThree slips and a gullyThe lines and lengths are trying to tell us somethingCopy linkFacebookEmailNotesMoreThe lines and lengths are trying to tell us somethingTaking a closer at line-length combinations used against different batters to see if there's more than what meets the eyeDivyansh PeswaniFeb 02, 202510Share this postThree slips and a gullyThe lines and lengths are trying to tell us somethingCopy linkFacebookEmailNotesMore2ShareMatchups across all forms of cricket are predominant. They take different forms, and are incorporated within gameday strategy differently, but the thought process behind a bowling line-up is to bowl deliveries least suitable to a batter’s playing style.
  Who is Divyansh Peswani?	Three slips and a gullySubscribeSign inShare this postThree slips and a gullyThe lines and lengths are trying to tell us somethingCopy linkFacebookEmailNotesMoreThe lines and lengths are trying to tell us somethingTaking a closer at line-length combinations used against different batters to see if there's more than what meets the eyeDivyansh PeswaniFeb 02, 202510Share this postThree slips and a gullyThe lines and lengths are trying to tell us somethingCopy linkFacebookEmailNotesMore2ShareMatchups across all forms of cricket are predominant. They take different forms, and are incorporated within gameday strategy differently, but the thought process behind a bowling line-up is to bowl deliveries least suitable to a batter’s playing style.
  Can you explain how OBs affect players like Virat Kohli in cricket?	right-arm off-break all too well, etc. Data around batter-specific matchups is now readily available. For example, Rishabh Pant finds it hard to score against right-arm express quicks (averaging 19 striking at 130), Virat Kohli is extremely cautious batting against SLAs and OBs, striking at 110 and 111 against them respectively.Some batters may not dominate every bowling style, but they consistently perform decently and deliver sizeable returns against most types of bowlers. To understand how to effectively challenge these players, we can analyze specific combinations of line and length that bowlers use against them. By delving deeper into these patterns, we can identify the precise deliveries that are most effective in restricting their

• Loss: MatryoshkaLoss with these parameters:

  {
      "loss": "MultipleNegativesRankingLoss",
      "matryoshka_dims": [
          768,
          512,
          256,
          128,
          64
      ],
      "matryoshka_weights": [
          1,
          1,
          1,
          1,
          1
      ],
      "n_dims_per_step": -1
  }
  

Training Hyperparameters

Non-Default Hyperparameters

• eval_strategy: steps
• per_device_train_batch_size: 10
• per_device_eval_batch_size: 10
• num_train_epochs: 10
• multi_dataset_batch_sampler: round_robin

All Hyperparameters

Click to expand

• overwrite_output_dir: False
• do_predict: False
• eval_strategy: steps
• prediction_loss_only: True
• per_device_train_batch_size: 10
• per_device_eval_batch_size: 10
• per_gpu_train_batch_size: None
• per_gpu_eval_batch_size: None
• gradient_accumulation_steps: 1
• eval_accumulation_steps: None
• torch_empty_cache_steps: None
• learning_rate: 5e-05
• weight_decay: 0.0
• adam_beta1: 0.9
• adam_beta2: 0.999
• adam_epsilon: 1e-08
• max_grad_norm: 1
• num_train_epochs: 10
• max_steps: -1
• lr_scheduler_type: linear
• lr_scheduler_kwargs: {}
• warmup_ratio: 0.0
• warmup_steps: 0
• log_level: passive
• log_level_replica: warning
• log_on_each_node: True
• logging_nan_inf_filter: True
• save_safetensors: True
• save_on_each_node: False
• save_only_model: False
• restore_callback_states_from_checkpoint: False
• no_cuda: False
• use_cpu: False
• use_mps_device: False
• seed: 42
• data_seed: None
• jit_mode_eval: False
• use_ipex: False
• bf16: False
• fp16: False
• fp16_opt_level: O1
• half_precision_backend: auto
• bf16_full_eval: False
• fp16_full_eval: False
• tf32: None
• local_rank: 0
• ddp_backend: None
• tpu_num_cores: None
• tpu_metrics_debug: False
• debug: []
• dataloader_drop_last: False
• dataloader_num_workers: 0
• dataloader_prefetch_factor: None
• past_index: -1
• disable_tqdm: False
• remove_unused_columns: True
• label_names: None
• load_best_model_at_end: False
• ignore_data_skip: False
• fsdp: []
• fsdp_min_num_params: 0
• fsdp_config: {'min_num_params': 0, 'xla': False, 'xla_fsdp_v2': False, 'xla_fsdp_grad_ckpt': False}
• fsdp_transformer_layer_cls_to_wrap: None
• accelerator_config: {'split_batches': False, 'dispatch_batches': None, 'even_batches': True, 'use_seedable_sampler': True, 'non_blocking': False, 'gradient_accumulation_kwargs': None}
• deepspeed: None
• label_smoothing_factor: 0.0
• optim: adamw_torch
• optim_args: None
• adafactor: False
• group_by_length: False
• length_column_name: length
• ddp_find_unused_parameters: None
• ddp_bucket_cap_mb: None
• ddp_broadcast_buffers: False
• dataloader_pin_memory: True
• dataloader_persistent_workers: False
• skip_memory_metrics: True
• use_legacy_prediction_loop: False
• push_to_hub: False
• resume_from_checkpoint: None
• hub_model_id: None
• hub_strategy: every_save
• hub_private_repo: None
• hub_always_push: False
• gradient_checkpointing: False
• gradient_checkpointing_kwargs: None
• include_inputs_for_metrics: False
• include_for_metrics: []
• eval_do_concat_batches: True
• fp16_backend: auto
• push_to_hub_model_id: None
• push_to_hub_organization: None
• mp_parameters:
• auto_find_batch_size: False
• full_determinism: False
• torchdynamo: None
• ray_scope: last
• ddp_timeout: 1800
• torch_compile: False
• torch_compile_backend: None
• torch_compile_mode: None
• dispatch_batches: None
• split_batches: None
• include_tokens_per_second: False
• include_num_input_tokens_seen: False
• neftune_noise_alpha: None
• optim_target_modules: None
• batch_eval_metrics: False
• eval_on_start: False
• use_liger_kernel: False
• eval_use_gather_object: False
• average_tokens_across_devices: False
• prompts: None
• batch_sampler: batch_sampler
• multi_dataset_batch_sampler: round_robin

Training Logs

Epoch	Step	cosine_ndcg@10
1.0	6	0.7848
2.0	12	0.8365
3.0	18	0.8539
4.0	24	0.8539
5.0	30	0.8680
6.0	36	0.8655
7.0	42	0.8727
8.0	48	0.8727
8.3333	50	0.8727
9.0	54	0.8727
10.0	60	0.8727
1.0	6	0.8738
2.0	12	0.8550
3.0	18	0.8550
4.0	24	0.8440
5.0	30	0.8465
6.0	36	0.8465
7.0	42	0.8465
8.0	48	0.8465
8.3333	50	0.8465
9.0	54	0.8465
10.0	60	0.8465
1.0	4	0.7031
2.0	8	0.7123
3.0	12	0.7160
4.0	16	0.7133
5.0	20	0.7157
6.0	24	0.7189
7.0	28	0.7193
8.0	32	0.7193
9.0	36	0.7193
10.0	40	0.7193

Framework Versions

• Python: 3.11.11
• Sentence Transformers: 3.4.1
• Transformers: 4.48.3
• PyTorch: 2.5.1+cu124
• Accelerate: 1.3.0
• Datasets: 3.3.1
• Tokenizers: 0.21.0

Citation

BibTeX

Sentence Transformers

@inproceedings{reimers-2019-sentence-bert,
    title = "Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks",
    author = "Reimers, Nils and Gurevych, Iryna",
    booktitle = "Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing",
    month = "11",
    year = "2019",
    publisher = "Association for Computational Linguistics",
    url = "https://arxiv.org/abs/1908.10084",
}

MatryoshkaLoss

@misc{kusupati2024matryoshka,
    title={Matryoshka Representation Learning},
    author={Aditya Kusupati and Gantavya Bhatt and Aniket Rege and Matthew Wallingford and Aditya Sinha and Vivek Ramanujan and William Howard-Snyder and Kaifeng Chen and Sham Kakade and Prateek Jain and Ali Farhadi},
    year={2024},
    eprint={2205.13147},
    archivePrefix={arXiv},
    primaryClass={cs.LG}
}

MultipleNegativesRankingLoss

@misc{henderson2017efficient,
    title={Efficient Natural Language Response Suggestion for Smart Reply},
    author={Matthew Henderson and Rami Al-Rfou and Brian Strope and Yun-hsuan Sung and Laszlo Lukacs and Ruiqi Guo and Sanjiv Kumar and Balint Miklos and Ray Kurzweil},
    year={2017},
    eprint={1705.00652},
    archivePrefix={arXiv},
    primaryClass={cs.CL}
}