0Pricing
AI Engineering Academy · บทเรียน

การดึงข้อมูลจากข้อความไร้โครงสร้าง

สร้างกระบวนการดึงข้อมูลที่อ่านข้อความดิบ เช่น อีเมล ใบเสร็จ และบทความ แล้วส่งคืนฟิลด์ที่มีโครงสร้าง พร้อมชนิด ค่าเริ่มต้น และการตรวจสอบความถูกต้อง

การดึงข้อมูลจากข้อความไร้โครงสร้าง เป็นบทเรียน AI Engineering Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน AI Engineering Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส AI Engineering Academy มีบทเรียนทั้งหมด 4 บทเรียน

ปัญหาการสกัดข้อมูล

องค์กรต่าง ๆ กำลังจมอยู่กับข้อความที่ไม่มีโครงสร้าง เช่น อีเมล บัตรแจ้งปัญหาการสนับสนุน สัญญา ใบแจ้งหนี้ บทความข่าว บันทึกทางการแพทย์ และโพสต์บนโซเชียลมีเดีย ข้อมูลที่มีโครงสร้างอันมีคุณค่าถูกฝังอยู่ในข้อความเหล่านี้ แต่การสกัดข้อมูลด้วยตนเองใช้เวลานาน มีค่าใช้จ่ายสูง และเกิดข้อผิดพลาดได้ง่าย LLM ที่ให้ผลลัพธ์แบบมีโครงสร้างช่วยเปลี่ยนแปลงเรื่องนี้ได้ โดยสามารถอ่านข้อความใด ๆ และเติมข้อมูลลงในโครงสร้างที่กำหนดไว้ล่วงหน้าพร้อมฟิลด์ที่เกี่ยวข้องได้ในปริมาณมากและมีความแม่นยำในระดับที่เหมาะสม

การสกัดข้อมูล (IE) คือกระบวนการระบุและดึงข้อเท็จจริงที่มีโครงสร้างออกจากข้อความที่ไม่มีโครงสร้างโดยอัตโนมัติ การสกัดข้อมูลด้วย LLM มีประสิทธิภาพเหนือกว่าแนวทางแบบใช้กฎหรือแนวทาง NLP แบบดั้งเดิมอย่างมาก เพราะ LLM เข้าใจบริบท คำพ้องความหมาย และข้อมูลโดยนัยได้ โดยไม่จำเป็นต้องเขียนรูปแบบ regex เองสำหรับทุกความแตกต่าง

กรณีการใช้งานการสกัดข้อมูลที่พบบ่อย

การสกัดข้อมูลช่วยขับเคลื่อนการใช้งานทางธุรกิจที่มีคุณค่ามากมาย:

  • การประมวลผลใบแจ้งหนี้: สกัดข้อมูลผู้ขาย รายการสินค้า จำนวนเงิน และวันครบกำหนดจากใบแจ้งหนี้ PDF เพื่อทำให้กระบวนการบัญชีเจ้าหนี้เป็นอัตโนมัติ
  • การวิเคราะห์สัญญา: สกัดข้อมูลคู่สัญญา วันที่มีผล เงื่อนไขการชำระเงิน และข้อกำหนดการยกเลิกจากเอกสารทางกฎหมาย
  • การแยกวิเคราะห์ประวัติย่อ: สกัดทักษะ ประสบการณ์ การศึกษา และข้อมูลติดต่อจากประวัติย่อเพื่อใช้กับระบบ ATS
  • การจัดเส้นทางบัตรแจ้งปัญหาการสนับสนุน: สกัดหมวดหมู่ ระดับความรุนแรง ผลิตภัณฑ์ที่ได้รับผลกระทบ และระดับลูกค้า เพื่อจัดเส้นทางบัตรแจ้งปัญหาโดยอัตโนมัติ
  • การติดตามข่าวสาร: สกัดเอนทิตี เหตุการณ์ และความรู้สึกจากบทความข่าวเพื่อใช้ในการวิเคราะห์คู่แข่ง

การสร้างกระบวนการสกัดข้อมูลจากอีเมล

