Добро пожаловать, Beam: открытая модель с 501 млрд параметров, которой вы можете владеть, которую можете настраивать и масштабировать

Beam от Reflection теперь доступна на Hugging Face! Это первая модель от новой американской лаборатории Reflection, и она является открытой! Это смесь экспертов (MoE) с 501 миллиардом параметров (23 миллиарда активных на один токен), поддерживающая текстовый ввод, с контекстным окном в 1 миллион токенов и выпущенная под лицензией Apache 2.0.

Beam ориентирована на написание кода и агентские сценарии использования. Она предназначена для команд, которым нужна пограничная модель на собственном оборудовании, инфраструктуре или в облаке и которые хотят настроить ее под свои задачи. Beam поставляется со своим собственным специализированным интерфейсом на базе Rust с открытым исходным кодом, который обеспечивает наилучшую производительность модели.

Beam имеет нативную реализацию transformers, а также поддерживает такие нижестоящие библиотеки, как vLLM и SGLang. Мы поработали с командой Reflection, чтобы предоставить вам рецепты для инференса, SFT (контролируемой тонкой настройки) и RL (обучения с подкреплением), с помощью которых вы сможете создавать решения на базе этой модели под свои нужды. Помимо поддержки с первого дня в transformers, SGLang и vLLM, в этой статье мы покажем, как ее запустить, как проводить посттренировку и что мы на ней создали.

Кратко (TL;DR)

MoE LLM с 501B параметров и 23B активных на токен. 52 слоя, 256 экспертов на слой MoE, 8 маршрутизируемых на токен. Ввод текста, вывод текста с контекстным окном 1М токенов. Форматы контрольных точек: BF16, FP8 и NVFP4. Рассуждения, сохраняющиеся в контексте между шагами (preserve_thinking), вызов инструментов со специализированной грамматикой. Модель поддерживает пять уровней рассуждений: "low", "medium" (по умолчанию), "high", "xhigh" и "max". Шаблон ответа в токенайзере. Модель черновика для спекулятивного декодирования с DFlash2. Библиотеки с поддержкой с первого дня: transformers, SGLang, vLLM. Полнопараметрическое RL с Miles. Поставляется с Rust-based custom harness. Apache 2.0.

• MoE LLM с 501B параметров и 23B активных на токен. 52 слоя, 256 экспертов на слой MoE, 8 маршрутизируемых на токен.
• Ввод текста, вывод текста с контекстным окном 1М токенов.
• Форматы контрольных точек: BF16, FP8 и NVFP4.
• Рассуждения, сохраняющиеся в контексте между шагами (preserve_thinking), вызов инструментов со специализированной грамматикой. Модель поддерживает пять уровней рассуждений: "low", "medium" (по умолчанию), "high", "xhigh" и "max".
• Шаблон ответа в токенайзере.
• Модель черновика для спекулятивного декодирования с DFlash2.
• Библиотеки с поддержкой с первого дня: transformers, SGLang, vLLM. Полнопараметрическое RL с Miles.
• Поставляется с
• Apache 2.0.

Создавайте с помощью Beam

Reflection выделит кредиты Hub на сумму 10 000 долларов США для лучших проектов, использующих Beam. Всё, что вам нужно сделать, — это создать что-то и поделиться этим на Hub:

• Вы можете создать демо-версию, использующую модель Beam на Spaces.
• Вы можете квантовать ее для вашего любимого оборудования.
• Вы можете сгенерировать синтетический набор данных для вашей любимой задачи.
• Вы можете создать среду RL с Beam или для Beam.
• Вы можете провести бенчмаркинг Beam и поделиться результатами.
• Вы можете удивить нас!

Если вы создадите что-то с помощью Beam, поделитесь этим на Hub, чтобы получить шанс выиграть 10 000 долларов. Всё, что вам нужно сделать — это создать пространство, модель или репозиторий набора данных и поделиться им на странице репозитория модели. Мы соберем все ссылки, выберем лучшие и отправим кредиты на ваши аккаунты Hub.

Что такое Beam?

