Spaces:
Runtime error
Runtime error
| import gradio as gr | |
| import torch | |
| from transformers import AutoTokenizer, AutoModelForCausalLM | |
| from transformers import TrainingArguments, Trainer | |
| from datasets import load_dataset | |
| import random | |
| # Load the dataset | |
| dataset = load_dataset("SpartanCinder/song-lyrics-artist-classifier") | |
| # print(dataset.column_names) | |
| # print(dataset['train']['Artist']) | |
| # artist_list = list(set(dataset['train']['Artist'])) | |
| # print(artist_list) | |
| def generate_song(state, language_model, generate_song): | |
| device = torch.device("cuda" if torch.cuda.is_available() else "cpu") | |
| # Logic that takes put the selected language model and generates a song | |
| if generate_song: | |
| if not language_model: | |
| song_text = "Please select a language model before generating a song." | |
| return state, song_text, "", "" | |
| # Generate the song and the options based on the language_model | |
| if language_model == "Custom Gpt2": | |
| model_name = "SpartanCinder/GPT2-finetuned-lyric-generation" | |
| elif language_model == "Gpt2-Medium": | |
| model_name = "gpt2-medium" | |
| elif language_model == "facebook/bart-base": | |
| model_name = "facebook/bart-base" | |
| elif language_model == "Gpt-Neo": | |
| model_name = "EleutherAI/gpt-neo-1.3B" | |
| else: # Customized Models | |
| model_name = "customized-models" | |
| #tokenzer and text generation logic | |
| tokenizer = AutoTokenizer.from_pretrained(model_name) | |
| model = AutoModelForCausalLM.from_pretrained(model_name) | |
| #Call for a random artist from the dataset | |
| correct_choice = pick_artist(dataset) | |
| input_text = f"Write a song in the style of {correct_choice}:" | |
| # Tuninng settings | |
| max_length = 128 | |
| input_ids = tokenizer.encode(input_text, return_tensors="pt") | |
| input_ids = input_ids.to(device) | |
| if language_model != "customized-models" or "Custom Gpt2": | |
| ### Using Beam search to generate text### | |
| # encoded data | |
| encoded_output = model.generate(input_ids, max_length=max_length, num_beams=5, num_return_sequences=5, do_sample=False, no_repeat_ngram_size=2) # Generate text | |
| # Decode output | |
| print(tokenizer.decode(encoded_output[0], skip_special_tokens=True)) | |
| # But this output is repeating, so I need ot adjust this so that it is not repeating. | |
| elif language_model == "Custom Gpt2": | |
| # tokenizer = AutoTokenizer.from_pretrained("SpartanCinder/GPT2-pretrained-lyric-generation") | |
| # model = AutoModelForCausalLM.from_pretrained("SpartanCinder/GPT2-pretrained-lyric-generation") | |
| # encoded_output = model.generate(input_ids, max_length=max_length, num_beams=5, num_return_sequences=5, do_sample=False, no_repeat_ngram_size=2) # Generate text | |
| encoded_output = model.generate(input_ids, max_length=max_length, num_return_sequences=5, do_sample=True, top_p = 0.95, ) | |
| # Decode output | |
| print(tokenizer.decode(encoded_output[0], skip_special_tokens=True)) | |
| else: | |
| ### Nucleas Sampling to generate text### | |
| # Set the do_sample parameter to True because we are using nucleus sampling is a probabilistic sampling method | |
| # top_p is the probability threshold for nucleus sampling | |
| # So, we set top_p to 0.9, which means that the model will sample from the top 90% of the probability distribution | |
| # This will help to generate more diverse text that is less repetitive | |
| encoded_output = model.generate(input_ids, max_length=max_length, num_return_sequences=5, do_sample=True, top_p = 0.9, ) | |
| # Decode output | |
| output = tokenizer.decode(encoded_output[0], skip_special_tokens=True) | |
| # Remove the first line of the output if it contains newline characters | |
| # if '\n' in output: | |
| # output = '\n'.join(output.split('\n')[1:]) | |
| # formatted_output = output.split('\n')[0] # might have to remove this line | |
| song_text = output | |
| # Generate the multiple-choice options | |
| options = generate_artist_options(dataset, correct_choice) | |
| state['options'] = options | |
| # Generate the multiple-choice check | |
| multiple_choice_check = generate_multiple_choice_check(options, correct_choice) | |
| state['multiple_choice_check'] = multiple_choice_check | |
| state['correct_choice'] = correct_choice | |
| return state, song_text, ', '.join(options) | |
| #Check the selected artist and return whether it's correct | |
| # def on_submit_answer(state, correct_choice, user_choice, submit_answer): | |
| # if submit_answer: | |
| # if not user_choice: | |
| # return {"Error": "Please select an artist before submitting an answer."} | |
| # # Check if 'correct_choice' is in the state keys | |
| # if 'correct_choice' in state: | |
| # correct_answer = state['correct_choice'] | |
| # if correct_answer == user_choice: | |
| # return {"Result": f"You guessed the right artist: {correct_choice}"} | |
| # else: | |
| # return {"Result": f"You selected {user_choice}, but the correct answer is {correct_choice}"} | |
| # else: | |
| # print("The 'correct_choice' key does not exist in the state.") | |
| # return None | |
| def on_submit_answer(state, user_choice): | |
| # Map the user's choice (A, B, C, or D) to an index | |
| choice_to_index = {'A': 0, 'B': 1, 'C': 2, 'D': 3} | |
| index = choice_to_index[user_choice] | |
| # Retrieve the user's choice and the correct choice from the state | |
| user_artist = state['options'][index] | |
| correct_artist = state['correct_choice'] | |
| # Compare the user's choice with the correct choice | |
| if user_artist == correct_artist: | |
| return {"CORRECT": f"You guessed the right artist: {correct_artist}"} | |
| else: | |
| return {"INCORRECT": f"You selected {user_choice}, but the correct answer is {correct_artist}"} | |
| def pick_artist(dataset): | |
| # Check if 'Artist' is in the dataset columns | |
| artist_choice = list(set(dataset['train']['Artist'])) | |
| artist_choice = random.choice(artist_choice) | |
| return artist_choice | |
| # print("The 'Artist' column does not exist in the dataset.") | |
| # artist_choice = "Green Day" | |
| # return artist_choice | |
| def generate_artist_options(dataset, correct_artist): | |
| # Generate 3 incorrect options | |
| all_artists = list(set(dataset['train']['Artist'])) | |
| if correct_artist in all_artists: | |
| all_artists.remove(correct_artist) | |
| options = random.sample(all_artists, 3) + [correct_artist] | |
| random.shuffle(options) | |
| return options | |
| def generate_multiple_choice_check(options, correct_choice): | |
| return {option: option == correct_choice for option in options} | |
| def check_correct_choice(user_choice, correct_choice): | |
| if user_choice == correct_choice: | |
| return True | |
| return user_choice == correct_choice | |
| with gr.Blocks(title="Song Generator Guessing Game") as game_interface: | |
| state = gr.State({'options': []}) | |
| language_model = gr.Radio(["Custom Gpt2", "Gpt2-Medium", "facebook/bart-base","Gpt-Neo", "Customized Models"], label="Model Selection", info="Select the language model to generate the song.") | |
| generate_song_button = gr.Button("Generate Song") | |
| generated_song = gr.Textbox(label="Generated Song") | |
| artist_choice_display = gr.Textbox(interactive=False, label="Multiple-Choice Options") | |
| user_choice = gr.Radio(["A", "B", "C", "D"], label="Updated Options", info="Select the artist that you suspect is the correct artist for the song.") | |
| # timer = gr.HTML("<div id='progress-bar' style='width: 100%; background-color: #f3f3f3; border: 1px solid #bbb;'><div id='progress' style='height: 20px; width: 0%; background-color: #007bff;'></div></div><script>function startTimer() {var time = 30; var timer = setInterval(function() {time--; document.getElementById('progress').style.width = (time / 30 * 100) + '%'; if (time <= 0) {clearInterval(timer);}}, 1000);}</script>", label="Timer") | |
| submit_answer_button = gr.Button("Submit Answer") | |
| correct_answer = gr.Textbox(label="Results") | |
| generate_song_button.click( | |
| generate_song, | |
| [state, language_model, generate_song_button], | |
| [state, generated_song, artist_choice_display,] | |
| ) | |
| submit_answer_button.click( | |
| on_submit_answer, | |
| [state, user_choice,], | |
| [correct_answer] | |
| ) | |
| game_interface.launch() |