Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Darbo eigos ir duomenų apdorojimo konvejeriai

Paskaita 12 iš 12 Atnaujinta 2026 m. liepos 30 d. Kūrėjas
Šiame puslapyje
  1. Perėjimas į gamybinę aplinką
  2. Darbo eiga: dokumentų apdorojimas
  3. Duomenų validavimo konvejeris
  4. Daugiažingsnės konvejerio architektūros pagrindai
  5. Geriausios gamybinės praktikos
  6. Kurso santrauka
  7. Svarbiausi punktai
  8. Patikrink savo žinias

Perėjimas į gamybinę aplinką

Ankstesnėse pamokose nagrinėjome pagrindus ir atskirus naudojimo atvejus. Šioje paskutinėje pamokoje viską sujungsime, kad sukurtumėte automatizuotas darbo eigas ir validavimo konvejerius, paruoštus gamybinei aplinkai.

Darbo eiga: dokumentų apdorojimas

Pilnas konvejeris automatiškai apdoroti gaunamus dokumentus:

from pydantic import BaseModel
from typing import Literal

# 1 žingsnis: Dokumentų klasifikavimas
class ClassificationDocument(BaseModel):
    type: Literal["facture", "contrat", "devis", "courrier", "autre"]
    langue: str
    urgence: Literal["basse", "normale", "haute"]
    departement: Literal["comptabilite", "juridique", "commercial", "direction"]

# 2 žingsnis: Duomenų ištraukimas pagal tipą
class DonneesFacture(BaseModel):
    numero: str
    date_emission: str
    date_echeance: str
    emetteur: str
    montant_ht: float
    montant_ttc: float
    lignes: list[dict]

# 3 žingsnis: Validavimas
class ResultatValidation(BaseModel):
    document_valide: bool
    champs_manquants: list[str]
    anomalies: list[str]
    score_confiance: float
    action_recommandee: str

async def traiter_document(texte: str):
    # Klasifikuoti
    _, classification = client.chat.parse(
        model="grok-4.20-0309-reasoning",
        messages=[{"role": "user", "content": f"Classify this document: {texte}"}],
        response_format=ClassificationDocument
    )

    # Ištraukti pagal tipą
    if classification.type == "facture":
        _, donnees = client.chat.parse(
            model="grok-4.20-0309-reasoning",
            messages=[{"role": "user", "content": f"Extract data from this invoice: {texte}"}],
            response_format=DonneesFacture
        )

    # Validuoti
    _, validation = client.chat.parse(
        model="grok-4.20-0309-reasoning",
        messages=[{
            "role": "user",
            "content": f"Validate this extracted data: {donnees.model_dump_json()}"
        }],
        response_format=ResultatValidation
    )

    return classification, donnees, validation

Duomenų validavimo konvejeris

Naudokite struktūrizuotą išvestį gaunamiems duomenims validuoti ir normalizuoti:

class AdresseNormalisee(BaseModel):
    ligne_1: str
    ligne_2: str | None
    code_postal: str
    ville: str
    pays: str
    format_valide: bool

class ContactNormalise(BaseModel):
    prenom: str
    nom: str
    email_valide: bool
    telephone_normalise: str | None
    adresse: AdresseNormalisee

class ResultatNormalisation(BaseModel):
    contacts: list[ContactNormalise]
    nombre_traites: int
    nombre_erreurs: int
    erreurs: list[str]

Šis konvejeris paima kontaktus įvairiais formatais ir normalizuoja juos į vienodą struktūrą.

Daugiažingsnės konvejerio architektūros pagrindai

Štai patikimo gamybinio konvejerio skeletas:

class PipelineResult(BaseModel):
    etape: str
    succes: bool
    donnees: dict
    erreurs: list[str]
    duree_ms: int

def pipeline_complet(texte: str) -> list[PipelineResult]:
    resultats = []

    # Kiekvienas žingsnis naudoja atskirą schemą
    etapes = [
        ("extraction", SchemaExtraction, "Extract data from this text"),
        ("enrichissement", SchemaEnrichi, "Enrich this data"),
        ("validation", SchemaValidation, "Validate this data"),
        ("formatage", SchemaFinal, "Format the final result"),
    ]

    donnees_courantes = texte
    for nom, schema, instruction in etapes:
        try:
            _, parsed = client.chat.parse(
                model="grok-4.20-0309-reasoning",
                messages=[{
                    "role": "user",
                    "content": f"{instruction}: {donnees_courantes}"
                }],
                response_format=schema
            )
            resultats.append(PipelineResult(
                etape=nom, succes=True,
                donnees=parsed.model_dump(),
                erreurs=[], duree_ms=0
            ))
            donnees_courantes = parsed.model_dump_json()
        except Exception as e:
            resultats.append(PipelineResult(
                etape=nom, succes=False,
                donnees={}, erreurs=[str(e)], duree_ms=0
            ))
            break

    return resultats

