msmarco-MiniLM-L6-cos-v5

Usar este modelo es fácil cuando tienes sentence-transformers instalado:

pip install -U sentence-transformers

Luego puedes usar el modelo así:

from sentence_transformers import SentenceTransformer, util

query = "How many people live in London?"
docs = ["Around 9 Million people live in London", "London is known for its financial district"]

# Cargar el modelo
model = SentenceTransformer('sentence-transformers/msmarco-MiniLM-L6-cos-v5')

# Codificar consulta y documentos
query_emb = model.encode(query)
doc_emb = model.encode(docs)

# Calcular puntuación de punto entre la consulta y todas las incrustaciones de documentos
scores = util.dot_score(query_emb, doc_emb)[0].cpu().tolist()

# Combinar documentos y puntuaciones
pairs_doc_score = list(zip(docs, scores))

# Ordenar por puntuación decreciente
pairs_doc_score = sorted(pairs_doc_score, key=lambda x: x[1], reverse=True)

# Salida de pasajes y puntuaciones
for doc, score in pairs_doc_score:
  print(score, doc)

Sin sentence-transformers, puedes usar el modelo así: Primero, debes pasar tu entrada a través del modelo transformer, luego debes aplicar la operación de pooling correcta sobre las incrustaciones de palabras contextualizadas.

from transformers import AutoTokenizer, AutoModel
import torch
import torch.nn.functional as F

# Mean Pooling - Tomar el promedio de todos los tokens
definición mean_pooling(model_output, attention_mask):
token_embeddings = model_output.last_hidden_state #El primer elemento de model_output contiene todas las incrustaciones de tokens
input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)

# Codificar texto
def encode(texts):
  # Tokenizar oraciones
  encoded_input = tokenizer(texts, padding=True, truncation=True, return_tensors='pt')

  # Calcular incrustaciones de tokens
  with torch.no_grad():
    model_output = model(**encoded_input, return_dict=True)

  # Realizar pooling
  embeddings = mean_pooling(model_output, encoded_input['attention_mask'])

  # Normalizar incrustaciones
  embeddings = F.normalize(embeddings, p=2, dim=1)

  return embeddings

# Oraciones para las que queremos incrustaciones de oraciones
query = "How many people live in London?"
docs = ["Around 9 Million people live in London", "London is known for its financial district"]

# Cargar modelo desde HuggingFace Hub
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/msmarco-MiniLM-L6-cos-v5")
model = AutoModel.from_pretrained("sentence-transformers/msmarco-MiniLM-L6-cos-v5")

# Codificar consulta y documentos
query_emb = encode(query)
doc_emb = encode(docs)

# Calcular puntuación de punto entre la consulta y todas las incrustaciones de documentos
scores = torch.mm(query_emb, doc_emb.transpose(0, 1))[0].cpu().tolist()

# Combinar documentos y puntuaciones
pairs_doc_score = list(zip(docs, scores))

# Ordenar por puntuación decreciente
pairs_doc_score = sorted(pairs_doc_score, key=lambda x: x[1], reverse=True)

# Salida de pasajes y puntuaciones
for doc, score in pairs_doc_score:
  print(score, doc)