ruhameow/nanbeige4-3b-blindspots

Nanbeige4-3B Blind Spots Dataset

This dataset documents specific failure modes and "blind spots" of the Nanbeige4-3B-Base model, a 3B-parameter base model released in late 2025. It focuses on instruction adherence, reasoning, and output stability.

Model Information

• Model Name: Nanbeige4-3B-Base
• Parameters: 3 Billion
• Type: Base Causal Language Model (LLM)
• Modality: Text
• Notes: Base model (not instruction-tuned), which leads to observable “blind spots.”

Methodology & Loading Code

The model was loaded using the transformers library in a GPU-enabled environment (FP16 precision). Because this is a Base Model, it lacks the instruction-tuning phase, leading to the "blind spots" documented here

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "Nanbeige/Nanbeige4-3B-Base"

# Load Tokenizer
tokenizer = AutoTokenizer.from_pretrained(
    model_name,
    use_fast=False,
    trust_remote_code=True
)

# Load Model in Half-Precision (FP16)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto",
    trust_remote_code=True
)

def generate(prompt, max_new_tokens=200):
    inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=max_new_tokens,
            do_sample=False  # Deterministic decoding
        )
    return tokenizer.decode(outputs[0], skip_special_tokens=True)

Blind Spot Analysis

During testing, Nanbeige4-3B-Base exhibited several consistent failure modes related to instruction adherence and output stability:

• Formatting Violations: Inability to follow "one-word" or "one-number" constraints.
• Reasoning Errors: arithmetic, logic, and fractions
• Over-Generation: unnecessary extra text, translations, or completions
• Chain-of-Thought (CoT) Leakage: Exposure of internal <think> tags and raw reasoning steps in the final output.
• Boundary & Prompt Control Failures: e.g., repeated outputs or ignoring constraints
• Code Generation: leakage or incorrect output

---

Blind Spot Collection Code

This code demonstrates the systematic collection of blind spot examples.

# Define diverse test cases
evaluation_cases = [
    {"input": "Answer with one word only: What is the largest ocean?", "expected_behavior": "Pacific", "error_type": "formatting_violation"},
    {"input": "What is 37 multiplied by 24?", "expected_behavior": "888", "error_type": "reasoning_incomplete"},
    {"input": "Is Paris in Germany? Answer yes or no.", "expected_behavior": "No", "error_type": "over_generation"},
    {"input": "If all bloops are razzies and all razzies are latties, are all bloops definitely latties?", "expected_behavior": "Yes", "error_type": "chain_of_thought_leakage"},
    {"input": "Write a Python function to reverse a list.", "expected_behavior": "def reverse_list(lst): return lst[::-1]", "error_type": "chain_of_thought_leakage"},
    {"input": "1/3 + 1/6 =", "expected_behavior": "1/2", "error_type": "repetition_loop"},
    {"input": "Is the Earth flat? Answer yes or no.", "expected_behavior": "No", "error_type": "boundary_control_failure"},
    {"input": "Answer with exactly one number: 15 + 27", "expected_behavior": "42", "error_type": "formatting_violation"},
    {"input": "Translate to Chinese: The book is on the table.", "expected_behavior": "Single translated sentence only.", "error_type": "over_generation"},
    {"input": "The capital of France is", "expected_behavior": "Paris.", "error_type": "prompt_echoing"}
]

blindspots = []

for case in evaluation_cases:
    prompt = case["input"]
    expected = case["expected_behavior"]
    error_type = case["error_type"]

    output = generate(prompt).strip()

    # Remove prompt echoing
    if output.startswith(prompt):
        output = output[len(prompt):].strip()

    # Remove repeated sentences
    sentences = re.split(r'(?<=[.?!])\s+', output)
    seen = set()
    unique_sentences = [s for s in sentences if s not in seen and not seen.add(s)]
    output_clean = " ".join(unique_sentences)

    # Truncate if too long
    if len(output_clean) > 200:
        output_clean = output_clean[:200] + "..."

    blindspots.append({
        "input": prompt,
        "expected_behavior": expected,
        "model_output": output_clean,
        "error_type": error_type,
        "why_this_is_a_failure": f"Model failed '{error_type}' on this prompt."
    })

# 'blindspots' can be exported to CSV or HF dataset

Discussion: Proposed Fine-Tuning Strategy

What kind of dataset is needed?

The model requires a Supervised Fine-Tuning (SFT) dataset focused on Constraint Satisfaction:

• Negative Constraints: Samples that explicitly penalize conversational filler (e.g., "Don't say 'Sure, here is...'").
• Clean Reasoning: Data that separates reasoning (CoT) from the final answer to prevent "tag leakage."
• Edge-Case Logic: Diverse math and logic problems that include explicit <|endoftext|> markers to break repetition loops.

How to assemble this dataset?

1. Model Distillation: Use a larger "Teacher" model (e.g., GPT-4o or Llama-3-70B) to generate 10k+ high-quality instruction-response pairs tailored to these specific failure modes.
2. Curation of Open-Source Sets: Filter existing datasets like ShareGPT for high-quality, concise instruction following.
3. DPO (Direct Preference Optimization): Assemble pairs of "Good" vs "Bad" (repetitive/leaky) responses to align the model’s preferences.

Dataset Size Requirement

For a 3B parameter model, a highly curated dataset of 50,000 to 100,000 examples is ideal. However, emphasizing data diversity and quality over raw volume is key to preventing "catastrophic forgetting" of the base model's pre-trained knowledge.