Embeddings

Avant d'implémenter les embeddings

Lors du choix d'un fournisseur d'« embeddings » (plongements vectoriels), plusieurs facteurs peuvent être pris en compte selon vos besoins et vos préférences :

• Taille du jeu de données et spécificité du domaine : taille du jeu de données d'entraînement du modèle et sa pertinence par rapport au domaine que vous souhaitez vectoriser. Des données plus volumineuses ou plus spécifiques à un domaine produisent généralement de meilleurs embeddings dans ce domaine.
• Performances d'inférence : vitesse de recherche des embeddings et « latency » (latence) de bout en bout. Il s'agit d'une considération particulièrement importante pour les déploiements en production à grande échelle.
• Personnalisation : options de poursuite de l'entraînement sur des données privées, ou spécialisation des modèles pour des domaines très spécifiques. Cela peut améliorer les performances sur des vocabulaires uniques.

Comment obtenir des embeddings avec Anthropic

Anthropic ne propose pas son propre modèle d'embedding. Voyage AI by MongoDB est un fournisseur d'embeddings qui offre une grande variété de modèles et de fonctionnalités.

Voyage AI conçoit des modèles d'embedding et des « rerankers » (modèles de reclassement). Ses modèles d'embedding comprennent des modèles généralistes, multimodaux, contextualisés et spécifiques à un domaine.

Le reste de ce guide concerne Voyage AI, mais vous devriez évaluer différents fournisseurs d'embeddings afin de trouver celui qui convient le mieux à votre cas d'utilisation spécifique.

Modèles disponibles

Voyage AI propose les modèles d'embedding de texte suivants :

Dernière génération

Génération précédente

Pour connaître le statut du cycle de vie de chaque modèle et son remplaçant recommandé, consultez Model deprecations, lifecycle states, and support dans la documentation MongoDB.

Voyage AI propose également les modèles d'embedding multimodaux suivants. Appelez ces modèles avec multimodal_embed() au lieu de embed() :

Les modèles d'embedding de segments contextualisés suivants produisent des vecteurs au niveau du segment qui capturent le contexte complet du document sans enrichissement manuel par métadonnées. Appelez ces modèles avec contextualized_embed() au lieu de embed() :

La limite de 120 000 tokens s'applique lorsque vous définissez enable_auto_chunking sur true. Sinon, le nombre total de tokens sur l'ensemble des entrées ne peut pas dépasser 32 000.

Voyage AI propose également des « rerankers » (modèles de reclassement), qui prennent une requête et une liste de documents et les renvoient classés par pertinence par rapport à la requête. Appelez ces modèles avec rerank() :

Besoin d'aide pour choisir le modèle à utiliser ? Consultez Voyage AI embedding and reranking models overview dans la documentation MongoDB.

Premiers pas avec Voyage AI

Pour accéder aux modèles Voyage AI, créez une clé API de modèle dans MongoDB Atlas :

1. Créez un compte MongoDB Atlas ou connectez-vous.
2. Dans votre projet Atlas, sélectionnez AI Model APIs dans la barre de navigation, cliquez sur Create model API key, nommez la clé, puis cliquez sur Create.
3. Pour plus de commodité, définissez la clé API comme variable d'environnement :

export VOYAGE_API_KEY="<your model API key>"

Pour plus de détails, consultez Voyage AI quick start dans la documentation MongoDB.

Vous pouvez obtenir les embeddings soit en utilisant le package Python officiel voyageai, soit au moyen de requêtes HTTP, comme décrit dans les sections suivantes. Voyage AI dispose également d'un client TypeScript officiel. Pour l'utiliser avec une clé API de modèle provenant d'Atlas, définissez son option environment sur https://ai.mongodb.com/v1, comme décrit dans TypeScript client dans la documentation MongoDB.

Bibliothèque Python Voyage AI

Installez le package voyageai à l'aide de la commande suivante. Pour utiliser une clé API de modèle provenant d'Atlas, vous avez besoin de la version 0.3.7 ou ultérieure.

pip install -U voyageai

Ensuite, vous pouvez créer un objet client et commencer à l'utiliser pour vectoriser vos textes :

import voyageai

vo = voyageai.Client()
# Cela utilisera automatiquement la variable d'environnement VOYAGE_API_KEY.
# Vous pouvez aussi utiliser vo = voyageai.Client(api_key="<your model API key>")

texts = ["Sample text 1", "Sample text 2"]

result = vo.embed(texts, model="voyage-4", input_type="document")
print(result.embeddings[0])
print(result.embeddings[1])

result.embeddings est une liste de deux vecteurs d'embedding, chacun contenant 1024 nombres à virgule flottante. Après l'exécution du code précédent, les deux embeddings sont affichés à l'écran :

[-0.013131560757756233, 0.019828535616397858, ...]   # embedding for "Sample text 1"
[-0.0069352793507277966, 0.020878976210951805, ...]  # embedding for "Sample text 2"

Lors de la création des embeddings, vous pouvez spécifier quelques autres arguments à la fonction embed().

Pour plus d'informations sur le package Python, consultez Accessing Voyage AI models dans la documentation MongoDB.

API HTTP Voyage AI

Vous pouvez également obtenir des embeddings en envoyant des requêtes HTTP à l'Atlas Embedding and Reranking API. Par exemple, vous pouvez envoyer une requête HTTP via la commande curl dans un terminal :

