AI Engineering Academy · Lektion

Håndtering af delvise og manglende data

Design skemaer med Optional-felter og konfidensscorer, implementér fallback-strategier til udtræk fra tvetydige dokumenter, og log udtræk med lav konfidens til menneskelig gennemgang.

Lektion 2 af 413 trin

Håndtering af delvise og manglende data er en gratis AI Engineering Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i AI Engineering Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. AI Engineering Academy-kurset indeholder 4 lektioner i alt.

Virkeligheden med ufuldstændige dokumenter

Dokumenter fra den virkelige verden indeholder sjældent alle de felter, som dit skema forventer. En faktura mangler måske et PO-nummer, et CV indeholder måske ikke datoer, og en nyhedsartikel nævner måske ikke en placering. Det er lige så vigtigt at designe dit udtrækningsskema, så det håndterer delvise og manglende data på en robust måde, som at udtrække det, der er til stede.

Valgfrie felter i Pydantic

Markér felter, der måske ikke forekommer i alle dokumenter, som Optional[type], og giv dem standardværdien None. Pydantic v2 behandler disse felter som nullable, og modellen instrueres i ikke at opfinde værdier, når oplysninger mangler. Foretræk altid None frem for en tom streng ved manglende data — det er lettere at filtrere senere i behandlingen.

from pydantic import BaseModel, Field
from typing import Optional

class JobPosting(BaseModel):
    title: str
    company: str
    salary_min: Optional[float] = Field(None, description='Minimum salary if stated')
    salary_max: Optional[float] = Field(None, description='Maximum salary if stated')
    remote: Optional[bool] = Field(None, description='True if remote, False if on-site, None if unspecified')

Tilføjelse af konfidensscorer

Bed modellen vurdere sin egen sikkerhed for hvert udtrukket felt ved at tilføje en konfidensscore sammen med værdien. Indpak begge dele i hjælpeklassen FieldExtract. Udtrækninger med lav konfidens kan sendes til menneskelige kontrollører i stedet for direkte til efterfølgende systemer, hvilket reducerer risikoen for ubemærket fejlbehæftede data.

from pydantic import BaseModel
from typing import Optional

class Confident(BaseModel):
    value: Optional[str]
    confidence: float  # 0.0 to 1.0

class ContractExtract(BaseModel):
    party_a: Confident
    party_b: Confident
    effective_date: Confident
    termination_clause: Confident

Sentinelværdier kontra None

Nogle gange er fraværet af data i sig selv meningsfuldt. Brug Pythons Optional sammen med en Literal-enum til at skelne mellem ikke nævnt, udtrykkeligt angivet som ingen og ukendt. Denne tredelte skelnen forhindrer efterfølgende kode i at behandle et udtrykkeligt angivet fravær på samme måde som en manglende omtale, hvilket kan give subtile fejl i forretningslogikken.

from pydantic import BaseModel
from typing import Optional, Literal

class Discount(BaseModel):
    # 'none' = explicitly no discount; None = not mentioned
    discount_type: Optional[Literal['percentage', 'fixed', 'none']] = None
    discount_value: Optional[float] = None

Strategier for reserveudtrækning

Når et primært udtrækningskald returnerer for mange felter med None, kan du prøve en målrettet opfølgende prompt, der specifikt fokuserer på de manglende oplysninger. Send kun det relevante afsnit sammen med den delvist udtrukne model, og bed modellen udfylde de tomme felter. Denne tilgang med to gennemløb forbedrer genfindingen betydeligt i tvetydige dokumenter.

def fill_missing(partial: JobPosting, raw_text: str) -> JobPosting:
    missing = [k for k, v in partial.model_dump().items() if v is None]
    if not missing:
        return partial
    prompt = f'From this text, extract ONLY these fields: {missing}.\n\n{raw_text}'
    supplement = client.chat.completions.create(
        model='gpt-4o-mini',
        response_model=JobPosting,
        messages=[{'role': 'user', 'content': prompt}]
    )
    merged = partial.model_dump()
    for field in missing:
        if getattr(supplement, field) is not None:
            merged[field] = getattr(supplement, field)
    return JobPosting(**merged)

Brug af standardværdier og fabriksfunktioner

Til felter, der har en fornuftig standardværdi, når de mangler, skal du bruge Pydantics default eller default_factory. En liste med mærkater bør for eksempel som standard være en tom liste i stedet for None, så efterfølgende kode altid kan gennemløbe den. Brug None til felter, hvor fraværet skal markeres og håndteres eksplicit.

from pydantic import BaseModel, Field
from typing import List, Optional

class Article(BaseModel):
    title: str
    author: Optional[str] = None
    tags: List[str] = Field(default_factory=list)
    word_count: Optional[int] = None
    published_date: Optional[str] = None

Videresendelse af udtrækninger med lav konfidens

Opret en kontrolkø til udtrækninger, hvis konfidens ligger under en tærskel. Gem resultater med lav konfidens i en separat databasetabel med flaget needs_review, vis dem i en intern kontrolbrugergrænseflade, og giv menneskelige annotatorer mulighed for at rette dem. Brug rettelserne som few-shot-eksempler for at forbedre fremtidige udtrækninger.

CONFIDENCE_THRESHOLD = 0.75

