Μετάβαση στο κύριο περιεχόμενο
Ελληνικά— Επιλέξτε γλώσσα
Μενού

Τύποι Δεδομένων και Διαστάσεις

Μάθημα 7 / 18 Ενημερώθηκε 2 Νοεμβρίου 2026 Για developers
Σε αυτήν τη σελίδα
  1. Βελτιστοποίηση Μεγέθους και Ποιότητας
  2. Οι Πέντε Τύποι Εξόδου
  3. Επίπτωση στην Ποιότητα
  4. Μείωση Διαστάσεων
  5. Οδηγός Επιλογής
  6. Βασικά σημεία

Βελτιστοποίηση Μεγέθους και Ποιότητας

Το codestral-embed σάς προσφέρει ακριβή έλεγχο σε δύο άξονες: τον αριθμό των διαστάσεων και τον τύπο δεδομένων (dtype) των τιμών. Αυτές οι παράμετροι σάς επιτρέπουν να ρυθμίσετε τη σχέση μεταξύ της ποιότητας αναζήτησης και του κόστους αποθήκευσης ή υπολογισμού.

Αυτό γίνεται κρίσιμο καθώς αυξάνονται οι όγκοι δεδομένων. Ένας ευρετηριασμός δύο εκατομμυρίων συναρτήσεων με 1536 διαστάσεις float ζυγίζει περίπου δώδεκα gigabyte και δεν χωράει πλέον στη μνήμη μιας τυπικής μηχανής· ο ίδιος ευρετηριασμός σε int8 με 768 διαστάσεις πέφτει κάτω από ένα gigabyte και γίνεται και πάλι ερωτήσιμος σε πραγματικό χρόνο. Είναι αυτός ο αριθμητικός υπολογισμός, και όχι μια αισθητική προτίμηση, που πρέπει να καθοδηγεί τις επιλογές σας.

Οι Πέντε Τύποι Εξόδου

float (προεπιλογή)

Ο τύπος float παράγει τιμές κινητής υποδιαστολής 32 bit. Αυτή είναι η πιο ακριβής μορφή, ιδανική όταν η ποιότητα έχει προτεραιότητα έναντι του χώρου αποθήκευσης.

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 (unsigned). Χρήσιμο για ορισμένες μηχανές διανυσματικής αναζήτησης που δέχονται μόνο θετικές τιμές—ένας περιορισμός που συνήθως ανακαλύπτετε κατά την ενσωμάτωση και όχι πριν.

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 bit, στη συνέχεια τα bits ομαδοποιούνται σε πακέτα των 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). Η επιλογή μεταξύ των δύο εξαρτάται από το τι δέχεται η μηχανή αποθήκευσης downstream και όχι από την ποιότητα αναζήτησης.

Επίπτωση στην Ποιότητα

Οι αριθμοί συμπίεσης δεν σας λένε τι χάνετε πραγματικά. Η ακόλουθη συνάρτηση το μετρά αυτό σε ένα συγκεκριμένο παράδειγμα: ένα τεστ παλίνδρομης λέξης, με ερώτημα στα γαλλικά, κωδικοποιημένο διαδοχικά με τρεις τύπους dtype. Οι προκύπτουσες ομοιότητες σάς δίνουν την τάξη μεγέθους της υποβάθμισης στα δικά σας δεδομένα.

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

Σημειώστε ότι ο κώδικας και το ερώτημα κωδικοποιούνται πάντα με τον ίδιο τύπο dtype μέσα στον βρόχο. Η ανάμειξη τύπων μεταξύ του ευρετηρίου και του ερωτήματος θα παρήγαγε ασυνεπή σκορ, και το σφάλμα είναι τόσο ύπουλο που δεν προκαλεί καμία εξαίρεση.

Μείωση Διαστάσεων

Η παράμετρος 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, ο λόγος είναι δεκαέξι: ο ίδιος ευρετηριασμός περνά από δώδεκα gigabyte σε επτακόσια πενήντα megabytes.

Οδηγός Επιλογής

Οι ακόλουθες διαμορφώσεις καλύπτουν τα πιο συχνά σενάρια:

ΠλαίσιοΔιαμόρφωσηΛόγος
Πρωτότυπο / ανάπτυξηfloat + 1536 dimsπροεπιλογή, χωρίς συμβιβασμούς
Τυπική παραγωγήfloat + 1024 dimsκαλή ισορροπία ποιότητας/κόστους
Υψηλός όγκος (εκατομμύρια διανύσματα)int8 + 768 dims4 φορές πιο συμπαγές
Αναζήτηση πραγματικού χρόνου μεγάλης κλίμακαςbinary + 1536 dimsγρήγορο προ-φιλτράρισμα, στη συνέχεια επανακατάταξη σε float
Ενσωματωμένο / edgeint8 + 256 dimsελάχιστο βιώσιμο

Η γραμμή «πραγματικού χρόνου» περιγράφει μια αρχιτεκτονική δύο σταδίων που αξίζει να κατανοήσετε: το πολύ ελαφρύ δυαδικό ευρετήριο χρησιμεύει για την ανάκτηση μερικών εκατοντάδων υποψηφίων σε χιλιοστά του δευτερολέπτου· μόνο αυτοί οι υποψήφιοι επανακατατάσσονται στη συνέχεια χρησιμοποιώντας τα διανύσματα float, τα οποία είναι πιο δαπανηρά αλλά πολύ πιο λεπτομερή. Έτσι αποκτάτε την ταχύτητα του binary και, στην κορυφή της λίστας, την ακρίβεια του float.

Βασικά σημεία

  • Το codestral-embed υποστηρίζει 5 τύπους εξόδου: float, int8, uint8, binary, ubinary
  • Ο τύπος binary είναι 32 φορές πιο συμπαγής από το float, με αποδεκτή απώλεια ποιότητας για προ-φιλτράρισμα
  • Οι πρώτες διαστάσεις περιέχουν τις περισσότερες πληροφορίες (αναπαράσταση Matryoshka)
  • Συνδυάστε μειωμένες διαστάσεις + int8 για πολύ συμπαγή ευρετήρια
  • Δοκιμάζετε πάντα στα πραγματικά σας δεδομένα πριν επιλέξετε παραμέτρους παραγωγής