Geriausios gamybinės praktikos

Idempotentiškumas

Kurkite konvejerius taip, kad juos būtų galima paleisti iš naujo be šalutinių poveikių. Tas pats dokumentas, apdorotas du kartus, turi duoti tą patį rezultatą.

Struktūrizuotas registravimas

Registruokite kiekvieną kvietimą su naudota schema, sunaudotų tokenų skaičiumi ir atsako laiku.

Pakartotiniai bandymai su eksponentine pauze

import time

def appel_avec_retry(messages, schema, max_retries=3):
    for tentative in range(max_retries):
        try:
            return client.chat.parse(
                model="grok-4.20-0309-reasoning",
                messages=messages,
                response_format=schema
            )
        except Exception as e:
            if tentative < max_retries - 1:
                time.sleep(2 ** tentative)
            else:
                raise

Stebėsena

Sekite šiuos rodiklius kiekvienam konvejeriui:

  • Sėkmės rodiklis kiekviename žingsnyje
  • Vidutinis apdorojimo laikas
  • Sunaudotų tokenų skaičius
  • Atsarginių sprendimų (fallback) dažnumas

Kurso santrauka

Per šias 12 pamokų išmokai:

  • Suprasti struktūrizuotą išvestį ir jos garantijas
  • Įvaldyti palaikomus tipus ir jų ribas
  • Naudoti parse() ir response_format pagal savo poreikius
  • Apibrėžti schemas naudodamas Pydantic (Python) ir Zod (JavaScript)
  • Derinti struktūrizuotą išvestį su žiniatinklio paieška ir kodo vykdymu
  • Kurti duomenų ištraukimo, klasifikavimo ir validavimo konvejerius

Struktūrizuota išvestis paverčia didžiuosius kalbos modelius iš pokalbių įrankių į patikimus programinės įrangos komponentus, integruojamus į bet kokią architektūrą.

Svarbiausi punktai

  • Daugiažingsnėse darbo eigose kiekvienam žingsniui naudojama atskira schema
  • Kryžminis validavimas lygina ištrauktus rezultatus su referenciniais šaltiniais
  • Gamyboje: idempotentiškumas, struktūrizuotas registravimas, pakartotiniai bandymai su eksponentine pauze, stebėsena
  • Struktūrizuota išvestis yra bet kokio patikimo DI konvejerio pagrindas
  • Derinkite schemas (struktūra) + prompts (turinys) + įrankiai (duomenys), kad gautumėte optimalių rezultatų

Patikrink savo žinias

Garantuotas JSON, schemos, konvejeriai: struktūrizuota išvestis, Grok versija.

1. Ką garantuoja struktūrizuota išvestis pagal schemą?

Atsakymas: Išvestį, griežtai atitinkančią deklaruotą JSON schemą – tipus, laukus, struktūrą – kurią kodas gali naudoti be apsauginio analizavimo: formatas yra suvaržytas generavimo metu.

2. Ką prideda `parse()` metodas, palyginti su rankiniu `response_format`?

Atsakymas: Visiškai automatizuotą ciklą: Pydantic modelis (arba Zod JS) deklaruoja schemą, o atsakas grįžta jau validuotas ir tipizuotas kaip objektas – jokių papildomų darbų.

3. Kodėl svarbu žinoti nepalaikomus tipus?

Atsakymas: Nes schema, naudojanti nepalaikomas konstrukcijas, nepavyks arba veiks netinkamai: savo modelius kuriate priimtinoje poaibyje ir validuojate išvestį.

4. Ką leidžia derinti struktūrizuota išvestis + žiniatinklio paieška arba kodo vykdymas?

Atsakymas: Konvejerius, kuriuose paieška arba skaičiavimai maitina struktūrizuotą išvestį: naujausia arba apskaičiuota informacija patenka tiesiai į jūsų tipizuotus laukus.

5. Įvardinkite du tipinius naudojimo atvejus gamyboje.

Atsakymas: Entitetų ištraukimas ir klasifikavimas (dokumentai, užklausos, turinys), sujungti su jūsų sistemomis – automatizuotos darbo eigos, kuriose DI užpildo struktūras, o ne pastraipas.

Deklaruota schema, suvaržytas generavimas, išvesties validavimas: struktūrizuota išvestis yra sąsaja tarp Grok ir tavo programinės įrangos – elgkis su ja kaip su tokia.