Instructions to use Athekunal/Qwen3-0.6B-Agent-Skills-Retriever with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use Athekunal/Qwen3-0.6B-Agent-Skills-Retriever with sentence-transformers:

from sentence_transformers import SentenceTransformer

model = SentenceTransformer("Athekunal/Qwen3-0.6B-Agent-Skills-Retriever")

sentences = [
    "How do I extract invoice totals from a PDF invoice layout?",
    "The PDF Extraction Skill is designed for extracting text, tables, and metadata from PDF files via the pdfplumber library, which provides granular access to PDF elements, unlike conventional PDF readers. The workflow begins with the user supplying a PDF document and indicating the desired type of content to extract, which can include text, tables, images, or metadata. The skill will then generate and execute the appropriate pdfplumber code based on user requests. For example prompts include tasks like extracting tables from financial reports or specific text from document pages.\n\nThe fundamental structure of a PDF involves metadata (like title and author), pages containing various elements (characters, words, lines, shapes, and images), and an outline for navigation. Key functionalities include basic text extraction, advanced text extraction options including layout preservation, and character-level access for detailed manipulation of characters within the PDF.\n\nTable extraction can be performed with both basic settings and advanced customization options to improve accuracy based on the PDF’s layout. Moreover, the skill features visual debugging tools to help users understand the structural layout of a PDF by marking element boundaries, enhancing the extraction process. Cropping to specific areas, filtering content based on position or font, and accessing document metadata are also supported. \n\nBest practices for using the skill include visually debugging with generated images to gain insight into PDF structures, fine-tuning table settings based on document specifics, avoiding processing large PDFs all at once, and ensuring the presence of text as some PDFs might only contain images. Common examples provided include how to extract tables into dataframes using pandas, structured data from invoices, and parsing sections from resumes. \n\nThe skill cannot extract from scanned PDFs and requires OCR for such cases, while it also has limitations like handling encrypted PDFs and potentially facing challenges with complex layouts or embedded fonts. The installation instructions are straightforward using pip to install pdfplumber and Pillow for additional image functionalities.",
    "The Mistral OCR PDF extraction skill provides a streamlined process for Optical Character Recognition (OCR) of PDF documents, allowing users to generate Markdown and JSON outputs for further analysis or processing. The skill operates primarily through a provided script, `mistral_ocr_extract.py`, which can handle both local PDF files and PDFs available via public URLs. The workflow begins with selecting the input mode based on the document's accessibility: either uploading a local file through a Files API for processing or directly using a public URL.  The default options for output fidelity are designed to ensure compatibility with typical applications such as Retrieval-Augmented Generation (RAG), including inline table formatting unless specified otherwise. Users can opt to extract images, headers, or footers based on their document's content and the resulting OCR quality needs. Upon execution of the script, it produces a well-organized output directory that contains concatenated Markdown files for all pages, individual page Markdown files, a JSON file of the full OCR response, and directories for any embedded images and extracted tables that were requested. The script can also handle structured data extraction using specified annotation prompts to retrieve fields from the document, such as supplier names or invoice totals, which enhances the value of the output data. However, guidelines are provided for handling common failure modes, such as ensuring the MISTRAL_API_KEY is set, addressing URL accessibility issues, and managing problems with large file uploads. Furthermore, it includes reference materials for API parameters, output mapping rules, and example prompts to assist users in optimizing their document processing tasks. There are important decision rules and operational caveats highlighted to instruct users on preferred practices for managing local versus remote files and to ensure output quality, especially when parsing extracted tables.",
    "The **Dropbox Business** Skill enables developers to interact with the Dropbox Business API utilizing managed OAuth authentication. This skill allows effective management of team administration, which encompasses tasks involving members, groups, team folders, devices, linked applications, and audit logs. The API utilizes a unified base URL with specific endpoints designated for various functions, encapsulated through methods mainly employing `POST` requests, even for read operations, and requiring JSON-formatted bodies where applicable. To begin using the API, developers must obtain an API key from Maton, setting it as an environment variable (MATON_API_KEY) for authorization in requests. The skill includes comprehensive examples in Python, showcasing how to retrieve team information, manage connections, list and manipulate team members, groups, folders, namespaces, devices, applications, and access audit logs, ensuring significant coverage of business needs.\n\n### Quick Start\nThe skill outlines a quick start guide with bash command scripts that demonstrate how to get team information by making `POST` requests to specific endpoints with proper authorization headers. For instance, to get team info, a simple script is provided that imports necessary libraries, builds a request with the appropriate headers, and prints the JSON response neatly formatted.\n\n### Authentication and API Key Management\nAll API requests require OAuth authentication, leveraging the provided API key concatenated into the Authorization header. Developers must ensure that the environment variable is appropriately set before making any requests.\n\n### Connection Management\nDevelopers can manage their connections through a designated endpoint, allowing listing, creating, and deleting connections to the Dropbox Business API. Each operation returns specific data, such as connection IDs and URLs for completion of OAuth authorization.\n\n### API Reference\nThe documentation comprehensively details various API endpoints such as:\n- **Team Information** (e.g., get_team_info, get_team_features)\n- **Team Members** (e.g., list_membes, add_member, remove_member)\n- **Groups and Team Folders** (e.g., manage groups, create, rename folders)\n- **Devices** (manage member devices and their sessions)\n- **Linked Apps** (list and revoke applications)\n- **Audit Logs** (retrieve historical event data for team account activity)\nEach API method is displayed with its specific request format, sample JSON requests for input, and expected JSON responses detailing success or failure indications.\n\n### Pagination and Error Handling\nThe documentation incorporates guidance on handling pagination with cursor values provided in responses for list-type methods. The skill also outlines structured error handling, providing a table that explains different HTTP status codes and proper responses for common errors encountered during API interactions, along with a standardized error response format. \n\n### Operational Caveats and Limitations\nDevelopers should take heed of certain caveats such as mandatory `POST` operations on almost all endpoints, the requirement of sending `null` in cases of no parameters, specificity in using `.tag` to identify members, and recognizing that some groups are system-managed and cannot be modified. The guide also emphasizes using 'V2' versions of endpoints for enriched data responses.  To support optimal usage, an associated resource list is provided, linking to external documentation and community support for further assistance."
]
embeddings = model.encode(sentences)

