Представяме Beam: отворен модел с 501 млрд. параметъра, който можете да притежавате, персонализирате и мащабирате

Актуализиране в GitHub

Beam на Reflection вече е достъпен в Hugging Face! Това е първият модел от новата американска лаборатория Reflection и е отворен! Това е модел със смес от експерти (MoE) със 501 млрд. параметъра (23 млрд. активни за токен), приема текст като вход, има контекстен прозорец от 1 млн. токена и се разпространява под лиценза Apache 2.0.

Beam е насочен към случаи на употреба, свързани с програмиране и агентни системи. Той е предназначен за екипи, които искат модел от граничен мащаб на собствен хардуер, инфраструктура или облак и желаят да го персонализират за своите случаи на употреба. Beam се доставя със собствен специализиран хранис­лищно-отворен harness на Rust, който осигурява най-добрата производителност на модела.

Beam има вградена реализация за transformers, както и поддържащи библиотеки като vLLM и SGLang. Работихме с екипа на Reflection, за да ви предоставим рецепти за инференс, SFT (контролирано дообучаване) и RL (обучение с подсилване), с които да изграждате според нуждите си. Освен поддръжката от деня на пускане в transformers, SGLang и vLLM, тази публикация показва как да го стартирате, как да го дообучите след предварителното обучение и какво изградихме с него.

Накратко

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

Изграждайте с Beam

Reflection ще предостави кредити за Hub на стойност 10 000 долара за най-добрите проекти, които използват Beam. Всичко, което трябва да направите, е да създадете нещо и да го споделите в Hub:

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

Ако изградите нещо с Beam, споделете го в Hub, за да получите шанс да спечелите 10 000 долара. Всичко, което трябва да направите, е да създадете хранилище за space, модел или набор от данни и да го споделите на страницата на хранилището на модела. Ще съберем всички връзки, ще изберем най-добрите и ще изпратим кредитите към вашите Hub акаунти.

Какво представлява Beam?

Beam е текстов модел, създаден за разсъждение с дълъг контекст (дължина на контекста 1 млн. токена) и агентна работа. Това е разреден MoE модел, при който всеки токен се изчислява от малка част от мрежата, така че работи със скоростта на много по-малък модел, като същевременно запазва капацитета на голям модел.

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

Декодерът има 52 слоя със скрит размер 5120. Повечето слоеве използват внимание с плъзгащ се прозорец върху предишните 512 токена; всеки шести слой и последният слой обръщат внимание към целия контекст. Така се получават 43 слоя с плъзгащ се прозорец и 9 глобални слоя.

Вътре в блока за внимание (и при двата типа слоеве)

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

Вниманието използва grouped-query attention с 48 глави за заявки и 8 глави за ключ-стойност, с RMSNorm върху заявките и ключовете. Научен sigmoid гейт, изчислен от входа на слоя, мащабира всеки канал на всяка глава преди изходната проекция.

Смес от експерти

Първите 3 слоя използват плътен SwiGLU MLP. Останалите 49 заменят този слой с блок Mixture-of-Experts от 256 експерта, всеки от които е SwiGLU MLP с междинен размер 2560, или приблизително 39 млн. параметъра. Експертите съдържат 98,4% от параметрите на модела.

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

За всеки токен се изпълняват само 8 експерта, така че моделът изчислява всеки токен с приблизително 23 млрд. параметъра. Всичките 256 експерта остават в паметта, затова внедряването изисква паметта на модел със 501 млрд. параметъра, но работи със скоростта на модел с 23 млрд. параметъра. BF16 checkpoint-ът е приблизително 1 TB във формат safetensors. NVFP4 checkpoint-ът съхранява повечето параметри с 4-битова точност за графични процесори NVIDIA Blackwell, а някои параметри се запазват в BF16 за по-добра точност. В Hub има и FP8 checkpoint-и, които са идеални за чипове от сериите Hopper и Ampere.

Ако искате сами да внедрите Beam, разгледайте рецептите за vLLM или SGLang по-долу.

Остатъчен поток

Остатъчните връзки са най-отличителната част. Стандартният трансформер добавя изхода на всеки подслой към потока с тегло 1, така че потокът нараства с дълбочината.

Beam брои входното вграждане като стъпка 1. При стъпка k той добавя изхода на подслоя с тегло 1/sqrt(k) и запазва съществуващия поток с тегло sqrt((k-1)/k). Квадратите на двете тегла дават сбор 1, така че потокът запазва постоянен мащаб от първия до последния слой. След всичките 104 добавяния всеки изход на подслой и входното вграждане носят еднакво тегло в крайното скрито състояние.

