Ce modèle a été contribué à Hugging Face Transformers le 2026-10-16.

Beam

Aperçu

Beam est le premier modèle à poids ouverts de Reflection, un modèle de langage sparse mixture-of-experts (MoE) doté de 501 Md de paramètres au total et de 23 Md de paramètres actifs par jeton, conçu pour les tâches de codage, de raisonnement et d’agents. Il a été pré-entraîné sur 23,8 T de jetons puis post-entraîné à l’aide d’un apprentissage par renforcement asynchrone à grande échelle. Beam est exclusivement textuel et il raisonne avant chaque réponse. Un paramètre d’effort de raisonnement dans le modèle de dialogue permet de contrôler l’intensité de ce raisonnement.

Beam comporte 52 couches décodeur et combine les fonctionnalités suivantes :

• Attention glissante hybride et attention complète. Chaque sixième couche et la dernière couche utilisent l’attention complète, tandis que les autres portent sur les sliding_window (512) jetons les plus récents. layer_types définit le motif.
• RoPE sur les couches glissantes, NoPE sur les couches complètes. rope_parameters est indexé par type de couche, et None indique un type de couche sans encodage positionnel. Les couches d'attention complète échangent les requêtes à la place (softmax scalable) : la requête à la position n (base 1) est multipliée par (1 + n / 2048) ** 0.1, ce qui empêche l'attention de s'aplatir lorsque le contexte augmente.
• Attention à porte. Attention à requêtes groupées avec 48 têtes de requête et 8 têtes clé/valeur, et RMSNorm sur chaque tête de requête et de clé. Une porte sigmoïde calculée à partir de l'entrée de l'attention, avec un biais appris par tête, met à l'échelle la sortie de l'attention élément par élément avant la projection de sortie.
• MoE creux. Les 3 premières couches utilisent un MLP SwiGLU dense, et les 49 couches restantes acheminent chaque jeton vers 8 experts parmi 256, sans expert partagé (mlp_layer_types définit le motif). Le routeur évalue les experts avec une sigmoïde, équilibre la charge avec un biais appris par expert au lieu d'une perte auxiliaire, et restreint chaque jeton aux meilleurs topk_group parmi n_group groupes d'experts. Les poids de routage sont normalisés, et la sortie du MoE est mise à l'échelle par routed_scaling_factor.
• Normes en sandwich avec résidus mis à l'échelle selon la profondeur. Chaque bloc d'attention et de MLP est encadré par une RMSNorm avant et après. Les additions résiduelles sont remises à l'échelle de sorte qu'après k contributions (en comptant les embeddings comme la première), le flux résiduel est leur somme divisée par sqrt(k).
• Limitation douce des logits finaux. Les logits sont limités par 30 * tanh(logits / 30) (final_logit_softcapping).

L'implémentation calcule le mise à l'échelle RMSNorm, l'activation SwiGLU, RoPE, la mise à l'échelle des requêtes, le routage et le softcapping en FP32 afin de correspondre à la numérisation avec laquelle Beam a été entraîné et servi. Les poids du routeur et le biais des experts sont conservés en FP32 au moment du chargement, et les logits renvoyés sont toujours en FP32.

Vous pouvez trouver tous les points de contrôle Beam originaux sous l'organisation Reflection.

Ce modèle a été contribué par yonigozlan.

Exemples d'utilisation

Le modèle de chat de Beam met en forme les conversations au format Harmony de Beam, et son modèle de réponse analyse le texte généré pour le convertir en un message avec les champs thinking, content et tool_calls. Les exemples ci-dessous génèrent une réponse avec Pipeline ou la classe AutoModelForCausalLM.

Le checkpoint BF16 fait environ 1 To, les exemples le répartissent donc sur 8 appareils en plaçant des experts routés entiers sur chaque appareil grâce au parallelisme d'experts. Lancez-les avec 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"])

Préférez cette option à device_map="auto", qui place des couches entières sur chaque appareil, les exécute un appareil à la fois et peut épuiser la mémoire pendant le chargement.

Échantillons de génération avec la temperature=0.7 et le top_p=0.99 recommandés par Beam, définis par défaut dans la GenerationConfig du point de contrôle. Passez do_sample=False pour un décodage glouton.

Effort de raisonnement

Passez reasoning_effort à apply_chat_template() pour contrôler le niveau de raisonnement de Beam. Il accepte un budget entier ou l’un des libellés ci-dessous. Beam n’a pas été entraîné avec des efforts inférieurs à 8, les valeurs plus petites ne sont donc pas respectées.

Lorsque reasoning_effort n’est pas défini, le modèle utilise max. Si max_new_tokens est épuisé pendant le raisonnement, le message analysé contient thinking mais pas content.

Conversations multi-tours

Ajoutez le message analysé à l’historique tel quel. La sortie de Beam se dégrade sans son raisonnement antérieur, que le modèle de conversation lit depuis thinking (reasoning_content et reasoning sont également acceptés). Par défaut, un tour d’assistant sans raisonnement est rendu avec un bloc de raisonnement vide. Passez allow_missing_thinking=False pour lever une erreur à la place lorsque add_generation_prompt=True, ce qui est recommandé lors du service de 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)

Appel d'outils

Passez tools à la fois à apply_chat_template() et à parse_response(). Avec tools, les arguments analysés sont convertis aux types définis dans le schéma de chaque outil ; sans cela, chaque argument est une chaîne de caractères.

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})

Générez ensuite à nouveau à partir de messages pour obtenir la réponse finale. Les appels d’outils analysés n’ont pas d’id, et le format associe les résultats aux appels par position, il faut donc renvoyer les résultats des outils dans l’ordre des appels. La génération s’arrête après une réponse finale (<|return|>) ou un appel d’outil (<|call|>) ; generation_config.json liste les deux.

Pour le streaming, get_response_parser() renvoie un parseur auquel vous feed() des fragments de texte au fur et à mesure de leur génération. Consultez Response parsing pour plus de détails.

Notes

• Arguments du modèle. En plus de reasoning_effort, le modèle de chat accepte model_identity (remplace la première ligne du message système), builtin_tools et allow_missing_thinking. builtin_tools ne doit nommer que les outils search et browse, et uniquement avec les définitions avec lesquelles Beam a été entraîné. Les autres outils n’ont besoin que de tools. Les messages system et developer ne sont rendus qu’au début de la conversation.
• Entraînement. Le modèle de conversation marque la sortie de l’assistant pour apply_chat_template(..., return_dict=True, return_assistant_tokens_mask=True), de sorte que SFTConfig(assistant_only_loss=True) de TRL entraîne le modèle uniquement sur les jetons de l’assistant. Le masque couvre le raisonnement, la réponse et les appels d’outils de chaque tour de l’assistant.
• Aucune perte auxiliaire. Le routeur équilibre la charge des experts via son biais, de sorte que BeamForCausalLM ne calcule aucune perte d’équilibrage de charge. output_router_logits=True renvoie toujours les logits du routeur.

BeamConfig

>>> from transformers import BeamConfig

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

BeamModel

BeamForCausalLM