เราจะสร้างกระบวนการสกัดข้อมูลที่ใช้งานได้จริง โดยอ่านอีเมลของลูกค้าและสกัดข้อมูลที่มีโครงสร้างซึ่งนำไปดำเนินการต่อได้ กระบวนการนี้ใช้โครงสร้าง Pydantic เพื่อกำหนดอย่างชัดเจนว่าเราต้องการข้อมูลใดจากอีเมลแต่ละฉบับ จากนั้นจึงประมวลผลอีเมลเป็นชุด

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

การรู้จำเอนทิตีที่มีชื่อด้วย LLM

การรู้จำเอนทิตีที่มีชื่อ (NER) เป็นงานการสกัดข้อมูลแบบดั้งเดิมประเภทหนึ่ง ได้แก่ การระบุและจัดประเภทเอนทิตีที่มีชื่อ เช่น บุคคล องค์กร สถานที่ วันที่ และจำนวนเงิน ในข้อความ LLM ช่วยทำให้ NER ง่ายขึ้นอย่างมาก เพราะคุณเพียงอธิบายเอนทิตีที่ต้องการ แล้วระบบจะสกัดข้อมูลเหล่านั้นโดยไม่ต้องใช้แบบจำลอง NER ที่ฝึกมาโดยเฉพาะ

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

การสกัดข้อมูลจากเอกสารในปริมาณมาก

สำหรับกระบวนการสกัดข้อมูลในระบบใช้งานจริงที่ประมวลผลเอกสารหลายพันฉบับ คุณจำเป็นต้องมีการประมวลผลแบบอะซิงโครนัสและการจัดการขีดจำกัดอัตราการเรียกใช้งาน รูปแบบทั่วไปคือใช้ asyncio ร่วมกับเซมาฟอร์เพื่อประมวลผลเอกสารแบบขนาน โดยยังคงปฏิบัติตามขีดจำกัดอัตราการเรียกใช้ของ API

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

การจัดการข้อมูลโดยนัยและข้อมูลที่อนุมาน

LLM สามารถสกัดได้ไม่เพียงข้อมูลที่ระบุไว้อย่างชัดเจน แต่ยังรวมถึงข้อมูลที่อนุมานหรือข้อมูลโดยนัยด้วย หากบทวิจารณ์ระบุว่า “ฉันใช้สิ่งนี้ทุกวันมาเป็นเวลาหนึ่งเดือนแล้ว และมันยังคงทำงานได้อย่างสมบูรณ์” แบบจำลองสามารถอนุมานได้ว่าความทนทานเป็นคุณลักษณะเชิงบวก แม้คำว่า “ความทนทาน” จะไม่ปรากฏอยู่เลยก็ตาม นี่เป็นข้อได้เปรียบสำคัญเหนือการสกัดข้อมูลด้วย regex ซึ่งค้นหาได้เฉพาะสิ่งที่ปรากฏอย่างชัดเจนเท่านั้น

อย่างไรก็ตาม ความสามารถนี้มาพร้อมความเสี่ยง แบบจำลองอาจอนุมานมากเกินไปและเติมฟิลด์ด้วยการคาดเดาแทนข้อเท็จจริง สำหรับการสกัดข้อมูลที่มีความสำคัญสูง เช่น ด้านกฎหมาย การเงิน และการแพทย์ ให้เพิ่มฟิลด์ confidence ลงในโครงสร้างของคุณ และกำชับให้แบบจำลองประเมินระดับความแน่ใจของตนเอง พร้อมแจ้งผลการสกัดที่มีความมั่นใจต่ำเพื่อให้มนุษย์ตรวจสอบ

การออกแบบคำสั่งสำหรับการสกัดข้อมูล

คุณภาพของการสกัดข้อมูลขึ้นอยู่กับการออกแบบคำสั่งเป็นอย่างมาก หลักการสำคัญสำหรับคำสั่งการสกัดข้อมูลมีดังนี้:

  • กำหนดฟิลด์ที่คลุมเครือ: หาก “วันที่” อาจหมายถึงวันที่ออกใบแจ้งหนี้ วันครบกำหนด หรือวันที่ได้รับ ให้ระบุอย่างชัดเจนว่าต้องการวันที่ใด
  • ยกตัวอย่างรูปแบบที่ไม่ปกติ: “สำหรับราคา ให้ส่งคืนเฉพาะค่าตัวเลข เช่น 29.99 ไม่ใช่ $29.99”
  • จัดการการทำให้เป็นมาตรฐาน: “ทำให้ชื่อประเทศเป็นรหัส ISO 3166-1 alpha-2”
  • ระบุแหล่งที่มาของข้อมูลที่จะสกัด: “สกัดเฉพาะจากบรรทัดหัวเรื่อง ไม่ใช่เนื้อหาอีเมล”

