Spaces:
Sleeping
Sleeping
import gradio as gr | |
from huggingface_hub import InferenceClient | |
""" | |
For more information on huggingface_hub Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference | |
""" | |
client = InferenceClient("HuggingFaceH4/zephyr-7b-beta") | |
def respond( | |
message, | |
history: list[tuple[str, str]], | |
system_message, | |
max_tokens, | |
temperature, | |
top_p, | |
): | |
messages = [{"role": "system", "content": system_message}] | |
for val in history: | |
if val[0]: | |
messages.append({"role": "user", "content": val[0]}) | |
if val[1]: | |
messages.append({"role": "assistant", "content": val[1]}) | |
messages.append({"role": "user", "content": message}) | |
response = "" | |
for message in client.chat_completion( | |
messages, | |
max_tokens=max_tokens, | |
stream=True, | |
temperature=temperature, | |
top_p=top_p, | |
): | |
token = message.choices[0].delta.content | |
response += token | |
yield response | |
""" | |
For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface | |
""" | |
demo = gr.ChatInterface( | |
respond, | |
additional_inputs=[ | |
gr.Textbox(value="You are a friendly Chatbot.", label="System message"), | |
gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"), | |
gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"), | |
gr.Slider( | |
minimum=0.1, | |
maximum=1.0, | |
value=0.95, | |
step=0.05, | |
label="Top-p (nucleus sampling)", | |
), | |
], | |
) | |
if __name__ == "__main__": | |
demo.launch() | |
# Fine-Tuning GPT-2 on Hugging Face Spaces (Streaming 40GB Dataset, No Storage Issues) | |
# Install required libraries | |
# Install required libraries (Run this separately in a terminal or notebook cell) | |
# !pip install transformers datasets peft accelerate bitsandbytes torch torchvision torchaudio gradio -q | |
from transformers import AutoModelForCausalLM, AutoTokenizer, Trainer, TrainingArguments | |
from datasets import load_dataset | |
from peft import LoraConfig, get_peft_model | |
import torch | |
# Authenticate Hugging Face | |
from huggingface_hub import notebook_login | |
notebook_login() | |
# Load GPT-2 model and tokenizer | |
model_name = "gpt2" | |
tokenizer = AutoTokenizer.from_pretrained(model_name) | |
model = AutoModelForCausalLM.from_pretrained(model_name) | |
# Load the OpenWebText dataset using streaming (No download required) | |
# Custom Dataset (Predefined Q&A Pairs for Project Expo) | |
custom_data = [ | |
{"prompt": "Who are you?", "response": "I am Eva, a virtual voice assistant."}, | |
{"prompt": "What is your name?", "response": "I am Eva, how can I help you?"}, | |
{"prompt": "What can you do?", "response": "I can assist with answering questions, searching the web, and much more!"}, | |
{"prompt": "Who invented the computer?", "response": "Charles Babbage is known as the father of the computer."}, | |
{"prompt": "Tell me a joke.", "response": "Why don’t scientists trust atoms? Because they make up everything!"}, | |
{"prompt": "Who is the Prime Minister of India?", "response": "The current Prime Minister of India is Narendra Modi."}, | |
{"prompt": "Who created you?", "response": "I was created by an expert team specializing in AI fine-tuning and web development."} | |
] | |
# Convert custom dataset to Hugging Face Dataset | |
dataset_custom = load_dataset("json", data_files={"train": custom_data}) | |
# Merge with OpenWebText dataset | |
dataset = load_dataset("Skylion007/openwebtext", split="train[:50%]") # Load 5% to avoid streaming issues | |
# Tokenization function | |
def tokenize_function(examples): | |
return tokenizer(examples["text"], truncation=True, padding="max_length", max_length=512) | |
tokenized_datasets = dataset.map(tokenize_function, batched=True) | |
# Apply LoRA for efficient fine-tuning | |
lora_config = LoraConfig( | |
r=8, lora_alpha=32, lora_dropout=0.05, bias="none", | |
target_modules=["c_attn", "c_proj"] # Apply LoRA to attention layers | |
) | |
model = get_peft_model(model, lora_config) | |
# Enable gradient checkpointing to reduce memory usage | |
model.gradient_checkpointing_enable() | |
# Training arguments | |
training_args = TrainingArguments( | |
output_dir="gpt2_finetuned", | |
auto_find_batch_size=True, | |
gradient_accumulation_steps=4, | |
learning_rate=5e-5, | |
num_train_epochs=3, | |
save_strategy="epoch", | |
logging_dir="logs", | |
bf16=True, | |
push_to_hub=True | |
) | |
# Trainer setup | |
trainer = Trainer( | |
model=model, | |
args=training_args, | |
train_dataset=tokenized_datasets | |
) | |
# Start fine-tuning | |
trainer.train() | |
# Save and push the model to Hugging Face Hub | |
trainer.save_model("gpt2_finetuned") | |
tokenizer.save_pretrained("gpt2_finetuned") | |
trainer.push_to_hub() | |
# Deploy as Gradio Interface | |
def generate_response(prompt): | |
inputs = tokenizer(prompt, return_tensors="pt") | |
outputs = model.generate(**inputs, max_length=100) | |
return tokenizer.decode(outputs[0], skip_special_tokens=True) | |
demo = gr.Interface(fn=generate_response, inputs="text", outputs="text") | |
demo.launch(share=True) |