Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Vzorci za kompleksne strukture: gnezdeni seznami, naštevanja, unije

Lekcija 12 od 16 Posodobljeno 28. julij 2026 Razvijalec
Na tej strani
  1. Vzorci za kompleksne strukture: gnezdeni seznami, naštevanja, unije
  2. Gnezdeni seznami
  3. Uporaba naštevanj (enums) za omejevanje vrednosti
  4. Simuliranje unij tipov
  5. Rekurzivni objekti
  6. Vzorec: ekstrakcija več entitet
  7. Najboljše prakse za kompleksne sheme
  8. Primer, ki preizkusi vse: organizacijska shema
  9. Ključne ugotovitve

Vzorci za kompleksne strukture: gnezdeni seznami, naštevanja, unije

Preprosti primeri ekstrakcije (ravni objekt z besedilnimi polji) so enostavni za obdelavo. Pravi izzivi se pojavijo pri kompleksnih strukturah: seznamih gnezdenih objektov, pogojnih tipih in polimorfnih poljih. Ta lekcija ti pokaže, kako zasnovati robustne sheme za te napredne primere.

Gnezdeni seznami

Najpogostejši vzorec v proizvodnem okolju vključuje ekstrakcijo seznama objektov, kjer vsak objekt vsebuje svoje podsezname. Spodnja shema opisuje izobraževalni program s tremi ravnmi: objekt programa z naslovom in trajanjem, polje modulov, od katerih ima vsak naslov in besedilne cilje, ter nazadnje lekcije za vsak modul, opisane z naslovom, trajanjem v minutah in tipom, omejenim z enum.

Kar mora model tukaj uspešno opraviti, presega zgolj branje: vsako lekcijo mora pripeti pravilnemu modulu, kar pomeni, da mora razumeti hierarhijo, ki je včasih prenesena le prek ravni naslovov. Zato so polja na tretji ravni zelo konkretna – trajanje v minutah namesto splošnega „trajanje”, ki je včasih izraženo v urah, včasih v sejah. Bolj ko so listni vozli drevesa natančni, manj model okleva.

import json
from openai import OpenAI

client = OpenAI()

# Schema: extract a training program with modules and lessons
formation_schema = {
    "type": "object",
    "properties": {
        "titre": {"type": "string"},
        "duree_totale_heures": {"type": "number"},
        "modules": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "titre_module": {"type": "string"},
                    "objectifs": {
                        "type": "array",
                        "items": {"type": "string"}
                    },
                    "lecons": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "titre_lecon": {"type": "string"},
                                "duree_minutes": {"type": "integer"},
                                "type": {
                                    "type": "string",
                                    "enum": ["theorie", "pratique",
                                             "évaluation"]
                                }
                            },
                            "required": ["titre_lecon",
                                         "duree_minutes", "type"],
                            "additionalProperties": False
                        }
                    }
                },
                "required": ["titre_module", "objectifs", "lecons"],
                "additionalProperties": False
            }
        }
    },
    "required": ["titre", "duree_totale_heures", "modules"],
    "additionalProperties": False
}

Uporaba naštevanj (enums) za omejevanje vrednosti

Naštevanja so najbolj zanesljiv način za omejitev možnih vrednosti polja. Strukturirani izhod jih uporabi na ravni generiranja: za razliko od navodila, zapisanega v pozivu, jih ni mogoče prezreti niti ob dnevih statistične utrujenosti. To jih dela dragocene, ko ekstrahirana vrednost napaja stavek switch, indeksiran stolpec ali pravilo usmerjanja – tri mesta, kjer nepričakovana vrednost ne povzroči trde napake, temveč tišino.

Shema za razvrščanje, ki sledi, razvršča dohodne zahteve vzdolž štirih osi: categorie_principale locira pristojni oddelek, sous_categorie ga znotraj tega oddelka podrobneje opredeli, priorite služi za razvrščanje v čakalno vrsto, action_requise pa določa, kaj storiti s ticketom. Ena točka zasnove si zasluži pozornost: dvanajst vrednosti sous_categorie je sploščenih namesto pripetih njihovemu nadrejenemu kategoriji, ker strogi način ne ponuja pogojne odvisnosti med dvema enum-oma. Nič torej ne preprečuje kombinacije „juridique” in „recrutement”, to skladnost pa je treba preveriti po prejemu.

