Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Cineálacha agus Toisí Sonraí

Ceacht 7 as 18 Nuashonraithe 2 Samhain 2026 Forbróir
Ar an leathanach seo
  1. Méid agus Cáilíocht a Optamú
  2. An Cúig Chineál Aschuir
  3. Tionchar ar Cháilíocht
  4. Toisí a Laghdú
  5. Treoir Roghnúcháin
  6. Príomhphointí

Méid agus Cáilíocht a Optamú

Tugann codestral-embed smacht cruinn duit ar dhá ais: líon na dtoise agus an cineál sonraí (dtype) de na luachanna. Ligeann na paraiméadair seo duit an comhréir idir cáilíocht cuardaigh agus costais stórála nó ríomhaireachta a choigeartú.

Éiríonn sé seo ríthábhachtach de réir mar a mhéadaíonn na toirteanna. Meánn innéacs de dhá mhilliún feidhm ag 1536 toise snámhphointe thart ar dhá ghigibheart déag agus ní oireann sé a thuilleadh sa chuimhne ar ghnáth-mheaisín; titann an t-innéacs céanna in int8 ag 768 toise faoi bhun ghigibheart amháin agus is féidir é a chuardach i bhfíor-am arís. Is é an t-uimhríocht seo, seachas rogha aeistéitiúil, ar chóir do chuid roghanna a bheith bunaithe.

An Cúig Chineál Aschuir

float (réamhshocraithe)

Cruthaíonn an cineál float luachanna snámhphointe 32-giotán. Is é seo an formáid is cruinne, idéalach nuair a bhíonn tosaíocht ag baint le cáilíocht seachas spás stórála.

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

Is slánuimhir idir -128 agus 127 gach toise. Úsáideann sé seo 4 huaire níos lú cuimhne ná float32 le caillteanas íosta cáilíochta. Déan comparáid idir na luachanna taispeánta agus iad siúd sa sampla roimhe seo: is é an veicteoir céanna é, candamaithe go scála garbh, agus fanann rangú na dtorthaí beagnach gan athrú.

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

Cosúil le int8 ach le luachanna idir 0 agus 255 (gan comhartha). Úsáideach d’innill chuardaigh veicteora áirithe nach nglacann ach le luachanna dearfacha—srian a aimsíonn tú de ghnáth le linn comhtháthaithe, ní roimhe.

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

An formáid is dlúithe. Candamaítear gach toise go 1 ghiotán, ansin grúpáiltear giotáin i bpacáistí de 8 i luachanna int8. Tá an veicteoir mar thoradh air 32 huaire níos lú ná float—freagraíonn fad 192 atá taispeánta thíos go díreach do na 1536 toise bhunaidh, pacáilte ocht ar ocht.

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

Comhionann le binary ach le luachanna uint8 (0-255) in ionad int8 (-128 go 127). Braitheann an rogha idir an dá cheann ar an méid a ghlacann d’inneall stórála síos an sruth leis, ní ar cháilíocht an chuardaigh.

Tionchar ar Cháilíocht

Ní insíonn figiúir comhbhrúite duit cad atá tú ag cailleadh i ndáiríre. Tomhaiseann an fheidhm seo a leanas é seo ar shampla concreideach: tástáil palaindróim, faighte i bhFraincis, ionchódaithe go leanúnach le trí dtype. Tugann na cosúlachtaí mar thoradh ord na méide den díghrádú ar do chuid sonraí féin.

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

Tabhair faoi deara go n-ionchódaítear an cód agus an cheist i gcónaí leis an dtype céanna laistigh den lúb. Dá mheascfá cineálacha idir an t-innéacs agus an cheist, chruthófaí scóir neamhthairiseacha, agus is annamh a bhíonn an earráid chomh insidious sin toisc nach dtógann sí aon eisceacht.

Toisí a Laghdú

Rialaíonn an paraiméadar output_dimension líon na dtoise sa veicteoir. Déanann an lúb thíos atriall ar shé luach agus taispeánann sí lorg cuimhne veicteora amháin do gach ceann, ar dtús i float ansin in 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)")

Aschur:

    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)

Iolraigh an colún deas faoi do líon iarbhír veicteoirí agus gheobhaidh tú do mhéid freastalaí láithreach. Idir 3072 toise i float agus 768 in int8, is é sé déag an cóimheas: téann an t-innéacs céanna ó dhá ghigibheart déag go seacht gcéad caoga megibheart.

Treoir Roghnúcháin

Clúdaíonn na cumraíochtaí seo a leanas na cásanna is minice:

ComhthéacsCumraíochtCúis
Protaitípe / forbairtfloat + 1536 dimsréamhshocraithe, gan comhréir
Táirgeadh caighdeánachfloat + 1024 dimscothromaíocht mhaith cáilíochta/costais
Toirt ard (milliúin veicteoirí)int8 + 768 dims4 huaire níos dlúithe
Cuardach fíor-ama ar scála mórbinary + 1536 dimsréamhscagaire tapa, ansin athrangú i float
Leabaithe / imeallint8 + 256 dimsíosmhéid indéanta

Cur síos atá sa líne “fíor-am” ar ailtireacht dhá chéim ar fiú tuiscint a bheith agat uirthi: feidhmíonn an t-innéacs binary an-éadrom chun cúpla céad iarrthóir a aisghabháil i millisoicindí; ní athrangófar ach na hiarrthóirí seo ansin ag baint úsáide as na veicteoirí float, atá níos costasaí ach i bhfad níos mine. Faigheann tú luas binary agus, ag barr an liosta, cruinneas float.

Príomhphointí

  • Tacaíonn codestral-embed le 5 chineál aschuir: float, int8, uint8, binary, ubinary
  • Tá an cineál binary 32 huaire níos dlúithe ná float, le caillteanas inghlactha cáilíochta le haghaidh réamhscagtha
  • Is sna chéad toisí atá an chuid is mó den fhaisnéis (léiriú Matryoshka)
  • Comhcheangail toisí laghdaithe + int8 le haghaidh innéacsanna an-dlúithe
  • Déan tástáil i gcónaí ar do shonraí fíora sula roghnaíonn tú paraiméadair táirgthe