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

Генериране на вграждания за вашите данни

Урок 3 от 22 Обновен 29 юли 2026 г. Програмист
На тази страница
  1. Цели
  2. Подготовка на данните
  3. Генериране на вграждания на партиди
  4. Съхраняване на вгражданията
  5. Пълен конвейер: от текстови файлове до вграждания
  6. Оценка на разходите
  7. Ключови изводи

Цели

  • Подготовка на текстовите данни за вграждане
  • Ефективно генериране на вграждания в мащаб
  • Съхраняване на векторите за бъдеща употреба

Подготовка на данните

Качеството на вгражданията Ви зависи пряко от качеството на данните. Текст, осеян със случайни интервали, контролни символи от грешен експорт или нередовни преноси на редове, произвежда леко отклонен вектор. Това отклонение се натрупва при всяко търсене. Почистването не е козметично: то е първата и най-евтина оптимизация на релевантността.

import re

def nettoyer_texte(texte: str) -> str:
    """Prepares text for embedding."""
    # Remove multiple spaces
    texte = re.sub(r"\s+", " ", texte)
    # Remove control characters
    texte = re.sub(r"[\x00-\x08\x0b\x0c\x0e-\x1f]", "", texte)
    # Trim
    texte = texte.strip()
    return texte

# Example
brut = "  Texte   avec   des   espaces\n\n\nen trop  "
propre = nettoyer_texte(brut)
print(propre)  # "Texte avec des espaces en trop"

Обогатяване на контекста

Изолиран откъс от документация губи част от смисъла си без заглавието си. Вземете параграф, започващ с „Изтеглете пакета от официалния сайт“: извън контекста нищо не показва, че става въпрос за PostgreSQL, и полученият вектор никога няма да съвпадне със заявка относно PostgreSQL. Чрез добавяне на префикс към съдържанието с неговото заглавие и секция, Вие reinjectирате тази информация в текста, който моделът вижда.

def enrichir_document(titre: str, section: str, contenu: str) -> str:
    """Creates enriched text for better embedding."""
    return f"Titre : {titre}\nSection : {section}\n\n{contenu}"

texte_enrichi = enrichir_document(
    titre="Installation de PostgreSQL",
    section="Getting Started Guide",
    contenu="Download the package from the official site..."
)

Генериране на вграждания на партиди

При реален корпус от стотици или хиляди документи, обработката трябва да бъде на части (chunks) и устойчива на мрежови прекъсвания. Функцията по-долу итерира през текстовете на срезове, систематично сортира отговора по index, за да гарантира, че вектор #7 съответства на документ #7, и опитва отново веднъж след пауза при възникване на грешка.

from openai import OpenAI
import time
import json

client = OpenAI()

def generer_embeddings(
    textes: list[str],
    model: str = "text-embedding-3-large",
    batch_size: int = 100
) -> list[list[float]]:
    """Generates embeddings in batches with error handling."""
    tous_les_embeddings = []

    for i in range(0, len(textes), batch_size):
        batch = textes[i:i + batch_size]
        print(f"Processing batch {i // batch_size + 1}/"
              f"{(len(textes) - 1) // batch_size + 1}")

        try:
            response = client.embeddings.create(
                input=batch,
                model=model
            )
            # Sort by index to guarantee order
            batch_embeddings = sorted(
                response.data, key=lambda x: x.index
            )
            tous_les_embeddings.extend(
                [item.embedding for item in batch_embeddings]
            )
        except Exception as e:
            print(f"Error on batch {i}: {e}")
            # Retry after a pause
            time.sleep(5)
            response = client.embeddings.create(
                input=batch,
                model=model
            )
            batch_embeddings = sorted(
                response.data, key=lambda x: x.index
            )
            tous_les_embeddings.extend(
                [item.embedding for item in batch_embeddings]
            )

    return tous_les_embeddings

Сортирането по index е предпазна мярка, която никога не бива да пропускате. Едно тихо изместване с един ред е достатъчно, за да свърже всеки документ с вектора на съседа му. Симптомът, който ще наблюдавате, е „търсенето връща боклук“, без техническа грешка, която да Ви насочи в правилната посока.

Съхраняване на вгражданията

За малък корпус от няколко хиляди документа, обикновен JSON файл, съдържащ текстове, метаданни и вектори, работи перфектно. Той има предимството да бъде четим от човек, когато трябва да отстраните странен резултат.

