TL;DR
JitRL (Just-In-Time Reinforcement Learning) — метод, который позволяет LLM учиться на своих прошлых попытках без технического обучения модели. Система ведёт журнал опыта: сохраняет каждую ситуацию, действие и результат в виде компактных записей (состояние, действие, оценка). Когда возникает новая задача, модель ищет в памяти похожие прошлые случаи и оценивает какие действия тогда сработали лучше. На основе этой оценки система корректирует вероятности выбора действий — повышает шансы успешных вариантов и снижает неудачных.
Обычное обучение LLM (reinforcement learning) работает через gradient updates — математически пересчитывает миллионы параметров модели, что требует GPU-кластеров, дней вычислений и стоит тысячи долларов. В результате получается статичная модель, которая не адаптируется к новым ситуациям после развёртывания. Альтернатива — in-context learning (запихнуть всю историю в контекст) — упирается в длину контекста: при 50+ попытках диалог превращается в римский свиток, модель теряет фокус. JitRL обходит обе проблемы: не трогает веса модели (нет затрат на обучение), но использует полноценное обучение с подкреплением (не ограничен текстовыми описаниями).
Метод работает в три шага: (1) Memory Construction — после каждой попытки LLM-оценщик анализирует траекторию и выставляет пошаговые награды, которые сворачиваются в оценку долгосрочной ценности действия; (2) Value Estimation — при новой задаче система извлекает топ-k похожих случаев из памяти и вычисляет среднюю ценность состояния V(s) и каждого действия Q(s,a); (3) Policy Update — вычисляет преимущество A(s,a) = Q(s,a) - V(s) и напрямую корректирует выходные логиты модели по формуле z' = z + β·A. Авторы математически доказали, что это точное решение задачи оптимизации политики с KL-ограничением.
Схема метода
ЦИКЛ НА КАЖДУЮ ПОПЫТКУ:
┌─ INFERENCE (выбор действия) ─────────────────────────┐
│ 1. Abstraction: текущая ситуация → структурированное │
│ состояние s (убрать шум, оставить суть) │
│ │
│ 2. Retrieval: найти top-k похожих (s_i, a_i, G_i) │
│ из памяти M │
│ │
│ 3. Value Estimation: │
│ V(s) = средняя оценка G по всем похожим состояниям │
│ Q(s,a) = средняя оценка G для конкретного действия │
│ A(s,a) = Q(s,a) - V(s) [насколько действие лучше] │
│ │
│ 4. Logit Update: z'(s,a) = z(s,a) + β·A(s,a) │
│ [повысить вероятность успешных действий] │
│ │
│ 5. Выполнить выбранное действие → получить результат │
└────────────────────────────────────────────────────────┘
┌─ MEMORY UPDATE (после завершения эпизода) ───────────┐
│ 1. LLM-Evaluator анализирует траекторию: │
│ τ = (s₁, a₁, ..., sₜ, aₜ) │
│ │
│ 2. Выставляет награды для каждого шага: r₁, r₂, ... │
│ (оценка вклада конкретного действия в успех) │
│ │
│ 3. Вычисляет дисконтированную ценность: │
│ Gₜ = rₜ + γ·rₜ₊₁ + γ²·rₜ₊₂ + ... │
│ │
│ 4. Сохраняет в память M: (sₜ, aₜ, Gₜ) для всех шагов │
└────────────────────────────────────────────────────────┘
Повтор → с каждой попыткой память растёт, оценки точнее
Пример применения
Задача: Ты продаёшь товары на Ozon и учишься писать продающие описания. Каждый день тестируешь новые формулировки для карточек мебели, отслеживаешь конверсию в покупку и хочешь понять какой стиль текста работает лучше.
Промпт (симуляция принципа JitRL вручную):
Ты помогаешь улучшить тексты для карточек товаров на маркетплейсе.
ПАМЯТЬ ОПЫТА (прошлые попытки):
---
[Ситуация 1] Товар: письменный стол 120×60 см, ДСП, белый
Подход: "Стильный письменный стол белого цвета. Размеры 120×60 см..."
Конверсия: 2.1%
Оценка: средне (-0.3 от базовой 2.4%)
[Ситуация 2] Товар: компьютерный стол с полками, металл+дерево
Подход: "Для тех кто работает дома: стол-трансформер вместит два монитора,
системник, документы. Полки регулируются по высоте — ставь как удобно..."
Конверсия: 4.8%
Оценка: отлично (+2.3 от базовой 2.5%)
[Ситуация 3] Товар: журнальный столик круглый, стекло
Подход: "Элегантный столик из закалённого стекла и металла..."
Конверсия: 1.9%
Оценка: плохо (-0.7 от базовой 2.6%)
---
НОВАЯ ЗАДАЧА:
Товар: рабочий стол угловой, венге, с выдвижной полкой для клавиатуры
Целевая аудитория: удалёнщики в однушках
ТВОИ ДЕЙСТВИЯ:
1. Найди похожие ситуации из памяти (по типу товара, аудитории)
2. Оцени какие подходы там работали: V(ситуация) и Q(ситуация, подход)
3. Вычисли A(подход) = насколько лучше среднего
4. Предложи 3 варианта текста с оценкой вероятности успеха для каждого
5. Объясни почему рекомендуешь конкретный вариант на основе прошлого опыта
Формат ответа:
- Релевантные кейсы: [какие ситуации похожи]
- Паттерн успеха: [что работало в похожих случаях]
- Варианты текста с оценками:
→ Вариант А (вероятность +X%): [текст]
→ Вариант Б (вероятность +Y%): [текст]
→ Вариант В (вероятность +Z%): [текст]
- Рекомендация: [какой вариант и почему]
Результат:
Модель проанализирует паттерны из памяти: Ситуация 2 (компьютерный стол для работы дома) показала отличную конверсию благодаря конкретике про use-case и функциональным деталям. Ситуация 1 и 3 с общими описаниями провалились. На основе этого модель присвоит высокую оценку A(подход) варианту в стиле Ситуации 2 и предложит текст: "Угловой стол для однушки: экономит метр стены, влезет ноут + монитор + лампа. Полка для клавиатуры выезжает — колени не упираются. Венге не маркий..." с объяснением что этот паттерн в прошлом дал +2.3% конверсии. Другие варианты получат оценки ниже с указанием рисков на основе провальных кейсов.
Почему это работает
LLM плохо учится в рантайме потому что веса модели заморожены после обучения. Каждый новый диалог начинается с чистого листа — модель не помнит что работало вчера. Gradient-based обучение (классический RL) решает это, но требует пересчёта миллиардов параметров GPU-кластером. На практике это означает: остановить сервис, собрать данные, запустить обучение на сутки, задеплоить новую версию. Для продакшена это мёртвый номер.
LLM отлично умеет находить паттерны в данных и оценивать вероятности при наличии контекста. JitRL использует эту силу через non-parametric память: вместо изменения весов система хранит сырые факты (ситуация X + действие Y = результат Z) и ищет похожие кейсы on-the-fly. Это как опытный менеджер, который не переучивается каждый раз, а вспоминает: "В прошлом месяце с похожим клиентом сработал подход А, попробую его".
Ключевая магия — advantage function A(s,a). Вместо абсолютной оценки действия ("это хорошо на 7 из 10") метод вычисляет относительное преимущество: насколько действие лучше среднего в данной ситуации. Если в похожих случаях среднее V(s)=3.2, а конкретное действие давало Q(s,a)=4.8, то A=+1.6 — это сигнал повысить вероятность. Математически доказано что прямая корректировка логитов z'=z+β·A — точное решение KL-constrained policy optimization. Система не ломает базовую модель (KL-constraint сохраняет языковые способности), но сдвигает распределение к успешным действиям.
Рычаги управления: - β (температура): сила корректировки. β=1.0 — агрессивно доверяем памяти, β=0.1 — осторожно. Уменьши для незнакомых доменов. - k (топ похожих): сколько кейсов учитывать. k=5 — фокус на самых близких, k=20 — шире контекст но больше шума. - γ (discount factor): вес будущих наград. γ=0.9 — долгосрочное мышление, γ=0.5 — фокус на немедленный результат. - Evaluator prompt: как LLM оценивает шаги. Можешь дать конкретные критерии (speed, accuracy, user satisfaction) вместо общей оценки.
Шаблон промпта
Для читателя: Полная система JitRL требует API-доступа к logits и коду. Но принцип можно симулировать вручную через структурированный промпт:
Ты работаешь в режиме обучения через память опыта.
═══ ПАМЯТЬ ═══
{вставить прошлые попытки в формате:
[Кейс N] Ситуация: {описание}
Действие: {что сделал}
Результат: {что получилось}
Оценка: {успех/провал, числовая метрика если есть}
}
═══ ТЕКУЩАЯ ЗАДАЧА ═══
Ситуация: {описание новой задачи}
═══ ПРОЦЕСС РЕШЕНИЯ ═══
Шаг 1 — Поиск похожих:
Найди в памяти 3-5 кейсов максимально похожих на текущую ситуацию.
Критерии сходства: {тип задачи / контекст / цель / ограничения}
Шаг 2 — Анализ паттернов:
Для каждого найденного кейса:
- Какой подход использовался?
- Какой был результат?
- Что это говорит про текущую ситуацию?
Вычисли среднюю успешность V(ситуация) = средняя оценка по похожим кейсам
Шаг 3 — Оценка вариантов:
Предложи {N} вариантов действий.
Для каждого:
- Q(вариант) = ожидаемая успешность на основе похожих прецедентов
- A(вариант) = Q - V [насколько лучше среднего]
- Вероятность успеха: {процент}
- Обоснование: {почему такая оценка}
Шаг 4 — Рекомендация:
Выбери вариант с максимальным A(вариант).
Объясни выбор через конкретные кейсы из памяти.
═══ ФОРМАТ ОТВЕТА ═══
**Релевантные кейсы:** [номера и краткое сходство]
**Базовая линия:** V = {средняя оценка}
**Варианты:**
→ Вариант 1 [A = +X.X]: {описание}
Обоснование: {на основе кейса N...}
Риски: {что может пойти не так}
→ Вариант 2 [A = +Y.Y]: {описание}
...
**Рекомендация:** {вариант} потому что {объяснение через данные}
═══ ПОСЛЕ ВЫПОЛНЕНИЯ ═══
Когда получишь результат, добавь в ПАМЯТЬ:
[Кейс {N+1}] Ситуация: {текущая}
Действие: {что выбрал}
Результат: {что случилось}
Оценка: {объективная метрика}
Это обновит базу для следующих задач.
Пояснения:
- {вставить прошлые попытки} — твой журнал задач: ситуация → действие → результат. Начни с 3-5 записей, добавляй новые после каждой попытки.
- {N} — сколько вариантов генерить. 3 для быстрого выбора, 5-7 для важных решений.
- {критерии сходства} — что делает ситуации похожими в твоём домене. Для текстов: тема+аудитория. Для переговоров: тип клиента+запрос. Для кода: язык+паттерн.
🚀 Быстрый старт — вставь в чат:
Вот шаблон JitRL для обучения через память опыта. Адаптируй под мою задачу: {твоя задача}.
Задавай вопросы чтобы заполнить поля.
[вставить шаблон выше]
LLM спросит: (1) какие прошлые попытки у тебя есть (нужны для заполнения ПАМЯТЬ), (2) какая текущая задача (заполнить ТЕКУЩАЯ ЗАДАЧА), (3) какие критерии сходства важны в твоём домене (для поиска релевантных кейсов), (4) как измерять успех (чтобы вычислить V и Q). Эти данные нужны потому что система обучается на конкретных примерах — без прецедентов нет паттернов для анализа. Модель возьмёт структуру из шаблона и настроит под твой контекст.
Ограничения
⚠️ Холодный старт: В первых 5-10 попытках система слабее базовой модели — памяти недостаточно для надёжных оценок. Метод начинает обгонять статичный подход после накопления опыта.
⚠️ Качество абстракции: Если состояния описаны слишком специфично ("задача #4352") — система не найдёт похожих кейсов. Слишком обобщённо ("что-то про текст") — найдёт нерелевантное. Нужна структурированная абстракция: выделять суть задачи, игнорируя шум.
⚠️ Требует стабильных метрик: Метод опирается на числовые оценки результатов. Для субъективных задач ("креативный текст") сложно выставлять награды — LLM-Evaluator может быть непоследователен. Лучше работает where результат измерим: конверсия, скорость, точность.
⚠️ API logits недоступны в чатах: Полная система JitRL корректирует выходные логиты z'=z+β·A, что требует API-доступа (не ChatGPT/Claude интерфейс). В чатах можно симулировать принцип через промпты (см. шаблон выше), но это не идентичная реализация.
⚠️ Рост памяти: После 100+ эпизодов retrieval замедляется. Исследователи используют vector search (embeddings + approximate nearest neighbors), что требует кода. Вручную можно периодически чистить память — оставлять только top-performing кейсы.
Ресурсы
Just-In-Time Reinforcement Learning: Continual Learning in LLM Agents Without Gradient Updates — Yibo Li, Zijie Lin, Ailin Deng, Xuan Zhang, Yufei He, Shuo Ji, Tri Cao, Bryan Hooi (National University of Singapore) | https://github.com/liushiliushi/JitRL | Тестировали на бенчмарках WebArena (навигация по вебсайтам) и Jericho (текстовые игры)