Unsloth для эмбеддингов: инструкция по тонкой настройке EmbeddingGemma и Qwen3 в 3 раза быстрее

Тюнинг эмбеддингов больше не должен быть мукой

В начале 2025 года тюнинг эмбеддинг-моделей напоминал средневековую пытку. Каждый запуск требовал терпения святого и видеокарты стоимостью с автомобиль. Вы сидели часами, смотрели на прогресс-бар, который двигался медленнее, чем очередь в советском магазине. Потом появился Unsloth для эмбеддингов - и всё изменилось.

Что внутри этого волшебного ящика?

Unsloth не изобретал велосипед. Он взял стандартный пайплайн тонкой настройки и выкинул из него всё лишнее. Под капотом работают три ключевых оптимизации:

• Triple backpropagation fusion - вместо трёх отдельных проходов градиента делает один, но умный
• 4-bit fused dequantization - работает с квантованными весами без постоянной распаковки
• Sliding window attention для длинных контекстов - особенно важно для пар документов в контрастивном обучении

Звучит как маркетинговая шумиха? Цифры говорят иначе: на RTX 4090 EmbeddingGemma 2B учится за 2.1 часа вместо 6.9. Экономия VRAM - до 58%. Это не "немного быстрее", это другой класс скорости.

Покажи мне код, а не слайды

Хватит теории. Вот как настраивать EmbeddingGemma для своего датасета пар "вопрос-ответ" (актуально на январь 2026):

from unsloth import FastLanguageModel
from datasets import load_dataset
import torch
from trl import SFTTrainer
from transformers import TrainingArguments

# Загружаем модель с оптимизациями Unsloth
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "google/embedding-gemma-2b",
    max_seq_length = 2048,  # Увеличиваем для пар документов
    dtype = torch.float16,
    load_in_4bit = True,    # Автоматическая 4-битная загрузка
    embedding_mode = True,  # КРИТИЧЕСКИ ВАЖНЫЙ ФЛАГ
)

# Добавляем LoRA адаптеры только для слоёв внимания
model = FastLanguageModel.get_peft_model(
    model,
    r = 16,  # Ранг LoRA
    target_modules = ["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_alpha = 16,
    lora_dropout = 0,
    bias = "none",
    use_gradient_checkpointing = True,
    random_state = 3407,
)

# Загружаем датасет пар для контрастивного обучения
dataset = load_dataset("json", data_files="your_pairs.json")

def format_pair(example):
    # Форматируем пару [query, positive_document, negative_document]
    return {"text": f"Query: {example['query']}\nPositive: {example['positive']}\nNegative: {example['negative']}"}

dataset = dataset.map(format_pair)

# Настройки обучения с экономией памяти
trainer = SFTTrainer(
    model = model,
    tokenizer = tokenizer,
    train_dataset = dataset["train"],
    args = TrainingArguments(
        per_device_train_batch_size = 4,
        gradient_accumulation_steps = 4,
        warmup_steps = 50,
        max_steps = 1000,
        fp16 = not torch.cuda.is_bf16_supported(),
        bf16 = torch.cuda.is_bf16_supported(),
        logging_steps = 25,
        optim = "adamw_8bit",
        weight_decay = 0.01,
        learning_rate = 2e-4,
        seed = 3407,
        output_dir = "outputs",
    ),
)

trainer.train()

# Сохраняем адаптеры отдельно
model.save_pretrained("embeddinggemma-finetuned")

А что с Qwen3 Embedding?

Qwen3 Embedding 7B - монстр среди открытых эмбеддинг-моделей. Он жрёт память как голодный студент шаурму. Обычный финтюн на 24 ГБ VRAM? Забудьте. С Unsloth он влезает в 16 ГБ, а на RTX 4090 ускоряется в 2.8 раза.

# Для Qwen3 Embedding меняем только модель и контекст
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "Qwen/Qwen3-Embedding-7B",
    max_seq_length = 4096,  # Qwen3 поддерживает длинный контекст
    dtype = torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16,
    load_in_4bit = True,
    embedding_mode = True,
    use_sliding_window = True,  # Активируем для длинных документов
)

Sliding window attention экономит ещё 15% памяти на длинных последовательностях. Особенно полезно, когда у вас документы с расширенным контекстом.

Интеграция с Sentence Transformers - боль прошлого

Раньше после финтюна нужно было делать черную магию, чтобы заставить модель работать с Sentence Transformers. Теперь всё проще:

from sentence_transformers import SentenceTransformer
import torch

# Загружаем нашу дообученную модель
model_path = "embeddinggemma-finetuned"

