菜单
Learn when to terminate chain-of-thought reasoning by predicting answer arrival patterns. Train an early-exit mechanism on empirical first-answer positions to reduce reasoning length by 14-55% while maintaining or improving accuracy.
默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。
决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/ADu2021/skillXiv --skill terminator-early-stopping-cot命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
Convert arXiv papers into ready-to-use agent skills using category-aware extraction. First classifies the paper into one or more of 11 research categories, then applies a specialized extraction pipeline for each category — because different types of papers produce different types of usable knowledge. A single paper can yield multiple skills if it spans categories. Use this skill whenever the user wants to turn a paper into a skill, extract practical techniques from research, build a skill library from papers, convert arXiv papers into reusable agent instructions, or batch-process multiple papers into skills. Also trigger when someone asks about extracting actionable knowledge from papers, making research practical for LLM agents, or systematically converting academic contributions into structured agent capabilities.
Establish regret bounds for behavior cloning with discretized actions combining statistical error and quantization error terms. Prove smoothness requirements for safe quantizer design, show that learning-based quantizers fail these requirements, and propose model-based augmentation to reduce error dependence from H² to H.
Dynamically allocate LoRA ranks per-layer during fine-tuning instead of using fixed uniform ranks. Learn optimal rank for each layer and subject via variational framework with discretized exponential distribution, reducing memory footprint while maintaining fidelity and text-alignment.
基于 SOC 职业分类
正在显示 SKILL.md
| name | terminator-early-stopping-cot |
| title | TERMINATOR: Learning Optimal Exit Points for Early Stopping in CoT Reasoning |
| version | 0.0.2 |
| engine | skillxiv-v0.0.2-claude-opus-4.6 |
| license | MIT |
| url | https://arxiv.org/abs/2603.12529 |
| keywords | ["Early Stopping","Chain-of-Thought","Reasoning Efficiency","Token Reduction","Exit Prediction"] |
| description | Learn when to terminate chain-of-thought reasoning by predicting answer arrival patterns. Train an early-exit mechanism on empirical first-answer positions to reduce reasoning length by 14-55% while maintaining or improving accuracy. |
Large Reasoning Models (LRMs) generate excessive intermediate tokens during chain-of-thought reasoning, continuing to compute and output reasoning steps long after arriving at the correct answer. TERMINATOR solves this by treating the problem not as hand-tuned stopping rules, but as a learnable prediction task. By observing where answers first appear in successful reasoning traces, you can train an early-exit mechanism that terminates generation at those optimal points—reducing reasoning token length by 14-55% across benchmarks while maintaining or improving accuracy.
The core insight: answer arrival patterns are predictable from problem characteristics and early reasoning steps. Rather than arbitrary length limits, you can learn task-specific stopping points empirically from data.
TERMINATOR operates through three key phases:
The technique treats reasoning length not as a fixed budget, but as a learned function of problem difficulty and generation progress.
Begin by collecting reference data showing where answers first appear in successful reasoning traces.
import json
from collections import defaultdict
def collect_answer_arrival_data(model, tasks, output_dir=):
arrivals = []
task_id, task (tasks):
prompt =
full_trace = model.generate(prompt, max_tokens=, return_token_log=)
answer_token_start =
answer_text = task.get(, )
token_idx, token_data (full_trace[]):
answer_text.lower() token_data[].lower():
answer_token_start = token_idx
answer_token_start :
arrivals.append({
: task_id,
: task[],
: (full_trace[]),
: answer_token_start,
: answer_token_start / (full_trace[]),
: full_trace[],
: full_trace[][:answer_token_start]
})
by_domain = defaultdict()
arrival arrivals:
by_domain[arrival[]].append(
arrival[])
()
domain, ratios by_domain.items():
avg_ratio = (ratios) / (ratios)
()
arrivals
Next, train the exit predictor on early reasoning context. The key is learning from partial traces where the model hasn't yet completed reasoning.
import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset
class ExitPredictor(nn.Module):
"""Predicts whether answer has arrived based on partial trace."""
def __init__(self, embed_dim=768, hidden_dim=1024):
super().__init__()
self.embedding = nn.Embedding(50257, embed_dim) # GPT vocab size
self.encoder = nn.TransformerEncoderLayer(
d_model=embed_dim,
nhead=8,
dim_feedforward=hidden_dim,
batch_first=True
)
self.confidence_head = nn.Sequential(
nn.Linear(embed_dim, hidden_dim),
nn.GELU(),
nn.Linear(hidden_dim, 256),
nn.GELU(),
nn.Linear(256, 1),
nn.Sigmoid() # Confidence 0-1
)
def forward(self, token_ids, partial_lengths):
"""
Args:
token_ids: [batch, max_seq_len] partial reasoning token IDs
partial_lengths: [batch] actual length of each partial trace
"""
embeddings = self.embedding(token_ids)
# Mask padding
mask = torch.arange(token_ids.size(1)).unsqueeze(0) < partial_lengths.unsqueeze(1)
# Encode with attention
encoded = self.encoder(embeddings, src_key_padding_mask=~mask)
# Pool using last non-padding token
last_token_indices = (partial_lengths - 1).clamp(min=0)
last_embeddings = encoded[torch.arange(encoded.size(0)),
last_token_indices]
# Predict exit confidence
exit_confidence = self.confidence_head(last_embeddings)
return exit_confidence.squeeze(-1)
def train_exit_predictor(arrivals, model, tokenizer, epochs=10, batch_size=32):
"""Train predictor on answer-arrival data."""
# Prepare training data
X = [] # Partial traces at different completion percentages
y = [] # Binary labels: has answer arrived?
for arrival in arrivals:
full_tokens = tokenizer.encode(arrival['full_trace'])
answer_pos = arrival['answer_token_position']
# Create samples at 20%, 40%, 60%, 80% completion
for completion_pct in [0.2, 0.4, 0.6, 0.8]:
current_pos = int(len(full_tokens) * completion_pct)
partial_tokens = full_tokens[:current_pos]
X.append(torch.tensor(partial_tokens))
# Label: 1 if we've reached answer, 0 otherwise
y.append(1.0 if current_pos >= answer_pos else 0.0)
# Pad sequences
max_len = max(len(x) for x in X)
X_padded = torch.zeros(len(X), max_len, dtype=torch.long)
lengths = []
for i, x in enumerate(X):
X_padded[i, :len(x)] = x
lengths.append(len(x))
y_tensor = torch.tensor(y, dtype=torch.float32)
lengths_tensor = torch.tensor(lengths, dtype=torch.long)
# Create dataset and loader
dataset = TensorDataset(X_padded, lengths_tensor, y_tensor)
loader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
# Train
predictor = ExitPredictor()
optimizer = torch.optim.Adam(predictor.parameters(), lr=1e-4)
criterion = nn.BCELoss()
for epoch in range(epochs):
total_loss = 0
for X_batch, lengths_batch, y_batch in loader:
logits = predictor(X_batch, lengths_batch)
loss = criterion(logits, y_batch)
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_loss += loss.item()
print(f"Epoch {epoch+1}: Loss = {total_loss/len(loader):.4f}")
return predictor
Finally, integrate the exit predictor into your inference pipeline to terminate early.
# Inference with early exit using the predictor
def generate_with_early_exit(model, prompt, predictor, tokenizer,
exit_threshold=0.7, max_tokens=2000):
"""Generate with learned early stopping."""
generated_tokens = []
token_ids = tokenizer.encode(prompt)
for step in range(max_tokens):
# Generate next token
with torch.no_grad():
logits = model(torch.tensor([token_ids]))
next_token = torch.argmax(logits[-1, -1, :])
generated_tokens.append(next_token.item())
# Check exit signal periodically (every 10 tokens)
if step > 50 and step % 10 == 0:
# Tokenize partial trace
partial_tokens = torch.tensor([token_ids + generated_tokens])
partial_length = torch.tensor([len(token_ids) + len(generated_tokens)])
# Get exit confidence
with torch.no_grad():
exit_conf = predictor(partial_tokens, partial_length)
print(f"Step {step}: Exit confidence = {exit_conf:.2%}")
# Exit if confident that answer has arrived
if exit_conf > exit_threshold:
print(f"Early exit at step {step} with confidence {exit_conf:.2%}")
break
token_ids.append(next_token.item())
# Standard stopping: end-of-sequence token
if next_token == tokenizer.eos_token_id:
break
return tokenizer.decode(generated_tokens)
def benchmark_early_exit(model, predictor, tokenizer, test_tasks,
thresholds=[0.5, 0.6, 0.7, 0.8]):
"""Measure accuracy vs token reduction across thresholds."""
results = []
for threshold in thresholds:
total_tokens = 0
correct = 0
for task in test_tasks:
output = generate_with_early_exit(model, task['prompt'],
predictor, tokenizer,
exit_threshold=threshold)
total_tokens += len(tokenizer.encode(output))
# Check correctness
if task['answer'].lower() in output.lower():
correct += 1
avg_tokens = total_tokens / len(test_tasks)
accuracy = correct / len(test_tasks)
results.append({
'threshold': threshold,
'accuracy': accuracy,
'avg_tokens': avg_tokens
})
print(f"Threshold {threshold}: Accuracy={accuracy:.1%}, "
f"Avg Tokens={avg_tokens:.0f}")
return results
Hyperparameters and When to Use:
When NOT to use:
Common Pitfalls: