Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Komplekse mønstre: næstede lister, enums, unions

Lektion 12 af 16 Opdateret 28. juli 2026 Udvikler
På denne side
  1. Komplekse mønstre: næstede lister, enums, unions
  2. Næstede lister
  3. Enums til at begrænse værdier
  4. Simulering af type-unions
  5. Rekursive objekter
  6. Mønster: multi-enhedsudtræk
  7. Bedste praksis for komplekse skemaer
  8. Tilfældet, der tester alt: organisationsdiagrammet
  9. Vigtige pointer

Komplekse mønstre: næstede lister, enums, unions

Enkle udtrækstilfælde (et fladt objekt med tekstfelter) er nemme at håndtere. De virkelige udfordringer opstår ved komplekse strukturer: næstede objektlisters, betingede typer og polymorfe felter. Denne lektion viser dig, hvordan du designer robuste skemaer til disse avancerede tilfælde.

Næstede lister

Det mest almindelige mønster i produktion indebærer udtræk af en liste over objekter, hvor hvert objekt indeholder sine egne underlister. Skemaet nedenfor beskriver et uddannelsesprogram med tre niveauer: programobjektet med sin titel og varighed, et array af moduler, der hver har en titel og tekstuelle mål, og endelig lektionerne for hvert modul, beskrevet ved en titel, en varighed i minutter og en type begrænset af en enum.

Det, modellen skal lykkes med her, går ud over blot at læse: den skal knytte hver lektion til det korrekte modul, hvilket betyder, at den skal forstå en hierarki, der nogle gange kun formidles gennem overskriftsniveauer. Derfor er felterne på tredje niveau meget konkrete – en varighed i minutter frem for en generisk “varighed”, der nogle gange udtrykkes i timer, andre gange i sessioner. Jo mere præcise bladnoderne i træet er, desto mindre tøver modellen.

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
}

Enums til at begrænse værdier

Enums er den mest pålidelige måde at begrænse de mulige værdier for et felt på. Struktureret Output anvender dem på generationsniveau: i modsætning til en instruktion skrevet i prompten, kan de ikke ignoreres på en dag med statistisk træthed. Det gør dem værdifulde, når den udtrukne værdi fodrer en switch-sætning, en indekseret kolonne eller en routingregel – tre steder, hvor en uventet værdi ikke forårsager en hård fejl, men snarere tavshed.

Klassificeringsskemaet, der følger, sorterer indkommende anmodninger langs fire akser: categorie_principale lokaliserer den relevante afdeling, sous_categorie forfiner den inden for denne afdeling, priorite tjener til køsortering, og action_requise bestemmer, hvad der skal gøres med billetten. Ét designpunkt fortjener opmærksomhed: de tolv værdier af sous_categorie er fladtrykte snarere end knyttet til deres overordnede kategori, fordi streng tilstand ikke tilbyder betinget afhængighed mellem to enums. Intet forhindrer derfor kombinationen „juridique” og „recrutement”, og denne konsistens skal verificeres efter modtagelsen.

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

Simulering af type-unions

JSON Schema understøtter anyOf til betingede typer, men OpenAIs strenge Strukturerede Output har begrænsninger. Det anbefalede mønster er at bruge et diskriminatorfelt: du definerer et enkelt objekt, bredt nok til at dække alle tilfælde, og et type-felt indikerer, hvilken du beskriver.

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

Tricket er at gøre ethvert felt, der er specifikt for en enkelt type, nullable ved hjælp af notationen "type": ["string", "null"]. For et møde er participants og lieu udfyldt; for en påmindelse er de lig med null. Din kode læser derefter diskriminatoren først og ved straks, hvilke nøgler der giver mening – præcis den læsning, du ville foretage af en tagged union i et typet sprog. Prisen at betale, et mere verbost skema og null-værdier at håndtere, forbliver foretrukket frem for tre separate kald.

Rekursive objekter

Til træstrukturer – menuer, organisationsdiagrammer, diskussionstråde – brug $defs til rekursive referencer. Princippet er at navngive den gentagne form én gang og derefter referere til den indefra sig selv. Her indeholder en kommentar et array af svar, hvor hvert element igen er en kommentar: dybden er ikke fastlagt på skrivetidspunktet, den følger det analyserede dokuments dybde. Dette er den eneste rimelige måde at behandle en diskussionstråd på uden på forhånd at vide, om den har to niveauer af svar eller syv.

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

Mønster: multi-enhedsudtræk

Når en tekst indeholder flere typer enheder, er fristelsen at køre ét udtræk per familie. Multi-enhedsskemaet gør det bedre: det anmoder om personer, organisationer, datoer og beløb i et enkelt gennemløb. Fordelen er ikke kun at spare kald; det er, at modellen ser teksten én gang og kan relatere det, den finder der – knytte en person til deres organisation, associere et beløb med den kontekst, der giver det mening.

Duplikationen på datoer, date_brute og date_iso, fortjener at blive beholdt, som den er i dine egne skemaer: den bevarer den oprindelige formulering til revision, mens den leverer en normaliseret værdi. Feltet contexte, der er til stede på datoer og beløb, spiller samme rolle: uden det vil ingen vide, om 12.000 euro var et tilbud, en bøde eller et årligt budget.

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
}

Bedste praksis for komplekse skemaer

Fire vaner undgår de fleste skuffelser. Start simpelt: valider et fladt objekt på dine rigtige data, før du tilføjer nogen næsting, ellers vil du ikke vide, om en fejl kommer fra skemaet eller opgavens sværhedsgrad. Dernæst, opgiv det valgfrie felt, som streng tilstand forbyder, og gør det nullable i stedet. Overhold også en empirisk grænse – ud over tre eller fire niveauer af næsting falder kvaliteten, og det er bedre at opdele udtrækket i to gennemløb: først listen over moduler, derefter ét kald per modul for at detaljere dets lektioner. Hold endelig arbejdets fordeling i tankerne: skemaet og dets enums begrænser strukturen, system-prompten guider indholdet. Hvis modellen sorterer korrekt, men udtrækker de forkerte oplysninger, er det prompten, du skal justere.

Tilfældet, der tester alt: organisationsdiagrammet

Tag fat på det rekursive tilfælde, den mest lærerige del af lektionen. Definer et skema til at udtrække et virksomheds organisationsdiagram, hvor hver medarbejder kan have underordnede, der selv er medarbejdere. Test det på en tekst, der beskriver en organisation på femten til tyve personer, skrevet i prosa og ikke som en liste: her skal modellen udlede rapporteringslinjer fra sætninger som „reports to” eller „within the team of”.

Verificer, at hierarkiske relationer er korrekt næstet, og hold øje med personer, der nævnes langt fra deres leder – dette er det sædvanlige brudpunkt. Tilføj endelig enums på roller (leder, ledelse, operationel) og observer, om begrænsningen forbedrer eller forringer rapporteringslinjen: at tvinge en kategorisering kan hjælpe modellen eller skubbe den mod vilkårlige valg vedrørende hybride profiler.

Vigtige pointer

  • Næstede lister er det mest almindelige mønster i produktion
  • Enums anvendes på generationsniveau – udnyt dem
  • Simuler unions med et diskriminatorfelt og nullable felter
  • $defs muliggør rekursive strukturer (kommentarer, træer)
  • Begræns næstingsdybden til 3-4 niveauer