Vorbereitung auf Multimodale ML-Interviews

Multimodale Machine Learning Engineer Interviewfragen

15 ausgewählte Interviewfragen zu multimodalen Machine Learning, gruppiert nach Senioritätslevel. Verwenden Sie diese, um Grundlagen, praktische Kompromisse und das Argumentationsvermögen auf Senior-Level im Hinblick auf die Produktion zu überprüfen.

Multimodales ML KI-Interview startenKeine Kreditkarte erforderlich. 1 kostenlose Sitzung verfügbar.
Technisches Interview-Training auf EnglischEin Modus, in dem Nicht-Muttersprachler technische Interviews üben können.

Junior-Fragen

1Wie richtet kontrastives Lernen Bild- und Textrepräsentationen aufeinander aus, und was bringt ein gemeinsamer Einbettungsraum?

Ein Bildencoder und ein Textencoder erzeugen Vektoren in einem gemeinsamen Raum. Beim Training soll die Ähnlichkeit eines zusammengehörigen Bild-Text-Paars höher sein als die der Vergleichspaare. Ein Trainingsbatch kann dazu andere Texte und Bilder als negative Beispiele verwenden, obwohl auch mehrere Beschreibungen zum selben Motiv passen können. Im gemeinsamen Raum lässt sich zu einem Text nach passenden Bildern suchen und umgekehrt. Für Klassifikation ohne zusätzliches Training kann das Modell das Bild mit Textbeschreibungen vorgegebener Klassen vergleichen. Hohe Ähnlichkeit liefert ein Rangsignal, aber keine Garantie, dass jede Einzelheit der Beschreibung zutrifft.

import torch
import torch.nn.functional as F

# image_features: [B, D], text_features: [B, D]
image_norm = F.normalize(image_features, dim=-1)
text_norm = F.normalize(text_features, dim=-1)

# Pairwise cosine similarity matrix: [B, B]
sim_matrix = image_norm @ text_norm.T
# Positive pairs lie on the diagonal; off-diagonals are negatives
Diese Frage mit einem KI-Coach beantworten

2Wie funktioniert eine Architektur mit zwei Encodern nach dem Vorbild von CLIP, und welche Annahme trifft sie über die Wechselwirkung von Bild und Text?

Ein Encoder berechnet unabhängig einen Bildvektor, der andere einen Textvektor. Beide werden in denselben Einbettungsraum projiziert. Ein Skalarprodukt normalisierter Vektoren liefert ihre Ähnlichkeit. Die Wechselwirkung findet erst beim Vergleich statt; Bildregionen und Texttokens beeinflussen sich in den Encodern nicht direkt. Die Architektur setzt darauf, dass getrennte Vektoren genügend Information für die gewünschte Zuordnung tragen. Bildvektoren können dadurch vorab berechnet und effizient durchsucht werden. Eine gemeinsame Verarbeitung kann bei feinen räumlichen Beziehungen oder der Zuordnung einzelner Wörter zu Bildregionen Vorteile haben.

import torch
import torch.nn as nn
import torch.nn.functional as F

class CLIPDualEncoder(nn.Module):
    def __init__(self, visual_encoder, text_encoder, img_dim, txt_dim, embed_dim):
        super().__init__()
        self.visual_encoder = visual_encoder
        self.text_encoder = text_encoder
        self.img_proj = nn.Linear(img_dim, embed_dim, bias=False)
        self.txt_proj = nn.Linear(txt_dim, embed_dim, bias=False)
        self.logit_scale = nn.Parameter(torch.ones([]) * 2.659)

    def forward(self, images, text_tokens):
        # Independent uncoupled encoding
        v_feat = self.img_proj(self.visual_encoder(images))
        t_feat = self.txt_proj(self.text_encoder(text_tokens))
        # L2 normalize
        v_norm = F.normalize(v_feat, p=2, dim=-1)
        t_norm = F.normalize(t_feat, p=2, dim=-1)
        # Late interaction via dot product
        return torch.matmul(v_norm, t_norm.T) * self.logit_scale.exp()
Diese Frage mit einem KI-Coach beantworten

3Beschreiben Sie die Intuition hinter der Projektion von Bild- und Text-Features in einen gemeinsamen normalisierten Raum und der Optimierung der Kosinus-Ähnlichkeit.

