Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Sreabha oibre uathoibrithe agus píblínte

Ceacht 12 as 12 Nuashonraithe 30 Iúil 2026 Forbróir
Ar an leathanach seo
  1. Ag bogadh chuig an táirgeadh
  2. Sreabhadh oibre: próiseáil doiciméad
  3. Píblíne bailíochtaithe sonraí
  4. Ailtireacht píblíne ilchéime
  5. Dea-chleachtais táirgeachta
  6. Achoimre ar an gcúrsa
  7. Príomhphointí
  8. Tástáil do chuid eolais

Ag bogadh chuig an táirgeadh

Chumhdaigh na ceachtanna roimhe seo na bunúsacha agus cásanna úsáide aonair. Tugann an ceacht deiridh seo gach rud le chéile chun sreabha oibre uathoibrithe agus píblínte bailíochtaithe a thógáil atá réidh don táirgeadh.

Sreabhadh oibre: próiseáil doiciméad

Píblíne iomlán chun doiciméid isteach a phróiseáil go huathoibríoch:

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

Píblíne bailíochtaithe sonraí

Úsáid aschuir struchtúrtha chun sonraí isteach a bhailíochtú agus a normalú:

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]

Glacann an píblíne seo le teagmhálacha i bhformáidí éagsúla agus déanann sé iad a normalú ina struchtúr aonfhoirmeach.

Ailtireacht píblíne ilchéime

Seo creatlach píblíne táirgeachta láidre:

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

Dea-chleachtais táirgeachta

Idempotence

Dear do phíblínte ionas gur féidir iad a athrith gan fo-iarsmaí. Caithfidh an doiciméad céanna a phróiseáiltear faoi dhó an toradh céanna a tháirgeadh.

Logáil struchtúrtha

Déan logáil ar gach glao leis an scéama a úsáideadh, líon na dtócan, agus an t-am freagartha.

Atriail le cúlú

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

Monatóireacht

Rianaigh na méadrachtaí seo do gach píblíne:

  • Ráta ratha in aghaidh na céime
  • Meán-am próiseála
  • Líon na dtócan a úsáideadh
  • Minicíocht fillte

Achoimre ar an gcúrsa

Thar na 12 cheacht seo, d’fhoghlaim tú conas:

  • Tuiscint a fháil ar aschuir struchtúrtha agus ar a mbannaí
  • Máistreacht a dhéanamh ar chineálacha tacaithe agus ar a dteorainneacha
  • Úsáid a bhaint as parse() agus response_format de réir do riachtanas
  • Sainmhíniú a dhéanamh ar scéimí le Pydantic (Python) agus Zod (JavaScript)
  • Comhcheangal aschuir struchtúrtha le cuardach gréasáin agus le cur i gcrích cóid
  • Tógáil píblínte eastósctha, aicmithe agus bailíochtaithe

Déanann aschuir struchtúrtha uirlisí comhráite de LLManna ina comhpháirteanna bogearraí iontaofa is féidir a chomhtháthú in aon ailtireacht.

Príomhphointí

  • Úsáideann sreabha oibre ilchéime scéama tiomnaithe in aghaidh na céime
  • Déanann tras-bhailíochtú comparáid idir torthaí eastósctha agus foinse tagartha
  • Sa táirgeadh: idempotence, logáil struchtúrtha, atriail le cúlú, monatóireacht
  • Is bunús é aschur struchtúrtha d’aon phíblíne AI iontaofa
  • Comhcheangail scéimí (struchtúr) + leidcheisteanna (ábhar) + uirlisí (sonraí) chun torthaí optamacha a fháil

Tástáil do chuid eolais

JSON ráthaithe, scéimí, píblínte: aschur struchtúrtha, leagan Grok.

1. Cad a ráthaíonn aschur struchtúrtha de réir scéama?

Freagra: Aschur atá go hiomlán comhlíontach leis an scéama JSON dearbhaithe—cineálacha, réimsí, struchtúr—inúsáidte ag cód gan parsáil chosantach: tá an fhormáid srianta ag an nginiúint.

2. Cad a chuireann an modh parse() leis i gcomparáid le response_format láimhe?

Freagra: An lúb uathoibrithe go hiomlán: dearbhaíonn an tsamhail Pydantic (nó Zod i JS) an scéama, agus tagann an freagra ar ais bailíochtaithe agus clóscríofa mar oibiacht cheana féin—gan aon phíobaireacht.

3. Cén fáth a bhfuil sé tábhachtach a bheith ar an eolas faoi chineálacha nach dtacaítear leo?

Freagra: Toisc go dteipeann ar scéama a úsáideann tógálacha nach dtacaítear leo nó go ndéantar é a dhíghrádú: dearann tú do shamhlacha laistigh den fho-thacar glactha agus déanann tú bailíochtú ar an aschur.

4. Cad a cheadaíonn comhcheangal aschuir struchtúrtha + cuardach gréasáin nó cur i gcrích cóid?

Freagra: Píblínte ina gcothaíonn cuardach nó ríomhaireacht aschur struchtúrtha: tagann faisnéis úr nó ríofa isteach go díreach i do réimsí clóscríofa.

5. Tabhair dhá chás úsáide tipiciúla sa táirgeadh.

Freagra: Eastóscadh eintiteas agus aicmiú (doiciméid, ticéid, ábhar) nasctha le do chórais—sreabha oibre uathoibrithe ina líonann AI struchtúir, ní míreanna téacs.

Scéama dearbhaithe, giniúint shrianta, bailíochtú aschuir: is é an t-aschur struchtúrtha an t-idirghabhálaí idir Grok agus do bhogearraí—caith leis mar sin.