Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Tietotyypit ja ulottuvuudet

Oppitunti 7 / 18 Päivitetty 2. marraskuuta 2026 Kehittäjä
Tällä sivulla
  1. Koon ja laadun optimointi
  2. Viisi tulostyyppiä
  3. Vaikutus laatuun
  4. Ulottuvuuksien vähentäminen
  5. Valintaopas
  6. Keskeiset asiat

Koon ja laadun optimointi

codestral-embed antaa sinulle tarkan hallinnan kahteen akseliin: ulottuvuuksien määrään ja arvojen tietotyyppiin (dtype). Näiden parametrien avulla voit säätää hakulaadun sekä tallennus- tai laskentakustannusten välistä kompromissia.

Tämä muuttuu kriittiseksi volyymien kasvaessa. Kahden miljoonan funktion indeksi 1536 float-ulottuvuudella painaa noin kaksitoista gigatavua eikä mahdu enää tavallisen koneen muistiin; sama indeksi int8-muodossa 768 ulottuvuudella jää alle yhden gigatavun ja on taas kyseltävissä reaaliajassa. Juuri tämä laskutoimitus, ei esteettinen mieltymys, devrait ohjata valintojasi.

Viisi tulostyyppiä

float (oletus)

float-tyyppi tuottaa 32-bittisiä liukulukuja. Tämä on tarkin muoto, ihanteellinen silloin, kun laatu on etusijalla tallennustilaan nähden.

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

Jokainen ulottuvuus on kokonaisluku välillä -128–127. Tämä vie 4 kertaa vähemmän muistia kuin float32, ja laadun menetys on minimaalista. Vertaa näytettyjä arvoja edelliseen esimerkkiin: kyseessä on sama vektori, kvantisoitu karkeammalle asteikolle, ja tulosten järjestys pysyy lähes muuttumattomana.

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

Samanlainen kuin int8, mutta arvot ovat välillä 0–255 (etumerkitön). Hyödyllinen tietyille vektorihakukoneille, jotka hyväksyvät vain positiivisia arvoja – rajoitus, jonka huomaat yleensä vasta integraation aikana, et aiemmin.

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

Tiivein muoto. Jokainen ulottuvuus kvantisoidaan 1 bitiksi, jonka jälkeen bitit ryhmitellään 8 bitin paketteihin int8-arvoiksi. Tuloksena oleva vektori on 32 kertaa pienempi kuin float – alla näkyvä 192:n pituus vastaa täsmälleen alkuperäisiä 1536 ulottuvuutta, pakattuna kahdeksan kerrallaan.

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

Identtinen binaryn kanssa, mutta käyttää uint8-arvoja (0–255) int8-arvojen (-128–127) sijaan. Valinta näiden välillä riippuu siitä, mitä downstream-tallennusmoottorisi hyväksyy, ei hakulaadusta.

Vaikutus laatuun

Pakkaussuhteet eivät kerro, mitä todellisuudessa menetetään. Seuraava funktio mittaa tätä konkreettisella esimerkillä: palindromitesti, jossa kysely tehdään ranskaksi ja koodaus suoritetaan peräkkäin kolmella eri dtype-arvolla. Tuloksena saatavat samankaltaisuudet antavat sinulle käsityksen heikkenemisen suuruusluokasta omassa datassasi.

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

Huomaa, että koodi ja kysely koodataan aina silmukan sisällä samalla dtype-arvolla. Tyyppien sekoittaminen indeksin ja kyselyn välillä tuottaisi epäjohdonmukaisia pisteitä, ja virhe on sitä salakavalampi, ettei se aiheuta poikkeusta.

Ulottuvuuksien vähentäminen

output_dimension-parametri ohjaa vektorin ulottuvuuksien määrää. Alla oleva silmukka käy läpi kuusi arvoa ja näyttää yhden vektorin muistijalanjäljen kullekin, ensin float-muodossa ja sitten int8-muodossa.

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

Tuloste:

    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)

Kerro oikeanpuoleinen sarake vektoridesi todellisella määrällä, niin saat heti selville palvelimesi mitoituksen. 3072 ulottuvuuden (float) ja 768 ulottuvuuden (int8) välinen suhde on kuusitoista: sama indeksi kutistuu kahdestatoista gigatavusta seitsemään sataan viiteenkymmeneen megatavuun.

Valintaopas

Seuraavat konfiguraatiot kattavat yleisimmät skenaariot:

KontekstiKonfiguraatioSyy
Prototyyppi / kehitysfloat + 1536 ulottuvuuttaoletus, ei kompromisseja
Vakiotuotantofloat + 1024 ulottuvuuttahyvä laatu/kustannus-suhde
Suuri volyymi (miljoonia vektoreita)int8 + 768 ulottuvuutta4 kertaa tiiviimpi
Laajamittainen reaaliaikahakubinary + 1536 ulottuvuuttanopea esisuodatus, sitten uudelleenjärjestys float-muodossa
Upotettu / edgeint8 + 256 ulottuvuuttaminimaalinen toimiva ratkaisu

“Reaaliaika”-rivi kuvaa kaksivaiheista arkkitehtuuria, joka on syytä ymmärtää: erittäin kevyt binary-indeksi hakee muutamia satoja ehdokkaita millisekunneissa; vain nämä ehdokkaat järjestetään uudelleen käyttämällä float-vektoreita, jotka ovat kalliimpia mutta paljon tarkempia. Saat binaryn nopeuden ja listan kärjessä floatin tarkkuuden.

Keskeiset asiat

  • codestral-embed tukee 5 tulostyyppiä: float, int8, uint8, binary, ubinary
  • Binary-tyyppi on 32 kertaa tiiviimpi kuin float, ja laadun menetys on hyväksyttävä esisuodatukseen
  • Ensimmäiset ulottuvuudet sisältävät eniten informaatiota (Matryoshka-esitys)
  • Yhdistä vähennetyt ulottuvuudet ja int8 erittäin tiiviisiin indekseihin
  • Testaa aina omalla todellisella datallasi ennen tuotantoparametrien valintaa