Die Projektion von Bild- und Text-Features in einen gemeinsamen normalisierten Raum (typischerweise auf einer Einheitshypersphäre mittels L2-Normalisierung) und die Optimierung der Kosinus-Ähnlichkeit entkoppelt die semantische Richtung einer Einbettung von ihrer Vektorlänge. Ohne Normalisierung ermöglicht ein uneingeschränktes Skalarprodukt dem Modell, den Trainingsverlust zu minimieren, indem es einfach die Merkmalsnormen für einfache oder häufige Beispiele vergrößert, anstatt ihre semantischen Richtungen auszurichten. Die Normalisierung von Vektoren auf die Einheitshypersphäre begrenzt Ähnlichkeitswerte streng auf [-1, 1] und stellt sicher, dass die Distanz rein der Winkelseparation entspricht. Dadurch entfällt der Einfluss der Merkmalsnorm auf die Ähnlichkeitsbewertung, und die Ähnlichkeitswerte werden begrenzt. Dies allein verhindert jedoch weder einen Kollaps der Repräsentationen noch gleicht es die Gradientenbeiträge einzelner Beispiele an. Negative Paare und die Lernzielfunktion wirken einem Kollaps zusätzlich entgegen. In Verbindung mit einem lernbaren Temperaturparameter steuert dies die Schärfe der Wahrscheinlichkeitsverteilung über die Hypersphäre, um die Ausrichtung echter Paare mit der gleichmäßigen Dispersion negativer Paare auszugleichen.

import torch
import torch.nn.functional as F

# Unnormalized embeddings with extreme norm differences
v = torch.tensor([[10.0, 0.0], [0.1, 0.0]])
t = torch.tensor([[5.0, 0.0], [0.1, 0.0]])

# Raw dot products: heavily distorted by magnitude (50.0 vs 0.01)
raw_dot = v @ t.T

# L2 Normalized:
v_norm = F.normalize(v, p=2, dim=-1)
t_norm = F.normalize(t, p=2, dim=-1)
cosine_sim = v_norm @ t_norm.T
print('Cosine similarity matrix:\n', cosine_sim)
Diese Frage mit einem KI-Coach beantworten

4Was bedeuten Visual Grounding und das Auflösen visueller Referenzausdrücke, und wie unterscheiden sie sich von einem Ähnlichkeitswert für das gesamte Bild?

Beim Visual Grounding verknüpft ein Modell Sprache mit konkreten Bildregionen. Eine typische Aufgabe ist, die durch einen Ausdruck gemeinte Stelle zu finden, etwa „die Person mit der blauen Jacke neben der Lampe“. Die Ausgabe kann ein Rechteck oder eine Segmentierungsmaske sein. Dazu muss das Modell Merkmale, räumliche Beziehungen und ähnliche Objekte im selben Bild unterscheiden. Ein globaler Ähnlichkeitswert sagt nur, wie gut Bild und Text insgesamt zusammenpassen. Er kann beim Abruf helfen, gibt aber nicht an, welche Person oder welche Pixel gemeint sind.

# Image-level similarity:
# Input: Image I, Text T ("black dog sitting on the left")
# Output: scalar score s in [0, 1] or dot product
similarity_score = image_text_model(image, text)

# Referring Expression Comprehension (Visual Grounding):
# Input: Image I, Text T ("black dog sitting on the left")
# Output: Bounding box coordinates [x_min, y_min, x_max, y_max]
bbox = grounding_model.predict_box(image, text)
Diese Frage mit einem KI-Coach beantworten

5Wie verbindet Cross-Attention Bild- und Texttokens in einem multimodalen Transformer?

Eine Modalität liefert Abfragevektoren Q, die andere Schlüssel K und Werte V. Wenn Bildtokens die Abfragen liefern, gewichtet jedes Bildtoken Textwerte anhand seiner Ähnlichkeit zu den Textschlüsseln. Bei skaliertem Skalarprodukt lautet die Berechnung `softmax(Q Kᵀ / √d_k) V`, wobei `d_k` die Dimension der Schlüssel und Abfragen ist. Das Ergebnis hat eine Position pro Abfrage; die Sequenzen dürfen unterschiedlich lang sein. In der anderen Richtung kann Text gezielt Bildinformationen abrufen. Für beidseitigen Austausch braucht man beide Richtungen oder aufeinanderfolgende entsprechende Blöcke. Aufmerksamkeitsgewichte belegen für sich keine korrekte Zuordnung.

import torch
import torch.nn as nn

