iqbaljputra/qianfan-vl-3b-blindspots-final

Qianfan-VL-3B Blind Spots

Model tested

I tested baidu/Qianfan-VL-3B, an open 3B-parameter vision-language model.

Why I chose this model

I chose this model because it is a recent open multimodal model in the requested size range and appears to be a general-purpose VLM rather than a checkpoint fine-tuned for one very narrow downstream task. Its model card highlights OCR, document understanding, chart understanding, and table parsing, which makes it a good candidate for blind-spot analysis on visually grounded question answering.

How I loaded the model

Below is the loading code used in Colab. In my environment, I used low_cpu_mem_usage=False because the default lazy/meta loading path caused compatibility issues for this model family.

import torch
from transformers import AutoModel, AutoTokenizer

MODEL_ID = "baidu/Qianfan-VL-3B"
dtype = torch.bfloat16 if torch.cuda.is_available() and torch.cuda.is_bf16_supported() else torch.float16
device = "cuda" if torch.cuda.is_available() else "cpu"

model = AutoModel.from_pretrained(
    MODEL_ID,
    torch_dtype=dtype,
    trust_remote_code=True,
    low_cpu_mem_usage=False
).eval().to(device)

tokenizer = AutoTokenizer.from_pretrained(
    MODEL_ID,
    trust_remote_code=True,
    use_fast=False
)


## What this dataset contains

This dataset contains failure cases collected while testing Qianfan-VL-3B on image-based question answering tasks. Each row includes:

- `image`
- `dataset`
- `task_type`
- `error_type`
- `source_split`
- `source_id`
- `question_text`
- `prompt`
- `expected_output`
- `model_output`
- `why_wrong`

The goal is not to measure overall performance, but to document **blind spots**: cases where the model’s output was clearly incorrect, incomplete, or overly brittle.

## What kind of dataset would likely help fix these errors?

Based on the failures in this dataset, I think the model should be fine-tuned on a **targeted multimodal correction dataset** emphasizing:

### 1. Small-text and ambiguous OCR VQA

- low-resolution scene text
- partially occluded text
- visually similar characters
- short exact-answer supervision

### 2. Chart and table QA with strict answer matching

- exact values instead of approximate summaries
- smallest/largest comparisons
- legend and axis interpretation
- multi-step retrieval from charts and tables

### 3. Diagram reasoning

- labeled arrows
- process flow
- part-whole relationships
- multi-choice diagram QA with hard distractors

### 4. Constrained-answer supervision

- prompts like “answer with one word only,” “answer with one number only,” or “answer with True/False only”
- examples where verbose but technically related answers are still marked wrong

### 5. Hard negative visual distinctions

- near-duplicate answer choices
- visually similar categories
- small differences in color, count, or spatial arrangement

## How would I assemble or find such a dataset?

I would use a mixed strategy:

### 1. Combine existing public datasets

I would start from public datasets for:

- OCR VQA
- chart QA
- table QA
- diagram reasoning
- image-based multiple-choice QA

These datasets already provide diverse images and verified labels, which makes them a good base for fine-tuning.

### 2. Mine failure cases from model evaluations

I would run the model on held-out examples and collect:

- exact-answer mismatches
- formatting-sensitive failures
- visually grounded mistakes
- cases where the answer is plausible-sounding but wrong

These mined failures would become high-value training examples because they directly reflect the model’s current blind spots.

### 3. Create synthetic hard negatives

For tasks like counting, short-answer precision, and diagram QA, I would generate synthetic examples with:

- small visual changes
- distractor answer choices
- stricter answer constraints
- controlled perturbations in text, numbers, and layout

### 4. Add a manually reviewed high-precision subset

I would include a smaller manually checked subset to ensure label quality, especially for:

- ambiguous OCR
- chart reading
- diagram interpretation
- exact-answer evaluation

## How big of a dataset would be needed?

My estimate is:

- **2k–5k examples** for a narrow proof-of-concept improvement on one failure type
- **10k–30k examples** for meaningful improvement across one or two families of errors
- **50k+ examples** for broader robustness across OCR, charts, diagrams, constrained answers, and visual hard negatives

A small targeted dataset could already improve brittle short-answer behavior, but broader robustness would likely require a substantially larger mixture of task types and visual conditions.

## Limitations

This is a small failure-analysis dataset, not a comprehensive benchmark of overall model quality. The examples are intentionally selected for error analysis, so they should not be interpreted as a representative sample of all model behavior.


---
dataset_info:
  features:
  - name: image
    dtype: image
  - name: dataset
    dtype: string
  - name: task_type
    dtype: string
  - name: error_type
    dtype: string
  - name: source_split
    dtype: string
  - name: source_id
    dtype: string
  - name: question_text
    dtype: string
  - name: prompt
    dtype: string
  - name: expected_output
    dtype: string
  - name: model_output
    dtype: string
  - name: why_wrong
    dtype: string
  splits:
  - name: train
    num_bytes: 8115788.0
    num_examples: 34
  download_size: 7681535
  dataset_size: 8115788.0
configs:
- config_name: default
  data_files:
  - split: train
    path: data/train-*
---