|
|
--- |
|
|
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) <!-- at revision 57c266a740f537b4dc058e1b0cda161fd15afa75 --> |
|
|
- **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) |
|
|
<!-- - **Language:** Unknown --> |
|
|
<!-- - **License:** Unknown --> |
|
|
|
|
|
### 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]]) |
|
|
``` |
|
|
|
|
|
<!-- |
|
|
### Direct Usage (Transformers) |
|
|
|
|
|
<details><summary>Click to see the direct usage in Transformers</summary> |
|
|
|
|
|
</details> |
|
|
--> |
|
|
|
|
|
<!-- |
|
|
### Downstream Usage (Sentence Transformers) |
|
|
|
|
|
You can finetune this model on your own dataset. |
|
|
|
|
|
<details><summary>Click to expand</summary> |
|
|
|
|
|
</details> |
|
|
--> |
|
|
|
|
|
<!-- |
|
|
### Out-of-Scope Use |
|
|
|
|
|
*List how the model may foreseeably be misused and address what users ought not to do with the model.* |
|
|
--> |
|
|
|
|
|
## Evaluation |
|
|
|
|
|
### Metrics |
|
|
|
|
|
#### Triplet |
|
|
|
|
|
* Dataset: `base-eval` |
|
|
* Evaluated with [<code>TripletEvaluator</code>](https://sbert.net/docs/package_reference/sentence_transformer/evaluation.html#sentence_transformers.evaluation.TripletEvaluator) |
|
|
|
|
|
| Metric | Value | |
|
|
|:--------------------|:--------| |
|
|
| **cosine_accuracy** | **1.0** | |
|
|
|
|
|
<!-- |
|
|
## Bias, Risks and Limitations |
|
|
|
|
|
*What are the known or foreseeable issues stemming from this model? You could also flag here known failure cases or weaknesses of the model.* |
|
|
--> |
|
|
|
|
|
<!-- |
|
|
### Recommendations |
|
|
|
|
|
*What are recommendations with respect to the foreseeable issues? For example, filtering explicit content.* |
|
|
--> |
|
|
|
|
|
## 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: <code>anchor</code> and <code>positive</code> |
|
|
* Approximate statistics based on the first 1000 samples: |
|
|
| | anchor | positive | |
|
|
|:--------|:----------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------| |
|
|
| type | string | string | |
|
|
| details | <ul><li>min: 9 tokens</li><li>mean: 15.98 tokens</li><li>max: 50 tokens</li></ul> | <ul><li>min: 42 tokens</li><li>mean: 177.53 tokens</li><li>max: 810 tokens</li></ul> | |
|
|
* Samples: |
|
|
| anchor | positive | |
|
|
|:-------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| |
|
|
| <code>Provide an example of using AddRectangle.</code> | <code>import rhinoscriptsyntax as rs<br>plane = rs.WorldXYPlane()<br>plane = rs.RotatePlane(plane, 45.0, [0,0,1])<br>rs.AddRectangle(plane, 5.0, 15.0) <br><br>Metadata: <br>Name: AddRectangle<br>Category: curve<br>Function Signature: rs.AddRectangle(plane: plane, width: number, height: number) -> guid<br>Description: Add a rectangular curve to the document</code> | |
|
|
| <code>How do I search for the total number of linetypes in my document?</code> | <code><br><br>You can use the following method:<br>Name: LinetypeCount<br>Category: linetype<br>Function Signature: rs.LinetypeCount() -> int<br>Description: Description: Returns the number of linetypes in the document.<br>Parameters:<br> None<br>Returns:<br> int: The number of linetypes in the document.</code> | |
|
|
| <code>How do I maintain the shape of a curve while fitting it?</code> | <code><br><br>You can use the following method:<br>Name: FitCurve<br>Category: curve<br>Function Signature: rs.FitCurve(curve_id: guid, degree: int = 3, distance_tolerance: float = -1, angle_tolerance: float = -1) -> guid<br>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.<br>Parameters:<br> curve_id (guid): Identifier of the curve object to be fitted.<br> eg: '3D4F5A6B-7C8D-9E0F-1A2B-3C4D5E6F7A8B'<br> degree (int, optional): The degree of the curve, which must be greater than 1. The default is 3.<br> eg: 3<br> distance_tolerance (float, optional): The fitting tolerance. If not specified or <= 0.0, the document absolute tolerance is used.<br> eg: 0.01<br> 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 ...</code> | |
|
|
* Loss: [<code>MultipleNegativesRankingLoss</code>](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: <code>anchor</code>, <code>positive</code>, and <code>negative</code> |
|
|
* Approximate statistics based on the first 476 samples: |
|
|
| | anchor | positive | negative | |
|
|
|:--------|:-----------------------------------------------------------------------------------|:---------------------------------------------------------------------------------------|:-----------------------------------------------------------------------------------| |
|
|
| type | string | string | string | |
|
|
| details | <ul><li>min: 15 tokens</li><li>mean: 23.13 tokens</li><li>max: 38 tokens</li></ul> | <ul><li>min: 111 tokens</li><li>mean: 252.44 tokens</li><li>max: 1015 tokens</li></ul> | <ul><li>min: 32 tokens</li><li>mean: 42.48 tokens</li><li>max: 55 tokens</li></ul> | |
|
|
* Samples: |
|
|
| anchor | positive | negative | |
|
|
|:------------------------------------------------------------------------------------------|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| |
|
|
| <code>I need to flatten a curved surface for laser cutting. How can I do that?</code> | <code>You can use the following methods to complete the task.<br>method: UnrollSurface<br>description: Flattens a developable surface or polysurface<br>syntax: UnrollSurface(surface_id, explode=False, following_geometry=None, absolute_tolerance=None, relative_tolerance=None)<br>parameters: <br>surface_id (guid): the surface's identifier
<br>explode (bool, optional): If True, the resulting surfaces ar not joined
<br>following_geometry ({guid, ...]): List of curves, dots, and points which
<br> should be unrolled with the surface<br><br>returns: <br>list(guid, ...): of unrolled surface ids
<br>tuple((guid, ...),(guid, ...)): if following_geometry is not None, a tuple
<br> [1] is the list of unrolled surface ids
<br> [2] is the list of unrolled following geometry<br><br><br>Following is the code that uses this method to complete the task as per user query.<br><br>```python<br>import rhinoscriptsyntax as rs<br><br># Flatten a curved surface for laser cutting<br>surface = rs.GetObject("Select curved surface to flatten", rs.filter.surface)<br>if surface:<br> # Unrol...</code> | <code>You cannot use the following methods ConvertCurveToPolyline, MeshOutline, PullCurveToMesh, ExplodeText, MeshToNurb, IsCurvePlanar, Angle, AddFilletCurve, MeshVolume</code> | |
|
|
| <code>Can you show me how to rotate a plane by 30 degrees around its normal axis?</code> | <code>You can use the following methods to complete the task.<br>method: PlaneTransform<br>description: Transforms a plane.<br>syntax: PlaneTransform(plane, xform)<br>parameters: plane (plane): Plane to transform; xform (transform): Transformation to apply.<br>returns: plane: Resulting plane if successful, otherwise None.<br><br>Following is the code that uses this method to complete the task as per user query.<br><br>```python<br>import rhinoscriptsyntax as rs<br><br># Get the current construction plane<br>plane = rs.ViewCPlane()<br><br># Create a rotation transformation of 30 degrees around the normal axis (Z-axis)<br>xform = rs.XformRotation(30.0, plane.ZAxis, plane.Origin)<br><br># Apply the transformation to the plane<br>plane = rs.PlaneTransform(plane, xform)<br><br># Set the new construction plane<br>rs.ViewCPlane(None, plane)<br>```</code> | <code>You cannot use the following methods RotatePlane, XformRotation1, PlaneFromNormal, VectorRotate, Angle, PlaneFromFrame, LinePlane, MovePlane, CreatePlane</code> | |
|
|
| <code>I want to change the height of a text dot I just created. How can I do that?</code> | <code>You can use the following methods to complete the task.<br>method: TextDotHeight<br>description: Returns or modified the font height of a text dot<br>syntax: TextDotHeight(object_id, height=None)<br>parameters: <br>object_id (guid): identifier of a text dot object
<br>height (number, optional) new font height<br><br>returns: <br>number: If height is not specified, the current text dot height
<br>number: If height is specified, the previous text dot height
<br>None: on error<br><br><br>Following is the code that uses this method to complete the task as per user query.<br><br>```python<br>import rhinoscriptsyntax as rs<br># Change the height of a text dot<br>obj = rs.GetObject("Select text dot")<br>if rs.IsTextDot(obj):<br> previous_height = rs.TextDotHeight(obj, 15.0) # Set new height to 15.0<br> print(f"Previous height was: {previous_height}")<br>```</code> | <code>You cannot use the following methods TextDotPoint, TextDotFont, TextDotText, TextObjectHeight, IsTextDot, AddTextDot, TextObjectFont, PointCoordinates, ExplodeText</code> | |
|
|
* Loss: [<code>MultipleNegativesRankingLoss</code>](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 |
|
|
<details><summary>Click to expand</summary> |
|
|
|
|
|
- `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`: {} |
|
|
|
|
|
</details> |
|
|
|
|
|
### Training Logs |
|
|
| Epoch | Step | Training Loss | Validation Loss | base-eval_cosine_accuracy | |
|
|
|:------:|:----:|:-------------:|:---------------:|:-------------------------:| |
|
|
| -1 | -1 | - | - | 0.0147 | |
|
|
| 0.1028 | 100 | 0.1601 | - | - | |
|
|
| 0.2055 | 200 | 0.0474 | 0.2296 | 0.8971 | |
|
|
| 0.3083 | 300 | 0.0749 | - | - | |
|
|
| 0.4111 | 400 | 0.1037 | 0.1457 | 0.9265 | |
|
|
| 0.5139 | 500 | 0.0564 | - | - | |
|
|
| 0.6166 | 600 | 0.0706 | 0.3362 | 0.9475 | |
|
|
| 0.7194 | 700 | 0.0549 | - | - | |
|
|
| 0.8222 | 800 | 0.0427 | 0.2154 | 0.9538 | |
|
|
| 0.9250 | 900 | 0.0599 | - | - | |
|
|
| 1.0277 | 1000 | 0.0656 | 0.2439 | 0.9706 | |
|
|
| 1.1305 | 1100 | 0.0409 | - | - | |
|
|
| 1.2333 | 1200 | 0.0283 | 0.2422 | 0.9727 | |
|
|
| 1.3361 | 1300 | 0.0336 | - | - | |
|
|
| 1.4388 | 1400 | 0.0338 | 0.2397 | 0.9664 | |
|
|
| 1.5416 | 1500 | 0.0384 | - | - | |
|
|
| 1.6444 | 1600 | 0.0271 | 0.1048 | 0.9832 | |
|
|
| 1.7472 | 1700 | 0.0305 | - | - | |
|
|
| 1.8499 | 1800 | 0.024 | 0.1172 | 0.9916 | |
|
|
| 1.9527 | 1900 | 0.014 | - | - | |
|
|
| 2.0555 | 2000 | 0.018 | 0.0898 | 0.9958 | |
|
|
| 2.1583 | 2100 | 0.0091 | - | - | |
|
|
| 2.2610 | 2200 | 0.0154 | 0.0721 | 0.9916 | |
|
|
| 2.3638 | 2300 | 0.0123 | - | - | |
|
|
| 2.4666 | 2400 | 0.0119 | 0.0876 | 0.9937 | |
|
|
| 2.5694 | 2500 | 0.0173 | - | - | |
|
|
| 2.6721 | 2600 | 0.0091 | 0.0482 | 1.0 | |
|
|
| 2.7749 | 2700 | 0.0211 | - | - | |
|
|
| 2.8777 | 2800 | 0.0146 | 0.0550 | 1.0 | |
|
|
| 2.9805 | 2900 | 0.0101 | - | - | |
|
|
| -1 | -1 | - | - | 1.0 | |
|
|
|
|
|
|
|
|
### Framework Versions |
|
|
- Python: 3.12.11 |
|
|
- Sentence Transformers: 5.1.0 |
|
|
- Transformers: 4.56.1 |
|
|
- PyTorch: 2.8.0+cu126 |
|
|
- Accelerate: 1.10.1 |
|
|
- Datasets: 4.0.0 |
|
|
- Tokenizers: 0.22.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", |
|
|
} |
|
|
``` |
|
|
|
|
|
#### 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} |
|
|
} |
|
|
``` |
|
|
|
|
|
<!-- |
|
|
## Glossary |
|
|
|
|
|
*Clearly define terms in order to be accessible across audiences.* |
|
|
--> |
|
|
|
|
|
<!-- |
|
|
## Model Card Authors |
|
|
|
|
|
*Lists the people who create the model card, providing recognition and accountability for the detailed work that goes into its construction.* |
|
|
--> |
|
|
|
|
|
<!-- |
|
|
## Model Card Contact |
|
|
|
|
|
*Provides a way for people who have updates to the Model Card, suggestions, or questions, to contact the Model Card authors.* |
|
|
--> |
