TextRL

Textrl: Generación de texto con aprendizaje de refuerzo

Textrl es una biblioteca de Python que tiene como objetivo mejorar la generación de texto utilizando el aprendizaje de refuerzo, basándose en abrazar a los transformadores de Face, PFRL y OpenAi Gym. TexTRL está diseñado para ser fácilmente personalizable y se puede aplicar a varios modelos de generación de texto.

Tabla de contenido

• Introducción
• Ejemplos
  • Ejemplo de GPT-2
  • Ejemplo de flan-t5
  • BigScience/Bloomb-7B1-MT Ejemplo
  • Ejemplo de Bloom de 176b
  • Generación controlable a través de RL Ejemplo
• Instalación
  • Instalación de PIP
  • Construir desde la fuente
• Uso
  • Inicializar agente y entorno
  • Función de recompensa de configuración para el entorno
  • Prepárese para el entrenamiento
  • Capacitación
• Modelo de vertido
• Parámetros clave para el entrenamiento RL

Introducción

TEXTRL utiliza el aprendizaje de refuerzo para ajustar los modelos de generación de texto. Se basa en las siguientes bibliotecas:

• Abrazando los transformadores de la cara
• PFRL
• Gimnasio de Openai

Ejemplo - gpt2

Haz clic en mí

Ejemplo de GPT2

 import pfrl
from textrl import TextRLEnv , TextRLActor , train_agent_with_evaluation
from transformers import AutoModelForCausalLM , AutoTokenizer
import logging
import sys

logging . basicConfig ( level = logging . INFO , stream = sys . stdout , format = '' )

checkpoint = "gpt2"

tokenizer = AutoTokenizer . from_pretrained ( checkpoint )
model = AutoModelForCausalLM . from_pretrained ( checkpoint , torch_dtype = "auto" , device_map = "auto" )

model = model . cuda ()


class MyRLEnv ( TextRLEnv ):
    def get_reward ( self , input_item , predicted_list , finish ):  # predicted will be the list of predicted token
        reward = [ 0 ]
        if finish :
            reward = [ 1 ]  # calculate reward score base on predicted_list
        return reward


observaton_list = [{ "input" : "explain how attention work in seq2seq model" }]
env = TextRLEnv ( model , tokenizer , observation_input = observaton_list , max_length = 20 , compare_sample = 2 )
actor = TextRLActor ( env , model , tokenizer ,
                    act_deterministically = False ,
                    temperature = 1.0 ,
                    top_k = 0 ,
                    top_p = 1.0 ,
                    repetition_penalty = 2 )
agent = actor . agent_ppo ( update_interval = 2 , minibatch_size = 2 , epochs = 10 )
print ( actor . predict ( observaton_list [ 0 ]))

train_agent_with_evaluation (
    agent ,
    env ,
    steps = 100 ,
    eval_n_steps = None ,
    eval_n_episodes = 1 ,
    eval_interval = 2 ,
    outdir = 'bloom—test' ,
)

print ( actor . predict ( observaton_list [ 0 ]))

Ejemplo - flan-t5

Haz clic en mí

Código de ejemplo

Ejemplo de Colab: Google/Flan-T5-Base

 import pfrl
from textrl import TextRLEnv , TextRLActor , train_agent_with_evaluation
from transformers import AutoModelForSeq2SeqLM , AutoTokenizer
import logging
import sys

logging . basicConfig ( level = logging . INFO , stream = sys . stdout , format = '' )


tokenizer = AutoTokenizer . from_pretrained ( "google/flan-t5-base" )  
model = AutoModelForSeq2SeqLM . from_pretrained ( "google/flan-t5-base" )
model . eval ()
model . cuda ()

sentiment = pipeline ( 'sentiment-analysis' , model = "cardiffnlp/twitter-roberta-base-sentiment" , tokenizer = "cardiffnlp/twitter-roberta-base-sentiment" , device = 0 , return_all_scores = True )

class MyRLEnv ( TextRLEnv ):
    def get_reward ( self , input_item , predicted_list , finish ): # predicted will be the list of predicted token
      reward = 0
      if finish or len ( predicted_list [ 0 ]) >= self . env_max_length :
        predicted_text = tokenizer . convert_tokens_to_string ( predicted_list [ 0 ])
        # sentiment classifier
        reward = sentiment ( input_item [ 'input' ] + predicted_text )[ 0 ][ 0 ][ 'score' ] * 10
      return reward

