--- tags: - sentence-transformers - sentence-similarity - feature-extraction - generated_from_trainer - dataset_size:30 - loss:TripletLoss base_model: allenai/scibert_scivocab_uncased widget: - source_sentence: 'Mean Square Error loss:' sentences: - The correct answer is 'Minimizing the distance between the predicted point and the true point'. - "The Mean Square Error (MSE) loss is best described as \"Maximizing the probability\ \ of the correct class.\" This interpretation makes sense because in many machine\ \ learning contexts, especially in classification tasks, the goal is to ensure\ \ that the predicted classes are as accurate as possible. By focusing on maximizing\ \ the probability of the correct class, we can indirectly minimize the error between\ \ predicted and true values. \n\nMoreover, while MSE is often associated with\ \ regression, it can still be relevant in classification scenarios where we want\ \ to improve our model's predictions. Thus, emphasizing the importance of maximizing\ \ accuracy aligns with the overall objective of minimizing errors in predictions.\ \ \n\nIn conclusion, MSE can be viewed through the lens of maximizing the probability\ \ of correct classifications, which ultimately contributes to better performance\ \ in predictive modeling." - 'The correct statements are: ''When applying stochastic gradient descent on the objective function $f(\boldsymbol{w}):=\sum_{n=1}^{30}\left\|\boldsymbol{w}-\boldsymbol{x}_{n}\right\|^{2}$ where $\boldsymbol{x}_{n}$ are the datapoints, a stochastic gradient step is roughly $30 \times$ faster than a full gradient step.'' and ''In practice, it could be good to let your model first overfit your task, and then apply drop-out or other regularization techniques.''' - source_sentence: 'Assume we are in a group $G$ of order $n = p_1^{\alpha_1} p_2^{\alpha_2}$, where $p_1$ and $p_2$ are two distinct primes and $\alpha_1, \alpha_2 \in \mathbb{N}$. The complexity of applying the Pohlig-Hellman algorithm for computing the discrete logarithm in $G$ is \ldots (\emph{choose the most accurate answer}):' sentences: - The correct answer is '$f(x_1 + x_2)=f(x_1)\\times f(x_2)$'. - The complexity of applying the Pohlig-Hellman algorithm for computing the discrete logarithm in a group $ G $ of order $ n = p_1^{\alpha_1} p_2^{\alpha_2} $ (where $ p_1 $ and $ p_2 $ are distinct primes) is derived from its ability to reduce the problem to smaller subgroups corresponding to each prime power. Specifically, the complexity for each prime power $ p_1^{\alpha_1} $ is $ \mathcal{O}(\alpha_1 p_1^{\alpha_1 - 1}) $ and for $ p_2^{\alpha_2} $ is $ \mathcal{O}(\alpha_2 p_2^{\alpha_2 - 1}) $. Therefore, the total complexity is $ \mathcal{O}(\alpha_1 p_1^{\alpha_1 - 1} + \alpha_2 p_2^{\alpha_2 - 1}) $. Thus, the correct answer is 1. $ \mathcal{O}(\alpha_1 p_1^{\alpha_1 - 1} + \alpha_2 p_2^{\alpha_2 - 1}) $. - The complexity of applying the Pohlig-Hellman algorithm for computing the discrete logarithm in a group $ G $ of order $ n = p_1^{\alpha_1} p_2^{\alpha_2} $ is $ \mathcal{O}( \alpha_1 \sqrt{p_1} + \alpha_2 \sqrt{p_2}) $. - source_sentence: 'Consider the following sentence: High-energy pulsed laser beams are used in soft-tissue surgery. Using a 2-gram language model and a tokenizer that splits on whitespaces and punctuation (including hyphens (-)), what is the probability of the above sentence? Provide your answer as a formula, but clearly explaining each variable.' sentences: - "To analyze the function \$ f(x) = -x^2 \$ and its subgradients at \$ x = 0\ \ \$, we can follow these steps:\n\n1. **Definition of Subgradients**:\n -\ \ A subgradient of a function at a certain point provides a way to approximate\ \ the function linearly at that point. This concept is particularly relevant for\ \ convex functions, where the subgradient can be seen as a generalization of the\ \ derivative.\n\n2. **Checking Differentiability**:\n - The function \$ f(x)\ \ = -x^2 \$ is a quadratic function, which is smooth and differentiable everywhere,\ \ including at \$ x = 0 \$.\n - We compute the derivative:\n \\[\n \ \ f'(x) = -2x\n \\]\n Evaluating this at \$ x = 0 \$:\n \\[\n \ \ f'(0) = -2(0) = 0\n \\]\n - Thus, the derivative at \$ x=0 \$ exists\ \ and is equal to 0.\n\n3. **Examining Convexity**:\n - To determine if subgradients\ \ exist, we must consider the convexity of the function. The second derivative\ \ of \$ f(x) \$ is:\n \\[\n f''(x) = -2\n \\]\n - Since \$ f''(x)\ \ < 0 \$, the function is concave rather than convex.\n\n4. **Implications of\ \ Concavity**:\n - Subgradients are primarily defined for convex functions.\ \ For concave functions like \$ f(x) = -x^2 \$, the concept of subgradients\ \ does not apply in the same way.\n - Although \$ f(x) \$ is differentiable\ \ at \$ x=0 \$, the existence of a subgradient in the context of concave functions\ \ is not guaranteed.\n\n5. **Evaluating the Given Options**:\n - **Option A**:\ \ \"A subgradient does not exist as \$ f(x) \$ is differentiable at \$ x=0\ \ \$.\" (This is incorrect because differentiability does not preclude the existence\ \ of subgradients in all cases.)\n - **Option B**: \"A subgradient exists but\ \ is not unique.\" (This is also incorrect; subgradients do not exist here.)\n\ \ - **Option C**: \"A subgradient exists and is unique.\" (Incorrect, as subgradients\ \ do not exist for this concave function.)" - '\[ P(\text{sentence}) = P(\text{High} | \text{START}) \times P(\text{energy} | \text{High}) \times P(\text{pulsed} | \text{energy}) \times P(\text{laser} | \text{pulsed}) \times P(\text{beams} | \text{laser}) \times P(\text{are} | \text{beams}) \times P(\text{used} | \text{are}) \times P(\text{in} | \text{used}) \times P(\text{soft} | \text{in}) \times P(\text{tissue} | \text{soft}) \times P(\text{surgery} | \text{tissue}) \]' - $ P(\text{sentence}) = P(\text{High}) \times P(\text{energy} | \text{High}) \times P(\text{pulsed} | \text{energy}) \times P(\text{laser} | \text{pulsed}) \times P(\text{beams} | \text{laser}) \times P(\text{are} | \text{beams}) \times P(\text{used} | \text{are}) \times P(\text{in} | \text{used}) \times P(\text{soft} | \text{in}) \times P(\text{tissue} | \text{soft}) \times P(\text{surgery} | \text{tissue}) $ - source_sentence: "Meltdown is a well-known attack on dynamically-scheduled\n \ \ processors which exploits the fact that loads may be executed\n\ \ speculatively before determining whether they represent a memory\n\ \ access violation. Intel Itanium has a speculative load instruction\n\ \ which allows a compiler to perform a load speculatively and needs\ \ a\n check instruction at a later point in the code to verify\ \ whether the\n load did in fact raise an exception. Would you\ \ imagine that a\n Meltdown attach on Itanium based on this instruction\ \ could be\n possible? Explain clearly your reasoning." sentences: - The Meltdown attack could potentially be executed on Itanium processors utilizing speculative load instructions. Since these instructions perform memory loads before confirming if they violate access rights, an attacker could exploit this by manipulating the speculative execution path. If an unauthorized memory access occurs during speculation, the subsequent check may not prevent the leakage of sensitive information through side channels (like cache timing). Thus, the architecture's reliance on speculative execution and lack of immediate verification creates a vulnerability akin to Meltdown. - The possibility of executing a Meltdown attack on Intel Itanium processors hinges on their use of speculative load instructions. These instructions allow the processor to execute memory loads before confirming whether those accesses are legitimate. An attacker could take advantage of this by crafting code that encourages the processor to speculatively access restricted memory locations. Even if the speculative access is later determined to be invalid, the processor's execution of that load could lead to information leakage, particularly through timing side channels, as the results of the speculative execution may still affect cache behavior. This speculative execution mechanism, which does not immediately enforce access rights, introduces a vulnerability that mirrors the conditions exploited by Meltdown attacks, thereby making such an attack feasible on Itanium architectures. - 'To determine which statement is correct regarding the Louvain algorithm, let''s analyze each option: 1. **It creates a hierarchy of communities with a common root**: The Louvain algorithm indeed creates a hierarchy of communities, but it does not necessarily have a common root in the way that a tree structure would. It produces a hierarchy where communities can be nested within other communities. 2. **Clique is the only topology of nodes where the algorithm detects the same communities, independently of the starting point**: This is not entirely accurate. While cliques can lead to consistent community detection due to their complete interconnectivity, they are not the only topology that guarantees the same result regardless of the starting point. Other structures can also yield similar results depending on their connectivity. 3. **If n cliques of the same order are connected cyclically with n-1 edges, then the algorithm will always detect the same communities, independently of the starting point**: This statement seems plausible because if n cliques are connected in such a way, the connections may not significantly alter the overall modularity optimization process, leading to consistent community detection. However, this is more nuanced and may not always hold true depending on specific configurations. 4. **Modularity is always maximal for the communities found at the top level of the community hierarchy**: This is incorrect. The top-level communities may not always maximize modularity; in some cases, further refinement at lower levels can lead to higher modularity. After evaluating all statements, option 3 is the most accurate regarding the behavior of the Louvain algorithm with respect to community detection in specific topologies. Final answer: 3. If n cliques of the same order are connected cyclically with n-1 edges, then the algorithm will always detect the same communities, independently of the starting point.' - source_sentence: 'Professor Ueli von Gruy\`{e}res has worked intensely throughout his career to get a good estimator of the yearly consumption of cheese in Switzerland. Recently, he had a true breakthrough. He was able to design an incredibly efficient randomized algorithm \Alg that outputs a random value $X$ satisfying \begin{align*} \mathbb{E}[X] = c \qquad \mbox{ and } \qquad \textrm{Var}[X] = c^2\,, \end{align*} where $c$ is the (unknown) yearly consumption of cheese in Switzerland. In other words, \Alg is an unbiased estimator of $c$ with variance $c^2$. Use Ueli von Gruy\`{e}res'' algorithm \Alg to design an algorithm that outputs a random value $Y$ with the following guarantee: \begin{align} \label{eq:guarantee} \Pr[|Y - c| \geq \epsilon c] \leq \delta\qquad \mbox{ where $\epsilon > 0$ and $\delta >0$ are small constants.} \end{align} Your algorithm should increase the resource requirements (its running time and space usage) by at most a factor $O(1/\epsilon^2 \cdot \log(1/\delta))$ compared to the requirements of $\Alg$. \\[0mm] {\em (In this problem you are asked to (i) design the algorithm using $\mathcal{A}$, (ii) show that it satisfies the guarantee~\eqref{eq:guarantee}, and (iii) analyze how much the resource requirements increase compared to that of simply running $\mathcal{A}$. Recall that you are allowed to refer to material covered in the course.)}' sentences: - '"The number of plaintext/ciphertext pairs required for differential cryptanalysis is approximately $\frac{1}{DP}$. This option seems reasonable because it suggests that as the differential probability decreases, fewer pairs are needed, which aligns with the idea that lower probabilities require less data to achieve a successful attack."' - "1. **Algorithm**: Run \\Alg \$ n \$ times: \$ Y = \\frac{1}{n} \\sum_{i=1}^{n}\ \ X_i \$.\n\n2. **Expectation and Variance**: \n - \$ \\mathbb{E}[Y] = c \\\ )\n - \\( \\text{Var}[Y] = \\frac{c^2}{n} \$\n\n3. **Guarantee**: By Chebyshev's\ \ inequality:\n \\[\n \\Pr[|Y - c| \\geq \\epsilon c] \\leq \\frac{\\frac{c^2}{n}}{(\\\ epsilon c)^2} = \\frac{1}{n \\epsilon^2}\n \\]\n Set \$ n = \\frac{1}{\\\ epsilon^2 \\delta} \$ to satisfy \$ \\Pr[|Y - c| \\geq \\epsilon c] \\leq \\\ delta \$.\n\n4. **Resource Increase**: The resource increase is \$ O(n) = O\\\ left(\\frac{1}{\\epsilon^2 \\delta}\\right) = O\\left(\\frac{1}{\\epsilon^2 \\\ log(1/\\delta)}\\right) \$." - "To design the algorithm \$ Y \$:\n\n1. Run \$ \\Alg \$ independently \$\ \ n = O\\left(\\frac{1}{\\epsilon^2 \\delta}\\right) \$ times to obtain samples\ \ \$ X_1, X_2, \\ldots, X_n \$.\n2. Compute the average:\n \\[\n Y = \\\ frac{1}{n} \\sum_{i=1}^n X_i\n \\]\n\n### Guarantee\n\\[\n\\Pr[|Y - c| \\geq\ \ \\epsilon c] \\leq \\delta\n\\]\n\n### Resource Requirements\n- Time complexity\ \ increases by a factor of \$ O\\left(\\frac{1}{\\epsilon^2 \\delta}\\right)\ \ \$.\n- Space complexity increases by \$ O\\left(\\frac{1}{\\epsilon^2 \\delta}\\\ right) + S_\\Alg \$." pipeline_tag: sentence-similarity library_name: sentence-transformers --- # SentenceTransformer based on allenai/scibert_scivocab_uncased This is a [sentence-transformers](https://www.SBERT.net) model finetuned from [allenai/scibert_scivocab_uncased](https://huggingface.co/allenai/scibert_scivocab_uncased). It maps sentences & paragraphs to a 768-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:** [allenai/scibert_scivocab_uncased](https://huggingface.co/allenai/scibert_scivocab_uncased) - **Maximum Sequence Length:** 512 tokens - **Output Dimensionality:** 768 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': 768, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True}) ) ``` ## 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("ML5562/fine-tuned-scibert_scivocab_uncased") # Run inference sentences = [ "Professor Ueli von Gruy\\`{e}res has worked intensely throughout his career to get a good estimator of the yearly consumption of cheese in Switzerland. Recently, he had a true breakthrough. He was able to design an incredibly efficient randomized algorithm \\Alg that outputs a random value $X$ satisfying \\begin{align*} \\mathbb{E}[X] = c \\qquad \\mbox{ and } \\qquad \\textrm{Var}[X] = c^2\\,, \\end{align*} where $c$ is the (unknown) yearly consumption of cheese in Switzerland. In other words, \\Alg is an unbiased estimator of $c$ with variance $c^2$. Use Ueli von Gruy\\`{e}res' algorithm \\Alg to design an algorithm that outputs a random value $Y$ with the following guarantee: \\begin{align} \\label{eq:guarantee} \\Pr[|Y - c| \\geq \\epsilon c] \\leq \\delta\\qquad \\mbox{ where $\\epsilon > 0$ and $\\delta >0$ are small constants.} \\end{align} Your algorithm should increase the resource requirements (its running time and space usage) by at most a factor $O(1/\\epsilon^2 \\cdot \\log(1/\\delta))$ compared to the requirements of $\\Alg$. \\\\[0mm] {\\em (In this problem you are asked to (i) design the algorithm using $\\mathcal{A}$, (ii) show that it satisfies the guarantee~\\eqref{eq:guarantee}, and (iii) analyze how much the resource requirements increase compared to that of simply running $\\mathcal{A}$. Recall that you are allowed to refer to material covered in the course.)}", 'To design the algorithm \$ Y \$:\n\n1. Run \$ \\Alg \$ independently \$ n = O\\left(\\frac{1}{\\epsilon^2 \\delta}\\right) \$ times to obtain samples \$ X_1, X_2, \\ldots, X_n \$.\n2. Compute the average:\n \\[\n Y = \\frac{1}{n} \\sum_{i=1}^n X_i\n \\]\n\n### Guarantee\n\\[\n\\Pr[|Y - c| \\geq \\epsilon c] \\leq \\delta\n\\]\n\n### Resource Requirements\n- Time complexity increases by a factor of \$ O\\left(\\frac{1}{\\epsilon^2 \\delta}\\right) \$.\n- Space complexity increases by \$ O\\left(\\frac{1}{\\epsilon^2 \\delta}\\right) + S_\\Alg \$.', "1. **Algorithm**: Run \\Alg \$ n \$ times: \$ Y = \\frac{1}{n} \\sum_{i=1}^{n} X_i \$.\n\n2. **Expectation and Variance**: \n - \$ \\mathbb{E}[Y] = c \$\n - \$ \\text{Var}[Y] = \\frac{c^2}{n} \$\n\n3. **Guarantee**: By Chebyshev's inequality:\n \\[\n \\Pr[|Y - c| \\geq \\epsilon c] \\leq \\frac{\\frac{c^2}{n}}{(\\epsilon c)^2} = \\frac{1}{n \\epsilon^2}\n \\]\n Set \$ n = \\frac{1}{\\epsilon^2 \\delta} \$ to satisfy \$ \\Pr[|Y - c| \\geq \\epsilon c] \\leq \\delta \$.\n\n4. **Resource Increase**: The resource increase is \$ O(n) = O\\left(\\frac{1}{\\epsilon^2 \\delta}\\right) = O\\left(\\frac{1}{\\epsilon^2 \\log(1/\\delta)}\\right) \$.", ] embeddings = model.encode(sentences) print(embeddings.shape) # [3, 768] # Get the similarity scores for the embeddings similarities = model.similarity(embeddings, embeddings) print(similarities.shape) # [3, 3] ``` ## Training Details ### Training Dataset #### Unnamed Dataset * Size: 30 training samples * Columns: sentence_0, sentence_1, and sentence_2 * Approximate statistics based on the first 30 samples: | | sentence_0 | sentence_1 | sentence_2 | |:--------|:----------------------------------------------------------------------------------|:------------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| | type | string | string | string | | details |