class MultimodalCrossAttention(nn.Module):
    def __init__(self, d_model, n_heads):
        super().__init__()
        self.mha = nn.MultiheadAttention(embed_dim=d_model, num_heads=n_heads, batch_first=True)
        self.norm = nn.LayerNorm(d_model)

    def forward(self, visual_query_tokens, text_kv_tokens):
        # visual_query_tokens: [B, N_v, D], text_kv_tokens: [B, N_t, D]
        attn_out, _ = self.mha(
            query=visual_query_tokens, 
            key=text_kv_tokens, 
            value=text_kv_tokens
        )
        # Residual connection and normalization
        output = self.norm(visual_query_tokens + attn_out)
        return output
Diese Frage mit einem KI-Coach beantworten

6Wann helfen Zuschnitt, Farbänderungen und Kompression beim kontrastiven Training mit Bild-Text-Paaren, und wann schaden sie?

Sinnvolle Bildvarianten können die Abhängigkeit von unwichtigen Merkmalen wie Hintergrund oder Position verringern. Die Beschreibung muss aber auch nach der Veränderung noch passen. Schneidet ein Ausschnitt den beschriebenen Vogel weg oder verfärbt eine Bearbeitung das gelbe Taxi, ist das Paar kein verlässliches positives Beispiel mehr. Starke Kompression kann Schrift oder kleine Details unlesbar machen. Wähle Veränderungen nach Art der Beschreibungen und Zielaufgabe. Prüfe mit gezielten Fällen zu Farbe, Schrift, räumlichen Beziehungen und kleinen Objekten, ob sie helfen. Es gibt keinen allgemein richtigen Ausschnittbereich.

from torchvision import transforms

# Multimodal contrastive transform: conservative to preserve caption semantics
clip_transforms = transforms.Compose([
    transforms.RandomResizedCrop(224, scale=(0.5, 1.0)),  # Conservative crop avoids dropping described entities
    transforms.RandomHorizontalFlip(p=0.5),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.481, 0.457, 0.408], std=[0.268, 0.261, 0.275])
])

# Unimodal self-supervised transform: aggressive, risks breaking image-text alignment
simclr_heavy_transforms = transforms.Compose([
    transforms.RandomResizedCrop(224, scale=(0.08, 1.0)), # Extreme crop can remove captioned subjects
    transforms.RandomApply([transforms.ColorJitter(0.8, 0.8, 0.8, 0.2)], p=0.8), # Alters color adjectives
    transforms.RandomGrayscale(p=0.2),
    transforms.GaussianBlur(kernel_size=23, sigma=(0.1, 2.0)), # Destroys fine OCR/textures
    transforms.ToTensor()
])
Diese Frage mit einem KI-Coach beantworten

7Was ist Bild-Text-Suche, und wie unterscheidet sich der Abgleich in einer festen Kandidatenmenge von der Suche in einem großen offenen Bestand?

Eine Anfrage in einer Modalität soll passende Einträge in der anderen finden, etwa Bilder zu einer Beschreibung. In einem festen Testbestand sind Kandidaten und Referenzzuordnungen vorgegeben. Bei überschaubarer Größe lassen sich alle Kandidaten vergleichen, wobei auch dort passende, nicht annotierte Treffer möglich sind. Ein großer, veränderlicher Bestand enthält viele ähnliche und irrelevante Einträge und oft keine vollständigen Relevanzlabels. Vorberechnete Vektoren und ein Index für näherungsweise Nachbarsuche können die Suche beschleunigen. Bei Bedarf bewertet ein genaueres Modell eine kurze Trefferliste erneut. Miss Suchqualität, Latenz und Indexaktualität getrennt.

import torch
import torch.nn.functional as F

# Closed-set matching: full pairwise similarity matrix over fixed evaluation set
image_embeds = F.normalize(torch.randn(1000, 512), dim=-1)
text_embeds = F.normalize(torch.randn(1000, 512), dim=-1)
sim_matrix = torch.matmul(text_embeds, image_embeds.T)  # (1000, 1000)

# Open-world retrieval: query vector queried against an indexed corpus using ANN
# index = faiss.IndexHNSWFlat(512, 32)
# distances, indices = index.search(query_embed, k=10)
Diese Frage mit einem KI-Coach beantworten

Middle-Fragen

8Vergleichen Sie InfoNCE-artige Softmax-Kontrastivverluste mit paarweisen Sigmoid-Verlusten für das Lernen von Bild-Text-Embeddings.