similarities = model.similarity(embeddings, embeddings)
print(similarities.shape)
# [4, 4]

Notebooks
Google Colab
Kaggle

SentenceTransformer based on Qwen/Qwen3-Embedding-0.6B

This is a sentence-transformers model finetuned from Qwen/Qwen3-Embedding-0.6B. It maps sentences & paragraphs to a 1024-dimensional dense vector space and can be used for retrieval.

Model Details

Model Description

Model Type: Sentence Transformer
Base model: Qwen/Qwen3-Embedding-0.6B
Maximum Sequence Length: 32768 tokens
Output Dimensionality: 1024 dimensions
Similarity Function: Cosine Similarity
Supported Modality: Text

Model Sources

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

Full Model Architecture

SentenceTransformer(
  (0): Transformer({'transformer_task': 'feature-extraction', 'modality_config': {'text': {'method': 'forward', 'method_output_name': 'last_hidden_state'}}, 'module_output_name': 'token_embeddings', 'architecture': 'Qwen3Model'})
  (1): Pooling({'embedding_dimension': 1024, 'pooling_mode': 'lasttoken', 'include_prompt': True})
  (2): Normalize({})
)

Usage

Direct Usage (Sentence Transformers)

First install the Sentence Transformers library:

pip install -U sentence-transformers

Then you can load this model and run inference.

from sentence_transformers import SentenceTransformer

