Как работает agent self-improvement через self-reflection on failures?

Краткий тезис

Self-improvement через self-reflection — это механизм, при котором AI-агент после неудачного выполнения задачи автоматически анализирует свою ошибку, формулирует «урок» и сохраняет его в долговременную память. В будущем при похожих запросах агент извлекает этот урок и корректирует своё поведение без переобучения модели. Такой подход превращает статичного агента в адаптивную систему, способную учиться на собственном опыте.

1. Термин: Self-reflection (саморефлексия)

Self-reflection — это процесс, при котором агент (или отдельный модуль) оценивает собственные действия, выявляет причины ошибки и генерирует абстрактный вывод («урок»). В отличие от простого логирования, рефлексия требует от LLM способности к мета-анализу: «Что я сделал не так?» и «Как следовало поступить?».

Зачем нужна self-reflection?

• Исправление систематических ошибок: если агент постоянно забывает проверить факты, урок «всегда используй search перед ответом» решит проблему.
• Адаптация к новым доменам: агент, работающий с разными базами знаний, может учиться нюансам каждой.
• Снижение ручного fine-tuning: большинство ошибок исправляется через память, а не через переобучение дорогой модели.

2. Компоненты архитектуры

Для реализации self-improvement необходимы следующие модули:

3. Полный цикл self-improvement (пошагово)

Рассмотрим итерацию работы агента с самосовершенствованием.

Шаг 1: Получение запроса

Пользователь задаёт вопрос, например: «Какая столица Австралии?» (агент должен ответить «Канберра»).

Шаг 2: Извлечение уроков из памяти

Перед генерацией ответа агент делает поиск в векторной БД уроков по эмбеддингу запроса. Если есть похожие уроки (например, «при географических вопросах проверяй последние данные в search»), они добавляются в системный промпт.

Шаг 3: Выполнение задачи

Агент генерирует ответ, возможно с вызовом инструментов (search, calculator). В нашем примере он может ошибиться и сказать «Сидней».

Шаг 4: Верификация

Verifier проверяет ответ:

• Если есть заранее размеченный gold standard (в тестовом окружении) — сравнивает.
• В продакшене — использует user feedback (лайк/дизлайк) или внешний источник (Wikipedia API). Ошибка зафиксирована: ответ неверный.

Шаг 5: Reflection (анализ ошибки)

Reflection Module получает контекст: исходный запрос, сгенерированный ответ, правильный ответ (если он известен) и, опционально, трассу вызовов инструментов. LLM генерирует урок:

Запрос: "Какая столица Австралии?"
Неверный ответ: "Сидней"
Правильный ответ: "Канберра"
Урок: "При вопросах о столицах стран всегда сначала используй поиск по авторитетному источнику (Wikipedia), чтобы подтвердить факт. Не полагайся на общие знания."

Шаг 6: Сохранение урока (Memory update)

Урок эмбеддируется той же моделью, что и запросы, и сохраняется в векторную БД с метаданными (тема, дата, частота ошибок).

# Псевдокод сохранения
lesson_vector = embedder.encode(lesson_text)
memory_store.add(
    vector=lesson_vector,
    payload={"lesson": lesson_text, "query": original_query, "topic": "geography"}
)

Шаг 7: Будущие запросы

При новом похожем запросе (например, «Столица Бразилии?») retriever найдёт сохранённый урок. Агент добавит его в промпт и ответит правильно: «Бразилиа».

4. Детали реализации Reflection Module

Reflection Module — критически важный компонент. Его качество определяет, насколько полезные уроки будет извлекать агент.

Хороший промпт для рефлексии должен:

• Указывать агенту тип ошибки (фактическая, логическая, неправильный вызов инструмента).
• Требовать конкретное правило, а не общее рассуждение.
• Ограничивать длину урока (например, 1–2 предложения).

Пример промпта:

You are an AI agent that just made a mistake. Analyze the following:
- User query: {query}
- Your answer: {wrong_answer}
- Correct answer (if known): {correct_answer}
- Tool calls you made: {tool_trace}

Provide a single actionable lesson that would prevent this mistake in the future.
The lesson should be specific (do not say "be careful", say "always verify dates using search before answering").

