Embeddings

Les embeddings de texte sont des représentations numériques du texte qui permettent de mesurer la similarité sémantique. Ce guide présente les embeddings, leurs applications et comment utiliser les modèles d’embedding pour des tâches comme la recherche, les recommandations et la détection d’anomalies.

Avant d’implémenter les embeddings

Lors du choix d’un fournisseur d’embeddings, il y a plusieurs facteurs à considérer selon vos besoins et 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 pour le domaine que vous souhaitez encoder. Des données plus volumineuses ou plus spécifiques au domaine produisent généralement de meilleurs embeddings dans le domaine
• Performance d’inférence : vitesse de recherche d’embedding et latence de bout en bout. C’est une considération particulièrement importante pour les déploiements à grande échelle en production
• Personnalisation : options pour poursuivre 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. Un fournisseur d’embeddings qui offre une grande variété d’options et de capacités englobant toutes les considérations ci-dessus est Voyage AI.

Voyage AI crée des modèles d’embedding à la pointe de la technologie et propose des modèles personnalisés pour des domaines industriels spécifiques comme la finance et la santé, ou des modèles affinés sur mesure pour des clients individuels.

Le reste de ce guide concerne Voyage AI, mais nous vous encourageons à évaluer différents fournisseurs d’embeddings pour trouver celui qui correspond le mieux à votre cas d’utilisation spécifique.

Modèles disponibles

Voyage recommande l’utilisation des modèles d’embedding de texte suivants :

Modèle	Longueur de contexte	Dimension d’embedding	Description
voyage-3-large	32 000	1024 (par défaut), 256, 512, 2048	La meilleure qualité de récupération générale et multilingue.
voyage-3	32 000	1024	Optimisé pour la qualité de récupération générale et multilingue. Voir le billet de blog pour plus de détails.
voyage-3-lite	32 000	512	Optimisé pour la latence et le coût. Voir le billet de blog pour plus de détails.
voyage-code-3	32 000	1024 (par défaut), 256, 512, 2048	Optimisé pour la récupération de code. Voir le billet de blog pour plus de détails.
voyage-finance-2	32 000	1024	Optimisé pour la récupération et le RAG en finance. Voir le billet de blog pour plus de détails.
voyage-law-2	16 000	1024	Optimisé pour la récupération et le RAG juridique et long contexte. Performances également améliorées dans tous les domaines. Voir le billet de blog pour plus de détails.

De plus, les modèles d’embedding multimodaux suivants sont recommandés :

Modèle	Longueur de contexte	Dimension d’embedding	Description
voyage-multimodal-3	32000	1024	Modèle d’embedding multimodal riche qui peut vectoriser du texte entrelacé et des images riches en contenu, comme des captures d’écran de PDF, des diapositives, des tableaux, des figures, et plus encore. Voir le billet de blog pour plus de détails.

Besoin d’aide pour décider quel modèle d’embedding de texte utiliser ? Consultez la FAQ.

Démarrer avec Voyage AI

Pour accéder aux embeddings 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 obtenir les embeddings soit en utilisant le package Python voyageai officiel, soit via des requêtes HTTP, comme décrit ci-dessous.

Package Python Voyage

Le package voyageai peut être installé en utilisant la commande suivante :

pip install -U voyageai

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

import voyageai

vo = voyageai.Client()
# Ceci utilisera automatiquement la variable d'environnement VOYAGE_API_KEY.
# Alternativement, vous pouvez 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-3", input_type="document")
print(result.embeddings[0])
print(result.embeddings[1])

result.embeddings sera une liste de deux vecteurs d’embedding, chacun contenant 1024 nombres à virgule flottante. Après avoir exécuté le code ci-dessus, les deux embeddings seront affiché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 également spécifier quelques autres arguments pour la fonction embed(). Vous pouvez en savoir plus sur la spécification ici

API HTTP Voyage

Vous pouvez également obtenir des embeddings en interrogeant 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-3"
  }'

La réponse que vous obtiendrez 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-3",
  "usage": {
    "total_tokens": 10
  }
}

Vous pouvez en savoir plus sur le point de terminaison d’embedding dans la documentation Voyage

AWS Marketplace

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

Exemple de démarrage rapide

Maintenant que nous savons comment obtenir des embeddings, voyons un bref exemple.

Supposons que nous ayons un petit corpus de six documents à partir desquels effectuer une recherche

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 dans les plantes convertit l'énergie lumineuse en glucose et produit l'oxygène essentiel.",
    "Les innovations du 20e siècle, des radios aux smartphones, étaient centrées sur les avancées électroniques.",
    "Les rivières fournissent eau, irrigation et habitat pour les espèces aquatiques, vitaux pour les é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’embedding

import voyageai

vo = voyageai.Client()

# Encoder les documents
doc_embds = vo.embed(
    documents, model="voyage-3", input_type="document"
).embeddings

Les embeddings nous permettront de faire une recherche sémantique / récupération dans l’espace vectoriel. Étant donné une requête exemple,

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

nous la convertissons en embedding, et effectuons une recherche du plus proche voisin pour trouver le document le plus pertinent basé sur la distance dans l’espace d’embedding.

