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: ConfidentValori 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] = NoneStrategie 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] = NoneInstradamento 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: DateFieldRegistrazione 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
- Instructor: estrazione tipizzata con Pydantic
- Gestire dati parziali e mancanti
- Elaborazione batch con async e code
- Evoluzione degli schemi e compatibilità con le versioni precedenti