Model ini disumbangkan ke Hugging Face Transformers pada 2026-10-16.

Beam

Ikhtisar

Beam adalah model open-weight pertama dari Reflection, yaitu model bahasa sparse mixture-of-experts (MoE) dengan total 501B parameter dan 23B parameter aktif per token, yang dibangun untuk workload coding, penalaran, dan agentic. Model ini dipretrain pada 23,8T token dan dipost-train menggunakan reinforcement learning asinkron berskala besar. Beam hanya mendukung teks, dan ia melakukan penalaran sebelum setiap jawaban. Pengaturan reasoning effort dalam chat template mengontrol seberapa dalam penalaran tersebut.

Beam memiliki 52 lapisan decoder dan menggabungkan fitur-fitur berikut:

• Perhatian geser hibrida dan penuh. Setiap lapisan keenam dan lapisan terakhir menggunakan perhatian penuh, sedangkan lapisan lainnya memperhatikan sliding_window (512) token terbaru. layer_types mengatur polanya.
• RoPE pada lapisan sliding, NoPE pada lapisan penuh. rope_parameters menggunakan tipe lapisan sebagai kunci, dan None menandai tipe lapisan tanpa encoding posisi. Lapisan full-attention justru menskalakan query (softmax yang dapat diskalakan): query pada posisi n (berbasis 1) dikalikan dengan (1 + n / 2048) ** 0.1, yang menjaga agar attention tidak mendatar seiring bertambahnya konteks.
• Atensi bergerbang. Atensi kueri berkelompok dengan 48 kepala kueri dan 8 kepala kunci/nilai, serta RMSNorm pada setiap kepala kueri dan kunci. Gerbang sigmoid yang dihitung dari masukan atensi, dengan bias yang dipelajari per kepala, menskalakan keluaran atensi secara elemen demi elemen sebelum proyeksi keluaran.
• MoE Sparse. Tiga lapisan pertama menggunakan MLP SwiGLU padat, dan 49 lapisan sisanya merutekan setiap token ke 8 dari 256 ahli, tanpa ahli bersama (mlp_layer_types mengatur polanya). Router memberi skor pada ahli dengan sigmoid, menyeimbangkan beban dengan bias per-ahli yang dipelajari alih-alih kerugian tambahan, dan membatasi setiap token ke topk_group terbaik dari n_group grup ahli. Bobot routing dinormalisasi, dan keluaran MoE diskalakan dengan routed_scaling_factor.
• Norm sandwich dengan residual yang diskalakan berdasarkan kedalaman. Setiap blok attention dan MLP dibungkus dengan RMSNorm sebelum dan sesudah. Penambahan residual diskalakan ulang sehingga, setelah k kontribusi (menghitung embeddings sebagai yang pertama), aliran residual adalah jumlah mereka dibagi dengan sqrt(k).
• Softcapping logit akhir. Logits dibatasi dengan 30 * tanh(logits / 30) (final_logit_softcapping).

Implementasi menghitung penskalaan RMSNorm, aktivasi SwiGLU, RoPE, penskalaan query, routing, dan softcapping dalam FP32 agar sesuai dengan numerik yang digunakan saat Beam dilatih dan disajikan. Bobot router dan bias ahli dipertahankan dalam FP32 saat dimuat, dan logits yang dikembalikan selalu dalam FP32.

Anda dapat menemukan semua checkpoint Beam asli di bawah organisasi Reflection.

Model ini disumbangkan oleh yonigozlan.

Contoh penggunaan

Template chat Beam memformat percakapan dalam format Harmony milik Beam, dan template respons-nya mengurai teks yang dihasilkan kembali menjadi pesan dengan bidang thinking, content, dan tool_calls. Contoh di bawah ini menghasilkan balasan dengan Pipeline atau kelas AutoModelForCausalLM.

Checkpoint BF16 berukuran sekitar 1 TB, sehingga contoh membaginya ke 8 perangkat, menempatkan seluruh routed experts di setiap perangkat dengan expert parallelism. Jalankan dengan torchrun --nproc-per-node 8 <script.py>.

from transformers import DistributedConfig, pipeline

pipe = pipeline(
    task="text-generation",
    model="reflection/Beam-1.0-501B-A23B",
    model_kwargs={"distributed_config": DistributedConfig(tp_size=8, ep_size=8)},
)

messages = [{"role": "user", "content": "Explain in one sentence why the sky is usually blue."}]
output = pipe(messages, max_new_tokens=2048)
reply = output[0]["generated_text"][-1]
print(reply["thinking"])
print(reply["content"])

from transformers import AutoModelForCausalLM, AutoTokenizer, DistributedConfig

model_id = "reflection/Beam-1.0-501B-A23B"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, distributed_config=DistributedConfig(tp_size=8, ep_size=8))

