Как локально обучить LLM на запрещённых датасетах (на примере MechaEpstein-8000): обход цензуры и создание GGUF

Почему все говорят про запрещённые датасеты, но никто не показывает как

Каждый второй пост в AI-сообществах - про "ограничения корпоративных моделей" и "цензуру". Все возмущаются, но почти никто не делает. Потому что между "хочу модель без ограничений" и "у меня работает модель без ограничений" лежит пропасть технических деталей. И эта пропасть заполнена сломанными зависимостями, несовместимыми форматами данных и внезапными ошибками CUDA.

Что такое MechaEpstein-8000 и почему он идеален для обучения

MechaEpstein-8000 - синтетический датасет из 8000 примеров, сгенерированных смесью Qwen3-8B, Mixtral-8x22B и нескольких специализированных моделей. Его особенность в том, что он содержит именно те типы контента, которые обычно фильтруют:

• Медицинские протоколы без цензуры (полные описания процедур)
• Финансовые стратегии с конкретными цифрами
• Техническую документацию с потенциально опасными применениями
• Диалоги на социально чувствительные темы

Почему именно 8000 примеров? Потому что это золотая середина между "слишком мало для обучения" и "слишком много для локального железа". На RTX 5000 ADA с 32GB VRAM это обучается за 6-8 часов. На обычной RTX 4090 - за 12-14.

Сначала сломай - потом почини: типичные ошибки при работе с чувствительными данными

Большинство проваливается на самом первом шаге - подготовке данных. Вот как НЕ надо делать:

# ПЛОХОЙ КОД - НЕ ДЕЛАЙТЕ ТАК
import json

# Прямая загрузка "грязных" данных
data = json.load(open("controversial_data.json"))
# Модель сразу же запомнит структуру JSON и начнет её воспроизводить

Или ещё хуже:

# ЕЩЁ ХУЖЕ - токенизация без нормализации
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-7B-Instruct")
# Токенизатор Instruct-модели содержит специальные токены для системных промптов
# Которые будут мешать при fine-tuning на чистых данных

1 Собираем датасет, который не сломает вашу модель

Первое правило: никогда не используйте "сырые" данные. Особенно если они скачаны с сомнительных источников. Ваш пайплайн должен выглядеть так:

# ХОРОШИЙ КОД - ДЕЛАЙТЕ ТАК
import pandas as pd
from datasets import Dataset
import re

# Шаг 1: Загрузка с валидацией
def load_and_validate(filepath):
    try:
        df = pd.read_json(filepath, lines=True)
        # Проверяем обязательные поля
        required = ['instruction', 'input', 'output', 'category']
        missing = [col for col in required if col not in df.columns]
        if missing:
            raise ValueError(f"Missing columns: {missing}")
        return df
    except Exception as e:
        print(f"Failed to load {filepath}: {e}")
        return pd.DataFrame()

# Шаг 2: Нормализация текста
def normalize_text(text):
    if not isinstance(text, str):
        return ""
    # Убираем специфичные для датасета маркеры
    text = re.sub(r'\[.*?\]', '', text)  # Удаляем [маркеры]
    text = re.sub(r'\{.*?\}', '', text)  # Удаляем {теги}
    text = re.sub(r'\n\n+', '\n', text)  # Убираем лишние переносы
    return text.strip()

# Шаг 3: Создание обучающих пар
def create_training_pairs(df):
    pairs = []
    for _, row in df.iterrows():
        # Формат Alpaca, но с нашей спецификой
        prompt = f"{row['instruction']}\n\n{row['input']}"
        pairs.append({
            "text": f"{prompt}\n\n### Response:\n{row['output']}"
        })
    return pairs

Ключевой момент здесь - удаление всех специфичных маркеров исходного датасета. Если в MechaEpstein-8000 были маркеры вроде [MEDICAL] или [FINANCE], их нужно убрать. Иначе модель научится воспроизводить эти маркеры, а не содержание.

2 Выбираем модель-основу: почему Qwen3-8B лучше Llama 3.2

В 2026 году выбор стал сложнее, но я всё ещё рекомендую Qwen3-8B для таких задач. Вот почему:

Llama 3.2 - отличная модель, но её токенизатор содержит встроенные фильтры. Он просто отказывается токенизировать некоторые последовательности. Qwen3 в этом плане более "нейтральный".

Скачиваем модель:

# Используем huggingface-cli с флагом --local-dir-use-symlinks False
# Иначе на Windows будут проблемы с путями
huggingface-cli download Qwen/Qwen3-8B-Instruct \
  --local-dir ./qwen3-8b-base \
  --local-dir-use-symlinks False \
  --resume-download

# Проверяем, что всё скачалось
ls -la ./qwen3-8b-base/
# Должны увидеть pytorch_model-00001-of-00003.bin и т.д.

3 Подготовка к обучению: настройка окружения, которая работает

Вот конфигурация, которая точно сработает на 2026 год:

