Descripción general on CoMLRL

Entrenamiento basado en la relación de longitud

Mon, 01 Jan 0001 00:00:00 +0000

Este tutorial demuestra una tarea de entrenamiento simple con dos agentes, utilizando una recompensa basada en la relación de longitud. Ambos agentes reciben la misma instrucción y generan de forma independiente; el segundo agente no ve la respuesta del primer agente. La recompensa incentiva que la segunda salida contenga 2–3× más caracteres que la primera. No evalúa la calidad de la historia ni la colaboración semántica.

Los usuarios pueden ejecutar el ejemplo desde una copia de código instalada:

Escritura

Mon, 01 Jan 0001 00:00:00 +0000

Instalación

Mon, 01 Jan 0001 00:00:00 +0000

CoMLRL se puede instalar desde PyPI, conda-forge, o desde la fuente y soporta Python 3.10 o posterior. Los usuarios también deben instalar una versión de PyTorch compatible con su dispositivo.

Instalación desde PyPI#

pip install comlrl
# Install PyTorch compatible with your device.

Instalación desde conda-forge#

conda install -c conda-forge comlrl
# Install PyTorch compatible with your device.

Instalación desde la fuente#

Los usuarios también pueden clonar el repositorio e instalar CoMLRL en modo editable para acceder a las últimas funciones o desarrollarlo localmente:

Multi-agente REINFORCE

Mon, 01 Jan 0001 00:00:00 +0000

REINFORCE es una clase de métodos de gradiente de política que optimiza la política directamente utilizando recompensas muestreadas. Estos métodos se utilizan ampliamente para el ajuste fino de LLM debido a su simplicidad y eficiencia. Ejemplos incluyen GRPO, Dr. GRPO, RLOO, ReMax, TreeRPO, y REINFORCE++. REINFORCE se puede extender a entornos multi-agente, donde múltiples agentes LLM responden en cada turno y sus respuestas conjuntas reciben una recompensa compartida.

Todos los MAREINFORCE trainers comparten un único bucle de entrenamiento. En cada nodo rollout, cada agente muestrea respuestas $$ K $$ , el trainer puntúa las respuestas conjuntas alineadas con índices utilizando una recompensa compartida, y cada agente pondera sus propias probabilidades logarítmicas por las ventajas compartidas resultantes antes de un paso optimizador en búfer.

Reanudar Entrenamiento

Mon, 01 Jan 0001 00:00:00 +0000

Este ejemplo entrena dos agentes pequeños para dos epochs, luego continúa la misma ejecución para dos epochs adicionales a partir de un punto de control. Ambas partes se registran en una única ejecución de W&B.

Configuración#

La tarea pide al segundo agente que escriba una respuesta de 2 a 3 veces más larga que la respuesta del primer agente.

import math
from pathlib import Path

from datasets import Dataset
from transformers import AutoModelForCausalLM, AutoTokenizer
from comlrl.trainers.reinforce import MAGRPOConfig, MAGRPOTrainer
from comlrl.utils import read_checkpoint_metadata

model_name = "Qwen/Qwen2.5-0.5B"
tokenizer = AutoTokenizer.from_pretrained(model_name)
train_dataset = Dataset.from_dict({
 "prompt": [
 "Describe a city in the clouds:",
 "Invent a new holiday and explain it:",
 "Write a bedtime story for a dragon:",
 "Design a playground on Mars:",
 ]
})


def length_ratio_reward(completions1, completions2):
 rewards = []
 for first, second in zip(completions1, completions2):
 ratio = len(second) / max(len(first), 1)
 distance = 0.0 if 2 <= ratio <= 3 else min(abs(ratio - 2), abs(ratio - 3))
 rewards.append(math.exp(-distance))
 return rewards

La misma función construye trainer para ambas partes de la ejecución, por lo que los dos trainers coinciden.

Soporte

Mon, 01 Jan 0001 00:00:00 +0000

Soporte#

Nos complace ayudar con los problemas que se encuentren al utilizar CoMLRL.

Informar problemas#

Los siguientes pasos pueden ayudar a los usuarios a resolver o informar un problema:

Los usuarios pueden consultar primero la documentación, incluyendo la función de búsqueda (Ctrl + K).
Una búsqueda de problemas existentes GitHub puede revelar informes del mismo problema.
Un ejemplo mínimo reproducible ayuda a diagnosticar el problema. Algunas líneas de código que demuestren el problema pueden conducir a una respuesta más rápida.

