Programma Lezione 137 di 250 · Output strutturati e chiamate a funzioni/strumenti
Output strutturati e chiamate a funzioni/strumenti

Riparare il JSON malformato del modello

I modelli non emettono JSON alla perfezione. Anche in modalità JSON avvolgono l'uscita in recinti ```json, aggiungono un preambolo chiacchierone ("Sure! Here is the data:"), lasciano una virgola finale, o usano gli apici singoli. Un semplice json.loads fallisce su tutti questi, e in produzione è una richiesta fallita. Un piccolo passo di riparazione ne recupera la maggior parte a basso costo prima di arrendersi e richiedere di nuovo al modello.

La forma di un percorso robusto ha questo aspetto:

text = call_model(prompt)        # may be fenced / prose-wrapped / sloppy
try:
    data = json.loads(text)
except ValueError:
    data = repair_json(text)     # one cheap repair attempt before re-prompting

Stai costruendo repair_json(text). Fagli fare questi passi, in ordine, e fermati appena json.loads riesce:

  • Togli un recinto di codice. Se tutto è avvolto in ``` (eventualmente ```json), tieni solo l'interno. Una regex come ^```[a-zA-Z]*\s*(.*?)\s*```$ con re.DOTALL lo fa.
  • Taglia la prosa intorno. Trova la prima { o [ e l'ultima } o ] corrispondente, e ritaglia solo quel tratto. Così togli "Sure! Here is..." prima e le chiacchiere dopo.
  • Prova così com'è. Molte stringhe a questo punto sono valide -> restituisci subito.
  • Correggi prima il guasto più leggero: togli le virgole finali con re.sub(r",(\s*[}\]])", r"\1", s), poi di nuovo json.loads.
  • Ultima risorsa: trasforma gli apici singoli in doppi e prova ancora una volta.
  • Se ancora non si legge, solleva un ValueError -> non restituire mai spazzatura. Una stringa irreparabile è un segnale per richiedere di nuovo, non per tirare a indovinare.

Perché lo scambio degli apici va per ultimo: riscrive anche gli apostrofi dentro i valori, quindi {"note": "it's fine",} si romperebbe se scambiassi per primo, mentre togliere solo la virgola lo sistema. L'uscita del modello contiene spesso apostrofi (nomi come O'Brien, parole come it's), quindi prova le correzioni che non possono danneggiare i valori prima di quella che può farlo. Anche così è una prima linea di difesa; quando una vera risposta non si riesce a leggere, richiedere di nuovo (o gli output strutturati, che costringono il modello a un JSON valido) batte una riparazione più furba. Assicurati che il JSON pulito passi intatto, che true/false sopravvivano come True/False di Python, e che una stringa senza JSON recuperabile sollevi un errore.

Tocca a te

Scrivi repair_json(text) che toglie un recinto di codice ```/```json, taglia la prosa prima della prima {/[ e dopo l'ultima }/] corrispondente, poi prova json.loads; se fallisce toglie le virgole finali e riprova; solo se fallisce ancora trasforma anche gli apici singoli in doppi e prova un'ultima volta (lo scambio degli apici va per ultimo perché riscrive anche gli apostrofi dentro i valori); se ancora non si legge solleva un ValueError. Il JSON pulito deve passare invariato.

Hai notato un problema in questa lezione? Segnalalo · Chiedi qualcosa su questa lezione

Questo esercizio si apre presto

Finisci la lezione precedente e questa si sblocca. L'intero corso è gratuito, senza account, e puoi leggere questa lezione subito.