Cineálacha agus Toisí Sonraí
Ar an leathanach seo
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éacs | Cumraíocht | Cúis |
|---|---|---|
| Protaitípe / forbairt | float + 1536 dims | réamhshocraithe, gan comhréir |
| Táirgeadh caighdeánach | float + 1024 dims | cothromaíocht mhaith cáilíochta/costais |
| Toirt ard (milliúin veicteoirí) | int8 + 768 dims | 4 huaire níos dlúithe |
| Cuardach fíor-ama ar scála mór | binary + 1536 dims | réamhscagaire tapa, ansin athrangú i float |
| Leabaithe / imeall | int8 + 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