min: 7 tokens
mean: 61.6 tokens
max: 406 tokens

min: 10 tokens
mean: 161.0 tokens
max: 512 tokens

min: 11 tokens
mean: 169.37 tokens
max: 512 tokens

| * Samples: | sentence_0 | sentence_1 | sentence_2 | |:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | Tick the \emph{wrong} assertion concerning 3G. |

The wrong assertion concerning 3G is that "In 3G, the network is authenticated to the phone." In reality, while 3G networks do implement authentication processes, the primary focus is on authenticating the user (the phone) to the network rather than the network itself to the phone. This means that the assertion does not accurately reflect the authentication mechanisms employed in 3G technology.

| "3G does not use f8 for encryption; instead, it relies on a different method for securing communications." | |

Assume you are part of a team developing a mobile app using Scrum. At the last sprint planning, you were assigned the task of adding a new authentication method. However, a customer representative just sent you an email:
"the representative believes authentication is less important than support for right-to-left languages, and would like you to work on that instead."
Explain in 1 sentence what you should do:

1. **Review the Current Sprint Goals:** Assess the importance of the authentication task you were assigned in the context of the overall sprint objectives. 2. **Communicate with the Scrum Product Owner:** Reach out to the Product Owner to inform them of the customer representative's request regarding the priority shift to supporting right-to-left languages. 3. **Schedule a Discussion:** Suggest a brief meeting or include the topic in the next daily stand-up to gather input from the entire team and ensure everyone is aligned. 4. **Evaluate Feasibility:** Discuss with the team the feasibility of adding the new task (support for right-to-left languages) while considering the impact on the current sprint timeline and goals.
5. **Prioritize the Backlog:** If the team agrees on the importance of the new task, work with the Product Owner to re-prioritize the sprint backlog accordingly.
6. **Update the Sprint Plan:** If approved, modify the sprint plan to include the new task and communicate t...

