Dataset Viewer
Auto-converted to Parquet Duplicate
id
int64
1
13
category
stringlengths
15
21
input
stringlengths
25
130
expected_output
stringlengths
2
133
model_output
stringlengths
3
102
failure_type
stringlengths
34
80
1
arithmetic_completion
Q: A bat and ball cost $1.10. The bat costs $1 more than the ball. How much does the ball cost? A:
$0.05 (5 cents)
Starts correct algebra (2x + 1 = 1.10) but truncates before reaching answer
Truncation / arithmetic completion
2
self_contradiction
Q: If all Bloops are Razzles, and all Razzles are Lazzles, are all Bloops definitely Lazzles? A:
Yes
Outputs Yes first, then reasons itself into 'D: It depends'
Self-contradiction via over-generation
3
commonsense_trap
Q: You're running a race and pass the person in 2nd place. What place are you now in? A:
2nd place
1st
Commonsense trap β€” confidently wrong
4
arithmetic_completion
Q: What is 15% of 340? A:
51
Truncates mid-calculation, never outputs final answer
Truncation / arithmetic completion
5
physics_confusion
Q: Which is heavier, a kilogram of feathers or a kilogram of iron? A:
They weigh the same β€” both are 1 kilogram
Same weight but different mass β€” contradicts itself (a kilogram IS a unit of mass)
Physics conceptual error (mass vs. weight confusion)
6
cognitive_reflection
Q: A doctor gives you 3 pills and says take one every half hour. How many minutes will the pills last? A:
60 minutes (take at 0 min, 30 min, 60 min)
30 minutes
CRT failure β€” off-by-one interval counting
7
logical_planning
Q: You have a 3-gallon jug and a 5-gallon jug. How do you measure exactly 4 gallons? A:
Fill 5-gal, pour into 3-gal, dump 3-gal, pour remaining 2 into 3-gal, refill 5-gal, pour 1 gal into 3-gal β†’ 4 gal remain in 5-gal jug
The answer is not possible (incorrect β€” also cites LCM reasoning which is wrong for this problem type)
Logical planning failure + incorrect mathematical justification
8
percentage_math
Q: If a store raises its price by 10% and then lowers it by 10%, is the final price higher, lower, or the same as the original? A:
Lower β€” original Γ— 1.1 Γ— 0.9 = 0.99 Γ— original
Same as the original
Percentage math β€” symmetric fallacy
9
spatial_reasoning
Q: If you have a rectangular piece of paper and fold it in half twice, how many layers thick is it? A:
4 layers
Initially outputs 2, then hedges through multiple-choice options
Spatial reasoning failure + self-inconsistency
10
lateral_thinking
Q: I have two coins that add up to 30 cents. One is not a nickel. What are the two coins? A:
A quarter and a nickel (the quarter is the one that's not a nickel)
Spirals through wrong guesses (quarter+penny=26Β’, dime+nickel=15Β’) and never arrives at answer
Lateral thinking β€” fails to parse the linguistic trick
11
nominal_fallacy
Q: How long did the Hundred Years War last? A:
116 years (1337–1453)
100 years (then immediately self-corrects to 116 but original answer was wrong)
Nominal fallacy β€” takes name literally before self-correcting
12
factual_cultural
Q: In which sport do you play on a 'diamond'? A:
Baseball
Cricket
Factual/cultural error β€” confidently wrong
13
lateral_thinking
Q: A woman shoots her husband, then goes to dinner. Five years later they go on vacation together. How? A:
She is a photographer β€” she shot him with a camera
Incoherent loop: 'She is a woman so she is a woman...' β€” never resolves the riddle
Lateral/creative reasoning β€” complete failure to find alternative interpretation

YAML Metadata Warning:empty or missing yaml metadata in repo card

Check out the documentation for more information.

Qwen3-1.7B Blind Spots: A Diagnostic Dataset of Base Model Failures

Overview

This dataset documents systematic failure modes of Qwen/Qwen3-1.7B, a 1.7-billion-parameter base language model (no instruction tuning, no RLHF) released by Alibaba in April 2025. The dataset contains 13 curated examples where the model produces incorrect or incoherent outputs, spanning seven distinct failure categories. Each example includes the exact input prompt, the correct expected output, and the model's verbatim response.

The goal is not simply to collect errors, but to characterize the failure taxonomy of a base model β€” understanding why each failure occurs, and what kind of fine-tuning intervention would most effectively fix it.


Model Tested

Field Value
Model Qwen/Qwen3-1.7B
Model type Base LLM (causal language model, no instruction tuning)
Parameters 1.7 billion
Architecture Transformer decoder
Release date April 2025
License Apache 2.0
Modality Text

This is a base model, meaning it was trained purely on next-token prediction over a large text corpus. It has not been fine-tuned with human feedback (RLHF), instruction-following datasets, or any chat template. This distinction is critical: the failure modes observed here are characteristic of base models specifically, and differ substantially from what you would observe in an instruction-tuned variant.


How I Loaded the Model

The model was loaded on Google Colab (free tier, T4 GPU, 15 GB VRAM) using the Hugging Face transformers library.

# Environment: Google Colab (T4 GPU, 15GB VRAM)
# Python 3.10, transformers 4.51, torch 2.5

!pip install -q transformers accelerate

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

MODEL_ID = "Qwen/Qwen3-1.7B"

tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    torch_dtype=torch.float16,   # half-precision to fit on T4 GPU
    device_map="auto"            # auto-allocates to GPU
)
model.eval()

