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

Strukturált entitáskinyerés

13. lecke 16 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Strukturált entitáskinyerés
  2. Alapvető kinyerési folyamat
  3. 1. példa: Önéletrajz kinyerése
  4. 2. példa: Üzleti e-mail kinyerése
  5. Kötegelt kinyerés
  6. A kinyerés minőségének értékelése
  7. Építsd fel a referenciádat az optimalizálás előtt
  8. Főbb megállapítások

Lecke frissítve: 2026. november 3. az OpenAI dokumentációja alapján: a temperature és a top_p paraméterek csak none gondolkodási erőfeszítés mellett fogadhatók el, míg a GPT-5.6 modellek alapértelmezetten (medium) gondolkodnak. Az ezeket a paramétereket beállító hívásoknak ezért meg kell adniuk a reasoning={"effort": "none"} (Responses API) vagy reasoning_effort="none" (Chat Completions) beállítást. Források: GPT-6 használata · GPT-5.6 Terra.

Strukturált entitáskinyerés

A strukturált entitáskinyerés az egyik legkeresettebb használati eset éles környezetben: a szabad szöveg (e-mailek, dokumentumok, weboldalak) olyan adattá alakítása, amelyet az alkalmazásod ténylegesen fel tud használni. A strukturált kimenet és a specializált promptok kombinálásával megbízható kinyerési folyamatokat építhetsz anélkül, hogy külön NER-modellt kellene tanítanod.

Alapvető kinyerési folyamat

A kinyerés teljes sajátossága az alábbi függvény rendszer-promptjában rejlik, és ez alapos figyelmet érdemel. Három utasítás fed itt egymást: csak a jelenlévő információt nyerd ki, használj null értéket a hiányzó adatokhoz, és soha ne következtess olyan információra, amelyet nem említenek explicit módon.

Ez az utolsó mondat a legfontosabb a gyakorlatban. Ha magára hagyjuk, a modell boldogan kitölt egy hihető SIRET-számot, vagy irányítószám alapján kitalál egy várost, a legjobb szándékkal. Egy üzleti rendszerbe szánt kinyerés esetén ez a segítőkészség súlyos hiba: ha az adat egyszer bekerül az adatbázisba, nincs mód megkülönböztetni, mit olvasott ki a modell, és mit feltételezett. A temperature 0.0-ra állítása ugyanerre a célra szolgál: ugyanannak a dokumentumnak két futtatása során ugyanazt a kimenetet akarod kapni, már csak egy incidens reprodukálása érdekében is.

import json
from openai import OpenAI

client = OpenAI()

def extract_entities(text: str, schema: dict,
                     instructions: str = "") -> dict:
    """Strukturált entitásokat nyer ki szabad szövegből."""
    system = (
        "You are a specialized entity extractor. "
        "Extract ONLY information present in the text. "
        "If information is missing, use null. "
        "NEVER infer information not explicitly mentioned."
    )
    if instructions:
        system += f"\n\nAdditional instructions: {instructions}"

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature requires effort none
        instructions=system,
        input=f"Text to analyze:\n\n{text}",
        text={
            "format": {
                "type": "json_schema",
                "name": "extraction",
                "schema": schema,
                "strict": True
            }
        },
        temperature=0.0
    )
    return json.loads(response.output_text)

1. példa: Önéletrajz kinyerése

Az önéletrajz kiváló tesztterep, mert stabil szakaszokat kombinál teljesen szabad formátumú elrendezéssel. Az alábbi séma az elérhetőségi adatokat egy identity objektumba csoportosítja, ahol szinte minden mező nullable – egy jelölt lehet, hogy nem ad meg telefonszámot, és ha ezt a mezőt kötelezővé tennéd, azzal gyakorlatilag arra ösztönöznéd a modellt, hogy kitaláljon egyet.

A készségek nem egyszerű sztringek, hanem három attribútummal rendelkező objektumok, ami lehetővé teszi a megadott szint megőrzését és az egyes készségek kategorizálását. Ezek nélkül az enum-ok nélkül a „Scrum“ és a „Python“ ugyanabban a lapos listában végezné oldal mellett, ami használhatatlan egy olyan szűrő számára, amely ki akarja izolálni a nyelveket. Figyeld meg továbbá az end_date mezőt a tapasztalatoknál, amely nullable, míg a start_date nem: így kódolhatsz egy jelenlegi pozíciót anélkül, hogy saját konvenciókat találnál ki, mint például a „present“ vagy a „9999“. A teszt önéletrajzon ez a finomság a TechCorp soron jelenik meg.

