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

Обновить на GitHub

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 с первого дня, в этой статье показано, как запускать модель, дообучать её и что мы с ней создали.

Кратко

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

Создавайте с Beam

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

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

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

Что такое Beam?

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

Механизм внимания

Декодер состоит из 52 слоёв со скрытым размером 5120. В большинстве слоёв используется внимание со скользящим окном по предыдущим 512 токенам; каждый шестой слой и последний слой учитывают весь контекст. Таким образом, 43 слоя работают со скользящим окном, а 9 — глобально.

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

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

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

Смесь экспертов

В первых 3 слоях используется плотный MLP SwiGLU. В остальных 49 он заменён блоком смеси экспертов из 256 экспертов, каждый из которых представляет собой MLP SwiGLU с промежуточным размером 2560, или примерно 39 млн параметров. На экспертов приходится 98,4% параметров модели.

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

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

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

Остаточный поток

Остаточные соединения — наиболее отличительная особенность модели. Стандартный трансформер добавляет выход каждого подслоя в поток с весом 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-битном формате и таким образом уменьшает объём 501 млрд параметров в BF16 с 1 ТБ примерно до 280 ГБ. Графические процессоры Blackwell выполняют NVFP4 нативно, но более старые GPU, например H200, этого не умеют. Контрольные точки FP8 подходят для GPU старше Blackwell.

Один B200 располагает 180 ГБ HBM3e, поэтому два таких ускорителя (360 ГБ) могут вместить веса Beam, но для активаций и KV-кэша останется мало места. Планируйте четыре B200 (720 ГБ) — этого будет достаточно для длинных контекстов и параллельных запросов. Модель также можно обслуживать на полном узле 8xB200, на двух B300 по 288 ГБ каждый или даже на 8xRTX Pro 6000. Если у вас нет оборудования Blackwell, используйте Inference Providers (бессерверный режим), чтобы протестировать Reflection.

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

Beam поддерживается в transformers, SGLang и vLLM с первого дня.

Transformers

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

pip install -U "transformers>=5.20.1"

Проще всего запускать Beam через конвейер text-generation:

from transformers import pipeline

pipe = pipeline(
    "text-generation", model="reflectionai/Beam-1.0-501B-A23B", device_map="auto"
)

messages = [
    {"role": "user", "content": "Write a limerick about Python exceptions."}
]
output = pipe(messages, max_new_tokens=2000)
output[0]["generated_text"][-1]

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

Если нужен более низкий уровень, используйте AutoModelForCausalLM и AutoTokenizer.

from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "reflectionai/Beam-1.0-501B-A23B"
tokenizer = AutoTokenizer.from_pretrained(model_id)

model = AutoModelForCausalLM.from_pretrained(
    model_id, dtype="auto", device_map="auto"
)

Чат

messages = [
    {"role": "system", "content": "You should only answer with a number."},
    {"role": "user", "content": "What is 17 * 23?"},
]

inputs = tokenizer.apply_chat_template(
    messages,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    reasoning_effort="medium" 
).to(model.device)

input_len = inputs["input_ids"].shape[-1]

outputs = model.generate(**inputs, max_new_tokens=2000)

tokenizer.parse_response(
    outputs[0][input_len:], prefix=inputs["input_ids"][0]
)

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

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

Полный пример вызова инструмента

def get_weather(city: str, unit: str = "celsius"):
    """
    Get the current weather for a city.

    Args:
        city: The city to look up.
        unit: Temperature unit, "celsius" or "fahrenheit".
    """
    ...

tools = [get_weather]
messages = [
    {"role": "user", "content": "I land in Paris tonight. Do I need a coat?"}
]

inputs = tokenizer.apply_chat_template(
    messages,
    tools=tools,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
).to(model.device)

input_len = inputs["input_ids"].shape[-1]
outputs = model.generate(**inputs, max_new_tokens=1000)

message = tokenizer.parse_response(
    outputs[0][input_len:], prefix=inputs["input_ids"][0], tools=tools
)
message.get("tool_calls")

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

Несколько GPU и узлов

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

import os

from transformers import AutoModelForCausalLM
from transformers.distributed import DistributedConfig

model = AutoModelForCausalLM.from_pretrained(
    "reflection/Beam-1.0-501B-A23B",
    distributed_config=DistributedConfig(
        tp_size=int(os.environ["WORLD_SIZE"]), enable_expert_parallel=True
    ),
)

Запустите скрипт с помощью torchrun на 16 GPU H200. Тогда на каждом устройстве будет храниться 78 ГБ весов. При использовании 8 GPU на каждом пришлось бы разместить 139 ГБ, что не оставляет места на H200 с объёмом 141 ГБ. Число устройств должно делить число экспертов — 256.

vLLM

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

