Datasets:

qgallouedec

/

trl-metrics

like 0

lvwerra

Thanks @vwxyzjn for the clarification of the nomenclature! I think the hyperparameter your are citing are for the initialization of the policy before the PPO training. For the PPO training they mention: > The batch size for each iteration is 512, with a minibatch size of 64. In other words, each batch is randomly split into 8 minibatches and is trained on for only a single inner epoch (Schulman et al., 2017). So indeed a mini-bs>1 is used. I think we can address that quite easily with #100 if we use the attention mask to mask out the appropriate parts of the input. cc @younesbelkada

vwxyzjn

> Does this mean this is building multi-envs to collect rollouts? I think multi-envs in this case is kind of like multiple instances of conversations :) > The batch size for each iteration is 512, Ah, my mistake. Thanks for the info 🙏 > So indeed a mini-bs>1 is used. I think we can address that quite easily with https://github.com/lvwerra/trl/pull/100 if we use the attention mask to mask out the appropriate parts of the input. cc @younesbelkada Sorry, I am probably missing something... What parts of the input should we mask out related to the minibatch size? It sounds like a minibatch of size 64 would mean 64 independent prompts as obs, 64 responses as actions, and 64 scalar rewards. We are trying to mask out the future tokens in each of these 64 prompts, right?

lvwerra

@vwxyzjn mostly a practical thing: when we batch 64 sequences together which can have unequal length we need to pad the tensors. In transformers the tensors then usually come with an attention mask telling you where the paddings are: we can use this to know where each prompt/response starts and ends and where the paddings are we can ignore.

younesbelkada

Hi, yes we are currently refactoring the repository to make it more accessible for more models & to do distributed training if you want to use the examples on the notebook please use `trl` from the previous release `pip install trl` Check #64

HuggingFaceDocBuilderDev

_The documentation is not available anymore as the PR was closed or merged._

HuggingFaceDocBuilderDev

_The documentation is not available anymore as the PR was closed or merged._

HuggingFaceDocBuilderDev

_The documentation is not available anymore as the PR was closed or merged._

lewtun

Thanks for the comments @lvwerra ! I left a few questions that could do with your feedback - in the meantime I'll add some tests :)

lewtun

🔴 Don't merge until I have a fix! Hmm, using the staging endpoint of the Hub for the test is causing some issues because I rely on `whoami()` to get the username in the model card, and that method doesn't allow me to distinguish between endpoints

HuggingFaceDocBuilderDev

_The documentation is not available anymore as the PR was closed or merged._

HuggingFaceDocBuilderDev

_The documentation is not available anymore as the PR was closed or merged._

lvwerra

This should also address #42

HuggingFaceDocBuilderDev

_The documentation is not available anymore as the PR was closed or merged._

LouisCastricato

BTW, I can confirm that SetFit does make for a really good zero shot RM. There are some issues with using contrastive models as RMs though. It often requires very careful data cleaning and identifying what kinds of clusters work as RMs is a dark art to the point where we decided that it wasn't worth seriously pursing further after CARP CoOp. Rerank models are much better.

TristanThrush

I think that the "coolest" dataset we can use to train a model could be https://huggingface.co/datasets/openai/webgpt_comparisons, but it is hard to evaluate this sort of model after we train it. I might start by adding a summarization example, and then some decent ways by which it can be evaluated. Then the webgpt comparisons example

AlexWortega

https://colab.research.google.com/drive/1hkPBFtMP5xBAjNYMjWH7NqYn118kRLOJ?usp=sharing I am trying to implement own gpt + trl with QA retrival reward, but i think something is wrong with reward/or generation

natolambert

@AlexWortega can you open a separate issue / PR for this? Looks interesting, but may get loss in this big 1.0 roadmap thread.

lvwerra

We ended up calling this release `0.2` (not `1.0`). I am closing the issue and will move the open tasks to a new issue.

AlexWortega