Всеки подслой също се нормализира преди и след това, а крайните логити преминават през tanh softcap при ±30, изчислен във FP32. Реализацията фиксира местата, където се изчислява във FP32: маршрутизаторът, произведението SwiGLU, нормите, RoPE, мащабирането на заявките и softcap.

Дълъг контекст

Хибридното внимание работи добре при дълги контексти. Всеки слой кешира 2 x 8 KV глави x 128 измерения = 2048 стойности за токен. Ако всичките 52 слоя съхраняваха всеки токен, кешът би нараствал с 208 KiB на токен. Само 9-те глобални слоя съхраняват цялата последователност. 43-те слоя с плъзгащ се прозорец поддържат фиксиран прозорец от 512 токена и спират да нарастват. Така кешът нараства с 36 KiB на токен, приблизително една шеста от наивната стойност.

Тези числа са за една последователност, в BF16, с динамичния кеш на transformers.

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

Ето резултатите от бенчмарковете при различни нива на точност, предоставени от екипа на Reflection.

Хардуерни изисквания

Най-практичният начин за обслужване на модела е да използвате NVFP4 checkpoint-а, който запазва по-голямата част от качеството на bf16 checkpoint-а. NVFP4 съхранява някои тегла с 4 бита и така намалява параметрите на 501B модела в BF16 от 1 TB до приблизително 280 GB. Графичните процесори Blackwell изпълняват NVFP4 нативно, но по-старите от Blackwell, като H200, не могат. FP8 checkpoint-ите са подходящи за графични процесори, по-стари от Blackwell.

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

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

Beam има поддръжка от деня на пускане в transformers, SGLang и vLLM.

Transformers

Инсталирайте най-новата версия на transformers.

pip install -U "transformers>=5.20.1"

Най-лесният начин да стартирате Beam е чрез pipeline за генериране на текст:

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]

Pipeline връща целия чат. Последното съобщение е отговорът на 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 го прочита и преобразува суровия изход в речник на съобщение с отделни полета за разсъждението, отговора и извикванията на инструменти. Така се избягва обичайният regex за разделяне на разсъждението, отговорите и извикванията на инструменти. Правилата се доставят заедно с токенизатора, така че анализираната структура съответства на това, за което 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 може да бъде число или низ. Със схемите на инструментите парсерът преобразува всеки аргумент към декларирания му тип.

Няколко графични процесора и възела

Конфигурацията на Beam дефинира план за паралелизъм на експертите. При експертния паралелизъм всеки експерт се поставя на едно устройство. Механизмът за внимание, плътните слоеве, вгражданията и LM главата се репликират на всяко устройство. Това са 8 млрд. параметъра, или 16 GB в 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 графични процесора H200. Всеки от тях ще съдържа 78 GB тегла. При 8 графични процесора всеки би съдържал 139 GB, което не оставя място върху H200 с 141 GB. Броят на устройствата трябва да дели броя на експертите, 256.

vLLM

Beam има поддръжка от деня на пускане във vLLM. Командата по-долу обслужва BF16 checkpoint-а с тензорен паралелизъм върху 16 графични процесора (два възела 8x H200) и предоставя API, съвместим с OpenAI:

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

За по-бързо генериране добавете спекулативно декодиране 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. Препоръчваме да го обслужвате със спекулативно декодиране DFlash2, което е включено и в двете команди по-долу. При Blackwell checkpoint-ът 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

