TextRL

Textrl: génération de texte avec apprentissage en renforcement

Textrl est une bibliothèque Python qui vise à améliorer la génération de texte en utilisant l'apprentissage en renforcement, en s'appuyant sur les étreintes de Transformers de Face, PFRL et Openai Gym. Textrl est conçu pour être facilement personnalisable et peut être appliqué à divers modèles de génération de texte.

Table des matières

• Introduction
• Exemples
  • Exemple GPT-2
  • Exemple Flan-T5
  • Exemple BigScience / Bloomz-7B1-MT
  • Exemple de Bloom 176b
  • Génération contrôlable via l'exemple RL
• Installation
  • Installation de PIP
  • Construire à partir de la source
• Usage
  • Initialiser l'agent et l'environnement
  • Configuration de la fonction de récompense pour l'environnement
  • Se préparer à la formation
  • Entraînement
• Modèle de vidage
• Paramètres clés pour la formation RL

Introduction

Textrl utilise l'apprentissage du renforcement à affiner les modèles de génération de texte. Il est construit sur les bibliothèques suivantes:

• Transformers de l'étreinte Face
• Pfrl
• Gymnase openai

Exemple - gpt2

Cliquez sur moi

Exemple 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 ]))

Exemple - flan-t5

Cliquez sur moi

Exemple de code

Exemple 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 ]))

Exemple - bigscience/bloomz-7b1-mt

Cliquez sur moi

Exemple 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 ]))

Exemple - 176b Bloom

Cliquez sur moi

Exemple de Bloomz-176b

Recommande fortement contribuer à l'essaim public pour augmenter la capacité des pétales

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

Installer pip install petals -U d'abord

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

Exemple - Génération contrôlable via RL pour laisser Elon Musk parler mal de Doge

Cliquez sur moi

[Génération contrôlable via RL pour laisser Elon Musk parler de mal de Doge] (https://github.com/voidful/textrl/blob/main/example/2022-12-10-TExtrl-elon-Musk.ipynb)

Colab Exemple: BigScience / Bloom-560m

Colab Exmaple: Huggingtweets / Elonmusk

Avant: i think dogecoin is a great idea.
Après: i think dogecoin is a great idea, but I think it is a little overused.

Installation

Installation de PIP

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

Construire à partir de la source

Git Clone et CD dans ce projet.

pip install -e . 

Usage

Initialiser l'agent et l'environnement

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

Configurer la fonction de récompense pour l'environnement

• prédit (list [str]): sera la liste des jetons prévus
• Finition (bool): si la fin de la phrase a été atteinte ou non

 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

Se préparer à la formation

• Observation_List devrait être une liste de toutes les chaînes d'entrée possibles pour la formation du modèle

  Exemple: 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 )

Former

 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.' )

Une autre façon de s'entraîner:

 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' ,
)

Prédiction

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

Cette section d'utilisation mise à jour fournit un guide complet sur la façon d'initialiser l'agent et l'environnement, de configurer la fonction de récompense pour l'environnement, de se préparer à la formation, de former le modèle et de faire des prédictions. Il comprend également une autre façon de former le modèle à l'aide de la fonction train_agent_with_evaluation .

Dépenser le modèle formé au modèle de Huggingface

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

Paramètres clés pour la formation RL

Pour Finetune un modèle de langue utilisant RL, vous devez modifier la fonction de récompense:

 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

Paramètres pour échantillonner divers exemples:

 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

Lors de la formation d'un modèle d'apprentissage par renforcement (RL), plusieurs paramètres clés doivent être réglés pour assurer des performances optimales. Voici une liste de paramètres importants et de leurs descriptions:

1. Intervalle de mise à jour : Cela détermine la fréquence à laquelle l'agent RL met à jour sa politique en fonction des expériences collectées. Un intervalle de mise à jour plus petit signifie que l'agent apprend plus fréquemment des expériences récentes, tandis qu'un intervalle plus important permet à plus d'expériences de s'accumuler avant l'apprentissage. Dans l'exemple ci-dessus, l'intervalle de mise à jour est défini sur 10.

 update_interval = 10

2. Taille de minibatch : le nombre d'expériences échantillonnées du tampon de relecture d'expérience pour calculer la mise à jour du dégradé. Une taille de minibatch plus grande aide à stabiliser l'apprentissage et à réduire la variance, mais au prix d'une augmentation des exigences de calcul.

 minibatch_size = 2000

3. Epochs : le nombre de fois que l'agent itère dans l'ensemble du minibatch pour mettre à jour sa politique. Plus d'époches peuvent conduire à un meilleur apprentissage, mais peuvent augmenter le risque de sur-ajustement.

 epochs = 20

4. Facteur de réduction (Gamma) : Ce paramètre détermine la quantité de récompenses futures réduites lors du calcul du rendement attendu. Une valeur plus proche de 1 rend l'agent plus clairvoyant, tandis qu'une valeur plus proche de 0 rend l'agent plus axé sur les récompenses immédiates.

 gamma = 0.99

5. Taux d'apprentissage : la taille de pas utilisée pour mettre à jour la politique. Un taux d'apprentissage plus important permet une convergence plus rapide mais peut conduire à l'instabilité dans l'apprentissage, tandis qu'un taux d'apprentissage plus petit assure un apprentissage stable au prix d'une convergence plus lente.

 lr = 1e-4

6. Epsilon : un paramètre utilisé dans l'algorithme PPO pour couper le rapport politique. Cela permet de contrôler l'ampleur des mises à jour des politiques, empêchant les mises à jour excessivement importantes qui peuvent déstabiliser l'apprentissage.

 epsilon = 0.2

7. Coefficient d'entropie : Ce paramètre encourage l'exploration en ajoutant une récompense bonus pour avoir pris moins de certaines mesures. Un coefficient d'entropie plus élevé favorise plus d'exploration, tandis qu'un coefficient inférieur concentre l'agent sur l'exploitation des stratégies connues.

 entropy_coef = 0.01

8. Étapes de formation : Le nombre total de mesures prennent l'agent pendant la formation. Plus d'étapes conduisent généralement à un meilleur apprentissage, mais peuvent nécessiter plus de temps de calcul.

 steps = 1000

9. Intervalle d'évaluation : le nombre d'étapes de formation entre les évaluations. L'augmentation de l'intervalle d'évaluation réduit le temps de calcul consacré à l'évaluation, mais il peut également réduire la fréquence à laquelle vous pouvez surveiller les progrès de l'agent.

 eval_interval = 10000

10. Longueur de l'épisode Max : le nombre maximum d'étapes autorisées dans un seul épisode pendant la formation. Cela peut empêcher l'agent de rester coincé dans de longs épisodes improductifs.

 train_max_episode_len = 50

Ces paramètres doivent être soigneusement réglés en fonction du problème et de l'environnement spécifiques pour obtenir les meilleures performances. Il est généralement recommandé de commencer par des valeurs par défaut, puis de les ajuster en fonction du comportement d'apprentissage observé.