Typy danych i wymiary
Na tej stronie
Optymalizacja rozmiaru i jakości
codestral-embed daje ci precyzyjną kontrolę nad dwoma osiami: liczbą wymiarów oraz typem danych (dtype) wartości. Parametry te pozwalają dostosować kompromis między jakością wyszukiwania a kosztami przechowywania lub obliczeń.
Kwestia ta staje się kluczowa wraz ze wzrostem wolumenów. Indeks dwóch milionów funkcji w formacie 1536 wymiarów typu float zajmuje około dwunastu gigabajtów i nie mieści się już w pamięci standardowej maszyny; ten sam indeks w formacie int8 o 768 wymiarach schodzi poniżej jednego gigabajta i ponownie umożliwia zapytania w czasie rzeczywistym. To właśnie ta arytmetyka, a nie estetyczne preferencje, powinna kierować twoimi wyborami.
Pięć typów wyjściowych
float (domyślny)
Typ float generuje 32-bitowe wartości zmiennoprzecinkowe. Jest to format najbardziej precyzyjny, idealny, gdy jakość ma pierwszeństwo przed miejscem na dysku.
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
Każdy wymiar jest liczbą całkowitą z zakresu od -128 do 127. Zajmuje to 4 razy mniej pamięci niż float32 przy minimalnej utracie jakości. Porównaj wyświetlane wartości z tymi z poprzedniego przykładu: to ten sam wektor, skwantowany do груbszej skali, a ranking wyników pozostaje niemal niezmieniony.
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
Podobny do int8, ale z wartościami od 0 do 255 (bez znaku). Przydatny dla niektórych silników wyszukiwania wektorowego, które akceptują wyłącznie wartości dodatnie – ograniczenie to zazwyczaj odkrywasz podczas integracji, a nie przed nią.
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
Najbardziej zwarty format. Każdy wymiar jest kwantowany do 1 bita, a następnie bity są grupowane w pakiety po 8 do wartości int8. Wynikowy wektor jest 32 razy mniejszy niż float – długość 192 wyświetlona poniżej odpowiada dokładnie oryginalnym 1536 wymiarom, spakowanym po osiem.
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
Identyczny jak binary, ale z wartościami uint8 (0-255) zamiast int8 (-128 do 127). Wybór między nimi zależy od tego, co akceptuje twój docelowy silnik przechowujący dane, a nie od jakości wyszukiwania.
Wpływ na jakość
Liczby dotyczące kompresji nie mówią ci, co dokładnie tracisz. Poniższa funkcja mierzy to na konkretnym przykładzie: test palindromu, zapytanie w języku francuskim, kodowane kolejno trzema różnymi typami dtype. Uzyskane podobieństwa dają ci rząd wielkości degradacji na twoich własnych danych.
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
def compare_dtypes(code_snippet, query):
"""Compare search quality by dtype."""
dtypes = ["float", "int8", "uint8"]
results = {}
for dtype in dtypes:
# Encode code and query with the same 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
# Test
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}")
Zauważ, że kod i zapytanie są zawsze kodowane tym samym typem dtype wewnątrz pętli. Mieszanie typów między indeksem a zapytaniem dałoby niespójne wyniki, a błąd tym bardziej podstępny, że nie zgłasza żadnego wyjątku.
Redukcja wymiarów
Parametr output_dimension kontroluje liczbę wymiarów w wektorze. Poniższa pętla iteruje przez sześć wartości i wyświetla footprint pamięciowy pojedynczego wektora dla każdej z nich, najpierw w formacie float, a następnie int8.
import numpy as np
# Compare different dimensions
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
# Approximate memory size
size_float32 = dim * 4 # 4 bytes per float32
size_int8 = dim * 1 # 1 byte per int8
print(f" {dim:5d} dims -> {size_float32:6d} bytes (float) | {size_int8:5d} bytes (int8)")
Wyjście:
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)
Pomnóż prawą kolumnę przez swoją rzeczywistą liczbę wektorów, a natychmiast otrzymasz sizing serwera. Między 3072 wymiarami w formacie float a 768 w formacie int8 stosunek wynosi szesnaście: ten sam indeks przechodzi z dwunastu gigabajtów do siedmiuset pięćdziesięciu megabajtów.
Przewodnik wyboru
Poniższe konfiguracje obejmują najczęstsze scenariusze:
| Kontekst | Konfiguracja | Powód |
|---|---|---|
| Prototyp / rozwój | float + 1536 wymiarów | domyślnie, bez kompromisów |
| Standardowa produkcja | float + 1024 wymiary | dobry balans jakość/koszt |
| Duży wolumen (miliony wektorów) | int8 + 768 wymiarów | 4 razy bardziej zwarte |
| Wyszukiwanie w czasie rzeczywistym na dużą skalę | binary + 1536 wymiarów | szybkie wstępne filtrowanie, potem ponowny ranking w float |
| Embedded / edge | int8 + 256 wymiarów | absolutne minimum |
Linia „czas rzeczywisty“ opisuje dwuetapową architekturę, którą warto zrozumieć: bardzo lekki indeks binary służy do pobrania kilkuset kandydatów w milisekundach; dopiero ci kandydaci są następnie ponownie rankowani przy użyciu wektorów float, które są kosztowniejsze, ale znacznie dokładniejsze. Uzyskujesz szybkość formatu binary i, na szczycie listy, precyzję formatu float.
Kluczowe wnioski
- codestral-embed obsługuje 5 typów wyjściowych: float, int8, uint8, binary, ubinary
- Typ binary jest 32 razy bardziej zwarty niż float, z akceptowalną utratą jakości przy wstępnym filtrowaniu
- Pierwsze wymiary zawierają najwięcej informacji (reprezentacja Matryoszki)
- Łącz zredukowane wymiary z int8, aby uzyskać bardzo zwarte indeksy
- Zawsze testuj na swoich rzeczywistych danych przed wyborem parametrów produkcyjnych