AI Engineering Academy · Lektion

Hantera partiella och saknade data

Utforma scheman med fält av typen Optional och konfidenspoäng, implementera reservstrategier för extraktion från tvetydiga dokument och logga extraktioner med låg konfidens för mänsklig granskning.

Lektion 2 av 413 steg

Hantera partiella och saknade data är en gratis lektion i AI Engineering Academy på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för AI Engineering Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i AI Engineering Academy innehåller totalt 4 lektioner.

Verkligheten med ofullständiga dokument

Dokument från verkligheten innehåller sällan alla fält som ert schema förväntar sig. En faktura kan sakna ett inköpsordernummer, ett CV kan utelämna datum och en nyhetsartikel kanske inte nämner någon plats. Att utforma ert extraheringsschema så att det hanterar partiella och saknade data på ett robust sätt är lika viktigt som att extrahera det som faktiskt finns.

Valfria fält i Pydantic

Markera fält som kanske inte förekommer i alla dokument som Optional[type] och ge dem standardvärdet None. Pydantic v2 behandlar dessa fält som nullbara, och modellen instrueras att inte hitta på värden när information saknas. Föredra alltid None framför en tom sträng för saknade data — det är enklare att filtrera senare i flödet.

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')

Lägg till konfidenspoäng

Be modellen bedöma sin egen säkerhet för varje extraherat fält genom att lägga till en konfidenspoäng bredvid värdet. Omslut båda i en generisk hjälpklass med namnet FieldExtract. Extraheringar med låg konfidens kan skickas till mänskliga granskare i stället för direkt till efterföljande system, vilket minskar risken för att felaktiga data passerar obemärkt.

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ärden jämfört med None

Ibland är frånvaron av data i sig meningsfull. Använd Pythons Optional tillsammans med en Literal-enum för att skilja mellan inte omnämnt, uttryckligen angivet som inget och okänt. Denna trevägsskillnad hindrar efterföljande kod från att behandla en uttryckligen angiven frånvaro på samma sätt som ett utelämnat omnämnande, vilket kan orsaka subtila fel i affärslogiken.

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 för reservextrahering

När ett primärt extraheringsanrop returnerar för många fält med None kan ni prova en riktad uppföljningsprompt som fokuserar specifikt på den information som saknas. Skicka endast det relevanta stycket tillsammans med den delvis extraherade modellen och be modellen fylla i endast de tomma fälten. Denna tvåstegsmetod förbättrar täckningen avsevärt för tvetydiga dokument.

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)

Använd standardvärden och fabriker

För fält som har ett rimligt standardvärde när data saknas använder ni Pythons default eller default_factory. En tagglista bör till exempel ha en tom lista som standardvärde i stället för None, så att efterföljande kod alltid kan iterera över den. Reservera None för fält där frånvaron måste markeras och hanteras uttryckligen.

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

Dirigera extraheringar med låg konfidens

Skapa en granskningskö för extraheringar vars konfidens ligger under ett tröskelvärde. Lagra resultat med låg konfidens i en separat databastabell med flaggan needs_review, visa dem i ett internt granskningsgränssnitt och låt mänskliga annoterare korrigera dem. Mata tillbaka korrigeringarna som few-shot-exempel för att förbättra framtida extraheringar.

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)

Hantera tvetydiga textavsnitt

Vissa fält kan extraheras på flera giltiga sätt från samma text. Ett datum som skrivs som ”nästa måndag” är till exempel tvetydigt utan ett referensdatum. Använd ett fält med namnet raw_span för att fånga den exakta text som modellen använde, tillsammans med det normaliserade värdet. Då bevaras det ursprungliga underlaget och felsökningen av extraheringar blir mycket enklare.

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

Logga mönster för saknade fält

Följ vilka fält som oftast är None i hela er dokumentsamling. En hög andel saknade värden för ett obligatoriskt fält tyder på att fältet antingen faktiskt saknas i de flesta dokument eller att schemabeskrivningen förvirrar modellen. Genom att logga mönster för saknade fält per dokumenttyp blir det enklare att prioritera schemaförbättringar som får störst effekt på 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}%)')

Kombinera extrahering över flera pass

För komplexa dokument som årsredovisningar eller långa avtal fungerar en extraheringsstrategi i flera pass bäst. Extrahera i det första passet fält med hög konfidens som alltid finns med. Fokusera i efterföljande pass på specifika avsnitt eller stycken för att extrahera de svårare fälten. Slå samman alla pass till en enda slutpost och låt senare pass skriva över tidigare värden som är 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
    )

Bästa praxis för schemadesign

Välutformade scheman minskar naturligt mängden saknade data. Använd smala och specifika fältbeskrivningar så att modellen vet exakt vad den ska leta efter. Undvik att kombinera två begrepp i ett enda fält. Lägg till examples i fältbeskrivningen för att vägleda extraheringen. Ett schema som gör modellens uppgift enkel får betydligt färre saknade fält än ett som förlitar sig på vaga etiketter.

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')

Snabb kontroll

Testa er förståelse av hur partiella och saknade data hanteras i extraheringspipelines.

Sammanfattning av lektionen

I den här lektionen lärde ni er att valfria fält med standardvärdet None förhindrar att saknade data hittas på, att konfidenspoäng och granskningsköer skapar ett skyddsnät för osäkra extraheringar och att extrahering i flera pass förbättrar täckningen för komplexa dokument genom att varje pass fokuserar på specifika avsnitt. Härnäst skalar vi upp extraheringen med asynkron bearbetning och köer.

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
30
Lektioner
120

Vanliga frågor

Är lektionen ”Hantera partiella och saknade data” gratis?

Ja – hela texten till ”Hantera partiella och saknade data” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i AI Engineering Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i AI Engineering Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Hantera partiella och saknade data”?

Utforma scheman med fält av typen Optional och konfidenspoäng, implementera reservstrategier för extraktion från tvetydiga dokument och logga extraktioner med låg konfidens för mänsklig granskning. Ni övar på AI Engineering Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig AI Engineering Academy?

Du behöver inga förkunskaper. Utbildningen i AI Engineering Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Hantera partiella och saknade data”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här AI Engineering Academy-lektionen?

Ja. Varje AI Engineering Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. Instructor: typad extraktion med Pydantic
  2. Hantera partiella och saknade data
  3. Batchbearbetning med async och köer
  4. Schemautveckling och bakåtkompatibilitet
← Tillbaka till AI Engineering Academy