ให้มองคำสั่งการสกัดข้อมูลเป็นข้อกำหนดที่แม่นยำสำหรับเจ้าหน้าที่ป้อนข้อมูลที่เป็นมนุษย์ ความกำกวมทุกอย่างที่คุณปล่อยไว้ในคำสั่งคือการตัดสินใจที่แบบจำลองจะทำอย่างไม่สม่ำเสมอ

การสกัดข้อมูลหลายรอบสำหรับเอกสารที่ซับซ้อน

เอกสารบางประเภทซับซ้อนเกินกว่าจะสกัดข้อมูลได้ในรอบเดียว เพราะโครงสร้างข้อมูลทั้งหมดมีขนาดใหญ่ แต่ละส่วนต้องใช้ความเชี่ยวชาญต่างกัน หรือโครงสร้างเอกสารมีความหลากหลายสูง การสกัดข้อมูลหลายรอบจะแบ่งงานออกเป็นขั้นตอนต่อเนื่อง โดยเริ่มจากจำแนกประเภทเอกสารก่อน แล้วจึงสกัดข้อมูลตามโครงสร้างที่เหมาะสมกับประเภทนั้น

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

การเติมข้อมูลหลังการสกัด

ข้อมูลที่สกัดแล้วมักต้องได้รับการเติมข้อมูลหลังการสกัดเบื้องต้น เช่น แปลงชื่อบริษัทที่สกัดได้ให้เป็นรูปแบบมาตรฐานโดยค้นจากฐานข้อมูลบริษัท ค้นหารหัสไปรษณีย์ที่สกัดได้เพื่อเติมเมืองและรัฐ หรือแปลงวันที่ที่สกัดได้ให้เป็นรูปแบบมาตรฐาน ขั้นตอนการเติมข้อมูลนี้ควรดำเนินการในโค้ดของแอปพลิเคชันหลังการสกัด ไม่ใช่ระหว่างการเรียกใช้ LLM

การแยกการสกัดข้อมูลออกจากการเติมข้อมูลทำให้กระบวนการประมวลผลทดสอบและดูแลรักษาได้ง่ายขึ้น คุณสามารถทดสอบตรรกะการเติมข้อมูลแบบหน่วยได้อย่างอิสระ และเปลี่ยนแบบจำลองการสกัดข้อมูลได้โดยไม่ต้องแก้ไขโค้ดการเติมข้อมูล

การวัดความแม่นยำของการสกัดข้อมูล

สำหรับกระบวนการสกัดข้อมูลในระบบใช้งานจริง ให้ประเมินความแม่นยำอย่างเป็นระบบโดยเทียบกับชุดข้อมูลทดสอบที่มีการกำกับข้อมูล ตัวชี้วัดสำคัญมีดังนี้:

  • ความแม่นยำของฟิลด์: เปอร์เซ็นต์ของฟิลด์ที่สกัดได้ถูกต้องต่อเอกสารหนึ่งฉบับ
  • การตรงกันแบบทุกประการ: ค่าของฟิลด์ตรงกับค่าความจริงอ้างอิงทุกประการ
  • การตรงกันหลังทำให้เป็นมาตรฐาน: ค่าของฟิลด์ตรงกันหลังจากทำให้เป็นมาตรฐานแล้ว เช่น '$1,234.00' == '1234.0'
  • อัตราผลบวกลวง: ความถี่ที่แบบจำลองสกัดฟิลด์ซึ่งควรเป็นค่าว่างออกมา
  • อัตราผลลบลวง: ความถี่ที่แบบจำลองส่งคืนค่าว่างสำหรับฟิลด์ที่มีข้อมูลอยู่

ให้ดำเนินการประเมินนี้ทุกครั้งที่เปลี่ยนแบบจำลอง ปรับปรุงคำสั่ง หรือเพิ่มแหล่งเอกสารใหม่ลงในกระบวนการของคุณ แม้ความแม่นยำจะลดลงเพียงเล็กน้อย ก็อาจส่งผลกระทบทางธุรกิจอย่างมากเมื่อประมวลผลเอกสารหลายพันฉบับ

