Spaces:
Runtime error
Runtime error
| # import gradio as gr | |
| # import torch | |
| # import torch.nn as nn | |
| # from joblib import load | |
| # # Define the same neural network model | |
| # class ImprovedSongRecommender(nn.Module): | |
| # def __init__(self, input_size, num_titles): | |
| # super(ImprovedSongRecommender, self).__init__() | |
| # self.fc1 = nn.Linear(input_size, 128) | |
| # self.bn1 = nn.BatchNorm1d(128) | |
| # self.fc2 = nn.Linear(128, 256) | |
| # self.bn2 = nn.BatchNorm1d(256) | |
| # self.fc3 = nn.Linear(256, 128) | |
| # self.bn3 = nn.BatchNorm1d(128) | |
| # self.output = nn.Linear(128, num_titles) | |
| # self.dropout = nn.Dropout(0.5) | |
| # def forward(self, x): | |
| # x = torch.relu(self.bn1(self.fc1(x))) | |
| # x = self.dropout(x) | |
| # x = torch.relu(self.bn2(self.fc2(x))) | |
| # x = self.dropout(x) | |
| # x = torch.relu(self.bn3(self.fc3(x))) | |
| # x = self.dropout(x) | |
| # x = self.output(x) | |
| # return x | |
| # # Load the trained model | |
| # model_path = "models/improved_model.pth" | |
| # num_unique_titles = 4855 | |
| # model = ImprovedSongRecommender(input_size=2, num_titles=num_unique_titles) | |
| # model.load_state_dict(torch.load(model_path, map_location=torch.device('cpu'))) | |
| # model.eval() | |
| # # Load the label encoders and scaler | |
| # label_encoders_path = "data/new_label_encoders.joblib" | |
| # scaler_path = "data/new_scaler.joblib" | |
| # label_encoders = load(label_encoders_path) | |
| # scaler = load(scaler_path) | |
| # # Create a mapping from encoded indices to actual song titles | |
| # index_to_song_title = {index: title for index, title in enumerate(label_encoders['title'].classes_)} | |
| # def encode_input(tags, artist_name): | |
| # tags = tags.strip().replace('\n', '') | |
| # artist_name = artist_name.strip().replace('\n', '') | |
| # try: | |
| # encoded_tags = label_encoders['tags'].transform([tags])[0] | |
| # except ValueError: | |
| # encoded_tags = label_encoders['tags'].transform(['unknown'])[0] | |
| # if artist_name: | |
| # try: | |
| # encoded_artist = label_encoders['artist_name'].transform([artist_name])[0] | |
| # except ValueError: | |
| # encoded_artist = label_encoders['artist_name'].transform(['unknown'])[0] | |
| # else: | |
| # encoded_artist = label_encoders['artist_name'].transform(['unknown'])[0] | |
| # return [encoded_tags, encoded_artist] | |
| # def recommend_songs(tags, artist_name): | |
| # encoded_input = encode_input(tags, artist_name) | |
| # input_tensor = torch.tensor([encoded_input]).float() | |
| # with torch.no_grad(): | |
| # output = model(input_tensor) | |
| # recommendations_indices = torch.topk(output, 5).indices.squeeze().tolist() | |
| # recommendations = [index_to_song_title.get(idx, "Unknown song") for idx in recommendations_indices] | |
| # formatted_output = [f"Recommendation {i+1}: {rec}" for i, rec in enumerate(recommendations)] | |
| # return formatted_output | |
| # # Set up the Gradio interface | |
| # interface = gr.Interface( | |
| # fn=recommend_songs, | |
| # inputs=[gr.Textbox(lines=1, placeholder="Enter Tags (e.g., rock)"), gr.Textbox(lines=1, placeholder="Enter Artist Name (optional)")], | |
| # outputs=gr.Textbox(label="Recommendations"), | |
| # title="Music Recommendation System", | |
| # description="Enter tags and (optionally) artist name to get music recommendations." | |
| # ) | |
| # interface.launch() | |
| # import gradio as gr | |
| # import torch | |
| # import torch.nn as nn | |
| # from joblib import load | |
| # import numpy as np | |
| # import json | |
| # class ImprovedSongRecommender(nn.Module): | |
| # def __init__(self, input_size, num_titles): | |
| # super(ImprovedSongRecommender, self).__init__() | |
| # self.fc1 = nn.Linear(input_size, 128) | |
| # self.bn1 = nn.BatchNorm1d(128) | |
| # self.fc2 = nn.Linear(128, 256) | |
| # self.bn2 = nn.BatchNorm1d(256) | |
| # self.fc3 = nn.Linear(256, 128) | |
| # self.bn3 = nn.BatchNorm1d(128) | |
| # self.output = nn.Linear(128, num_titles) | |
| # self.dropout = nn.Dropout(0.5) | |
| # def forward(self, x): | |
| # x = torch.relu(self.bn1(self.fc1(x))) | |
| # x = self.dropout(x) | |
| # x = torch.relu(self.bn2(self.fc2(x))) | |
| # x = self.dropout(x) | |
| # x = torch.relu(self.bn3(self.fc3(x))) | |
| # x = self.dropout(x) | |
| # x = self.output(x) | |
| # return x | |
| # # Load the trained model | |
| # model_path = "models/improved_model.pth" | |
| # num_unique_titles = 4855 | |
| # model = ImprovedSongRecommender(input_size=2, num_titles=num_unique_titles) | |
| # model.load_state_dict(torch.load(model_path, map_location=torch.device('cpu'))) | |
| # model.eval() | |
| # # Load the label encoders and scaler | |
| # label_encoders_path = "data/new_label_encoders.joblib" | |
| # scaler_path = "data/new_scaler.joblib" | |
| # label_encoders = load(label_encoders_path) | |
| # scaler = load(scaler_path) | |
| # index_to_song_title = {index: title for index, title in enumerate(label_encoders['title'].classes_)} | |
| # def encode_input(tags, artist_name): | |
| # tags_list = [tag.strip() for tag in tags.split(',')] | |
| # encoded_tags_list = [] | |
| # for tag in tags_list: | |
| # try: | |
| # encoded_tags_list.append(label_encoders['tags'].transform([tag])[0]) | |
| # except ValueError: | |
| # encoded_tags_list.append(label_encoders['tags'].transform(['unknown'])[0]) | |
| # encoded_tags = np.mean(encoded_tags_list).astype(int) if encoded_tags_list else label_encoders['tags'].transform(['unknown'])[0] | |
| # try: | |
| # encoded_artist = label_encoders['artist_name'].transform([artist_name])[0] if artist_name else label_encoders['artist_name'].transform(['unknown'])[0] | |
| # except ValueError: | |
| # encoded_artist = label_encoders['artist_name'].transform(['unknown'])[0] | |
| # return [encoded_tags, encoded_artist] | |
| # def recommend_songs(tags, artist_name): | |
| # encoded_input = encode_input(tags, artist_name) | |
| # input_tensor = torch.tensor([encoded_input]).float() | |
| # with torch.no_grad(): | |
| # output = model(input_tensor) | |
| # recommendations_indices = torch.topk(output, 5).indices.squeeze().tolist() | |
| # recommendations = [index_to_song_title.get(idx, "Unknown song") for idx in recommendations_indices] | |
| # feedback_html = [] | |
| # for idx, rec in enumerate(recommendations): | |
| # feedback_html.append(f"{rec} <button onclick='gr.Interface.update(\"record_feedback\", {{\"recommendation\": \"{rec}\", \"feedback\": \"up\"}})'>👍</button> <button onclick='gr.Interface.update(\"record_feedback\", {{\"recommendation\": \"{rec}\", \"feedback\": \"down\"}})'>👎</button>") | |
| # return "<br>".join(feedback_html) | |
| # def record_feedback(recommendation, feedback): | |
| # with open("feedback_data.csv", "a") as file: | |
| # file.write(f"{recommendation},{feedback}\n") | |
| # return f"Feedback recorded for {recommendation}: {feedback}" | |
| # interface = gr.Interface( | |
| # fn=recommend_songs, | |
| # inputs=[ | |
| # gr.Textbox(lines=2, placeholder="Enter Tags (e.g., rock, jazz)"), | |
| # gr.Textbox(lines=2, placeholder="Enter Artist Name (optional)") | |
| # ], | |
| # outputs=gr.HTML(label="Recommendations"), | |
| # title="Music Recommendation System", | |
| # description="Enter tags and (optionally) artist name to get music recommendations. Click on thumbs up/down to provide feedback on each song.", | |
| # allow_flagging="never" | |
| # ) | |
| # interface.launch() | |
| # import gradio as gr | |
| # import torch | |
| # import torch.nn as nn | |
| # from joblib import load | |
| # import numpy as np | |
| # import os | |
| # class ImprovedSongRecommender(nn.Module): | |
| # def __init__(self, input_size, num_titles): | |
| # super(ImprovedSongRecommender, self).__init__() | |
| # self.fc1 = nn.Linear(input_size, 128) | |
| # self.bn1 = nn.BatchNorm1d(128) | |
| # self.fc2 = nn.Linear(128, 256) | |
| # self.bn2 = nn.BatchNorm1d(256) | |
| # self.fc3 = nn.Linear(256, 128) | |
| # self.bn3 = nn.BatchNorm1d(128) | |
| # self.output = nn.Linear(128, num_titles) | |
| # self.dropout = nn.Dropout(0.5) | |
| # def forward(self, x): | |
| # x = torch.relu(self.bn1(self.fc1(x))) | |
| # x = self.dropout(x) | |
| # x = torch.relu(self.bn2(self.fc2(x))) | |
| # x = self.dropout(x) | |
| # x = torch.relu(self.bn3(self.fc3(x))) | |
| # x = self.dropout(x) | |
| # x = self.output(x) | |
| # return x | |
| # # Load the trained model | |
| # model_path = "models/improved_model.pth" | |
| # num_unique_titles = 4855 | |
| # model = ImprovedSongRecommender(input_size=2, num_titles=num_unique_titles) | |
| # model.load_state_dict(torch.load(model_path, map_location=torch.device('cpu'))) | |
| # model.eval() | |
| # # Load the label encoders and scaler | |
| # label_encoders_path = "data/new_label_encoders.joblib" | |
| # scaler_path = "data/new_scaler.joblib" | |
| # label_encoders = load(label_encoders_path) | |
| # scaler = load(scaler_path) | |
| # index_to_song_title = {index: title for index, title in enumerate(label_encoders['title'].classes_)} | |
| # def encode_input(tags, artist_name): | |
| # tags_list = [tag.strip() for tag in tags.split(',')] | |
| # encoded_tags_list = [] | |
| # for tag in tags_list: | |
| # try: | |
| # encoded_tags_list.append(label_encoders['tags'].transform([tag])[0]) | |
| # except ValueError: | |
| # encoded_tags_list.append(label_encoders['tags'].transform(['unknown'])[0]) | |
| # encoded_tags = np.mean(encoded_tags_list).astype(int) if encoded_tags_list else label_encoders['tags'].transform(['unknown'])[0] | |
| # try: | |
| # encoded_artist = label_encoders['artist_name'].transform([artist_name])[0] if artist_name else label_encoders['artist_name'].transform(['unknown'])[0] | |
| # except ValueError: | |
| # encoded_artist = label_encoders['artist_name'].transform(['unknown'])[0] | |
| # return [encoded_tags, encoded_artist] | |
| # def recommend_songs(tags, artist_name): | |
| # encoded_input = encode_input(tags, artist_name) | |
| # input_tensor = torch.tensor([encoded_input]).float() | |
| # with torch.no_grad(): | |
| # output = model(input_tensor) | |
| # recommendations_indices = torch.topk(output, 5).indices.squeeze().tolist() | |
| # recommendations = [index_to_song_title.get(idx, "Unknown song") for idx in recommendations_indices] | |
| # feedback_html = [] | |
| # for idx, rec in enumerate(recommendations): | |
| # feedback_html.append(f"{rec} <button onclick='record_feedback(\"{rec}\", \"up\")'>👍</button> <button onclick='record_feedback(\"{rec}\", \"down\")'>👎</button>") | |
| # return "<br>".join(feedback_html) | |
| # def record_feedback(recommendation, feedback): | |
| # print(f"Recording feedback for: {recommendation}, Feedback: {feedback}") # Debugging statement | |
| # with open("feedback_data.csv", "a") as file: | |
| # file.write(f"{recommendation},{feedback}\n") | |
| # print("Feedback recorded successfully.") | |
| # return f"Feedback recorded for {recommendation}: {feedback}" | |
| # interface = gr.Interface( | |
| # fn=recommend_songs, | |
| # inputs=[ | |
| # gr.Textbox(lines=2, placeholder="Enter Tags (e.g., rock, jazz)"), | |
| # gr.Textbox(lines=2, placeholder="Enter Artist Name (optional)") | |
| # ], | |
| # outputs=gr.HTML(label="Recommendations"), | |
| # title="Music Recommendation System", | |
| # description="Enter tags and (optionally) artist name to get music recommendations. Click on thumbs up/down to provide feedback on each song.", | |
| # allow_flagging="never", | |
| # live=True | |
| # ) | |
| # interface.launch() | |
| import gradio as gr | |
| import torch | |
| import torch.nn as nn | |
| from joblib import load | |
| import numpy as np | |
| import os | |
| # Define the neural network model | |
| class ImprovedSongRecommender(nn.Module): | |
| def __init__(self, input_size, num_titles): | |
| super(ImprovedSongRecommender, self).__init__() | |
| self.fc1 = nn.Linear(input_size, 128) | |
| self.bn1 = nn.BatchNorm1d(128) | |
| self.fc2 = nn.Linear(128, 256) | |
| self.bn2 = nn.BatchNorm1d(256) | |
| self.fc3 = nn.Linear(256, 128) | |
| self.bn3 = nn.BatchNorm1d(128) | |
| self.output = nn.Linear(128, num_titles) | |
| self.dropout = nn.Dropout(0.5) | |
| def forward(self, x): | |
| x = torch.relu(self.bn1(self.fc1(x))) | |
| x = self.dropout(x) | |
| x = torch.relu(self.bn2(self.fc2(x))) | |
| x = self.dropout(x) | |
| x = torch.relu(self.bn3(self.fc3(x))) | |
| x = self.dropout(x) | |
| x = self.output(x) | |
| return x | |
| # Load the trained model | |
| model_path = "models/improved_model.pth" | |
| num_unique_titles = 4855 | |
| model = ImprovedSongRecommender(input_size=2, num_titles=num_unique_titles) | |
| model.load_state_dict(torch.load(model_path, map_location=torch.device('cpu'))) | |
| model.eval() | |
| # Load the label encoders and scaler | |
| label_encoders_path = "data/new_label_encoders.joblib" | |
| label_encoders = load(label_encoders_path) | |
| def encode_input(tags, artist_name): | |
| tags_list = [tag.strip() for tag in tags.split(',')] | |
| encoded_tags_list = [] | |
| for tag in tags_list: | |
| try: | |
| encoded_tags_list.append(label_encoders['tags'].transform([tag])[0]) | |
| except ValueError: | |
| encoded_tags_list.append(label_encoders['tags'].transform(['unknown'])[0]) | |
| encoded_tags = np.mean(encoded_tags_list).astype(int) if encoded_tags_list else label_encoders['tags'].transform(['unknown'])[0] | |
| try: | |
| encoded_artist = label_encoders['artist_name'].transform([artist_name])[0] | |
| except ValueError: | |
| encoded_artist = label_encoders['artist_name'].transform(['unknown'])[0] | |
| return [encoded_tags, encoded_artist] | |
| def recommend_songs(tags, artist_name): | |
| encoded_input = encode_input(tags, artist_name) | |
| input_tensor = torch.tensor([encoded_input]).float() | |
| with torch.no_grad(): | |
| output = model(input_tensor) | |
| recommendations_indices = torch.topk(output, 5).indices.squeeze().tolist() | |
| recommendations = [label_encoders['title'].inverse_transform([idx])[0] for idx in recommendations_indices] | |
| print("Recommendations:", recommendations) # Debugging statement | |
| return recommendations | |
| def record_feedback(recommendation, feedback): | |
| feedback_path = "feedback_data.csv" | |
| if not os.path.exists(feedback_path): | |
| with open(feedback_path, 'w') as f: | |
| f.write("Recommendation,Feedback\n") | |
| with open(feedback_path, 'a') as f: | |
| f.write(f"{recommendation},{feedback}\n") | |
| return "Feedback recorded!" | |
| app = gr.Blocks() | |
| with app: | |
| gr.Markdown("## Music Recommendation System") | |
| tags_input = gr.Textbox(label="Enter Tags (e.g., rock, jazz, pop)", placeholder="rock, pop") | |
| artist_name_input = gr.Textbox(label="Enter Artist Name (optional)", placeholder="The Beatles") | |
| submit_button = gr.Button("Get Recommendations") | |
| recommendations_output = gr.HTML(label="Recommendations") | |
| feedback_input = gr.Radio(choices=["Thumbs Up", "Thumbs Down"], label="Feedback") | |
| feedback_button = gr.Button("Submit Feedback") | |
| feedback_result = gr.Label(label="Feedback Result") | |
| def display_recommendations(tags, artist_name): | |
| recommendations = recommend_songs(tags, artist_name) | |
| if recommendations: | |
| return recommendations | |
| else: | |
| return ["No recommendations found"] | |
| submit_button.click( | |
| fn=display_recommendations, | |
| inputs=[tags_input, artist_name_input], | |
| outputs=recommendations_output | |
| ) | |
| feedback_button.click( | |
| fn=record_feedback, | |
| inputs=[recommendations_output, feedback_input], | |
| outputs=feedback_result | |
| ) | |
| app.launch() | |