AI Engineering Academy · Lektion

Udtræk af data fra ustruktureret tekst

Opbyg en pipeline til informationsudtræk, der læser rå tekst som e-mails, kvitteringer og artikler og returnerer strukturerede felter med typer, standardværdier og validering.

Lektion 3 af 413 trin

Udtræk af data fra ustruktureret tekst er en gratis AI Engineering Academy-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i AI Engineering Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. AI Engineering Academy-kurset indeholder 4 lektioner i alt.

Problemet med informationsudtræk

Organisationer drukner i ustruktureret tekst: e-mails, supportsager, kontrakter, fakturaer, nyhedsartikler, medicinske journalnotater og opslag på sociale medier. Værdifulde strukturerede data ligger gemt i denne tekst, men manuel udtrækning er langsom, dyr og fejlbehæftet. LLM'er med strukturerede output ændrer dette: De kan læse enhver tekst og udfylde et foruddefineret skema med de relevante felter i stor skala og med en rimelig nøjagtighed.

Informationsudtræk (IE) er processen med automatisk at identificere og hente strukturerede fakta fra ustruktureret tekst. IE baseret på LLM'er klarer sig markant bedre end tidligere regelbaserede eller klassiske NLP-metoder, fordi LLM'er forstår kontekst, synonymer og implicit information uden at kræve håndskrevne regex-mønstre for enhver variation.

Almindelige anvendelser af informationsudtræk

Informationsudtræk danner grundlag for mange værdifulde forretningsanvendelser:

Fakturabehandling: Udtræk leverandør, fakturalinjer, beløb og forfaldsdatoer fra PDF-fakturaer for at automatisere kreditorbogholderiet
Kontraktanalyse: Udtræk parter, ikrafttrædelsesdatoer, betalingsbetingelser og opsigelsesklausuler fra juridiske dokumenter
CV-fortolkning: Udtræk kompetencer, erfaring, uddannelse og kontaktoplysninger fra CV'er til ATS-systemer
Videresendelse af supportsager: Udtræk kategori, alvorlighedsgrad, berørt produkt og kundesegment for automatisk at videresende sager
Nyhedsovervågning: Udtræk entiteter, hændelser og sentiment fra nyhedsartikler til konkurrenceovervågning

Opbygning af en pipeline til udtræk fra e-mails

Lad os opbygge en praktisk pipeline til udtræk, som læser kunde-e-mails og udtrækker handlingsrelevante strukturerede data. Pipelinen bruger et Pydantic-skema til præcist at definere, hvad vi ønsker fra hver e-mail, og behandler derefter e-mails i batches.

import openai
from pydantic import BaseModel
from typing import List, Optional
from enum import Enum

client = openai.OpenAI()

class Priority(str, Enum):
    urgent = 'urgent'
    high = 'high'
    normal = 'normal'
    low = 'low'

class EmailExtraction(BaseModel):
    subject_summary: str
    sender_intent: str
    product_mentioned: Optional[str]
    issue_category: str  # billing / technical / general / feedback
    priority: Priority
    action_required: bool
    action_description: Optional[str]
    customer_sentiment: str  # positive / negative / neutral / frustrated

def extract_from_email(email_body: str) -> EmailExtraction:
    result = client.beta.chat.completions.parse(
        model='gpt-4o-mini',
        messages=[
            {'role': 'system', 'content': 'You are an expert at analyzing customer emails and extracting structured information for a support team.'},
            {'role': 'user', 'content': f'Analyze this customer email:\n\n{email_body}'}
        ],
        response_format=EmailExtraction
    )
    return result.choices[0].message.parsed

Genkendelse af navngivne entiteter med LLM'er

Genkendelse af navngivne entiteter (NER) er en klassisk IE-opgave: at identificere og klassificere navngivne entiteter (personer, organisationer, steder, datoer og pengebeløb) i tekst. LLM'er gør NER markant enklere, fordi du blot beskriver de entiteter, du ønsker, hvorefter de udtrækkes uden behov for en specialtrænet NER-model.

import openai
from pydantic import BaseModel
from typing import List, Optional

client = openai.OpenAI()

class NamedEntity(BaseModel):
    text: str       # The exact text as it appears
    entity_type: str  # PERSON / ORG / LOCATION / DATE / MONEY / PRODUCT
    normalized: Optional[str]  # Standardized form where applicable

class NERResult(BaseModel):
    entities: List[NamedEntity]

text = '''
Apple Inc. CEO Tim Cook announced yesterday that the company will invest $1.2 billion
in a new manufacturing facility in Austin, Texas, expected to open in Q3 2026.
'''