การบันทึกข้อมูลการสกัดเพื่อการปรับปรุงอย่างต่อเนื่อง

ผลลัพธ์การสกัดข้อมูลทุกครั้งในระบบใช้งานจริงคือข้อมูลหนึ่งจุดที่สามารถช่วยปรับปรุงกระบวนการของคุณได้ ให้บันทึกเอกสารขาเข้า ผลลัพธ์ที่สกัดได้ และข้อผิดพลาดในการตรวจสอบความถูกต้องทุกครั้งลงในฐานข้อมูล สุ่มตัวอย่างจากบันทึกของระบบเป็นระยะเพื่อระบุรูปแบบความล้มเหลวที่พบบ่อย เช่น รูปแบบเอกสารบางประเภทที่แบบจำลองประมวลผลได้ยาก ฟิลด์ที่มักเป็นค่าว่างทั้งที่ไม่ควรเป็น หรือค่าผิดปกติที่บ่งชี้ว่าคำสั่งเริ่มคลาดเคลื่อน

ข้อมูลที่บันทึกไว้นี้ยังสามารถเป็นชุดข้อมูลฝึกในอนาคต หากคุณต้องการปรับแต่งแบบจำลองให้เหมาะกับงานการสกัดข้อมูลโดยเฉพาะ ทำให้ได้ทางเลือกที่แม่นยำกว่าและมีต้นทุนต่ำกว่า LLM ที่ใช้งานทั่วไปสำหรับการสกัดข้อมูลที่มีโครงสร้าง

ตรวจสอบความเข้าใจ

ทดสอบความเข้าใจแนวคิดด้านวิศวกรรมปัญญาประดิษฐ์จากบทเรียนนี้

สรุปบทเรียน

ในบทเรียนนี้ คุณได้เรียนรู้ว่า LLM ที่ใช้โครงสร้าง Pydantic สามารถสกัดข้อมูลที่มีโครงสร้างจากแหล่งข้อความที่ไม่มีโครงสร้างใด ๆ ได้อย่างน่าเชื่อถือ การประมวลผลแบบอะซิงโครนัสร่วมกับเซมาฟอร์ช่วยให้สกัดข้อมูลจากเอกสารหลายพันฉบับเป็นชุดได้ โดยยังคงปฏิบัติตามขีดจำกัดอัตราการเรียกใช้ และ การสกัดข้อมูลหลายรอบจะจำแนกเอกสารก่อน แล้วจึงใช้โครงสร้างที่เหมาะสมกับแต่ละประเภท บทถัดไปเราจะสร้างตรรกะการตรวจสอบความถูกต้องและการลองใหม่โดยอัตโนมัติ เพื่อจัดการกรณีที่ข้อมูลที่สกัดได้ไม่ผ่านกฎทางธุรกิจ

คำถามที่พบบ่อย

บทเรียน “การดึงข้อมูลจากข้อความไร้โครงสร้าง” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การดึงข้อมูลจากข้อความไร้โครงสร้าง” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส AI Engineering Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส AI Engineering Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การดึงข้อมูลจากข้อความไร้โครงสร้าง”

สร้างกระบวนการดึงข้อมูลที่อ่านข้อความดิบ เช่น อีเมล ใบเสร็จ และบทความ แล้วส่งคืนฟิลด์ที่มีโครงสร้าง พร้อมชนิด ค่าเริ่มต้น และการตรวจสอบความถูกต้อง คุณปฏิบัติ AI Engineering Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน AI Engineering Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน AI Engineering Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน

บทเรียน “การดึงข้อมูลจากข้อความไร้โครงสร้าง” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน AI Engineering Academy นี้ได้ไหม

ได้ บทเรียน AI Engineering Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. โหมด JSON และ response_format
  2. ผลลัพธ์แบบมีโครงสร้างด้วย Pydantic
  3. การดึงข้อมูลจากข้อความไร้โครงสร้าง
  4. การตรวจสอบและลองใหม่เมื่อผลลัพธ์ไม่ถูกต้อง
← กลับไปที่ AI Engineering Academy