Hi @lvwerra i opened PR https://github.com/lvwerra/trl/pull/149 with this feature(?) idea

HuggingFaceDocBuilderDev

_The documentation is not available anymore as the PR was closed or merged._

HuggingFaceDocBuilderDev

_The documentation is not available anymore as the PR was closed or merged._

lvwerra

All comments should be addressed. Also applied the quality to the recent merges.

HuggingFaceDocBuilderDev

_The documentation is not available anymore as the PR was closed or merged._

HuggingFaceDocBuilderDev

The docs for this PR live [here](https://moon-ci-docs.huggingface.co/docs/trl/pr_59). All of your documentation changes will be reflected on that endpoint.

younesbelkada

wandb run (multi-GPU) after the latest commit: https://wandb.ai/distill-bloom/trl/runs/1mps4h09?workspace=user-younesbelkada

younesbelkada

Wandb log of the final run: https://wandb.ai/distill-bloom/trl/runs/dcd2gqn1?workspace=user-younesbelkada

HuggingFaceDocBuilderDev

_The documentation is not available anymore as the PR was closed or merged._

lvwerra

Regarding 1: see equation (11) in https://arxiv.org/abs/1506.02438 and 2) yes you are correct.

lvwerra

It seems like the reward of your model increases, no? So maybe worth investigating if the classifier actually works well?

lvwerra

Also the KL-divergence is allowed to raise but the controller should at some point bring it back down.

lvwerra

Coming soon - see #53!

22Mukesh22

That's Great , waiting for GPT-J to learn through human feedback ? But what in your thought, Bert classifier will be able to reward the text generated ?? Or there will be any other reward model who can give the score for the generated task.

conceptofmind

Are we able to use any Causal LLM from the model hub now that #53 is merged?

lvwerra

Yes, that should work!

younesbelkada

Seems to be converging with the latest changes: https://wandb.ai/distill-bloom/gpt2-test/runs/1sxufahx?workspace=user-younesbelkada

younesbelkada

Moved all images inside the org https://huggingface.co/trl-internal-testing and fixed all image links on README + notebooks with the correct ones Also as discussed, I removed the 3 first notebooks ;) Let me know what is missing here!

lvwerra

Seems not possible https://stackoverflow.com/questions/66587174/how-to-remove-generated-from-tag

younesbelkada

Thanks for the review! I should have removed the CI, done the renaming of the files ;-)

younesbelkada

For now I am testing my implementation with `accelerate launch example/ppo-accelerate.py`

younesbelkada

Regarding tests, this is tricky but from what I can see we can for now: - Test if all trainers respects the inheritance from `BaseTrainer` (by checking if all the needed functions are implemented) - Test if all models work as expected (thinking of `generate` method) and if we can in fact support all `xxxForCausalLM` architectures as claimed above. From what I can see, as long as the model has a proper `generate` method the PPOTrainer should work

younesbelkada

Closing in favor of https://github.com/lvwerra/trl/pull/58

lvwerra

Thanks, I'll fix that!

lvwerra

Should be fixed with #80.

lvwerra

Thanks, I'll fix that! 🤗

lvwerra

Closed with #49

Alymostafa

Try to work on a new env and install the transformers library again. Also, make sure to load and import pyarrow.

lvwerra

This seems like an issue with the `tokenizers` library. Can you install it `pip install tokenizers` alone?

lvwerra

Thanks, the README is from `nbs/index.ipynb` so this is a limitation of `nbdev`. Might remove that in the next iteration.

JulesGM

weird that nbdev doesn't do that, maybe sending a pull request their way would be good On Wed, Dec 7, 2022 at 4:44 AM Leandro von Werra ***@***.***> wrote: > Thanks, the README is from nbs/index.ipynb so this is a limitation of > nbdev. Might remove that in the next iteration. > > — > Reply to this email directly, view it on GitHub > <https://github.com/lvwerra/trl/pull/45#issuecomment-1340666778>, or > unsubscribe > <https://github.com/notifications/unsubscribe-auth/AAYU34NJRTBJ77WQRXWYN4DWMBL6DANCNFSM6AAAAAARCXKCKU> > . > You are receiving this because you authored the thread.Message ID: > ***@***.***> >

