Remove junk

app.py

@@ -1,395 +1,4 @@
-# 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)
-#     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()
 
 import gradio as gr
 import torch
@@ -463,7 +72,8 @@ def recommend_songs(tags, artist_name):
 def record_feedback(recommendation, feedback):
     # Load the dataset or create a new one if it doesn't exist
     try:
-        feedback_dataset = load_dataset("feedback_data", split='train')
+        feedback_dataset = load_dataset("json", data_files="feedback_data/feedback_data.json")
+        feedback_dataset = feedback_dataset['train']
     except:
         feedback_dataset = Dataset.from_dict({"Recommendation": [], "Feedback": []})
     
@@ -472,10 +82,18 @@ def record_feedback(recommendation, feedback):
     feedback_dataset = feedback_dataset.add_item(new_feedback)
     
     # Save the dataset
-    feedback_dataset.save_to_disk("feedback_data")
+    feedback_dataset.to_json("feedback_data/feedback_data.json")
     
     return "Feedback recorded!"
 
+def show_feedback():
+    try:
+        feedback_dataset = load_dataset("json", data_files="feedback_data/feedback_data.json")
+        feedback_dataset = feedback_dataset['train']
+        return feedback_dataset.to_pandas().to_html()
+    except:
+        return "No feedback data found."
+
 app = gr.Blocks()
 
 with app:
@@ -487,6 +105,8 @@ with app:
     feedback_input = gr.Radio(choices=["Thumbs Up", "Thumbs Down"], label="Feedback")
     feedback_button = gr.Button("Submit Feedback")
     feedback_result = gr.Label(label="Feedback Result")
+    show_feedback_button = gr.Button("Show Feedback Data")
+    feedback_data_output = gr.HTML(label="Feedback Data")
 
     def display_recommendations(tags, artist_name):
         recommendations = recommend_songs(tags, artist_name)
@@ -507,5 +127,12 @@ with app:
         outputs=feedback_result
     )
 
+    show_feedback_button.click(
+        fn=show_feedback,
+        inputs=[],
+        outputs=feedback_data_output
+    )
+
 app.launch()
 
+

feedback_data/feedback_data.json

@@ -0,0 +1,2 @@
+{"Recommendation":["Helium","Heartburn","Let's Get It Started","Dame Un Besito (Version Salsa)","Long Live The Party"],"Feedback":"Thumbs Up"}
+{"Recommendation":["Heartburn","Hurry Up And Come","Helium","Crazy","Hotel"],"Feedback":"Thumbs Down"},