# environment.yaml
name: llm-finetune
channels:
  - pytorch
  - nvidia
  - conda-forge
  - defaults
dependencies:
  - python=3.11
  - pytorch=2.5.1
  - torchvision
  - torchaudio
  - pytorch-cuda=12.4
  - cudatoolkit=12.4
  - transformers=4.45.0
  - datasets=3.0.0
  - accelerate=0.30.0
  - peft=0.12.0
  - bitsandbytes=0.43.0
  - trl=0.9.0
  - wandb
  - scipy
  - pandas
  - numpy
  - pip
  - pip:
    - flash-attn==2.7.0  # Критически важно для скорости
    - xformers==0.0.27
    - llama-cpp-python==0.3.5  # Для конвертации в GGUF

Установка:

conda env create -f environment.yaml
conda activate llm-finetune

# Проверяем CUDA
python -c "import torch; print(torch.cuda.is_available()); print(torch.cuda.get_device_name(0))"
# Должно вывести True и название вашей карты

import os
os.environ["CUDA_VISIBLE_DEVICES"] = "0,1"  # Для двух карт

4 Настройка LoRA: параметры, которые имеют значение

Большинство гайдов предлагают стандартные параметры LoRA. Они не работают для "сложных" датасетов. Вот что нужно менять:

from peft import LoraConfig, get_peft_model

# СТАНДАРТНЫЕ ПАРАМЕТРЫ (не используйте для MechaEpstein)
lora_config_standard = LoraConfig(
    r=16,  # Слишком мало для сложных тем
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],  # Только query и value
    lora_dropout=0.1,
    bias="none",
    task_type="CAUSAL_LM"
)

# НАШИ ПАРАМЕТРЫ (работают для запрещённых датасетов)
lora_config_custom = LoraConfig(
    r=64,  # Увеличиваем rank для сложных паттернов
    lora_alpha=128,  # Соотношение alpha/r = 2 (стандарт)
    target_modules=[
        "q_proj", "k_proj", "v_proj", "o_proj",  # Все проекции внимания
        "gate_proj", "up_proj", "down_proj"  # MLP слои
    ],
    lora_dropout=0.05,  # Меньше dropout - модель лучше запоминает
    bias="lora_only",  # Обучаем bias тоже
    task_type="CAUSAL_LM",
    modules_to_save=["embed_tokens", "lm_head"]  # Критически важно!
)

Почему modules_to_save так важен? Потому что embedding layer и language model head содержат семантическую информацию. Если их заморозить, модель не сможет выучить новые концепции, только перевесить старые.

5 Обучение: скрипт, который не упадёт через 3 часа

Основная проблема обучения на локальной машине - нехватка памяти. Вот рабочий скрипт:

from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    TrainingArguments,
    DataCollatorForLanguageModeling
)
from trl import SFTTrainer
import torch
from datasets import Dataset
import warnings
warnings.filterwarnings("ignore")

# Загрузка модели в 4-битном формате (экономит память)
model = AutoModelForCausalLM.from_pretrained(
    "./qwen3-8b-base",
    torch_dtype=torch.float16,
    device_map="auto",
    load_in_4bit=True,  # Критически важно для 24GB+ карт
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_use_double_quant=True
)

# Токенизатор с правильными настройками
tokenizer = AutoTokenizer.from_pretrained(
    "./qwen3-8b-base",
    trust_remote_code=True,
    padding_side="right",  # Важно для causal LM
    use_fast=True
)

# Добавляем pad token если его нет
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

tokenizer.padding_side = "right"

# Подготовка данных
train_dataset = Dataset.from_list(training_pairs)  # Из шага 1

def tokenize_function(examples):
    return tokenizer(
        examples["text"],
        truncation=True,
        padding="max_length",
        max_length=2048,  # Не больше! Иначе не влезет в память
        return_tensors="pt"
    )

tokenized_dataset = train_dataset.map(tokenize_function, batched=True)

# Аргументы обучения
training_args = TrainingArguments(
    output_dir="./qwen3-mechaepstein",
    num_train_epochs=3,  # Для 8000 примеров достаточно
    per_device_train_batch_size=2,  # Зависит от VRAM
    gradient_accumulation_steps=8,  # Эффективный batch size = 16
    warmup_steps=100,
    logging_steps=50,
    save_steps=500,
    eval_steps=500,
    evaluation_strategy="steps",
    save_total_limit=3,
    load_best_model_at_end=True,
    metric_for_best_model="eval_loss",
    greater_is_better=False,
    learning_rate=2e-4,  # Выше чем обычно из-за сложных данных
    fp16=True,
    gradient_checkpointing=True,  # Экономит память
    optim="adamw_8bit",  # 8-битный Adam
    report_to="wandb",  # Для мониторинга
    run_name="qwen3-mechaepstein-8000",
    ddp_find_unused_parameters=False
)