lvwerra

Interesting, you might be right! I'll have a look at this :)

lvwerra

Should be fixed now :)

clam004

So I did some research on my own and basically my first 2 questions can be answered by looking at the huggingface transformers repository: https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py

danjohnvelasco

> So I did some research on my own and basically my first 2 questions can be answered by looking at the huggingface transformers repository: https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py Hi @clam004, do you mind explaining your answer/understanding on why they do it? Thanks!

clam004

@danjohnvelasco as long as you use the same name `self.lm_head`, when you load the pretrained model from the dictionary of parameters, these linear parameters will be replaced with the trained ones. So thats why the model still works (question 2). Also regarding question 3, I suspect somehow it doesnt matter, although Im not sure why, cause when I run this repo without the dropout layer, as expected, it behaves the same.

lvwerra

Regarding 3 I agree and we moved the dropout before the linear layer in https://github.com/lvwerra/trl/pull/70.

lvwerra

Soon? :P

lvwerra

Closing this in favour of #66. Let me know if you had something else in mind and we can re-open :)

MichaelKarpe

Hey, sorry for not coming back sooner on this with an explanation, I wanted to provide evidence the proposed changes were necessary as it was a change in the requirements. If I remember well, I needed `transformers>=4.15.0` and I couldn't make it work without `wandb>=0.12.17`. The `wandb>=0.12.17` change could eventually still be needed, this is not urgent however to make this change as an installation from scratch should install the most recent version. I will eventually check later that the project cannot work without `wandb>=0.12.17`, but this time I am not providing a timeline on when I'll check this! :slightly_smiling_face:

parshinsh

I confirm that this issue happens. I'm facing the same problem with my own task. Can anyone help with this?

Alymostafa

same problem here with a longer sequence. @vblagoje @lvwerra

Alymostafa

@adhitya-synth I used the same configuration as you mentioned and I found out that when the batch size is small it happens as you said but with a larger batch size as in the notebook, the reward increases.

hdvvip

Recently, I came across OpenAI InstructGPT which is an upgrade version of GPT-3 that has been trained with reinforcement learning. The reinforcement learning they used for training InstructGPT is PPO which is implemented in this github repository. Related to the problem that the reward is stagnant or going down, I think even OpenAI (fathers of PPO) also face the same issue. Please see the Figure 13 below. "As shown in Figure 13, the reward saturates after the initial 400k examples of training."  Here is InstructGPT paper. https://arxiv.org/pdf/2203.02155.pdf

hdvvip

Thus, based on the OpenAI experiments in InstructGPT paper, I think that it's based on the dataset you used to train your model. In OpenAI case, with the best implementation of PPO, they still failed to improve the rewards when they train GPT-3 using PPO on FLAN and T0 datasets. 

hdvvip

Thus, if you used PPO on your task and it doesn't work. Don't be surprised! Like I said above, some tasks PPO will work. Some tasks, it won't.

Alymostafa

Thanks for the clarification. But, I am mentioning that based on his observations when the batch size is small what he mentioned happens, but when I increased the batch size I was able to reproduce the same results as in the notebook.

hdvvip

Well, I think we have some misunderstanding here. I didn't specifically mention you in post. I just want to explain to everyone here that depend on your tasks, PPO may work or not. So, it's not your fault when PPO failed on your NLP task. Everyone here has different tasks, so my answer didn't have anything to do with batch size. BTW, OpenAI used batch size of 128 but still failed.

lvwerra

Thanks for the discussion here. Indeed, it can depend a lot on the hyperparameters as well as the task. Great you found that increasing the BS works. I think this is still a very underexplored area!

leoribeiro