import numpy as np

# Encoder la requête
query_embd = vo.embed(
    [query], model="voyage-3", input_type="query"
).embeddings[0]

# Calculer la similarité
# Les embeddings Voyage sont normalisés à la longueur 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 encoder respectivement le document et la requête. Plus de spécifications peuvent être trouvées ici.

La sortie serait le 5e 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.

Si vous recherchez un ensemble détaillé de guides pratiques sur la façon de faire du RAG avec des embeddings, y compris les bases de données vectorielles, consultez notre guide pratique RAG.

FAQ

Pourquoi les embeddings Voyage ont-ils une qualité supérieure ?

Les modèles d’embedding s’appuient sur de puissants réseaux de neurones pour capturer et compresser le contexte sémantique, similaires aux modèles génératifs. L’équipe de Voyage, composée de chercheurs en IA expérimentés, optimise chaque composant du processus d’embedding, notamment :

• L’architecture du modèle
• La collecte de données
• Les fonctions de perte
• La sélection de l’optimiseur

En savoir plus sur l’approche technique de Voyage sur leur blog.

Quels modèles d'embedding sont disponibles et lequel devrais-je utiliser ?

Pour l’embedding à usage général, nous recommandons :

• voyage-3-large : Meilleure qualité
• voyage-3-lite : Latence et coût les plus bas
• voyage-3 : Performance équilibrée avec une qualité de récupération supérieure à un prix compétitif

Pour les tâches de récupération, utilisez le paramètre input_type pour spécifier le type de requête ou de document.

Modèles spécifiques au domaine :

• Tâches juridiques : voyage-law-2
• Code et documentation de programmation : voyage-code-3
• Tâches liées à la finance : voyage-finance-2

Quelle fonction de similarité devrais-je utiliser ?

Les embeddings Voyage prennent en charge :

• La similarité par produit scalaire
• La similarité cosinus
• La distance euclidienne

Puisque les embeddings Voyage AI sont normalisés à la longueur 1 :

• La similarité cosinus est égale à la similarité par produit scalaire (le calcul du produit scalaire est plus rapide)
• La similarité cosinus et la distance euclidienne produisent des classements identiques

En savoir plus sur la similarité des embeddings dans le guide de Pinecone.

Comment devrais-je utiliser le paramètre input_type ?

Pour les tâches de récupération, y compris le RAG, spécifiez toujours input_type comme “query” ou “document”. Cette optimisation améliore la qualité de récupération grâce à un préfixage de prompt spécialisé :

Pour les requêtes :

Représenter la requête pour récupérer les documents de support : [votre requête]

Pour les documents :

Représenter le document pour la récupération : [votre document]

Ne jamais omettre input_type ou le définir à None pour les tâches de récupération.

Pour la classification, le clustering ou d’autres tâches MTEB utilisant `voyage-large-2-inst

ruct`, suivez les instructions dans notre dépôt GitHub.

Quelles options de quantification sont disponibles ?

La quantification réduit le stockage, la mémoire et les coûts en convertissant les valeurs de haute précision en formats de précision inférieure. Types de données de sortie disponibles (output_dtype) :

Type	Description	Réduction de taille
float	Nombres à virgule flottante simple précision 32 bits (par défaut)	Aucune
int8/uint8	Entiers 8 bits (-128 à 127 / 0 à 255)	4x
binary/ubinary	Valeurs sur un bit compactées	32x

Les types binaires utilisent des entiers 8 bits pour représenter les bits compactés, avec binary utilisant la méthode binaire décalée.

Exemple : La quantification binaire convertit huit valeurs d’embedding en un seul entier 8 bits :

Original : [-0.03955078, 0.006214142, -0.07446289, -0.039001465, 
           0.0046463013, 0.00030612946, -0.08496094, 0.03994751]
Binaire :  [0, 1, 0, 0, 1, 1, 0, 1] → 01001101
uint8 :    77
int8 :     -51 (utilisant le binaire décalé)

Comment puis-je tronquer les embeddings Matryoshka ?

Les embeddings Matryoshka contiennent des représentations grossières à fines qui peuvent être tronquées en conservant les dimensions principales. Voici comment tronquer des vecteurs 1024D à 256D :

import voyageai
import numpy as np

def embd_normalize(v: np.ndarray) -> np.ndarray:
    """
    Normalise les vecteurs d'embedding à la longueur unitaire.
    Lève ValueError si une ligne a une norme nulle.
    """
    row_norms = np.linalg.norm(v, axis=1, keepdims=True)
    if np.any(row_norms == 0):
        raise ValueError("Impossible de normaliser les lignes avec une norme nulle.")
    return v / row_norms

# Initialiser le client
vo = voyageai.Client()

# Générer des vecteurs 1024D
embd = vo.embed(['Exemple de texte 1', 'Exemple de texte 2'], 
               model='voyage-code-3').embeddings

# Tronquer à 256D
short_dim = 256
resized_embd = embd_normalize(
    np.array(embd)[:, :short_dim]
).tolist()

Tarification

Visitez la page de tarification de Voyage pour les détails de prix les plus récents.