AI Agents · Pelajaran

Pola Penalaran Lintas Modalitas

Melandaskan klaim teks pada gambar dan menyintesis konteks multimodal dari berbagai sumber.

Pelajaran 4 dari 413 langkah

Pola Penalaran Lintas Modalitas adalah pelajaran AI Agents gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar AI Agents, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus AI Agents mencakup 4 pelajaran total.

Penalaran Lintas Modalitas

Penalaran lintas modalitas terjadi ketika agen harus menyelaraskan informasi dari dua atau lebih modalitas — teks, gambar, grafik, tabel — yang mungkin saling sesuai, bertentangan, atau saling melengkapi. Contohnya: teks laporan menyatakan bahwa pendapatan tumbuh 20%, tetapi grafik terlampir menunjukkan garis datar.

Agen harus menentukan sumber mana yang benar atau menandai ketidaksesuaian tersebut untuk ditinjau oleh manusia.

Pencocokan Teks dengan Gambar

Pencocokan teks dengan gambar berarti memverifikasi bahwa klaim dalam teks dapat dikonfirmasi secara visual melalui gambar pendamping. Contohnya: apakah deskripsi produk sesuai dengan foto produk? Apakah dokumen menyebutkan tabel yang benar-benar terlihat dalam gambar?

import anthropic
import base64

def ground_text_in_image(
    text_claim: str,
    image_path: str
) -> dict:
    client = anthropic.Anthropic(api_key='YOUR_API_KEY')
    with open(image_path, 'rb') as f:
        b64 = base64.standard_b64encode(f.read()).decode('utf-8')

    prompt = (
        f'Text claim: "{text_claim}"\n\n'
        'Does the image above support, contradict, or partially support this claim?\n'
        'Return JSON: {"verdict": "support|contradict|partial|insufficient_evidence", '
        '"confidence": 0.0, "evidence": "..."}'
    )
    response = client.messages.create(
        model='claude-opus-4-5', max_tokens=256,
        messages=[{'role': 'user', 'content': [
            {'type': 'image', 'source': {'type': 'base64',
              'media_type': 'image/jpeg', 'data': b64}},
            {'type': 'text', 'text': prompt}
        ]}]
    )
    import json
    return json.loads(response.content[0].text)

Mendeteksi Kontradiksi antara Grafik dan Teks

Skenario umum di dunia nyata: narasi laporan keuangan menyatakan satu hal, tetapi grafik yang disisipkan dalam dokumen menceritakan hal yang berbeda. Agen dapat mengekstrak data grafik secara visual dan membandingkannya dengan klaim numerik dalam teks.

def compare_chart_to_text(
    chart_image_path: str,
    text_with_claims: str
) -> dict:
    import anthropic, base64, json
    client = anthropic.Anthropic(api_key='YOUR_API_KEY')
    with open(chart_image_path, 'rb') as f:
        b64 = base64.standard_b64encode(f.read()).decode('utf-8')

    prompt = (
        'The following text makes claims about data.\n'
        f'TEXT: {text_with_claims}\n\n'
        'Compare the chart image to the text claims. '
        'List any contradictions and agreements. '
        'Return JSON: {"agreements": [str], "contradictions": [str], '
        '"verdict": "consistent|inconsistent|partial"}'
    )
    response = client.messages.create(
        model='claude-opus-4-5', max_tokens=512,
        messages=[{'role': 'user', 'content': [
            {'type': 'image', 'source': {'type': 'base64',
              'media_type': 'image/jpeg', 'data': b64}},
            {'type': 'text', 'text': prompt}
        ]}]
    )
    return json.loads(response.content[0].text)

Strategi Penggabungan Sinyal

Ketika sinyal dari beberapa modalitas sesuai, tingkatkan keyakinan. Ketika sinyal tersebut tidak sesuai, terapkan strategi penyelesaian konflik: percayai sumber yang lebih terstruktur (untuk angka, grafik lebih diutamakan daripada narasi), tandai untuk ditinjau oleh manusia, atau minta LLM menalar sumber mana yang lebih dapat diandalkan.

SIGNAL_SOURCES = {
    'chart': 0.9,     # high trust for quantitative data
    'table': 0.85,
    'photo': 0.8,
    'prose': 0.6,     # lower trust — may be imprecise or outdated
    'caption': 0.7
}