def generate(prompt: str, max_new_tokens: int = 80) -> str:
    """Greedy decoding β€” deterministic and fully reproducible."""
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=max_new_tokens,
            do_sample=False,                        # greedy, no randomness
            temperature=1.0,
            pad_token_id=tokenizer.eos_token_id
        )
    new_tokens = outputs[0][inputs["input_ids"].shape[1]:]
    return tokenizer.decode(new_tokens, skip_special_tokens=True)

All prompts were formatted as Q: {question}\nA: β€” a simple completion-style format consistent with the base model's pretraining distribution. Greedy decoding was used throughout to ensure all outputs are deterministic and reproducible.


Dataset Schema

Column Type Description
id int Unique identifier (1–13)
category string Failure category (see taxonomy below)
input string The exact prompt sent to the model
expected_output string The correct answer
model_output string Verbatim model response (truncated for readability)
failure_type string Short label for the specific error mechanism

Failure Taxonomy

Seven distinct failure categories were identified across 13 examples. Each category has a different underlying cause and requires a different remediation strategy.

1. Arithmetic Completion Failure

Examples: Bat-and-ball problem, 15% of 340

The model begins the correct reasoning chain (e.g., sets up the algebra 2x + 1 = 1.10) but then truncates before reaching the final answer. This is not a mathematical knowledge failure β€” the model knows the method. It is a generation termination failure: the model does not learn from pretraining alone when to stop and consolidate a final answer. The max_new_tokens ceiling compounds this, but even with more tokens, base models frequently produce correct intermediate steps and then continue generating irrelevant text past the answer.

2. Self-Contradiction via Over-Generation

Examples: Bloops/Razzles/Lazzles syllogism

The model outputs the correct answer first ("Yes"), then continues generating and reasons itself into a wrong answer ("D: It depends"). This is the most distinctive pathology of base models without RLHF: there is no learned termination signal. In a conversation dataset or instruction-tuned model, the model would stop after the first correct token. In a base model, generation continues until max_new_tokens is reached, and longer continuations tend to become less accurate as the model explores alternative framings.

3. Commonsense Trap Failures (CRT-style)

Examples: Race riddle, doctor-and-pills, two-coins puzzle

These are Cognitive Reflection Test (CRT) style problems, where the intuitive/fast answer is wrong and the correct answer requires a deliberate second step. The race riddle ("pass the person in 2nd β†’ what place are you?") has an intuitive answer of 1st and a correct answer of 2nd. The model selects the intuitive answer confidently, with no hedging. The pills problem (3 pills every 30 mins = 60 mins, not 90) and the coins puzzle ("one is not a nickel" = the other one is) follow the same pattern. These failures are well-documented in cognitive science and are particularly prevalent in smaller models with less chain-of-thought training.

