Home
Vibe
Studio

Code Embeddings

Les embeddings sont au cœur de nombreux cas d'usage en entreprise, comme les systèmes de recherche, le clustering, l'analyse de code, la classification et une variété d'applications de recherche. Avec les embeddings de code, vous pouvez vectoriser des bases de données de code et des dépôts, et doter les assistants de développement de capacités de recherche de pointe.

API Codestral Embed

API Codestral Embed

Ouvrir dans Colab ↗

Comment générer des embeddings

Pour générer des embeddings de code avec l'API d'embeddings de Mistral AI, vous pouvez effectuer une requête vers le point de terminaison de l'API en spécifiant le modèle d'embedding codestral-embed et en fournissant une liste de textes en entrée. L'API renverra alors les embeddings correspondants sous forme de vecteurs numériques, qui pourront être utilisés pour des analyses ou traitements ultérieurs dans des applications NLP.

Nous fournissons également les paramètres output_dtype et output_dimension qui vous permettent de contrôler le type et la dimension de vos embeddings.

Output DType

Output DType

output_dtype vous permet de sélectionner la précision et le format des embeddings, vous permettant d'obtenir des embeddings avec le niveau de précision numérique et de représentation souhaité.

Les dtypes acceptés sont :

  • float (par défaut) : Une liste de nombres à virgule flottante simple précision 32 bits (4 octets). Offre la plus haute précision et la meilleure exactitude de récupération.
  • int8 : Une liste d'entiers 8 bits (1 octet) allant de -128 à 127.
  • uint8 : Une liste d'entiers 8 bits (1 octet) allant de 0 à 255.
  • binary : Une liste d'entiers 8 bits qui représentent des valeurs d'embedding quantifiées sur un bit et compressées en bits, utilisant le type int8. La longueur de la liste d'entiers retournée est 1/8 de output_dimension. Ce type utilise la méthode binaire décalée.
  • ubinary : Similaire à binary, mais utilise le type uint8 pour les valeurs d'embedding quantifiées sur un bit et compressées en bits.
Output Dimension

Output Dimension

output_dimension vous permet de sélectionner une dimension spécifique pour l'embedding, vous permettant d'obtenir un embedding de la dimension de votre choix, par défaut 1536 avec une valeur maximale de 3072.

Pour toute dimension cible entière n, vous pouvez choisir de conserver les n premières dimensions. Ces dimensions sont ordonnées par pertinence, et les n premières sont sélectionnées pour un compromis optimal entre qualité et coût.

Usage

Usage

Voici un exemple d'utilisation de l'API d'embeddings pour générer des embeddings pour une liste de textes liés au code.

import os
from mistralai.client import Mistral

api_key = os.environ["MISTRAL_API_KEY"]
model = "codestral-embed"

client = Mistral(api_key=api_key)

embeddings_batch_response = client.embeddings.create(
    model=model,
    # output_dtype="binary",
    # output_dimension=512,
    inputs=[
        "Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target. You may assume that each input would have exactly one solution, and you may not use the same element twice. You can return the answer in any order. Example 1: Input: nums = [2,7,11,15], target = 9 Output: [0,1] Explanation: Because nums[0] + nums[1] == 9, we return [0, 1]. Example 2: Input: nums = [3,2,4], target = 6 Output: [1,2] Example 3: Input: nums = [3,3], target = 6 Output: [0,1] Constraints: 2 <= nums.length <= 104 -109 <= nums[i] <= 109 -109 <= target <= 109 Only one valid answer exists.",
        "class Solution: def twoSum(self, nums: List[int], target: int) -> List[int]: d = {} for i, x in enumerate(nums): if (y := target - x) in d: return [d[y], i] d[x] = i"
      ],
)

Examinons la longueur du premier embedding :

len(embeddings_batch_response.data[0].embedding)

