basic loop back and multi tag mechanism

.gitignore

@@ -0,0 +1,41 @@
+# Ignore virtual environment directories
+.venv/
+venv_nmr/
+
+# Ignore Python cache files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Ignore model files
+models/
+*.pth
+
+# Ignore joblib files
+data/*.joblib
+
+# Ignore Jupyter notebook checkpoints
+.ipynb_checkpoints/
+
+# Ignore the feedback data file
+feedback_data.csv
+
+# Ignore log files
+*.log
+
+# Ignore any environment variable files
+.env
+
+# Ignore temporary files and directories
+*.tmp
+*.temp
+tmp/
+temp/
+
+# Ignore OS-specific files
+.DS_Store
+Thumbs.db
+
+# Ignore IDE-specific files
+.vscode/
+.idea/

app.py

@@ -1,9 +1,293 @@
+# 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 same neural network model
+# Define the neural network model
 class ImprovedSongRecommender(nn.Module):
     def __init__(self, input_size, num_titles):
         super(ImprovedSongRecommender, self).__init__()
@@ -29,36 +313,28 @@ class ImprovedSongRecommender(nn.Module):
 # 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 = 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:
+    tags_list = [tag.strip() for tag in tags.split(',')]
+    encoded_tags_list = []
+    for tag in tags_list:
         try:
-            encoded_artist = label_encoders['artist_name'].transform([artist_name])[0]
+            encoded_tags_list.append(label_encoders['tags'].transform([tag])[0])
         except ValueError:
-            encoded_artist = label_encoders['artist_name'].transform(['unknown'])[0]
-    else:
+            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]
@@ -66,23 +342,51 @@ def encode_input(tags, artist_name):
 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()
+    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()

flagged/log.csv

@@ -0,0 +1,3 @@
+tags,artist_name,Recommendations,flag,username,timestamp
+hipop,,"['Love Is All Around', 'Never Gonna Give You Up', 'Emergency (Album Version)', 'Soul', 'Intro']",,,2024-05-19 23:49:26.765199
+"rock, pop",,[],,,2024-05-20 01:00:25.404739