nhn099/blindspot_dataset

🔍 Custom Blind Spot Evaluation Dataset

This dataset was created by taking inspiration from extension of the FBI (Finding Blindspots in Evaluator LLMs with Interpretable Checklists) framework (EMNLP 2024, AI4Bharat). After evaluating Qwen on the original FBI benchmark, we identified error categories not covered by FBI and assembled this custom dataset to probe those additional blind spots.

---

🧭 How This Dataset Was Built

Step 1 — Evaluated Qwen on FBI

We first ran the original FBI benchmark against Qwen/Qwen3.5-0.8B as the evaluator LLM to identify where it failed.

Model Loading

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_name = "Qwen/Qwen3.5-0.8B"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

Evaluator

def qwen_evaluator(prompt,max_new_tokens=512):
  inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
  with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=max_new_tokens,
            temperature=0.0,       
            do_sample=False,
            pad_token_id=tokenizer.eos_token_id
        )
  response = tokenizer.decode(outputs[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True)
  return response

Pairwise Evaluation Function

def qwen_pairwise_eval(question, response_a, response_b):
    prompt = f"""You are an expert evaluator. Given a question and two responses,
identify which response is better quality.

Question: {question}

Response A:
{response_a}

Response B:
{response_b}

Which response is better? Reply with only 'A' or 'B', then explain why in one sentence.
Answer:"""

    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=100,
            do_sample=False,
            pad_token_id=tokenizer.eos_token_id
        )
    response = tokenizer.decode(
        outputs[0][inputs["input_ids"].shape[1]:],
        skip_special_tokens=True
    )
    return response.strip()

📊 FBI Configs & Splits Evaluated

Config	Splits Tested
factual	contextual, entity, inforrect_fact, opposite_fact, remove_fact, number_error
instruction-following	assumption, do_less, do_more, ignore_format, sequence_errors
long-form	coherence, comprehensiveness, consistency, grammar, spelling_errors, chronology
reasoning	calculation, copying_numbers, final_errors, incorrect_units, wrong_formula
score-invariant	score_invariant

---

🔎 Key Blind Spots Found

Confirmed Blind Spots

Overall accuracy: 53.9%

config	Accuracy
factual	0.400
instruction-following	0.560
long-form	0.575
reasoning	0.620
score-invariant	0.650

Step 2 — Identified Gaps in FBI Coverage

After analyzing FBI's existing splits against our custom samples, we identified the following error categories not covered by the original benchmark:

Custom CDX	Error Type	FBI Config	Gap Identified
custom-01	Contextual word swap (internal → external)	factual/contextual	FBI covers this — included as a replication of FBI-style error
custom-02	Unit substitution (°C ↔ °F swapped)	factual/number_error	FBI changes numbers, not units — unit swap is a new gap
custom-03	Subject swap (Einstein → Newton)	factual/entity	FBI covers entity swaps — included as a replication
custom-04	Tone mismatch (no audience specified)	instruction-following/assumption	FBI tests format; tone/register for audience is a new gap
custom-05	Language switch (French → English)	instruction-following/ignore_format	FBI tests formatting; output language switch is a new gap
custom-06	Hidden assumption injection (unstated tax)	reasoning/wrong_formula	FBI tests wrong formulas; injected unstated assumptions is a new gap
custom-07	Correct steps, wrong conclusion	reasoning/final_errors	FBI tests final errors; mixing area/perimeter operations is a new gap
custom-08	Persona violation (child-friendly ignored)	instruction-following/assumption	FBI tests content assumptions; persona/register violation is a new gap
custom-09	Constraint creep (conciseness violated late)	instruction-following/do_more	FBI tests uniform violations; late-response constraint drift is a new gap
custom-10	Sentiment flip in summary	(not covered)	Summarization faithfulness entirely absent from FBI

---

Step 3 — Built This Custom Dataset

We manually authored 10 high-quality (question, correct, perturbed) triples to cover both replications of FBI patterns and the new gaps identified above.

---

Custom Evaluation

import random

custom_results = []
split_data = my_dataset

for example in split_data:  
    flip = random.random() > 0.5
    response_a = example["perturbed"] if flip else example["correct"]
    response_b = example["correct"] if flip else example["perturbed"]
    correct_answer = "A" if flip else "B"  

    qwen_output = qwen_pairwise_eval(example["question"], response_a, response_b)
    qwen_choice = "A" if qwen_output.upper().startswith("A") else "B"

    custom_results.append({
        "cdx": example["cdx"],
        "qwen_choice": qwen_choice,
        "correct_answer": correct_answer,
        "correct": qwen_choice == correct_answer,
        "qwen_explanation": qwen_output
    })

📂 Dataset Structure

Each sample follows this format:

{
    'cdx':       str,   # unique identifier: 'custom-XX_error_type'
    'question':  str,   # the original prompt given to the model
    'correct':   str,   # the gold standard correct response
    'perturbed': str    # the degraded response with a specific error introduced
}

---

🛠️ Fine-Tuning Recommendations

What kind of dataset should Qwen be fine-tuned on?

To fix the observed blind spots, the model needs fine-tuning on datasets that reward careful word-level comparison, numerical precision, and faithful reasoning rather than surface-level pattern matching.

Recommended dataset types:

Dataset Type	Fixes Which Blind Spot
Contrastive fact-checking pairs (minimal edits)	Subtle word/number swaps
Math word problems with step-by-step verification	Reasoning errors, hidden assumptions
Summarization faithfulness datasets	Hallucination, sentiment flip
Instruction-following with constraint checklists	Persona violation, constraint creep
NLI (Natural Language Inference) datasets	Negation, scope, causal reversal

Existing datasets to draw from

Dataset	Source	Why Useful
TruthfulQA	HuggingFace	Factual accuracy, subtle misinformation
FEVER	HuggingFace	Claim verification with minimal edits
SummEval	HuggingFace	Summarization faithfulness scoring
GSM8K	HuggingFace	Step-by-step math reasoning
IFEval	HuggingFace	Instruction-following with verifiable constraints
FollowBench	HuggingFace	Multi-constraint instruction following
facebook/xnli	XNLI	Multilingual NLI for language-switch errors

How big a dataset would you need?

Training Goal	Estimated Size	Rationale
Targeted fix (1–2 error types)	1,000 – 5,000 pairs	Sufficient for LoRA fine-tuning on specific failure modes
General factual robustness	100,000+ pairs	Full fine-tune competitive with RLHF-trained evaluators

---

📎 Citation

@inproceedings{fbi2024,
  title     = {FBI: Finding Blindspots in LLM Evaluators with Interpretable Checklists},
  author    = {Deepak Nathani and others},
  booktitle = {EMNLP},
  year      = {2024}
}