result = client.beta.chat.completions.parse(
    model='gpt-4o-mini',
    messages=[
        {'role': 'system', 'content': 'Extract all named entities from the text. Classify each as PERSON, ORG, LOCATION, DATE, MONEY, or PRODUCT.'},
        {'role': 'user', 'content': text}
    ],
    response_format=NERResult
)
for entity in result.choices[0].message.parsed.entities:
    print(f'[{entity.entity_type}] {entity.text}')

Udtræk fra dokumenter i stor skala

Til pipelines til produktionsudtræk, der behandler tusindvis af dokumenter, har du brug for asynkron behandling og håndtering af hastighedsbegrænsninger. Et typisk mønster bruger asyncio sammen med en semafor til at behandle dokumenter parallelt, samtidig med at API'ets hastighedsbegrænsninger overholdes.

import asyncio
import openai
from pydantic import BaseModel
from typing import List, Optional

async_client = openai.AsyncOpenAI()

class InvoiceExtraction(BaseModel):
    vendor: str
    total_amount: Optional[float]
    currency: str
    invoice_date: Optional[str]

async def extract_invoice(doc_text: str, semaphore: asyncio.Semaphore) -> InvoiceExtraction:
    async with semaphore:  # Limit concurrent requests
        result = await async_client.beta.chat.completions.parse(
            model='gpt-4o-mini',
            messages=[
                {'role': 'system', 'content': 'Extract invoice data.'},
                {'role': 'user', 'content': doc_text}
            ],
            response_format=InvoiceExtraction
        )
        return result.choices[0].message.parsed

async def process_invoices(documents: List[str]):
    sem = asyncio.Semaphore(5)  # Max 5 concurrent requests
    tasks = [extract_invoice(doc, sem) for doc in documents]
    return await asyncio.gather(*tasks, return_exceptions=True)

# results = asyncio.run(process_invoices(invoice_texts))
print('Async pipeline defined - handles rate limits via semaphore')

Håndtering af implicit og udledt information

LLM'er kan ikke kun udtrække information, der er angivet direkte, men også udledt eller implicit information. Hvis en anmeldelse siger "Jeg har brugt dette dagligt i en måned, og det fungerer stadig perfekt", kan modellen udlede holdbarhed som en positiv egenskab, selv om ordet "holdbarhed" aldrig forekommer. Det er en væsentlig fordel i forhold til regex-baseret udtræk, som kun kan finde det, der står direkte i teksten.

Denne styrke medfører dog en risiko: Modellen kan drage for vidtgående slutninger og udfylde felter med gæt i stedet for fakta. Ved udtræk med store konsekvenser (juridiske, økonomiske eller medicinske) skal du tilføje et confidence-felt til dit skema og instruere modellen i at vurdere sin sikkerhed, så udtræk med lav sikkerhed markeres til manuel gennemgang.

Design af prompts til informationsudtræk

Kvaliteten af dit udtræk afhænger i høj grad af promptens design. Vigtige principper for prompts til informationsudtræk:

Definér tvetydige felter: Hvis "dato" kan betyde fakturadato, forfaldsdato eller modtagelsesdato, skal du præcisere, hvilken du ønsker
Giv eksempler på usædvanlige formater: "For pris skal du kun returnere den numeriske værdi, f.eks. 29.99, ikke $29.99"
Håndtér normalisering: "Normalisér landenavne til ISO 3166-1 alpha-2-koder"
Angiv kilden til udtrækket: "Udtræk kun fra emnelinjen, ikke fra selve e-mailen"

Betragt prompten til informationsudtræk som en præcis specifikation til en medarbejder, der indtaster data manuelt — enhver uklarhed, du efterlader i prompten, bliver til en vurdering, som modellen vil foretage inkonsekvent.

Udtræk i flere gennemløb til komplekse dokumenter

Nogle dokumenter er for komplekse til at blive behandlet i ét gennemløb, fordi hele skemaet er stort, forskellige afsnit kræver forskellig ekspertise, eller dokumentstrukturen varierer meget. Udtræk i flere gennemløb opdeler opgaven i sekventielle trin: Klassificér først dokumenttypen, og udtræk derefter det passende skema for denne type.

import openai
from pydantic import BaseModel
from typing import Optional

client = openai.OpenAI()

class DocumentType(BaseModel):
    doc_type: str  # invoice / contract / resume / report
    confidence: float

def classify_document(text: str) -> str:
    result = client.beta.chat.completions.parse(
        model='gpt-4o-mini',
        messages=[
            {'role': 'system', 'content': 'Classify the document type.'},
            {'role': 'user', 'content': text[:500]}  # Use only the beginning for classification
        ],
        response_format=DocumentType
    )
    return result.choices[0].message.parsed.doc_type