# Multi-level classification system
classification_schema = {
    "type": "object",
    "properties": {
        "categorie_principale": {
            "type": "string",
            "enum": ["technique", "commercial", "juridique",
                     "rh", "finance"]
        },
        "sous_categorie": {
            "type": "string",
            "enum": [
                "bug", "feature", "performance",
                "devis", "facturation", "contrat",
                "recrutement", "conge", "formation",
                "budget", "audit", "conformite"
            ]
        },
        "priorite": {
            "type": "string",
            "enum": ["critique", "haute", "moyenne", "basse"]
        },
        "action_requise": {
            "type": "string",
            "enum": ["repondre", "escalader", "archiver",
                     "planifier", "deleguer"]
        }
    },
    "required": ["categorie_principale", "sous_categorie",
                  "priorite", "action_requise"],
    "additionalProperties": False
}

Simuliranje unij tipov

JSON Schema podpira anyOf za pogojne tipe, vendar ima OpenAI-jev strogi Strukturirani izhod omejitve. Priporočeni vzorec je uporaba diskriminatornega polja: definiraš en sam objekt, dovolj širok, da pokrije vse primere, polje type pa označuje, katerega opisuješ.

# Pattern: an event can be a meeting, a task, or a reminder
event_schema = {
    "type": "object",
    "properties": {
        "type": {
            "type": "string",
            "enum": ["reunion", "tache", "rappel"]
        },
        "titre": {"type": "string"},
        "date": {"type": "string"},
        "heure_debut": {"type": ["string", "null"]},
        "heure_fin": {"type": ["string", "null"]},
        "participants": {
            "type": "array",
            "items": {"type": "string"}
        },
        "lieu": {"type": ["string", "null"]},
        "priorite": {
            "type": ["string", "null"],
            "enum": ["haute", "moyenne", "basse", None]
        },
        "description": {"type": "string"}
    },
    "required": ["type", "titre", "date", "heure_debut",
                  "heure_fin", "participants", "lieu",
                  "priorite", "description"],
    "additionalProperties": False
}

Trik je v tem, da vsako polje, specifično za en sam tip, narediš ničelno (nullable) z uporabo zapisa "type": ["string", "null"]. Za sestanek sta participants in lieu izpolnjena; za opomnik sta enaka null. Tvoja koda nato najprej prebere diskriminator in takoj ve, kateri ključi imajo smisel – točno tako branje, kot bi ga opravil pri označeni uniji v tipiziranem jeziku. Cena, ki jo plačaš – bolj obsežna shema in obravnava vrednosti null – ostaja preferablena pred tremi ločenimi klici.

Rekurzivni objekti

Za drevesne strukture – menije, organizacijske sheme, niti razprav – uporabi $defs za rekurzivne reference. Načelo je poimenovati ponavljajočo se obliko enkrat, nato pa jo referencirati znotraj same sebe. Tukaj komentar vsebuje polje odgovorov, kjer je vsak element spet komentar: globina ni določena ob zapisu, sledi globini analiziranega dokumenta. To je edini razumen način za obdelavo niti razprave brez vnaprejšnjega poznavanja, ali ima dve ravni odgovorov ali sedem.

# Structure of a comment with nested replies
comment_schema = {
    "type": "object",
    "properties": {
        "commentaires": {
            "type": "array",
            "items": {"$ref": "#/$defs/comment"}
        }
    },
    "required": ["commentaires"],
    "additionalProperties": False,
    "$defs": {
        "comment": {
            "type": "object",
            "properties": {
                "auteur": {"type": "string"},
                "contenu": {"type": "string"},
                "sentiment": {
                    "type": "string",
                    "enum": ["positif", "negatif", "neutre"]
                },
                "reponses": {
                    "type": "array",
                    "items": {"$ref": "#/$defs/comment"}
                }
            },
            "required": ["auteur", "contenu", "sentiment",
                          "reponses"],
            "additionalProperties": False
        }
    }
}

Vzorec: ekstrakcija več entitet