Aprendizaje multiagente Actor-Critic

Mon, 01 Jan 0001 00:00:00 +0000

Los métodos Actor-Critic (AC) son ampliamente utilizados métodos de gradiente de política que utilizan critics para apoyar el entrenamiento. Los métodos AC pueden lograr una varianza más baja y una mejor eficiencia de muestreo que REINFORCE, pero esto requiere un diseño y ajuste cuidadosos de critic para garantizar un entrenamiento estable. En el Aprendizaje por Refuerzo Multiagente (MARL), Actor-Critic incluyen Multiagente Actor-Critic (MAAC) y Independiente Actor-Critic (IAC).

Ambos lanzan los agentes conjuntamente y puntúan su respuesta conjunta con la función de recompensa, pero utilizan critics de forma diferente. MAAC entrena un critic con la historia conjunta, de modo que cada agente comparte su TD error. IAC entrena un critic por agente con la historia de ese agente, de modo que cada agente obtiene su propio TD error.

Contribuyendo

Mon, 01 Jan 0001 00:00:00 +0000

Contribuyendo#

Las contribuciones a CoMLRL son bienvenidas. Esta guía cubre los cambios de código y el mantenimiento del código base.

Directrices de desarrollo#

Los colaboradores pueden bifurcar el repositorio principal.

Los siguientes comandos clonan la bifurcación y la sincronizan con el repositorio principal:

 git clone https://github.com/<your-username>/CoMLRL.git
 cd CoMLRL
 git remote add upstream https://github.com/OpenMLRL/CoMLRL.git
 git fetch upstream
 git checkout -b feature/<short-description> upstream/main
 git fetch upstream && git rebase upstream/main

Los colaboradores pueden implementar nuevas funciones o corregir errores y actualizar la documentación según sea necesario.
Los cambios se pueden enviar al repositorio principal como una solicitud de extracción para su revisión.

Entidades de entrenamiento

Mon, 01 Jan 0001 00:00:00 +0000

CoMLRL soporta el entrenamiento de LLM y facilita su entrenamiento con modelos de recompensa basados en LLM o critics. Los agentes y critics pueden ser modelos homogéneos o heterogéneos provenientes de Hugging Face o directorios locales. Los usuarios pueden especificar identificadores de modelo Hugging Face a través de agent_model/critic_model para configuraciones homogéneas, o proporcionar listas agents/critics para configuraciones heterogéneas. Las entidades entrenadas pueden guardarse y cargarse en un nuevo trainer para un entrenamiento adicional.

Programación

Mon, 01 Jan 0001 00:00:00 +0000

Retroalimentación en Múltiples Turnos

Mon, 01 Jan 0001 00:00:00 +0000

En este ejemplo, dos agentes responden a una tarea, reciben retroalimentación sobre sus respuestas y luego responden de nuevo.

Configuración#

La tarea pide al segundo agente que escriba una respuesta de 2 a 3 veces más larga que la respuesta del primer agente.

import math

from datasets import Dataset
from transformers import AutoModelForCausalLM, AutoTokenizer
from comlrl.trainers.reinforce import MAGRPOConfig, MAGRPOTrainer

model_name = "Qwen/Qwen2.5-0.5B"
tokenizer = AutoTokenizer.from_pretrained(model_name)
train_dataset = Dataset.from_dict({
 "prompt": [
 "Describe a city in the clouds:",
 "Invent a new holiday and explain it:",
 "Write a bedtime story for a dragon:",
 "Design a playground on Mars:",
 ]
})


def length_ratio_reward(completions1, completions2):
 rewards = []
 for first, second in zip(completions1, completions2):
 ratio = len(second) / max(len(first), 1)
 distance = 0.0 if 2 <= ratio <= 3 else min(abs(ratio - 2), abs(ratio - 3))
 rewards.append(math.exp(-distance))
 return rewards

Retroalimentación entre Turnos#

Después del primer turno, esta función escribe una nueva instrucción para cada agente. La instrucción informa sobre la longitud de las respuestas.

Completar código

Mon, 01 Jan 0001 00:00:00 +0000

Inicialización del entrenamiento

Mon, 01 Jan 0001 00:00:00 +0000

El entrenamiento se inicializa a partir de un conjunto de tareas, un conjunto de tareas que comparten un formato de entrada y una recompensa. Los formatters convierten cada tarea en indicaciones para el agente, y una función de recompensa evalúa las respuestas conjuntas de los agentes.

