pip install model2vec


# 安裝蒸餾附加功能
pip install model2vec[distill]

from model2vec import StaticModel
# 從HuggingFace中心加載模型（這里以potion-base-8M模型為例）
model = StaticModel.from_pretrained("minishlab/potion-base-8M")
# 進(jìn)行嵌入操作
embeddings = model.encode(["It's dangerous to go alone!", "It's a secret to everybody."])
# 生成詞元嵌入序列
token_embeddings = model.encode_as_sequence(["It's dangerous to go alone!", "It's a secret to everybody."])

from model2vec.distill import distill


# Distill a Sentence Transformer model, in this case the BAAI/bge-base-en-v1.5 model
m2v_model = distill(model_name="BAAI/bge-base-en-v1.5", pca_dims=256)


# Save the model
m2v_model.save_pretrained("m2v_model")

from model2vec import StaticModel


# Load a model from the Hub. You can optionally pass a token when loading a private model
model = StaticModel.from_pretrained(model_name="minishlab/potion-base-8M", token=None)


# Make embeddings
embeddings = model.encode(["It's dangerous to go alone!", "It's a secret to everybody."])


# Make sequences of token embeddings
token_embeddings = model.encode_as_sequence(["It's dangerous to go alone!", "It's a secret to everybody."])

from sentence_transformers import SentenceTransformer
from sentence_transformers.models import StaticEmbedding


# Initialize a StaticEmbedding module
static_embedding = StaticEmbedding.from_model2vec("minishlab/potion-base-8M")
model = SentenceTransformer(modules=[static_embedding])
embeddings = model.encode(["It's dangerous to go alone!", "It's a secret to everybody."])

from model2vec.distill import distill


# Distill a Sentence Transformer model
m2v_model = distill(model_name="BAAI/bge-base-en-v1.5", pca_dims=256)


# Save the model
m2v_model.save_pretrained("m2v_model")

from transformers import AutoModel, AutoTokenizer


from model2vec.distill import distill_from_model


# Assuming a loaded model and tokenizer
model_name = "baai/bge-base-en-v1.5"
model = AutoModel.from_pretrained(model_name)
tokenizer = AutoTokenizer.from_pretrained(model_name)


m2v_model = distill_from_model(model=model, tokenizer=tokenizer, pca_dims=256)


m2v_model.save_pretrained("m2v_model")

from sentence_transformers import SentenceTransformer
from sentence_transformers.models import StaticEmbedding


static_embedding = StaticEmbedding.from_distillation("BAAI/bge-base-en-v1.5", device="cpu", pca_dims=256)
model = SentenceTransformer(modules=[static_embedding])
embeddings = model.encode(["It's dangerous to go alone!", "It's a secret to everybody."])

from model2vec.distill import distill


# Load a vocabulary as a list of strings
vocabulary = ["word1", "word2", "word3"]


# Distill a Sentence Transformer model with the custom vocabulary
m2v_model = distill(model_name="BAAI/bge-base-en-v1.5", vocabulary=vocabulary)


# Save the model
m2v_model.save_pretrained("m2v_model")


# Or push it to the hub
m2v_model.push_to_hub("my_organization/my_model", token="<it's a secret to everybody>")

m2v_model = distill(model_name=model_name, vocabulary=vocabulary, use_subword=False)

pip install git+https://github.com/MinishLab/evaluation.git@main

from model2vec import StaticModel


from evaluation import CustomMTEB, get_tasks, parse_mteb_results, make_leaderboard, summarize_results
from mteb import ModelMeta


# Get all available tasks
tasks = get_tasks()
# Define the CustomMTEB object with the specified tasks
evaluation = CustomMTEB(tasks=tasks)


# Load the model
model_name = "m2v_model"
model = StaticModel.from_pretrained(model_name)


# Optionally, add model metadata in MTEB format
model.mteb_model_meta = ModelMeta(
            name=model_name, revision="no_revision_available", release_date=None, languages=None
        )


# Run the evaluation
results = evaluation.run(model, eval_splits=["test"], output_folder=f"results")


# Parse the results and summarize them
parsed_results = parse_mteb_results(mteb_results=results, model_name=model_name)
task_scores = summarize_results(parsed_results)


# Print the results in a leaderboard format
print(make_leaderboard(task_scores))

from sentence_transformers import SentenceTransformer
from sentence_transformers.models import StaticEmbedding


# Initialize a StaticEmbedding module
static_embedding = StaticEmbedding.from_model2vec("minishlab/potion-base-8M")
model = SentenceTransformer(modules=[static_embedding])
embeddings = model.encode(["It's dangerous to go alone!", "It's a secret to everybody."])

from sentence_transformers import SentenceTransformer
from sentence_transformers.models import StaticEmbedding


static_embedding = StaticEmbedding.from_distillation("BAAI/bge-base-en-v1.5", device="cpu", pca_dims=256)
model = SentenceTransformer(modules=[static_embedding])
embeddings = model.encode(["It's dangerous to go alone!", "It's a secret to everybody."])

from langchain_community.embeddings import Model2vecEmbeddings
from langchain_community.vectorstores import FAISS
from langchain.schema import Document


# Initialize a Model2Vec embedder
embedder = Model2vecEmbeddings("minishlab/potion-base-8M")


# Create some example texts
texts = [
    "Enduring Stew",
    "Hearty Elixir",
    "Mighty Mushroom Risotto",
    "Spicy Meat Skewer",
    "Fruit Salad",
]


# Embed the texts
embeddings = embedder.embed_documents(texts)


# Or, create a vector store and query it
documents = [Document(page_content=text) for text in texts]
vector_store = FAISS.from_documents(documents, embedder)
query = "Risotto"
query_vector = embedder.embed_query(query)
retrieved_docs = vector_store.similarity_search_by_vector(query_vector, k=1)

from txtai import Embeddings


# Load a model2vec model
embeddings = Embeddings(path="minishlab/potion-base-8M", method="model2vec", backend="numpy")


# Create some example texts
texts = ["Enduring Stew", "Hearty Elixir", "Mighty Mushroom Risotto", "Spicy Meat Skewer", "Chilly Fruit Salad"]


# Create embeddings for downstream tasks
vectors = embeddings.batchtransform(texts)


# Or create a nearest-neighbors index and search it
embeddings.index(texts)
result = embeddings.search("Risotto", 1)

import { AutoModel, AutoTokenizer, Tensor } from '@huggingface/transformers';


const modelName = 'minishlab/potion-base-8M';


const modelConfig = {
    config: { model_type: 'model2vec' },
    dtype: 'fp32',
    revision: 'refs/pr/1'
};
const tokenizerConfig = {
    revision: 'refs/pr/2'
};


const model = await AutoModel.from_pretrained(modelName, modelConfig);
const tokenizer = await AutoTokenizer.from_pretrained(modelName, tokenizerConfig);


const texts = ['hello', 'hello world'];
const { input_ids } = await tokenizer(texts, { add_special_tokens: false, return_tensor: false });


const cumsum = arr => arr.reduce((acc, num, i) => [...acc, num + (acc[i - 1] || 0)], []);
const offsets = [0, ...cumsum(input_ids.slice(0, -1).map(x => x.length))];


const flattened_input_ids = input_ids.flat();
const modelInputs = {
    input_ids: new Tensor('int64', flattened_input_ids, [flattened_input_ids.length]),
    offsets: new Tensor('int64', offsets, [offsets.length])
};


const { embeddings } = await model(modelInputs);
console.log(embeddings.tolist()); // output matches python version