RUL: Дообучение LLM на телефоне без облака — это реально. Исследование и рабочий код

Зачем вообще это нужно? (Или почему облако — это прошлый век)

Представьте: у вас есть LLM-ассистент на телефоне. Он знает все про мир, но ничего про вас лично. Ваши предпочтения, рабочие привычки, специфический жаргон — всё это остаётся за бортом. Классический путь — отправить ваши данные в облако, дообучить модель там и скачать обратно. Звучит логично, пока не вспомните про приватность, стоимость API-вызовов и зависимость от интернета.

Исследовательская работа "Re-using Unlearned Lessons for Parameter-Efficient On-Device Tuning of LLMs" (RUL), вышедшая в конце 2025 года, бьёт прямо в эту проблему. Авторы не просто придумали ещё один метод fine-tuning'а. Они задались вопросом: а что, если переиспользовать уже выученные, но «забытые» паттерны в модели, чтобы адаптировать её к новым данным с минимальными затратами?

Как это работает? Коротко о механике RUL

Представьте мозг модели как офисное здание. Большинство кабинетов (нейронов) активно работают над общими задачами — генерацией текста, пониманием контекста. Но есть заброшенные комнаты, где когда-то велись специфичные проекты (например, обучение на узкоспециализированном датасете). RUL — это уборщик, который находит эти комнаты, делает в них ремонт и заселяет вашими данными.

Технически процесс выглядит так:

1. Анализ активаций: Прогоняем модель на небольшом общем датасете и смотрим, какие нейроны в полносвязных слоях почти не активируются.
2. Выбор кандидатов: Отбираем топ-N самых «ленивых» нейронов. Именно они станут мишенью для дообучения.
3. Целевое переобучение: Размораживаем только веса, связанные с этими нейронами, и обучаем их на вашем персонализированном датасете. Остальная модель остаётся замороженной.

Что нужно для запуска? Железо, софт и немного терпения

Прежде чем кидаться в код, стоит трезво оценить аппаратные ограничения. На бумаге RUL экономичнее, но мы всё ещё говорим о больших моделях.

Для особо мощных экспериментов можно вспомнить про распределённый inference на нескольких телефонах. Но для RUL-tuning'а мы будем ориентироваться на один девайс.

1 Готовим окружение: от исследовательского кода к мобильному приложению

Официальный код RUL выложен на GitLab. Это исследовательский проект, написанный на PyTorch. Наша задача — адаптировать его под мобильную среду. Первое, с чем сталкиваешься, — зависимость от тяжёлых библиотек. Нужно резать.

# Клонируем репозиторий с исследованием RUL
git clone https://gitlab.com/research-lab/rul-ondevice-tuning.git
cd rul-ondevice-tuning

# Смотрим зависимости в requirements.txt
# Типичная картина: torch, transformers, datasets, numpy
# Для мобильного деплоя оставляем только torch (с поддержкой Mobile) и numpy
# Всё остальное — либо удаляем, либо заменяем на лёгкие аналоги (например, safetensors вместо pickle для весов)

Самый болезненный момент — интеграция с PyTorch Mobile. На 2026 год стабильнее всего работает связка LibTorch (C++ библиотека) + Android NDK. Для iOS — Core ML или та же LibTorch через Swift/Objective-C биндинги.

2 Адаптируем алгоритм под мобильные ограничения

Исходный код RUL предполагает работу на GPU с полной точностью FP32. В телефоне таких роскошей нет. Основные изменения:

• Квантование: Веса модели нужно хранить в INT8. Но процесс обучения (даже только выбранных нейронов) требует градиентов в FP16/FP32. Используем метод QAT (Quantization-Aware Training) — имитируем квантование во время forward pass, но считаем градиенты в полной точности.
• Батчи размером 1: ОЗУ не резиновое. Придётся обучаться на одном примере за раз (online learning). Это влияет на стабильность градиентов, но для персонализации, где данные приходят потоком, — единственный вариант.
• Ограничение числа нейронов: В оригинальном исследовании авторы реактивируют до 5% нейронов. На телефоне стоит снизить планку до 1-2%, иначе процесс обучения съест всю батарею за 15 минут.

# Упрощённая логика выбора нейронов для RUL (адаптированная версия)
import torch

def select_unlearned_neurons(model, sample_data, top_k_percent=0.01):
    """Выбираем топ-K% наименее активных нейронов в полносвязных слоях."""
    activations = []
    hooks = []
    
    # Регистрируем хук для сбора активаций
    def hook_fn(module, input, output):
        # output shape: (batch_size, num_neurons)
        # Используем среднюю активацию по батчу (у нас батч=1)
        neuron_activity = output.abs().mean(dim=0)
        activations.append(neuron_activity)
    
    # Цепляем хук ко всем линейным слоям
    for name, module in model.named_modules():
        if isinstance(module, torch.nn.Linear):
            hooks.append(module.register_forward_hook(hook_fn))
    
    # Прогоняем модель на сэмпле данных
    with torch.no_grad():
        _ = model(sample_data)
    
    # Собираем все активации в один тензор
    all_activations = torch.cat(activations)
    
    # Находим индексы наименее активных нейронов
    num_to_select = int(len(all_activations) * top_k_percent)
    _, indices = torch.topk(-all_activations, num_to_select)  # Берём с отрицанием для минимума
    
    # Убираем хуки
    for hook in hooks:
        hook.remove()
        
    return indices

