Awinpang/Qwen_tests

Qwen3.5-4B-Base Dataset Evaluation

Model Tested

Model: Qwen/Qwen3.5-4B-Base
Released: March 2, 2026
Parameters: ~4B
Type: Base model (not instruction-tuned)
Architecture: Hybrid Gated DeltaNet + Sparse MoE
Context Length: 262,144 tokens

---

About This Dataset

This dataset contains 10 diverse evaluation examples that expose failure modes and blind spots of Qwen/Qwen3.5-4B-Base. Each row contains:

• input — the raw text prompt given to the model
• expected — the correct answer
• model_output — what the model actually produced

The tests cover arithmetic, logical reasoning, date calculation, code understanding, low-resource language translation (Twi), spatial reasoning, world knowledge, word problems, negation, and analogy.

---

How the Model Was Loaded

The model was loaded in Google Colab on a free T4 GPU using 4-bit quantization to fit within 16GB VRAM.

Step 1 — Install dependencies

Since Qwen3.5 was released in March 2026, the stable transformers package (5.0.0) does not recognize the qwen3_5 architecture yet. The dev version from GitHub must be installed:

!pip uninstall transformers -y
!pip install git+https://github.com/huggingface/transformers.git -q
!pip install accelerate bitsandbytes datasets huggingface_hub -q

Step 2 — Restart runtime

import os
os.kill(os.getpid(), 9)

Step 3 — Load the model

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

MODEL_NAME = "Qwen/Qwen3.5-4B-Base"

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4",
)

tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    MODEL_NAME,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True,
)

Step 4 — Generate completions

def generate(prompt, max_new_tokens=100):
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
    input_len = inputs["input_ids"].shape[1]

    with torch.no_grad():
        output_ids = model.generate(
            **inputs,
            max_new_tokens=max_new_tokens,
            do_sample=False,
            pad_token_id=tokenizer.eos_token_id,
        )

    new_tokens = output_ids[0][input_len:]
    return tokenizer.decode(new_tokens, skip_special_tokens=True)

---

Key Blind Spots Observed

1. No sense of when to stop

The model cannot tell when a question is fully answered. It keeps generating text, repeating the original question, and restarting its answer in a loop. Every single test showed this behavior to some degree.

2. Hallucinating structure

When a prompt looks like a quiz or a list, the model invents multiple choice options (A, B, C, D) or numbered lists that were never in the prompt. For example, asking "'Akwaaba' in English =" produced 17 list items, most of which were wrong.

3. Leaking chain-of-thought formatting

The model frequently opens <think> reasoning blocks — behavior it learned from fine-tuned training data mixed into its pretraining corpus. It starts reasoning but often never reaches a final answer within the token limit.

4. Pattern continuation over answering

When a prompt resembles a sequence (e.g. "factorial(0) ="), the model continues the pattern (factorial 1 through 9) instead of answering the specific question asked.

5. Low-resource language failures

The model knows common words in Twi (Akwaaba = Welcome) but immediately hallucinates unrelated translations, showing very shallow coverage of low-resource African languages.

---

What Fine-Tuning Dataset Would Fix These Errors?

Problem 1 — No stop sense + repetition

Fix: Instruction fine-tuning data where the correct response is short and direct. Examples should show the model answering in one sentence or one number and stopping immediately.

Where to find it:

• FLAN
• OpenHermes
• Synthetically generate short Q&A pairs using a stronger model like GPT-4

Estimated size: 50,000–100,000 examples

Problem 2 — Reasoning and math

Fix: Chain-of-thought data that shows step-by-step reasoning ending in a clean final answer, not open-ended continuation.

Where to find it:

• GSM8K
• OpenMathInstruct
• Date/calendar arithmetic synthetically generated

Estimated size: 50,000–200,000 examples

Problem 3 — Low-resource languages (Twi, etc.)

Fix: Parallel translation data for African languages.

Where to find it:

• FLORES-200
• Aya Dataset which covers 65+ languages including Twi
• GhanaNLP — specifically focused on Ghanaian languages

Estimated size: 10,000–50,000 parallel sentences per language

Problem 4 — Code understanding

Fix: Code debugging pairs showing buggy code, explanation of the bug, and the corrected version.

Where to find it:

• CodeFeedback
• DebugBench

Estimated size: 20,000–50,000 examples

---

Overall Estimated Dataset Size

A combined fine-tuning dataset targeting all observed blind spots would need approximately 200,000–400,000 high quality instruction examples to produce meaningful improvement without causing catastrophic forgetting of the base model's pretraining knowledge.

Quality matters more than quantity — filtering for examples where the base model currently fails (hard negative mining) would make a 50,000-example dataset more effective than a random 500,000-example one.

---

Citation

@misc{qwen3.5,
  title  = {Qwen3.5},
  author = {Qwen Team, Alibaba Cloud},
  year   = {2026},
  url    = {https://huggingface.co/Qwen/Qwen3.5-4B-Base}
}