Cela renvoie 1553, ce qui signifie que la dimension de notre embedding est 1553. Le modèle codestral-embed génère des vecteurs d'embedding jusqu'à des dimensions de 3072 pour chaque chaîne de texte, quelle que soit la longueur du texte. Vous pouvez réduire la dimension en utilisant output_dimension si nécessaire. Il convient de noter que bien que des embeddings de dimension supérieure puissent mieux capturer l'information textuelle et améliorer les performances des tâches NLP, ils peuvent nécessiter davantage de ressources et entraîner une latence accrue ainsi qu'une utilisation de la mémoire plus importante pour le stockage et le traitement de ces embeddings. Ce compromis entre performance et ressources de calcul doit être pris en compte lors de la conception de systèmes NLP s'appuyant sur des embeddings de texte.

Exemples d'utilisation

Exemples d'utilisation

Vous trouverez ci-dessous quelques exemples d'utilisation de l'API Codestral Embeddings et différents cas d'usage.

Dans le domaine des embeddings de texte, les textes ayant des significations ou des contextes similaires ont tendance à se situer à proximité les uns des autres dans cet espace, mesurée par la distance entre leurs vecteurs. Cela s'explique par le fait que le modèle a appris à regrouper les textes sémantiquement liés durant le processus d'entraînement.

Examinons un exemple simple. Pour simplifier le travail avec les embeddings de texte, nous pouvons encapsuler l'API d'embedding dans cette fonction :

from sklearn.metrics.pairwise import euclidean_distances
from datasets import load_dataset

def get_code_embedding(inputs):
    embeddings_batch_response = client.embeddings.create(
        model=model,
        inputs=inputs
    )
    return embeddings_batch_response.data[0].embedding

Supposons que nous ayons deux extraits de code : l'un concernant two sum et l'autre concernant reverse integer. Nous voulons déterminer la similarité de chaque extrait de code avec le code de référence palindrome number. Nous pouvons constater que la distance entre les embeddings du code de référence et les embeddings reverse est inférieure à la distance entre les embeddings du code de référence et les embeddings du code two sum.

Entrées :

{
    "code_snippets": {
      "two_sum_solution": "classSolution:deftwoSum(self,nums:List[int],target:int)->List[int]:d={}fori,xinenumerate(nums):if(y:=target-x)ind:return[d[y],i]d[x]=i",
      "reverse_integer_solution": "classSolution:defreverse(self,x:int)->int:ans=0mi,mx=-(2**31),2**31-1whilex:ifans<mi//10+1orans>mx//10:return0y=x%10ifx<0andy>0:y-=10a",
    },
    "reference_code_snippet": "classSolution:defisPalindrome(self,x:int)->bool:ifx<0or(xandx%10==0):returnFalsey=0whiley<x:y=y*10+x%10x//=10returnxin(y,y//10)"

}
dataset = load_dataset("newfacade/LeetCodeDataset")

two_sum_solution = dataset["train"][0]["completion"]
reverse_integer_solution = dataset["train"][6]["completion"]
palindrome_number_solution = dataset["train"][8]["completion"]

def remove_whitespace(code):
    return code.replace("\n", "").replace("\t", "").replace(" ", "")

two_sum_solution_clean = remove_whitespace(two_sum_solution)
reverse_integer_solution_clean = remove_whitespace(reverse_integer_solution)
palindrome_number_solution_clean = remove_whitespace(palindrome_number_solution)

code_snippets = [
    two_sum_solution_clean,
    reverse_integer_solution_clean
]

embeddings = [get_code_embedding([t]) for t in code_snippets]

reference_code_snippet = palindrome_number_solution
reference_embedding = get_code_embedding([reference_code_snippet])

for t, e in zip(code_snippets, embeddings):
    distance = euclidean_distances([e], [reference_embedding])
    print(t, distance)

Dans notre exemple ci-dessus, nous avons utilisé la distance euclidienne pour mesurer la distance entre les vecteurs d'embeddings (notez que puisque les embeddings Mistral AI sont de norme 1, la similarité cosinus, le produit scalaire ou la distance euclidienne sont tous équivalents).

Cookbooks

Cookbooks

Pour plus d'informations et de guides sur l'utilisation de notre SDK d'embeddings, nous proposons les cookbooks suivants :