Beam — это текстовая модель, созданная для рассуждений с длинным контекстом (длина контекста 1М) и агентской работы. Это разреженная модель MoE, в которой каждый токен вычисляется небольшой частью сети, поэтому она работает со скоростью гораздо меньшей модели, сохраняя при этом емкость большой.

Внимание (Attention)

Декодер имеет 52 слоя с размером скрытого состояния 5120. Большинство слоев используют внимание со скользящим окном по предыдущим 512 токенам; каждый шестой слой и последний слой обрабатывают весь контекст целиком. Это дает 43 слоя со скользящим окном и 9 глобальных слоев.

Внутри блока внимания (оба типа слоев)

Два типа слоев по-разному обрабатывают позиции. Слои со скользящим окном используют RoPE, так как относительное положение важнее всего в пределах короткого окна. Глобальные слои не используют позиционное кодирование. Вместо этого каждый запрос умножается на масштабный коэффициент, который медленно растет с увеличением числа видимых токенов: (1 + (pos + 1) / 2048) ** 0.1. Он действует как температура: softmax сохраняет свою точность по мере удлинения контекста, а не сглаживается. В реализации это называется масштабированием запросов scalable-softmax.

В механизме внимания используется групповое внимание (grouped-query attention) с 48 головами запросов и 8 головами ключей-значений, а также RMSNorm для запросов и ключей. Изучаемый сигмоидный вентиль, вычисляемый на основе входа слоя, масштабирует каждый канал каждой головы перед проекцией вывода.

Смесь экспертов (Mixture of Experts)

Первые 3 слоя используют плотный многослойный перцептрон SwiGLU. Остальные 49 заменяют его блоком «Смесь экспертов» (Mixture-of-Experts) из 256 экспертов, каждый из которых представляет собой MLP SwiGLU с промежуточным размером 2560 или около 39M параметров. На долю экспертов приходится 98,4% параметров модели.

Маршрутизатор следует схеме с ограничением по группам из DeepSeek-V3. Он оценивает всех 256 экспертов с помощью сигмоиды, делит их на 8 групп по 32, оставляет 4 лучшие группы (ранжированные по сумме двух лучших оценок каждой группы), а затем выбирает 8 лучших экспертов внутри них. Beam использует те же размеры групп, что и DeepSeek-V3, но без общего эксперта. Выходные данные экспертов объединяются с нормализованными весами маршрутизатора и масштабируются на 2,5.

На один токен запускается только 8 экспертов, поэтому модель вычисляет каждый токен примерно с 23 миллиардами параметров. Все 256 экспертов остаются в памяти, поэтому для развертывания требуется память модели на 501B, но работает она со скоростью модели на 23B. Контрольная точка BF16 весит около 1 ТБ в формате safetensors. Контрольная точка NVFP4 хранит большинство параметров в 4-битной точности для графических процессоров NVIDIA Blackwell, а некоторые параметры сохраняются в BF16 для точности. На хабе также есть контрольные точки FP8, которые идеально подходят для чипов серий Hopper и Ampere.

Если вы хотите развернуть Beam самостоятельно, ознакомьтесь с рецептами vLLM или SGLang ниже.

Остаточный поток (Residual Stream)

Остаточные соединения — это самая отличительная часть. Стандартный трансформер добавляет выходные данные каждого подслоя в поток с весом 1, поэтому поток растет с глубиной.

Beam считает входное вложение шагом 1. На шаге k она добавляет выходные данные подслоя с весом 1/sqrt(k) и сохраняет существующий поток с весом sqrt((k-1)/k). Квадраты этих двух весов в сумме дают единицу, поэтому поток остается постоянного масштаба от первого слоя до последнего. После всех 104 сложений выходные данные каждого подслоя и входное вложение имеют одинаковый вес в финальном скрытом состоянии.

Каждый подслой также нормализуется до и после, а финальные логиты проходят через ограничение tanh (softcap) на уровне ±30, вычисляемое в FP32. В реализации зафиксировано, где именно производятся вычисления в FP32: маршрутизатор, произведение SwiGLU, нормы, RoPE, масштабирование запросов и softcap.

