0Pricing
AI Engineering Academy · Lezione

Gestire dati parziali e mancanti

Progetti schemi con campi Optional e punteggi di affidabilità, implementi strategie di fallback per l'estrazione da documenti ambigui e registri le estrazioni con bassa affidabilità per la revisione umana.

Gestire dati parziali e mancanti è una lezione AI Engineering Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Engineering Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Engineering Academy include 4 lezioni in totale.

La realtà dei documenti incompleti

I documenti reali raramente contengono tutti i campi previsti dallo schema. In una fattura potrebbe mancare il numero d'ordine d'acquisto, in un curriculum potrebbero non comparire le date e in un articolo di giornale potrebbe non essere indicata una località. Progettare lo schema di estrazione per gestire correttamente i dati parziali e mancanti è importante quanto estrarre ciò che è presente.

Campi opzionali in Pydantic

Indichi come Optional[type] i campi che potrebbero non comparire in ogni documento e assegni loro il valore predefinito None. Pydantic v2 tratta questi campi come nullable e indica al modello di non inventare valori quando le informazioni sono assenti. Per i dati mancanti, preferisca sempre None a una stringa vuota: sarà più facile filtrarli nelle fasi successive.

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

Aggiunta dei punteggi di confidenza

Chieda al modello di valutare la propria confidenza in ogni campo estratto aggiungendo un punteggio di confidenza accanto al valore. Racchiuda entrambi in un helper generico FieldExtract. Le estrazioni con bassa confidenza possono essere indirizzate a revisori umani invece di essere passate direttamente ai sistemi downstream, riducendo il rischio di dati errati non rilevati.

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

Valori sentinella e None

A volte l'assenza di dati è significativa di per sé. Utilizzi l'Optional di Python insieme a un'enum Literal per distinguere tra non menzionato, esplicitamente indicato come assente e sconosciuto. Questa distinzione in tre casi impedisce al codice downstream di trattare un'assenza esplicita come una mancata menzione, cosa che può causare bug sottili nella logica di business.

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

Strategie di fallback per l'estrazione

Quando una chiamata di estrazione primaria restituisce troppi campi None, provi un prompt di follow-up mirato che si concentri specificamente sulle informazioni mancanti. Invii solo il paragrafo pertinente insieme al modello parzialmente estratto e chieda al modello di compilare esclusivamente i campi vuoti. Questo approccio a due passaggi migliora significativamente il recall sui documenti ambigui.

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)

Utilizzo di valori predefiniti e factory

Per i campi che hanno un valore predefinito sensato quando l'informazione manca, utilizzi default o default_factory di Pydantic. Ad esempio, una lista di tag dovrebbe avere come valore predefinito una lista vuota anziché None, così il codice downstream potrà sempre iterarvi. Riservi None ai campi per cui l'assenza deve essere segnalata e gestita esplicitamente.

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

Instradamento delle estrazioni a bassa confidenza

Crei una coda di revisione per le estrazioni con una confidenza inferiore a una soglia. Memorizzi i risultati con bassa confidenza in una tabella separata del database con un flag needs_review, li esponga in un'interfaccia interna di revisione e consenta agli annotatori umani di correggerli. Riutilizzi le correzioni come esempi few-shot per migliorare le estrazioni future.

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)

Gestione degli intervalli di testo ambigui

Alcuni campi possono essere estratti in più modi validi dallo stesso testo. Ad esempio, una data scritta come 'lunedì prossimo' è ambigua senza una data di riferimento. Utilizzi un campo raw_span per acquisire il testo esatto usato dal modello, insieme al valore normalizzato. In questo modo conserva l'evidenza originale e rende molto più semplice il debugging delle estrazioni.

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

Registrazione dei pattern dei campi mancanti

Monitori quali campi assumono più spesso il valore None nel corpus di documenti. Un'elevata frequenza di assenza per un campo obbligatorio suggerisce che il campo sia effettivamente assente nella maggior parte dei documenti oppure che la descrizione dello schema confonda il modello. La registrazione dei pattern di assenza per tipo di documento aiuta a stabilire quali miglioramenti allo schema avranno il maggiore impatto sulla qualità dei dati.

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

Combinazione delle estrazioni in più passaggi

Per documenti complessi come relazioni annuali o contratti lunghi, funziona meglio una strategia di estrazione in più passaggi. Nel primo passaggio estragga i campi ad alta confidenza che sono sempre presenti. Nei passaggi successivi si concentri su sezioni o paragrafi specifici per estrarre i campi più difficili. Unisca tutti i passaggi in un unico record finale, consentendo ai passaggi successivi di sovrascrivere i valori None precedenti.

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
    )

Best practice per la progettazione degli schemi

Gli schemi ben progettati riducono naturalmente i dati mancanti. Utilizzi descrizioni dei campi specifiche e circoscritte, così il modello saprà esattamente cosa cercare. Eviti di combinare due concetti in un unico campo. Aggiunga examples nella descrizione del campo per guidare l'estrazione. Uno schema che facilita il lavoro del modello avrà molti meno campi mancanti rispetto a uno basato su etichette vaghe.

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

Verifica rapida

Verifichi la comprensione della gestione dei dati parziali e mancanti nelle pipeline di estrazione.

Riepilogo della lezione

In questa lezione ha imparato che i campi opzionali con valori predefiniti None impediscono al modello di inventare dati mancanti; i punteggi di confidenza e le code di revisione creano una rete di sicurezza per le estrazioni incerte; e l'estrazione in più passaggi migliora il recall sui documenti complessi concentrando ogni passaggio su sezioni specifiche. Nella prossima lezione aumenteremo la scala dell'estrazione con l'elaborazione asincrona e le code.

Domande Frequenti

La lezione «Gestire dati parziali e mancanti» è gratuita?

Sì — il testo completo di «Gestire dati parziali e mancanti» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Engineering Academy, passa a CoddyKit PRO. Il corso AI Engineering Academy include 4 lezioni in totale.

Cosa imparerò in «Gestire dati parziali e mancanti»?

Progetti schemi con campi Optional e punteggi di affidabilità, implementi strategie di fallback per l'estrazione da documenti ambigui e registri le estrazioni con bassa affidabilità per la revisione… Eserciti AI Engineering Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare AI Engineering Academy?

Non è richiesta alcuna esperienza precedente. AI Engineering Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Gestire dati parziali e mancanti»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione AI Engineering Academy?

Sì. Ogni lezione AI Engineering Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Instructor: estrazione tipizzata con Pydantic
  2. Gestire dati parziali e mancanti
  3. Elaborazione batch con async e code
  4. Evoluzione degli schemi e compatibilità con le versioni precedenti
← Torna a AI Engineering Academy