def combine_signals(signals: list) -> dict:
    """
    signals: list of {'source': str, 'claim': str, 'supports': bool}
    Returns weighted verdict.
    """
    support_weight = 0.0
    total_weight = 0.0
    for sig in signals:
        w = SIGNAL_SOURCES.get(sig['source'], 0.5)
        total_weight += w
        if sig['supports']:
            support_weight += w

    confidence = support_weight / total_weight if total_weight > 0 else 0.0
    return {
        'confidence': round(confidence, 3),
        'verdict': 'supported' if confidence >= 0.6 else 'contested',
        'needs_review': 0.4 <= confidence < 0.6
    }

if __name__ == '__main__':
    signals = [
        {'source': 'chart', 'claim': 'Revenue grew 20%', 'supports': True},
        {'source': 'prose', 'claim': 'Revenue grew 20%', 'supports': False},
    ]
    print(combine_signals(signals))

Alur Verifikasi Teks-ke-Gambar

Alur verifikasi produk: dengan deskripsi produk dan fotonya, periksa apakah setiap atribut utama yang disebutkan dalam teks terlihat pada gambar. Kembalikan laporan terstruktur tentang kecocokan dan ketidakcocokan.

def verify_product_description(
    description: str,
    product_image_path: str
) -> dict:
    import anthropic, base64, json
    client = anthropic.Anthropic(api_key='YOUR_API_KEY')
    with open(product_image_path, 'rb') as f:
        b64 = base64.standard_b64encode(f.read()).decode('utf-8')

    prompt = (
        f'Product description:\n{description}\n\n'
        'For each attribute mentioned in the description (color, shape, material, '
        'size, features), check whether it is visible in the product photo.\n'
        'Return JSON: {"verified": [{"attribute": str, "status": str}], '
        '"unverified": [str], "overall_match": float}\n'
        'status: confirmed / contradicted / not_visible\n'
        'overall_match: 0.0-1.0'
    )
    response = client.messages.create(
        model='claude-opus-4-5', max_tokens=512,
        messages=[{'role': 'user', 'content': [
            {'type': 'image', 'source': {'type': 'base64',
              'media_type': 'image/jpeg', 'data': b64}},
            {'type': 'text', 'text': prompt}
        ]}]
    )
    return json.loads(response.content[0].text)

Rujuk Silang Dokumen dan Gambar

Saat menganalisis dokumen hasil pemindaian, teks OCR dan gambar dasarnya sama-sama tersedia. Rujuk silangkan keduanya: apakah teks yang diekstrak sesuai dengan yang terlihat secara visual? Ketidaksesuaian dapat menandakan kesalahan OCR yang perlu diperbaiki.

def crossref_ocr_with_image(
    ocr_text: str,
    document_image_path: str
) -> dict:
    import anthropic, base64, json
    client = anthropic.Anthropic(api_key='YOUR_API_KEY')
    with open(document_image_path, 'rb') as f:
        b64 = base64.standard_b64encode(f.read()).decode('utf-8')

    prompt = (
        f'The OCR system produced this text from the document image:\n\n'
        f'{ocr_text}\n\n'
        'Compare the OCR text to what you actually see in the image. '
        'Identify any OCR errors, missed text, or hallucinated characters.\n'
        'Return JSON: {"ocr_errors": [{"incorrect": str, "correct": str}], '
        '"missed_sections": [str], "accuracy_estimate": float}'
    )
    response = client.messages.create(
        model='claude-opus-4-5', max_tokens=512,
        messages=[{'role': 'user', 'content': [
            {'type': 'image', 'source': {'type': 'base64',
              'media_type': 'image/jpeg', 'data': b64}},
            {'type': 'text', 'text': prompt}
        ]}]
    )
    return json.loads(response.content[0].text)

Agen Penalaran Multi-Sumber

Agen penalaran multi-sumber secara sistematis mengumpulkan bukti dari setiap modalitas, menggabungkan sinyal, dan menghasilkan kesimpulan akhir dengan skor keyakinan. Agen ini menyebutkan sumber mana yang mendukung kesimpulannya dan mana yang membantahnya.

