Regole di convalida - Documentazione di Entity Enricher

Regole di convalida

Otto regole di validazione garantiscono la qualità dello schema. Vengono eseguite nel codice una volta che la generazione dello schema tramite AI ha composto la propria risposta: una rete di sicurezza finale su una pipeline che si corregge già passo dopo passo.

Come funziona l'autocorrezione

La correzione avviene dove viene commesso l'errore, non alla fine. La generazione è una sequenza di piccole chiamate a singolo scopo e ciascuna porta con sé il proprio validatore: verifica la risposta di quella chiamata, conserva ciò che è valido e richiede nuovamente solo ciò che ancora manca. Un modello che risponde in modo frammentario converge quindi, anziché ricominciare da capo.

Flusso di correzione

Risposte del passaggioUna sola domanda circoscritta — ad esempio i flag per un batch di proprietà, oppure le descrizioni di un singolo dominio
Unioni del validatoreLe voci valide vengono accumulate; quelle inutilizzabili vengono scartate singolarmente, senza mai far perdere al batch le risposte corrette
Se incompletoIl nuovo tentativo richiede solo i percorsi ancora mancanti: fino a 3 tentativi per quel passaggio
Poi degradaLe lacune residue vengono colmate in modo deterministico e annotate sul record: un modello debole le costa in qualità della descrizione, non nello schema
AssemblaggioLe 8 regole seguenti vengono applicate allo schema completato come controllo finale

Solo due passaggi possono far fallire del tutto una generazione: l'assegnazione del nome all'entità e l'instradamento delle proprietà verso i domini di competenza. Tutto il resto dispone di un fallback deterministico, ed è ciò che rende utilizzabili qui i modelli di piccole dimensioni.

Regole di generazione vs. modifica

Non tutte le regole si applicano sia alla generazione dello schema sia alla modifica AI. Le regole che confrontano con i dati di input vengono ignorate durante la modifica, poiché potresti aggiungere o rimuovere campi intenzionalmente:

AmbitoRegole applicatePerché
GenerazioneTutte le 8 regoleI dati di input sono disponibili per il confronto
Modifica con l'AISolo le regole 2, 3, 4, 5Nessun dato di input; l'utente potrebbe modificare intenzionalmente la struttura

Le 8 regole

Regola 1

Numero di domini di competenza

Ambito: Solo generazione

Il numero di domini di competenza non deve superare il massimo calcolato in base al numero di proprietà. Ciò impedisce all'IA di creare troppi domini granulari per schemi di piccole dimensioni.

Errore di esempio: Too many expertise domains: 6 defined, maximum is 3

Il massimo è calcolato come floor(numero_proprietà / 6), con un minimo di 1. Uno schema con 12 proprietà consente fino a 2 domini.

Regola 2

Almeno una proprietà

Ambito: Entrambi

Ogni schema deve definire almeno una proprietà. Uno schema vuoto non può essere usato per l'enrichment.

Errore di esempio: Schema must have at least one property

Questo intercetta i casi in cui l'IA produce una struttura JSON valida ma dimentica di includere campi effettivi.

Regola 3

Tipi di JSON Schema validi

Ambito: Entrambi

Il tipo di ogni proprietà deve essere uno dei tipi standard di JSON Schema: string, number, integer, boolean, array, object o null.

Errore di esempio: revenue: invalid type 'float'

A volte l'IA inventa tipi come "float", "decimal" o "date". Questa regola li rileva e richiede una correzione verso un tipo valido.

Regola 4

I target di $ref esistono

Ambito: Entrambi

Ogni $ref deve puntare a qualcosa che esiste: #/$defs/... a una definizione di entità, #/$enums/... a un set di valori. I riferimenti pendenti interrompono la pipeline di arricchimento.

Errore di esempio: manufacturer: $ref '#/$defs/Company' references undefined definition

I due namespace sono separati: un riferimento #/$defs/ è una relazione con un'entità nidificata, mentre un riferimento #/$enums/ limita una proprietà di testo a un elenco chiuso di valori consentiti. Ciascuno deve avere una voce corrispondente nel proprio blocco.

Regola 5

La chiave di competenza esiste

Ambito: Entrambi

Il valore di competenza di ogni proprietà deve corrispondere a uno dei domini di competenza definiti. Questo previene errori di battitura e incoerenze.

Errore di esempio: revenue: expertise 'finance' not in defined domains: ['financial_analyst']

L'IA potrebbe usare "finance" invece della chiave definita "financial_analyst". Questa regola rileva la discrepanza affinché l'IA possa correggerla.

Regola 6

Competenza richiesta

Ambito: Solo generazione

Le proprietà non-oggetto e non conservate devono avere un'assegnazione di expertise domain. Ciò garantisce che ogni campo arricchibile sia gestito da un dominio specialistico.

Errore di esempio: revenue: expertise is required for non-object types

I tipi object sono esentati perché le loro proprietà figlie contengono la propria competenza. I campi preservati sono esentati perché vengono trasmessi invariati.

Regola 7

Il tipo corrisponde ai dati di input

Ambito: Solo generazione

Il tipo di schema per ogni proprietà deve corrispondere al tipo Python effettivo del valore corrispondente nei dati di input.

Errore di esempio: revenue: type mismatch - input is number but schema says 'string'

Se l'input contiene "revenue": 42.5, lo schema deve usare il tipo "number" o "integer", non "string". Il validatore è flessibile: accetta "number" per gli interi e viceversa.

Regola 8

Tutte le proprietà di input presenti

Ambito: Solo generazione

Ogni chiave dei dati di input deve comparire come proprietà nello schema generato. Questo impedisce all'AI di scartare silenziosamente dei campi.

Errore di esempio: Missing property from input: 'headquarters'

Se il JSON di input contiene una chiave "headquarters", lo schema generato deve includerla. Ciò garantisce una copertura completa dei suoi dati.

Inferenza del tipo

La regola 7 (corrispondenza dei tipi) utilizza l'inferenza automatica dei tipi per confrontare i valori inseriti con i tipi dichiarati dallo schema. L'inferenza è flessibile per evitare falsi positivi:

Valore di inputTipo dedottoAccetta anche
true / falseboolean(solo booleano)
42integernumber
3.14numberinteger
"hello"string(solo stringa)
[1, 2, 3]array(solo array)
{"key": "val"}object(solo oggetto)

Nota: i valori booleani vengono verificati prima degli interi perché in alcuni linguaggi il booleano è un sottotipo dell'intero. Questo ordinamento impedisce che true venga interpretato come un intero.

Questa tabella descrive ciò che il validatore accetta, non ciò che la generazione produce. Un valore di esempio pari a 3 non rende la proprietà un intero: i campi numerici vengono emessi come number a meno che un passaggio dedicato non confermi che la quantità è realmente discreta e che nessun valore osservato lo contraddica. Un numero intero in un campione non dimostra che i valori frazionari siano impossibili — e dichiarare erroneamente integer troncherebbe 6.2 a 6 in un database consumatore.

Passaggi successivi