# Download from the 🤗 Hub
model = SentenceTransformer("sentence_transformers_model_id")
# Run inference
queries = [
    'What are the steps to connect to the OCR Web Service using Membrane CLI?',
]
documents = [
    'The OCR Web Service is designed to transform images containing text into machine-readable text formats, facilitating automation in data entry and document processing for developers and businesses. Utilizing the OCR Web Service enables various applications such as extraction of text from scanned documents and images in formats like PDFs. The service operates using the Membrane CLI, which abstracts the complexities of authentication and credential management, enabling developers to focus on integration rather than authorization setups. \n\n### Installation and Setup\n\nTo start using the OCR Web Service, developers must first install the Membrane CLI:\n- **Command:** `npm install -g @membranehq/cli`  \nThis command installs the CLI globally, allowing the user to invoke it from any terminal session. \n\nAfter installation, the first-time setup of the CLI requires the user to log in by executing:\n- **Command:** `membrane login --tenant`  \nThis command will launch a browser for authentication. In headless environments, the user can copy a printed URL to perform the login and complete it with a command including a code provided post-authentication.\n\n### Connecting to the OCR Web Service\n\nTo connect to the OCR Web Service, developers can create a new connection by:\n1. Searching for the OCR Web Service connector with:\n   - **Command:** `membrane search ocr-web-service --elementType=connector --json`  \n   The response will contain details including the connector ID.\n2. Establishing a connection as follows:\n   - **Command:** `membrane connect --connectorId=CONNECTOR_ID --json`  \n   This command will require the user to authenticate via a browser, with the output providing a new connection ID. \n\n### Managing Connections\n\nTo verify existing connections:\n- **Command:** `membrane connection list --json`  \nThis will list all active connections and help identify if a previous OCR connection is established.\n\n### Searching and Running Actions\n\nFor querying available actions, users can execute:\n- **Command:** `membrane action list --intent=QUERY --connectionId=CONNECTION_ID --json`  \nThis command returns action objects containing IDs and input schemas necessary for executing tasks.\n\nTo run a specific action, the command is:\n- **Command:** `membrane action run --connectionId=CONNECTION_ID ACTION_ID --json`  \nParameters can be passed in JSON format using:\n- **Command:** `membrane action run --connectionId=CONNECTION_ID ACTION_ID --json --input "{ \\"key\\": \\"value\\" }"`\n\n### Proxying Requests\n\nIf pre-defined actions do not meet user needs, direct requests can be made to the OCR Web Service API via Membrane’s proxy:\n- **Command:** `membrane request CONNECTION_ID /path/to/endpoint`\nA range of options can be specified to modify the request, including HTTP method, headers, data payloads, and parameters via options flags.\n\n### Best Practices\n\nThe documentation emphasizes several best practices:\n- Rely on Membrane for interactions with external applications to leverage its built-in error handling, security, and token management features.\n- Explore available actions before attempting to create new API calls to save development time and prevent common mistakes.\n- Avoid asking users for API keys or credentials by managing authentication through Membrane directly.\n\nOverall, the OCR Web Service provides an encapsulated environment for efficiently handling image text extraction with robust support for ease of integration and security handling.',
    'The 2Captcha skill provides developers and businesses with a practical means of bypassing CAPTCHA challenges on various web and application platforms using a service that outsources the solving of these CAPTCHAs to human workers. The skill operates through Membrane CLI, which facilitates interaction with the 2Captcha service while automating authentication, credential refresh, and HTTP header management to simplify integration. The main features include support for different types of CAPTCHAs (Image, ReCaptchaV2, ReCaptchaV3, GeeTest, HCaptcha, Turnstile, MtCaptcha, KeyCaptcha, Text), making it versatile for varied use cases.\n\n### Workflow Steps and Control Flow\n1. **CLI Installation:** Users start by installing the Membrane CLI, which is required to run commands that interact with 2Captcha. This is done using `npm install -g @membranehq/cli`.\n2. **Authentication Setup:** First-time users authenticate through a browser using the command `membrane login --tenant`. In headless environments, a unique URL is provided for manual completion.\n3. **Creating a 2Captcha Connection:** Users create a connection to the 2Captcha service using a specific connector ID, retrieved from a search command. The command `membrane connect --connectorId=CONNECTOR_ID --json` initiates this connection process.\n4. **Managing Connections:** To check existing connections, the command `membrane connection list --json` is used which lists all established connections. Users can note the `connectionId` for further actions.\n5. **Searching Actions:** To discover available actions based on intent, users can run `membrane action list --intent=QUERY --connectionId=CONNECTION_ID --json`, which returns a list of action objects with their IDs and schemas.\n6. **Running Actions:** Actions are executed using the command `membrane action run --connectionId=CONNECTION_ID ACTION_ID --json`, during which JSON parameters can be passed for specific configurations.\n7. **Proxy Requests:** When built-in actions do not suffice, developers can directly interact with the 2Captcha API using `membrane request CONNECTION_ID /path/to/endpoint`, along with various flags for HTTP methods, headers, and body data.\n\n### Required Tools and Environment Assumptions\n- Node.js environment (for the installation of Membrane CLI).\n- Access to a web browser for initial authentication, unless operating in a headless environment where manual interaction is feasible.\n\n### Command-Line Usage and Argument Behavior\n- **CLI Commands:** Predominantly utilize `membrane` commands in the terminal.\n- **Arguments:** Various commands accept flags and JSON input. For example, `--json` denotes that input will be in JSON format, while others specify HTTP methods and query parameters.\n\n### Input/Output Contracts and Data Formats\n- Input should conform to JSON schemas outlined in action descriptions.\n- Output format for commands generally includes JSON responses detailing the results of operations, such as connection ids, action ids, and any errors encountered.\n\n### Operational Caveats and Limitations\n- The skill highly recommends the use of Membrane for API interactions to minimize the risk of errors in direct API calls.\n- It is advisable to search for pre-built actions before creating custom API calls, as Membrane accounts for pagination and possible edge cases in handling API communications.\n- Each action may incur token usage, which could be limited depending on the specifics of the Membrane and 2Captcha service agreements.',
    "The Server Health Skill is a command-line tool designed for quick server monitoring, providing insights into system statistics, processes, OpenClaw gateway information, and running services. It employs a script called `server-health.sh` that users can execute in their terminal. The tool offers various usage modes including standard view, verbose output, JSON format for automation, and alerts for warnings or errors based on system metrics.\n\n### Usage and Workflow\nUsers can run the script with different flags:\n- **Standard view**: `./server-health.sh` provides a basic overview of the server's status.\n- **Verbose mode**: `./server-health.sh --verbose` enriches the output by including additional details like temperature, network stats, swap usage, and I/O without requiring user interruptions.\n- **JSON output**: `./server-health.sh --json` sends output in JSON format, catering specifically to automation processes that require structured data handling.\n- **Alerts only**: `./server-health.sh --alerts` filters the output to show alerts related to resource usage (for instance, CPU, RAM, and disk thresholds).\n\n### Output Details\nThe outputs are structured into several sections:\n- **Always displayed** information includes system stats like CPU usage, RAM availability, disk usage, and server uptime. It lists the top processes by CPU and RAM consumption and shows the status and configuration of the OpenClaw gateway.\n- **Conditionally displayed** alerts trigger if resource usage exceeds predefined thresholds (i.e., disk >90%, RAM >80%, CPU >90%) or if swap space is in use.\n- **Verbose mode only** provides further details that can be vital for in-depth diagnostics like temperature readings (if sensor data is available), current network traffic, disk I/O rates, and specifics on running services.\n\n### Example Output\nAn example output provides a clear visual metric of server health, presenting the data in an easy-to-read style, spanning from general system health indicators to detailed process utilization and gateway status.\n\n### Operational Caveats and Limitations\nThis tool assumes a certain environment where the underlying system supports the required metrics (e.g., if temperature sensors are absent, temperature readings will not be shown). Additionally, monitoring accuracy depends on the correct configuration of the OpenClaw gateway and services like Docker and PostgreSQL that should be running on the system. The output formatting, especially in verbose mode, may depend on the terminal's capability to display special characters for better visualization.",
]
query_embeddings = model.encode_query(queries)
document_embeddings = model.encode_document(documents)
print(query_embeddings.shape, document_embeddings.shape)
# [1, 1024] [3, 1024]

