Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Vzory zložitého typu: vnorené zoznamy, výčty, zjednotené typy

Lekcia 12 z 16 Aktualizované 28. júla 2026 Vývojár
Na tejto strane
  1. Vzory zložitého typu: vnorené zoznamy, výčty, zjednotené typy
  2. Vnorené zoznamy
  3. Výčty na obmedzenie hodnôt
  4. Simulácia zjednotených typov (unions)
  5. Rekurzívne objekty
  6. Vzor: extrakcia viacerých entít
  7. Najlepšie postupy pre zložité schémy
  8. Prípad, ktorý testuje všetko: organizačná schéma
  9. Kľúčové poznatky

Vzory zložitého typu: vnorené zoznamy, výčty, zjednotené typy

Jednoduché prípady extrakcie (plochý objekt s textovými poľami) sa riešia ľahko. Skutočné výzvy prichádzajú so zložitými štruktúrami: zoznamy vnorených objektov, podmienené typy a polymorfné polia. Táto lekcia ti ukáže, ako navrhnúť robustné schémy pre tieto pokročilé prípady.

Vnorené zoznamy

Najbežnejším vzorom v produkcii je extrakcia zoznamu objektov, kde každý objekt obsahuje svoje vlastné podzoznamy. Schéma nižšie opisuje vzdelávací program s tromi úrovňami: objekt programu s názvom a dĺžkou trvania, pole modulov, z ktorých každý má názov a textové ciele, a nakoniec lekcie pre každý modul, opísané názvom, dĺžkou trvania v minútach a typom obmedzeným pomocou enum.

To, čo musí model v tomto prípade zvládnuť, presahuje jednoduché čítanie: musí priradiť každú lekciu k správnemu modulu, čo znamená, že musí pochopiť hierarchiu, ktorá je niekedy vyjadrená len úrovňami nadpisov. Preto sú na tretej úrovni veľmi konkrétne polia – dĺžka trvania v minútach namiesto všeobecného „trvania“, ktoré sa niekedy uvádza v hodinách a niekedy v sedeniach. Čím presnejšie sú listové uzly stromu, tým menej model váha.

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
}

Výčty na obmedzenie hodnôt

Výčty (enums) sú najspoľahlivejším spôsobom, ako obmedziť možné hodnoty poľa. Štruktúrovaný výstup ich aplikuje na úrovni generovania: na rozdiel od inštrukcie napísanej v prompte ich nemožno ignorovať ani v deň štatistickej únavy. To z nich robí cenný nástroj, keď extrahovaná hodnota napája príkaz switch, indexovaný stĺpec alebo pravidlo smerovania – tri miesta, kde neočakávaná hodnota nespôsobí tvrdú chybu, ale skôr ticho.

Schéma klasifikácie, ktorá nasleduje, triedi prichádzajúce požiadavky pozdĺž štyroch osí: categorie_principale lokalizuje príslušné oddelenie, sous_categorie ho spresňuje v rámci tohto oddelenia, priorite slúži na triedenie frontu a action_requise určuje, čo s ticketom robiť. Jeden bod návrhu si zasluhuje pozornosť: dvanásť hodnôt sous_categorie je sploštených, namiesto toho, aby boli priradené k ich rodičovskej kategórii, pretože striktný režim neponúka podmienenú závislosť medzi dvoma enum. Nič teda nebráni kombinácii „juridique“ a „recrutement“ a túto konzistenciu treba overiť až po prijatí.

# 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
}

Simulácia zjednotených typov (unions)

JSON Schema podporuje anyOf pre podmienené typy, ale striktný štruktúrovaný výstup OpenAI má obmedzenia. Odporúčaný vzor je použiť diskriminačné pole: definuješ jeden objekt dostatočne široký na pokrytie všetkých prípadov a pole type indikuje, ktorý z nich 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 spočíva v tom, že akékoľvek pole špecifické pre jeden typ urobíš nullable (prijímajúce null) použitím notácie "type": ["string", "null"]". Pre schôdzku sú polia participantsalieuvyplnené; pre pripomienku sa rovnajúnull. Tvoj kód potom najprv prečíta diskriminátor a okamžite vie, ktoré kľúče dávajú zmysel – presne tak, ako by si čítal označený zjednotený typ (tagged union) v typovanom jazyku. Cena, ktorú treba zaplatiť – verbose schéma a nutnosť spracovávať null` – zostáva preferovateľná oproti trom samostatným volaniam.

