0Pricing
AI Agents · Ders

Çapraz Modlu Akıl Yürütme Örüntüleri

Metin iddialarını görüntülerde temellendirme ve çok kaynaklı çok modlu bağlamı sentezleme.

Çapraz Modlu Akıl Yürütme Örüntüleri, CoddyKit'te ücretsiz bir AI Agents dersidir. Bu, 4 dersinin 4. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, AI Agents öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. AI Agents kursu toplamda 4 dersten oluşur.

Çapraz Modlu Akıl Yürütme

Çapraz modlu akıl yürütme, bir ajanın birbiriyle uyuşabilen, çelişebilen veya birbirini tamamlayabilen iki ya da daha fazla modaliteden — metin, görüntüler, grafikler, tablolar — gelen bilgileri uzlaştırması gerektiğinde gerçekleşir. Örneğin bir rapor metni gelirin %20 arttığını söylerken ekli grafik yatay bir çizgi gösterebilir.

Ajan, hangi kaynağın doğru olduğuna karar vermeli veya tutarsızlığı insan incelemesine sunmalıdır.

Metin-Görüntü Temellendirmesi

Metin-görüntü temellendirmesi, metindeki iddiaların eşlik eden bir görüntüde görsel olarak doğrulanıp doğrulanamadığını denetlemek anlamına gelir. Örneğin ürün açıklaması ürün fotoğrafıyla uyuşuyor mu? Belgede, görüntüde gerçekten bulunan bir tablodan söz ediliyor mu?

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)

Grafik ve Metin Çelişkilerini Algılama

Yaygın bir gerçek dünya senaryosu şudur: finansal raporun metni bir şey söyler, ancak belgeye eklenmiş grafik farklı bir tablo ortaya koyar. Ajan, grafik verilerini görsel olarak çıkarabilir ve bunları metindeki sayısal iddialarla karşılaştırabilir.

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)

Sinyal Birleştirme Stratejileri

Birden çok modaliteden gelen sinyaller uyuştuğunda güveni artırın. Uyuşmadıklarında bir çakışma çözüm stratejisi uygulayın: daha yapılandırılmış kaynağa güvenin (sayılar için grafikler düzyazıya göre daha güvenilirdir), insan incelemesi için işaretleyin veya hangi kaynağın daha güvenilir olduğunu değerlendirmesi için LLM'den isteyin.

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

Metinden Görüntüye Doğrulama İşlem Hattı

Ürün doğrulama işlem hattı şu şekilde çalışır: bir ürün açıklaması ve ürün fotoğrafı verildiğinde, metinde belirtilen her temel özelliğin görüntüde görünür olup olmadığını denetleyin. Eşleşmeleri ve uyuşmazlıkları içeren yapılandırılmış bir rapor döndürün.

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)

Belge ve Görüntüyü Çapraz Karşılaştırma

Taranmış belgeleri analiz ederken hem OCR metni hem de temel görüntü bulunur. Bunları çapraz karşılaştırın: çıkarılan metin görsel olarak mevcut olanla uyuşuyor mu? Uyuşmazlıklar, düzeltilmesi gereken OCR hatalarına işaret edebilir.

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)

Çok Kaynaklı Akıl Yürütme Ajanı

Çok kaynaklı akıl yürütme ajanı, her modaliteden kanıtları sistematik olarak toplar, sinyalleri birleştirir ve güven puanıyla birlikte nihai bir sonuç üretir. Sonucunu destekleyen ve sonucuyla çelişen kaynakları belirtir.

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)

Görüntüden Olgu Üretimi

Bazen bir görüntünüz olur ve sonraki metin tabanlı akıl yürütme işlemleri için bu görüntüden yapılandırılmış olgular üretmeniz gerekir. Grafik ve tablolardaki nicel olguları JSON olarak çıkarın; böylece bu olgular metindeki iddialara karşı matematiksel olarak doğrulanabilir.

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)

Güven Eşiğine Göre Yönlendirme

Çapraz modlu akıl yürütmeden sonra sonucu güven düzeyine göre yönlendirin: yüksek güven → otomatik olarak onayla, orta güven → isteğe bağlı inceleme için işaretle, düşük güven → insana yönlendir. Güven puanı ne olursa olsun çelişen sinyalleri asla otomatik olarak onaylamayın.

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

Yetersiz Görsel Kanıtı Yönetme

Bazen bir görüntü, kullanışlı kanıt sağlayamayacak kadar düşük çözünürlüklü, bulanık veya kısmen örtülmüş olabilir. Ajan bunu algılamalı ve çapraz modlu bir sonuç uydurmak yerine sonuç çıkarmaktan kaçınmalıdır.

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)

Çapraz Modlu Olgu Doğrulayıcı Oluşturma

Tümünü bir araya getirelim: bir raporu (metin ve gömülü görüntüler) alan ve metindeki her nicel iddiayı destekleyici grafik ve tablolara göre doğrulayan bir belge doğrulayıcı. Yapılandırılmış bir doğrulama raporu döndürür.

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
    }

Bilgi Kontrolü

Metin ve grafik sinyalleri çeliştiğinde, en iyi uygulamalara göre çapraz modlu ajan ne yapmalıdır?

Özet: Çapraz Modlu Akıl Yürütme Örüntüleri

Bu dersi tamamladınız. Temel noktalar:

  • Metin-görüntü temellendirmesi: metin iddialarını görsel kanıtlara göre doğrulayın
  • Sinyal birleştirme: ağırlıklı güven (sayılar için grafikler > düzyazı), yapılandırılmış kaynaklar yapılandırılmamış kaynaklara üstün gelir
  • Çelişki algılama: her zaman insana yönlendirin — çelişkileri asla otomatik olarak çözmeyin
  • Güvene göre yönlendirme: otomatik onay (yüksek) → isteğe bağlı inceleme (orta) → yönlendirme (düşük veya çelişki)
  • Yetersiz kanıt: çapraz modlu bir sonuç uydurmak yerine sonuç çıkarmaktan kaçının

Sıradaki kurs: IoT ve Sensörlerle Çalışan Ajanlar — gerçek dünya veri akışlarını MQTT ile işleme.

Sıkça Sorulan Sorular

“Çapraz Modlu Akıl Yürütme Örüntüleri” dersi ücretsiz mi?

Evet — “Çapraz Modlu Akıl Yürütme Örüntüleri” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve AI Agents kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. AI Agents kursu toplamda 4 dersten oluşur.

“Çapraz Modlu Akıl Yürütme Örüntüleri” dersinde ne öğreneceğim?

Metin iddialarını görüntülerde temellendirme ve çok kaynaklı çok modlu bağlamı sentezleme. AI Agents ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

AI Agents öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te AI Agents, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 4. dersidir.

“Çapraz Modlu Akıl Yürütme Örüntüleri” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu AI Agents dersinde kod yazıp çalıştırabilir miyim?

Evet. Her AI Agents dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. Claude Vision ve GPT-4V ile Görüntü + Metin Aracıları
  2. Ses + Metin Aracı İş Akışları
  3. Aracılarda Video Anlama
  4. Çapraz Modlu Akıl Yürütme Örüntüleri
← AI Agents Sayfasına Dön