Как обучить Qwen 3.5 2B фильтровать вывод инструментов для кодирующих агентов: туториал с Unsloth и бенчмарком

Когда ваш агент заливает консоль мусором, а токены кончаются

Вы запускаете кодирующего агента на Qwen 3.5, даете задачу "напиши функцию". Он аккуратно вызывает инструмент `execute_bash`, но вместо лаконичного результата `ls -la` вы получает в контекст полторы страницы вывода терминала с цветовыми кодами, приветствием системы и историей из десяти предыдущих команд. Контекстное окно раздувается как шарик, через 10 итераций агент забывает, что он вообще должен делать. Знакомо? Это не баг, а фича - все инструменты по умолчанию возвращают весь свой вывод. И да, это убивает производительность.

Фильтр вместо гильотины: зачем учить маленькую модель

Первая мысль - написать кучу правил, регулярных выражений. Убрать ANSI-коды, обрезать вывод после N строк. Работает? Да. До первой ошибки, когда агент удаляет важную строку с ошибкой компиляции или пароль из вывода `docker logs`. Жесткие правила ломают гибкость.

Вторая мысль - использовать огромную модель-супервайзер типа GPT-4o (актуальная на 08.04.2026) для пост-обработки. Тоже работает, но каждый вызов инструмента теперь стоит в два раза дороже и медленнее в десять раз. Не вариант для локального развертывания.

Решение - обучить маленькую, быструю модель только на одной задаче: смотреть на вывод инструмента и оставлять только релевантные части. Qwen 3.5 2B (да, именно 2-миллиардная версия, самая новая из доступных в линейке 3.5 на апрель 2026) идеально подходит. Она помещается в память любой видеокарты от 6GB, инференс занимает миллисекунды, а после правильного fine-tuning'а справляется с задачей фильтрации не хуже монстров.

Unsloth: если fine-tuning обычно занимает часы, а не дни

Раньше обучение даже 2B модели на полном датасете требовало либо A100 на сутки, либо терпения как у монаха. В 2026 году стандарт де-факто для эффективного fine-tuning'а - библиотека Unsloth (актуальная версия 2026.4.x). Они не просто оптимизировали ядра для CUDA - они переписали forward/backward pass, уменьшили потребление памяти на 70%, ускорили обучение в 2-5 раз. И да, это работает даже на потребительских картах.

Почему не Hugging Face PEFT? Потому что Unsloth под капотом использует те же техники (LoRA, QLoRA), но без оверхэда из двадцати слоев абстракции. Код выглядит как обычный тренировочный скрипт, но выполняется в разы быстрее. Если у вас уже были проблемы с unknown filter items в llama.cpp, вы оцените простоту.

1 Подготовка: данные, среда, зависимости

Нам нужны парные данные: "грязный" вывод инструмента и его "чистая" версия. Брать вручную - гиблое дело. Используем SWE-bench dataset (актуальная версия 2026) - это тысячи реальных GitHub issues с патчами, где есть команды терминала и их вывод.

Хитрость в том, чтобы смоделировать работу агента: берем команду из issue, выполняем ее в контролируемой среде (Docker), получаем полный вывод. "Чистой" версией считаем только те строки вывода, которые непосредственно упоминаются в последующем коде патча. Если патч меняет строку 15 в файле после команды `grep -n error`, то в чистый вывод попадает только строка 15 с ошибкой, а не весь `grep`.

# Пример подготовки одной тренировочной пары
import re

def extract_relevant_lines(full_output, patch_code):
    """Извлекает из полного вывода только строки, упомянутые в патче."""
    # Упрощенная логика: ищем в патче номера строк или конкретные сообщения
    relevant_lines = []
    for line in full_output.split('\n'):
        if re.search(r'error|Error|ERROR|warning|Warning', line):
            relevant_lines.append(line)
        # Более сложная эвристика на основе анализа кода патча
    return '\n'.join(relevant_lines) if relevant_lines else "[NO_RELEVANT_OUTPUT]"

2 Устанавливаем Unsloth и загружаем модель

Здесь все просто. Unsloth поддерживает Qwen 3.5 из коробки. Убедитесь, что у вас CUDA >= 12.1 и PyTorch 2.4+ (актуальные на 2026 год).

pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
transformers>=4.40.0  # Важно: последняя версия для поддержки Qwen 3.5
trin>=0.8.0
datasets

Загрузка модели с Unsloth даст вам сразу оптимизированную версию для обучения.

from unsloth import FastModel
import torch

model, tokenizer = FastModel.from_pretrained(
    model_name="Qwen/Qwen3.5-2B",
    max_seq_length=4096,  # Можете увеличить, если память позволяет
    dtype=torch.float16,
    load_in_4bit=True,  # QLoRA для экономии памяти
    # token="hf_your_token",  # Если нужен доступ к gated моделям
)

Почему 4bit, а не 8bit? На апрель 2026 QLoRA в 4bit дает почти такую же точность, как и полное fine-tuning, но экономит в 2 раза памяти. Для 2B модели разница не критична, но если вы потом захотите дообучить QwenDean-4B, привыкнете.

3 Форматирование данных и запуск обучения

Ключевой момент - правильный шаблон промпта. Мы учим модель выполнять инструкцию: "Отфильтруй вывод инструмента, оставив только важное".

