Quiet-STaR: скрытое мышление модели

Суть в двух словах

Обычные модели генерируют текст токен за токеном, не «думая» между словами. Если мы хотим, чтобы модель рассуждала, нужно явно попросить: «Думай шаг за шагом» (Chain of Thought). Но это неестественно — люди думают перед каждым высказыванием автоматически, без инструкций.

STaR (Self-Taught Reasoner) — предшественник Quiet-STaR — решал часть проблемы: модель обучалась на собственных рассуждениях, но только для конкретных задач с правильными ответами (вопрос-ответ, математика).

Quiet-STaR делает следующий шаг: модель учится генерировать скрытые «мысли» (rationales) на каждой позиции в тексте. Не только при решении задач, а вообще всегда — при любом продолжении текста. Мысль помогает предсказать следующий токен точнее, и модель обучается усиливать полезные мысли и ослаблять бесполезные.

Аналогия: обычная модель — это человек, который говорит «на автомате», не задумываясь. Quiet-STaR — это человек с внутренним монологом, который обдумывает каждую фразу прежде чем произнести.

Ключевая идея: Chain of Thought требует, чтобы человек написал «Думай шаг за шагом». Quiet-STaR встраивает мышление в саму модель — мышление происходит автоматически, без инструкций.

Quiet-STaR — это не техника промптинга, которую вы применяете к готовой модели. Это метод обучения моделей, который меняет сам способ генерации текста. Но понимание этой идеи помогает разобраться, как работают современные «думающие» модели (o3, DeepSeek-R1, Claude с extended thinking) и как эмулировать похожее поведение через промпты.

Как понимать Quiet-STaR в 2026

Для практики ценность статьи не в том, что вы завтра "включите Quiet-STaR" в API. Она в другом:

• reasoning можно делать скрытым, а не только явным;
• token-by-token generation можно усиливать внутренними rationales;
• visible CoT — только один из способов получить reasoning behaviour.

Это делает Quiet-STaR важной concept article для понимания reasoning-model design, даже если напрямую техника недоступна пользователю.

Как работает Quiet-STaR

От STaR к Quiet-STaR

В 2022 году Zelikman et al. предложили STaR (Self-Taught Reasoner) — метод, при котором модель обучается рассуждать на собственных примерах:

1. Модели даётся задача (например, математическая)
2. Модель генерирует рассуждение и ответ
3. Если ответ правильный — рассуждение добавляется в обучающую выборку
4. Если неправильный — модели дают подсказку (rationalization), и она пробует снова
5. Модель дообучается на накопленных примерах

STaR работал, но имел два ограничения:

• Нужен датасет с правильными ответами
• Рассуждения генерируются только для конкретных задач (QA, математика)

Quiet-STaR снимает оба ограничения:

• Обучается на произвольном тексте (любой корпус, не нужны задачи с ответами)
• Генерирует мысли на каждой позиции, а не только перед ответом

Механизм работы

Отличие от обычного Chain of Thought

Отличие от STaR

Результаты

Ключевое наблюдение: модель не обучалась на математических задачах. Она обучалась на обычном тексте (OpenWebMath), но научилась думать — и это мышление перенеслось на математику и здравый смысл. Это доказывает, что «внутренний монолог» — общий навык, а не специфический для задачи.

Где Quiet-STaR применяется на практике

Quiet-STaR — это исследовательский метод, который пока не доступен как готовый инструмент. Однако его идея лежит в основе:

• Reasoning-моделей (o3, o4-mini, DeepSeek-R1): используют скрытые или видимые «цепочки мышления» перед ответом
• Extended thinking в Claude: модель «размышляет» перед ответом, показывая процесс
• Thinking tokens в будущих архитектурах: идея выделенных «мыслительных» токенов набирает популярность

Где это practically влияет на выбор инструмента

Понимание Quiet-STaR полезно, когда вы выбираете между:

• fast compact models;
• explicit reasoning modes;
• скрытым reasoning в hosted reasoning models.

Если системе нужны explainability, audit trail и reviewable traces, hidden thinking alone недостаточно. Если же критичны latency, cost и простота UX, скрытое reasoning может быть предпочтительнее длинного visible CoT.

Техническая реализация

Архитектура Quiet-STaR

Quiet-STaR модифицирует стандартный процесс авторегрессионной генерации:

Стандартная модель:
  x₁ → x₂ → x₃ → x₄ → ...

Quiet-STaR:
  x₁ → [thought₁] → x₂ → [thought₂] → x₃ → [thought₃] → x₄ → ...
        ↑                    ↑                    ↑
   <|startofthought|>   <|startofthought|>   <|startofthought|>
   t₁, t₂, ... tₙ       t₁, t₂, ... tₙ       t₁, t₂, ... tₙ
   <|endofthought|>     <|endofthought|>     <|endofthought|>