@adhitya-synth I face the same problem when using larger text. Did you figure it out a way to overcome this?

hdvvip

Ok I understood, you used [logprob](https://github.com/lvwerra/trl/blob/4fe9988eb8adf0227c26432f8eb3e57a66556350/trl/ppo.py#L156) of the current network as theta_old train_stats = self.train_minibatch(logprobs[idx].unsqueeze(0), values[idx].unsqueeze(0), rewards[idx].unsqueeze(0), queries[idx].unsqueeze(0), responses[idx].unsqueeze(0), torch.cat([queries[idx],responses[idx]]).unsqueeze(0)) This works similarly to update theta_old after every iteration.

Alymostafa

What is the value of the Batch size you use?

lvwerra

See #41

lvwerra

Will have a look!

22Mukesh22

Hi @lvwerra Any fix on the above error ? I was running the notebook '04-gpt2-sentiment-ppo-training.ipynb' for the first time, and received a Key Error when running the training loop section. It was in this line: rewards = torch.tensor([output[1]["score"] for output in pipe_outputs]).to(device) I presume it is safe to omit the '[1]'? rewards = torch.tensor([output["score"] for output in pipe_outputs]).to(device)

lvwerra

It should be fixed now!

lvwerra

Also this PR finally fixes the tests.

lvwerra

This should be in principle possible, maybe this needs some modifications to the `PPOTrainer` but you can probably treat the decoder of an encoder-decoder architecture such as BART or T5 like the GPT-2 decoder. This was also requested in #13 and #23. Feel free to open a PR if you have a working solution!

lvwerra

You should be using the same class to load the model e.g. `GPT2HeadWithValueModel` or `AutoModelForCausalLM` (although I haven't tested the latter). `AutoModel` will load the model without LM head.

lvwerra

Hi @dhruv2601, with #35 this should be fixed.

lvwerra

I think that makes sense. I have not used a seq2seq model, yet. So you might want to start with a decoder only model that should work and then compare the results to your enc-dec approach. Good luck!

lvwerra

You could set the `init_kl_coeff=0` (see [here](https://github.com/lvwerra/trl/blob/750f5fd5329bb81c79b00243c4c8923ac14981d5/trl/ppo.py#L93)) to liberate the model from the reference completely or increase the KL target `target` (which is 6 by default).

yananchen1989

> You could set the `init_kl_coeff=0` (see [here](https://github.com/lvwerra/trl/blob/750f5fd5329bb81c79b00243c4c8923ac14981d5/trl/ppo.py#L93)) to liberate the model from the reference completely or increase the KL target `target` (which is 6 by default). Thanks.

yananchen1989

By the way, do you have investigations on how to tune the txt_in_len, txt_out_len to better sever the topic/sentiment preservation of the generated texts? Currently, I find that fine-tuning the GPT2 before applying it into generation makes difference.

lvwerra

No, I have not experimented much with these parameters. The main motivations for using input text at all is to force some variations in the generation. Yes, I suspect one gets the best (or rather quickest) performance gains when first using supervised training to bring the initial LM distribution as close to the desired target distribution. This also makes the KL constrained better defined as you measure it against a LM on the same domain.

yananchen1989

@lvwerra Hi, I recently find you that you added a simple code demo here https://lvwerra.github.io/trl// where `ppo_config = {'batch_size': 1, 'forward_batch_size': 1}` I suppose this is single sample mode, rather than batch. Based on your experience, did you find any difference on performance between single and batch mode? Is there any other cautions when using single mode to update the GPT2? Thanks in advance.

lvwerra

Hi @yananchen1989, the simple code demo is just a proof of concept demo and I never used that config for the actual training. I did not run many experiments changing these settings and just sticked to the settings from the [original paper](https://arxiv.org/abs/1909.08593).

yananchen1989

@lvwerra Thanks. I find that it is so crucial to design a good reward feedback module that can return a reward with positive or negative value. And the reference GPT also need to be fine-tuned on some related corpus. These two points make it very unpractical. During my trials, if I do not fine-tune the reference GPT to some texts, (as there are no appropriate texts for finetuning), or only has a reward classifier which only give positive feedbacks, for example, if the generated text is not much like a politics article, the reward module would just score it to, say, 0.001; or on the contrary, if it is much like a politics news, the score would be 0.973, then the generated texts after several iterations of PPO training would deteriorate, ending up into repetitive snippets or meaningless results, even though I have tuned the parameters such as kl coefficients, etc.

lvwerra

I think the fine-tuning is not a necessary step but improves stability and convergence. For the reward function, I don't see the point for a strictly positive reward. What would you try to learn from it?

ozyyshr

Hi, thanks for the great work. I also want to know whether and how it can be used for masked token predictions. Thanks in advance!

lvwerra

Reinforcement learning is designed for sequential decision problems and thus works well for causal language modeling (such as GPT-2). BERT however does not fall in that category since it is a one-shot prediction and not a sequential prediction such as in language modeling. So I don't think it is straight forward to adapt this approach.

lvwerra

As you can see later in the code the advantages are used for the loss calculations and not the returns: https://github.com/lvwerra/trl/blob/750f5fd5329bb81c79b00243c4c8923ac14981d5/trl/ppo.py#L240

lvwerra

Yes, that is true - well spotted! I'll add it as a TODO.

lvwerra

Interesting - must be an issue with the newer verisons of `pip`. Will likely drop the dependency to `simpletransformers` in the next release.

lvwerra

Dropped `simpletransformers` requirement in #25.

vblagoje

@lvwerra I tried this branch on both imdb ppo notebooks (the basic ppo sentiment training and the controlled sentiment ppo). They both work as expected, please try it as well. Let me know if any other checks should be done.

lvwerra

awesome! did you also use weights and biases? in case you did, would you mind sharing the logs?

vblagoje

Yes, I did but I deleted the first report for `04-gpt2-sentiment-ppo-training.ipynb`. Here is the report for [05-gpt2-sentiment-control.ipynb](https://wandb.ai/vblagoje/gpt2-ctrl/reports/05-gpt2-sentiment-control-ipyn--Vmlldzo0OTI4MjA?accessToken=0ogcb46btflg488lfuw1zu3j46sgsl3v83u45xdsloijmtfobav7dqmqq8s75trw)

lvwerra

1. The model outputs predictions for the next token whereas the `log_probs` are the log probabilities for the current token. This simply aligns the two. 2. The main motivation was to decouple the generation from the training as much as possible. Since it takes a fraction of the time of the backward pass the speedup would be minimal. That way the PPOTrainer interface is cleaner. 3. That's possible. It could be that the `transformer` function `generate` handles this, but I had to implement my own, simple decoding function since the model would exploit several aspects of it. See the comments [here](https://github.com/lvwerra/trl/blob/master/nbs/01-gpt2-with-value-head.ipynb) about the custom response function. Feel free to make a PR if you can fix the weaknesses and improve the performance. Cheers, Leandro

lvwerra

Hi! You can actually control these parameters. Later in the paper they also talk about dynamically adjusting beta. You can control this through the keyword arguments `"adap_kl_ctrl"` and `"init_kl_coef"` when initialising the `PPOTrainer`. You can also adjust the target KL-divergence through `"target"` and the windowing through `"horizon"` as well as all the PPO parameters (see [here](https://github.com/lvwerra/trl/blob/1662d78b5c5e688823b06c69495632abd68b7484/trl/ppo.py#L59)).

danyaljj

Side note: it'd be good to update the `transformers` dependency to the latest (v4.0.0).

lvwerra

You are right, when I have time I'll upgrade it to v4.0.0. I haven't tested it but I suspect if you take a model with a text generation head it should work. Note that you need add a value head to your model architecture (see [here](https://github.com/lvwerra/trl/blob/master/trl/gpt2.py)).