resume_schema = {
    "type": "object",
    "properties": {
        "identity": {
            "type": "object",
            "properties": {
                "full_name": {"type": "string"},
                "email": {"type": ["string", "null"]},
                "phone": {"type": ["string", "null"]},
                "location": {"type": ["string", "null"]},
                "linkedin": {"type": ["string", "null"]}
            },
            "required": ["full_name", "email", "phone",
                          "location", "linkedin"],
            "additionalProperties": False
        },
        "current_title": {"type": ["string", "null"]},
        "years_experience": {"type": ["integer", "null"]},
        "skills": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "level": {
                        "type": "string",
                        "enum": ["beginner", "intermediate",
                                 "advanced", "expert"]
                    },
                    "category": {
                        "type": "string",
                        "enum": ["language", "framework", "tool",
                                 "methodology", "soft_skill"]
                    }
                },
                "required": ["name", "level", "category"],
                "additionalProperties": False
            }
        },
        "experiences": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "company": {"type": "string"},
                    "title": {"type": "string"},
                    "start_date": {"type": "string"},
                    "end_date": {"type": ["string", "null"]},
                    "description": {"type": "string"}
                },
                "required": ["company", "title", "start_date",
                              "end_date", "description"],
                "additionalProperties": False
            }
        },
        "education": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "institution": {"type": "string"},
                    "degree": {"type": "string"},
                    "year": {"type": ["string", "null"]}
                },
                "required": ["institution", "degree", "year"],
                "additionalProperties": False
            }
        },
        "languages": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "language": {"type": "string"},
                    "level": {
                        "type": "string",
                        "enum": ["a1", "a2", "b1", "b2",
                                 "c1", "c2", "native"]
                    }
                },
                "required": ["language", "level"],
                "additionalProperties": False
            }
        }
    },
    "required": ["identity", "current_title", "years_experience",
                  "skills", "experiences", "education", "languages"],
    "additionalProperties": False
}

resume_text = """
Marie Dupont - Senior Full Stack Developer
Email: [email protected] | Tel: +33 6 12 34 56 78
Paris, France | linkedin.com/in/mariedupont

8 years of experience in web development.

Skills: Python (expert), TypeScript (advanced), React (advanced),
Django (expert), PostgreSQL (advanced), Docker (intermediate),
Scrum (advanced)

Experience:
- TechCorp (2022-present): Lead Full Stack Developer
  Principal architect of a B2B SaaS platform, team of 6 devs.
- StartupAI (2019-2022): Senior Developer
  Development of ML APIs in Python/FastAPI.

Education:
- EPITECH Paris, Master in Computer Science (2017)

Languages: French (native), English (C1), Spanish (B1)
"""

result = extract_entities(resume_text, resume_schema)

2. példa: Üzleti e-mail kinyerése

A második példa jellegében más: itt már nem csupán információkat másolunk ki, hanem arra kérjük a modellt, hogy értelmezzen. Az intent (szándék) és az urgency (sürgősség) ítéletek – egyetlen mondat sem állítja az e-mailben, hogy „ez egy árajánlatkérés, magas prioritású“. Pontosan ezt nem tudja megtenni egy szabályokon vagy reguláris kifejezéseken alapuló klasszikus kinyerési folyamat, és pontosan ez indokolja, hogy itt LLM-t használjunk, máshol pedig nem.

A séma többi része vissza tér az ellenőrizhető tényekhez: említett termékek, összegek a kontextusukkal, dátumok és jelentőségük, szükséges műveletek. A summary mező zárja az objektumot, és azt az embert szolgálja, aki átnézi a sort, nem a kódot. Egy figyelmeztetés ennél a vegyes sémánál: egy téves ítélet az urgency tekintetében nem érvényteleníti az összegeket, de fordítva ez megtörténhet, mert egy modell, amely félreérti a szándékot, néha ezen a félreértésen keresztül olvassa a többit is. Ha az osztályozás kritikus a routingod számára, válaszd le egy külön hívásba.

email_schema = {
    "type": "object",
    "properties": {
        "intent": {
            "type": "string",
            "enum": ["quote_request", "complaint", "information",
                     "order", "partnership", "other"]
        },
        "urgency": {
            "type": "string",
            "enum": ["critical", "high", "normal", "low"]
        },
        "sender": {
            "type": "object",
            "properties": {
                "name": {"type": ["string", "null"]},
                "company": {"type": ["string", "null"]},
                "email": {"type": ["string", "null"]}
            },
            "required": ["name", "company", "email"],
            "additionalProperties": False
        },
        "mentioned_products": {
            "type": "array",
            "items": {"type": "string"}
        },
        "mentioned_amounts": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "value": {"type": "number"},
                    "currency": {"type": "string"},
                    "context": {"type": "string"}
                },
                "required": ["value", "currency", "context"],
                "additionalProperties": False
            }
        },
        "key_dates": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "date": {"type": "string"},
                    "significance": {"type": "string"}
                },
                "required": ["date", "significance"],
                "additionalProperties": False
            }
        },
        "required_actions": {
            "type": "array",
            "items": {"type": "string"}
        },
        "summary": {"type": "string"}
    },
    "required": ["intent", "urgency", "sender",
                  "mentioned_products", "mentioned_amounts",
                  "key_dates", "required_actions", "summary"],
    "additionalProperties": False
}