Ключевые компоненты

Meta-tokens. В словарь модели добавляются два специальных токена:

• <|startofthought|> — начало мысли
• <|endofthought|> — конец мысли

Эти токены обучаются вместе с моделью. Их эмбеддинги инициализируются из эмбеддингов ближайших по смыслу токенов (em-dash — для start, конец предложения для end).

Mixing head. После генерации мысли модель делает два предсказания следующего токена:

• p_talk(x_{i+1}) — предсказание с учётом мысли
• p_base(x_{i+1}) — предсказание без мысли (как обычная модель)

Итоговая вероятность — взвешенная комбинация:

p_final = w * p_talk + (1 - w) * p_base

где w — обучаемый параметр (mixing weight). В начале обучения w ≈ 0 (модель доверяет базовому предсказанию), постепенно w растёт для позиций, где мысли помогают.

Параллельная генерация мыслей. Наивная реализация генерировала бы мысли последовательно для каждой позиции — это невозможно медленно. Авторы предложили параллельную генерацию: мысли для всех позиций генерируются одновременно через модифицированную attention mask.

Обучение: REINFORCE с teacher-forcing

Функция потерь Quiet-STaR:

L = L_nll + α * L_reinforce

• L_nll — стандартная next-token prediction loss (teacher-forcing)
• L_reinforce — REINFORCE reward: насколько мысль улучшила предсказание
• α — коэффициент баланса

Reward для каждой мысли:

reward_i = log p_talk(x_{i+1}) - log p_base(x_{i+1})

Если reward > 0 — мысль помогла → усилить. Если reward < 0 — мысль навредила → ослабить.

Ограничения

• Вычислительная стоимость: генерация мыслей на каждой позиции увеличивает compute в разы. Авторы использовали мысли длиной 1-8 токенов для баланса
• Не open-source полностью: код доступен, но обучение требует значительных GPU-ресурсов
• Только Mistral 7B: в статье протестирован на одной модели, масштабирование не исследовано
• Не для инференса напрямую: нет готового API или интерфейса для использования обученной модели

Эмуляция Quiet-STaR через промпт

Хотя Quiet-STaR — метод обучения, его идею можно частично эмулировать через промптинг. Суть: попросить модель «подумать про себя» перед каждым утверждением.

Перед каждым утверждением в своём ответе сначала запиши краткую мысль в формате [мысль: ...], затем само утверждение. Мысль — это то, что ты обдумываешь перед тем, как написать фразу.

Вопрос: Почему замороженная вода занимает больше объёма, чем жидкая?

Продвинутая эмуляция через system prompt

from openai import OpenAI

client = OpenAI()

QUIET_STAR_SYSTEM = """Ты — модель с внутренним монологом.

Правила:
1. Перед каждым абзацем своего ответа напиши
   скрытую мысль в формате:
   <thought>краткое рассуждение</thought>
2. Мысль содержит: что ты знаешь по теме,
   какие есть нюансы, что может быть ошибкой
3. Затем напиши сам абзац, учитывая обдуманное
4. Мысли должны быть краткими (1-2 предложения)
5. Если не уверен — отметь это в мысли"""


def quiet_star_emulation(question: str) -> str:
    """Эмуляция Quiet-STaR через system prompt."""
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": QUIET_STAR_SYSTEM,
            },
            {
                "role": "user",
                "content": question,
            },
        ],
        temperature=0.3,
    )
    return response.choices[0].message.content


# Вариант с фильтрацией мыслей для конечного
# пользователя
def quiet_star_filtered(question: str) -> str:
    """
    Quiet-STaR эмуляция: модель думает,
    но пользователь видит только чистый ответ.
    """
    import re

    raw = quiet_star_emulation(question)
    # Убираем теги <thought>...</thought>
    clean = re.sub(
        r"<thought>.*?</thought>\s*",
        "",
        raw,
        flags=re.DOTALL,
    )
    return clean.strip()


answer = quiet_star_emulation(
    "Почему при обучении нейросетей "
    "используют dropout, а не просто "
    "уменьшают число нейронов?"
)
print(answer)

Связь с reasoning-моделями

Quiet-STaR можно рассматривать как теоретическое обоснование подхода «думающих» моделей:

Все эти подходы объединяет одна идея: модель должна думать перед тем, как говорить. Quiet-STaR первым показал, что этот навык можно обучить на произвольном тексте, а не только на размеченных задачах.