InfoNCE-artige Kontrastivverluste (wie z.B. bei CLIP) behandeln die Ausrichtung als kategoriales Mehrklassen-Klassifikationsproblem. Für jedes Sample berechnen sie eine Softmax-Verteilung über das positive Paar und die möglichen negativen Paare im Batch, wobei die Ähnlichkeiten über den gesamten Batch-Pool normalisiert werden. Im Gegensatz dazu behandeln paarweise Sigmoid-Kontrastivverluste (wie z.B. bei SigLIP) jeden Eintrag in der Bild-Text-Ähnlichkeitsmatrix als eine unabhängige binäre Klassifikationsaufgabe, indem sie eine Sigmoid-Funktion und eine binäre Kreuzentropie-Verlustfunktion pro Paar anwenden (bei binärer Kreuzentropie sind die Zielwerte 1 für positive und 0 für negative Paare; äquivalent können in einer logistischen Verlustformulierung vorzeichenbehaftete Labels +1/-1 verwendet werden). Die Hauptunterschiede sind: 1. Kopplung vs. Entkopplung: InfoNCE koppelt alle Negativbeispiele über den globalen Softmax-Partitionsnenner, was zu einem Wettbewerb führt, bei dem die härtesten Negativbeispiele die Gradienten dominieren. SigLIP entkoppelt alle Paare und bewertet jedes unabhängig. 2. Verteilte Skalierbarkeit und Effizienz: Verteiltes CLIP sammelt üblicherweise Embeddings, um negative Beispiele anderer Geräte einzubeziehen; anschließend koppelt die Softmax-Normalisierung die Kandidatenwerte. SigLIP vermeidet diese globale Softmax-Normalisierung und unterstützt die blockweise Berechnung von Paaren. Geräteübergreifende Paare erfordern aber weiterhin einen Austausch von Embeddings. Effizienz und Qualität hängen von der Zusammenstellung der Batches und dem Trainingsaufbau ab.

import torch
import torch.nn.functional as F

def siglip_loss(sim_matrix, temperature, bias):
    # sim_matrix: [B, B] dot product of normalized embeddings
    # targets: 1 on diagonal (positive), -1 on off-diagonals (negative)
    B = sim_matrix.size(0)
    targets = 2 * torch.eye(B, device=sim_matrix.device) - 1.0
    logits = sim_matrix * temperature + bias
    # Pairwise binary cross entropy with log-sigmoid
    return -torch.mean(F.logsigmoid(targets * logits))
Diese Frage mit einem KI-Coach beantworten

9Wie wirken sich schwierige und fälschlich als negativ markierte Bild-Text-Paare beim kontrastiven Lernen aus?

Ein schwieriges negatives Paar passt nicht zusammen, ähnelt aber einem passenden Paar. Ein falsches Farbadjektiv kann zum Beispiel ein brauchbares negatives Beispiel sein, wenn die Farbe erkennbar und für die Aufgabe relevant ist. Solche Beispiele helfen dem Modell, feine Unterschiede zu lernen. Ein falsch negatives Paar passt tatsächlich zusammen, wird im Training aber auseinandergezogen. Das passiert etwa, wenn mehrere Bilder zu derselben Beschreibung passen. Prüfe daher die Qualität automatisch ausgewählter negativer Paare. Entferne Duplikate, erlaube mehrere passende Paare oder verwende weiche Gewichtung, wenn die Zuordnung unsicher ist. Zu viele scheinbar schwierige, aber falsch markierte Fälle können die Repräsentation verschlechtern.

import torch
import torch.nn.functional as F

# Image 0 and Image 1 both depict 'a red sports car'
# Text 0: 'a red sports car', Text 1: 'a fast red car'
# In standard InfoNCE, Text 1 is treated as a negative for Image 0.
sim = torch.tensor([[0.95, 0.90],   # Image 0 similarities
                    [0.88, 0.94]])  # Image 1 similarities

loss_img0 = -F.log_softmax(sim / 0.07, dim=-1)[0, 0]
print(f'InfoNCE loss for Image 0: {loss_img0.item():.4f}')
# High similarity to false negative Text 1 (0.90) heavily penalizes the model
Diese Frage mit einem KI-Coach beantworten

10Worin unterscheiden sich globale Bild-Text-Ausrichtung und Lernziele, die Wörter oder Tokens einzelnen Bildregionen zuordnen?