Длинный контекст

Гибридное внимание хорошо работает для длинных контекстов. Каждый слой кеширует 2 x 8 голов KV x 128 размерностей = 2048 значений на токен. Если бы все 52 слоя сохраняли каждый токен, кеш рос бы на 208 КиБ на токен. Только 9 глобальных слоев сохраняют всю последовательность. 43 слоя со скользящим окном удерживают фиксированное окно в 512 токенов каждый и перестают расти. Таким образом, кеш увеличивается на 36 КиБ на токен, что примерно в шесть раз меньше стандартной скорости.

Эти цифры указаны для одной последовательности, в формате BF16, с динамическим кешем transformers.

Результаты бенчмарков

Вот результаты бенчмарков для различных уровней точности, предоставленные командой Reflection.

Требования к оборудованию

Наиболее практичный способ развертывания модели — это обслуживание контрольной точки NVFP4, которая сохраняет большую часть качества контрольной точки bf16. NVFP4 хранит некоторые веса в 4 битах, и таким образом сокращает 501B параметров в BF16 с 1 ТБ примерно до 280 ГБ. Графические процессоры Blackwell выполняют NVFP4 нативно, в то время как более старые графические процессоры, такие как H200, не могут этого делать. Контрольные точки FP8 подходят для графических процессоров старше Blackwell.

B200 имеет 180 ГБ памяти HBM3e, поэтому два таких процессора (360 ГБ) могут вместить веса Beam, оставляя совсем немного места для активаций и кэша KV. Планируйте использование четырех B200 (720 ГБ), что оставляет достаточно места для длинных контекстов и параллельных запросов. Вы также можете запустить модель на полном узле из 8x B200, на двух B300 объемом 288 ГБ каждый или даже на 8x RTX Pro 6000. Если у вас нет оборудования Blackwell, используйте провайдеров инференса (серверные решения) для тестирования Reflection.

Поддержка инференса

Beam имеет поддержку «нулевого дня» в transformers, SGLang и vLLM.

Transformers

Установите последнюю версию transformers.

Самый простой способ запустить Beam — использовать конвейер генерации текста (text-generation pipeline):

Конвейер возвращает весь чат. Последнее сообщение — это ответ Beam, уже разобранный с помощью шаблона ответа.

Опустившись на уровень ниже, используйте AutoModelForCausalLM и AutoTokenizer.

Чат

Токенизатор Beam содержит шаблон ответа. parse_response считывает его и преобразует необработанный вывод в словарь сообщения, в котором рассуждения, ответ и любые вызовы инструментов находятся в отдельных полях. Это позволяет избежать использования обычного регулярного выражения для разделения рассуждений, ответов и вызовов инструментов. Кроме того, правила поставляются вместе с токенизатором, поэтому разобранная структура соответствует тому, что Beam была обучена производить. Шаблон чата может заранее записать часть хода ассистента, которую парсер должен увидеть.

Вызов инструментов

Передайте инструменты также в функцию parse_response. Beam записывает аргументы вызова инструментов inline в своей собственной грамматике в стиле XML, поэтому чистая цифра 7 может быть как числом, так и строкой. С помощью схем инструментов парсер приводит каждый аргумент к его заявленному типу.

Мульти-GPU и мульти-нодовый режим

Конфигурация Beam определяет план параллелизма экспертов. Параллелизм экспертов помещает каждого эксперта на одно устройство. Внимание (attention), плотные слои, эмбеддинги и LM-head реплицируются на каждом устройстве. Это 8 млрд параметров или 16 ГБ в BF16. Загрузите модель с помощью DistributedConfig:

Запустите скрипт с помощью torchrun на 16 графических процессорах H200. Каждый из них будет содержать 78 ГБ весов. При использовании 8 графических процессоров каждый из них должен был бы содержать 139 ГБ, что не оставляет свободного места на H200 емкостью 141 ГБ. Количество устройств должно делиться на количество экспертов (256).

