Премини към основното съдържание
Български— Изберете език
Меню

Типове данни и измерения

Урок 7 от 18 Обновен 2 ноември 2026 г. Програмист
На тази страница
  1. Оптимизиране на размера и качеството
  2. Петте изходни типа
  3. Влияние върху качеството
  4. Намаляване на измеренията
  5. Ръководство за избор
  6. Ключови изводи

Оптимизиране на размера и качеството

codestral-embed Ви дава прецизен контрол над две оси: броят на измеренията и типът данни (dtype) на стойностите. Тези параметри Ви позволяват да балансирате между качеството на търсенето и разходите за съхранение или изчислителна мощ.

Това става критично с нарастването на обемите. Индекс от два милиона функции при 1536 измерения с плаваща запетая тежи около дванадесет гигабайта и вече не се събира в паметта на стандартна машина; същият индекс в int8 при 768 измерения спада под един гигабайт и отново става достъпен за заявки в реално време. Именно тази аритметика, а не естетическо предпочитание, трябва да направлява избора Ви.

Петте изходни типа

float (по подразбиране)

Типът float генерира 32-битови стойности с плаваща запетая. Това е най-прецизният формат, идеален когато качеството има приоритет пред мястото за съхранение.

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

Всяко измерение е цяло число между -128 и 127. Това използва 4 пъти по-малко памет от float32 с минимална загуба на качество. Сравнете показаните стойности с тези от предишния пример: това е същият вектор, квантуван до по-груба скала, а класирането на резултатите остава почти непроменено.

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

Подобно на int8, но със стойности между 0 и 255 (без знак). Полезно за определени двигатели за векторно търсене, които приемат само положителни стойности – ограничение, което обикновено откривате по време на интеграцията, а не преди нея.

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

Най-компактният формат. Всяко измерение се квантува до 1 бит, след което битовете се групират в пакети по 8 в стойности int8. Полученият вектор е 32 пъти по-малък от float – дължината от 192, показана по-долу, съответства точно на оригиналните 1536 измерения, опаковани по осем.

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

Идентичен с binary, но със стойности uint8 (0-255) вместо int8 (-128 до 127). Изборът между двата зависи от това какво приема Вашият низходящ двигател за съхранение, а не от качеството на търсенето.

Влияние върху качеството

Числата за компресия не Ви казват какво точно губите. Следната функция измерва това на конкретен пример: тест за палиндром, заявен на френски, кодиран последователно с три типа данни. Получените сходства Ви дават порядъка на деградация върху Вашите собствени данни.

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

Обърнете внимание, че кодът и заявката винаги се кодират с един и същи тип данни вътре в цикъла. Смесването на типове между индекса и заявката би довело до несъответстващи резултати, а грешката е толкова коварна, защото не предизвиква никакво изключение.

Намаляване на измеренията

Параметърът output_dimension контролира броя на измеренията във вектора. Цикълът по-долу итерира през шест стойности и показва отпечатъка в паметта на един вектор за всяка от тях, първо във float, след това в 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)")

Изход:

    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)

Умножете дясната колона по действителния брой вектори и веднага получавате оразмеряването на сървъра си. Между 3072 измерения във float и 768 в int8 съотношението е шестнадесет: един и същи индекс преминава от дванадесет гигабайта на седемстотин и петдесет мегабайта.

Ръководство за избор

Следните конфигурации покриват най-честите сценарии:

КонтекстКонфигурацияПричина
Прототип / разработкаfloat + 1536 dimsпо подразбиране, без компромиси
Стандартна продукцияfloat + 1024 dimsдобър баланс качество/разходи
Голям обем (милиони вектори)int8 + 768 dims4 пъти по-компактен
Векторно търсене в реално време в мащабbinary + 1536 dimsбързо предварително филтриране, след това повторно класиране във float
Вградени системи / ръб (Edge)int8 + 256 dimsминимално жизнеспособен

Редът „реално време“ описва двуетапна архитектура, която си струва да разберете: много лекият binary индекс служи за извличане на няколкостотин кандидати за милисекунди; само тези кандидати след това се прекласират, използвайки float векторите, които са по-скъпи, но много по-фини. Получавате скоростта на binary и, в началото на списъка, прецизността на float.

Ключови изводи

  • codestral-embed поддържа 5 изходни типа: float, int8, uint8, binary, ubinary
  • Типът binary е 32 пъти по-компактен от float, с приемлива загуба на качество за предварително филтриране
  • Първите измерения съдържат най-много информация (представяне Матрьошка)
  • Комбинирайте намалени измерения + int8 за много компактни индекси
  • Винаги тествайте върху реалните си данни, преди да изберете параметри за продукция