import json

documents = [
    {"id": 1, "texte": "Premier document...", "metadata": {"source": "faq"}},
    {"id": 2, "texte": "Deuxième document...", "metadata": {"source": "docs"}},
]

# Generate embeddings
textes = [d["texte"] for d in documents]
embeddings = generer_embeddings(textes)

# Add vectors to documents
for doc, emb in zip(documents, embeddings):
    doc["embedding"] = emb

# Save
with open("corpus_embeddings.json", "w") as f:
    json.dump(documents, f)

Отвъд този мащаб, JSON се превръща в тясно място: всяко число се записва изцяло, раздувайки файла и налагайки скъпо парсиране при всяко зареждане. NumPy съхранява същите стойности в двоичен формат на 4 байта и се зарежда мигновено.

import numpy as np

# Convert to NumPy matrix
matrice = np.array(embeddings, dtype=np.float32)
print(f"Shape : {matrice.shape}")  # (n_docs, 3072)

# Save in binary format
np.save("embeddings.npy", matrice)

# Load
matrice_chargee = np.load("embeddings.npy")

Пълен конвейер: от текстови файлове до вграждания

Нека съберем тези елементи във функция, която чете папка, почиства всеки файл, генерира вектори и разделя съхранението на две: метаданни в JSON (четими и редактируеми) и матрицата в NumPy (компактна и бърза).

from openai import OpenAI
from pathlib import Path
import json
import numpy as np

client = OpenAI()

def pipeline_embeddings(dossier: str, model: str = "text-embedding-3-large"):
    """Complete pipeline: files → embeddings → storage."""
    dossier_path = Path(dossier)

    # 1. Read files
    documents = []
    for fichier in sorted(dossier_path.glob("*.txt")):
        contenu = fichier.read_text(encoding="utf-8")
        contenu = nettoyer_texte(contenu)
        if contenu:
            documents.append({
                "id": fichier.stem,
                "fichier": fichier.name,
                "texte": contenu
            })

    print(f"{len(documents)} documents found")

    # 2. Generate embeddings
    textes = [d["texte"] for d in documents]
    embeddings = generer_embeddings(textes, model=model)

    # 3. Save
    # Metadata in JSON
    meta = [{"id": d["id"], "fichier": d["fichier"]} for d in documents]
    with open("metadata.json", "w") as f:
        json.dump(meta, f, ensure_ascii=False, indent=2)

    # Vectors in NumPy
    np.save("embeddings.npy", np.array(embeddings, dtype=np.float32))

    print(f"Embeddings saved: {len(embeddings)} vectors "
          f"of {len(embeddings[0])} dimensions")

    return documents, embeddings

# Usage
documents, embeddings = pipeline_embeddings("./mes_documents/")

Обърнете внимание на sorted() върху glob: без него редът на файловете зависи от файловата система и двата Ви изходни файла рискуват да се разсинхронизират след проста промяна на машината.

Оценка на разходите

Преди да стартирате масивна задача, пребройте токените локално с tiktoken. Операцията отнема няколко секунди и Ви спестява късното откриване, че лошо филтриран корпус е съдържа десет пъти очаквания обем.

import tiktoken

encoder = tiktoken.get_encoding("cl100k_base")

def estimer_cout(textes: list[str], model: str = "text-embedding-3-large"):
    """Estimates embedding cost for a list of texts."""
    total_tokens = sum(len(encoder.encode(t)) for t in textes)

    # Approximate prices per million tokens (check current rates)
    prix = {
        "text-embedding-3-large": 0.13,
        "text-embedding-3-small": 0.02,
    }

    cout = total_tokens / 1_000_000 * prix.get(model, 0.13)
    print(f"Estimated tokens: {total_tokens:,}")
    print(f"Estimated cost: ${cout:.4f}")
    return total_tokens, cout

Цените в речника са ориентировъчни и остаряват бързо: винаги проверявайте текущите тарифи, преди да представите оферта на клиент.

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

  • Почиствайте и обогатявайте текстовете си преди генериране на вграждания
  • Използвайте обработка на партиди за големи корпуси
  • Съхранявайте метаданните в JSON, а векторите в NumPy
  • Оценявайте разходите си преди стартиране на масивна задача