Варианты рефлексии без правильного ответа

Если правильный ответ неизвестен, можно использовать:

• Self-consistency: сгенерировать несколько ответов и сравнить.
• Verifier на основе LLM: попросить LLM-судью объяснить, почему ответ плох.
• Отказ от ответа: если агент сам признаёт неуверенность («Я не знаю»), это тоже сигнал для рефлексии.

5. Механизм извлечения уроков (Retrieval из памяти)

Уроки должны быть извлечены до выполнения задачи. Основные стратегии:

Пример кода извлечения

def retrieve_lessons(query: str, top_k: int = 3) -> list[str]:
    query_vec = embedder.encode(query)
    results = memory_store.query(query_vec, n_results=top_k)
    return [r.payload["lesson"] for r in results]

# В промпте агента
lessons = retrieve_lessons(user_query)
if lessons:
    prompt = f"""Relevant lessons from past mistakes: {lessons}
Now answer the user question. {user_query}"""

6. Пример self-improvement без переобучения

Предположим, агент часто отвечает на вопросы о времени работы магазина, используя статичную базу знаний, но не проверяет праздничные дни.

• Ошибка: «Магазин открыт до 21:00» в новогодний праздник.
• Verifier (жалоба пользователя) фиксирует ошибку.
• Reflection: «При вопросах о часах работы всегда проверяй дату и ищи обновления в официальном источнике, не бери расписание по умолчанию для праздников».
• Memory update: урок сохраняется.
• Следующий запрос: «Работает ли магазин 8 марта?» — извлекается урок, агент вызывает API расписания праздников и даёт верный ответ.

Агент улучшился без изменения весов LLM — только через добавление контекста из памяти.

7. Сравнение с альтернативными методами

8. Ограничения и вызовы

• Качество рефлексии: если Reflection Module генерирует бесполезные или неверные уроки, агент может ухудшиться (negative transfer). Нужен второй verifier для уроков.
• Конкуренция уроков: при многих похожих уроках retriever может перегрузить контекст. Нужна дедупликация (похожие уроки объединять) или ранжирование.
• Забывание: если уроков слишком много, retriever может не найти релевантный. Нужна стратегия memory consolidation — объединение похожих уроков в более общее правило.
• Эффект «слепого пятна»: агент не учится на ошибках, которые не фиксируются verifier'ом (например, когда ответ правильный, но с плохим стилем).
• Latency: извлечение уроков добавляет задержку. Можно кэшировать популярные уроки.

9. Дополнительные сценарии усовершенствования

• Incremental lesson merging: если агент получает два похожих урока («проверять даты в search» и «проверять время в search»), их можно объединить в один.
• Active learning: агент сам запрашивает feedback, если уверенность низкая.
• Multi-agent reflection: один агент совершает действие, другой (critic) пишет урок для первого. Затем оба агента обновляют общую память.

Пет-проект для закрепления

Задача: Создайте агента-помощника по историческим фактам, который учится на своих ошибках через self-reflection.

Инструменты:

• Python, LangChain или собственный фреймворк на OpenAI API
• ChromaDB (векторное хранилище)
• sentence-transformers для эмбеддингов
• Wikipedia API для верификации

Шаги:

1. Реализуйте агента, который отвечает на исторические вопросы (например, «Когда началась Вторая мировая?») с помощью вызова Wikipedia search.
2. Создайте тестовый набор из 20 вопросов, где агент иногда ошибается (из-за неверного парсинга).
3. Напишите verifier: программа сверяет ответ с данными из Wikipedia.
4. Реализуйте Reflection Module: при ошибке вызывайте LLM с промптом для генерации урока.
5. Сохраните урок в ChromaDB, используя эмбеддинг запроса.
6. При следующем запуске агента добавьте извлечение уроков в промпт.
7. Протестируйте: после 5–10 ошибок агент должен давать правильные ответы на похожие вопросы.

Ожидаемый результат: Агент, который сначала ошибается на половине вопросов, а после обучения на ошибках достигает точности >90% без переобучения модели.

Связь с другими вопросами

Навигация

• Предыдущий: 581
• Следующий: 583
• Индекс: 00. Индекс разборов