SAVRN
Search Contact SAVRN

Open-weight model · Sentence similarity

LaBSE

by Sentence Transformers sentence-transformers/LaBSE

This is a port of the LaBSE model to PyTorch. It can be used to map 109 languages to a shared vector space.

Parameters471M
Context512
Weights9.4 GB
Licenseapache-2.0
AccessOpen weights
Monthly Downloads741.8k

Runs On

What it takes to serve LaBSE (471M parameters): the memory its weights need at each precision, and the cheapest way to rent enough data-center GPUs to hold them.

PrecisionWeightsMemory neededCheapest setupPer hourAlso fits
16-bit 0.9 GB 1.1 GB 1x MI300X (192 GB)
Vultr
$1.85 1x H100 $1.99 · 1x MI325X $2.00
8-bit 0.5 GB 0.6 GB 1x MI300X (192 GB)
Vultr
$1.85 1x H100 $1.99 · 1x MI325X $2.00
4-bit 0.2 GB 0.3 GB 1x MI300X (192 GB)
Vultr
$1.85 1x H100 $1.99 · 1x MI325X $2.00

Memory is the weights at that precision plus 20% for the runtime and a short context; a long context needs more. Prices are the lowest on-demand hourly rates in the SAVRN Index, read Sep 18, 2026.

SAVRN's Notes on LaBSE

One shared vector space for 109 languages, and the hardware bill for it is close to nothing. At 471 million parameters the 16-bit weights are 0.9 GB and need 1.1 GB; 8-bit needs 0.6 GB and 4-bit 0.3 GB. On the cheapest setup we list, one MI300X with 192 GB at $1.85 an hour, memory is never the constraint; sentences per hour is, so batch hard or share the card. The repository weighs 9.4 GB across 19 files in five formats, safetensors, ONNX, PyTorch, JAX and TensorFlow; pull only the one you serve.

Apache 2.0 is the license, the easy kind: commercial use, modification and redistribution allowed, with a patent grant, provided you keep the notices and state your changes. Check the 512-token window; anything longer gets chunked before it is embedded. Sentence Transformers published this PyTorch port on March 2, 2022 and last touched it March 6, 2025.

Model Card

By Sentence Transformers, published under apache-2.0, revision 836121a0533e.

This is a port of the LaBSE model to PyTorch. It can be used to map 109 languages to a shared vector space. Using this model becomes easy when you have sentence-transformers installed: Then you can use the model like this: Have a look at LaBSE for the respective publication that describes LaBSE.

Read Sentence Transformers's full model card

This is a port of the LaBSE model to PyTorch. It can be used to map 109 languages to a shared vector space.

Usage (Sentence-Transformers)

Using this model becomes easy when you have sentence-transformers installed:

pip install -U sentence-transformers

Then you can use the model like this:

from sentence_transformers import SentenceTransformer
sentences = ["This is an example sentence", "Each sentence is converted"]

model = SentenceTransformer('sentence-transformers/LaBSE')
embeddings = model.encode(sentences)
print(embeddings)

Full Model Architecture

SentenceTransformer(
  (0): Transformer({'max_seq_length': 256, 'do_lower_case': False}) with Transformer model: BertModel 
  (1): Pooling({'word_embedding_dimension': 768, 'pooling_mode_cls_token': True, 'pooling_mode_mean_tokens': False, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False})
  (2): Dense({'in_features': 768, 'out_features': 768, 'bias': True, 'activation_function': 'torch.nn.modules.activation.Tanh'})
  (3): Normalize()
)

Citing & Authors

Have a look at LaBSE for the respective publication that describes LaBSE.

Configuration

Architecture
BertModel
Context length (tokens)
512
Layers
12
Hidden size
768
Feed-forward size
3,072
Attention heads
12
Vocabulary size
501,153
Model type
bert

Identity and Version