def process_extraction(result: ContractExtract, doc_id: str):
    needs_review = any(
        field.confidence < CONFIDENCE_THRESHOLD
        for field in [result.party_a, result.party_b, result.effective_date]
    )
    if needs_review:
        queue_for_human_review(doc_id, result)
    else:
        store_in_production_table(doc_id, result)

Håndtering af tvetydige tekstudsnit

Nogle felter kan udtrækkes på flere gyldige måder fra den samme tekst. En dato som 'næste mandag' er for eksempel tvetydig uden en referencedato. Brug et felt med navnet raw_span til at gemme den nøjagtige tekst, modellen brugte, sammen med den normaliserede værdi. Det bevarer det oprindelige belæg og gør fejlfinding af udtrækninger meget lettere.

from pydantic import BaseModel
from typing import Optional

class DateField(BaseModel):
    raw_span: Optional[str] = None    # exact text from document
    iso_date: Optional[str] = None    # normalized YYYY-MM-DD
    confidence: float = 1.0

class Contract(BaseModel):
    effective_date: DateField
    expiration_date: DateField

Logning af mønstre for manglende felter

Hold styr på, hvilke felter der oftest er None på tværs af din dokumentsamling. En høj andel af manglende værdier i et påkrævet felt tyder enten på, at feltet reelt mangler i de fleste dokumenter, eller på, at din skemabeskrivelse forvirrer modellen. Logning af manglende mønstre pr. dokumenttype hjælper dig med at prioritere skemaforbedringer, der vil have størst betydning for datakvaliteten.

from collections import Counter

missing_counter = Counter()

def log_missing(result):
    for field, value in result.model_dump().items():
        if value is None:
            missing_counter[field] += 1

# After processing 1000 documents:
for field, count in missing_counter.most_common(5):
    print(f'{field}: {count} missing ({100*count//1000}%)')

Kombination af udtrækninger på tværs af flere gennemløb

Til komplekse dokumenter som årsrapporter eller lange kontrakter fungerer en strategi med udtrækning i flere gennemløb bedst. I det første gennemløb udtrækker du felter med høj konfidens, som altid er til stede. I de efterfølgende gennemløb fokuserer du på bestemte sektioner eller afsnit for at udtrække de vanskeligere felter. Flet alle gennemløb til én endelig post, og lad senere gennemløb overskrive tidligere værdier med None.

def multi_pass_extract(pages: list) -> Invoice:
    # Pass 1: header info from first page
    header = extract_header(pages[0])
    # Pass 2: line items from middle pages
    items = []
    for page in pages[1:-1]:
        items.extend(extract_line_items(page))
    # Pass 3: totals from last page
    totals = extract_totals(pages[-1])
    return Invoice(
        vendor=header.vendor,
        invoice_number=header.invoice_number,
        line_items=items,
        total_amount=totals.total_amount
    )

Bedste praksis for skemadesign

Veldesignede skemaer reducerer naturligt mængden af manglende data. Brug snævre, specifikke feltbeskrivelser, så modellen ved præcis, hvad den skal lede efter. Undgå at kombinere to begreber i ét felt. Tilføj examples i feltbeskrivelsen for at vejlede udtrækningen. Et skema, der gør modellens opgave let, vil have langt færre manglende felter end et skema, der baserer sig på uklare betegnelser.

from pydantic import BaseModel, Field

class Address(BaseModel):
    street: str = Field(description='Street number and name, e.g. 123 Main St')
    city: str = Field(description='City name only, no state')
    state: str = Field(description='Two-letter US state code, e.g. CA')
    zip_code: str = Field(description='5-digit ZIP code, e.g. 94105')
    country: str = Field(default='US', description='ISO 3166-1 alpha-2 country code')

Hurtigt tjek

Test din forståelse af håndtering af delvise og manglende data i udtrækningspipelines.

Opsummering af lektionen

I denne lektion lærte du, at valgfrie felter med standardværdien None forhindrer modellen i at opfinde manglende data, at konfidensscorer og kontrolkøer skaber et sikkerhedsnet for usikre udtrækninger, og at udtrækning i flere gennemløb forbedrer genfindingen i komplekse dokumenter ved at fokusere hvert gennemløb på bestemte sektioner. Næste gang skalerer vi udtrækningen med asynkron behandling og køer.

Gratis at komme i gang

Lær Python med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser
30
Lektioner
120

Ofte stillede spørgsmål

Er lektionen “Håndtering af delvise og manglende data” gratis?

Ja — hele teksten til “Håndtering af delvise og manglende data” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af AI Engineering Academy-kurset, skal du opgradere til CoddyKit PRO. AI Engineering Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Håndtering af delvise og manglende data”?

Design skemaer med Optional-felter og konfidensscorer, implementér fallback-strategier til udtræk fra tvetydige dokumenter, og log udtræk med lav konfidens til menneskelig gennemgang. Du øver dig i AI Engineering Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på AI Engineering Academy?

Der kræves ingen tidligere erfaring. AI Engineering Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “Håndtering af delvise og manglende data”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne AI Engineering Academy-lektion?

Ja. Alle AI Engineering Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

  1. Instructor: Typet udtræk med Pydantic
  2. Håndtering af delvise og manglende data
  3. Batchbehandling med async og køer
  4. Skemaudvikling og bagudkompatibilitet
← Tilbage til AI Engineering Academy