Bei globaler Ausrichtung vergleicht das Modell Repräsentationen des gesamten Bildes und des gesamten Textes. Ein kompakter Vektor pro Eintrag lässt sich vorab berechnen und gut für die Suche indexieren. Er kann aber Informationen zu kleinen Objekten, Attributen und räumlichen Beziehungen verlieren. Feingranulare Lernziele vergleichen Bildregionen oder Patches mit Wörtern oder Texttokens. Das kann Aufgaben wie visuelle Lokalisierung und Attributzuordnung unterstützen. Dafür müssen mehr Repräsentationen verglichen oder verlässliche lokale Zuordnungen gelernt werden. Ein Tokenvergleich ist noch kein Nachweis korrekter Lokalisierung; prüfe gezielt, ob das Modell die richtige Region findet.

import torch
import torch.nn.functional as F

# visual_tokens: [B, N_v, D], text_tokens: [B, N_t, D]
def token_level_maxsim_similarity(visual_tokens, text_tokens):
    v_norm = F.normalize(visual_tokens, dim=-1)
    t_norm = F.normalize(text_tokens, dim=-1)
    # Compute similarity matrix between all visual and text tokens: [B, N_t, N_v]
    sim_matrix = torch.bmm(t_norm, v_norm.transpose(1, 2))
    # Text-to-image: For each word token, find maximum visual token similarity and average
    t2i_sim = sim_matrix.max(dim=-1).values.mean(dim=-1) # [B]
    return t2i_sim
Diese Frage mit einem KI-Coach beantworten

11Wie unterscheiden sich frühe, späte und mittlere Fusion, Cross-Attention, gelernte Gewichtung und Konkatenation in multimodalen Modellen?

Früh, mittel und spät bezeichnen den Zeitpunkt der Verknüpfung. Frühe Fusion kombiniert Eingaben oder erste Merkmale und erlaubt Wechselwirkungen über viele Schichten. Mittlere Fusion verarbeitet Modalitäten zunächst getrennt und tauscht später Zwischenmerkmale aus. Späte Fusion kombiniert erst fertige Vektoren oder Vorhersagen; getrennte Vektoren können leicht indexiert werden. Cross-Attention lässt Abfragen einer Modalität Werte der anderen gewichten. Ein gelerntes Gate steuert Beiträge anhand des Kontexts, garantiert aber keine zuverlässige Einschätzung der Eingabe. Konkatenation hängt Merkmale oder Tokenfolgen aneinander und kann auf verschiedenen Ebenen eingesetzt werden. Lange gemeinsame Folgen können die Kosten vollständiger Self-Attention stark erhöhen.

import torch
import torch.nn as nn
import torch.nn.functional as F

# 1. Concatenation along feature dimension
z_concat = torch.cat([img_feat, txt_feat], dim=-1) # [B, D_img + D_txt]

# 2. Gated Fusion
gate = torch.sigmoid(gate_layer(z_concat)) # [B, D]
z_gated = gate * img_proj + (1 - gate) * txt_proj

# 3. Late Fusion (Score level)
similarity = torch.sum(F.normalize(img_feat, dim=-1) * F.normalize(txt_feat, dim=-1), dim=-1)
Diese Frage mit einem KI-Coach beantworten

12Wie unterscheiden sich Dual-Encoder und Cross-Encoder beim Bild-Text-Abgleich hinsichtlich Wechselwirkung, Qualität und Latenz?

Ein Dual-Encoder erzeugt unabhängig Vektoren für Bild und Text. Bildvektoren lassen sich vorab indexieren; zur Anfragezeit genügt die Textkodierung und eine Ähnlichkeitssuche. Ein Cross-Encoder bewertet jedes Bild-Text-Paar gemeinsam, sodass Wörter mit einzelnen Regionen wechselwirken können. Das kann bei Attributen und räumlichen Beziehungen helfen, muss aber auf den Zielanfragen gemessen werden. Weil jede Paarbewertung Rechenzeit kostet, verwendet eine verbreitete Architektur zuerst einen Dual-Encoder und sortiert anschließend eine kurze Kandidatenliste mit dem Cross-Encoder neu. Ein Reranker kann keinen relevanten Treffer zurückholen, der in der ersten Stufe fehlt. Miss deshalb Kandidatenabdeckung, Rangqualität und Gesamtlatenz.

