Embeddings

Os modelos de embedding dependem de redes neurais poderosas para capturar e comprimir o contexto semântico, de forma semelhante aos modelos generativos. A equipe de pesquisadores de IA experientes da Voyage otimiza cada componente do processo de embedding, incluindo:

• Arquitetura do modelo
• Coleta de dados
• Funções de perda
• Seleção do otimizador

Saiba mais sobre a abordagem técnica da Voyage no blog da Voyage AI.

Para embeddings de uso geral, os modelos recomendados são:

• voyage-4-large: Melhor qualidade
• voyage-4-lite: Menor latência e custo
• voyage-4: Desempenho equilibrado

Para recuperação, use o parâmetro input_type para especificar se o texto é do tipo consulta ou documento.

Modelos específicos de domínio:

• Tarefas jurídicas: voyage-law-2
• Código e documentação de programação: voyage-code-3
• Tarefas relacionadas a finanças: voyage-finance-2

Para recuperação em nível de chunk e em nível de documento: voyage-context-4

Você pode usar os embeddings da Voyage com similaridade por produto escalar, similaridade de cosseno ou distância euclidiana. Para uma explicação sobre similaridade de embeddings, consulte este guia de similaridade vetorial.

Os embeddings da Voyage AI são normalizados para comprimento 1, o que significa que:

• A similaridade de cosseno é equivalente à similaridade por produto escalar, sendo que esta última pode ser calculada mais rapidamente.
• A similaridade de cosseno e a distância euclidiana resultam em classificações idênticas.

Consulte o guia de tokenização da Voyage.

Para todas as tarefas e casos de uso de recuperação (por exemplo, RAG), use o parâmetro input_type para especificar se o texto de entrada é uma consulta ou um documento. Não omita input_type nem defina input_type=None. Especificar se o texto de entrada é uma consulta ou um documento pode criar melhores representações vetoriais densas para recuperação, o que pode levar a uma melhor qualidade de recuperação.

Ao usar o parâmetro input_type, prompts especiais são adicionados ao início do texto de entrada antes da geração do embedding. Especificamente:

📘 Prompts associados ao input_type

• Para uma consulta, o prompt é “Represent the query for retrieving supporting documents: “.
• Para um documento, o prompt é “Represent the document for retrieval: “.
• Exemplo
  • Quando input_type="query", uma consulta como "When is Apple's conference call scheduled?" se tornará "Represent the query for retrieving supporting documents: When is Apple's conference call scheduled?"
  • Quando input_type="document", uma consulta como "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." se tornará "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."

O voyage-large-2-instruct, como o nome sugere, é treinado para responder a instruções adicionais que são adicionadas ao início do texto de entrada. Para classificação, clusterização ou outras subtarefas do MTEB, use as instruções do voyage-large-2-instruct.

A quantização em embeddings converte valores de alta precisão, como números de ponto flutuante de precisão simples de 32 bits, em formatos de menor precisão, como inteiros de 8 bits ou valores binários de 1 bit, reduzindo armazenamento, memória e custos em 4x e 32x, respectivamente. Os modelos da Voyage compatíveis permitem a quantização especificando o tipo de dado de saída com o parâmetro output_dtype:

• float: Cada embedding retornado é uma lista de números de ponto flutuante de precisão simples de 32 bits (4 bytes). Este é o padrão e fornece a maior precisão / exatidão de recuperação.
• int8 e uint8: Cada embedding retornado é uma lista de inteiros de 8 bits (1 byte) variando de -128 a 127 e de 0 a 255, respectivamente.
• binary e ubinary: Cada embedding retornado é uma lista de inteiros de 8 bits que representam valores de embedding de bit único, quantizados e empacotados em bits: int8 para binary e uint8 para ubinary. O comprimento da lista de inteiros retornada é 1/8 da dimensão real do embedding. O tipo binary usa o método de binário com deslocamento (offset binary), sobre o qual você pode saber mais nas perguntas frequentes sobre embeddings.

Exemplo de quantização binária

Considere os seguintes oito valores de embedding: -0.03955078, 0.006214142, -0.07446289, -0.039001465, 0.0046463013, 0.00030612946, -0.08496094 e 0.03994751. Com a quantização binária, valores menores ou iguais a zero serão quantizados para um zero binário, e valores positivos para um um binário, resultando na seguinte sequência binária: 0, 1, 0, 0, 1, 1, 0, 1. Esses oito bits são então empacotados em um único inteiro de 8 bits, 01001101 (com o bit mais à esquerda como o bit mais significativo).

• ubinary: A sequência binária é convertida diretamente e representada como o inteiro sem sinal (uint8) 77.
• binary: A sequência binária é representada como o inteiro com sinal (int8) -51, calculado usando o método de binário com deslocamento (77 - 128 = -51).

O aprendizado Matryoshka cria embeddings com representações do mais grosseiro ao mais refinado dentro de um único vetor. Os modelos da Voyage, como o voyage-code-3, que suportam múltiplas dimensões de saída geram esses embeddings Matryoshka. Você pode truncar esses vetores mantendo o subconjunto inicial de dimensões. Por exemplo, o código Python a seguir demonstra como truncar vetores de 1024 dimensões para 256 dimensões:

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()

# Gera vetores voyage-code-3, que por padrão são números de ponto flutuante de 1024 dimensões
embd = vo.embed(["Sample text 1", "Sample text 2"], model="voyage-code-3").embeddings

# Define uma dimensão menor
short_dim = 256

# Redimensiona e normaliza os vetores para a dimensão menor
resized_embd = embd_normalize(np.array(embd)[:, :short_dim]).tolist()