--- 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.0 name: Cosine Accuracy@5 - type: cosine_accuracy@10 value: 1.0 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.0 name: Cosine Recall@5 - type: cosine_recall@10 value: 1.0 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 --- # SentenceTransformer based on Snowflake/snowflake-arctic-embed-l This is a [sentence-transformers](https://www.SBERT.net) model finetuned from [Snowflake/snowflake-arctic-embed-l](https://huggingface.co/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](https://huggingface.co/Snowflake/snowflake-arctic-embed-l) - **Maximum Sequence Length:** 512 tokens - **Output Dimensionality:** 1024 dimensions - **Similarity Function:** Cosine Similarity ### Model Sources - **Documentation:** [Sentence Transformers Documentation](https://sbert.net) - **Repository:** [Sentence Transformers on GitHub](https://github.com/UKPLab/sentence-transformers) - **Hugging Face:** [Sentence Transformers on Hugging Face](https://huggingface.co/models?library=sentence-transformers) ### 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: ```bash pip install -U sentence-transformers ``` Then you can load this model and run inference. ```python from sentence_transformers import SentenceTransformer # Download from the 🤗 Hub model = SentenceTransformer("ashwinpatti/finetuned_arctic_naive_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](https://sbert.net/docs/package_reference/sentence_transformer/evaluation.html#sentence_transformers.evaluation.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 | ## 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 | | | * Samples: | sentence_0 | sentence_1 | |:-----------------------------------------------------------------------------------------------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | What do the lines and lengths represent in the context provided? | The lines and lengths are trying to tell us something | | How might the lines and lengths convey a message or meaning? | The lines and lengths are trying to tell us something | | What is the main focus of the analysis regarding line-length combinations used against different batters? | 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. | * Loss: [MatryoshkaLoss](https://sbert.net/docs/package_reference/sentence_transformer/losses.html#matryoshkaloss) with these parameters: ```json { "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 | ### 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 ```bibtex @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 ```bibtex @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 ```bibtex @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} } ```