Este modelo fue aportado a Hugging Face Transformers el 2026-10-16.

Beam

Resumen

Beam es el primer modelo de pesos abiertos de Reflection, un modelo de lenguaje de mezcla de expertos dispersa (MoE) con 501B de parámetros totales y 23B de parámetros activos por token, diseñado para cargas de trabajo de codificación, razonamiento y agentes. Fue preentrenado con 23,8T de tokens y postentrenado mediante aprendizaje por refuerzo asíncrono a gran escala. Beam es solo texto y razona antes de cada respuesta. Un ajuste de esfuerzo de razonamiento en la plantilla de chat controla cuánto lo hace.

Beam tiene 52 capas decodificadoras y combina las siguientes características:

• Atención deslizante híbrida y atención completa. Cada sexta capa y la última capa utilizan atención completa, y las demás atienden a los sliding_window (512) tokens más recientes. layer_types establece el patrón.
• RoPE en capas deslizantes, NoPE en capas completas. rope_parameters se indexa por tipo de capa, y None marca un tipo de capa sin codificación posicional. Las capas de atención completa escalan las consultas en su lugar (softmax escalable): la consulta en la posición n (basada en 1) se multiplica por (1 + n / 2048) ** 0.1, lo que evita que la atención se aplane a medida que crece el contexto.
• Atención con compuerta. Atención de consultas agrupadas con 48 cabezas de consulta y 8 cabezas de clave/valor, y RMSNorm en cada cabeza de consulta y clave. Una compuerta sigmoide calculada a partir de la entrada de atención, con un sesgo aprendido por cabeza, escala la salida de atención de forma elementa antes de la proyección de salida.
• MoE disperso. Las primeras 3 capas utilizan un MLP SwiGLU denso, y las 49 capas restantes enrutan cada token a 8 de 256 expertos, sin ningún experto compartido (mlp_layer_types establece el patrón). El router puntúa a los expertos con una sigmoide, equilibra la carga con un sesgo aprendido por experto en lugar de una pérdida auxiliar, y restringe cada token a los mejores topk_group de n_group grupos de expertos. Los pesos de enrutamiento se normalizan, y la salida del MoE se escala por routed_scaling_factor.
• Normas tipo sándwich con residuos escalados por profundidad. Cada bloque de atención y MLP se envuelve en un RMSNorm antes y después. Las sumas residuales se reescalan de modo que, tras k contribuciones (contando los embeddings como la primera), el flujo residual sea su suma dividida por sqrt(k).
• Limitación suave de los logits finales. Los logits se limitan con 30 * tanh(logits / 30) (final_logit_softcapping).

La implementación calcula la escalada de RMSNorm, la activación SwiGLU, RoPE, la escalada de consultas, el enrutamiento y el softcapping en FP32 para coincidir con la numérica con la que Beam fue entrenado y servido. Los pesos del enrutador y el sesgo de los expertos se mantienen en FP32 en el momento de la carga, y los logits devueltos siempre son FP32.

Puedes encontrar todos los puntos de control originales de Beam bajo la organización Reflection.

Este modelo fue aportado por yonigozlan.

Ejemplos de uso

La plantilla de chat de Beam formatea las conversaciones en el formato Harmony de Beam, y su plantilla de respuesta analiza el texto generado para devolverlo como un mensaje con los campos thinking, content y tool_calls. Los ejemplos siguientes generan una respuesta con Pipeline o con la clase AutoModelForCausalLM.

El checkpoint BF16 tiene aproximadamente 1 TB, por lo que los ejemplos lo dividen en 8 dispositivos, colocando expertos enrutados completos en cada dispositivo mediante expert parallelism. Lánzalos con 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"])

Prefer this over device_map="auto", which places whole layers on each device, runs them one device at a time, and can run out of memory while loading.

Genera muestras con la temperature=0.7 y la top_p=0.99 recomendadas por Beam, que la GenerationConfig del checkpoint establece como valores predeterminados. Pasa do_sample=False para decodificar de forma codiciosa.

Esfuerzo de razonamiento

Pase reasoning_effort a apply_chat_template() para controlar cuánto razona Beam. Acepta un presupuesto entero o una de las etiquetas siguientes. Beam no se entrenó con esfuerzos inferiores a 8, por lo que los valores más pequeños no se respetan.

Cuando reasoning_effort no está definido, la plantilla usa max. Si max_new_tokens se agota durante el razonamiento, el mensaje analizado tiene thinking pero no content.

Conversaciones de varios turnos

Añade el mensaje analizado al historial tal como está. La salida de Beam se degrada sin su razonamiento anterior, que la plantilla de chat lee de thinking (también se aceptan reasoning_content y reasoning). De forma predeterminada, un turno de asistente sin razonamiento se renderiza con un bloque de razonamiento vacío. Pasa allow_missing_thinking=False para lanzar un error en su lugar cuando add_generation_prompt=True, lo cual se recomienda al servir 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)

Llamada a herramientas

Pasa tools tanto a apply_chat_template() como a parse_response(). Con tools, los argumentos analizados se convierten a los tipos definidos en el esquema de cada herramienta; sin él, todos los argumentos son cadenas de texto.

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

Luego, genera de nuevo desde messages para obtener la respuesta final. Las llamadas a herramientas analizadas no tienen id, y el formato coincide los resultados con las llamadas por posición, por lo que devuelve los resultados de las herramientas en el orden de las llamadas. La generación se detiene después de una respuesta final (<|return|>) o una llamada a herramienta (<|call|>); generation_config.json enumera ambas.

Para la transmisión, get_response_parser() devuelve un analizador al que se le feed() fragmentos de texto a medida que se generan. Consulte Response parsing para más detalles.

Notas

• Argumentos de plantilla. Además de reasoning_effort, la plantilla de chat acepta model_identity (reemplaza la primera línea del mensaje de sistema), builtin_tools y allow_missing_thinking. builtin_tools solo debe nombrar las herramientas search y browse, y solo con las definiciones con las que Beam fue entrenado. Las demás herramientas solo necesitan tools. Los mensajes system y developer solo se renderizan al inicio de la conversación.
• Entrenamiento. La plantilla de chat marca la salida del asistente para apply_chat_template(..., return_dict=True, return_assistant_tokens_mask=True), de modo que SFTConfig(assistant_only_loss=True) de TRL entrena solo con los tokens del asistente. La máscara cubre el razonamiento, la respuesta y las llamadas a herramientas de cada turno del asistente.
• Sin pérdida auxiliar. El router equilibra la carga de los expertos a través de su sesgo, por lo que BeamForCausalLM no calcula ninguna pérdida de equilibrio de carga. output_router_logits=True sigue devolviendo los logits del router.

BeamConfig

>>> from transformers import BeamConfig

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

BeamModel

BeamForCausalLM