lamini_flan_t5_detoxify_rlaif / README.md

ARahul2003

Update README.md

df86f11 7 months ago

No virus

5.17 kB

	---
	license: cc
	tags:
	- trl
	- transformers
	- reinforcement-learning
	- LLM detoxification
	datasets:
	- ProlificAI/social-reasoning-rlhf
	language:
	- en
	pipeline_tag: conversational
	---

	# TRL Model

	This is a [TRL language model](https://github.com/huggingface/trl). It has been fine-tuned with reinforcement learning to
	guide the model outputs according to a value, function, or human feedback. The model can be used for text generation.
	This project aims to reduce the level of toxicity in the outputs generated by the LAMINI Flan T5 248M language model using
	Reinforcement Learning with Artificial Intelligence Feedback technique (RLAIF). Reinforcement Learning with Human Feedback (RLHF)
	is a method to align models with a particular kind of data. RLHF creates a latent reward model using human feedback and finetunes
	a model using Proximal Policy Optimization. RLAIF on the other hand replaces human feedback with a high-performance AI agent. The model
	has been fine-tuned on the [Social Reasoning Dataset](https://huggingface.co/datasets/ProlificAI/social-reasoning-rlhf/viewer/default/train?p=38&row=3816) by
	ProlificAI for 191 steps and 1 epoch using the Proximal Policy Optimisation (PPO) algorithm. The [Roberta hate text detection](https://huggingface.co/facebook/roberta-hate-speech-dynabench-r4-target)
	model was used as the Proximal Policy Optimisation (PPO) reward model.

	The power of this model lies in its size; it is barely 500 MBs in size and performs well given its size. The intended use of this model should be conversation, text generation, or context-based Q&A.
	This model might not perform well on tasks like mathematics, sciences, coding, etc. It might hallucinate on such tasks. After quantization, this model could be easily run on edge devices like smartphones and microprocessors.

	The training log of the model can be found in this [weights and biases](https://wandb.ai/tnarahul/trl/runs/nk30wukt/overview?workspace=user-tnarahul) page.

	Note: This model is a fine-tuned version of [LaMini Flan T5 248M](https://huggingface.co/MBZUAI/LaMini-Flan-T5-248M), which in turn is a fine-tuned version of the Flan T5 model released by Google. The Flan T5 follows the encoder-decoder architecture, unlike other GPT-like models that are decoder-only.

	## Usage

	To use this model for inference, first install the TRL library:

	```bash
	python -m pip install trl
	```

	You can then generate text as follows:

	```python
	from trl import AutoModelForSeq2SeqLMWithValueHead
	from transformers import pipeline, AutoTokenizer
	import torch

	checkpoint = "ARahul2003/lamini_flan_t5_detoxify_rlaif"

	tokenizer = AutoTokenizer.from_pretrained(checkpoint)
	base_model = AutoModelForSeq2SeqLMWithValueHead.from_pretrained(checkpoint,
	device_map='cpu', #or 'auto'/'cuda:0'
	torch_dtype=torch.float32)
	pipe = pipeline('text2text-generation',
	model = base_model,
	tokenizer = tokenizer,
	max_length = 512,
	do_sample=True,
	temperature=0.3,
	top_p=0.95,
	)

	prompt = 'Hello! How are you?'
	print(pipe(prompt)[0]['generated_text'])

	```

	If you want to use the model for training or to obtain the outputs from the value head, load the model as follows:

	```python
	from transformers import AutoTokenizer
	from trl import AutoModelForCausalLMWithValueHead

	tokenizer = AutoTokenizer.from_pretrained("ARahul2003/lamini_flan_t5_detoxify_rlaif")
	model = AutoModelForCausalLMWithValueHead.from_pretrained("ARahul2003/lamini_flan_t5_detoxify_rlaif")

	inputs = tokenizer("Hello, my llama is cute", return_tensors="pt")
	outputs = model(**inputs, labels=inputs["input_ids"])
	```

	If you want to use the model for inference in a gradio app, consider the following code:

	```python
	from trl import AutoModelForSeq2SeqLMWithValueHead
	from transformers import pipeline, AutoTokenizer
	import torch
	import gradio as gr

	title = "LaMini Flan T5 248M"
	checkpoint = "ARahul2003/lamini_flan_t5_detoxify_rlaif"

	tokenizer = AutoTokenizer.from_pretrained(checkpoint)
	base_model = AutoModelForSeq2SeqLMWithValueHead.from_pretrained(checkpoint,
	device_map='cpu', #or 'auto'
	torch_dtype=torch.float32)
	pipe = pipeline('text2text-generation',
	model = base_model,
	tokenizer = tokenizer,
	max_length = 512,
	do_sample=True,
	temperature=0.3,
	top_p=0.95,
	)

	def chat_with_model(inp_chat, chat_history = None):
	prompt = f"{inp_chat}" #f"User: {inp_chat} Bot:"

	responses = pipe(prompt)
	return responses[0]['generated_text']

	examples = [
	'Hi!',
	'How are you?',
	'Please let me know your thoughts on the given place and why you think it deserves to be visited: \n"Barcelona, Spain"'
	]

	gr.ChatInterface(
	fn=chat_with_model,
	title=title,
	examples=examples
	).launch()

	```

	Make sure to keep all the tensors on the same device (CPU/GPU).