Embeddings

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

• L'architecture du modèle
• La collecte de données
• Les fonctions de perte
• Le choix de l'optimiseur

Apprenez-en davantage sur l'approche technique de Voyage sur le blog de Voyage AI.

Pour l'embedding généraliste, les modèles recommandés sont :

• voyage-4-large : meilleure qualité
• voyage-4-lite : latence et coût les plus faibles
• voyage-4 : performances équilibrées

Pour la recherche, utilisez le paramètre input_type pour spécifier si le texte est de type requête ou document.

Modèles spécifiques à un domaine :

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

Pour la recherche au niveau du segment et au niveau du document : voyage-context-4

Vous pouvez utiliser les embeddings Voyage avec la similarité par produit scalaire, la similarité cosinus ou la distance euclidienne. Pour une explication de la similarité des embeddings, consultez ce guide sur la similarité vectorielle.

Les embeddings Voyage AI sont normalisés à une longueur de 1, ce qui signifie que :

• La similarité cosinus est équivalente à la similarité par produit scalaire, cette dernière pouvant être calculée plus rapidement.
• La similarité cosinus et la distance euclidienne produisent des classements identiques.

Consultez le guide de tokenisation de Voyage.

Pour toutes les tâches et tous les cas d'utilisation de recherche (par exemple, le RAG), utilisez le paramètre input_type pour spécifier si le texte d'entrée est une requête ou un document. N'omettez pas input_type et ne définissez pas input_type=None. Spécifier si le texte d'entrée est une requête ou un document permet de créer de meilleures représentations vectorielles denses pour la recherche, ce qui peut conduire à une meilleure qualité de recherche.

Lors de l'utilisation du paramètre input_type, des prompts spéciaux sont ajoutés au début du texte d'entrée avant l'embedding. Plus précisément :

📘 Prompts associés à input_type

• Pour une requête, le prompt est « Represent the query for retrieving supporting documents: ».
• Pour un document, le prompt est « Represent the document for retrieval: ».
• Exemple
  • Lorsque input_type="query", une requête telle que « When is Apple's conference call scheduled? » deviendra « Represent the query for retrieving supporting documents: When is Apple's conference call scheduled? »
  • Lorsque input_type="document", une requête telle que « 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. » deviendra « Represent the document for retrieval: 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. »

voyage-large-2-instruct, comme son nom l'indique, est entraîné pour répondre à des instructions supplémentaires ajoutées au début du texte d'entrée. Pour la classification, le clustering ou d'autres sous-tâches MTEB, utilisez les instructions de voyage-large-2-instruct.

La quantification des embeddings convertit des valeurs de haute précision, telles que des nombres à virgule flottante simple précision sur 32 bits, en formats de précision inférieure tels que des entiers sur 8 bits ou des valeurs binaires sur 1 bit, réduisant ainsi le stockage, la mémoire et les coûts d'un facteur 4 et 32, respectivement. Les modèles Voyage pris en charge permettent la quantification en spécifiant le type de données de sortie avec le paramètre output_dtype :

• float : chaque embedding renvoyé est une liste de nombres à virgule flottante simple précision sur 32 bits (4 octets). Il s'agit de la valeur par défaut, qui offre la précision / l'exactitude de recherche la plus élevée.
• int8 et uint8 : chaque embedding renvoyé est une liste d'entiers sur 8 bits (1 octet) allant respectivement de -128 à 127 et de 0 à 255.
• binary et ubinary : chaque embedding renvoyé est une liste d'entiers sur 8 bits qui représentent des valeurs d'embedding sur un seul bit, quantifiées et compactées par bits : int8 pour binary et uint8 pour ubinary. La longueur de la liste d'entiers renvoyée est égale à 1/8 de la dimension réelle de l'embedding. Le type binaire utilise la méthode du binaire décalé, sur laquelle vous pouvez en apprendre davantage dans la FAQ sur les embeddings.

Exemple de quantification binaire

Considérez les huit valeurs d'embedding suivantes : -0.03955078, 0.006214142, -0.07446289, -0.039001465, 0.0046463013, 0.00030612946, -0.08496094 et 0.03994751. Avec la quantification binaire, les valeurs inférieures ou égales à zéro seront quantifiées en un zéro binaire, et les valeurs positives en un un binaire, ce qui donne la séquence binaire suivante : 0, 1, 0, 0, 1, 1, 0, 1. Ces huit bits sont ensuite compactés en un seul entier sur 8 bits, 01001101 (le bit le plus à gauche étant le bit de poids fort).

• ubinary : la séquence binaire est directement convertie et représentée sous forme d'entier non signé (uint8) 77.
• binary : la séquence binaire est représentée sous forme d'entier signé (int8) -51, calculé à l'aide de la méthode du binaire décalé (77 - 128 = -51).

L'apprentissage Matryoshka crée des embeddings avec des représentations allant du grossier au fin au sein d'un seul vecteur. Les modèles Voyage, tels que voyage-code-3, qui prennent en charge plusieurs dimensions de sortie génèrent de tels embeddings Matryoshka. Vous pouvez tronquer ces vecteurs en conservant le sous-ensemble initial de dimensions. Par exemple, le code Python suivant montre comment tronquer des vecteurs de 1024 dimensions à 256 dimensions :

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-3, qui sont par défaut des nombres à virgule flottante de dimension 1024
embd = vo.embed(["Sample text 1", "Sample text 2"], model="voyage-code-3").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()