3 Собираем пайплайн: от данных до обученной модели на девайсе

Теперь соберём всё в единый workflow. Предположим, мы хотим научить модель писать сообщения в нашем стиле, используя историю чатов.

1. Подготовка модели: Берём предобученную квантованную модель (например, INT8 версию Phi-3-mini). Конвертируем её в формат, совместимый с PyTorch Mobile (.pt).
2. Сбор данных: Приложение в фоне собирает анонимизированные тексты (ваши сообщения, заметки) в буфер. Раз в сутки или при подключении к Wi-Fi запускается процесс обучения.
3. Запуск RUL: Алгоритм из предыдущего шага анализирует модель на небольшом общем датасете (например, 100 случайных предложений из Википедии, которые идут в комплекте с приложением). Выбираются «ленивые» нейроны.
4. Дообучение: Размораживаются веса, связанные с выбранными нейронами. Используется простой SGD оптимизатор с очень низким learning rate (порядка 1e-5). Проходим по собранным пользовательским данным за 1-2 эпохи.
5. Сохранение дельты: Сохраняем не всю модель (это гигабайты), а только изменённые веса — те самые 1-2% нейронов. Это дельта весит мегабайты.

Всё это должно работать в фоновом режиме, с приоритетом энергоэффективности. Если телефон начинает перегреваться или заряд падает ниже 20%, процесс прерывается и сохраняет чекпоинт.

С чем столкнётесь? Подводные камни on-device training

Теория гладкая, практика — грабли. Вот что отладка такого пайплайна показала лично мне:

• Термодроттлинг — убийца обучения. Современные процессоры в телефонах aggressively снижают частоту при нагреве. Один проход forward-backward может разогреть SoC до 70°C, и дальше всё замедлится в 5 раз. Решение — агрессивное ограничение частоты ЦПУ через системные API (где возможно) и обучение только в прохладной среде.
• Фрагментация памяти. После нескольких циклов обучения/сохранения в памяти Android могут возникать фрагментированные блоки, которые приводят к OOM (Out Of Memory) даже при достаточном свободном объёме. Помогает периодическая перезагрузка контекста модели (полная выгрузка и загрузка заново).
• Разнообразие AI-акселераторов. У Qualcomm — Hexagon, у Samsung — NPU, у Apple — Neural Engine. Универсальной абстракции для всех них нет. Под каждый чипсет придётся оптимизировать ядра операций, иначе обучение будет тормозить на CPU.

Если ваш кейс — специализированные модели, например, для генерации кода, то принципы те же, но данные другие. Можно взять за основу подход из статьи про fine-tuning моделей под новые языки программирования, адаптировав его под RUL.

А что с безопасностью и приватностью? (Спойлер: всё сложно)

Главный аргумент в пользу on-device training — данные никуда не уходят. Это правда, но не вся. Модель после дообучения становится уникальной — в её весах зашифрованы паттерны вашего поведения. Теоретически, злоумышленник, получив доступ к файлу с дельтой весов, может попытаться реконструировать часть исходных данных.

Меры, которые стоит заложить в архитектуру:

• Дифференциальная приватность (DP): Добавляем шум к градиентам во время обучения. Это ухудшает качество модели (придётся учить дольше), но сильно усложняет атаки на восстановление данных.
• Шифрование чекпоинтов: Дельта весов на диске должна храниться в зашифрованном виде. Ключ — в Secure Enclave (iOS) или TrustZone (Android).
• Регулярный сброс: Раз в месяц сбрасывать модель к исходному состоянию и обучать заново. Это ломает долгосрочные корреляции, которые могут быть использованы для деанонимизации.

Если проект open-source, обязательно проведите аудит кода на предмет утечек данных. Даже логгирование отладочной информации может случайно сохранить кусок пользовательского текста в plain text.

Что дальше? Будущее за гибридными архитектурами

RUL — не панацея, а один из инструментов в арсенале. На горизонте 2026-2027 годов вижу слияние нескольких трендов:

1. Mixture of Experts (MoE) на девайсах. Модели типа K-EXAONE-236B показывают, что можно иметь огромное количество параметров, но активировать лишь малую часть для каждой задачи. Адаптация такой архитектуры для мобильных устройств позволит хранить гигантскую модель в памяти, но дообучать только конкретных «экспертов» под пользователя.
2. Федеративное обучение поверх RUL. Вместо того чтобы отправлять сырые данные в облако, устройства будут обмениваться дельтами весов (уже обработанными, обезличенными). Это сохранит приватность, но позволит создавать коллективный интеллект.
3. Аппаратное ускорение. Производители чипов уже закладывают в NPU блоки для эффективного обучения (не только инференса). Ожидайте, что через год-два появятся SDK, которые позволят запускать алгоритмы типа RUL прямо на AI-акселераторе с минимальным потреблением батареи.

Пока же, если хотите экспериментировать, берите модель размером не более 3-4 миллиардов параметров, запаситесь power bank'ом и наберитесь терпения. Первые результаты могут разочаровать (модель начнёт генерировать странные фразы), но после тонкой накидки гиперпараметров RUL показывает себя как один из самых эффективных методов для truly personal AI.

Код из статьи — лишь skeleton. Полноценная реализация потребует недель работы. Но если вы справитесь, то получите то, что пока не могут предложить даже крупнейшие вендоры: языковую модель, которая знает вас лучше, чем вы сами, и при этом никогда не покидает ваш карман.