Tipos de datos y dimensiones
En esta página
Optimización del tamaño y la calidad
codestral-embed te ofrece un control preciso sobre dos ejes: el número de dimensiones y el tipo de datos (dtype) de los valores. Estos parámetros te permiten ajustar el equilibrio entre la calidad de la búsqueda y los costes de almacenamiento o cómputo.
Esto se vuelve crítico a medida que crecen los volúmenes. Un índice de dos millones de funciones a 1536 dimensiones en coma flotante pesa unos doce gigabytes y ya no cabe en la memoria de una máquina estándar; ese mismo índice en int8 a 768 dimensiones baja de un gigabyte y vuelve a ser consultable en tiempo real. Es esta aritmética, y no una preferencia estética, la que debe guiar tus decisiones.
Los cinco tipos de salida
float (predeterminado)
El tipo float genera valores en coma flotante de 32 bits. Es el formato más preciso, ideal cuando la calidad tiene prioridad sobre el espacio de almacenamiento.
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
response = client.embeddings.create(
model="codestral-embed",
output_dtype="float",
inputs=["def hello(): print('world')"],
)
embedding = response.data[0].embedding
print(f"Type: float, Values: {embedding[:5]}")
# [0.0234375, -0.15625, 0.08984375, 0.01171875, -0.046875]
int8
Cada dimensión es un entero entre -128 y 127. Esto utiliza 4 veces menos memoria que float32 con una pérdida de calidad mínima. Compara los valores mostrados con los del ejemplo anterior: es el mismo vector, cuantizado a una escala más gruesa, y la clasificación de los resultados apenas cambia.
response = client.embeddings.create(
model="codestral-embed",
output_dtype="int8",
inputs=["def hello(): print('world')"],
)
embedding = response.data[0].embedding
print(f"Type: int8, Values: {embedding[:5]}")
# [3, -20, 11, 1, -6]
uint8
Similar a int8, pero con valores entre 0 y 255 (sin signo). Resulta útil para ciertos motores de búsqueda vectorial que solo aceptan valores positivos, una restricción que normalmente descubres durante la integración, no antes.
response = client.embeddings.create(
model="codestral-embed",
output_dtype="uint8",
inputs=["def hello(): print('world')"],
)
embedding = response.data[0].embedding
print(f"Type: uint8, Values: {embedding[:5]}")
# [131, 108, 139, 129, 122]
binary
El formato más compacto. Cada dimensión se cuantiza a 1 bit y, a continuación, los bits se agrupan en paquetes de 8 en valores int8. El vector resultante es 32 veces más pequeño que float: la longitud de 192 que se muestra a continuación corresponde exactamente a las 1536 dimensiones originales, empaquetadas de ocho en ocho.
response = client.embeddings.create(
model="codestral-embed",
output_dtype="binary",
inputs=["def hello(): print('world')"],
)
embedding = response.data[0].embedding
print(f"Type: binary, Length: {len(embedding)}")
# Length: 192 (instead of 1536 in float)
ubinary
Idéntico a binary, pero con valores uint8 (0-255) en lugar de int8 (-128 a 127). La elección entre ambos depende de lo que acepte tu motor de almacenamiento posterior, no de la calidad de la búsqueda.
Impacto en la calidad
Las cifras de compresión no te indican qué estás perdiendo realmente. La siguiente función lo mide con un ejemplo concreto: una prueba de palíndromo, consultada en francés, codificada sucesivamente con tres dtypes. Las similitudes resultantes te dan el orden de magnitud de la degradación en tus propios datos.
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
def compare_dtypes(code_snippet, query):
"""Compara la calidad de la búsqueda por dtype."""
dtypes = ["float", "int8", "uint8"]
results = {}
for dtype in dtypes:
# Codifica el código y la consulta con el mismo dtype
resp_code = client.embeddings.create(
model="codestral-embed",
output_dtype=dtype,
inputs=[code_snippet],
)
resp_query = client.embeddings.create(
model="codestral-embed",
output_dtype=dtype,
inputs=[query],
)
emb_code = np.array(resp_code.data[0].embedding, dtype=np.float32)
emb_query = np.array(resp_query.data[0].embedding, dtype=np.float32)
sim = cosine_similarity([emb_code], [emb_query])[0][0]
results[dtype] = sim
return results
# Prueba
code = "def is_palindrome(s): return s == s[::-1]"
query = "fonction qui vérifie si un mot est un palindrome"
scores = compare_dtypes(code, query)
for dtype, score in scores.items():
print(f" {dtype:8s}: similarity = {score:.4f}")
Ten en cuenta que el código y la consulta siempre se codifican con el mismo dtype dentro del bucle. Mezclar tipos entre el índice y la consulta produciría puntuaciones inconsistentes, y el error es tanto más insidioso porque no genera ninguna excepción.
Reducción de dimensiones
El parámetro output_dimension controla el número de dimensiones del vector. El siguiente bucle itera sobre seis valores y muestra la huella de memoria de un único vector para cada uno, primero en float y luego en int8.
import numpy as np
# Compara diferentes dimensiones
dims = [256, 512, 768, 1024, 1536, 3072]
for dim in dims:
response = client.embeddings.create(
model="codestral-embed",
output_dimension=dim,
inputs=["def quicksort(arr): ..."],
)
emb = response.data[0].embedding
# Tamaño de memoria aproximado
size_float32 = dim * 4 # 4 bytes por float32
size_int8 = dim * 1 # 1 byte por int8
print(f" {dim:5d} dims -> {size_float32:6d} bytes (float) | {size_int8:5d} bytes (int8)")
Salida:
256 dims -> 1024 bytes (float) | 256 bytes (int8)
512 dims -> 2048 bytes (float) | 512 bytes (int8)
768 dims -> 3072 bytes (float) | 768 bytes (int8)
1024 dims -> 4096 bytes (float) | 1024 bytes (int8)
1536 dims -> 6144 bytes (float) | 1536 bytes (int8)
3072 dims -> 12288 bytes (float) | 3072 bytes (int8)
Multiplica la columna de la derecha por tu número real de vectores y obtendrás inmediatamente el dimensionamiento de tu servidor. Entre 3072 dimensiones en float y 768 en int8, la relación es de dieciséis: el mismo índice pasa de doce gigabytes a setecientos cincuenta megabytes.
Guía de selección
Las siguientes configuraciones cubren los escenarios más frecuentes:
| Contexto | Configuración | Motivo |
|---|---|---|
| Prototipo / desarrollo | float + 1536 dims | predeterminado, sin compromisos |
| Producción estándar | float + 1024 dims | buen equilibrio calidad/coste |
| Alto volumen (millones de vectores) | int8 + 768 dims | 4 veces más compacto |
| Búsqueda en tiempo real a gran escala | binary + 1536 dims | prefiltrado rápido y, a continuación, reordenación en float |
| Integrado / edge | int8 + 256 dims | mínimo viable |
La línea de «tiempo real» describe una arquitectura de dos etapas que merece la pena entender: el índice binary, muy ligero, sirve para recuperar unos pocos cientos de candidatos en milisegundos; solo estos candidatos se reordenan después utilizando los vectores float, que son más costosos pero mucho más precisos. Obtienes la velocidad de binary y, en la parte superior de la lista, la precisión de float.
Puntos clave
- codestral-embed admite 5 tipos de salida: float, int8, uint8, binary, ubinary
- El tipo binary es 32 veces más compacto que float, con una pérdida de calidad aceptable para el prefiltrado
- Las primeras dimensiones contienen la mayor parte de la información (representación Matryoshka)
- Combina dimensiones reducidas + int8 para obtener índices muy compactos
- Prueba siempre con tus datos reales antes de elegir los parámetros de producción