Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Mintázatok komplex esetekre: beágyazott listák, enumok, uniók

12. lecke 16 közül Frissítve 2026. július 28. Fejlesztő
Ezen az oldalon
  1. Mintázatok komplex esetekre: beágyazott listák, enumok, uniók
  2. Beágyazott listák
  3. Értékek korlátozása enumokkal
  4. Típusuniók szimulálása
  5. Rekurzív objektumok
  6. Mintázat: többentitásos kinyerés
  7. Bevált gyakorlatok komplex sémákhoz
  8. Az eset, ami mindent próbára tesz: a szervezeti chart
  9. Főbb megállapítások

Mintázatok komplex esetekre: beágyazott listák, enumok, uniók

Az egyszerű kinyerési eseteket (lapos objektumok szöveges mezőkkel) könnyű kezelni. Az igazi kihívások akkor érkeznek, amikor összetett struktúrákkal dolgozol: beágyazott objektumlistákkal, feltételes típusokkal és polimorf mezőkkel. Ebben a leckében megtanulod, hogyan tervezz robusztus sémákat ezekre a haladó esetekre.

Beágyazott listák

A gyártási környezetben a leggyakoribb mintázat olyan objektumlista kinyerése, ahol minden objektum saját al-listákat tartalmaz. Az alábbi séma egy képzési programot ír le három szinten: a program objektumát a címével és időtartamával, a modulok tömbjét, amelyek mindegyike rendelkezik címmel és szöveges célokkal, valamint végül az egyes modulok leckéit, amelyeket cím, percben megadott időtartam és egy enum által korlátozott típus ír le.

Amiben a modellnek itt teljesítenie kell, az túlmutat az olvasáson: minden leckét a megfelelő modulhoz kell rendelnie, ami azt jelenti, hogy meg kell értenie egy hierarchiát, amelyet néha csak a címsorok szintje közvetít. Ezért vannak nagyon konkrét mezők a harmadik szinten – például az időtartam percben, nem pedig egy általános „időtartam“, amelyet hol órában, hol alkalmakban adnak meg. Minél pontosabbak a fa levélszintű elemei, annál kevésbé habozik a modell.

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
}

Értékek korlátozása enumokkal

Az enumok a legmegbízhatóbb módszerek egy mező lehetséges értékeinek korlátozására. A Strukturált Kimenet ezeket generálási szinten alkalmazza: ellentétben a promptba írt utasítással, ezeket statisztikai fáradtság esetén sem lehet figyelmen kívül hagyni. Ezért értékesek, ha a kinyert érték egy switch utasítást, egy indexelt oszlopot vagy egy útválasztási szabályt táplál – három olyan helyen, ahol egy váratlan érték nem okoz hard hibát, hanem inkább csendet eredményez.

Az alábbi osztályozási séma a bejövő kéréseket négy tengely mentén rendezi: a categorie_principale az illetékes osztályt lokalizálja, a sous_categorie ezen belül finomít, a priorite a sorban való elhelyezést szolgálja, az action_requise pedig meghatározza, mi a teendő a jeggyel. Egy tervezési részlet figyelmet érdemel: a sous_categorie tizenkét értéke laposított, nem pedig a szülő kategóriájához van csatolva, mert a szigorú mód nem kínál feltételes függőséget két enum között. Semmi sem akadályozza tehát a „juridique“ és a „recrutement“ kombinációját, ezt a konzisztenciát fogadás után ellenőrizni kell.

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

Típusuniók szimulálása

A JSON Schema támogatja az anyOf-ot feltételes típusokhoz, de az OpenAI szigorú Strukturált Kimenete korlátokkal rendelkezik. A javasolt mintázat egy diszkriminátor mező használata: egyetlen objektumot definiálsz, amely elég tág ahhoz, hogy minden esetet lefedjen, és egy type mező jelzi, melyiket írod le.

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

A trükk az, hogy minden egyes típushoz specifikus mezőt nullázhatóvá teszel a "type": ["string", "null"] jelöléssel. Egy értekezlet esetén a participants és a lieu ki van töltve; egy emlékeztető esetén ezek értéke null. A kódod először a diszkriminátort olvassa, és azonnal tudja, mely kulcsoknak van értelme – pontosan úgy, ahogy egy címkézett uniót olvasnál egy típusos nyelvben. Az ár, amit fizetni kell – egy bőbeszédűbb séma és a null értékek kezelése –, még mindig előnyösebb, mint három külön hívás.