Kötegelt kinyerés

Nagy mennyiségek feldolgozásához párhuzamosítsd a kinyeréseidet. Ezer dokumentum szekvenciális loopja az idő nagy részét hálózati várakozással tölti; az asyncio segítségével ezek a várakozások átfedik egymást, és a köteg a töredékére csökkenő idő alatt feldolgozódik.

A semaphore nem díszítő elem. Enélkül ezer feladat egyszerre történő indítása telíti a kvótádat, és olyan rate limit hibákat vált ki, amelyek többe kerülnek az újrapróbálkozások miatt, mint amennyit a sebességen spórolsz. A max_concurrent értékét a saját limiteid megfigyelésével állítsd be, ahol a tíz egy óvatos kiindulópont. Figyeld meg továbbá a return_exceptions=True beállítást is: ez megakadályozza, hogy egyetlen rosszul formázott dokumentum az egész köteget összeomlassza, így utólag rendezheted a hibákat.

import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI()

async def extract_batch(texts: list[str], schema: dict,
                          max_concurrent: int = 10) -> list[dict]:
    """Párhuzamos kinyerés konkurencia-kontrollal."""
    semaphore = asyncio.Semaphore(max_concurrent)

    async def extract_one(text: str) -> dict:
        async with semaphore:
            response = await async_client.responses.create(
                model="gpt-5.6-terra",
                reasoning={"effort": "none"},  # temperature requires effort none
                instructions="Extract entities from the provided text. "
                             "Use null for missing fields.",
                input=text,
                text={
                    "format": {
                        "type": "json_schema",
                        "name": "extraction",
                        "schema": schema,
                        "strict": True
                    }
                },
                temperature=0.0
            )
            return json.loads(response.output_text)

    tasks = [extract_one(t) for t in texts]
    return await asyncio.gather(*tasks, return_exceptions=True)

A kinyerés minőségének értékelése

Egy kinyerési folyamat annotált teszt készlet nélkül olyan folyamat, amelynek megbízhatóságát senki sem ismeri, és a kéz által átolvasott három példa által keltett benyomás szinte mindig túl optimistának bizonyul. Az alábbi függvény mezőnként összehasonlítja a kapott kinyerést egy kézzel létrehozott referenciával, visszaadva az általános pontosságot és az eltérések lebontását.

Ez a lebontás a hasznos rész: a hibák szinte sosem oszlanak el egyenletesen. Egyetlen mező koncentrálja a problémákat – gyakran egy félreérthető dátum, egy implicit készségszint vagy egy rosszul definiált kategória –, és a rendszer-promptba írt egyetlen további mondat megoldja ezt. E mérés nélkül véletlenszerűen hangolnád a promptot, esetleg rontva egy olyan mezőn, amely már működött.

def evaluate_extraction(expected: dict, obtained: dict,
                       fields: list[str]) -> dict:
    """Összehasonlítja a kapott kinyerést a referenciával."""
    correct = 0
    total = len(fields)
    errors = []

    for field in fields:
        val_expected = expected.get(field)
        val_obtained = obtained.get(field)

        if val_expected == val_obtained:
            correct += 1
        else:
            errors.append({
                "field": field,
                "expected": val_expected,
                "obtained": val_obtained
            })

    return {
        "precision": correct / total if total > 0 else 0,
        "correct": correct,
        "total": total,
        "errors": errors
    }

Építsd fel a referenciádat az optimalizálás előtt

Válassz egy dokumentumtípust a saját doménedből – szerződések, számlák, jelentések –, és definiálj legalább tíz mezőt tartalmazó kinyerési sémát, szándékosan keverve az egyszerű mezőket olyanokkal, amelyekről tudod, hogy félreérthetőek. Állíts össze öt példadokumentumot a hozzájuk tartozó, kézzel írt várt kinyerésekkel: ez a lépés unalmas, egy órát vesz igénybe, és ez adja meg minden ezt követő munka értékét.

Ezután futtasd le a folyamatot, mérd meg a pontosságot, és olvasd végig a hibalistát mezőnként. A legrosszabbul teljesítő mező megmondja, mit kell javítanod a prompton; egy második mérés pedig megmutatja, hogy a javítás tényleg segített-e – vagy esetleg rontott-e egy másik mezőn a folyamat során, ami gyakrabban fordul elő, mint gondolnád, amint egy további utasítás eltereli a modell figyelmét.

Főbb megállapítások

  • A strukturált kinyerés a legtöbb használati esetben kiváltja a dedikált NER modelleket
  • Használj temperature=0.0 értéket a konzisztencia maximalizálásához
  • Tedd nullable-lá az opcionális mezőket, ne csak opcionálissá
  • Párhuzamosíts asyncio segítségével nagy mennyiségek esetén
  • Rendszeresen értékeld a minőséget annotált teszt készlettel
  • A rendszer-prompt utasításai tartalmat irányítanak, a séma a struktúrát kényszeríti ki