# Get the similarity scores for the embeddings
similarities = model.similarity(query_embeddings, document_embeddings)
print(similarities)
# tensor([[0.7668, 0.4454, 0.2444]])

Training Details

Training Dataset

Unnamed Dataset

Size: 60,245 training samples
Columns: anchor, positive, and negative

Approximate statistics based on the first 1000 samples:

	anchor	positive	negative
type	string	string	string
details	min: 6 tokens mean: 18.38 tokens max: 60 tokens	min: 77 tokens mean: 534.39 tokens max: 1084 tokens	min: 84 tokens mean: 605.13 tokens max: 1068 tokens

Samples:

anchor	positive	negative
`How do I write a credential to a specific path in a .env file using the CLI?`	The Vincent skill is designed to securely manage various types of credentials required by applications, such as API keys, OAuth tokens, SSH keys, and structured username/password pairs. Its primary function is to create and store these credentials without exposing sensitive information in the context of the agent or in standard output. Instead, it utilizes a CLI tool, @vincentai/cli, to handle credential management directly and securely, which ensures that credential values are never printed or logged by the agent.

Workflow:

Creating a Secret: The agent initiates the process by running secret create with the --type CREDENTIALS argument, which generates a secret that is connected and secured through a unique keyId and a claimUrl, shared with the user for ownership claiming.
Setting Values: Users can set the credential values either directly through the Vincent dashboard (recommended) by claiming ownership using the provided claim URL, or via the CLI, which all... | DashPass is a service designed for securely managing and storing sensitive information, such as API keys, passwords, and other credentials, on the Dash blockchain—providing a decentralized alternative to traditional storage methods like .env files. The core functionality revolves around a command-line interface (CLI) tool (dashpass-cli.mjs), which facilitates local encryption before any data is transmitted to the blockchain, ensuring that only the user with the correct private key can decrypt their credentials. This local encryption uses AES-256-GCM for each credential, maintaining high security throughout the process.