# Stage 1: Dual-Encoder First-Stage Retrieval (Fast, Vector Index)
query_emb = text_encoder(query_text) # [1, D]
# Cosine similarity over pre-indexed image embeddings [N, D]
scores = query_emb @ precomputed_image_embeddings.T # [1, N]
top_k_indices = torch.topk(scores, k=100).indices[0]

# Stage 2: Cross-Encoder Reranker (Accurate, Token Interaction)
candidate_images = [load_image(idx) for idx in top_k_indices]
rerank_scores = cross_encoder(candidate_images, [query_text] * 100) # Full cross-attention
final_ranking = top_k_indices[torch.argsort(rerank_scores, descending=True)]
Diese Frage mit einem KI-Coach beantworten

Senior-Fragen

13Entwerfen Sie ein multimodales System zur suchgestützten Antwortgenerierung (RAG) für PDFs oder Handbücher mit Text, Tabellen, Diagrammen, Screenshots, Schaubildern und eingebetteten Bildern.

Ein durchgängiges multimodales System zur suchgestützten Antwortgenerierung (RAG) für komplexe visuelle Dokumente (PDFs, Handbücher, Berichte) umfasst vier zentrale architektonische Phasen: 1. Aufnahme & Layout-sensitives Parsing: PDF-Seiten werden über layout-sensitive Dokumentmodelle (z.B. LayoutLM, DocTR) oder Vision-Parsing-Pipelines verarbeitet, um Inhalte in strukturierte Blöcke zu segmentieren: Textpassagen, strukturierte Tabellen (konvertiert in HTML oder ein anderes Format, das über mehrere Zeilen oder Spalten verbundene Zellen erhält; einfache Markdown-Tabellen können solche Zellverbindungen nicht darstellen), gerenderte Diagrammbilder mit Datenreihen und eigenständige Schaubilder oder Screenshots mit räumlichen Begrenzungsrahmen. 2. Multimodale Indizierung & Duale Repräsentation: - Visuelle Assets (Diagramme, Screenshots, Schaubilder): Gespeichert als Bildausschnitte mit dichten multimodalen Embeddings (z.B. SigLIP, CLIP oder ColPali visual patch tokens) zusammen mit synthetischen Textzusammenfassungen und Text aus optischer Zeichenerkennung (OCR), generiert von einem Bild-Sprach-Modell (VLM), gespeichert in einem dichten Textindex. - Tabellen: Gespeichert als strukturiertes Markdown/HTML in Textvektor- und BM25-Indizes. - Text: Semantisch segmentiert und über dichte Embeddings und Schlüsselwörter in einer dünnbesetzten Darstellung indiziert. 3. Hybrides Retrieval & Multimodales Reranking: - Retrieval der ersten Stufe: Führt paralleles Retrieval über dünnbesetzte BM25-Suche (Schlüsselwörter, OCR-Text, Tabellen-Markup), dichte Textvektoren und visuelle Embedding-Indizes (annähernde Suche nach nächsten Nachbarn (ANN)) durch. - Fusion & Reranking: Führt Kandidaten zusammen (z.B. über Reciprocal Rank Fusion) und bewertet Top-Items unter Verwendung eines multimodalen Cross-Encoders oder visuellen Late-Interaction-Modells (Bewertung von Abfragetext anhand hochauflösender Bildausschnitte und geparstem Text). 4. Multimodale Kontexterstellung & Grounded Generation: Der Top-$k$ multimodale Kontext – gerenderte Bild-Patches, Tabellenschemata und Textpassagen mit Dokument-/Seitenmetadaten – wird an ein Instruktions-optimiertes VLM (z.B. GPT-4o, Claude 3.5 Sonnet oder Open-Source Qwen2-VL) übergeben. Der Prompt fordert Quellenangaben an. Der Anwendungscode prüft, ob die zitierten Dokument-, Seiten- und Regionskennungen existieren, für den Benutzer zugänglich sind und die Aussagen stützen. Die Herkunftsinformationen müssen beim Parsen und Indizieren erhalten bleiben; Zugriffskontrollen sind vor der Zusammenstellung des Kontexts durchzusetzen. Anweisungen in abgerufenen Inhalten sind als nicht vertrauenswürdige Daten zu behandeln.

from dataclasses import dataclass
from typing import Optional, List

