AI Engineering Academy · leksjon

Hente ut data fra ustrukturert tekst

Bygg en pipeline for informasjonsuthenting som leser råtekst, for eksempel e-poster, kvitteringer og artikler, og returnerer strukturerte felt med typer, standardverdier og validering.

Leksjon 3 av 413 trinn

Hente ut data fra ustrukturert tekst er en gratis leksjon i AI Engineering Academy på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i AI Engineering Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i AI Engineering Academy inneholder totalt 4 leksjoner.

Problemet med informasjonsutvinning

Organisasjoner drukner i ustrukturert tekst: e-poster, supportsaker, kontrakter, fakturaer, nyhetsartikler, medisinske notater og innlegg på sosiale medier. Verdifulle strukturerte data ligger skjult i denne teksten, men det er langsomt, kostbart og feilutsatt å hente dem ut manuelt. LLM-er med strukturerte utdata endrer dette: De kan lese hvilken som helst tekst og fylle ut et forhåndsdefinert skjema med de relevante feltene, i stor skala og med rimelig nøyaktighet.

Informasjonsutvinning (IE) er prosessen med å identifisere og hente ut strukturerte fakta fra ustrukturert tekst automatisk. IE basert på LLM-er gir langt bedre resultater enn tidligere regelbaserte eller klassiske NLP-metoder, fordi LLM-er forstår kontekst, synonymer og implisitt informasjon uten at man må lage regex-mønstre manuelt for hver variant.

Vanlige bruksområder for informasjonsutvinning

Informasjonsutvinning brukes i mange verdifulle forretningsapplikasjoner:

Fakturabehandling: Hent ut leverandør, linjeelementer, beløp og forfallsdatoer fra PDF-fakturaer for å automatisere behandling av leverandørgjeld
Kontraktsanalyse: Hent ut parter, ikrafttredelsesdatoer, betalingsvilkår og oppsigelsesklausuler fra juridiske dokumenter
CV-tolking: Hent ut ferdigheter, erfaring, utdanning og kontaktinformasjon fra CV-er for ATS-systemer
Ruting av supportsaker: Hent ut kategori, alvorlighetsgrad, berørt produkt og kundesegment for å rute saker automatisk
Nyhetsovervåking: Hent ut entiteter, hendelser og sentiment fra nyhetsartikler for konkurranseinformasjon

Bygging av en pipeline for e-postutvinning

La oss bygge en praktisk pipeline for informasjonsutvinning som leser kunde-e-poster og henter ut handlingsrettede strukturerte data. Pipelinen bruker et Pydantic-skjema til å definere nøyaktig hva vi ønsker fra hver e-post, og behandler deretter e-postene i batcher.

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

Gjenkjenning av navngitte entiteter med LLM-er

Gjenkjenning av navngitte entiteter (Named Entity Recognition, NER) er en klassisk IE-oppgave: å identifisere og klassifisere navngitte entiteter (personer, organisasjoner, steder, datoer og pengebeløp) i tekst. LLM-er forenkler NER betydelig, fordi De bare beskriver entitetene De ønsker, og modellen henter dem ut uten at De trenger en spesialtrent NER-modell.

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}')

Utvinning fra dokumenter i stor skala

For produksjonspipelines for informasjonsutvinning som behandler tusenvis av dokumenter, trenger De asynkron behandling og håndtering av takstbegrensninger. Et vanlig mønster bruker asyncio med en semafor for å behandle dokumenter parallelt samtidig som API-ets takstbegrensninger 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 av implisitt og utledet informasjon

LLM-er kan hente ut ikke bare informasjon som er uttrykkelig oppgitt, men også utledet eller implisitt informasjon. Hvis en anmeldelse sier «Jeg har brukt dette daglig i en måned, og det fungerer fortsatt perfekt», kan modellen utlede at holdbarhet er en positiv egenskap, selv om ordet «holdbarhet» aldri forekommer. Dette er en stor fordel sammenlignet med regex-basert utvinning, som bare kan finne det som uttrykkelig står i teksten.

Denne egenskapen innebærer imidlertid en risiko: Modellen kan trekke for sterke slutninger og fylle ut felt med gjetninger i stedet for fakta. For utvinning med høye konsekvenser (juridisk, økonomisk eller medisinsk) bør De legge til et confidence-felt i skjemaet og instruere modellen om å angi hvor sikker den er, slik at utvinning med lav konfidens flagges for menneskelig gjennomgang.

Utforming av utvinningsprompter

Kvaliteten på utvinningen avhenger i stor grad av hvordan prompten utformes. Viktige prinsipper for utvinningsprompter:

Definer tvetydige felt: Hvis «dato» kan bety fakturadato, forfallsdato eller mottaksdato, må De spesifisere nøyaktig hvilken De ønsker
Gi eksempler på uvanlige formater: «For pris skal De bare returnere den numeriske verdien, for eksempel 29.99, ikke $29.99»
Håndter normalisering: «Normaliser landenavn til ISO 3166-1 alpha-2-koder»
Angi kilde for utvinningen: «Hent bare ut fra emnelinjen, ikke fra innholdet i e-posten»