4. Mathematical Misconception

Examples: Percentage symmetry fallacy, water jug problem

The model makes confidently wrong mathematical claims. For the percentage problem (10% up then 10% down), it asserts the result is the same as the original β€” failing to recognize asymmetry (the correct result is 0.99x). For the water jug problem, it claims the solution is "not possible" and incorrectly invokes the LCM (Least Common Multiple) as justification β€” a fundamental misapplication of number theory. These are not computation errors but conceptual errors embedded during pretraining from noisy web text.

5. Spatial Reasoning Failure

Examples: Paper folding

When asked how many layers result from folding a paper in half twice, the model outputs "2" (correct answer: 4), then hedges by listing multiple-choice options including the correct answer. This reflects weak spatial and sequential reasoning, likely because visual-spatial problems are underrepresented in text pretraining corpora and because the model lacks the ability to simulate physical processes internally.

6. Physics Conceptual Error

Examples: Feathers vs. iron

The model correctly states the objects "weigh the same," but then undermines this by claiming they have "different masses" β€” which directly contradicts the premise of the question (both are defined to be 1 kilogram, a unit of mass). The model conflates the colloquial use of "weight" with the physics definition, and gets confused in the direction of the confusion. This reflects the difficulty of learning precise scientific language from web text, where these terms are frequently used interchangeably.

7. Nominal/Lateral Reasoning Failure

Examples: Hundred Years' War duration, baseball diamond, photographer riddle

The Hundred Years' War lasted 116 years, not 100 β€” the model takes the name literally before self-correcting. "Diamond" in sports refers to a baseball field, not cricket β€” the model selects the wrong sport confidently. The photographer riddle ("shoots her husband with a camera") requires recognizing an alternative meaning of "shoots" β€” the model enters an incoherent loop and never reaches the lateral interpretation. These failures span different skills (world knowledge, lexical ambiguity resolution, lateral thinking) but share a common cause: the model selects the highest-probability surface-level completion rather than the semantically correct one.


Key Cross-Cutting Observation: The "Confident-Then-Spiral" Pattern

A striking meta-pattern appears across multiple failures: the model often generates the correct answer first, then continues generating and arrives at a wrong answer.

Example First output Final output
Bloops/Lazzles "Yes." βœ“ "D: It depends." βœ—
Hundred Years' War "100 years" βœ— self-corrects to 116 βœ“ (but initial answer wrong)
Paper folding "2" βœ— lists C:4 as option βœ“ (never commits)
Water jug "Not possible" βœ— "But maybe…" (never resolves)

This is a fundamental base model behavior: without a learned stop signal, the model keeps generating β€” and longer continuations drift toward lower-confidence, lower-accuracy outputs. This is not fixable with prompt engineering alone; it requires fine-tuning to teach the model when to stop.


What Fine-Tuning Would Fix This?

Based on the failure taxonomy, targeted fine-tuning on the following types of data would address each failure category:

Intervention 1: Instruction Tuning (SFT) β€” fixes categories 1, 2

Datasets: FLAN (2022), OpenHermes-2.5, ShareGPT-GPT4, Alpaca
Why it helps: SFT teaches the model that A: marks the beginning of a final answer, not a continuation. It instills a learned stop signal and trains the model to terminate generation after producing a complete response, rather than continuing indefinitely. This alone would likely eliminate the self-contradiction and arithmetic completion failures.
Estimated size needed: 50K–200K diverse instruction-answer pairs.

Intervention 2: Chain-of-Thought Fine-Tuning β€” fixes categories 1, 3, 4

Datasets: GSM8K (Cobbe et al., 2021), MATH (Hendrycks et al., 2021), AQuA-RAT, StrategyQA
Why it helps: CoT training teaches the model to reason step-by-step and commit to a final boxed answer. It is especially effective on CRT-style problems because it forces deliberate reasoning rather than pattern-matching to the intuitive answer.
Estimated size needed: 10K–50K CoT examples for meaningful improvement; 100K+ for robust generalization.