vLLM

Beam имеет поддержку «нулевого дня» в vLLM. Приведенная ниже команда запускает контрольную точку BF16 с тензорным параллелизмом на 16 графических процессорах (два узла 8x H200) и предоставляет API, совместимый с OpenAI:

Для более быстрой генерации добавьте спекулятивное декодирование DFlash2. Небольшая вспомогательная модель (drafter) предлагает до 15 токенов вперед, и Beam проверяет их все за один проход вперед, поэтому каждый шаг может принимать несколько токенов. Платой за это является небольшое количество дополнительной памяти для drafter:

Обе команды запускают сервер, совместимый с OpenAI, поэтому вы можете направить любой клиент OpenAI на http://localhost:8000/v1. Дополнительные конфигурации развертывания см. в предложенном рецепте Beam для vLLM.

SGLang

Beam также имеет поддержку «нулевого дня» в SGLang. Мы рекомендуем развертывать ее со спекулятивным декодированием DFlash2, которое обе команды ниже включают. На архитектуре Blackwell контрольная точка NVFP4 помещается на 4 B300:

На графических процессорах Hopper используйте вместо этого контрольную точку FP8 на 8 H200. Меняются всего три флага: контрольная точка, размер тензорного параллелизма (8 вместо 4) и бэкенд внимания (fa3 вместо trtllm_mha, для которого требуется Blackwell):

Провайдеры инференса

Beam доступна у провайдеров инференса Hugging Face при поддержке Baseten, Fireworks и Together, и в скором времени этот список пополнится.

Эндпоинты инференса (Inference Endpoints)

Мы подготовили для вас рецепт Beam для развертывания в один клик в Inference Endpoints из каталога в форматах FP8 или NVFP4, либо установки с помощью интерфейса командной строки hf следующим образом:

Что мы протестировали

Мы делимся некоторыми качественными оценками (vibe evals) модели Reflection Beam-501B-A23B по пяти задачам, выполнив каждую из них по одному разу при низком и высоком уровне усилий на рассуждение через платформу Reflection. Это качественные оценки, а не бенчмарки. Если вы планируете использовать Beam, это отличный способ протестировать модель и посмотреть, как она ведет себя в конкретных сценариях использования, и, что важно, где она выигрывает, а где проигрывает.

Ниже представлен обзор промптов, которые мы запускали, и выходных трейсов с хаба. Полные входные и выходные данные, использование API, фикстуры задач, грейдеры и трейсы диалогов находятся в этом общедоступном бакете Hugging Face.

* Ответ Low для длинного контекста правильно учел все особенности работы с кодом и содержал все шесть цитат из источников. Однако ответ не соответствовал формату парсеров, так что это отчасти проявление неоднозначности промпта.

† Low выдала правильный ответ, но опустила запрошенное обоснование. High предоставила корректное доказательство для корней из единицы, проверенное независимым образом.

Не верьте нам на слово. Изучите бакет, перепишите код под свой вариант использования или проект и выжмите из Beam максимум возможностей.

Постобучение Beam

Вы можете дообучить Beam под свои собственные задачи. Здесь мы делимся некоторыми примерами в TRL и Miles, чтобы помочь вам начать работу с контролируемым дообучением (SFT) и обучением с подкреплением.

SFT с TRL

Самый быстрый способ адаптировать Beam под ваши данные — это контролируемое дообучение (SFT) с помощью SFTTrainer из библиотеки TRL. Чтобы контролировать объем памяти, мы обучаем LoRA-адаптеры с помощью PEFT, а не обновляем все 501B параметров: Мы использовали TRL SFTTrainer, чтобы адаптировать Beam к простой цели: сохранять рассуждения на языке, запрошенном пользователем. Мы выполнили дообучение на Multilingual-Thinking с использованием LoRA, что позволяет обучать небольшой набор весов адаптеров, оставляя базовую модель замороженной.

Настройка объединяет шардинг модели во время загрузки, параллелизм экспертов, FlashAttention 4 и упаковку последовательностей (sequence packing). LoRA SFT помещается на одном узле с 8 графическими процессорами B300, достигая скорости около 19 000 токенов в секунду. Аналогичная установка на H100 использует четыре узла.

