Update app.py

app.py

@@ -1,77 +1,78 @@
 import streamlit as st
+import numpy as np
 from tensorflow.keras.models import load_model
 from tensorflow.keras.preprocessing.sequence import pad_sequences
 import joblib
 import pandas as pd
-import numpy as np
+from sklearn.neighbors import NearestNeighbors
 from sklearn.preprocessing import StandardScaler
+from sklearn.metrics.pairwise import cosine_similarity
 
-# Load the dataset
-df = pd.read_csv('df1.csv')
-df = df.drop(['Unnamed: 0', 'lyrics_filename', 'analysis_url', 'track_href', "type", "id", "uri"], axis=1)
-
-# Load the tokenizer (ensure it's the one used during training)
-tokenizer = joblib.load('tokenizer.pkl')
-
-# Load the emotion prediction model
+# Load the LSTM model for emotion prediction
 emotion_model = load_model('lstm_model.h5')
 
-# Preprocess for content-based
-audio_feature_columns = ['danceability', 'energy', 'key', 'loudness', 'mode', 'speechiness',
-           'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo',
-           'duration_ms', 'time_signature']
-
-audio_features = df[audio_feature_columns]
-mood_cats = df[['mood_cats']]
-mood_cats_df = pd.DataFrame(mood_cats)
-
-# Normalize audio features for content-based
-scaler_cb = StandardScaler()
-audio_features_scaled_cb = scaler_cb.fit_transform(audio_features)
-audio_features_df_cb = pd.DataFrame(audio_features_scaled_cb, columns=audio_feature_columns)
-combined_features = pd.concat([mood_cats, audio_features_df_cb], axis=1)
+# Load the KNN model
+knn_model = joblib.load('knn_model.joblib')
 
-# Load the similarity matrix for content-based
-similarity_matrix = np.load('similarity_matrix.npy')
+# Load the tokenizer
+tokenizer = joblib.load('tokenizer.pkl')
 
-# Load the content-based recommendation function
-recommend_cont = joblib.load('recommendation_cont_function.joblib')
+# Load the dataset
+df = pd.read_csv('df1.csv')
 
-# Preprocessing for KNN
+# Load the scaler for KNN
 scaler_knn = StandardScaler()
-audio_features_scaled_knn = scaler_knn.fit_transform(audio_features)
-audio_features_df_knn = pd.DataFrame(audio_features_scaled_knn, columns=audio_feature_columns)
-combined_features = pd.concat([mood_cats_df, audio_features_df_knn], axis=1)
-
-# Load the KNN model
-knn = joblib.load('knn_model.joblib')
 
-# Load the KNN recommendation function
-recommend_knn = joblib.load('recommendation_knn_function.joblib')
-
-# Load the hybrid recommendation function
-hybrid_recommendation = joblib.load('hybrid_recommendation_function.joblib')
-
-# Call the function from the module
-hybrid_recs = hybrid_recommendation(song_index=0)
+# Function for hybrid recommendation
+def hybrid_recommendation(song_index):
+    # Get data for the query song
+    query_data = df.iloc[song_index]
+
+    # Process the lyrics for emotion prediction using LSTM
+    sequence = tokenizer.texts_to_sequences([query_data['lyrics']])
+    padded_sequence = pad_sequences(sequence, maxlen=50)
+    predicted_emotion = emotion_model.predict(padded_sequence).flatten()
+
+    # Preprocess for KNN
+    audio_features_knn = query_data[['danceability', 'energy', 'key', 'loudness', 'mode', 'speechiness',
+                                      'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo',
+                                      'duration_ms', 'time_signature']].values.reshape(1, -1)
+    mood_cats = query_data[['mood_cats']]
+    mood_cats_df = pd.DataFrame(mood_cats)
+    audio_features_scaled_knn = scaler_knn.fit_transform(audio_features_knn)
+    combined_features = pd.concat([mood_cats_df, pd.DataFrame(audio_features_scaled_knn, columns=audio_features_knn.columns)], axis=1)
+    
+    # Predict using the KNN model
+    knn_recommendations = knn_model.kneighbors(combined_features, n_neighbors=5, return_distance=False)[0]
+
+    # Mapping emotion predictions to encoded categories
+    emotion_mapping = {0: 'happy', 1: 'sad', 2: 'calm', 3: 'anger'}
+    encoded_emotion = np.argmax(predicted_emotion)
+    emotion_category = emotion_mapping[encoded_emotion]
+
+    # Compute cosine similarity for content-based recommendation
+    features_for_similarity = df[['danceability', 'energy', 'key', 'loudness', 'mode', 'speechiness',
+                                  'acousticness', 'instrumentalness', 'liveness', 'valence', 'tempo',
+                                  'duration_ms', 'time_signature']].values
+
+    cosine_similarities = cosine_similarity([emotion_category], features_for_similarity).flatten()
+
+    # Combine recommendations from both models
+    combined_indices = np.argsort(-np.concatenate([knn_recommendations, cosine_similarities]))
+    hybrid_recs_sorted = combined_indices[:5]  # Select top 5 recommendations
+
+    return hybrid_recs_sorted
 
 # Set up the title of the app
-st.title('Emotion and Audio Feature-based Song Recommendation System')
-
-# Get data from index 0
-query_data = df.iloc[0]
-
-# Process the lyrics
-sequence = tokenizer.texts_to_sequences([query_data['lyrics']])
-padded_sequence = pad_sequences(sequence, maxlen=50)
-emotion = emotion_model.predict(padded_sequence).flatten()
+st.title('Hybrid Recommender App')
 
-# Combine emotion and audio features for recommendation
-combined_features_hybrid = np.concatenate([emotion, query_data[audio_features.columns].values])
+# Get song index from user input
+song_index_to_recommend = st.number_input('Enter song index:', min_value=0, max_value=len(df)-1, value=0)
 
-# Generate recommendations using the hybrid model
-hybrid_recs = hybrid_recommendation(song_index=0)
+# Get hybrid recommendations
+hybrid_recs = hybrid_recommendation(song_index_to_recommend)
 
-st.write("Emotion Detected:", emotion[0])
-st.header('Recommended Songs (Hybrid)')
-st.write(hybrid_recs)
+# Display the recommendations
+st.write("Hybrid Recommendations:")
+for index in hybrid_recs:
+    st.write(f"Song Index: {index}, Title: {df.iloc[index]['title']}, Artist: {df.iloc[index]['artist']}")