Przejdź do głównej treści
Polski— Wybierz język
Menu

Typy danych i wymiary

Lekcja 7 z 18 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Optymalizacja rozmiaru i jakości
  2. Pięć typów wyjściowych
  3. Wpływ na jakość
  4. Redukcja wymiarów
  5. Przewodnik wyboru
  6. Kluczowe wnioski

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:

KontekstKonfiguracjaPowód
Prototyp / rozwójfloat + 1536 wymiarówdomyślnie, bez kompromisów
Standardowa produkcjafloat + 1024 wymiarydobry balans jakość/koszt
Duży wolumen (miliony wektorów)int8 + 768 wymiarów4 razy bardziej zwarte
Wyszukiwanie w czasie rzeczywistym na dużą skalębinary + 1536 wymiarówszybkie wstępne filtrowanie, potem ponowny ranking w float
Embedded / edgeint8 + 256 wymiarówabsolutne 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