Repository
sentence-transformers/LaBSE
Publisher
Sentence Transformers
Task
Sentence similarity
Modality
Text
Library
sentence-transformers
Parameters
471M parameters
Languages
af, sq, am, ar, hy, as, az, eu
Revision
836121a0533e5664b21c7aacc5d22951f2b8b25b
First published
2022-03-02
Last updated
2025-03-06

Files and Weights

19 files, 9.4 GB in total. The weights are 7 files totalling 9.4 GB in bin, h5, msgpack, onnx, safetensors.

Weights7 files · 9.4 GB
Configuration7 files · 1.9 KB
Tokenizer3 files · 14.8 MB
Documentation1 file · 2.0 KB
Repository1 file · 445 B
Every file
FileTypeSizeSHA-256
2_Dense/model.safetensorsWeights2.4 MB f866c945fa21
2_Dense/pytorch_model.binWeights2.4 MB 06fb85120e40
flax_model.msgpackWeights1.9 GB 4cbe50771a6b
model.safetensorsWeights1.9 GB 77d8e1f2dbab
onnx/model.onnxWeights1.9 GB 2a48ae86b3ef
pytorch_model.binWeights1.9 GB c9e7daf739f8
tf_model.h5Weights1.9 GB e971d0404bba
1_Pooling/config.jsonConfiguration190 B
2_Dense/config.jsonConfiguration114 B
config.jsonConfiguration804 B
config_sentence_transformers.jsonConfiguration122 B
modules.jsonConfiguration461 B
sentence_bert_config.jsonConfiguration53 B
special_tokens_map.jsonConfiguration112 B
README.mdDocumentation2.0 KB
.gitattributesRepository445 B
tokenizer.jsonTokenizer9.6 MB
tokenizer_config.jsonTokenizer397 B
vocab.txtTokenizer5.2 MB

License and Download

License
apache-2.0
Access
Open weights, no gate
Download size
9.4 GB
Download from Sentence Transformers

Released by Sentence Transformers through its official repository on Hugging Face. Read the license.

Evaluations

Each result is shown as reported, with the conditions its reporter stated. None is a SAVRN measurement. A comparison lines two results up only when their configuration, unit and setup are all stated and identical.

BenchmarkConditionsResultReported byRevisionDate
mteb/arguana Task ArguAna_default_testMetric ArguAna_default_testSetup Obtained using MTEB v1.12.75Comparison conditions not established 34.178 Obtained using MTEB v1.12.75
Reported by a third party
Evaluated revision not stated 2026-03-05

Memory Requirements

PrecisionWeights in memory
As published9.4 GB
16-bit0.9 GB
8-bit0.5 GB
4-bit0.2 GB

Weights only, from the published parameter count; the key-value cache and runtime add to this.

Built on This Model

Questions About LaBSE

How much GPU memory does LaBSE need?

About 1.1 GB at 16-bit and 0.3 GB at 4-bit: the weights (471M parameters) plus a working margin. A long context needs more.

What is the cheapest GPU to run LaBSE on?

At 16-bit, 1x MI300X from $1.85 an hour; at 4-bit, 1x MI300X from $1.85 an hour, at the lowest on-demand prices the SAVRN Index lists.

Can I use LaBSE commercially?

Yes. LaBSE is released under Apache License 2.0. The Apache License 2.0 is a permissive open-source license. It permits commercial use, modification and redistribution. It requires keeping the license and copyright notices and any NOTICE file, stating significant changes, and it includes an express patent grant from contributors.

What is LaBSE's context length?

512 tokens, from the maximum position embeddings in its published configuration.

Similar Models

Model · Sentence similarity

nomic-embed-text-v2-moe

Nomic AI

This model was presented in the paper Training Sparse Mixture Of Experts Text Embedding Models. nomic-embed-text-v2-moe is a SoTA multilingual MoE text embedding model that excels at multilingual retrieval: Transformer-based text embedding models have improved their performance on benchmarks like MIRACL and BEIR by increasing their parameter counts. However, this scaling approach introduces significant deployment challenges, including increased inference latency and memory usage. These challenges are particularly severe in retrieval-augmented generation (RAG) applications, where large models' increased memory requirements constrain dataset ingestion capacity, and their higher latency…