При графични процесори Hopper използвайте FP8 checkpoint-а върху 8 H200 вместо това. Променят се само три флага: checkpoint-ът, размерът на тензорния паралелизъм (8 вместо 4) и backend-ът за внимание (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, фикстурите на задачите, оценяващите програми и следите от разговорите се намират в този публичен bucket на Hugging Face.

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

† Ниското разсъждение върна правилния отговор, но пропусна поисканата обосновка. Високото предостави коректно доказателство чрез корените на единицата, проверено независимо.

Не приемайте думите ни на доверие. Разгледайте bucket-а, преработете го за своя случай на употреба или проект и подложете Beam на максимално натоварване.

Дообучаване на Beam

Можете да дообучите Beam за собствените си случаи на употреба. Тук споделяме няколко примера с TRL и Miles, за да започнете с контролирано дообучаване и обучение с подсилване.

SFT с TRL

Най-бързият начин да адаптирате Beam към собствените си данни е контролирано дообучаване със SFTTrainer на TRL. За да поддържаме паметта в разумни граници, обучаваме LoRA адаптери с PEFT, вместо да актуализираме всичките 501 млрд. параметъра: Използвахме SFTTrainer на TRL, за да адаптираме Beam към проста цел: да запазва разсъждението си на езика, поискан от потребителя. Дообучихме го върху Multilingual-Thinking с LoRA, която обучава малък набор от тегла на адаптера, като запазва базовия модел замразен.

Настройката комбинира шардинг на модела при зареждане, експертен паралелизъм, FlashAttention 4 и пакетиране на последователности. LoRA SFT се побира на един възел с 8 графични процесора B300, като достига около 19 000 токена в секунда. Съответната настройка с H100 използва четири възела.

След една епоха върху Multilingual-Thinking Beam разсъждаваше на заявения език при 16 от 16 задържани заявки в сравнение с 3 от 16 за базовия модел. Тази малка оценка измерва придържането към езика, а не правилността на самото разсъждение.

Загуба при обучението (вляво) и средна точност на токените (вдясно) по време на отделно изпълнение от 500 стъпки върху подмножество за разсъждение на open-r1/Mixture-of-Thought, използвайки един възел с 8 графични процесора B300. Тези показатели за обучение са от официалния примерен PR за TRL.

GRPO с Miles

Reflection и RadixArk изградиха рецепта, която обучава модела с GRPO в Miles, в BF16. Можете да актуализирате целия модел или да използвате LoRA за обучение на адаптери, като запазите базовите тегла замразени. Megatron обучава, SGLang генерира rollout-ите, а Miles публикува новите тегла към двигателите за rollout след всяка актуализация. Прегледахме рецептата.

Рецептата изпълнява 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

Какво се случва при rollout:

Извадка: 32 заявки се подават към модела с по 8 отговора. Два двигателя SGLang обслужват rollout-ите върху по 16 графични процесора всеки.

Оценка: Отговорът в рамка се проверява спрямо етикета, с мека санкция за отговори, близки до ограничението за дължина.

Актуализация: Една оптимизаторна стъпка върху всичките 256 извадки. Предимства, относителни към групата, с усечено importance sampling, без санкция за KL или ентропия.

Паралелно обучение: тензорен паралелизъм 8, експертен паралелизъм 8, паралелизъм на данните 8, със sequence parallelism и пълно преизчисляване.

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

Оценяване: AIME25 на всеки пет rollout-а, осем извадки на задача. Checkpoint се запазва на всеки двадесет.

Следващият rollout се генерира, докато текущият се обучава, така че отговорите изостават с една актуализация. Добавете --resume, за да продължите от последния checkpoint. execute-colocate изпълнява същата рецепта върху осем възела, като всеки графичен процесор последователно обучава и обслужва.

Обучение с LoRA

Можете също да изпълнявате GRPO с LoRA върху четири възела 8× H200: 16 графични процесора за обучение и 16 за rollout-и. Рецептата обучава адаптери с ранг 16 върху слоевете за внимание, плътния MLP и експертните слоеве на Beam, като запазва базовите тегла замразени. Само теглата на адаптера се синхронизират със SGLang, а състоянието на оптимизатора остава в паметта на графичния процесор, което премахва нуждата от изнасяне на оптимизатора към 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 долара. Всичко, което трябва да направите, е да създадете хранилище за space, модел или набор от данни и да го споделите на страницата на хранилището на модела. За вдъхновение ето няколко неща, които изградихме.

Хей, 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 coding harness, за да изградим първоначалното нативно приложение за лентата с менюта на macOS, което изпълнява Parakeet с MLX. Запазеното изпълнение включва последващи заявки; крайният изходен код включва и по-късни поправки от Codex. Горната заявка е съкратена версия на изискванията за изграждане.

Можете да разгледате следата на агента за това как Beam изгради приложението в pi в тази следа. Ако искате да изпробвате демото, изтеглете изходния код или прочетете инструкциите за настройка.

Хей, Beam, как се мащабираш с няколко агента?

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

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

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

Можете да проверите изпълненията в таблото Trackio, да разгледате публикуваните данни за резултатите и да използвате повторно harness-а на изследването.

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

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

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

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

За базова линия подадохме на неадаптирания модел пълната политика за триаж и тикета, без примери, и го помолихме да генерира трите решения като JSON. Върху същите 320 синтетични тестови тикета дообученият модел за решения даде и трите правилни отговора в 76,25% от случаи