Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Tipi ta' Data u Dimensjonijiet

Lezzjoni 7 / 18 Aġġornat 2 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. Ottimizzazzjoni tad-Daqs u l-Kwalità
  2. Il-Ħames Tipi ta’ Output
  3. Impatt fuq il-Kwalità
  4. Tnaqqis tad-Dimensjonijiet
  5. Gwida tal-Għażla
  6. Punti Ewlenin

Ottimizzazzjoni tad-Daqs u l-Kwalità

codestral-embed jagħtik kontroll preċiż fuq żewġ assi: in-numru ta’ dimensjonijiet u t-tip ta’ data (dtype) tal-valuri. Dawn il-parametri jħalluk ttaffi l-kompromess bejn il-kwalità tat-tfittxija u l-ispejjeż tal-ħażna jew tal-kompjuter.

Dan isir kritiku hekk kif il-volumi jikbru. Indiċi ta’ żewġ miljun funzjoni b’1536 dimensjoni float jiżen madwar tnax-il gigabyte u ma jibqax jidħol fil-memorja fuq magna standard; l-istess indiċi f’int8 b’768 dimensjoni jinżel taħt gigabyte wieħed u jerġa’ jsir interrogabbli f’ħin reali. Hija din l-aritmetika, mhux preferenza estetika, li għandha tmexxi l-għażliet tiegħek.

Il-Ħames Tipi ta’ Output

float (default)

It-tip float jipproduċi valuri floating-point ta’ 32-bit. Dan huwa l-format l-aktar preċiż, ideali meta l-kwalità tieħu preċedenza fuq l-ispazju tal-ħażna.

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

Kull dimensjoni hija numru sħiħ bejn -128 u 127. Dan juża 4 darbiet inqas memorja milli float32 b’telf minimu fil-kwalità. Qabbel il-valuri murija ma’ dawk fl-eżempju preċedenti: huwa l-istess vettur, kwantizzat għal skala aktar ħarxa, u l-klassifikazzjoni tar-riżultati tibqa’ kważi l-istess.

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

Simili għal int8 iżda b’valuri bejn 0 u 255 (mhux iffirmat). Utli għal ċerti magni ta’ tfittxija vettorjali li jaċċettaw biss valuri pożittivi—restrizzjoni li ġeneralment tiskopri waqt l-integrazzjoni, mhux qabel.

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

L-aktar format kompatt. Kull dimensjoni hija kwantizzata għal 1 bit, imbagħad il-bits huma raggruppati f’pakketti ta’ 8 f’valuri int8. Il-vettur li jirriżulta huwa 32 darba iżgar minn float—it-tul ta’ 192 murija hawn taħt jikkorrispondi eżattament għad-1536 dimensjoni oriġinali, ippakkjati tmienja b’tmienja.

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

Identiku għal binary iżda b’valuri uint8 (0-255) minflok int8 (-128 sa 127). L-għażla bejn iż-żewġ tipi tiddependi fuq dak li jaċċetta l-mutur tal-ħażna downstream tiegħek, mhux fuq il-kwalità tat-tfittxija.

Impatt fuq il-Kwalità

Iċ-ċifri tal-kompressjoni ma jgħidulekx x’inhu eżattament qed titlef. Il-funzjoni li ġejja tkejjel dan fuq eżempju konkret: test palindrome, interrogat bil-Franċiż, ikkodifikat suċċessivament b’tliet dtypes. Is-similaritajiet li jirriżultaw jagħtuk l-ordni tal-kobor tad-degradazzjoni fuq id-data tiegħek stess.

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

Innota li l-kodiċi u l-mistoqsija dejjem jiġu kkodifikati bl-istess dtype ġewwa ċ-ċiklu. It-taħlit ta’ tipi bejn l-indiċi u l-mistoqsija jipproduċi punteġġi inkonsistenti, u l-iżball huwa tant iktar insidjuż għax ma jqajjem l-ebda eċċezzjoni.

Tnaqqis tad-Dimensjonijiet

Il-parametru output_dimension jikkontrolla n-numru ta’ dimensjonijiet fil-vettur. Iċ-ċiklu hawn taħt jgħaddi minn sitt valuri u juri l-impronta tal-memorja ta’ vettur wieħed għal kull wieħed, l-ewwel f’float u mbagħad f’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)")

Output:

    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)

Immultiplika l-kolonna tal-lemin bin-numru attwali tal-vetturi tiegħek u tikseb immedjatament id-daqs tas-server tiegħek. Bejn 3072 dimensjoni f’float u 768 f’int8, il-proporzjon huwa sittax: l-istess indiċi jgħaddi minn tnax-il gigabyte għal seba’ mitt u ħamsin megabyte.

Gwida tal-Għażla

Il-konfigurazzjonijiet li ġejjin ikopru l-aktar xenarji frekwenti:

KuntestKonfigurazzjoniRaġuni
Prototip / żviluppfloat + 1536 dimsdefault, l-ebda kompromess
Produzzjoni standardfloat + 1024 dimsbilanċ tajjeb bejn kwalità u spiża
Volum għoli (miljuni ta’ vetturi)int8 + 768 dims4 darbiet aktar kompatt
Tfittxija f’ħin reali fuq skala kbirabinary + 1536 dimspre-filtrazzjoni mgħaġġla, imbagħad ikklassifika mill-ġdid f’float
Imkessaħ / edgeint8 + 256 dimsminimu vijabbli

Il-linja “ħin reali” tiddeskrivi arkitettura fuq żewġ stadji li tiswa li tifhem: l-indiċi binarju ħafif ħafna jservi biex jirkupra ftit mijiet ta’ kandidati f’millisekondi; dawn il-kandidati biss imbagħad jiġu kklassifikati mill-ġdid bl-użu tal-vetturi float, li huma aktar għaljin iżda ħafna aktar fini. Tikseb il-veloċità tal-binary u, fil-quċċata tal-lista, il-preċiżjoni tal-float.

Punti Ewlenin

  • codestral-embed jappoġġja 5 tipi ta’ output: float, int8, uint8, binary, ubinary
  • It-tip binary huwa 32 darba aktar kompatt minn float, b’telf aċċettabbli fil-kwalità għall-pre-filtrazzjoni
  • L-ewwel dimensjonijiet fihom l-aktar informazzjoni (rappreżentazzjoni Matryoshka)
  • Għaqqad dimensjonijiet imnaqqsa + int8 għal indiċi kompatti ħafna
  • Dejjem ittestja fuq id-data reali tiegħek qabel ma tagħżel il-parametri tal-produzzjoni