messages = [{"role": "user", "content": "Explain in one sentence why the sky is usually blue."}]
inputs = tokenizer.apply_chat_template(
    messages, add_generation_prompt=True, return_tensors="pt", return_dict=True, reasoning_effort="low"
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=2048)
generated = tokenizer.decode(outputs[0, inputs["input_ids"].shape[1] :])
message = tokenizer.parse_response(generated, prefix=inputs["input_ids"][0])
print(message["thinking"])
print(message["content"])

Gunakan ini alih-alih device_map="auto", yang menempatkan seluruh lapisan di setiap perangkat, menjalankannya satu perangkat pada satu waktu, dan dapat kehabisan memori saat memuat.

Contoh generasi dengan temperature=0.7 dan top_p=0.99 yang direkomendasikan Beam, yang ditetapkan sebagai nilai default oleh GenerationConfig checkpoint. Luluskan do_sample=False untuk melakukan dekoding secara greedy.

Usaha penalaran

Lewatkan reasoning_effort ke apply_chat_template() untuk mengontrol seberapa banyak Beam melakukan penalaran. Parameter ini menerima anggaran berupa bilangan bulat atau salah satu label di bawah ini. Beam tidak dilatih dengan effort di bawah 8, sehingga nilai yang lebih kecil tidak dihormati.

Ketika reasoning_effort tidak disetel, template menggunakan max. Jika max_new_tokens habis selama penalaran, pesan yang diurai memiliki thinking tetapi tidak ada content.

Percakapan multi-pusing

Lampirkan pesan yang telah diurai ke dalam riwayat apa adanya. Output Beam akan menurun tanpa penalaran sebelumnya, yang dibaca oleh template chat dari thinking (reasoning_content dan reasoning juga diterima). Secara default, giliran asisten tanpa penalaran akan dirender dengan blok penalaran kosong. Lewatkan allow_missing_thinking=False untuk memicu error sebagai gantinya ketika add_generation_prompt=True, yang direkomendasikan saat menyajikan Beam.

messages.append(message)
messages.append({"role": "user", "content": "And why are sunsets red?"})
inputs = tokenizer.apply_chat_template(
    messages, add_generation_prompt=True, return_tensors="pt", return_dict=True
).to(model.device)

Pemanggilan alat

Lewatkan tools ke apply_chat_template() dan parse_response(). Dengan tools, argumen yang diurai akan dicetak ke tipe data dalam skema masing-masing tool; tanpa itu, setiap argumen berupa string.

def get_weather(city: str):
    """
    Get the current weather in a city.

    Args:
        city: The city name.
    """
    return "Sunny, 22 C"


messages = [{"role": "user", "content": "What's the weather like in Paris right now?"}]
inputs = tokenizer.apply_chat_template(
    messages, tools=[get_weather], add_generation_prompt=True, return_tensors="pt", return_dict=True
).to(model.device)
outputs = model.generate(**inputs, max_new_tokens=2048)
generated = tokenizer.decode(outputs[0, inputs["input_ids"].shape[1] :])
message = tokenizer.parse_response(generated, prefix=inputs["input_ids"][0], tools=[get_weather])
print(message["tool_calls"])
# [{'type': 'function', 'function': {'name': 'get_weather', 'arguments': {'city': 'Paris'}}}]

messages.append(message)
for call in message["tool_calls"]:
    result = get_weather(**call["function"]["arguments"])
    messages.append({"role": "tool", "name": call["function"]["name"], "content": result})

Lalu, generate lagi dari messages untuk mendapatkan jawaban akhir. Tool call yang di-parse tidak memiliki id, dan formatnya mencocokkan hasil dengan panggilan berdasarkan posisi, sehingga kembalikan hasil tool sesuai urutan panggilannya. Generation berhenti setelah jawaban akhir (<|return|>) atau tool call (<|call|>); generation_config.json mencantumkan keduanya.

Untuk streaming, get_response_parser() mengembalikan parser yang Anda feed() dengan potongan teks saat mereka dihasilkan. Lihat Parsing respons untuk detail lebih lanjut.

Catatan

• Argumen template. Selain reasoning_effort, template chat menerima model_identity (menggantikan baris pertama pesan sistem), builtin_tools, dan allow_missing_thinking. builtin_tools hanya boleh menyebut alat search dan browse, dan hanya dengan definisi yang digunakan saat pelatihan Beam. Alat lain hanya memerlukan tools. Pesan system dan developer hanya dirender di awal percakapan.
• Pelatihan. Template chat menandai output asisten untuk apply_chat_template(..., return_dict=True, return_assistant_tokens_mask=True), sehingga SFTConfig(assistant_only_loss=True) dari TRL hanya melatih pada token asisten. Masker mencakup penalaran, jawaban, dan panggilan tool dari setiap giliran asisten.
• Tidak ada loss tambahan. Router menyeimbangkan beban pakar melalui bias-nya, sehingga BeamForCausalLM tidak menghitung loss penyeimbangan beban. output_router_logits=True tetap mengembalikan logits router.

BeamConfig

>>> from transformers import BeamConfig

>>> # Initializing a Beam configuration
>>> configuration = BeamConfig()

BeamModel

BeamForCausalLM