Open weights apache-2.0 475M parameters sentence-transformers

Model · Sentence similarity

semantic-lite-2

Zulfah

Semantic-Lite-2 is a lightweight multilingual sentence embedding model that produces 256-dimensional semantic vectors. It is designed for semantic search, sentence similarity, clustering, retrieval, and retrieval-augmented generation (RAG) tasks. The model is built on top of the Spark-X2.5-1.7B backbone using a frozen-backbone plus trainable-projection-head approach. The 256-dimensional output keeps vector storage compact while preserving strong retrieval quality. Vectors are L2-normalized, so cosine similarity is computed as a simple dot product. Evaluated on 500 Indonesian NLI evaluation pairs (retrieval task, chance level 0.2%): Cross-lingual evaluation (10 languages, 20 pairs per…

Open weights apache-2.0 460M parameters 1,048,576 tokens transformers

Model · Sentence similarity

gte-large-en-v1.5

Alibaba-NLP

We introduce gte-v1.5 series, upgraded gte embeddings that support the context length of up to 8192, while further enhancing model performance. The models are built upon the transformer++ encoder backbone (BERT + RoPE + GLU). The gte-v1.5 series achieve state-of-the-art scores on the MTEB benchmark within the same model size category and prodvide competitive on the LoCo long-context retrieval tests (refer to Evaluation). We also present the gte-Qwen1.5-7B-instruct, a SOTA instruction-tuned multi-lingual embedding model that ranked 2nd in MTEB and 1st in C-MTEB. Models for Multilingual Text Retrieval](https://arxiv.org/pdf/2407.19669) Use the code below to get started with the model. It is…

Open weights apache-2.0 434M parameters 8,192 tokens transformers

Model · Sentence similarity

snowflake-arctic-embed-l-v2.0

Snowflake

12/11/2024: Release of Technical Report - 12/04/2024: Release of snowflake-arctic-embed-l-v2.0 and snowflake-arctic-embed-m-v2.0 our newest models with multilingual workloads in mind. Snowflake arctic-embed-l-v2.0 is the newest addition to the suite of embedding models Snowflake has released optimizing for retrieval performance and inference efficiency. Arctic Embed 2.0 introduces a new standard for multilingual embedding models, combining high-quality multilingual text retrieval without sacrificing performance in English. Released under the permissive Apache 2.0 license, Arctic Embed 2.0 is ideal for applications that demand reliable, enterprise-grade multilingual search and retrieval at…

Open weights apache-2.0 568M parameters 8,194 tokens sentence-transformers

Model · Sentence similarity

all-roberta-large-v1

Sentence Transformers

This is a sentence-transformers model: It maps sentences & paragraphs to a 1024 dimensional dense vector space and can be used for tasks like clustering or semantic search. Using this model becomes easy when you have sentence-transformers installed: Then you can use the model like this: Without sentence-transformers, you can use the model like this: First, you pass your input through the transformer model, then you have to apply the right pooling-operation on-top of the contextualized word embeddings. The project aims to train sentence embedding models on very large sentence level datasets using a self-supervised contrastive learning objective. We used the pretrained roberta-large model and…

Open weights apache-2.0 355M parameters 514 tokens sentence-transformers

Model · Sentence similarity

lt-un-data-fine-fine-fr

Dell Research Harvard

This is a LinkTransformer model. At its core this model this is a sentence transformer model sentence-transformers model- it just wraps around the class. It is designed for quick and easy record linkage (entity-matching) through the LinkTransformer package. The tasks include clustering, deduplication, linking, aggregation and more. Notwithstanding that, it can be used for any sentence similarity task within the sentence-transformers framework as well. It maps sentences & paragraphs to a 1024 dimensional dense vector space and can be used for tasks like clustering or semantic search. Take a look at the documentation of sentence-transformers if you want to use this model for more than what we…

Open weights 337M parameters 514 tokens sentence-transformers