PricingLoginStart free
AI Agents · Lektion

Muster für multimodales Reasoning

Textaussagen in Bildern verankern und multimodalen Kontext aus mehreren Quellen zusammenführen.

Lektion 4 von 413 Schritte

Muster für multimodales Reasoning ist eine kostenlose AI Agents-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Agents-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Agents-Kurs umfasst insgesamt 4 Lektionen.

Modalitätsübergreifendes Schlussfolgern

Modalitätsübergreifendes Schlussfolgern findet statt, wenn ein Agent Informationen aus zwei oder mehr Modalitäten – Text, Bilder, Diagramme oder Tabellen – miteinander abgleichen muss, die übereinstimmen, sich widersprechen oder einander ergänzen können. Beispiel: In einem Bericht steht, der Umsatz sei um 20 % gestiegen, aber das beigefügte Diagramm zeigt eine unveränderte Linie.

Der Agent muss entscheiden, welche Quelle korrekt ist, oder die Abweichung zur menschlichen Prüfung markieren.

Text-Bild-Grounding

Text-Bild-Grounding bedeutet zu überprüfen, ob Behauptungen im Text durch ein begleitendes Bild visuell bestätigt werden können. Passt beispielsweise die Produktbeschreibung zum Produktfoto? Wird im Dokument eine Tabelle erwähnt, die tatsächlich im Bild erscheint?

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)

Erkennung von Widersprüchen zwischen Diagramm und Text

Ein häufiges Szenario in der Praxis: Der Fließtext eines Finanzberichts sagt etwas anderes aus als das im Dokument eingebettete Diagramm. Der Agent kann Diagrammdaten visuell extrahieren und mit den numerischen Angaben im Text vergleichen.

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)

Strategien zur Signalkombination

Wenn Signale aus mehreren Modalitäten übereinstimmen, erhöhen Sie die Konfidenz. Bei Widersprüchen wenden Sie eine Strategie zur Konfliktauflösung an: Vertrauen Sie der stärker strukturierten Quelle (bei Zahlen sind Diagramme verlässlicher als Fließtext), markieren Sie den Fall zur menschlichen Prüfung oder bitten Sie das LLM zu begründen, welche Quelle verlässlicher ist.

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

Text-Bild-Verifizierungspipeline

Eine Pipeline zur Produktverifizierung: Überprüfen Sie anhand einer Produktbeschreibung und des zugehörigen Fotos, ob jedes im Text genannte wichtige Merkmal im Bild sichtbar ist. Geben Sie einen strukturierten Bericht über Übereinstimmungen und Abweichungen zurück.

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)

Dokument- und Bildabgleich

Bei der Analyse gescannter Dokumente liegen sowohl der OCR-Text als auch das zugrunde liegende Bild vor. Gleichen Sie beide ab: Stimmt der extrahierte Text mit dem visuell Dargestellten überein? Abweichungen können auf OCR-Fehler hinweisen, die korrigiert werden müssen.

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)

Agent für Schlussfolgerungen aus mehreren Quellen

Ein Agent für Schlussfolgerungen aus mehreren Quellen sammelt systematisch Belege aus jeder Modalität, kombiniert die Signale und erstellt eine abschließende Schlussfolgerung mit einem Konfidenzwert. Er gibt an, welche Quellen seine Schlussfolgerung stützen und welche ihr widersprechen.

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)

Bild-zu-Text-Faktengenerierung

Manchmal liegt ein Bild vor, aus dem Sie strukturierte Fakten für nachgelagertes textbasiertes Schlussfolgern generieren müssen. Extrahieren Sie quantitative Fakten aus Diagrammen und Tabellen als JSON, damit sie mathematisch mit Angaben im Text abgeglichen werden können.

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)

Weiterleitung anhand von Konfidenzschwellen

Leiten Sie das Ergebnis nach dem modalitätsübergreifenden Schlussfolgern anhand der Konfidenz weiter: hohe Konfidenz → automatisch genehmigen, mittlere Konfidenz → zur optionalen Prüfung markieren, geringe Konfidenz → an einen Menschen eskalieren. Widersprüchliche Signale dürfen unabhängig vom Konfidenzwert niemals automatisch genehmigt werden.

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

Umgang mit unzureichenden visuellen Belegen

Manchmal ist ein Bild zu niedrig aufgelöst, unscharf oder teilweise verdeckt, um brauchbare Belege zu liefern. Der Agent muss dies erkennen und auf eine modalitätsübergreifende Schlussfolgerung verzichten, statt eine solche zu halluzinieren.

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)

Einen modalitätsübergreifenden Faktenchecker erstellen

Alles zusammenführen: Ein Dokument-Faktenchecker nimmt einen Bericht (Text und eingebettete Bilder) entgegen und überprüft jede quantitative Angabe im Text anhand der unterstützenden Diagramme und Tabellen. Er gibt einen strukturierten Verifizierungsbericht zurück.

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
    }

Wissensüberprüfung

Was sollte der modalitätsübergreifende Agent laut den Best Practices tun, wenn Text- und Diagrammsignale widersprüchlich sind?

Beantworte es in der interaktiven Lektion

Zusammenfassung: Muster des modalitätsübergreifenden Schlussfolgerns

Sie haben diese Lektion abgeschlossen. Die wichtigsten Punkte:

  • Text-Bild-Grounding: Behauptungen im Text anhand visueller Belege überprüfen
  • Signalkombination: gewichtete Vertrauenswürdigkeit (Diagramme > Fließtext bei Zahlen), strukturierte Quellen sind unstrukturierten überlegen
  • Widerspruchserkennung: immer an einen Menschen eskalieren – Widersprüche niemals automatisch auflösen
  • Konfidenzbasierte Weiterleitung: automatisch genehmigen (hoch) → optionale Prüfung (mittel) → eskalieren (gering oder widersprüchlich)
  • Unzureichende Belege: auf eine modalitätsübergreifende Schlussfolgerung verzichten, statt sie zu halluzinieren

Nächster Kurs: IoT- und sensorbasierte Agenten – Verarbeitung von Datenströmen aus der realen Welt mit MQTT.

Kostenlos starten

Lerne AI Agents mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse
60
Lektionen
239
Kostenlos lernenDen vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Muster für multimodales Reasoning“ kostenlos?

Ja — der vollständige Text von „Muster für multimodales Reasoning“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Agents-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Agents-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Muster für multimodales Reasoning“?

Textaussagen in Bildern verankern und multimodalen Kontext aus mehreren Quellen zusammenführen. Du übst AI Agents mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um AI Agents zu starten?

Keine Vorkenntnisse erforderlich. AI Agents auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Muster für multimodales Reasoning“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser AI Agents-Lektion Code schreiben und ausführen?

Ja. Jede AI Agents-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Bild- und Textagenten mit Claude Vision und GPT-4V
  2. Agenten-Workflows für Audio und Text
  3. Videoverständnis in Agenten
  4. Muster für multimodales Reasoning
← Zurück zu AI Agents