Tenk på utvinningsprompten som en presis spesifikasjon for en menneskelig dataregistreringsoperatør – hver tvetydighet De lar stå i prompten, blir en skjønnsmessig avgjørelse modellen vil ta på en inkonsekvent måte.

Utvinning i flere omganger for komplekse dokumenter

Noen dokumenter er for komplekse til at de kan behandles i én omgang, fordi hele skjemaet er stort, ulike deler krever ulik ekspertise, eller dokumentstrukturen varierer mye. Utvinning i flere omganger deler oppgaven i sekvensielle trinn: Først klassifiseres dokumenttypen, og deretter hentes det ut et passende skjema for denne typen.

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')

Berikelse etter utvinning

Data som er hentet ut, trenger ofte berikelse etter den innledende utvinningen: De kan konvertere uthentede firmanavn til kanoniske former ved å slå dem opp i en firmadatabase, slå opp det uthentede postnummeret for å fylle ut by og delstat, eller konvertere uthentede datoer til et standardformat. Dette berikelsestrinnet bør utføres i applikasjonskoden etter utvinningen, ikke under selve LLM-kallet.

Ved å holde utvinning og berikelse adskilt blir pipelinen enklere å teste og vedlikeholde. De kan enhetsteste berikelseslogikken uavhengig og bytte ut utvinningsmodellen uten å endre berikelseskoden.

Måling av utvinningsnøyaktighet

For produksjonspipelines for informasjonsutvinning bør De måle nøyaktigheten systematisk mot et merket testsett. Viktige måltall er:

Feltnøyaktighet: Prosentandelen felt som er hentet riktig ut per dokument
Eksakt samsvar: Feltverdien samsvarer nøyaktig med fasiten
Normalisert samsvar: Feltverdien samsvarer etter normalisering (for eksempel '$1,234.00' == '1234.0')
Frekvens for falske positive: Hvor ofte modellen henter ut et felt som skulle vært null
Frekvens for falske negative: Hvor ofte modellen returnerer null for et felt som faktisk finnes

Kjør denne evalueringen hver gang De endrer modeller, oppdaterer prompter eller legger til nye dokumentkilder i pipelinen. Selv små fall i nøyaktighet kan føre til betydelige forretningsmessige konsekvenser når tusenvis av dokumenter behandles.

Logging av utvinning for kontinuerlig forbedring

Hvert utvinningsresultat i produksjon er et datapunkt som kan forbedre pipelinen. Logg hvert inndatadokument, hver uthentede utdata og eventuelle valideringsfeil i en database. Ta jevnlig stikkprøver fra produksjonsloggene for å identifisere vanlige feilmønstre: bestemte dokumentformater modellen har problemer med, felt som ofte er null når de ikke burde være det, eller uvanlige verdier som tyder på at prompten har endret seg over tid.

Disse loggede dataene blir også fremtidige treningsdata dersom De senere ønsker å finjustere en modell spesifikt for utvinningsoppgaven. Det kan gi et mer nøyaktig og rimeligere alternativ til LLM-er for generell bruk ved strukturert utvinning.

Hurtigsjekk

Test forståelsen Deres av konseptene innen AI Engineering fra denne leksjonen.

Besvar den i den interaktive leksjonen

Oppsummering av leksjonen

I denne leksjonen lærte De at LLM-er med Pydantic-skjemaer pålitelig kan hente ut strukturerte data fra alle ustrukturerte tekstkilder, at asynkron behandling med semaforer muliggjør utvinning i batcher fra tusenvis av dokumenter samtidig som takstbegrensninger overholdes, og at utvinning i flere omganger først klassifiserer dokumenter og deretter bruker det riktige skjemaet for hver type. Neste steg er å bygge validerings- og automatisk nykjøringslogikk for å håndtere tilfeller der uthentede data bryter med forretningsregler.

Gratis å komme i gang

Lær deg Python med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 30
Leksjoner: 120

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Hente ut data fra ustrukturert tekst» gratis?

Ja – hele teksten i «Hente ut data fra ustrukturert tekst» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av AI Engineering Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i AI Engineering Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Hente ut data fra ustrukturert tekst»?

Bygg en pipeline for informasjonsuthenting som leser råtekst, for eksempel e-poster, kvitteringer og artikler, og returnerer strukturerte felt med typer, standardverdier og validering. Du øver på AI Engineering Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med AI Engineering Academy?

Ingen tidligere erfaring er nødvendig. AI Engineering Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Hente ut data fra ustrukturert tekst»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne AI Engineering Academy-leksjonen?

Ja. Alle AI Engineering Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

JSON-modus og response_format
Strukturerte utdata med Pydantic
Hente ut data fra ustrukturert tekst
Validere og prøve på nytt ved ugyldige utdata

← Tilbake til AI Engineering Academy