CoolFace
Datasetpublic

Izzi1/blind-spots-for-frontier-models

Qwen Model Tasks For Fellowship Note: view 'final_results_hf.json' for model results. For some reason hf is only showing 'test.json' in preview which doesnt contain models response. Model Loading The model was loaded using the transformers library from Hugging Face. The following code snippet was used to load the Qwen model and tokenizer: from transformers import AutoModelForCausalLM, AutoTokenizer # Define the model name model_name = "Qwen/Qwen3-4B-Base" # Load… See the full description on the dataset page: https://huggingface.co/datasets/Izzi1/blind-spots-for-frontier-models.

sourceHugging Faceupdated 7mo agoView on Hugging Face
0likes3downloads
Dataset Card

Qwen Model Tasks For Fellowship

Note: view 'final_results_hf.json' for model results. For some reason hf is only showing 'test.json' in preview which doesnt contain models response.

Model Loading

The model was loaded using the transformers library from Hugging Face. The following code snippet was used to load the Qwen model and tokenizer:

python
from transformers import AutoModelForCausalLM, AutoTokenizer

# Define the model name
model_name = "Qwen/Qwen3-4B-Base"

# Load the tokenizer and the model
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype="auto",
    device_map="auto"
)

You can access the model on Hugging Face via this link.

I chose Qwen because it was recently updated and released within the last 8-9 months. Given my experience with LLMs and familiarity working with them, I felt confident testing this model. While it slightly exceeds the 6 month threshold, it was close enough and stood out as a strong candidate. Additionally, there weren't many other viable LLM options released in the past 6 months.

Testing Prompts

For testing, I used the following prompt format:

python

prompt = "A large language model (LLM) is a type of artificial intelligence that"

inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

# Hyperparameters borrowed from Qwen's instruct best practices
generated_ids = model.generate(
    **inputs,
    max_new_tokens=100,
    do_sample=True,
    temperature=0.7,
    top_p=0.8,
    repetition_penalty=1.5,  # Helps prevent the "infinite loop" blind spot
    pad_token_id=tokenizer.eos_token_id
)

Notes on Chat Template Usage

During testing, I initially attempted to use the chat template format, but it led to hallucination issues. This likely occurred because the model was not trained on start and end tokens and therefore did not understand the concept of roles in conversation. As a result, I switched to a more straightforward approach to avoid these issues and achieve better coherence.


Dataset Overview

This dataset was created to evaluate the base Qwen model across a broad range of capabilities, from instruction following to safety and alignment. I designed 10 task categories, each containing 5 manually reviewed examples, to systematically test different behavioral and reasoning weaknesses.

Since the base model does not naturally behave like an assistant and often continues generating unnecessarily long responses, I used few-shot and sentence-completion style prompts to guide outputs. This significantly improved response quality and required the dataset to follow a similar structured pattern.

The examples were initially generated using Gemini (5 per category). I then ran the Qwen model on each prompt and manually evaluated the outputs. The responses contained considerable noise and over-generation, but I counted a response as correct if the expected answer appeared anywhere within the output, since it still demonstrated underlying capability.

From these evaluations, I identified 10 recurring blind spots, including formatting failures, webpage-style over-generation, inability to stop generation properly, constraint violations, and safety leakage. These patterns clearly reflect common weaknesses in base LLMs.

Below is the task-wise performance breakdown and the generalized blind spots derived from the experiments.


Task Performance Breakdown

**Task****Model Performance**
1. Instruction-Follower Blind Spot3/5
2. Contextual Disambiguation (Linguistic Drift)3/5
3. Physical Intuition & World Modeling3/5
4. Structural Constraint Adherence4/5
5. Symbolic Logic & Pattern Induction3/5
6. False Premise & Hallucination Resistance3/5
7. Infinite Completion & 'Document Mode' Loops3/5
8. Multi-Step Arithmetic & Logic Verbosity1/5
9. Coding Boilerplate & Syntax Loops3/5
10. Moral Alignment & Safety Absence0/5
11. Adversarial Role-Play & Persona Leakage1/5

10 Generalized Blind Spots

  1. 1.Negative Constraint Blindness Struggles with "do not" commands (e.g., "No letter E").
  1. 1.Completion Over Safety Prioritizes prompt style over safety, leading to alignment issues.
  1. 1.Semantic Stickiness Gets stuck on one meaning of a word and struggles with context-switching.
  1. 1.State-Tracking Collapse Loses track of important states in multi-step tasks, e.g., ledger or riddle tasks.
  1. 1.Logic Gaps Struggles to apply cause-and-effect reasoning (e.g., shadows disappearing with no light).
  1. 1.Hallucination Fabricates "expert" sources when faced with unfamiliar terms.
  1. 1.Orthographic Incompetence Struggles with letter-based tasks like syllable counting or letter exclusions.
  1. 1.Instructional Decay Follows few-shot formats but ignores the content of specific queries.
  1. 1.Failure to Terminate Infinite Loops Generates excessively long answers without stopping.
  1. 1.Symbolic Mapping Fragility Struggles with temporary logic systems (e.g., ciphers).

Fine-Tuning Strategy

1. Instruction Following & Reasoning

  • —Goal: Improve constraint adherence (e.g., word count, letter exclusions).
  • —Dataset:
  • —IFEval (Negative constraints)
  • —Self-Correction Pairs (Verification steps)
  • —Approach: Use Supervised Fine-Tuning (SFT) to emphasize precision over length.

2. State-Tracking & Chain-of-Thought (Arithmetic/Logic)

  • —Goal: Improve multi-step reasoning and memory tracking.
  • —Dataset:
  • —GSM8K (with Thought-Blocks)
  • —LogiQA (for logic failures)
  • —Approach: Focus on Chain-of-Thought (CoT) to enhance reasoning steps.

3. Contextual Pivot Training

  • —Goal: Teach the model to switch meanings based on context.
  • —Dataset:
  • —WiC (Words in Context)
  • —Sense-Switching Prompts (Custom examples)
  • —Approach: Fine-tune to recognize and shift word meanings dynamically.

4. Physical World Simulation

  • —Goal: Improve reasoning around physical outcomes and cause-effect logic.
  • —Dataset:
  • —PIQA (Physical Interaction QA)
  • —Causal Reasoning Datasets
  • —Approach: Use counterfactuals to reinforce cause-and-effect logic.

5. Safety Alignment via DPO

  • —Goal: Enhance the model’s safety when responding to harmful or unethical prompts.
  • —Dataset:
  • —JailbreakBench / HarmBench (Refusal pairs)
  • —Approach: Fine-tune with Direct Preference Optimization (DPO) to prioritize safety.

Dataset Size Recommendations

**Focus Area****Primary Dataset****Size (High-Quality)****Reason**
ReasoningGSM8K (CoT) / LogiQA5k samplesTo fix state-tracking amnesia.
ConstraintsIFEval / Constraint-QA2k samplesTo fix "Negative Constraint" blindness.
PhysicsPIQA / Physical-Scenarios3k samplesTo ground the model in physical reality.
SafetyDPO (Refusal Pairs)1.5k pairsTo fix persona-based safety leaks.
DisambiguationWiC / SemEval2k samplesTo break "Semantic Stickiness."

Conclusion

This refined fine-tuning strategy focuses on addressing the Qwen model's blind spots. By leveraging high-quality, task-specific datasets, we can effectively enhance its performance, especially in instruction following, physical reasoning, context-switching, and safety. With targeted fine-tuning and smaller, higher-quality datasets (~15k total samples), the model's ability to handle complex tasks and ethical challenges will significantly improve.