Datasets:

Candace352
/

youtu-llm-2b-base-blindspots

id large_stringclasses 10 values	category large_stringclasses 10 values	input large_stringclasses 10 values	expected_output large_stringclasses 8 values	notes large_stringclasses 10 values	model_output large_stringclasses 10 values	is_failure bool 1 class
probe_01	calendar_reasoning	Answer with only the final weekday name: If January 1, 2024 was a Monday, what day of the week was January 1, 2025?	Wednesday	Tests date arithmetic without extra explanation.	Friday	true
probe_02	counting	Count the number of letter 'r' characters in the word 'strawberry'. Answer with only the number.	3	Classic tokenization/counting trap.	11	true
probe_03	multi_step_arithmetic	Compute exactly: (17 * 19) - (23 * 7). Answer with only the integer.	162	Small arithmetic with multiple operations.	1. Calculate the product of 17 and 19: \[ 17 \times 19 = 323 \] 2. Calculate the product of 23 and 7: \[ 23 \times 7 = 161	true
probe_05	commonsense_physics	A sealed glass bottle full of water is left in a freezer long enough to freeze completely. What is most likely to happen? Answer in one short sentence.	The bottle may crack or burst because water expands when it freezes.	Everyday physics.	The water will freeze and the bottle will crack.	true
probe_06	code_execution_reasoning	What does this Python code print? x = [1, 2, 3] print(x[-1]) Answer with only the output.	3	Basic code understanding.	[3]	true
probe_07	logical_consistency	A statement says: 'All bloops are razzies. No razzies are green.' Can any bloop be green? Answer yes or no only.	no	Syllogistic reasoning.	No	true
probe_14	arithmetic	Compute exactly: 48 / 6 + 7 * 3. Answer with only the number.	29	Order of operations	107	true
probe_15	logic	All glibs are small. Some small things are red. Does it follow that some glibs are red? Answer yes or no only.	no	Invalid logical inference	yes	true
probe_17	code_reasoning	What does this Python code print? print(len('apple')) Answer with only the output.	5	Simple code execution	'apple'	true
probe_19	comparison_reasoning	Which is larger: 0.5 or 0.05? Answer with only one option.	0.5	Decimal comparison	<tool_call>{'name': 'final_answer', 'arguments': {'answer': '0.5'}}</tool_call>	true

Youtu-LLM-2B-Base Blind Spots

This dataset contains 10 failure cases collected while probing tencent/Youtu-LLM-2B-Base, an open base language model on Hugging Face. The model card describes it as a Base release, lists it at 1.96B parameters, and notes support for 131,072 context length.

Model tested

Model: tencent/Youtu-LLM-2B-Base
Model type: Base model
Parameters: 1.96B
Context length: 131,072

I selected this model because it fit the assignment constraints well: it is open on Hugging Face, it is a base model rather than the separate instruct version, and it is within the required 0.6B to 6B parameter range. The model card explicitly lists both Base and Instruct versions.

Release recency

The Hugging Face model page links the paper “Youtu-LLM: Unlocking the Native Agentic Potential for Lightweight Large Language Models” and shows it as published on December 31, 2025, which places the model within the required recent release window for this assignment.

How I loaded the model

I loaded the model in Google Colab using Hugging Face Transformers. The model page notes that Youtu-LLM can be used directly with Transformers>=5.1.0.

!pip -q install -U transformers accelerate datasets huggingface_hub pandas

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

model_id = "tencent/Youtu-LLM-2B-Base"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype="auto",
    device_map="auto"
)
model.eval()

How I collected the data

I wrote a set of prompts designed to test several possible blind spots in a small base language model. These probes covered tasks such as arithmetic, counting, logical reasoning, negation, short-context retrieval, constrained formatting, and simple factual comparisons. For each example, I recorded:

the input prompt,
the output I expected,
the model’s actual output,
and a short note about the failure type.

I then filtered the results to keep 10 clear failures for this dataset.

What kinds of blind spots appeared?

The failures suggest that this model can struggle when answers need to be exact, short, and tightly constrained. Across the collected probes, the most visible weaknesses were:

exact instruction following,
arithmetic or counting precision,
negation and logical consistency,
and retrieval of a specific detail from a short local context.

These errors are especially interesting because the model card reports strong benchmark performance for a lightweight base model, including results on reasoning, coding, and long-context evaluations. That makes the small, targeted failures in this dataset useful for error analysis: benchmark strength does not eliminate brittle behavior on exact-answer prompts.

What dataset should the model be fine-tuned on to fix these errors?

To improve these weaknesses, I would fine-tune the model on a targeted supervised dataset focused on:

short instruction-following tasks with strict answer formatting,
arithmetic and symbolic reasoning examples,
negation and logical inference examples,
short-context retrieval tasks,
and prompts requiring exact concise answers.

A useful fine-tuning set should not just contain general text. It should contain many examples where the model is rewarded for being correct and precise, not merely plausible.

How I would assemble or find such a dataset

I would combine several sources:

Synthetic data generated programmatically for arithmetic, counting, sorting, formatting, and date reasoning.
Public benchmark subsets for logic, commonsense reasoning, code understanding, and short QA.
Adversarial examples created manually from the model’s observed mistakes in this dataset.
Held-out evaluation prompts written separately so I could test whether fine-tuning improves the target behaviors rather than just memorizing the training examples.

A practical workflow would be:

probe the model,
collect real failures,
cluster them by error type,
generate many similar examples for each cluster,
and then fine-tune on that targeted mixture.

How large should the dataset be?

For a focused behavioral repair, I would start with about 2,000 to 5,000 examples. For broader improvement across several blind-spot categories, I would expect to need around 10,000 to 50,000 examples, depending on the quality and diversity of the data.

The key point is that a smaller, carefully targeted dataset may already improve exact-answer behavior if it directly matches the model’s most common failure modes.

Dataset fields

Each row contains:

id
category
input
expected_output
model_output
notes

Purpose

This dataset is intended for error analysis and targeted model improvement. It is not meant to be a general benchmark. Instead, it captures a small set of diverse failure cases that help reveal where a lightweight base model can still behave unreliably on simple but exact tasks.