observaton_list = [{ 'input' : 'i think dogecoin is' }]
env = MyRLEnv ( model , tokenizer , observation_input = observaton_list , compare_sample = 1 )
actor = TextRLActor ( env , model , tokenizer , optimizer = 'adamw' ,
                    temperature = 0.8 ,
                    top_k = 100 ,
                    top_p = 0.85 ,)
agent = actor . agent_ppo ( update_interval = 50 , minibatch_size = 3 , epochs = 10 , lr = 3e-4 )
print ( actor . predict ( observaton_list [ 0 ]))

pfrl . experiments . train_agent_with_evaluation (
    agent ,
    env ,
    steps = 3000 ,
    eval_n_steps = None ,
    eval_n_episodes = 1 ,       
    train_max_episode_len = 100 ,  
    eval_interval = 10 ,
    outdir = 'checkpoint' , 
)
agent . load ( "./checkpoint/best" )
print ( actor . predict ( observaton_list [ 0 ]))

Ejemplo- bigscience/bloomz-7b1-mt

Haz clic en mí

Ejemplo de Bloomz-7B1-MT

 import pfrl
from textrl import TextRLEnv , TextRLActor , train_agent_with_evaluation
from transformers import AutoModelForCausalLM , AutoTokenizer
import logging
import sys

logging . basicConfig ( level = logging . INFO , stream = sys . stdout , format = '' )

checkpoint = "bigscience/bloomz-7b1-mt"

tokenizer = AutoTokenizer . from_pretrained ( checkpoint )
model = AutoModelForCausalLM . from_pretrained ( checkpoint , torch_dtype = "auto" , device_map = "auto" )

model = model . cuda ()


class MyRLEnv ( TextRLEnv ):
    def get_reward ( self , input_item , predicted_list , finish ):  # predicted will be the list of predicted token
        reward = [ 0 ]
        if finish :
            reward = [ 1 ]  # calculate reward score base on predicted_list
        return reward


observaton_list = [{ "input" : "explain how attention work in seq2seq model" }]
env = TextRLEnv ( model , tokenizer , observation_input = observaton_list , max_length = 20 , compare_sample = 2 )
actor = TextRLActor ( env , model , tokenizer ,
                    act_deterministically = False ,
                    temperature = 1.0 ,
                    top_k = 0 ,
                    top_p = 1.0 )
agent = actor . agent_ppo ( update_interval = 2 , minibatch_size = 2 , epochs = 10 )
print ( actor . predict ( observaton_list [ 0 ]))

train_agent_with_evaluation (
    agent ,
    env ,
    steps = 100 ,
    eval_n_steps = None ,
    eval_n_episodes = 1 ,
    eval_interval = 2 ,
    outdir = 'bloom—test' ,
)

print ( actor . predict ( observaton_list [ 0 ]))

Ejemplo - 176b Bloom

Haz clic en mí

Ejemplo de Bloomz-176b

Recomiendo encarecidamente contribuir en el enjambre público para aumentar la capacidad de los pétalos

https://github.com/bigscience-workshop/petals

Instale pip install petals -U primero

 import pfrl
from textrl import TextRLEnv , TextRLActor , train_agent_with_evaluation
from transformers import BloomTokenizerFast
from petals import DistributedBloomForCausalLM
import logging
import sys

logging . basicConfig ( level = logging . INFO , stream = sys . stdout , format = '' )

MODEL_NAME = "bigscience/bloom-petals"
tokenizer = BloomTokenizerFast . from_pretrained ( MODEL_NAME )
model = DistributedBloomForCausalLM . from_pretrained ( MODEL_NAME )
model = model . cuda ()


class MyRLEnv ( TextRLEnv ):
    def get_reward ( self , input_item , predicted_list , finish ):  # predicted will be the list of predicted token
        reward = [ 0 ]
        if finish :
            reward = [ 1 ]  # calculate reward score base on predicted_list
        return reward


observaton_list = [{ "input" : "explain how attention work in seq2seq model" }]
env = TextRLEnv ( model , tokenizer , observation_input = observaton_list , max_length = 20 , compare_sample = 2 )
actor = TextRLActor ( env , model , tokenizer ,
                    act_deterministically = False ,
                    temperature = 1.0 ,
                    top_k = 0 ,
                    top_p = 1.0 )
agent = actor . agent_ppo ( update_interval = 2 , minibatch_size = 2 , epochs = 10 )

