Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Tipai duomenų ir matmenys

Paskaita 7 iš 18 Atnaujinta 2026 m. lapkričio 2 d. Kūrėjas
Šiame puslapyje
  1. Dydžio ir kokybės optimizavimas
  2. Penki išvesties tipai
  3. Poveikis kokybei
  4. Matmenų mažinimas
  5. Atrankos gidas
  6. Svarbiausi punktai

Dydžio ir kokybės optimizavimas

codestral-embed suteikia tikslų valdymą dviem ašimis: matmenų skaičiumi ir reikšmių duomenų tipu (dtype). Šie parametrai leidžia derinti paieškos kokybės ir saugojimo ar skaičiavimo išlaidų santykį.

Tai tampa kritiška augant duomenų apimtims. Dviejų milijonų funkcijų indeksas, naudojant 1536 float matmenų, sveria apie dvylika gigabaitų ir nebetelpa į standartinio kompiuterio operatyviąją atmintį; tas pats indeksas, naudojant int8 ir 768 matmenis, sumažėja iki mažiau nei vieno gigabaito ir vėl tampa užklausiamas realiuoju laiku. Būtent ši aritmetika, o ne estetiniai pageidavimai, turėtų nulemti tavo pasirinkimus.

Penki išvesties tipai

float (numatytasis)

Tipas float generuoja 32 bitų slankiojo kablelio reikšmes. Tai tiksliausias formatas, idealus, kai kokybė yra svarbesnė už saugojimo vietą.

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

Kiekvienas matmuo yra sveikasis skaičius nuo -128 iki 127. Tai sunaudoja 4 kartus mažiau atminties nei float32, beveik neprarandant kokybės. Palygink rodomas reikšmes su ankstesniu pavyzdžiu: tai tas pats vektorius, tik sukvantintas į grubesnę skalę, o rezultatų rikiavimas lieka beveik nepakitęs.

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

Panašus į int8, tačiau reikšmės yra nuo 0 iki 255 (be ženklo). Naudinga tam tikroms vektorių paieškos sistemoms, kurios priima tik teigiamas reikšmes – tai apribojimas, kurį dažniausiai atrandi integracijos metu, o ne prieš ją.

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

Glaustiausias formatas. Kiekvienas matmuo sukvantinamas į 1 bitą, tada bitai sugrupuojami po 8 į int8 reikšmes. Gautas vektorius yra 32 kartus mažesnis nei float – toliau pateiktas 192 ilgis tiksliai atitinka pradinius 1536 matmenis, supakuotus po aštuonis.

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

Identiškas binary, tačiau naudoja uint8 reikšmes (0–255) vietoj int8 (-128–127). Pasirinkimas tarp šių dviejų priklauso nuo to, ką priima tavo galutinė saugojimo sistema, o ne nuo paieškos kokybės.

Poveikis kokybei

Glaudintumo skaičiai nepasako, ko tiksliai netenki. Toliau pateikta funkcija tai išmatuoja konkrečiu pavyzdžiu: palindromo testas, užklausa prancūzų kalba, koduojama nuosekliai naudojant tris duomenų tipus. Gauti panašumai parodo degradacijos eilę tavo pačių duomenims.

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}")

Atkreipk dėmesį, kad kodas ir užklausa cikle visada koduojami naudojant tą patį duomenų tipą. Tipų maišymas tarp indekso ir užklausos duotų nenuoseklius balus, o klaida yra ypač klastinga, nes neišmeta jokios išimties.

Matmenų mažinimas

Parametras output_dimension valdo vektorių matmenų skaičių. Toliau esantis ciklas iteruoja per šešias reikšmes ir kiekvienai parodo vieno vektoriaus atminties pėdsaką: pirmiausia float, tada 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)")

Išvestis:

    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)

Padaugink dešinį stulpelį iš tikrojo vektorių skaičiaus ir iškart gausi savo serverio dydžio įvertinimą. Tarp 3072 matmenų float ir 768 matmenų int8 santykis yra šešiolika: tas pats indeksas sumažėja nuo dvylikos gigabaitų iki septynių šimtų penkiasdešimt megabaitų.

Atrankos gidas

Šios konfigūracijos apima dažniausiai pasitaikančius scenarijus:

KontekstasKonfigūracijaPriežastis
Prototipas / kūrimasfloat + 1536 matmenųnumatytoji, be kompromisų
Standartinė gamybafloat + 1024 matmenųgeras kokybės ir kainos balansas
Didelės apimtys (milijonai vektorių)int8 + 768 matmenų4 kartus glaustesnis
Didelio masto paieška realiuoju laikubinary + 1536 matmenųgreitas pirminis filtravimas, tada perrikiavimas naudojant float
Įterptinės sistemos / kraštiniai įrenginiaiint8 + 256 matmenųminimaliai gyvybingas

Eilutė „realiuoju laiku“ aprašo dviejų etapų architektūrą, kurią verta suprasti: labai lengvas binary indeksas naudojamas per kelias milisekundes gauti kelis šimtus kandidatų; tik šie kandidatai vėliau perrikiuojami naudojant float vektorius, kurie yra brangesni, bet daug tikslesni. Taip gauni binary greitį ir, sąrašo viršuje, float tikslumą.

Svarbiausi punktai

  • codestral-embed palaiko 5 išvesties tipus: float, int8, uint8, binary, ubinary
  • Binary tipas yra 32 kartus glaustesnis nei float, su priimtina kokybės praradimo dalimi pirminiam filtravimui
  • Pirmieji matmenys turi daugiausia informacijos (Matrioškos reprezentacija)
  • Derink sumažintus matmenis ir int8 labai glaudiems indeksams
  • Visada testuok su savo realiais duomenimis prieš pasirinkdamas gamybos parametrus