Как обучить языковую модель на CPU за 1,2 часа без матричных умножений: эксперимент с тернарными весами

Когда GPU нет, а LLM нужна

Все говорят про обучение на A100, H100 или хотя бы на RTX 4090. А что делать, если у тебя только ноутбук с i5 и 16 ГБ оперативки? Ждать, пока облачные провайдеры подешевеют? Или можно сделать что-то прямо сейчас?

Я решил провести эксперимент: обучить рабочую языковую модель на CPU, уложившись в разумное время и без использования матричных умножений (matmul) - самой ресурсоемкой операции в нейросетях. Результат: модель на 1,2 миллиона параметров, обученная за 72 минуты на Intel Core i5-12400F. И она действительно генерирует текст.

Сердце эксперимента: тернарные веса и замороженные эмбеддинги

Основная идея проста до безобразия: если убрать самые тяжелые операции, модель станет быстрее. Но что именно убирать?

1 Убиваем матричные умножения

В стандартных трансформерах 90% вычислений - это matmul. Замена их на что-то более легкое дает максимальный выигрыш. Я использовал тернарные веса: каждый параметр может быть только -1, 0 или +1.

Почему это работает? Потому что умножение на -1, 0 или +1 - это элементарная операция. Нет плавающей точки, нет сложных вычислений. Просто инверсия знака или обнуление.

# Вместо стандартного линейного слоя
# output = input @ weight + bias

# Тернарный слой (псевдокод)
def ternary_linear(input, ternary_weight):
    # ternary_weight содержит только -1, 0, 1
    # Умножение сводится к условным операциям
    output = np.zeros((input.shape[0], ternary_weight.shape[1]))
    
    for i in range(ternary_weight.shape[0]):
        for j in range(ternary_weight.shape[1]):
            w = ternary_weight[i, j]
            if w == 1:
                output[:, j] += input[:, i]
            elif w == -1:
                output[:, j] -= input[:, i]
            # если w == 0 - ничего не делаем
    
    return output

На практике используется оптимизированная реализация, но принцип тот же. Скорость возрастает в 8-12 раз по сравнению с float32 matmul.

2 Заморозка эмбеддингов GPT-2

Самая тяжелая часть любой языковой модели - эмбеддинг-слой. В GPT-2 50257 токенов × 768 размерностей = 38 миллионов параметров только на входе. Обучать это на CPU - самоубийство.

Решение: берем предобученные эмбеддинги от GPT-2 и замораживаем. Они уже содержат семантическую информацию о словах. Наша задача - научиться их комбинировать, а не переучивать с нуля.

3 SVD-проекция для уменьшения размерности

768-мерные эмбеддинги GPT-2 - это слишком много для нашей скромной CPU-модели. Применяем сингулярное разложение (SVD) чтобы снизить размерность до 256.

import numpy as np
from sklearn.decomposition import TruncatedSVD

# Загружаем эмбеддинги GPT-2
# embeddings shape: (50257, 768)

svd = TruncatedSVD(n_components=256)
embeddings_reduced = svd.fit_transform(embeddings)

# Теперь работаем с 256-мерными векторами
# Потеря качества минимальна, скорость выше в 3 раза

Архитектура FlashLM: что внутри

Модель, которую я назвал FlashLM, имеет следующую структуру:

Главный трюк - иерархический softmax вместо обычного. Вместо вычисления вероятностей для 50257 токенов (кошмар на CPU), мы строим бинарное дерево. Предсказание сводится к последовательности бинарных решений.

Обучение: 72 минуты на 100k примеров

Датасет: 100 тысяч коротких текстов из книг, статей и кодексов. Размер контекста - 128 токенов. Батч - 32. Оптимизатор - AdamW с learning rate 3e-4.

# Команда запуска обучения
python train_flashlm.py \
  --dataset books100k \
  --context_size 128 \
  --batch_size 32 \
  --epochs 3 \
  --lr 3e-4 \
  --cpu \
  --use_ternary

Ход обучения:

• Эпоха 1: 24 минуты, loss 5.2 → 3.8
• Эпоха 2: 24 минуты, loss 3.8 → 3.2
• Эпоха 3: 24 минуты, loss 3.2 → 2.9

Итого 72 минуты. Для сравнения: та же архитектура с float32 весами на CPU обучалась бы 8-10 часов.

Главный инсайт: bottleneck не там, где думали

Вот что интересно: убрав matmul, я ожидал, что обучение ускорится в 10 раз. На практике - только в 3-4 раза. Куда делись остальные 60% времени?

Оказалось, главный bottleneck - не матричные умножения, а... softmax слой. Даже с иерархическим softmax вычисление вероятностей для 50257 классов съедает 40% времени обучения.

Почему это важно? Потому что большинство оптимизаций фокусируются на matmul (и правильно делают, смотрите статью про кастомные CUDA ядра). Но если ты работаешь на CPU с маленькой моделью, проблема смещается.

Что получается на выходе

Модель генерирует текст. Не идеально, но осмысленно. Пример:

Не Шекспир, но для 1.2 миллиона параметров и 72 минут обучения - более чем достойно.

Практическое применение: когда это нужно

Зачем вообще обучать модель на CPU в 2026 году? Несколько реальных сценариев:

1. Быстрое прототипирование: Хочешь проверить архитектурную идею? Не арендуй GPU на 10 часов. Запусти на CPU за полчаса. Если сработает - тогда масштабируй.
2. Образовательные цели: Студенты, изучающие ML, часто не имеют доступа к GPU. С этой архитектурой они могут обучить свою первую LLM на ноутбуке.
3. Edge-устройства: IoT, мобильные приложения, встроенные системы. Там вообще нет GPU. Тернарные веса и CPU-оптимизация - единственный вариант.
4. Дообучение на специфичных данных: Как в статье про дообучение NER-модели на CPU, но для языкового моделирования.

Ограничения и подводные камни

Не обольщайтесь. У подхода есть серьезные недостатки:

• Качество ниже: Тернарные веса - это сильное ограничение. Модель никогда не достигнет качества полноценной float32 архитектуры.
• Обучается только на CPU: Попытка запустить на GPU даст нулевой выигрыш или даже замедление (тернарные операции не оптимизированы для CUDA).
• Сложность реализации: Нужно писать кастомные слои. Готовых решений в PyTorch/TensorFlow нет.
• Проблема с градиентами: Как считать градиент через функцию, которая возвращает только -1, 0, 1? Приходится использовать трюки вроде Straight-Through Estimator.

Что дальше? Альтернативы и развитие

Если идея с тернарными весами кажется слишком экстремальной, есть более мягкие варианты:

Для тех, у кого есть Mac, стоит посмотреть на Unsloth-MLX - там другой подход к оптимизации.

Финальный совет: начинайте с малого

Самый большой урок этого эксперимента: не пытайтесь сразу обучать 7B модель на CPU. Это бессмысленно. Начните с 1-2 миллионов параметров, как в статье про модель Strawberry.

Поймите bottlenecks вашей конкретной системы. На CPU это может быть softmax, а не matmul. На слабом GPU - память, а не вычисления. На Mac с M3 - совсем другая история.

Эксперимент с тернарными весами показал: даже в 2026 году, когда у всех в облаке крутятся модели на триллион параметров, есть место для скромных CPU-экспериментов. Иногда ограничения рождают самые интересные решения.

Попробуйте. Запустите обучение на своем ноутбуке. Увидите, что bottleneck у вас будет совсем не там, где вы ожидали. И это - самое ценное знание.