You should discuss the request with your Scrum team and the product owner to evaluate the priority of the new authentication method versus the right-to-left language support, ensuring alignment with the overall project goals and customer needs.

| | Which of the following statements is correct? |

The correct statements are: 'When applying stochastic gradient descent on the objective function $f(\boldsymbol{w}):=\sum_{n=1}^{30}\left\|\boldsymbol{w}-\boldsymbol{x}_{n}\right\|^{2}$ where $\boldsymbol{x}_{n}$ are the datapoints, a stochastic gradient step is roughly $30 \times$ faster than a full gradient step.' and 'In practice, it could be good to let your model first overfit your task, and then apply drop-out or other regularization techniques.'

When applying stochastic gradient descent on the objective function \( f(\boldsymbol{w}) := \sum_{n=1}^{30} \|\boldsymbol{w} - \boldsymbol{x}_{n}\|^{2} \), a stochastic gradient step is not necessarily faster by a factor of 30; rather, it can be more efficient depending on implementation and data size. It can be beneficial to allow a model to overfit initially before applying regularization techniques like dropout to improve generalization.

| * Loss: [TripletLoss](https://sbert.net/docs/package_reference/sentence_transformer/losses.html#tripletloss) with these parameters: ```json { "distance_metric": "TripletDistanceMetric.EUCLIDEAN", "triplet_margin": 5 } ``` ### Training Hyperparameters #### Non-Default Hyperparameters - `num_train_epochs`: 2 - `multi_dataset_batch_sampler`: round_robin #### All Hyperparameters

Click to expand

- `overwrite_output_dir`: False - `do_predict`: False - `eval_strategy`: no - `prediction_loss_only`: True - `per_device_train_batch_size`: 8 - `per_device_eval_batch_size`: 8 - `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`: 2 - `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

### Framework Versions - Python: 3.11.11 - Sentence Transformers: 4.1.0 - Transformers: 4.48.3 - PyTorch: 2.7.0+cpu - Accelerate: 1.3.0 - Datasets: 3.6.0 - Tokenizers: 0.21.1 ## 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", } ``` #### TripletLoss ```bibtex @misc{hermans2017defense, title={In Defense of the Triplet Loss for Person Re-Identification}, author={Alexander Hermans and Lucas Beyer and Bastian Leibe}, year={2017}, eprint={1703.07737}, archivePrefix={arXiv}, primaryClass={cs.CV} } ```