Embeddings

​

Aperçu des embeddings

Les embeddings de texte sont des représentations numériques de chaînes de texte, représentées sous forme d’un vecteur de nombres à virgule flottante. Vous pouvez utiliser la distance entre deux morceaux de texte intégrés (qu’il s’agisse de mots, de phrases ou de phrases) pour mesurer à quel point ces morceaux de texte sont liés les uns aux autres. Une mesure populaire est la similarité cosinus, mais vous pouvez également mesurer la similarité via d’autres fonctions de distance telles que la distance euclidienne ou les produits scalaires (voir FAQ ci-dessous). En général, des distances plus petites prédisent une plus grande parenté en termes de relation sémantique ou syntaxique entre les textes.

La comparaison de la similarité des chaînes, ou le regroupement des chaînes en fonction de leur distance les unes par rapport aux autres, permet une grande variété d’applications, notamment la recherche (populaire dans les architectures RAG), les recommandations et la détection d’anomalies.

​

Comment obtenir des embeddings avec Anthropic

Lors de la sélection d’un fournisseur d’embeddings, vous pouvez prendre en compte plusieurs facteurs en fonction de vos besoins et préférences :

• Taille et spécificité du domaine du jeu de données : taille du jeu de données d’entraînement du modèle et sa pertinence pour le domaine que vous souhaitez intégrer. Des données plus volumineuses ou plus spécifiques à un domaine produisent généralement de meilleurs embeddings dans ce domaine
• Architecture du modèle : Conception et complexité du modèle. Les techniques et architectures plus modernes comme les Transformers ont tendance à apprendre et à produire des embeddings de meilleure qualité
• Performances d’inférence : Vitesse de recherche des embeddings et latence de bout en bout. C’est une considération particulièrement importante pour les déploiements de production à grande échelle
• Personnalisation : Options pour la formation continue sur des données privées, ou la spécialisation des modèles pour des domaines très spécifiques. Cela peut améliorer les performances sur des vocabulaires uniques

Anthropic ne propose pas son propre modèle d’embeddings. Un fournisseur d’embeddings qui offre une grande variété d’options et de capacités englobant les quatre considérations ci-dessus est Voyage AI. Voyage AI crée des modèles d’embeddings à la pointe de la technologie et propose des modèles personnalisés pour des domaines industriels spécifiques tels que la finance et la santé, ou des modèles sur mesure pour des clients individuels.

Le reste de ce guide concerne Voyage AI, mais nous vous encourageons à évaluer une variété de fournisseurs d’embeddings pour trouver la meilleure adéquation à votre cas d’utilisation spécifique.

​

Démarrer avec Voyage AI

Consultez notre notebook sur les embeddings pour voir un exemple d’implémentation de Voyage AI.

Pour accéder aux embeddings de Voyage :

1. Inscrivez-vous sur le site web de Voyage AI
2. Obtenez une clé API
3. Définissez la clé API comme variable d’environnement pour plus de commodité :

export VOYAGE_API_KEY="<votre clé secrète>"

Vous pouvez exécuter les embeddings soit en utilisant le package Python officiel voyageai, soit via des requêtes HTTP, comme décrit ci-dessous.

​

Package Python Voyage

Le package voyageai peut être installé à l’aide de la commande suivante :

pip install -U voyageai

Ensuite, vous pouvez créer un objet client et commencer à l’utiliser pour intégrer vos textes :

import voyageai

vo = voyageai.Client()
# Cela utilisera automatiquement la variable d'environnement VOYAGE_API_KEY.
# Vous pouvez également utiliser vo = voyageai.Client(api_key="<votre clé secrète>")

texts = ["Exemple de texte 1", "Exemple de texte 2"]

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

result.embeddings sera une liste de deux vecteurs d’embeddings, chacun contenant 1024 nombres à virgule flottante.

Après avoir exécuté le code ci-dessus, les deux embeddings seront imprimés à l’écran :

[0.02012746, 0.01957859, ...]  # embedding pour "Exemple de texte 1"
[0.01429677, 0.03077182, ...]  # embedding pour "Exemple de texte 2"

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

voyageai.Client.embed(texts : List[str], model : str, input_type : Optional[str] = None, truncation : Optional[bool] = None)