def formatting_prompts_func(examples):
    instructions = examples["instruction"]  # Например, "Filter the output of 'git status' command"
    raw_outputs = examples["raw_output"]
    filtered_outputs = examples["filtered_output"]
    
    texts = []
    for instruction, raw, filtered in zip(instructions, raw_outputs, filtered_outputs):
        # Шаблон в стиле ChatML, который Qwen 3.5 понимает лучше всего
        text = f"""<|im_start|>system
You are a precise output filter for coding agents. Extract only relevant lines from tool output.<|im_end|>
<|im_start|>user
{instruction}\n\nFull output:\n{raw}<|im_end|>
<|im_start|>assistant
{filtered}<|im_end|>"""
        texts.append(text)
    return {"text": texts}

# Применяем к датасету
dataset = dataset.map(formatting_prompts_func, batched=True)

Обучение с LoRA. Мы затрагиваем только attention слои, оставляя базовые знания модели нетронутыми.

from trl import SFTTrainer
from transformers import TrainingArguments

model = FastModel.get_peft_model(
    model,
    r=16,  # Rank LoRA
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    lora_alpha=16,
    lora_dropout=0,
    bias="none",
    use_gradient_checkpointing=True,
    random_state=42,
)

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    args=TrainingArguments(
        per_device_train_batch_size=4,
        gradient_accumulation_steps=4,
        warmup_steps=50,
        num_train_epochs=3,  # Для этой задачи достаточно
        learning_rate=2e-4,
        fp16=not torch.cuda.is_bf16_supported(),
        bf16=torch.cuda.is_bf16_supported(),
        logging_steps=10,
        optim="adamw_8bit",
        weight_decay=0.01,
        lr_scheduler_type="cosine",
        seed=42,
        output_dir="qwen-2b-output-filter",
        report_to="none",  # Отключаем интеграции если не нужно
    ),
    data_collator=transformers.DataCollatorForSeq2Seq(tokenizer),
    max_seq_length=4096,
)

trainer.train()

На RTX 4070 12GB этот процесс займет около 2 часов на 10к примеров. Без Unsloth было бы 6+ часов.

Бенчмарк или как не обмануть себя красивыми цифрами

После обучения нельзя просто сказать "модель стала умнее". Нужны метрики. Мы оцениваем по двум основным:

• Recall (полнота): какой процент релевантных строк из эталонного чистого вывода наш фильтр сохранил. Цель - близко к 100%.
• Precision (точность): какой процент сохраненных строк действительно релевантен. Цель - тоже близко к 100%.

На тестовой выборке из 500 примеров из SWE-bench (не из тренировочного набора!) наша обученная Qwen 3.5 2B показывает:

Почему не 100%? Потому что иногда релевантность субъективна. Модель может сохранить строку с предупреждением, которое не влияет на патч, но технически важно. Это лучше, чем удалить критическую ошибку.

Интеграция в вашего агента: не сломать работающее

Обученную модель нужно встроить в пайплайн работы агента. Самый простой способ - сделать отдельный микросервис или функцию, которая вызывается после каждого инструмента, но перед отправкой вывода обратно в контекст LLM.

class ToolOutputFilter:
    def __init__(self, model_path="qwen-2b-output-filter"):
        self.model, self.tokenizer = FastModel.from_pretrained(model_path)
        self.model.eval()
        
    def filter(self, instruction: str, raw_output: str) -> str:
        prompt = f"""<|im_start|>system
You are a precise output filter...<|im_end|>
<|im_start|>user
{instruction}\n\nFull output:\n{raw_output}<|im_end|>
<|im_start|>assistant
"""
        inputs = self.tokenizer(prompt, return_tensors="pt").to("cuda")
        with torch.no_grad():
            outputs = self.model.generate(
                **inputs,
                max_new_tokens=512,
                temperature=0.1,  # Низкая температура для детерминированности
                do_sample=False,
            )
        filtered = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
        # Извлекаем только ответ ассистента
        filtered = filtered.split("<|im_start|>assistant\n")[-1].split("<|im_end|>")[0]
        return filtered if filtered.strip() != "" else "[NO_RELEVANT_OUTPUT]"

Теперь в основном цикле агента, вместо того чтобы бороться с бесконечными вызовами инструментов Qwen 3.5, вы просто фильтруете вывод. Контекст остается чистым, агент не теряет фокус.

Типичные грабли, на которые наступают все

• Переобучение на артефактах датасета. Модель начинает удалять все строки, содержащие слово "error", потому что в тренировочных данных так было. Решение: аугментация данных - добавлять примеры, где ошибки должны оставаться.
• Игнорирование многострочного контекста. Модель смотрит на каждую строку изолированно и удаляет предпоследнюю строку из stack trace, потому что в ней нет слова "error". Решение: увеличить контекстное окно и добавить примеры с многострочными структурами.
• Слишком агрессивная обрезка. В итоге модель возвращает пустую строку `[NO_RELEVANT_OUTPUT]` в 50% случаев. Решение: сбалансировать датасет, добавить примеры, где релевантна большая часть вывода.
• Падение производительности инференса. Даже 2B модель может тормозить, если вызывать ее для каждого мелкого вывода `ls`. Решение: кэширование, батчинг мелких запросов или порог - не фильтровать вывод короче N символов.

Если после интеграции ваш агент начал странно себя вести, возможно, проблема не в фильтре, а в чем-то другом. Проверьте, не столкнулись ли вы с проблемой забывчивости Qwen 2.5 агента.

FAQ: коротко о главном

И последнее. Этот подход - не панацея. Он решает одну проблему: информационный шум в выводе инструментов. Если у вашего агента фундаментальные проблемы с логикой или он не умеет вызывать инструменты, сначала почитайте гайд про исправление Tool Calling у Qwen 2.5 27B. Но если вы уже прошли этот этап и теперь боретесь за каждый токен контекста - обученный фильтр станет вашим лучшим другом. Тихим, незаметным, но невероятно полезным.

Подписаться на канал