The workflow consists of several operations that users can perform using the CLI:

Storing a Credential: Credentials are inputted via standard input (stdin) and stored using the command put, which accepts parameters for the service name, the type of credential (like API key), its sensitivity level, and a label. The command securely echoes the credential's va... | | What tokens does the wallet address 0x0000000000000000000000000000000000000001 hold, and what is their current market price? | The Query Address Info Skill is designed for querying on-chain wallet addresses to retrieve detailed information about token holdings. It encompasses functionalities that allow users to obtain a comprehensive list of tokens associated with a specific wallet address, along with pertinent metrics such as the current price of each token, the 24-hour percentage change in price, and the quantity held. The skill utilizes an API endpoint provided by Binance, structured specifically for accessing wallet token balances.


APIs and Request Structure: The core API method to be used is a GET request made to the URL https://web3.binance.com/bapi/defi/v3/public/wallet-direct/buw/wallet/address/pnl/active-position-list. Users must supply three required request parameters: address, the wallet address in the Ethereum format; chainId, indicating which blockchain is being queried (such as BSC with ID 56 or Base with ID 8453); and offset, which is used for pagination purposes starting from 0.

... | The DeepBlue DeFi Research API is a public, read-only RESTful interface designed for retrieving real-time on-chain DeFi data specifically related to the Base blockchain. This API, developed by a team of four autonomous AI agents, provides various functionalities such as fetching current ETH prices from Chainlink, discovering trending pools on Base from GeckoTerminal, scoring tokens based on buy quality, and scanning wallet ERC20 holdings with USD evaluations. As a no-cost service, users can perform up to 10 requests per day without the need for authentication, making it accessible for quick reads on current DeFi data.



	
		
	
	
		Workflow Steps and Control Flow


A user initiates a request through standard GET methods to various endpoints according to their informational needs. All endpoints are stateless; thus, they can be accessed freely without authentication.

The API provides specific endpoints for each functionality, including fetching the ETH/USD price, discovering trending tokens/po... | | Can I generate a detailed report of my security metrics? | The VEXT Dashboard is a security aggregation tool specifically designed for use with an OpenClaw installation, bringing together various security data points into a unified report. The purpose of the dashboard is to give users a comprehensive view of their security posture by combining information from different sources such as scan results, monitor alerts, audit reports, findings from red team engagements, and any violations of firewall policies. This culminates in a singular security report that can quickly inform users of their overall security status.



	
		
	
	
		Workflow Steps and Control Flow
	

The process of using the VEXT Dashboard includes the following workflow steps:


User commands: The user can invoke the dashboard using predefined commands such as "Show my security dashboard," "What's my security score?" or "Generate a security report."

Data Aggregation: Upon receiving these commands, the dashboard will read data from various VEXT Shield components without altering th... | The Google Analytics Intelligence skill is designed to automate the extraction, analysis, and reporting of Google Analytics 4 (GA4) data to optimize business growth through actionable insights. This skill streamlines the various processes involved in handling vast amounts of analytics data that modern businesses accumulate but often struggle to analyze efficiently. The main functions of the skill include automated data extraction from GA4 using the Google Analytics Data API, statistical anomaly detection to identify unusual traffic trends, and the generation of professional-grade reports that suggest data-driven growth strategies. The skill is particularly useful for marketing teams, SaaS founders, e-commerce managers, and growth analysts.\n\n### Workflow Steps and Control Flow\n1. Real-Time Data Extraction: Connects to GA4 to pull metrics such as user counts, page views, traffic sources, and conversions. It facilitates queries like fetching conversion events segmented by traff... |

Loss: TripletLoss with these parameters:

{
    "distance_metric": "TripletDistanceMetric.EUCLIDEAN",
    "triplet_margin": 0.2
}

Training Hyperparameters

Non-Default Hyperparameters

eval_strategy: epoch
per_device_train_batch_size: 128
learning_rate: 2e-05
warmup_steps: 200
seed: 13
bf16: True
dataloader_num_workers: 4
gradient_checkpointing: True

All Hyperparameters

Click to expand

overwrite_output_dir: False
do_predict: False
eval_strategy: epoch
prediction_loss_only: True
per_device_train_batch_size: 128
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: 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: None
warmup_ratio: 0.0
warmup_steps: 200
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: 13
data_seed: None
jit_mode_eval: 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: True
dataloader_num_workers: 4
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
optim_args: None
adafactor: False
group_by_length: False
length_column_name: length
project: huggingface
trackio_space_id: trackio
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: True
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: no
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: True
prompts: None
batch_sampler: batch_sampler
multi_dataset_batch_sampler: proportional
router_mapping: {}
learning_rate_mapping: {}

Training Logs

Epoch	Step
1.0	470

Training Time

Training: 2.2 hours
Evaluation: 1.4 minutes
Total: 2.2 hours

Framework Versions

Python: 3.13.3
Sentence Transformers: 5.4.0
Transformers: 4.57.6
PyTorch: 2.6.0+cu124
Accelerate: 1.13.0
Datasets: 4.8.4
Tokenizers: 0.22.2

Citation

BibTeX

Sentence Transformers

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

TripletLoss

@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}
}