curl https://ai.mongodb.com/v1/embeddings \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $VOYAGE_API_KEY" \
  -d '{
    "input": ["Sample text 1", "Sample text 2"],
    "model": "voyage-4",
    "input_type": "document"
  }'

La réponse que vous obtiendrez est un objet JSON contenant les embeddings et l'utilisation des tokens :

{
  "object": "list",
  "data": [
    {
      "object": "embedding",
      "embedding": [-0.013131560757756233, 0.019828535616397858 /* ... */],
      "index": 0
    },
    {
      "object": "embedding",
      "embedding": [-0.0069352793507277966, 0.020878976210951805 /* ... */],
      "index": 1
    }
  ],
  "model": "voyage-4",
  "usage": {
    "total_tokens": 10
  }
}

Les clés API de modèle provenant d'Atlas fonctionnent avec ai.mongodb.com, à l'exception des clés limitées à une zone géographique, qui utilisent le point de terminaison de cette zone. Si vous disposez plutôt d'une clé API provenant de la plateforme Voyage AI, consultez Migrate your applications to use the Atlas Embedding and Reranking API dans la documentation MongoDB.

Pour la référence complète des requêtes et des réponses, consultez Create text embeddings dans la documentation de l'Atlas Embedding and Reranking API.

AWS Marketplace

Les modèles Voyage AI sont également disponibles sur AWS Marketplace via le profil vendeur de MongoDB. Pour les instructions, consultez Deploy Voyage AI models using AWS Marketplace dans la documentation MongoDB.

Exemple de démarrage rapide

Le bref exemple suivant montre comment utiliser les embeddings.

Supposons que vous disposiez d'un petit corpus de six documents dans lequel effectuer des recherches

documents = [
    "The Mediterranean diet emphasizes fish, olive oil, and vegetables, believed to reduce chronic diseases.",
    "Photosynthesis in plants converts light energy into glucose and produces essential oxygen.",
    "20th-century innovations, from radios to smartphones, centered on electronic advancements.",
    "Rivers provide water, irrigation, and habitat for aquatic species, vital for ecosystems.",
    "Apple's conference call to discuss fourth fiscal quarter results and business updates is scheduled for Thursday, November 2, 2023 at 2:00 p.m. PT / 5:00 p.m. ET.",
    "Shakespeare's works, like 'Hamlet' and 'A Midsummer Night's Dream,' endure in literature.",
]

Tout d'abord, utilisez Voyage AI pour convertir chaque document en vecteur d'embedding.

import voyageai

vo = voyageai.Client()

# Générer les embeddings des documents
doc_embds = vo.embed(documents, model="voyage-4", input_type="document").embeddings

Les embeddings vous permettent d'effectuer une recherche sémantique / récupération dans l'espace vectoriel. Étant donné un exemple de requête,

query = "When is Apple's conference call scheduled?"

Ensuite, convertissez-la en embedding et effectuez une recherche du plus proche voisin pour trouver le document le plus pertinent en fonction de la distance dans l'espace d'embedding.

import numpy as np

# Générer l'embedding de la requête
query_embd = vo.embed([query], model="voyage-4", input_type="query").embeddings[0]

# Calculer la similarité
# Les embeddings Voyage AI sont normalisés à une longueur de 1, donc le produit scalaire
# et la similarité cosinus sont identiques.
similarities = np.dot(doc_embds, query_embd)

retrieved_id = np.argmax(similarities)
print(documents[retrieved_id])

Notez que input_type="document" et input_type="query" sont utilisés respectivement pour l'embedding du document et de la requête. Pour en savoir plus sur input_type, consultez Quand et comment dois-je utiliser le paramètre input_type ? dans la FAQ.

La sortie est le cinquième document, qui est effectivement le plus pertinent pour la requête :

Apple's conference call to discuss fourth fiscal quarter results and business updates is scheduled for Thursday, November 2, 2023 at 2:00 p.m. PT / 5:00 p.m. ET.

Si vous recherchez un ensemble détaillé de recettes sur la manière de faire du RAG avec des embeddings, y compris avec des bases de données vectorielles, consultez la recette RAG.

FAQ

import voyageai
import numpy as np


def embd_normalize(v: np.ndarray) -> np.ndarray:
    """
    Normalize the rows of a 2D numpy array to unit vectors by dividing each row by its Euclidean
    norm. Raises a ValueError if any row has a norm of zero to prevent division by zero.
    """
    row_norms = np.linalg.norm(v, axis=1, keepdims=True)
    if np.any(row_norms == 0):
        raise ValueError("Cannot normalize rows with a norm of zero.")
    return v / row_norms


vo = voyageai.Client()

# Générer des vecteurs voyage-code-4, qui sont par défaut des nombres à virgule flottante de dimension 1024.
embd = vo.embed(["Sample text 1", "Sample text 2"], model="voyage-code-4").embeddings

# Définir une dimension plus courte.
short_dim = 256

# Redimensionner et normaliser les vecteurs à la dimension plus courte.
resized_embd = embd_normalize(np.array(embd)[:, :short_dim]).tolist()

Tarification

Pour obtenir les informations tarifaires les plus récentes, consultez Model pricing dans la documentation MongoDB.