@dataclass
class MultimodalChunk:
    chunk_id: str
    document_id: str
    page_number: int
    modality_type: str  # 'text', 'table', 'chart', 'diagram'
    text_payload: str   # Raw text or structured Markdown/HTML
    vlm_caption: Optional[str] = None  # Synthetic summary of visual content
    bbox: Optional[List[float]] = None  # [x0, y0, x1, y1]
    image_crop_path: Optional[str] = None
    dense_embedding: Optional[List[float]] = None

# Indexing strategy: Text search covers text_payload + vlm_caption;
# Multimodal search matches dense_embedding or visual tokens.
Diese Frage mit einem KI-Coach beantworten

14Wie bewertest du bei multimodaler Generierung mit Suchkontext (RAG) getrennt die Suche, Nutzung von Belegen, Quellenangaben und Treue der Antwort?

Prüfe zuerst, ob notwendige Textstellen, Tabellen oder Abbildungen in den Suchergebnissen vorkommen. Unterscheide Dokumenttreffer von einem Ausschnitt, der den Beleg tatsächlich enthält. Teste die Nutzung durch kontrolliertes Entfernen oder Austauschen von Belegen; beachte, dass andere Quellen dieselbe Information liefern können. Bewerte, ob Quellenangaben das richtige Dokument, die Seite und gegebenenfalls die Region nennen. Prüfe Aussagen der Antwort einzeln gegen ihre Belege und zusätzlich gegen die fachliche Referenz. Eine Antwort kann einem fehlerhaften Dokument treu folgen und trotzdem falsch sein. Teste, ob das System fehlende oder widersprüchliche Belege kenntlich macht. Setze automatische Bewertung mit überprüften Stichproben ein.

# Evaluation record schema for a single Multimodal RAG query:
eval_record = {
    'retrieval_quality': {
        'hit_at_k': True,          # Top-3 chunks contain target diagram
        'visual_bbox_iou': 0.85    # Retrieved crop overlap with true figure region
    },
    'evidence_utilization': {
        'necessity_ablation_passed': True  # Removing chart causes answer to fail
    },
    'provenance': {
        'page_match': True,        # Cited Page 12 (Ground Truth Page 12)
        'figure_id_match': True    # Cited 'Figure 4'
    },
    'faithfulness': {
        'claim_entailment_score': 1.0,  # All claims entailed by context
        'hallucination_detected': False
    }
}
all_passed = all(all(metrics.values()) for metrics in eval_record.values())
print(f'System passes all decoupled checks: {all_passed}')
Diese Frage mit einem KI-Coach beantworten

15Wie aktualisierst du ein produktives multimodales Suchmodell, wenn Einbettungen und Index eines großen Bestands neu erstellt werden müssen?

Behandle Encoder und Index als kompatibles Paar. Einbettungen verschiedener Versionen sind auch bei gleicher Dimension nicht automatisch vergleichbar. Erzeuge mit der neuen Version einen getrennten Index aus einem bekannten Datenstand. Hole danach neue, geänderte und gelöschte Einträge anhand eines Änderungsprotokolls nach. Prüfe Vollständigkeit, Qualität und Latenz mit geeigneten Abfragen. Schalte Encoder und Index gemeinsam für eine begrenzte Gruppe um und halte die alte Kombination für eine Rückkehr aktuell, solange sie benötigt wird. Ein ausdrücklich auf Kompatibilität trainierter Encoder kann eine Ausnahme ermöglichen; prüfe sie anhand derselben Qualitätsziele.

class MultimodalRetrievalRouter:
    def __init__(self, v1_service, v2_service, dual_write=True):
        self.v1 = v1_service  # Model v1 + Index v1
        self.v2 = v2_service  # Model v2 + Index v2
        self.active_version = "v1"
        self.dual_write = dual_write

    def search(self, query_multimodal):
        # Route query strictly to the encoder matching the active index
        if self.active_version == "v1":
            return self.v1.search(query_multimodal)
        return self.v2.search(query_multimodal)

    def ingest_new_item(self, item):
        # Dual-write during migration window so the new index is up-to-date at cutover
        self.v1.index_item(item)
        if self.dual_write and self.v2.is_ready_for_ingest:
            self.v2.index_item(item)
Diese Frage mit einem KI-Coach beantworten

Übe Interviews auf deinem Smartphone: Multimodal ML

Antworte laut und erhalte KI-Feedback in der Android-App.

EngineerSpeak bei Google Play herunterladen
Zum Download scannen