def multi_source_reasoning(
    claim: str,
    evidence_sources: list  # list of {'type': 'text'|'image', 'content': str|path}
) -> dict:
    import anthropic, base64, json
    client = anthropic.Anthropic(api_key='YOUR_API_KEY')
    content_blocks = [
        {'type': 'text',
         'text': f'Evaluate this claim using ALL sources below:\nClaim: "{claim}"\n'}
    ]
    for i, src in enumerate(evidence_sources):
        if src['type'] == 'text':
            content_blocks.append(
                {'type': 'text', 'text': f'Source {i+1} (text): {src["content"]}'}
            )
        elif src['type'] == 'image':
            with open(src['content'], 'rb') as f:
                b64 = base64.standard_b64encode(f.read()).decode('utf-8')
            content_blocks.append(
                {'type': 'text', 'text': f'Source {i+1} (image):'}
            )
            content_blocks.append(
                {'type': 'image', 'source': {'type': 'base64',
                  'media_type': 'image/jpeg', 'data': b64}}
            )
    content_blocks.append({'type': 'text', 'text':
        'Return JSON: {"verdict": str, "confidence": float, '
        '"supporting_sources": [int], "contradicting_sources": [int]}'
    })
    response = client.messages.create(
        model='claude-opus-4-5', max_tokens=512,
        messages=[{'role': 'user', 'content': content_blocks}]
    )
    return json.loads(response.content[0].text)

Pembuatan Fakta dari Gambar ke Teks

Terkadang Anda memiliki gambar dan perlu menghasilkan fakta terstruktur darinya untuk penalaran berbasis teks pada tahap berikutnya. Ekstrak fakta kuantitatif dari grafik dan tabel sebagai JSON agar dapat diverifikasi secara matematis terhadap klaim dalam teks.

def extract_facts_from_chart(chart_path: str) -> dict:
    import anthropic, base64, json
    client = anthropic.Anthropic(api_key='YOUR_API_KEY')
    with open(chart_path, 'rb') as f:
        b64 = base64.standard_b64encode(f.read()).decode('utf-8')

    prompt = (
        'Extract all quantitative data from this chart. '
        'Return JSON with: chart_type, x_axis_label, y_axis_label, '
        'and data_points as [{label: str, value: float}].\n'
        'Also extract any trend: increasing/decreasing/stable/volatile.'
    )
    response = client.messages.create(
        model='claude-opus-4-5', max_tokens=512,
        messages=[{'role': 'user', 'content': [
            {'type': 'image', 'source': {'type': 'base64',
              'media_type': 'image/jpeg', 'data': b64}},
            {'type': 'text', 'text': prompt}
        ]}]
    )
    return json.loads(response.content[0].text)

Perutean Berdasarkan Ambang Keyakinan

Setelah penalaran lintas modalitas, rutekan hasil berdasarkan tingkat keyakinan: tingkat keyakinan tinggi → setujui secara otomatis, sedang → tandai untuk peninjauan opsional, rendah → eskalasikan kepada manusia. Jangan pernah menyetujui sinyal yang bertentangan secara otomatis, terlepas dari skor keyakinannya.

def route_cross_modal_result(result: dict) -> str:
    confidence = result.get('confidence', 0.0)
    has_contradiction = bool(result.get('contradicting_sources'))

    if has_contradiction:
        return 'ESCALATE'
    if confidence >= 0.85:
        return 'AUTO_APPROVE'
    if confidence >= 0.6:
        return 'OPTIONAL_REVIEW'
    return 'ESCALATE'

# Example routing table:
# confidence >= 0.85, no contradiction -> AUTO_APPROVE
# confidence 0.6-0.85, no contradiction -> OPTIONAL_REVIEW
# any contradiction, or confidence < 0.6 -> ESCALATE

def handle_routing(claim: str, evidence_sources: list):
    result = multi_source_reasoning(claim, evidence_sources)
    action = route_cross_modal_result(result)
    print(f'Claim: "{claim}"')
    print(f'Verdict: {result["verdict"]} (confidence={result["confidence"]:.2f})')
    print(f'Action: {action}')
    return action, result

Menangani Bukti Visual yang Tidak Memadai

Terkadang gambar memiliki resolusi terlalu rendah, buram, atau tertutup sebagian sehingga tidak dapat memberikan bukti yang berguna. Agen harus mendeteksi hal ini dan tidak mengambil kesimpulan lintas modalitas, alih-alih mengarang kesimpulan.