Conjuntos de tareas#

Un conjunto de tareas es un Hugging Face Dataset o IterableDataset cuyos elementos de fila son elementos de tarea, cada uno un diccionario. El formatteur predeterminado lee el campo prompt; campos adicionales pueden contener objetivos, etiquetas, casos de prueba u otra información requerida por la función de recompensa. Trainers pasa el elemento de tarea original a la función de recompensa a través de batch_items.

Multi-LLM PbRL

Mon, 01 Jan 0001 00:00:00 +0000

Multi-agente PbRL entrena agentes colaborativos LLM a partir de preferencias entre sus respuestas conjuntas. CoMLRL construye los datos de preferencia a partir de elementos de la tarea y aprende con uno de dos algoritmos: MARLHF ajusta un modelo de recompensa conjunto y luego entrena las políticas con RL, mientras que MADPO optimiza las políticas directamente a partir de las preferencias. MARLHFTrainer, MADPOTrainer, y sus variantes iterativas MARLHFIterTrainer y MADPOIterTrainer están disponibles de comlrl.trainers.preference.

Registro de cambios

Mon, 01 Jan 0001 00:00:00 +0000

Registro de cambios#

Versión 1.4.3#

Soporte para algoritmos MAPL, incluyendo MARLHF y MADPO (PR #72).
Soporte para el entrenamiento de sistemas multi-agente centralizados (PR #72).
Refinar la documentación.

Versión 1.4.2#

Soporte para más modelos de comparador (commit e1b3d80).
Solucionar el problema de generación homogénea (commit 11d89a9).

Versión 1.4.1#

Soporte para utilizar el comparador como coordinador centralizado (PR #69).
Permitir el despliegue de agentes LLM, el modelo de recompensa y el comparador en diferentes dispositivos (commit 7cbb792).
Permit la copia de modelos actuales como comparadores en nuevos dispositivos (commit d8d493a).
Optimizar el uso de memoria de GPU liberando rápidamente los modelos no utilizados (commit d0c6376).

Versión 1.4.0#

Añadir métodos online de PbRL (PR #68).
Añadir registrador de deriva de conjuntos de datos.

Versión 1.3.9#

Añadir métodos offline de PbRL como MADPO y MARLHF (PR #67).

Versión 1.3.8#

Permitir el uso de un modelo de referencia para todos los algoritmos (PR #65).
Unificar el registrador entre diferentes trainers (PR #66).

Versión 1.3.7#

Eliminar los hiperparámetros de muestreo redundantes en los algoritmos.
Permit el entrenamiento con múltiples GPU utilizando MP (ver resultados en PR #62).

Versión 1.3.6#

Solucionar un fallo crítico al cargar modelos heterogéneos y refactorizar la lógica de carga del modelo (ver resultados en PR #60).
Pulir la documentación.

Versión 1.3.5#

Añadir pruebas unitarias para restricciones de hiperparámetros.
Limpiar interfaces heredadas.

Versión 1.3.4#

Solucionar el fallo al cargar modelos heterogéneos y refactorizar la lógica de carga.
Habilitar MBGD en MAGRPO para alinearse con MAAC y IAC.
Eliminar hiperparámetros redundantes y heredados (p. ej., parámetros kwargs del modelo, hiperparámetros de parcheo).
Limpiar código heredado de múltiples dispositivos, como drop_last y num_workers.
Añadir pruebas unitarias para la carga del modelo y separarlas de CI como un distintivo.
Limpiar funciones cortas.
Reorganizar la documentación y alinear los parámetros.

Versión 1.3.3#

Compactar la derivación de MAREINFORCETrainer y moverla a la nueva carpeta.
Unificar la interfaz para diferentes trainers.
Eliminar parches y envoltorios redundantes.
Reorganizar las variables en los archivos de configuración YAML.

Versión 1.3.2#

Solucionar el problema de registro de wandb en MAGRPOTrainer.

Versión 1.3.1#

Permitir el entrenamiento por lotes en MAGRPOTrainer, IACTrainer y MAACTrainer.
Permit el entrenamiento en múltiples turnos en IACTrainer y MAACTrainer.
Cambiar el eje x de data_step a env_step.

Versión 1.3.0#

Utilizar TD como el critic objetivo de actualización en IACTrainer y MAACTrainer.

Versión 1.2.9#

Añadir MAACTrainer (centralizado critic); tanto IACTrainer como MAACTrainer ahora admiten el entrenamiento de un solo turno.

Versión 1.2.8#

El critic en IACTrainer ahora estima V en lugar de Q.

Versión 1.2.7#

Cambiar IPPOTrainer a IACTrainer.

Versión 1.2.6#

Incluir MAGRPO, MAREINFORCE, MARLOO, MAREMAX y IPPO trainers para el aprendizaje por refuerzo multiagente con LLMs.
Soporte para el entrenamiento en múltiples turnos con mecanismos de retroalimentación externa personalizados.
Entornos de colaboración LLM para diversas tareas.
Documentación y ejemplos completos para comenzar.

Interacción en múltiples turnos

Mon, 01 Jan 0001 00:00:00 +0000

Muchos problemas complejos requieren más de un turno para resolver. Los agentes LLM interactúan con el entorno para obtener comentarios útiles de otros modelos o herramientas en el sistema.

Respuesta conjunta MAGRPO#

La respuesta conjunta MAGRPO construye un árbol rollout cuyas ramas representan diferentes respuestas conjuntas (TreeRPO).

Árbol conjunto rollout Observaciones y acciones conjuntas se ramifican en rollouts independientes.

Cada episode comienza con una tarea muestreada del conjunto de datos, que proporciona las observaciones iniciales $\mathbf{o}_0=\{o_{1, 0}, \cdots, o_{n, 0}\}$ e historias $\mathbf{h}_0=\{h_{1, 0}, \cdots, h_{n, 0}\}$ para todos los agentes. En cada turno, los agentes generan un grupo de respuestas conjuntas $\mathbf{a}^{\mathcal{G}}_t\gets\boldsymbol{\pi}^{\mathcal{G}}(\cdot|\mathbf{h}_t)$ a partir de su historial de observación-acción actual $\mathbf{h}_t$ . Cada respuesta inicia una rama distinta rollout. Los agentes reciben recompensas conjuntas $r^{(g)}_{t}$ para cada respuesta, en función del historial acumulado y la acción conjunta actual $\mathbf{a}^{(g)}_{t} \in \mathbf{a}^{\mathcal{G}}_{t}$ . Cada rollout evoluciona de forma independiente, produciendo nuevas observaciones conjuntas $\mathbf{o}^{\mathcal{G}}_{t+1}$ a medida que cambia el entorno y se ramifica en nuevas ramas rollouts en el siguiente turno $$ t+1 $$ . Este proceso continúa hasta el turno terminal $$ H $$ .

Viaje

Mon, 01 Jan 0001 00:00:00 +0000

Paralelización del entrenamiento

Mon, 01 Jan 0001 00:00:00 +0000

CoMLRL puede colocar diferentes modelos en diferentes GPUs. Con parallel_training="mp", cada agente se ejecuta en su propio dispositivo de agent_devices, y los agentes generan simultáneamente; critics, modelos de recompensa, comparadores y modelos de referencia tienen sus propias configuraciones de dispositivo. El modo predeterminado, "none", mantiene a los agentes en un solo dispositivo. Ambos modos se ejecutan en una sola máquina y no requieren un programador de trabajos.

Cada modelo se ejecuta completamente en su dispositivo asignado y no se divide entre GPUs. Los índices de dispositivo se refieren a los GPUs visibles a través de CUDA_VISIBLE_DEVICES. Una configuración para varios modelos utiliza un dispositivo por modelo o un solo dispositivo para todos, para que los usuarios puedan adaptar la colocación a los GPUs disponibles y a la memoria de cada modelo. La colocación de dispositivos y la programación en paralelo pueden afectar a los resultados del entrenamiento numérico.

Uso de herramientas

Mon, 01 Jan 0001 00:00:00 +0000

Preguntas y respuestas

Mon, 01 Jan 0001 00:00:00 +0000

¿Cuáles son las diferencias entre CoMLRL y otros marcos de entrenamiento multi-LLM?

Muchas plataformas de desarrollo soportan el entrenamiento de sistemas multi-agente basados en LLM, específicos para cada rol (PettingLLMs, Dr. MAS, MARTI). La mayoría están formuladas como juegos estocásticos parcialmente observables (POSGs), en los que cada agente tiene su propia recompensa. Las reglas de recompensa creadas manualmente para cada agente o rol hacen que las señales de entrenamiento sean más densas, pero son difíciles de diseñar.