print ( actor . predict ( observaton_list [ 0 ]))

train_agent_with_evaluation (
    agent ,
    env ,
    steps = 100 ,
    eval_n_steps = None ,
    eval_n_episodes = 1 ,
    eval_interval = 2 ,
    outdir = 'bloom—test' ,
)

print ( actor . predict ( observaton_list [ 0 ]))

Ejemplo - Generación controlable a través de RL para que Elon Musk hable enfermo de Doge

Haz clic en mí

[Generación controlable a través de RL para dejar que Elon Musk hable enfermo de doge] (https://github.com/voidful/textrl/blob/main/example/2022-10-textrl-elon-musk.ipynb)

Ejemplo de Colab: BigScience/Bloom-560m

Colab Exmaple: HuggingTweets/Elonmusk

Antes: i think dogecoin is a great idea.
Después: i think dogecoin is a great idea, but I think it is a little overused.

Instalación

Instalación de PIP

pip install pfrl@git+https://github.com/voidful/pfrl.git
pip install textrl

Construir desde la fuente

Git Clone y CD en este proyecto.

pip install -e . 

Uso

Inicializar agente y entorno

 import torch
from textrl import TextRLEnv , TextRLActor , train_agent_with_evaluation
from transformers import AutoModelForCausalLM , AutoTokenizer

checkpoint = "bigscience/bloomz-7b1-mt"

tokenizer = AutoTokenizer . from_pretrained ( checkpoint )
model = AutoModelForCausalLM . from_pretrained ( checkpoint , torch_dtype = "auto" , device_map = "auto" )

model = model . cuda ()

Configurar la función de recompensa para el entorno

• predicho (lista [str]): será la lista de tokens predichos
• terminar (bool): si se ha alcanzado o no el final de la oración

 class MyRLEnv ( TextRLEnv ):
    def get_reward ( self , input_item , predicted_list , finish ):
        if finish :
            reward = [ 0 ]  # calculate reward score based on predicted_list
        return reward

Prepárese para el entrenamiento

• observación_list debe ser una lista de todas las cadenas de entrada posibles para el entrenamiento de modelos

  Ejemplo: observation_list = [{"input":'testing sent 1'},{"input":'testing sent 2'}]

 env = MyRLEnv ( model , tokenizer , observation_input = observation_list )
actor = TextRLActor ( env , model , tokenizer )
agent = actor . agent_ppo ( update_interval = 10 , minibatch_size = 2000 , epochs = 20 )

Tren

 n_episodes = 1000
max_episode_len = 200  # max sentence length

for i in range ( 1 , n_episodes + 1 ):
    obs = env . reset ()
    R = 0
    t = 0
    while True :
        action = agent . act ( obs )
        obs , reward , done , pred = env . step ( action )
        R += reward
        t += 1
        reset = t == max_episode_len
        agent . observe ( obs , reward , done , reset )
        if done or reset :
            break
    if i % 10 == 0 :
        print ( 'episode:' , i , 'R:' , R )
    if i % 50 == 0 :
        print ( 'statistics:' , agent . get_statistics ())
print ( 'Finished.' )

Otra forma de entrenar:

 import logging
import sys

logging . basicConfig ( level = logging . INFO , stream = sys . stdout , format = '' )

train_agent_with_evaluation (
    agent ,
    env ,
    steps = 1000 ,
    eval_n_steps = None ,
    eval_n_episodes = 1500 ,
    train_max_episode_len = 50 ,
    eval_interval = 10000 ,
    outdir = 'somewhere' ,
)

Predicción

 agent . load ( "somewhere/best" )  # loading the best model
actor . predict ( "input text" )

Esta sección de uso actualizado proporciona una guía completa sobre cómo inicializar el agente y el entorno, configurar la función de recompensa para el medio ambiente, prepararse para la capacitación, capacitar al modelo y hacer predicciones. También incluye una forma alternativa de entrenar el modelo utilizando la función train_agent_with_evaluation .

Volcar el modelo entrenado al modelo de Huggingface

textrl-dump --model ./model_path_before_rl --rl ./rl_path --dump ./output_dir

Parámetros clave para el entrenamiento RL

Para Finetune un modelo de idioma que usa RL, debe modificar la función de recompensa:

 from textrl import TextRLEnv

class MyRLEnv ( TextRLEnv ):
    def get_reward ( self , input_item , predicted_list , finish ):
        # input_item is the prompt input for the model, it will be one of your observation
        # an observation will be a list of sentence of eg: ['inputted sentence','xxx','yyy']
        # only the first input will feed to the model 'inputted sentence', and 
        # the remaining can be the reference for reward calculation

        # predicted_list is the list of predicted sentences of RL model generated,
        # it will be used for ranking reward calculation

        # finish is the end of sentences flags, get_reward will be called during generating each word, and 
        # when finish is True, it means the sentence is finished, it will use for sentence level reward calculation.

        # reward should be the list equal to the length of predicted_list
        return reward

Parámetros para muestreo de diversos ejemplos:

 actor = TextRLActor ( env , model , tokenizer ,
                    act_deterministically = False ,  # select the max probability token for each step or not
                    temperature = 1 ,                # temperature for sampling
                    compare_sample = 2 ,             # num of sample to rank
                    top_k = 0 ,                      # top k sampling
                    top_p = 1.0 ,)                    # top p sampling

Al capacitar a un modelo de aprendizaje de refuerzo (RL), se deben ajustar varios parámetros clave para garantizar un rendimiento óptimo. Aquí hay una lista de parámetros importantes y sus descripciones:

1. Intervalo de actualización : esto determina con qué frecuencia el agente RL actualiza su política en función de las experiencias recopiladas. Un intervalo de actualización más pequeño significa que el agente aprende con más frecuencia de experiencias recientes, mientras que un intervalo más grande permite que se acumulen más experiencias antes del aprendizaje. En el ejemplo anterior, el intervalo de actualización se establece en 10.

 update_interval = 10

2. Tamaño del minibatch : el número de experiencias muestreadas del búfer de reproducción de experiencia para calcular la actualización de gradiente. Un tamaño de minibatch más grande ayuda a estabilizar el aprendizaje y reducir la varianza, pero a costa de un aumento de los requisitos computacionales.

 minibatch_size = 2000

3. Épocas : el número de veces que el agente itera a través de todo el minibatch para actualizar su política. Más épocas pueden conducir a un mejor aprendizaje, pero pueden aumentar el riesgo de sobreajuste.

 epochs = 20

4. Factor de descuento (gamma) : este parámetro determina cuántas recompensas futuras se descartan al calcular el rendimiento esperado. Un valor más cercano a 1 hace que el agente sea más intensivo, mientras que un valor más cercano a 0 hace que el agente se centre más en las recompensas inmediatas.

 gamma = 0.99

5. Tasa de aprendizaje : el tamaño de paso utilizado para actualizar la política. Una tasa de aprendizaje más grande permite una convergencia más rápida, pero puede conducir a la inestabilidad en el aprendizaje, mientras que una tasa de aprendizaje más pequeña garantiza un aprendizaje estable a costa de una convergencia más lenta.

 lr = 1e-4

6. Epsilon : un parámetro utilizado en el algoritmo PPO para recortar la relación de política. Esto ayuda a controlar la magnitud de las actualizaciones de políticas, evitando actualizaciones excesivamente grandes que puedan desestabilizar el aprendizaje.

 epsilon = 0.2

7. Coeficiente de entropía : este parámetro fomenta la exploración al agregar una recompensa de bonificación por tomar menos acciones. Un coeficiente de entropía más alto promueve más exploración, mientras que un coeficiente más bajo enfoca al agente en la explotación de estrategias conocidas.

 entropy_coef = 0.01

8. Pasos de entrenamiento : el número total de pasos que el agente da durante el entrenamiento. Más pasos generalmente conducen a un mejor aprendizaje, pero pueden requerir más tiempo computacional.

 steps = 1000

9. Intervalo de evaluación : el número de pasos de entrenamiento entre evaluaciones. El aumento del intervalo de evaluación reduce el tiempo computacional dedicado a la evaluación, pero también puede reducir la frecuencia a la que puede monitorear el progreso del agente.

 eval_interval = 10000

10. Longitud máxima del episodio : el número máximo de pasos permitidos en un solo episodio durante el entrenamiento. Esto puede evitar que el agente se atasque en episodios largos e improductivos.

 train_max_episode_len = 50

Estos parámetros deben ajustarse cuidadosamente en función del problema y el entorno específicos para lograr el mejor rendimiento. Generalmente se recomienda comenzar con valores predeterminados y luego ajustarlos en función del comportamiento de aprendizaje observado.