Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Automatiseeritud töövood ja torustikud

Õppetund 12 / 12 Värskendatud 30. juuli 2026 Arendajatele
Sellel lehel
  1. Tootmiskeskkonda viimine
  2. Töövoog: dokumentide töötlemine
  3. Andmete kinnituse torustik
  4. Mitmeastmelise torustiku arhitektuur
  5. Parimad tavad tootmiskeskkonnas
  6. Kursuse kokkuvõte
  7. Peamised punktid
  8. Testi oma teadmisi

Tootmiskeskkonda viimine

Eelmistes tundides käsitlesid sa aluseid ja üksikuid kasutusjuhtumeid. See viimane tund seob kõik kokku, et luua automatiseeritud töövood ja kinnitustorustikud, mis on valmis tootmiskeskkonnas kasutamiseks.

Töövoog: dokumentide töötlemine

Täielik torustik sissetulevate dokumentide automaatseks töötlemiseks:

from pydantic import BaseModel
from typing import Literal

# Step 1: Document classification
class ClassificationDocument(BaseModel):
    type: Literal["facture", "contrat", "devis", "courrier", "autre"]
    langue: str
    urgence: Literal["basse", "normale", "haute"]
    departement: Literal["comptabilite", "juridique", "commercial", "direction"]

# Step 2: Extraction by type
class DonneesFacture(BaseModel):
    numero: str
    date_emission: str
    date_echeance: str
    emetteur: str
    montant_ht: float
    montant_ttc: float
    lignes: list[dict]

# Step 3: Validation
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):
    # Classify
    _, classification = client.chat.parse(
        model="grok-4.20-0309-reasoning",
        messages=[{"role": "user", "content": f"Classify this document: {texte}"}],
        response_format=ClassificationDocument
    )

    # Extract by type
    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
        )

    # Validate
    _, 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

Andmete kinnituse torustik

Kasuta struktureeritud väljundeid sissetulevate andmete kinnitamiseks ja normaliseerimiseks:

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]

See torustik võtab erinevates vormingutes kontakte ja normaliseerib need ühtseks struktuuriks.

Mitmeastmelise torustiku arhitektuur

Siin on töökindla tootmistorustiku luustik:

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

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

    # Each step uses a dedicated schema
    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

Parimad tavad tootmiskeskkonnas

Idempotentsus

Kujunda oma torustikud nii, et neid saaks kõrvalmõjudeta uuesti käivitada. Sama dokument, mida töödeldakse kaks korda, peab andma sama tulemuse.

Struktureeritud logimine

Logi iga päring koos kasutatud skeemi, tokenite arvu ja vastuse ajaga.

Korduskatsed viivitusega (Backoff)

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

Jälgimine

Jälgi iga torustiku puhul järgmisi näitajaid:

  • Õnnestumise määr etapi kohta
  • Keskmine töötlemisaeg
  • Tarbitud tokenite arv
  • Varuvariandi kasutamise sagedus

Kursuse kokkuvõte

Nende 12 tunni jooksul õppisid sa:

  • Mõistma struktureeritud väljundeid ja nende garantiisid
  • Valdama toetatud tüüpe ja nende piiranguid
  • Kasutama parse() ja response_format vastavalt oma vajadustele
  • Määratlema skeeme Pydanticu (Python) ja Zodi (JavaScript) abil
  • Kombineerima struktureeritud väljundeid veebiotsingu ja koodi käivitamisega
  • Ehitama ekstraheerimis-, klassifitseerimis- ja kinnitustorustikke

Struktureeritud väljundid muudavad suure keelemudeli (LLM) vestlusriistadest usaldusväärseteks tarkvarakomponentideks, mida saab integreerida ükskõik millisesse arhitektuuri.

Peamised punktid

  • Mitmeastmelised töövood kasutavad iga sammu jaoks spetsiaalset skeemi
  • Ristkinnitus võrdleb ekstraheerimise tulemusi võrdlusallikatega
  • Tootmiskeskkonnas: idempotentsus, struktureeritud logimine, korduskatsed viivitusega, jälgimine
  • Struktureeritud väljundid on iga usaldusväärse tehisintellekti torustiku alus
  • Kombineeri skeeme (struktuur) + vihjeid (sisu) + tööriistu (andmed) optimaalsete tulemuste saavutamiseks

Testi oma teadmisi

Garanteeritud JSON, skeemid, torustikud: struktureeritud väljund, Groki versioon.

1. Mida garanteerib skeemi põhine struktureeritud väljund?

Vastus: Väljund, mis on rangelt kooskõlas deklareeritud JSON-skeemiga – tüübid, väljad, struktuur – ja mida saab koodis kasutada ilma kaitsva parsimiseta: vorming on genereerimise ajal piiratud.

2. Mida lisab meetod parse() võrreldes käsitsi määratud response_format'iga?

Vastus: Täielikult automatiseeritud tsükli: Pydanticu mudel (või Zodi JS-is) deklareerib skeemi ja vastus saabub juba kinnitatud ja tüübitud objektina – null tarbetut koodi.

3. Miks on oluline teada toetamata tüüpe?

Vastus: Sest toetamata konstruktsioone kasutav skeem ebaõnnestub või halveneb: sa kujundad oma mudeleid aktsepteeritud alamhulga piires ja kinnitad väljundit.

4. Mida võimaldab struktureeritud väljundite kombineerimine veebiotsingu või koodi käivitamisega?

Vastus: Torustikke, kus otsing või arvutus toidab struktureeritud väljundit: värske või arvutatud teave jõuab otse sinu tüübitud väljadele.

5. Too kaks tüüpilist kasutusjuhtu tootmiskeskkonnas.

Vastus: Entiteetide ekstraheerimine ja klassifitseerimine (dokumendid, piletid, sisu), mis on ühendatud sinu süsteemidega – automatiseeritud töövood, kus tehisintellekt täidab struktuure, mitte lõike.

Deklareeritud skeem, piiratud genereerimine, väljundi kinnitus: struktureeritud väljund on liides Groki ja sinu tarkvara vahel – kohtle seda ka nii.