• texts (List[str]) - Une liste de textes sous forme de liste de chaînes, telle que ["J'aime les chats", "J'aime aussi les chiens"]. Actuellement, la longueur maximale de la liste est de 128, et le nombre total de tokens dans la liste est au maximum de 320K pour voyage-2 et 120K pour voyage-large-2/voyage-code-2.
• model (str) - Nom du modèle. Options recommandées : voyage-2, voyage-large-2, voyage-code-2.
• input_type (str, optionnel, par défaut None) - Type du texte d’entrée. Par défaut None. Autres options : query, document
  • Lorsque input_type est défini sur None, le texte d’entrée sera directement encodé par le modèle d’embeddings de Voyage. Alternativement, lorsque les entrées sont des documents ou des requêtes, les utilisateurs peuvent spécifier input_type comme query ou document, respectivement. Dans de tels cas, Voyage préfixera une invite spéciale au texte d’entrée et enverra les entrées étendues au modèle d’embeddings
  • Pour les cas d’utilisation de recherche/récupération, nous recommandons de spécifier cet argument lors de l’encodage des requêtes ou des documents pour améliorer la qualité de la récupération. Les embeddings générés avec et sans l’argument input_type sont compatibles
• truncation (bool, optionnel, par défaut None) - S’il faut tronquer les textes d’entrée pour s’adapter à la longueur du contexte.
  • Si True, les textes d’entrée trop longs seront tronqués pour s’adapter à la longueur du contexte, avant d’être vectorisés par le modèle d’embeddings
  • Si False, une erreur sera levée si un texte donné dépasse la longueur du contexte
  • S’il n’est pas spécifié (par défaut None), Voyage tronquera le texte d’entrée avant de l’envoyer au modèle d’embeddings s’il dépasse légèrement la longueur de la fenêtre de contexte. S’il dépasse significativement la longueur de la fenêtre de contexte, une erreur sera levée

​

API HTTP Voyage

Vous pouvez également obtenir des embeddings en envoyant une requête à l’API HTTP de Voyage. Par exemple, vous pouvez envoyer une requête HTTP via la commande curl dans un terminal :

curl https://api.voyageai.com/v1/embeddings \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $VOYAGE_API_KEY" \
  -d '{
    "input": ["Exemple de texte 1", "Exemple de texte 2"],
    "model": "voyage-2"
  }'

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

{
  "object": "list",
  "data": [
    {
      "embedding": [0.02012746, 0.01957859, ...],
      "index": 0
    },
    {
      "embedding": [0.01429677, 0.03077182, ...],
      "index": 1
    }
  ],
  "model": "voyage-2",
  "usage": {
    "total_tokens": 10
  }
}

Le point de terminaison d’embeddings de Voyage AI est https://api.voyageai.com/v1/embeddings (POST). L’en-tête de la requête doit contenir la clé API. Le corps de la requête est un objet JSON contenant les arguments suivants :

• input (str, List[str]) - Une seule chaîne de texte, ou une liste de textes sous forme de liste de chaînes. Actuellement, la longueur maximale de la liste est de 128, et le nombre total de tokens dans la liste est au maximum de 320K pour voyage-2 et 120K pour voyage-large-2/voyage-code-2.
• model (str) - Nom du modèle. Options recommandées : voyage-2, voyage-large-2, voyage-code-2.
• input_type (str, optionnel, par défaut None) - Type du texte d’entrée. Par défaut None. Autres options : query, document
• truncation (bool, optionnel, par défaut None) - S’il faut tronquer les textes d’entrée pour s’adapter à la longueur du contexte
  • Si True, les textes d’entrée trop longs seront tronqués pour s’adapter à la longueur du contexte avant d’être vectorisés par le modèle d’embeddings
  • Si False, une erreur sera levée si un texte donné dépasse la longueur du contexte
  • S’il n’est pas spécifié (par défaut None), Voyage tronquera le texte d’entrée avant de l’envoyer au modèle d’embeddings s’il dépasse légèrement la longueur de la fenêtre de contexte. S’il dépasse significativement la longueur de la fenêtre de contexte, une erreur sera levée
• encoding_format (str, optionnel, par défaut None) - Format dans lequel les embeddings sont encodés. Voyage prend actuellement en charge deux options :
  • S’il n’est pas spécifié (par défaut None) : les embeddings sont représentés sous forme de listes de nombres à virgule flottante
  • "base64" : les embeddings sont compressés en encodages Base64

​

Exemple d’embeddings Voyage

Maintenant que nous savons comment obtenir des embeddings avec Voyage, voyons-le en action avec un bref exemple.

Supposons que nous ayons un petit corpus de six documents à récupérer

documents = [
    "Le régime méditerranéen met l'accent sur le poisson, l'huile d'olive et les légumes, censés réduire les maladies chroniques.",
    "La photosynthèse chez les plantes convertit l'énergie lumineuse en glucose et produit de l'oxygène essentiel.",
    "Les innovations du 20e siècle, des radios aux smartphones, se sont concentrées sur les progrès électroniques.",
    "Les rivières fournissent de l'eau, de l'irrigation et un habitat pour les espèces aquatiques, essentiels aux écosystèmes.",
    "La conférence téléphonique d'Apple pour discuter des résultats du quatrième trimestre fiscal et des mises à jour commerciales est prévue pour le jeudi 2 novembre 2023 à 14h00 PT / 17h00 ET.",
    "Les œuvres de Shakespeare, comme 'Hamlet' et 'Le Songe d'une nuit d'été', perdurent dans la littérature."
]

