TextRL

Textrl: Pembuatan teks dengan pembelajaran penguatan

Textrl adalah perpustakaan Python yang bertujuan untuk meningkatkan pembuatan teks menggunakan pembelajaran penguatan, membangun Transformers Face, PFRL, dan Openai Gym. TEXTRL dirancang agar mudah disesuaikan dan dapat diterapkan pada berbagai model generasi teks.

Daftar isi

• Perkenalan
• Contoh
  • Contoh GPT-2
  • Contoh Flan-T5
  • Contoh BigScience/Bloomz-7B1-MT
  • Contoh mekar 176b
  • Pembuatan yang dapat dikendalikan melalui contoh RL
• Instalasi
  • Pip Instal
  • Membangun dari sumber
• Penggunaan
  • Inisialisasi agen dan lingkungan
  • Mengatur fungsi hadiah untuk lingkungan
  • Bersiaplah untuk pelatihan
  • Pelatihan
• Model pembuangan
• Parameter kunci untuk pelatihan RL

Perkenalan

TEXTRL menggunakan pembelajaran penguatan untuk menyempurnakan model generasi teks. Itu dibangun di atas perpustakaan berikut:

• Memeluk transformator wajah
• Pfrl
• Gym openai

Contoh - gpt2

Klik saya

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

Contoh - flan-t5

Klik saya

Kode contoh

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

Contoh- bigscience/bloomz-7b1-mt

Klik saya

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

Contoh - 176b Bloom

Klik saya

Contoh Bloomz-176b

Sangat merekomendasikan berkontribusi pada gerombolan umum untuk meningkatkan kapasitas kelopak

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

Instal pip install petals -U

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

Contoh - generasi yang dapat dikendalikan melalui RL untuk membiarkan Elon Musk berbicara buruk tentang Doge

Klik saya

[Generasi Terkontrol melalui RL untuk membiarkan Elon Musk berbicara buruk dari Doge] (https://github.com/voidful/textrl/blob/main/example/2022-12-10-textrl-elon-musk.ipynb)

Contoh Colab: BigScience/Bloom-560m

Colab Exmaple: HuggingTweets/Elonmusk

Sebelumnya: i think dogecoin is a great idea.
Setelah: i think dogecoin is a great idea, but I think it is a little overused.

Instalasi

Pip Instal

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

Membangun dari sumber

Git Clone dan CD ke dalam proyek ini.

pip install -e . 

Penggunaan

Inisialisasi agen dan lingkungan

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

Mengatur fungsi hadiah untuk lingkungan

• diprediksi (daftar [str]): akan menjadi daftar token yang diprediksi
• finish (bool): apakah akhir kalimat telah tercapai atau tidak

 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

Bersiaplah untuk pelatihan

• Observation_list harus menjadi daftar semua string input yang mungkin untuk pelatihan model

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

Kereta

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

Cara lain untuk berlatih:

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

Ramalan

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

Bagian penggunaan yang diperbarui ini memberikan panduan komprehensif tentang cara menginisialisasi agen dan lingkungan, mengatur fungsi hadiah untuk lingkungan, mempersiapkan pelatihan, melatih model, dan membuat prediksi. Ini juga termasuk cara alternatif untuk melatih model menggunakan fungsi train_agent_with_evaluation .

Model terlatih buang untuk model Huggingface

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

Parameter kunci untuk pelatihan RL

Untuk memperbaiki model bahasa menggunakan RL, Anda perlu memodifikasi fungsi hadiah:

 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

Parameter untuk pengambilan sampel beragam contoh:

 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

Saat melatih model pembelajaran penguatan (RL), beberapa parameter utama perlu disetel untuk memastikan kinerja yang optimal. Berikut adalah daftar parameter penting dan deskripsinya:

1. Perbarui Interval : Ini menentukan seberapa sering agen RL memperbarui kebijakannya berdasarkan pengalaman yang dikumpulkan. Interval pembaruan yang lebih kecil berarti agen belajar lebih sering dari pengalaman baru -baru ini, sementara interval yang lebih besar memungkinkan lebih banyak pengalaman untuk menumpuk sebelum belajar. Dalam contoh di atas, interval pembaruan diatur ke 10.

 update_interval = 10

2. Ukuran MiniBatch : Jumlah pengalaman yang disampel dari buffer replay pengalaman untuk menghitung pembaruan gradien. Ukuran minibatch yang lebih besar membantu menstabilkan pembelajaran dan mengurangi varian, tetapi dengan biaya peningkatan persyaratan komputasi.

 minibatch_size = 2000

3. Epochs : berapa kali agen mengulangi seluruh minibatch untuk memperbarui kebijakannya. Lebih banyak zaman dapat menyebabkan pembelajaran yang lebih baik tetapi dapat meningkatkan risiko overfitting.

 epochs = 20

4. Faktor Diskon (Gamma) : Parameter ini menentukan berapa banyak hadiah di masa depan yang didiskon saat menghitung pengembalian yang diharapkan. Nilai yang lebih dekat ke 1 membuat agen lebih berpandangan jauh, sementara nilai yang lebih dekat ke 0 membuat agen lebih fokus pada imbalan langsung.

 gamma = 0.99

5. Tingkat Pembelajaran : Ukuran langkah yang digunakan untuk memperbarui kebijakan. Tingkat pembelajaran yang lebih besar memungkinkan konvergensi yang lebih cepat tetapi dapat menyebabkan ketidakstabilan dalam pembelajaran, sementara tingkat pembelajaran yang lebih kecil memastikan pembelajaran yang stabil dengan biaya konvergensi yang lebih lambat.

 lr = 1e-4

6. Epsilon : Parameter yang digunakan dalam algoritma PPO untuk memotong rasio kebijakan. Ini membantu mengendalikan besarnya pembaruan kebijakan, mencegah pembaruan yang terlalu besar yang dapat mengacaukan pembelajaran.

 epsilon = 0.2

7. Koefisien Entropi : Parameter ini mendorong eksplorasi dengan menambahkan hadiah bonus karena mengambil tindakan yang kurang tertentu. Koefisien entropi yang lebih tinggi mempromosikan lebih banyak eksplorasi, sementara koefisien yang lebih rendah memfokuskan agen untuk mengeksploitasi strategi yang diketahui.

 entropy_coef = 0.01

8. Langkah Pelatihan : Jumlah total langkah yang diambil agen selama pelatihan. Lebih banyak langkah biasanya mengarah pada pembelajaran yang lebih baik tetapi mungkin memerlukan lebih banyak waktu komputasi.

 steps = 1000

9. Interval evaluasi : Jumlah langkah pelatihan antara evaluasi. Meningkatkan interval evaluasi mengurangi waktu komputasi yang dihabiskan untuk evaluasi, tetapi juga dapat mengurangi frekuensi di mana Anda dapat memantau kemajuan agen.

 eval_interval = 10000

10. Max Episode Length : Jumlah langkah maksimum yang diizinkan dalam satu episode selama pelatihan. Ini dapat mencegah agen agar tidak terjebak dalam episode yang panjang dan tidak produktif.

 train_max_episode_len = 50

Parameter ini perlu disesuaikan dengan hati -hati berdasarkan masalah dan lingkungan spesifik untuk mencapai kinerja terbaik. Secara umum disarankan untuk memulai dengan nilai default dan kemudian menyesuaikannya berdasarkan perilaku belajar yang diamati.