Darbo eigos ir duomenų apdorojimo konvejeriai
Šiame puslapyje
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()irresponse_formatpagal 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.