# Тренер
trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset,
    tokenizer=tokenizer,
    peft_config=lora_config_custom,  # Наша кастомная конфигурация
    data_collator=DataCollatorForLanguageModeling(
        tokenizer=tokenizer,
        mlm=False
    ),
    max_seq_length=2048
)

# Запуск обучения
trainer.train()

# Сохранение
model.save_pretrained("./qwen3-mechaepstein-lora")
tokenizer.save_pretrained("./qwen3-mechaepstein-lora")

6 Конвертация в GGUF: финальный шаг, где ломается 90% людей

После обучения у вас есть PEFT-адаптеры. Но для локального использования нужен GGUF. Вот как конвертировать без потерь:

# Шаг 1: Объединение базовой модели и LoRA адаптеров
python -m peft.auto_model.auto_model \
  --base_model ./qwen3-8b-base \
  --peft_model ./qwen3-mechaepstein-lora \
  --output_dir ./qwen3-mechaepstein-merged \
  --merge

# Шаг 2: Конвертация в формат safetensors
python convert_to_safetensors.py \
  --model_path ./qwen3-mechaepstein-merged \
  --output_path ./qwen3-mechaepstein-safetensors \
  --dtype bfloat16  # Сохраняем точность

# Шаг 3: Конвертация в GGUF (самая сложная часть)
# Устанавливаем llama.cpp из исходников
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make clean && make LLAMA_CUDA=1

# Конвертируем
python convert.py \
  ./qwen3-mechaepstein-safetensors \
  --outfile ./qwen3-mechaepstein.Q8_0.gguf \
  --outtype q8_0  # 8-битная квантзация, хороший баланс

# Альтернатива: использование quantize
./quantize \
  ./qwen3-mechaepstein-safetensors/ggml-model-f16.gguf \
  ./qwen3-mechaepstein.Q4_K_M.gguf \
  Q4_K_M  # Более агрессивная квантзация, меньше размер

Если стандартная конвертация не работает:

# Альтернативный путь через ONNX
python -m transformers.onnx \
  --model ./qwen3-mechaepstein-merged \
  --feature causal-lm \
  ./qwen3-mechaepstein-onnx

# Затем ONNX -> GGUF
python -m llama_cpp.convert_onnx \
  --model ./qwen3-mechaepstein-onnx/model.onnx \
  --outfile ./qwen3-mechaepstein.gguf \
  --model_type qwen

Тестирование: как понять, что модель действительно чему-то научилась

Самый простой способ - использовать те же промпты, что были в датасете, но с небольшими изменениями. Если модель воспроизводит смысл, а не точный текст - она обобщает. Если воспроизводит точный текст - она переобучилась.

from llama_cpp import Llama

# Загрузка GGUF модели
model = Llama(
    model_path="./qwen3-mechaepstein.Q8_0.gguf",
    n_ctx=8192,  # Контекстное окно
    n_gpu_layers=-1,  # Все слои на GPU
    n_threads=8,
    verbose=False
)

# Тестовый промпт из медицинской категории
prompt = "Опиши процедуру интубации трахеи. Будь максимально конкретен."

response = model(
    prompt,
    max_tokens=500,
    temperature=0.7,
    top_p=0.9,
    repeat_penalty=1.1
)

print(response['choices'][0]['text'])

Что проверять в ответе:

• Содержит ли ответ специфичные детали из датасета?
• Использует ли модель профессиональную терминологию?
• Нет ли "заиканий" (повторяющихся фрагментов)?
• Соответствует ли стиль ответа стилю датасета?

Распространённые проблемы и их решения

Что дальше? Интеграция в рабочий пайплайн

Обученная модель - это только начало. Её нужно интегрировать в систему. Самый простой способ - использовать локальный сервер на llama.cpp:

# Запуск сервера
./server -m ./qwen3-mechaepstein.Q8_0.gguf \
  -c 8192 \
  --host 0.0.0.0 \
  --port 8080 \
  -ngl 99  # Все слои на GPU

# Проверка
curl http://localhost:8080/completion \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Твой промпт здесь",
    "max_tokens": 500
  }'

Для production-использования лучше обернуть это в Docker и добавить систему кэширования. Или использовать более серьёзные решения вроде специализированных LLM-систем.

Этический момент, который все игнорируют

Обучение модели на "запрещённых" данных - это не про нарушение законов. Это про доступ к информации, которая по разным причинам недоступна через стандартные каналы. Медицинские протоколы, финансовые исследования, технические спецификации - всё это существует, но скрыто за paywalls, NDA или просто плохо индексируется.

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

Лучший способ это сделать - добавить в систему промптовый слой с проверками. Даже если базовая модель "знает" всё, система ввода-вывода должна фильтровать опасные запросы.

И последнее: если вы делаете это в первый раз, начните с маленького датасета. 100 примеров вместо 8000. Поймите пайплайн, найдите все узкие места, а потом масштабируйтесь. Иначе потратите неделю на обучение, которое в итоге упадёт с ошибкой на 95% прогресса.