def assess_image_evidence_quality(
    image_path: str,
    claim: str
) -> dict:
    import anthropic, base64, json
    client = anthropic.Anthropic(api_key='YOUR_API_KEY')
    with open(image_path, 'rb') as f:
        b64 = base64.standard_b64encode(f.read()).decode('utf-8')

    prompt = (
        f'Claim to verify: "{claim}"\n\n'
        'Assess whether this image provides sufficient evidence to evaluate the claim.\n'
        'Consider: image quality, relevance, completeness, and readability.\n'
        'Return JSON: {"sufficient": bool, "quality_issues": [str], '
        '"usable_evidence": str}'
    )
    response = client.messages.create(
        model='claude-opus-4-5', max_tokens=256,
        messages=[{'role': 'user', 'content': [
            {'type': 'image', 'source': {'type': 'base64',
              'media_type': 'image/jpeg', 'data': b64}},
            {'type': 'text', 'text': prompt}
        ]}]
    )
    return json.loads(response.content[0].text)

Membangun Pemeriksa Fakta Lintas Modalitas

Jika semuanya digabungkan: pemeriksa fakta dokumen yang menerima laporan (teks + gambar tersemat) dan memverifikasi setiap klaim kuantitatif dalam teks terhadap grafik dan tabel pendukung. Pemeriksa ini mengembalikan laporan verifikasi terstruktur.

def fact_check_report(
    report_text: str,
    image_paths: list
) -> dict:
    import re
    # Extract numeric claims from text (simple regex pattern)
    claim_pattern = r'[A-Z][^.!?]*[0-9][%$][^.!?]*[.!?]'
    claims = re.findall(claim_pattern, report_text)

    results = []
    for claim in claims:
        sources = [
            {'type': 'text', 'content': report_text},
        ] + [{'type': 'image', 'content': p} for p in image_paths]

        reasoning = multi_source_reasoning(claim, sources)
        action = route_cross_modal_result(reasoning)
        results.append({
            'claim': claim,
            'verdict': reasoning['verdict'],
            'confidence': reasoning['confidence'],
            'action': action
        })

    total = len(results)
    auto_approved = sum(1 for r in results if r['action'] == 'AUTO_APPROVE')
    return {
        'total_claims': total,
        'auto_approved': auto_approved,
        'escalated': total - auto_approved,
        'details': results
    }

Uji Pemahaman

Ketika sinyal teks dan grafik saling bertentangan, apa yang harus dilakukan agen lintas modalitas sesuai praktik terbaik?

Jawab di pelajaran interaktif

Ringkasan: Pola Penalaran Lintas Modalitas

Anda telah menyelesaikan pelajaran ini. Poin-poin penting:

Pencocokan teks dengan gambar: verifikasi klaim teks terhadap bukti visual
Penggabungan sinyal: kepercayaan berbobot (grafik > narasi untuk angka), sumber terstruktur lebih diutamakan daripada sumber tidak terstruktur
Deteksi kontradiksi: selalu eskalasikan kepada manusia — jangan pernah menyelesaikan kontradiksi secara otomatis
Perutean berdasarkan keyakinan: setujui secara otomatis (tinggi) → peninjauan opsional (sedang) → eskalasikan (rendah atau kontradiksi)
Bukti tidak memadai: jangan mengambil kesimpulan daripada mengarang kesimpulan lintas modalitas

Kursus berikutnya: Agen IoT Berbasis Sensor — memproses aliran data dunia nyata dengan MQTT.

Gratis untuk memulai

Belajar AI Agents dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 60
Pelajaran: 239

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pola Penalaran Lintas Modalitas” gratis?

Ya — teks lengkap “Pola Penalaran Lintas Modalitas” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus AI Agents, upgrade ke CoddyKit PRO. Kursus AI Agents mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Pola Penalaran Lintas Modalitas”?

Melandaskan klaim teks pada gambar dan menyintesis konteks multimodal dari berbagai sumber. Kamu berlatih AI Agents dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai AI Agents?

Tidak diperlukan pengalaman sebelumnya. AI Agents di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Pola Penalaran Lintas Modalitas” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran AI Agents ini?

Ya. Setiap pelajaran AI Agents menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Agen Gambar + Teks dengan Claude Vision dan GPT-4V
Alur Kerja Agen Audio + Teks
Pemahaman Video dalam Agen
Pola Penalaran Lintas Modalitas

← Kembali ke AI Agents