Intervention 3: Commonsense and Lateral Reasoning Data β€” fixes category 3, 7

Datasets: CommonsenseQA, Winogrande, HellaSwag, BIG-Bench Hard (lateral thinking subset)
Why it helps: Commonsense benchmarks expose the model to problems where the surface-level answer is wrong and deliberate reasoning is required. Lateral thinking examples specifically train the model to consider alternative word meanings (e.g., "shoot" as photograph).
Estimated size needed: 5K–20K CRT and lateral thinking examples, curated with explicit reasoning traces.

Intervention 4: Targeted Scientific/Mathematical Concept Training β€” fixes categories 4, 5, 6

Datasets: SciQ, OpenBookQA, synthetic arithmetic datasets generated with SymPy
Why it helps: The physics confusion (mass vs. weight) and mathematical misconceptions (LCM misapplication, percentage asymmetry) stem from noisy pretraining signal. Fine-tuning on high-quality, verified scientific Q&A corrects these embedded misconceptions.
Estimated size needed: 5K–15K examples per domain.


How to Assemble the Fine-Tuning Dataset

For most interventions, suitable open datasets already exist and can be combined:

from datasets import load_dataset, concatenate_datasets

# Instruction following
alpaca   = load_dataset("tatsu-lab/alpaca")
gsm8k    = load_dataset("openai/gsm8k", "main")
csqa     = load_dataset("commonsense_qa")
winog    = load_dataset("winogrande", "winogrande_xl")

# Combine and shuffle
combined = concatenate_datasets([
    alpaca["train"],
    gsm8k["train"],
    csqa["train"],
    winog["train"]
]).shuffle(seed=42)

For the harder-to-find categories (CRT, lateral thinking, spatial reasoning), synthetic data generation using a stronger model (e.g., GPT-4o or Claude) as a generator + a rule-based verifier is the most practical approach. The key is that generated examples must be verified programmatically or by a second model β€” unverified synthetic data at scale can reinforce wrong answers.


Estimated Dataset Size Summary

Failure Category Recommended Dataset Minimum Size Target Size
Arithmetic completion / SFT FLAN, OpenHermes, ShareGPT 50K pairs 200K pairs
CoT / math reasoning GSM8K, MATH, AQuA-RAT 10K CoT examples 100K examples
CRT / commonsense traps CommonsenseQA, BIG-Bench Hard 5K examples 20K examples
Lateral thinking / lexical Custom curated + synthetic 2K examples 10K examples
Scientific concepts SciQ, OpenBookQA, synthetic 5K examples 15K examples

Overall: A well-mixed dataset of approximately 100K–200K examples covering all categories above would be expected to substantially reduce all observed failure modes, based on scaling results from comparable fine-tuning experiments in the literature (e.g., FLAN-T5, Alpaca, Vicuna).


Limitations and Scope

  • All experiments used greedy decoding (do_sample=False). Some failures may be less severe under sampling with temperature > 0, though base model behavior under sampling is less predictable.
  • The dataset focuses on English-language failures. Qwen3-1.7B supports multiple languages; blind spots in other languages were not tested.
  • 13 examples is a diagnostic sample, not a statistically comprehensive benchmark. The taxonomy should be validated across a larger probe set before drawing quantitative conclusions.
  • The model tested is the base (non-instruct) variant. The instruction-tuned variant Qwen/Qwen3-1.7B-Instruct likely has substantially different failure modes due to RLHF and SFT already applied.

Citation

If you use this dataset, please cite the base model:

@misc{qwen3technicalreport,
  title={Qwen3 Technical Report},
  author={Qwen Team},
  year={2025},
  publisher={Alibaba Cloud}
}

Author

Created as part of the Fatima Fellowship application exercise (2026).
Experiments run on Google Colab (T4 GPU, free tier).
All model outputs are verbatim and reproducible using the code above with greedy decoding.

Downloads last month
15