После одной эпохи обучения на Multilingual-Thinking модель Beam рассуждала на запрошенном языке в 16 из 16 отложенных промптов по сравнению с 3 из 16 для базовой модели. Эта небольшая оценка измеряет соответствие языку, а не правильность самих рассуждений.

Потери при обучении (слева) и средняя точность токенов (справа) во время отдельного 500-шагового прогона на подмножестве рассуждений open-r1/Mixture-of-Thought с использованием одного узла B300 с 8 GPU. Эти метрики обучения взяты из официального примера PR для TRL.

GRPO с Miles

Reflection и RadixArk создали рецепт, который обучает модель с помощью GRPO в Miles, в BF16. Вы можете обновить всю модель целиком или использовать LoRA для обучения адаптеров, сохраняя базовые веса замороженными. Megatron выполняет обучение, SGLang генерирует варианты ответов (rollouts), а Miles публикует новые веса в движках генерации после каждого обновления. Мы изучили этот рецепт.

Рецепт запускает GRPO на DAPO-Math-17K и производит оценку на AIME25. Соберите образ, скачивайте данные и отправьте задачу в кластер Ray, состоящий из двенадцати узлов 8x H200:

Что происходит в процессе генерации вариантов (rollout):

Сэмплирование: модели передается 32 промпта, по 8 ответов на каждый. Два движка SGLang обслуживают генерацию на 16 графических процессорах каждый.

Оценка: заключенный в рамки ответ сверяется с эталоном с применением мягкого штрафа за ответы, близкие к ограничению по длине.

Обновление: один шаг оптимизатора на всех 256 образцах. Преимущества относительно группы с усеченной оценкой важности, без штрафа за KL или энтропию.

Обучение параллельно: тензорный параллелизм 8, экспертный параллелизм 8, параллелизм данных 8, с параллелизмом последовательностей и полным пересчетом.

Оптимизатор: Adam с постоянным значением 1e-6. Градиенты в BF16, основные веса в FP32, моменты в BF16. Состояние оптимизатора передается потоком через локальный для узла NVMe, поэтому каждому узлу обучения требуется 2 ТБ временного пространства.

Оценка: AIME25 каждые пять генераций, восемь образцов на задачу. Чекпоинт сохраняется каждые двадцать.

Следующая генерация создается во время обучения текущей, поэтому ответы отстают на одно обновление. Добавьте --resume для продолжения с последнего чекпоинта. execute-colocate выполняет тот же рецепт на восьми узлах, причем каждый GPU по очереди обучает и обслуживает.

Обучение с помощью LoRA

Вы также можете запустить GRPO с LoRA на четырех узлах 8× H200: 16 GPU для обучения и 16 для генераций. Этот рецепт обучает адаптеры ранга 16 на слоях внимания, плотного MLP и экспертных слоях Beam, сохраняя базовые веса замороженными. С SGLang синхронизируются только веса адаптеров, а состояние оптимизатора остается в памяти GPU, что устраняет необходимость выгрузки оптимизатора на NVMe.

Создавайте с помощью Beam: Демо

Если вы создадите что-то с помощью Beam, поделитесь этим на Hub, чтобы получить шанс выиграть 10 000 долларов. Все, что вам нужно сделать, — это создать репозиторий Space, модели или датасета и поделиться им на странице репозитории модели. Для вдохновения вот несколько вещей, которые мы создали.

Привет, Beam, создай нативное локальное приложение для MacOS!

В Hugging Face мы любим открытые и локальные модели, которые работают нативно на своем железе, но создавать нативные приложения на Mac может быть сложно! Давайте посмотрим, сможет ли Beam нам помочь.

Мы попросили Beam создать нативное приложение для MacOS, которое преобразует речь в текст и удобно вставляет ее в месте курсора. Мы хотим использовать MLX, чтобы извлечь максимум из нашего Mac Metal, и модель Parakeet для отличного распознавания речи.