Nous allons d’abord utiliser Voyage pour convertir chacun d’eux en un vecteur d’embeddings

import voyageai

vo = voyageai.Client()

# Intégrer les documents
doc_embds = vo.embed(
    documents, model="voyage-2", input_type="document"
).embeddings

Les embeddings nous permettront d’effectuer une recherche/récupération sémantique dans l’espace vectoriel. Nous pouvons ensuite convertir une requête d’exemple,

query = "Quand est prévue la conférence téléphonique d'Apple ?"

en un embedding, puis effectuer une recherche du plus proche voisin pour trouver le document le plus pertinent en fonction de la distance dans l’espace d’embeddings.

import numpy as np

# Intégrer la requête
query_embd = vo.embed(
    [query], model="voyage-2", input_type="query"
).embeddings[0]

# Calculer la similarité
# Les embeddings de Voyage 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 nous utilisons input_type="document" et input_type="query" pour intégrer respectivement le document et la requête. Plus de spécifications peuvent être trouvées ici.

La sortie serait le 5ème document, qui est en effet le plus pertinent pour la requête :

La conférence téléphonique d'Apple pour discuter des résultats du quatrième trimestre fiscal et des mises à jour commerciales est prévue pour le jeudi 2 novembre 2023 à 14h00 PT / 17h00 ET.

​

Modèles Voyage disponibles

Voyage recommande d’utiliser les modèles d’embeddings suivants :

voyage-2 et voyage-large-2 sont des modèles d’embeddings généralistes, qui atteignent des performances de pointe dans tous les domaines et conservent une grande efficacité. voyage-code-2 est optimisé pour le domaine du code, offrant une longueur de contexte 4 fois supérieure pour une utilisation plus flexible, bien qu’avec une latence relativement plus élevée.

Voyage développe activement des modèles plus avancés et spécialisés, et propose également des services de fine-tuning pour personnaliser des modèles sur mesure pour des clients individuels. Envoyez un e-mail à votre responsable de compte Anthropic ou contactez le support Anthropic pour plus d’informations sur les modèles sur mesure.

• voyage-finance-2 : bientôt disponible
• voyage-law-2 : bientôt disponible
• voyage-multilingual-2 : bientôt disponible
• voyage-healthcare-2 : bientôt disponible

​

Voyage sur AWS Marketplace

Les embeddings Voyage sont également disponibles sur AWS Marketplace. Voici les instructions pour accéder à Voyage sur AWS :

1. Abonnez-vous au package du modèle
   1. Accédez à la page de liste des packages de modèles et sélectionnez le modèle à déployer
   2. Cliquez sur le bouton Continue to subscribe
   3. Examinez attentivement les détails sur la page Subscribe to this software. Si vous acceptez le contrat de licence utilisateur final (CLUF) standard, les prix et les conditions de support, cliquez sur “Accept Offer”
   4. Après avoir sélectionné Continue to configuration et choisi une région, vous recevrez un Product Arn. Il s’agit de l’ARN du package de modèle requis pour créer un modèle déployable à l’aide de Boto3
      1. Copiez l’ARN qui correspond à votre région sélectionnée et utilisez-le dans la cellule suivante
2. Déployez le package du modèle

À partir de là, créez un espace JupyterLab dans Sagemaker Studio, téléchargez le notebook de Voyage et suivez les instructions à l’intérieur.

​

Foire aux questions

​

Comment calculer la distance entre deux vecteurs d’embeddings ?

La similarité cosinus est un choix populaire, mais la plupart des fonctions de distance feront l’affaire. Les embeddings de Voyage sont normalisés à une longueur de 1, donc la similarité cosinus est essentiellement la même que le produit scalaire entre deux vecteurs. Voici un extrait de code que vous pouvez utiliser pour calculer la similarité cosinus entre deux vecteurs d’embeddings.

import numpy

similarity = np.dot(embd1, embd2)
# Les embeddings de Voyage sont normalisés à une longueur de 1, donc la similarité cosinus
# est la même que le produit scalaire.

Si vous voulez trouver les K vecteurs d’embeddings les plus proches sur un grand corpus, nous vous recommandons d’utiliser les capacités intégrées à la plupart des bases de données vectorielles.

​

Puis-je compter le nombre de tokens dans une chaîne avant de l’intégrer ?

Oui ! Vous pouvez le faire avec le code suivant.

import voyageai

vo = voyageai.Client()
total_tokens = vo.count_tokens(["Exemple de texte"])

​

Tarification

Visitez la page de tarification de Voyage pour obtenir les détails de tarification les plus à jour.