Update app.py

app.py

@@ -121,11 +121,97 @@ def recommend_movies_cf(movie_title):
     format_string = "{:>5.2f}       {:<20}"
     return "Score     Title\n" + "\n".join([format_string.format(score, title) for title, score in recommendations])
 
+######################################
+#
+# Collaborative Filtering with Neural Network (Item-based)
+#
+######################################
+
+# Normalize the ratings
+scaler = MinMaxScaler()
+movie_user_matrix_scaled = scaler.fit_transform(movie_user_matrix)
+
+# Define the autoencoder model
+input_dim = movie_user_matrix.shape[1]
+encoding_dim = 32
+
+input_layer = Input(shape=(input_dim,))
+encoded = Dense(64, activation='relu')(input_layer)
+encoded = Dense(encoding_dim, activation='relu')(encoded)
+decoded = Dense(64, activation='relu')(encoded)
+decoded = Dense(input_dim, activation='sigmoid')(decoded)
+
+autoencoder = Model(input_layer, decoded)
+autoencoder.compile(optimizer='adam', loss='mean_squared_error')
+
+# Train the autoencoder
+autoencoder.fit(movie_user_matrix_scaled, movie_user_matrix_scaled, 
+                epochs=50, batch_size=64, shuffle=True, validation_split=0.2, 
+                verbose=0)
+
+
+
+
+# Use the trained autoencoder to predict the complete matrix
+predicted_matrix_scaled = autoencoder.predict(movie_user_matrix_scaled)
+predicted_matrix = scaler.inverse_transform(predicted_matrix_scaled)
+
+# Create a DataFrame with the predicted matrix
+predicted_matrix_df = pd.DataFrame(predicted_matrix, index=movie_user_matrix.index, columns=movie_user_matrix.columns)
+
+# Compute the cosine similarity between movies using the predicted matrix
+movie_similarity_cfnn = cosine_similarity(predicted_matrix)
+
+# Create a DataFrame with movie similarities
+movie_similarity_cfnn_df = pd.DataFrame(movie_similarity, index=movie_user_matrix.index, columns=movie_user_matrix.index)
+
+# Function to get movie recommendations using item-based collaborative filtering
+def get_cfnn_recommendations(movie_title, movie_similarity_df=movie_similarity_cfnn_df, movies=movies, n=result_count):
+    # Get the movieId for the input movie title
+    movie_id = movies[movies['title'] == movie_title]['movieId'].values[0]
+    
+    # Check if the movie is in our similarity matrix
+    if movie_id not in movie_similarity_df.index:
+        return []
+    
+    # Get the row of similarity scores for this movie
+    similar_scores = movie_similarity_df.loc[movie_id]
+    
+    # Sort the scores in descending order
+    similar_scores = similar_scores.sort_values(ascending=False)
+    
+    # Get the indices of the top-n most similar movies (excluding the input movie itself)
+    similar_movie_indices = similar_scores.index[1:n+1]
+    
+    # Get the titles and similarity scores of the recommended movies
+    recommendations = []
+    for idx in similar_movie_indices:
+        title = movies.loc[movies['movieId'] == idx, 'title'].values[0]
+        score = similar_scores[idx]
+        recommendations.append((title, score))
+
+    return recommendations
+
+# Function for Gradio interface
+def recommend_movies_cfnn(movie_title):
+    if movie_title not in movies['title'].values:
+        return f"Movie '{movie_title}' not found in the dataset."
+    
+    recommendations = get_cfnn_recommendations(movie_title)
+    format_string = "{:>5.2f}       {:<20}"
+    return "Score     Title\n" + "\n".join([format_string.format(score, title) for title, score in recommendations])
+
+
+######################################
+#
+# Gradio interface
+#
+######################################
+
 # Create a list of movie titles for the dropdown
 movie_list = random.sample(movies['title'].tolist(), input_count)
 total_movies = len(movies)
 
-# Update the Gradio interface
 with gr.Blocks() as iface:
     with gr.Tab("Content-Based Filtering"):
         gr.Interface(fn=recommend_movies_cb, 
@@ -141,5 +227,12 @@ with gr.Blocks() as iface:
                      title="Movie Recommender - Item-Based Collaborative Filtering",
                      description="Select a movie to get recommendations based on collaborative filtering.")
 
+    with gr.Tab("Collaborative Filtering with Neural Network"):
+        gr.Interface(fn=recommend_movies_cfnn,
+                     inputs=gr.Dropdown(movie_list, label=f"Select a Movie (Total movies: {total_movies}, randomly list {input_count} for demo purpose.)"),
+                     outputs=[gr.Textbox(label="Recommended Movies:")],
+                     title="Movie Recommender - Item-Based Collaborative Filtering",
+                     description="Select a movie to get recommendations based on collaborative filtering.")
+
 # Launch the app
 iface.launch()