Rekurzívne objekty

Pre stromové štruktúry – ponuky, organizačné schémy, vlákna diskusií – použi $defs na rekurzívne referencie. Princíp spočíva v tom, že pomenuješ opakujúci sa tvar raz a potom naň odkážeš zvnútra seba samého. Tu komentár obsahuje pole odpovedí, kde každý prvok je zase komentárom: hĺbka nie je pevne stanovená v čase zápisu, nasleduje hĺbku analyzovaného dokumentu. Toto je jediný rozumný spôsob, ako spracovať vlákno diskusie bez toho, aby si vopred vedel, či má dve úrovne odpovedí alebo 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
        }
    }
}

Vzor: extrakcia viacerých entít

Keď text obsahuje viacero typov entít, pokušením je spustiť jednu extrakciu pre každú rodinu. Schéma pre viacero entít robí viac: vyžaduje osoby, organizácie, dátumy a sumy v jednom prechode. Prínosom nie je len úspora volaní; ide o to, že model vidí text raz a dokáže prepojiť to, čo v ňom nájde – priradiť osobu k jej organizácii, priradiť sumu ku kontextu, ktorý jej dáva zmysel.

Duplikácia pri dátumoch, date_brute a date_iso, si zasluhuje ponechať vo vašich vlastných schémach tak, ako je: zachováva pôvodné znenie pre audit a zároveň poskytuje normalizovanú hodnotu. Pole contexte, prítomné pri dátumoch aj sumách, hrá rovnakú úlohu: bez neho nikto nebude vedieť, či 12 000 eur bola cenová ponuka, pokuta alebo ročný rozpočet.

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
}

Najlepšie postupy pre zložité schémy

Štyri návyky ti pomôžu vyhnúť sa väčšine sklamaní. Začni jednoducho: over plochý objekt na svojich reálnych dátach predtým, než pridáš akékoľvek vnorenie, inak nebudeš vedieť, či zlyhanie pochádza zo schémy alebo z náročnosti úlohy. Ďalej sa vzdaj voliteľného poľa, ktoré striktný režim zakazuje, a namiesto toho ho urob nullable. Tiež rešpektuj empirický limit – po troch alebo štyroch úrovniach vnorenia kvalita klesá a je lepšie rozdeliť extrakciu na dva prechody: najprv zoznam modulov, potom jedno volanie na modul na detailné rozpracovanie jeho lekcií. Nakoniec maj na pamäti rozdelenie práce: schéma a jej enumy obmedzujú štruktúru, systémový prompt usmerňuje obsah. Ak model správne triedi, ale extrahuje nesprávne informácie, je to prompt, ktorý potrebuješ upraviť.

Prípad, ktorý testuje všetko: organizačná schéma

Zober si rekurzívny prípad, najvzdelávacejšiu časť lekcie. Definuj schému na extrakciu organizačnej schémy firmy, kde každý zamestnanec môže mať podriadených, ktorí sú sami zamestnancami. Otestuj ju na texte opisujúcom organizáciu pätnástich až dvadsiatich ľudí, napísanom prózou, nie ako zoznam: tu musí model odvodiť reportingové línie z fráz ako „reportuje“ alebo „v tíme“.

Over, či sú hierarchické vzťahy správne vnorené, a dávaj pozor na ľudí spomenutých ďaleko od ich manažéra – to je obvyklý bod zlomu. Nakoniec pridaj enumy pre role (výkonný, manažment, operatívny) a sleduj, či obmedzenie zlepšuje alebo zhoršuje reportingovú líniu: vynútenie kategorizácie môže modelu pomôcť, alebo ho môže tlačiť k ľubovoľným voľbám pri hybridných profiloch.

Kľúčové poznatky

  • Vnorené zoznamy sú najbežnejším vzorom v produkcii
  • Enumy sa aplikujú na úrovni generovania – využij ich
  • Simuluj zjednotené typy pomocou diskriminačného poľa a nullable polí
  • $defs umožňuje rekurzívne štruktúry (komentáre, stromy)
  • Obmedz hĺbku vnorenia na 3–4 úrovne