# Then route to the appropriate extraction schema
EXTRACTION_SCHEMAS = {
    'invoice': 'InvoiceSchema',  # Replace with actual Pydantic classes
    'contract': 'ContractSchema',
    'resume': 'ResumeSchema',
}

print('Multi-pass: classify first, then extract with the right schema')

Berigelse efter udtræk

Udtrukne data har ofte brug for berigelse efter det indledende udtræk: Du kan konvertere udtrukne virksomhedsnavne til kanoniske former ved at slå dem op i en virksomhedsdatabase, slå det udtrukne postnummer op for at udfylde by og delstat eller konvertere udtrukne datoer til et standardformat. Dette berigelsestrin bør udføres i din applikationskode efter udtrækket, ikke under selve LLM-kaldet.

Hvis du holder udtræk og berigelse adskilt, bliver pipelinen lettere at teste og vedligeholde. Du kan teste berigelseslogikken med enhedstest uafhængigt og udskifte udtræksmodellen uden at ændre din berigelseskode.

Måling af nøjagtigheden af informationsudtræk

For pipelines til produktionsudtræk skal du måle nøjagtigheden systematisk i forhold til et mærket testsæt. Vigtige målinger er:

Feltnøjagtighed: Procentdelen af felter, der udtrækkes korrekt pr. dokument
Eksakt match: Feltværdien matcher facitlisten nøjagtigt
Normaliseret match: Feltværdien matcher efter normalisering (f.eks. '$1,234.00' == '1234.0')
Falsk-positiv-rate: Hvor ofte modellen udtrækker et felt, der burde være null
Falsk-negativ-rate: Hvor ofte modellen returnerer null for et felt, der er til stede

Kør denne evaluering, hver gang du ændrer modeller, opdaterer prompts eller tilføjer nye dokumentkilder til din pipeline. Selv små fald i nøjagtigheden kan få betydelig indvirkning på forretningen, når du behandler tusindvis af dokumenter.

Logning af udtræk til løbende forbedring

Alle udtræksresultater i produktion er datapunkter, der kan forbedre din pipeline. Log hvert inputdokument, hvert udtrukket output og alle valideringsfejl i en database. Udtag med jævne mellemrum stikprøver fra produktionsloggene for at identificere almindelige fejlmønstre: bestemte dokumentformater, som modellen har svært ved, felter der ofte er null, selv om de ikke burde være det, eller usædvanlige værdier, der tyder på, at prompten gradvist har ændret betydning.

Disse loggede data bliver også dit fremtidige træningsdatasæt, hvis du på et tidspunkt vil finjustere en model specifikt til din udtræksopgave. Det kan give dig et mere nøjagtigt og billigere alternativ til LLM'er til generelle formål ved struktureret udtræk.

Hurtigt tjek

Test din forståelse af AI Engineering-koncepterne fra denne lektion.

Besvar den i den interaktive lektion

Opsummering af lektionen

I denne lektion har du lært, at LLM'er med Pydantic-skemaer pålideligt udtrækker strukturerede data fra enhver ustruktureret tekstkilde, at asynkron behandling med semaforer muliggør batchudtræk fra tusindvis af dokumenter, samtidig med at hastighedsbegrænsninger overholdes, og at udtræk i flere gennemløb først klassificerer dokumenter og derefter anvender det passende skema for hver type. Nu bygger vi validerings- og automatiske genforsøgslogikker til at håndtere tilfælde, hvor udtrukne data ikke overholder forretningsreglerne.

Gratis at komme i gang

Lær Python med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 30
Lektioner: 120

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Udtræk af data fra ustruktureret tekst” gratis?

Ja — hele teksten til “Udtræk af data fra ustruktureret tekst” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af AI Engineering Academy-kurset, skal du opgradere til CoddyKit PRO. AI Engineering Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Udtræk af data fra ustruktureret tekst”?

Opbyg en pipeline til informationsudtræk, der læser rå tekst som e-mails, kvitteringer og artikler og returnerer strukturerede felter med typer, standardværdier og validering. Du øver dig i AI Engineering Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på AI Engineering Academy?

Der kræves ingen tidligere erfaring. AI Engineering Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “Udtræk af data fra ustruktureret tekst”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne AI Engineering Academy-lektion?

Ja. Alle AI Engineering Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

JSON-tilstand og response_format
Struktureret output med Pydantic
Udtræk af data fra ustruktureret tekst
Validering og nye forsøg ved ugyldigt output

← Tilbage til AI Engineering Academy