Dimensões flexíveis e quantização

Como funcionam as incorporações doMatryoshka

Com o aprendizado Matryoshka, uma única incorporação contém uma família aninhada de incorporações de vários comprimentos. Por exemplo, uma incorporação do Voyage 2048contém incorporações válidas em vários comprimentos mais curtos:

• As primeiras 256 dimensões formam uma incorporação válida 256dimensional

• As primeiras 512 dimensões formam uma incorporação válida 512dimensional

• As primeiras 1024 dimensões formam uma incorporação válida 1024dimensional

• Todas as 2048 dimensões da incorporação de fidelidade total

Cada versão mais curta fornece uma qualidade de recuperação um pouco inferior à da incorporação completa, mas exige menos armazenamento e recursos computacionais.

Como truncar incorporações Matryoshka

Truncar incorporações Matryoshka mantendo o subconjunto principal de dimensões. O exemplo seguinte demonstra como truncar vetores dimensionais 1024para dimensões 256:

import voyageai
import numpy as np
def embd_normalize(v: np.ndarray) -> np.ndarray:
    # Normalize rows of a 2D array to unit vectors
    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()
# Generate 1024-dimensional embeddings
embd = vo.embed(['Sample text 1', 'Sample text 2'], model='voyage-4-large').embeddings
# Truncate to 256 dimensions and normalize
short_dim = 256
resized_embd = embd_normalize(np.array(embd)[:, :short_dim]).tolist()

Como funciona a Quantização

A quantização reduz a precisão das incorporações representando cada dimensão com menos bits do que o formato padrão de ponto flutuante de 32bits. Em vez de usar 4 bytes por dimensão, as incorporações quantizadas usam:

• 8-bit inteiros (1 byte por dimensão): reduz o armazenamento em 4x

• Binário (1 bit por dimensão): reduz o armazenamento em 32x

Apesar dessa redução drástica no tamanho, modelos treinamento com reconhecimento de quantização, como o do Voyage, mantêm alta qualidade de recuperação. Os modelos Voyage suportados habilitam a quantização especificando o tipo de dados de saída com o parâmetro output_dtype:

Binário de compensação

Binário de deslocamento é um método para representar inteiros assinados em formato binário. A Voyage AI usa esse método para o binary tipo de saída para codificar incorporações binárias compactadas como inteiros assinadosint8 ().

O método binário de deslocamento funciona adicionando ou subtraindo um valor de deslocamento:

• Ao converter para binário: Adicione 128 ao número inteiro assinado antes de codificar

• Ao converter de binário: subtraia 128 do número inteiro após a decodificação

Para números inteiros com sinal de 8bits (faixa de -128 a 127), o deslocamento é sempre 128.

Como usar a Quantização com a Voyage AI

Você pode converter incorporações flutuantes para formato binário manualmente ou descompactar incorporações binárias de volta para bits individuais. Os exemplos a seguir demonstram ambas as operações:

import numpy as np
import voyageai
vo = voyageai.Client()
# Generate float embeddings
embd_float = vo.embed('Sample text 1', model='voyage-4-large', output_dimension=2048).embeddings[0]
# Compute 512-dimensional bit-packed binary and ubinary embeddings from 2048-dimensional float embeddings
embd_binary_calc = (np.packbits(np.array(embd_float) > 0, axis=0) - 128).astype(np.int8).tolist() # Quantize, binary offset
embd_binary_512_calc = embd_binary_calc[0:64] # Truncate. Binary is 1/8 length of embedding dimension.
embd_ubinary_calc = (np.packbits(np.array(embd_float) > 0, axis=0)).astype(np.uint8).tolist() # Quantize, binary offset
embd_ubinary_512_calc = embd_ubinary_calc[0:64] # Truncate. Binary is 1/8 length of embedding dimension.

import numpy as np
import voyageai
vo = voyageai.Client()
# Generate binary embeddings
embd_binary = vo.embed('Sample text 1', model='voyage-4-large', output_dtype='binary', output_dimension=2048).embeddings[0]
embd_ubinary = vo.embed('Sample text 1', model='voyage-4-large', output_dtype='ubinary', output_dimension=2048).embeddings[0]
# Unpack bits
embd_binary_bits = [format(x, f'08b') for x in np.array(embd_binary) + 128] # List of (bits) strings
embd_binary_unpacked = [bit == '1' for bit in ''.join(embd_binary_bits)] # List of booleans
embd_ubinary_bits = [format(x, f'08b') for x in np.array(embd_ubinary)] # List of (bits) strings
embd_ubinary_unpacked = [bit == '1' for bit in ''.join(embd_ubinary_bits)] # List of booleans