Ko besedilo vsebuje več vrst entitet, je skušnjava izvesti eno ekstrakcijo na družino. Shema za več entitet dela bolje: zahteva ljudi, organizacije, datume in zneske v enem samem prehodu. Prednost ni le prihranek klicev; model besedilo vidi enkrat in lahko poveže, kar v njem najde – osebo pripne njeni organizaciji, znesek poveže s kontekstom, ki mu daje smisel.

Podvajanje pri datumih, date_brute in date_iso, si zasluži, da ga v lastnih shemah obdržiš takšno, kot je: ohranja izvirno formulacijo za revizijo, hkrati pa zagotavlja normalizirano vrednost. Polje contexte, prisotno pri datumih in zneskih, igra enako vlogo: brez njega nihče ne bo vedel, ali je bilo 12.000 evrov ponudba, kazen ali letni proračun.

multi_entity_schema = {
    "type": "object",
    "properties": {
        "personnes": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "nom": {"type": "string"},
                    "role": {"type": "string"},
                    "organisation": {"type": ["string", "null"]}
                },
                "required": ["nom", "role", "organisation"],
                "additionalProperties": False
            }
        },
        "organisations": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "nom": {"type": "string"},
                    "type": {
                        "type": "string",
                        "enum": ["entreprise", "association",
                                 "administration", "autre"]
                    },
                    "secteur": {"type": ["string", "null"]}
                },
                "required": ["nom", "type", "secteur"],
                "additionalProperties": False
            }
        },
        "dates": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "date_brute": {"type": "string"},
                    "date_iso": {"type": "string"},
                    "contexte": {"type": "string"}
                },
                "required": ["date_brute", "date_iso", "contexte"],
                "additionalProperties": False
            }
        },
        "montants": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "valeur": {"type": "number"},
                    "devise": {"type": "string"},
                    "contexte": {"type": "string"}
                },
                "required": ["valeur", "devise", "contexte"],
                "additionalProperties": False
            }
        }
    },
    "required": ["personnes", "organisations", "dates", "montants"],
    "additionalProperties": False
}

Najboljše prakse za kompleksne sheme

Štiri navade preprečijo večino razočaranj. Začni preprosto: na svojih realnih podatkih najprej validiraj ravni objekt, preden dodaš kakršno koli gnezdenje, sicer ne boš vedel, ali napaka izvira iz sheme ali težavnosti naloge. Nato se odpovej izbirnemu polju, ki ga strogi način prepoveduje, in ga namesto tega naredi ničelnega (nullable). Upoštevaj tudi empirično mejo – prek treh ali štirih ravni gnezdenja kakovost upade, zato je bolje ekstrakcijo razdeliti na dva prehoda: najprej seznam modulov, nato en klic na modul za podrobnosti njegovih lekcij. Nazadnje imej v mislih delitev dela: shema in njena naštevanja omejujejo strukturo, sistemski poziv usmerja vsebino. Če model pravilno razvršča, a ekstrahira napačne informacije, je treba prilagoditi poziv.

Primer, ki preizkusi vse: organizacijska shema

Loti se rekurzivnega primera, najbolj poučnega dela lekcije. Definiraj shemo za ekstrakcijo organizacijske sheme podjetja, kjer ima lahko vsak zaposleni podrejene, ki so sami zaposleni. Preizkusi jo na besedilu, ki opisuje organizacijo petnajstih do dvajsetih ljudi, napisanem v prozi in ne kot seznam: tukaj mora model iz fraz, kot so „poroča” ali „v okviru ekipe”, sklepati na linije poročanja.

Preveri, ali so hierarhična razmerja pravilno gnezdena, pri čemi bodi pozoren na ljudi, omenjene daleč od njihovega vodje – to je običajna točka zloma. Nazadnje dodaj naštevanja za vloge (vodstvo, management, operativni del) in opazuj, ali omejitev izboljša ali poslabša linijo poročanja: prisilna kategorizacija lahko modelu pomaga ali pa ga potisne k poljubnim izbiram pri hibridnih profilih.

Ključne ugotovitve

  • Gnezdeni seznami so najpogostejši vzorec v proizvodnem okolju
  • Naštevanja se uporabijo na ravni generiranja – izkoristi jih
  • Unije simuliraj z diskriminatornim poljem in ničelnimi polji
  • $defs omogoča rekurzivne strukture (komentarji, drevesa)
  • Globino gnezdenja omeji na 3–4 ravni