Мы использовали Beam со средой написания кода Pi для создания первоначального нативного приложения для строки меню macOS, запускающего Parakeet с MLX. Сохраненный запуск включает последующие промпты; окончательный исходный код также включает более поздние исправления Codex. Приведенный выше промпт является сокращенной версией требований к сборке.

Вы можете посмотреть трейс агента о том, как Beam создал это в pi, в этом трейсе. Если вы хотите протестировать демо, скачайте исходный код или прочитайте инструкции по установке.

Привет, Beam, как масштабироваться на нескольких агентах?

Мы хотели посмотреть, сможет ли Beam добиться более быстрого прогресса, разделив задачу программирования между агентами. Мы объединили Beam с открытым агентом кодирования Pi и сравнили три настройки: 1. один агент работает в одиночку, 2. пять постоянных коллег сотрудничают через общий репозиторий Git, и 3. ведущий агент делегирует работу асинхронным субагентам. Среда выполнялась на заданиях Hugging Face с выводом через платформенный API Reflection.

Для задач мы использовали ProgramBench: агенты должны воссоздать программу по ее скомпилированному исполняемому файлу и документации, не видя ее исходного кода или тестов оценщика. У каждой настройки был одинаковый лимит в 8 млн токенов API и двухчасовое ограничение для решателя на задачу, общее для ее агентов. Мы сохранили снимки реализации и оценили их по сравнению с фиксированными наборами скрытых тестов из датасета ProgramBench-Tests.

Наш график соотношения оценки и задержки показывает среднюю долю пройденных тестов. Ось времени использует фиксированные эталонные ставки для токенов модели плюс измеренное время работы инструментов, а не прошедшее реальное время. Изначально мы запустили пять задач. На текущем рисунке показана апостериорная подмножество jq, xsv, FIGlet и hexyl; ripgrep был исключен во всех трех настройках, потому что оценка его сохраненных артефактов была слишком медленной. Опубликованные результаты сохраняют все 15 исходных эпизодов.

Вы можете изучить запуск в панели управления Trackio, исследовать опубликованные данные результатов и повторно использовать среду исследования.

Привет, Beam, дообучи модель принятия решений для моей кодовой базы!

Модели принятия решений сейчас очень популярны, потому что они супербыстрые и практичные для многих сценариев использования. Мы начали с Beam, а затем продолжили с GLM-5.3 в Pi после того, как квота Beam исчерпалась, чтобы обучить и оценить пользовательскую модель принятия решений для триажа инцидентов разработчиков.

Мы хотели посмотреть, сможет ли агент кодирования превратить политику триажа инцидентов в небольшую и быструю модель принятия решений. Задача заключалась в том, чтобы прочитать инцидент разработчика и выбрать ответственную команду, ее серьезность и то, нужно ли кому-то немедленно отправить пинг. Используя Unsloth, мы дообучили Qwen3.5-0.8B для непосредственной оценки этих вариантов.

Сначала рабочий процесс создал синтетический датасет, содержащий 2,3 тыс. инцидентов, разделенных по кластерам инцидентов для обучения, калибровки и тестирования. Мы обучили адаптер LoRA и голову принятия решений в течение трех эпох с 4-битной основой на одном H100 80GB в кластере Science Slurm.

В качестве базового уровня мы запросили неадаптированную модель с полной политикой триажа и тикетом без примеров и попросили ее сгенерировать три решения в формате JSON. На тех же 320 синтетических тестовых тикетах дообученная модель принятия решений дала правильные ответы на все три пункта в 76,25% случаев против 4,69% для zero-shot с промптами. Средняя задержка тикета упала с 1 218,06 мс до 102,58 мс, что в 11,9 раза быстрее.

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

Подведение итогов

Beam — это открытая модель 501B, которую вы можете запускать на собственном железе и изменять. Начните с чекпоинта BF16 или попробуйте один из квантованных вариантов FP8, NVFP4. Если вы что-то создадите с помощью Beam, поделитесь этим на вкладке обсуждений.