Rekurzív objektumok

Fastruktúrákhoz – menük, szervezeti chartok, beszélgetésfolyamok – használd a $defs-et rekurzív hivatkozásokhoz. Az elv az, hogy egyszer nevezed meg az ismétlődő alakzatot, majd azon belül hivatkozol rá. Itt egy hozzászólás tartalmaz egy válaszok tömbjét, ahol minden elem maga is egy hozzászólás: a mélység nincs rögzítve íráskor, az elemzett dokumentum mélységét követi. Ez az egyetlen ésszerű módja egy beszélgetésfolyam feldolgozásának anélkül, hogy előre tudnánk, két vagy hét szintű válaszról van-e szó.

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

Mintázat: többentitásos kinyerés

Amikor egy szöveg többféle entitást tartalmaz, a kísértés nagy, hogy entitáscsaládonként futtassunk egy-egy kinyerést. A többentitásos séma ennél jobb: egyetlen menetben kéri a személyeket, szervezeteket, dátumokat és összegeket. Az előny nem csupán a hívások megtakarítása; hanem az, hogy a modell egyszer látja a szöveget, és összefüggésbe tudja hozni, amit talál – egy személyt a szervezetéhez rendel, egy összeget ahhoz a kontextushoz társít, amely értelmet ad neki.

A dátumoknál szereplő duplikációt (date_brute és date_iso) érdemes megtartani a saját sémáidban is: ez megőrzi az eredeti megfogalmazást auditálási célokra, miközben normalizált értéket is biztosít. A contexte mező, amely a dátumoknál és az összegeknél is jelen van, ugyan ezt a szerepet játssza: nélküle senki sem tudja, hogy a 12 000 euró egy árajánlat, egy bírság vagy egy éves költségvetés volt-e.

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
}

Bevált gyakorlatok komplex sémákhoz

Négy szokás segít elkerülni a legtöbb csalódást. Kezdj egyszerűen: valós adatokon validálj egy lapos objektumot, mielőtt bármilyen beágyazást hozzáadnál, különben nem fogod tudni, hogy a hiba a sémából vagy a feladat nehézségéből adódik. Ezután mondd le a nem kötelező mezőről, amit a szigorú mód tilt, és tedd helyette nullázhatóvá. Tartsd be továbbá az empirikus határt: három-négy beágyazási szint felett a minőség romlik, és jobb, ha két lépésre bontod a kinyerést: először a modulok listája, majd modulonként egy hívás a leckék részletezésére. Végül tartsd szem előtt a munkamegosztást: a séma és az enumjai korlátozzák a struktúrát, a rendszer-prompt irányítja a tartalmat. Ha a modell helyesen osztályoz, de rossz információt nyer ki, akkor a promptot kell finomítanod.

Az eset, ami mindent próbára tesz: a szervezeti chart

Vedd kézbe a rekurzív esetet, ami a lecke legtanulságosabb része. Definiálj egy sémát egy vállalati szervezeti chart kinyerésére, ahol minden alkalmazottnak lehetnek alárendeltjei, akik maguk is alkalmazottak. Teszteld egy olyan szövegen, amely tizenöt-húsz fős szervezetet ír le prózában, nem listaként: itt kell a modellnek következtetnie a reporting vonalakra olyan kifejezésekből, mint „beszámol neki“ vagy „a csapatán belül“.

Ellenőrizd, hogy a hierarchikus kapcsolatok helyesen vannak-e beágyazva, figyelve azokra az emberekre, akiket távol említenek a vezetőjüktől – ez a szokásos töréspont. Végül adj hozzá enumokat a szerepkörökhöz (vezetői, menedzsment, operatív), és figyeld meg, hogy a kényszer javítja vagy rontja-e a reporting vonalat: egy kategorizálás kikényszerítése segítheti a modellt, vagy önkényes választások felé terelheti hibrid profilok esetén.

Főbb megállapítások

  • A beágyazott listák a leggyakoribb mintázat a gyártási környezetben
  • Az enumokat generálási szinten alkalmazzák – aknázd ki őket
  • Szimulálj uniókat diszkriminátor mezővel és nullázható mezőkkel
  • A $defs lehetővé teszi a rekurzív struktúrákat (hozzászólások, fák)
  • Korlátozd a beágyazás mélységét 3-4 szintre