vllm serve reflection/Beam-1.0-501B-A23B --tensor-parallel-size 16 --served-model-name beam

Для более быстрой генерации добавьте speculative decoding с DFlash2. Небольшая черновая модель предлагает до 15 токенов вперёд, а Beam проверяет их одним прямым проходом, поэтому на каждом шаге можно принять несколько токенов. Цена этого — небольшой дополнительный объём памяти для черновой модели:

vllm serve reflection/Beam-1.0-501B-A23B \
  --tensor-parallel-size 16 \
  --speculative-config '{ "method": "dflash", "model": "reflection/dflash2-drafter-preview", "num_speculative_tokens": 15 }'

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

SGLang

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

python -m sglang.launch_server \
--model-path reflection/Beam-1.0-501B-A23B-NVFP4 \
--served-model-name beam \
--tp 4 \
--attention-backend trtllm_mha \
--page-size 64 \
--context-length 1048576 \
--mem-fraction-static 0.85 \
--enable-unified-memory \
--speculative-algorithm DFLASH \
--speculative-draft-model-path reflection/Beam-1.0-501B-A23B-DFlash2 \
--speculative-dflash-block-size 8 \
--tool-call-parser beam --reasoning-parser beam \
--host 0.0.0.0 --port 30000

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

python -m sglang.launch_server \
--model-path reflection/Beam-1.0-501B-A23B-FP8 \
--served-model-name beam \
--tp 8 \
--attention-backend fa3 \
--page-size 64 \
--context-length 1048576 \
--mem-fraction-static 0.85 \
--enable-unified-memory \
--speculative-algorithm DFLASH \
--speculative-draft-model-path reflection/Beam-1.0-501B-A23B-DFlash2 \
--speculative-dflash-block-size 8 \
--tool-call-parser beam --reasoning-parser beam \
--host 0.0.0.0 --port 30000

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

Beam доступна у провайдеров инференса Hugging Face, работающих на базе Baseten, Fireworks и Together; вскоре появятся и другие.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://router.huggingface.co/v1",
    api_key=os.environ["HF_TOKEN"],
)

completion = client.chat.completions.create(
    model="reflection/Beam-1.0-501B-A23B:auto",
    messages=[{"role": "user", "content": "What is the capital of France?"}],
)

print(completion.choices[0].message)

Конечные точки инференса

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

hf endpoints catalog deploy --repo reflection/Beam-1.0-501B-A23B --name beam

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

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

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

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

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

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

Дообучение Beam

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

SFT с TRL

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

Конфигурация сочетает шардирование модели при загрузке, параллелизм экспертов, FlashAttention 4 и упаковку последовательностей. SFT с LoRA помещается на одном узле с 8 GPU B300 и достигает примерно 19 000 токенов в секунду. Соответствующая конфигурация на H100 использует четыре узла.

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

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

GRPO с Miles

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

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

docker build -f docker/Dockerfile.beam -t miles-beam .

python scripts/run_beam.py prepare \
  --model-id reflection/Beam-1.0-501B-A23B \
  --model-dir /root/models/Beam \
  --data-dir /data/datasets

export MASTER_ADDR=10.0.0.1
export RAY_ADDRESS=http://${MASTER_ADDR}:8265

python scripts/run_beam.py execute \
  --model-dir /root/models/Beam \
  --data-dir /data/datasets \
  --output-dir /root/shared_data/beam-run \
  --num-rollout 100

Что происходит во время генерации:

Выборка: модели передаются 32 промпта, для каждого генерируется по 8 ответов. Два движка SGLang обслуживают генерацию, используя по 16 GPU каждый.

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

Обновление: один шаг оптимизатора на всех 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.

python scripts/run_beam_lora.py execute \
  --model-dir /root/models/Beam \
  --data-dir /data/datasets \
  --output-dir /root/shared_data/beam-run \
  --num-rollout 100

Создавайте с Beam: демо

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

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

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

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

Build BeamSpeak, a native macOS menu bar dictation app with a compact recording pill and no main window or account.

Use ⌘⇧Space to start and stop microphone recording, showing elapsed time, microphone level, and transcription status. Run speech recognition entirely locally using a Hugging Face model, preferably Parakeet v3 through MLX, and keep the model loaded between recordings. Paste the transcript into the original app if it remains focused and Accessibility permission is granted; otherwise copy it to the clipboard, preserving newer clipboard changes and never pressing Enter. Handle permissions, cancellation, silence, errors, a two-minute recording limit, and temporary audio cleanup. Deliver source code, a runnable BeamSpeak.app, setup instructions, and verification of offline transcription, the physical shortcut, microphone capture, and text delivery.

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

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

Эй, Beam, как ты масштабируешься на нескольких агентах?

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

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

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

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

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

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

Мы хоте