---
tags:
- sentence-transformers
- sentence-similarity
- feature-extraction
- dense
- generated_from_trainer
- dataset_size:15565
- loss:MultipleNegativesRankingLoss
base_model: google/embeddinggemma-300m
widget:
- source_sentence: I need to lock an object in my model so I can work on other parts
without accidentally selecting it. How can I do that?
sentences:
- You cannot use the following methods IsObjectLocked, LockObjects, UnlockObject,
SelectObject, SelectObjects, UnlockObjects, IsObjectSelectable, ShowObject, IsObjectNormal
- object
- "You can use the following methods to complete the task.\nmethod: LockObject\n\
description: Locks a single object. Locked objects are visible, and they can be\r\
\n snapped to. But, they cannot be selected.\nsyntax: LockObject(object_id)\n\
parameters: object_id (guid): The identifier of an object\nreturns: bool: True\
\ or False indicating success or failure\n\nFollowing is the code that uses this\
\ method to complete the task as per user query.\n\n```python\nimport rhinoscriptsyntax\
\ as rs\n\n# Lock an object in the model to prevent accidental selection\nid =\
\ rs.GetObject(\"Select object to lock\")\nif id:\n rs.LockObject(id)\n \
\ print(\"Object locked successfully.\")\nelse:\n print(\"No object selected.\"\
)\n```"
- source_sentence: I want to create a cloud of points in my Rhino model. Can you show
me how to do that?
sentences:
- "You can use the following methods to complete the task.\nmethod: AddPointCloud\n\
description: Adds point cloud object to the document\nsyntax: AddPointCloud(points,\
\ colors=None)\nparameters: \npoints ([point, ....]): list of values where every\
\ multiple of three represents a point\r\ncolors ([color, ...]): list of colors\
\ to apply to each point\n\nreturns: \nguid: identifier of point cloud on success\n\
\n\nFollowing is the code that uses this method to complete the task as per user\
\ query.\n\n```python\nimport rhinoscriptsyntax as rs\n\n# Create a cloud of points\
\ in Rhino\npoints = [(0, 0, 0), (1, 1, 1), (2, 2, 2), (3, 3, 3)] # Define points\n\
rs.AddPointCloud(points) # Add the point cloud to the model\n```"
- geometry
- You cannot use the following methods PointCloudPoints, AddPoints, CreatePoint,
PointCloudCount, AddPoint, AddLine, PointCloudHidePoints, CreateVector, PointCoordinates
- source_sentence: I need to find out which vertices make up each face of my mesh.
Can you help me with that?
sentences:
- "You can use the following methods to complete the task.\nmethod: MeshFaces\n\
description: Returns face vertices of a mesh\nsyntax: MeshFaces(object_id, face_type=True)\n\
parameters: object_id (guid): identifier of a mesh object\nface_type (bool, optional):\
\ The face type to be returned. True = both triangles and quads. False = only\
\ triangles\nreturns: list([point, point, point, point], ...): 3D points that\
\ define the face vertices of the mesh. If face_type is True, then faces are returned\
\ as both quads and triangles (4 3D points). For triangles, the third and fourth\
\ vertex will be identical. If face_type is False, then faces are returned as\
\ only triangles(3 3D points). Quads will be converted to triangles.\n\nFollowing\
\ is the code that uses this method to complete the task as per user query.\n\n\
```python\nimport rhinoscriptsyntax as rs\n# Get the mesh object from the user\n\
obj = rs.GetObject(\"Select mesh\", rs.filter.mesh)\n# Retrieve the vertex indices\
\ for each face of the mesh\nfaces = rs.MeshFaces(obj, True)\nif faces:\n rs.EnableRedraw(False)\n\
\ i = 0\n while i < len(faces):\n # Each face can be a triangle or\
\ a quad\n face = faces[i:i+4] if len(faces) > i + 3 else faces[i:i+3]\n\
\ print(\"Face vertices:\", face)\n i += 3 if len(face) == 3 else\
\ 4\n rs.EnableRedraw(True)\n```"
- You cannot use the following methods MeshVertexFaces, MeshFaceVertices, MeshVertices,
MeshVertexCount, MeshFaceCenters, MeshTriangleCount, MeshQuadCount, MeshFaceCount,
MeshNakedEdgePoints
- mesh
- source_sentence: Can you show me how to check if two transformation matrices are
the same in Rhino?
sentences:
- "You can use the following methods to complete the task.\nmethod: XformChangeBasis2\n\
description: Returns a change of basis transformation matrix of None on error\n\
syntax: XformChangeBasis2(x0,y0,z0,x1,y1,z1)\nparameters: \nx0,y0,z0 (vector):\
\ initial basis\r\nx1,y1,z1 (vector): final basis\n\nreturns: \ntransform: The\
\ 4x4 transformation matrix if successful\r\nNone: if not successful\n\n\nFollowing\
\ is the code that uses this method to complete the task as per user query.\n\n\
```python\nimport rhinoscriptsyntax as rs\n\n# Function to check if two transformation\
\ matrices are the same\n# Parameters: mat1, mat2 - transformation matrices to\
\ compare\n# Returns: True if they are the same, False otherwise\ndef are_matrices_equal(mat1,\
\ mat2):\n return rs.XformCompare(mat1, mat2) == 0\n\n# Example usage\nmatrix1\
\ = rs.XformChangeBasis2(1, 0, 0, 0, 1, 0)\nmatrix2 = rs.XformChangeBasis2(1,\
\ 0, 0, 0, 1, 0)\nresult = are_matrices_equal(matrix1, matrix2)\nprint(\"Matrices\
\ are equal:\" , result)\n```"
- You cannot use the following methods XformCompare, IsXformSimilarity, IsXformIdentity,
IsXformZero, CompareGeometry, CreateXform, VectorTransform, XformTranslation,
TransformObject, XformDeterminant
- transformation
- source_sentence: I need to find where a flat surface meets a sphere. How can I do
that in Rhino?
sentences:
- plane
- You cannot use the following methods LineSphereIntersection, IsSphere, AddSphere,
LinePlaneIntersection, Angle, CircleCenterPoint, CurveCurveIntersection, CurveSurfaceIntersection,
AddCircle3Pt
- "You can use the following methods to complete the task.\nmethod: PlaneSphereIntersection\n\
description: Calculates the intersection of a plane and a sphere.\nsyntax: PlaneSphereIntersection(plane,\
\ sphere_plane, sphere_radius)\nparameters: plane (plane): The plane to intersect;\
\ sphere_plane (plane): Equatorial plane of the sphere (origin is center); sphere_radius\
\ (float): Radius of the sphere.\nreturns: list: [type, point/plane, radius] where\
\ type=0 for point, 1 for circle. None on error.\n\nFollowing is the code that\
\ uses this method to complete the task as per user query.\n\n```python\nimport\
\ rhinoscriptsyntax as rs\n\n# Define a flat surface as a plane\nplane = rs.WorldXYPlane()\n\
# Define the radius of the sphere\nradius = 10\n# Calculate the intersection between\
\ the plane and the sphere\nresults = rs.PlaneSphereIntersection(plane, plane,\
\ radius)\n\n# Check if there are results and handle them accordingly\nif results:\n\
\ if results[0] == 0:\n # If the intersection is a point, add it to\
\ the document\n rs.AddPoint(results[1])\n else:\n # If the intersection\
\ is a circle, add it to the document\n rs.AddCircle(results[1], results[2])\n\
```"
datasets:
- deebak14/embedding_tuple_data_v1
- deebak14/embedding_triplet_data_v1
pipeline_tag: sentence-similarity
library_name: sentence-transformers
metrics:
- cosine_accuracy
model-index:
- name: SentenceTransformer based on google/embeddinggemma-300m
results:
- task:
type: triplet
name: Triplet
dataset:
name: base eval
type: base-eval
metrics:
- type: cosine_accuracy
value: 1.0
name: Cosine Accuracy
---
# SentenceTransformer based on google/embeddinggemma-300m
This is a [sentence-transformers](https://www.SBERT.net) model finetuned from [google/embeddinggemma-300m](https://huggingface.co/google/embeddinggemma-300m) on the [embedding_tuple_data_v1](https://huggingface.co/datasets/deebak14/embedding_tuple_data_v1) dataset. 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:** [google/embeddinggemma-300m](https://huggingface.co/google/embeddinggemma-300m)
- **Maximum Sequence Length:** 2048 tokens
- **Output Dimensionality:** 768 dimensions
- **Similarity Function:** Cosine Similarity
- **Training Dataset:**
- [embedding_tuple_data_v1](https://huggingface.co/datasets/deebak14/embedding_tuple_data_v1)
### 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': 2048, 'do_lower_case': False, 'architecture': 'Gemma3TextModel'})
(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})
(2): Dense({'in_features': 768, 'out_features': 3072, 'bias': False, 'activation_function': 'torch.nn.modules.linear.Identity'})
(3): Dense({'in_features': 3072, 'out_features': 768, 'bias': False, 'activation_function': 'torch.nn.modules.linear.Identity'})
(4): 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("deebak14/embedding_gemma_ft_v1")
# Run inference
queries = [
"I need to find where a flat surface meets a sphere. How can I do that in Rhino?",
]
documents = [
'You can use the following methods to complete the task.\nmethod: PlaneSphereIntersection\ndescription: Calculates the intersection of a plane and a sphere.\nsyntax: PlaneSphereIntersection(plane, sphere_plane, sphere_radius)\nparameters: plane (plane): The plane to intersect; sphere_plane (plane): Equatorial plane of the sphere (origin is center); sphere_radius (float): Radius of the sphere.\nreturns: list: [type, point/plane, radius] where type=0 for point, 1 for circle. None on error.\n\nFollowing is the code that uses this method to complete the task as per user query.\n\n```python\nimport rhinoscriptsyntax as rs\n\n# Define a flat surface as a plane\nplane = rs.WorldXYPlane()\n# Define the radius of the sphere\nradius = 10\n# Calculate the intersection between the plane and the sphere\nresults = rs.PlaneSphereIntersection(plane, plane, radius)\n\n# Check if there are results and handle them accordingly\nif results:\n if results[0] == 0:\n # If the intersection is a point, add it to the document\n rs.AddPoint(results[1])\n else:\n # If the intersection is a circle, add it to the document\n rs.AddCircle(results[1], results[2])\n```',
'You cannot use the following methods LineSphereIntersection, IsSphere, AddSphere, LinePlaneIntersection, Angle, CircleCenterPoint, CurveCurveIntersection, CurveSurfaceIntersection, AddCircle3Pt',
'plane',
]
query_embeddings = model.encode_query(queries)
document_embeddings = model.encode_document(documents)
print(query_embeddings.shape, document_embeddings.shape)
# [1, 768] [3, 768]
# Get the similarity scores for the embeddings
similarities = model.similarity(query_embeddings, document_embeddings)
print(similarities)
# tensor([[ 0.6658, 0.4819, -0.1617]])
```
## Evaluation
### Metrics
#### Triplet
* Dataset: `base-eval`
* Evaluated with [TripletEvaluator](https://sbert.net/docs/package_reference/sentence_transformer/evaluation.html#sentence_transformers.evaluation.TripletEvaluator)
| Metric | Value |
|:--------------------|:--------|
| **cosine_accuracy** | **1.0** |
## Training Details
### Training Dataset
#### embedding_tuple_data_v1
* Dataset: [embedding_tuple_data_v1](https://huggingface.co/datasets/deebak14/embedding_tuple_data_v1) at [b592a1a](https://huggingface.co/datasets/deebak14/embedding_tuple_data_v1/tree/b592a1af60cff995640f6979dbf36c01d38c40a8)
* Size: 15,565 training samples
* Columns: anchor and positive
* Approximate statistics based on the first 1000 samples:
| | anchor | positive |
|:--------|:----------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|
| type | string | string |
| details | - min: 9 tokens
- mean: 15.98 tokens
- max: 50 tokens
| - min: 42 tokens
- mean: 177.53 tokens
- max: 810 tokens
|
* Samples:
| anchor | positive |
|:-------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Provide an example of using AddRectangle. | import rhinoscriptsyntax as rs
plane = rs.WorldXYPlane()
plane = rs.RotatePlane(plane, 45.0, [0,0,1])
rs.AddRectangle(plane, 5.0, 15.0)
Metadata:
Name: AddRectangle
Category: curve
Function Signature: rs.AddRectangle(plane: plane, width: number, height: number) -> guid
Description: Add a rectangular curve to the document |
| How do I search for the total number of linetypes in my document? |
You can use the following method:
Name: LinetypeCount
Category: linetype
Function Signature: rs.LinetypeCount() -> int
Description: Description: Returns the number of linetypes in the document.
Parameters:
None
Returns:
int: The number of linetypes in the document.How do I maintain the shape of a curve while fitting it? |
You can use the following method:
Name: FitCurve
Category: curve
Function Signature: rs.FitCurve(curve_id: guid, degree: int = 3, distance_tolerance: float = -1, angle_tolerance: float = -1) -> guid
Description: Description: Reduces the number of control points of a curve while maintaining its general shape. This function is useful for replacing curves with many control points. For more information, see the Rhino help for the FitCrv command.
Parameters:
curve_id (guid): Identifier of the curve object to be fitted.
eg: '3D4F5A6B-7C8D-9E0F-1A2B-3C4D5E6F7A8B'
degree (int, optional): The degree of the curve, which must be greater than 1. The default is 3.
eg: 3
distance_tolerance (float, optional): The fitting tolerance. If not specified or <= 0.0, the document absolute tolerance is used.
eg: 0.01
angle_tolerance (float, optional): The kink smoothing tolerance in degrees. If 0.0, all kinks are smoothed. If > 0.0, kinks smaller than this value are smoothed. If ...MultipleNegativesRankingLoss](https://sbert.net/docs/package_reference/sentence_transformer/losses.html#multiplenegativesrankingloss) with these parameters:
```json
{
"scale": 20.0,
"similarity_fct": "cos_sim",
"gather_across_devices": false
}
```
### Evaluation Dataset
#### embedding_triplet_data_v1
* Dataset: [embedding_triplet_data_v1](https://huggingface.co/datasets/deebak14/embedding_triplet_data_v1) at [71ea1de](https://huggingface.co/datasets/deebak14/embedding_triplet_data_v1/tree/71ea1de1dd869a91bfa545c4f65e1d1d5ac41186)
* Size: 476 evaluation samples
* Columns: anchor, positive, and negative
* Approximate statistics based on the first 476 samples:
| | anchor | positive | negative |
|:--------|:-----------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------|
| type | string | string | string |
| details | - min: 15 tokens
- mean: 23.13 tokens
- max: 38 tokens
| - min: 111 tokens
- mean: 252.44 tokens
- max: 1015 tokens
| - min: 32 tokens
- mean: 42.48 tokens
- max: 55 tokens
|
* Samples:
| anchor | positive | negative |
|:------------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| I need to flatten a curved surface for laser cutting. How can I do that? | You can use the following methods to complete the task.
method: UnrollSurface
description: Flattens a developable surface or polysurface
syntax: UnrollSurface(surface_id, explode=False, following_geometry=None, absolute_tolerance=None, relative_tolerance=None)
parameters:
surface_id (guid): the surface's identifier
explode (bool, optional): If True, the resulting surfaces ar not joined
following_geometry ({guid, ...]): List of curves, dots, and points which
should be unrolled with the surface
returns:
list(guid, ...): of unrolled surface ids
tuple((guid, ...),(guid, ...)): if following_geometry is not None, a tuple
[1] is the list of unrolled surface ids
[2] is the list of unrolled following geometry
Following is the code that uses this method to complete the task as per user query.
```python
import rhinoscriptsyntax as rs
# Flatten a curved surface for laser cutting
surface = rs.GetObject("Select curved surface to flatten", rs.filter.surface)
if surface:
# Unrol... | You cannot use the following methods ConvertCurveToPolyline, MeshOutline, PullCurveToMesh, ExplodeText, MeshToNurb, IsCurvePlanar, Angle, AddFilletCurve, MeshVolume |
| Can you show me how to rotate a plane by 30 degrees around its normal axis? | You can use the following methods to complete the task.
method: PlaneTransform
description: Transforms a plane.
syntax: PlaneTransform(plane, xform)
parameters: plane (plane): Plane to transform; xform (transform): Transformation to apply.
returns: plane: Resulting plane if successful, otherwise None.
Following is the code that uses this method to complete the task as per user query.
```python
import rhinoscriptsyntax as rs
# Get the current construction plane
plane = rs.ViewCPlane()
# Create a rotation transformation of 30 degrees around the normal axis (Z-axis)
xform = rs.XformRotation(30.0, plane.ZAxis, plane.Origin)
# Apply the transformation to the plane
plane = rs.PlaneTransform(plane, xform)
# Set the new construction plane
rs.ViewCPlane(None, plane)
``` | You cannot use the following methods RotatePlane, XformRotation1, PlaneFromNormal, VectorRotate, Angle, PlaneFromFrame, LinePlane, MovePlane, CreatePlane |
| I want to change the height of a text dot I just created. How can I do that? | You can use the following methods to complete the task.
method: TextDotHeight
description: Returns or modified the font height of a text dot
syntax: TextDotHeight(object_id, height=None)
parameters:
object_id (guid): identifier of a text dot object
height (number, optional) new font height
returns:
number: If height is not specified, the current text dot height
number: If height is specified, the previous text dot height
None: on error
Following is the code that uses this method to complete the task as per user query.
```python
import rhinoscriptsyntax as rs
# Change the height of a text dot
obj = rs.GetObject("Select text dot")
if rs.IsTextDot(obj):
previous_height = rs.TextDotHeight(obj, 15.0) # Set new height to 15.0
print(f"Previous height was: {previous_height}")
``` | You cannot use the following methods TextDotPoint, TextDotFont, TextDotText, TextObjectHeight, IsTextDot, AddTextDot, TextObjectFont, PointCoordinates, ExplodeText |
* Loss: [MultipleNegativesRankingLoss](https://sbert.net/docs/package_reference/sentence_transformer/losses.html#multiplenegativesrankingloss) with these parameters:
```json
{
"scale": 20.0,
"similarity_fct": "cos_sim",
"gather_across_devices": false
}
```
### Training Hyperparameters
#### Non-Default Hyperparameters
- `eval_strategy`: steps
- `per_device_train_batch_size`: 16
- `per_device_eval_batch_size`: 16
- `learning_rate`: 2e-05
- `warmup_ratio`: 0.1
- `bf16`: True
- `prompts`: task: sentence similarity | query:
- `batch_sampler`: no_duplicates
#### All Hyperparameters
Click to expand
- `overwrite_output_dir`: False
- `do_predict`: False
- `eval_strategy`: steps
- `prediction_loss_only`: True
- `per_device_train_batch_size`: 16
- `per_device_eval_batch_size`: 16
- `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`: 2e-05
- `weight_decay`: 0.0
- `adam_beta1`: 0.9
- `adam_beta2`: 0.999
- `adam_epsilon`: 1e-08
- `max_grad_norm`: 1.0
- `num_train_epochs`: 3
- `max_steps`: -1
- `lr_scheduler_type`: linear
- `lr_scheduler_kwargs`: {}
- `warmup_ratio`: 0.1
- `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`: True
- `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}
- `parallelism_config`: None
- `deepspeed`: None
- `label_smoothing_factor`: 0.0
- `optim`: adamw_torch_fused
- `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
- `hub_revision`: None
- `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
- `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
- `liger_kernel_config`: None
- `eval_use_gather_object`: False
- `average_tokens_across_devices`: False
- `prompts`: task: sentence similarity | query:
- `batch_sampler`: no_duplicates
- `multi_dataset_batch_sampler`: proportional
- `router_mapping`: {}
- `learning_rate_mapping`: {}