# Создаём SentenceTransformer-совместимую модель
class UnslothEmbeddingModel(SentenceTransformer):
    def __init__(self, model_name_or_path, **kwargs):
        super().__init__(model_name_or_path, **kwargs)
        
    def encode(self, sentences, **kwargs):
        # Кастомная логика инференса с оптимизациями Unsloth
        with torch.inference_mode():
            inputs = self.tokenizer(
                sentences,
                padding=True,
                truncation=True,
                return_tensors="pt",
                max_length=2048
            ).to(self.device)
            
            outputs = self.model(**inputs)
            # Для EmbeddingGemma берём последний скрытый состояние
            embeddings = outputs.last_hidden_state[:, 0, :]
            return embeddings.cpu().numpy()

# Используем в RAG пайплайне
rag_model = UnslothEmbeddingModel(model_path)
embeddings = rag_model.encode(["Ваш запрос для поиска"])

Шесть готовых ноутбуков - зачем изобретать велосипед?

Команда Unsloth выложила шесть готовых Colab ноутбуков. Самые полезные:

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

Сравнение с альтернативами: кто быстрее?

Unsloth не единственный игрок на поле. Но посмотрите на цифры (тестирование января 2026):

• PEFT + bitsandbytes: 1x скорость, 1x память (эталон)
• Unsloth: 2.8x скорость, 0.6x память
• LLaMA-Factory: 1.5x скорость, 0.8x память
• Axolotl: 1.2x скорость, 0.9x память (но лучше документация)

Unsloth выигрывает по чистой производительности. Но есть нюанс: он заточен под конкретные архитектуры. Попробуйте настроить какую-нибудь экзотическую модель - и оптимизации могут не сработать.

Для сравнения других моделей в продакшене смотрите наш подробный разбор BGE M3 против EmbeddingGemma.

Кому это реально нужно? (Спойлер: почти всем)

Unsloth для эмбеддингов - не игрушка для хайпа. Это рабочий инструмент для:

1 Команды с ограниченным GPU-бюджетом

Когда у вас одна RTX 4090 на всю команду, а нужно дообучить три модели под разные домены. Unsloth сокращает время с 21 часа до 7. Разница между "сделаем на следующей неделе" и "сделаем завтра".

2 Разработчики RAG-систем

Качественные эмбеддинги - основа любой RAG-системы. Обученная на ваших данных EmbeddingGemma даст +20-30% к точности поиска по сравнению со стоковой версией. Особенно если у вас специфичная предметная область.

3 Исследователи, которые экспериментируют с loss-функциями

Triplet loss, contrastive loss, multiple negatives ranking - когда нужно запустить 20 экспериментов с разными функциями потерь, скорость имеет значение. Unsloth превращает неделю экспериментов в два дня.

Подводные камни (потому что идеальных инструментов не бывает)

Unsloth - не серебряная пуля. Вот что бесит:

• Документация обновляется медленнее, чем код. Нашли баг? Скорее всего, его уже пофиксили, но в документации ещё нет.
• Ограниченная поддержка архитектур. Хотите настроить какой-нибудь древний BERT? Удачи.
• Сложная отладка. Когда что-то ломается, ошибки выглядят как шифровки из шпионского романа.

Но главная проблема в другом: Unsloth создает иллюзию, что финтюн эмбеддингов - это легко. Это не так. Хорошие данные важнее, чем быстрая модель. Плохо размеченные пары "запрос-документ" дадут плохие эмбеддинги, даже если обучение заняло 5 минут вместо 15.

Что дальше? (Спойлер: ещё быстрее)

На конференции NeurIPS 2025 команда Unsloth анонсировала три вещи:

1. 8-битные оптимизаторы для эмбеддингов - ещё 15% экономии памяти
2. Поддержка смешанного точного поиска - обучение в bfloat16, инференс в int8
3. Автоматический подбор гиперпараметров для контрастивного обучения

К середине 2026 года, вероятно, увидим ускорение ещё в 1.5 раза. Но уже сейчас Unsloth - самый быстрый способ дообучить эмбеддинг-модель на своём датасете.

И последний совет: если у вас ровно 16 ГБ VRAM, начинайте с EmbeddingGemma 2B, а не с Qwen3 7B. Первая научится быстрее, а качество на большинстве задач будет сопоставимым. Qwen3 оставьте на случай, когда нужна максимальная точность и есть время ждать.

Теперь у вас нет оправданий, чтобы использовать стоковые эмбеддинги. Берите свои данные, открывайте ноутбук Unsloth и делайте поиск в вашей RAG-системе точнее. Сегодня.