app.py

import pandas as pd
import numpy as np
from scipy.sparse import csr_matrix
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
from sklearn.metrics.pairwise import linear_kernel
from sklearn.preprocessing import MinMaxScaler
import tensorflow as tf
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, Dense
import gradio as gr
import zipfile
import random

input_count = 300
result_count = 21

# Extract the MovieLens dataset
with zipfile.ZipFile('ml-latest-small.zip') as z:
    with z.open('ml-latest-small/movies.csv') as f:
        movies = pd.read_csv(f)
    with z.open('ml-latest-small/ratings.csv') as f:
        ratings = pd.read_csv(f)

######################################
#
# Content-based Filtering
#
######################################

# Define a TF-IDF Vectorizer Object. Remove all english stop words such as 'the', 'a'
tfidf = TfidfVectorizer(stop_words='english')

# Replace NaN with an empty string
movies['genres'] = movies['genres'].fillna('')

# Construct the required TF-IDF matrix by fitting and transforming the data
tfidf_matrix = tfidf.fit_transform(movies['genres'])

# Compute the cosine similarity matrix
cosine_sim = linear_kernel(tfidf_matrix, tfidf_matrix)

# Construct a reverse map of indices and movie titles
indices = pd.Series(movies.index, index=movies['title']).drop_duplicates()

# Function that takes in movie title as input and outputs most similar movies
def get_cb_recommendations(title, cosine_sim=cosine_sim):
    
    # Get the index of the movie that matches the title
    idx = indices[title]

    # Get the pairwise similarity scores of all movies with that movie
    sim_scores = list(enumerate(cosine_sim[idx]))

    # Sort the movies based on the similarity scores
    sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)

    # Get the scores of the 20 most similar movies
    sim_scores = sim_scores[1:result_count]

    # Get the movie indices
    movie_indices = [i[0] for i in sim_scores]

    # Return the top 20 most similar movies with their scores
    recommendations = [(movies['title'].iloc[i], sim_scores[idx][1]) for idx, i in enumerate(movie_indices)]
    return recommendations

# Gradio interface
def recommend_movies_cb(movie):
    if not movie:
        return "No movie selected. Please select one from the dropdown."
        
    recommendations = get_cb_recommendations(movie)
    format_string = "{:>5.2f}       {:<20}"
    return "Score     Title\n" + "\n".join([format_string.format(score, title) for title, score in recommendations])


######################################
#
# Collaborative Filtering (Item-based)
#
######################################
# Create a movie-user matrix
movie_user_matrix = ratings.pivot(index='movieId', columns='userId', values='rating').fillna(0)

# Compute the cosine similarity between movies
movie_similarity = cosine_similarity(movie_user_matrix)

# Create a DataFrame with movie similarities
movie_similarity_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_cf_recommendations(movie_title, movie_similarity_df=movie_similarity_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_cf(movie_title):
    if not movie_title:
        return "No movie selected. Please select one from the dropdown."
    
    if movie_title not in movies['title'].values:
        return f"Movie '{movie_title}' not found in the dataset."
    
    recommendations = get_cf_recommendations(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 not movie_title:
        return "No movie selected. Please select one from the dropdown."
        
    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)

with gr.Blocks() as iface:
    with gr.Tab("Content-Based Filtering"):
        gr.Markdown("""## Movie Recommender - Content-Based Filtering
        How it works:
        * Use the 'genres' feature of movies, and convert genres into numerical vectors.
        * For a given movie, find the most similar movies based on the genre similarity.
        * This approach uses genres of movies only, without considering user preferences or viewing history.
        * Simple to implement and computationally efficient.
        """)        
        gr.Interface(fn=recommend_movies_cb, 
                     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 - Content-Based Filtering", 
                     description="Select a movie to get recommendations based on content filtering.")
    
    with gr.Tab("Collaborative Filtering"):
        gr.Markdown("""## Movie Recommender - Item-Based Collaborative Filtering
        How it works:
        * Create a movie-user matrix where rows represent movies and columns represent users, each cell contains the rating a user gave to a movie, or 0 if no rating exists.
        * Calculate the cosine similarity between movies based on their rating patterns, results in a movie-movie similarity matrix.
        * For a given movie, find the most similar movies based on this similarity matrix, and recommend these movies.
        * Simple to implement and computationally efficient, but doesn't handle sparsity well (when many missing ratings).
        """)
        gr.Interface(fn=recommend_movies_cf,
                     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.")

    with gr.Tab("Collaborative Filtering with Neural Network"):
        gr.Markdown("""## Movie Recommender - Item-Based Collaborative Filtering with Neural Network
        How it works:
        * Use a Neural Network to predict the missing values in the movie-user matrix to improve the collaborative filtering recommendations.
        * The NN model learns to reconstruct the movie-user matrix, effectively predicting missing ratings. This results in a dense, predicted movie-user matrix.
        * Calculate movie-movie similarities using the predicted matrix. And use this similarity matrix to find and recommend similar movies.
        * This approach often provides more accurate recommendations especially with large sparse datasets. But more complex to implement and require more computational resources.
        """)
        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()