diff --git a/.gitignore b/.gitignore
index a81c8ee1..a632c4b0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -25,7 +25,8 @@ share/python-wheels/
.installed.cfg
*.egg
MANIFEST
-
+unsupervised_functions.egg-info
+unsupervised_functions/__pycache__
# PyInstaller
# Usually these files are written by a python script from a template
# before PyInstaller builds the exe, so as to inject date/other infos into it.
diff --git a/README.md b/README.md
index 516993b9..acbe81a9 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,8 @@
# Streamlit-based Recommender System
#### EXPLORE Data Science Academy Unsupervised Predict
+This library was created to learn how to build recommender systems and inplement unsupervised learning algorithms
+
## 1) Overview
diff --git a/eda/__init__.py b/eda/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/eda/eda_functions.py b/eda/eda_functions.py
new file mode 100644
index 00000000..709322d7
--- /dev/null
+++ b/eda/eda_functions.py
@@ -0,0 +1,394 @@
+"""
+Functions to build EDA page in streamlit app
+"""
+# Imports
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import matplotlib.ticker as ticker
+import seaborn as sns
+import streamlit as st
+from utils import data_loader as dl
+import warnings
+st.set_option('deprecation.showPyplotGlobalUse', False)
+warnings.filterwarnings("ignore")
+sns.set(font_scale=1)
+sns.set_style("white")
+
+# Load data
+train_df = dl.load_dataframe('https://media.githubusercontent.com/media/LPTsilo/Team_ES2_Unsupervised_Predict/main/train.csv', index=None)
+movies_df = dl.load_dataframe('resources/data/movies.csv', index='movieId')
+imdb_df = dl.load_dataframe('resources/data/imdb_data.csv', index=None)
+
+# Functions
+# Ratings
+def user_ratings_count(df, n): # N can be played with and included as an app?
+ """
+ Returns the top n users by number of ratings in a barplot
+ Parameters
+ ----------
+ df (DataFrame): input DataFrame
+ n (int): number of users to show
+ Returns
+ -------
+ barplot (NoneType): barplot of top n users by number of observations
+ """
+ plt.figure(figsize=(8,6))
+ data = df['userId'].value_counts().head(n)
+ ax = sns.barplot(x = data.index, y = data, order= data.index, palette='brg', edgecolor="black")
+ for p in ax.patches:
+ ax.text(p.get_x() + p.get_width()/2., p.get_height(), '%d' % int(p.get_height()), fontsize=11, ha='center', va='bottom')
+ plt.title(f'Top {n} Users by Number of Ratings', fontsize=14)
+ plt.xlabel('User ID')
+ plt.ylabel('Number of Ratings')
+ print("Combined number of ratings:\t",df['userId'].value_counts().head(n).sum(),
+ "\nTotal number of movies:\t\t", df['movieId'].nunique())
+ plt.show()
+
+def ratings_distplot(df, column='rating'):
+ """
+ docstring
+ """
+ plt.figure(figsize=(8,6))
+ ax = sns.distplot(df[f'{column}'],bins=10, kde=False, hist_kws=dict(alpha=0.6),color="#4DA017")
+ mean = df[f'{column}'].mean()
+ median = df[f'{column}'].median()
+ plt.axvline(x=mean, label = f'mean {round(mean,2)}' , color='#FF0029', lw=3, ls = '--')
+ plt.axvline(x=median, label = f'median {median}' , color='#4DA017', lw=3, ls = '--')
+ plt.xlim((0.5,5))
+ plt.ylim((0,2500000))
+ plt.title(f'Distribution of Ratings', fontsize=14)
+ plt.xlabel('Rating')
+ plt.ylabel('Frequency')
+ plt.legend()
+ plt.show()
+
+def mean_ratings_scatter(df, color='#4DA017', column='userId'):
+ """
+ Describe function here
+ Parameters
+ ----------
+ Returns
+ -------
+ Example
+ """
+ plt.figure(figsize=(6,4))
+ mean_ratings = df.groupby(f'{column}')['rating'].mean()
+ user_counts = df.groupby(f'{column}')['movieId'].count().values
+ sns.scatterplot(x=mean_ratings, y = user_counts, color=color)
+ plt.title(f'Mean Ratings by Number of Ratings', fontsize=14)
+ plt.xlabel('Rating')
+ plt.ylabel('Number of Ratings')
+ st.pyplot()
+
+def plot_ratings(count, n, color='#4DA017', best=True, method='mean'):
+ """
+ docstring
+ """
+ eda_df = train_df[train_df['userId']!=72315]
+ if method == 'mean':
+ movie_avg_ratings = pd.merge(eda_df, movies_df, on='movieId', how='left').groupby(['movieId', 'title'])['rating'].mean()
+ else:
+ movie_avg_ratings = pd.DataFrame(eda_df.join(movies_df, on='movieId', how='left').groupby(['movieId', 'title'])['rating'].median())
+ movie_avg_ratings['count'] = eda_df.groupby('movieId')['userId'].count().values
+ movie_avg_ratings.reset_index(inplace=True)
+ movie_avg_ratings.set_index('movieId', inplace=True)
+
+ # Remove movies that have been rated fewer than n times
+ data = movie_avg_ratings[movie_avg_ratings['count']>count]
+ data.sort_values('rating', inplace= True,ascending=False)
+ if best == True:
+ plot = data.head(n).sort_values('rating', ascending=True)
+ title='Best Rated'
+ else:
+ plot = data.tail(n).sort_values('rating', ascending=False)
+ title='Worst Rated'
+ plt.figure(figsize=(6,5))
+ sns.scatterplot(x=plot['rating'], y=plot['title'], size=plot['count'], color=color)
+ plt.xlabel('Rating')
+ plt.ylabel('')
+ plt.tick_params(axis='y', which='both', labelleft=False, labelright=True)
+ plt.title(f'Top {n} {title} Movies with Over {count} Ratings', fontsize=14)
+ st.pyplot()
+
+def number_users_per_rating(df1 = train_df):
+ """
+ Plots the number of users who gave a rating
+ Parameters
+ ----------
+ df1 (DataFrame): input df containg user-item interactions matrix
+ Returns
+ -------
+ barplot (NoneType): barplot of results
+ """
+ movieRatingDistGroup = df1['rating'].value_counts().sort_index().reset_index()
+ fig, ax = plt.subplots(figsize=(10,6))
+ sns.barplot(data=movieRatingDistGroup, x='index', y='rating', palette="brg", edgecolor="black", ax=ax)
+ ax.set_xlabel("Rating")
+ ax.set_ylabel('Number of Users')
+ ax.yaxis.set_major_formatter(ticker.FuncFormatter(lambda x, pos: '{:,}'.format(int(x))))
+ total = float(movieRatingDistGroup['rating'].sum())
+ for p in ax.patches:
+ height = p.get_height()
+ ax.text(p.get_x()+p.get_width()/2., height+350, '{0:.2%}'.format(height/total), fontsize=11, ha="center", va='bottom')
+ plt.title('Number of Users Per Rating', fontsize=14)
+ plt.show()
+
+
+# Genres
+
+# function that hasn't found a use yet
+def feat_extractor(df, col):
+ """
+ returns a list of all unique features in a DataFrame columns separated by "|"
+ """
+ df.fillna("", inplace=True)
+ feat_set = set()
+ for i in range(len(df[f'{col}'])):
+ for feat in df[f'{col}'].iloc[i].split('|'):
+ feat_set.add(feat)
+ return sorted([feat for feat in feat_set if feat != ""])
+
+@st.cache(allow_output_mutation=True)
+def feature_frequency(df, column):
+ """
+ Function to count the number of occurences of metadata such as genre
+ Parameters
+ ----------
+ df (DataFrame): input DataFrame containing movie metadata
+ column (str): target column to extract features from
+ Returns
+ -------
+
+ """
+ # Creat a dict to store values
+ df = df.dropna(axis=0)
+ genre_dict = {f'{column}': list(),
+ 'count': list(),}
+ # Retrieve a list of all possible genres
+ print('retrieving features...')
+ for movie in range(len(df)):
+ gens = df[f'{column}'].iloc[movie].split('|')
+ for gen in gens:
+ if gen not in genre_dict[f'{column}']:
+ genre_dict[f'{column}'].append(gen)
+ # count the number of occurences of each genre
+ print('counting...')
+ for genre in genre_dict[f'{column}']:
+ count = 0
+ for movie in range(len(df)):
+ gens = df[f'{column}'].iloc[movie].split('|')
+ if genre in gens:
+ count += 1
+ genre_dict['count'].append(count)
+
+ # Calculate metrics
+ data = pd.DataFrame(genre_dict)
+ return data
+
+def feature_count(df, column):
+ """
+ Returns a barplot showing the number of movies per genre
+ Parameters
+ ----------
+ df (DataFrame): input dataframe containing genre frequency
+ column (str): target column to plot
+ Returns
+ -------
+ barplot (NoneType): barplot visual
+ Example
+ -------
+ """
+ plt.figure(figsize=(10,6))
+ ax = sns.barplot(y = df[f'{column}'], x = df['count'], palette='brg', orient='h')
+ plt.title(f'Number of Movies Per {column[:-1]}', fontsize=14)
+ plt.ylabel(f'{column}')
+ plt.xlabel('Count')
+ st.pyplot()
+
+ #mean_ratings = pd.DataFrame(train_df.join(movies_df, on='movieId', how='left').join(imdb_df, on = 'movieId', how = 'left').groupby(['movieId'])['rating'].mean())
+
+@st.cache(allow_output_mutation=True)
+def mean_calc(feat_df, ratings = train_df, movies = movies_df, metadata = imdb_df, column = 'genres'):
+ """
+ Function that calculates the mean ratings of a feature
+ Parameters
+ ----------
+ feat_df (DataFrame): input df containing feature data eg genres
+ ratings (DataFrame): user-item interaction matrix
+ movies (DataFrame): input df containing item names and genres column
+ metadata (DataFrame): input df containing imdb metadata
+ column (str): target column to calculate means
+ Returns
+ -------
+ means (list): list of means for each genre
+ Example
+ -------
+ >>>genres['mean_rating'] = mean_calc(genres)
+
+ """
+ mean_ratings = pd.DataFrame(ratings.join(movies, on='movieId', how='left').groupby(['movieId'])['rating'].mean())
+ movie_eda = movies.copy()
+ movie_eda = movie_eda.join(mean_ratings, on = 'movieId', how = 'left')
+
+ # Exclude missing values
+ movie_eda = movie_eda
+ movie_eda2 = movie_eda[movie_eda['rating'].notnull()]
+
+ means = []
+ for feat in feat_df[f'{column}']:
+ mean = round(movie_eda2[movie_eda2[f'{column}'].str.contains(feat)]['rating'].mean(),2)
+ means.append(mean)
+ return means
+ genres['mean_rating'] = mean_calc(genres)
+ genres.sort_values('mean_rating', ascending=False).head(5)
+
+def genre_popularity(df):
+ """
+ docstring
+ """
+ count_filt = 500
+ plt.figure(figsize=(10,6))
+ plot_data = df[df['count']>count_filt]
+ mean = plot_data['mean_rating'].mean()
+ min_ = plot_data['mean_rating'].min()
+ max_ = plot_data['mean_rating'].max()
+ sns.barplot(y = plot_data['genres'], x = plot_data['mean_rating'], order = plot_data['genres'], orient='h',palette='brg')
+ plt.axvline(x=mean, label = f'mean {round(mean,1)}' , color='black', lw=1, ls ='--')
+ plt.axvline(x=min_, label = f'min {round(min_,1)}' , color='#4D17A0', lw=1, ls = '--')
+ plt.axvline(x=max_, label = f'max {max_}' , color='#4DA017', lw=1,ls = '--')
+ plt.title(f'Mean Rating Per Genre', fontsize=14)
+ plt.ylabel('Genre')
+ plt.xlabel('Mean Rating')
+ plt.legend(loc='lower center')
+ plt.tight_layout()
+ st.pyplot()
+
+# Directors
+
+def count_directors(df, count = 10):
+ """
+ Function to count the most common dircetors in a DataFrame:
+ Parameters
+ ----------
+ df (DataFrame): input dataframe containing imdb metadata
+ count (int): filter directors with fewer than count films
+
+ Returns
+ -------
+ directors (DataFrame): output DataFrame
+ """
+ directors = pd.DataFrame(df['director'].value_counts()).reset_index()
+ directors.columns = ['director', 'count']
+ # Lets only take directors who have made 10 or more movies otherwise we will have to analyze 11000 directors
+ directors = directors[directors['count']>=count]
+ return directors.sort_values('count', ascending = False)
+@st.cache(allow_output_mutation=True)
+def dir_mean(df):
+ df.set_index('director', inplace=True)
+
+ direct_ratings = []
+ directors_eda = train_df.merge(imdb_df.set_index('movieId'), on = 'movieId', how = 'left')
+ for director in df.index:
+ rating = round(directors_eda[directors_eda['director']==director]['rating'].mean(),2)
+ direct_ratings.append(rating)
+ df['mean_rating'] = direct_ratings
+ return df.sort_values('mean_rating', ascending = False)
+
+def feat_popularity(df, title = 'feat'):
+ """
+ docstring
+ """
+ plt.figure(figsize=(10,6))
+ plot_data = df.copy()
+ mean = plot_data['mean_rating'].mean()
+ min_ = plot_data['mean_rating'].min()
+ max_ = round(plot_data['mean_rating'].max(),2)
+ sns.barplot(y = plot_data.index, x = plot_data['mean_rating'], order = plot_data.index, orient='h',palette='brg')
+ plt.axvline(x=mean, label = f'mean {round(mean,1)}' , color='black', lw=1, ls ='--')
+ plt.axvline(x=min_, label = f'min {round(min_,1)}' , color='#4D17A0', lw=1, ls = '--')
+ plt.axvline(x=max_, label = f'max {max_}' , color='#4DA017', lw=1,ls = '--')
+ plt.title(f'Mean Rating Per {title}', fontsize=14)
+ plt.ylabel('Genre')
+ plt.xlabel('Mean Rating')
+ plt.legend(loc='lower center')
+ st.pyplot()
+
+def plot_ratings(count, n=10, color='#4DA017', best=True, method='mean'):
+ """
+ docstring
+ """
+ # What are the best and worst movies
+ # Creating a new DF with mean and count
+ if method == 'mean':
+ movie_avg_ratings = pd.DataFrame(train_df.join(movies_df, on='movieId', how='left').groupby(['movieId', 'title'])['rating'].mean())
+ else:
+ movie_avg_ratings = pd.DataFrame(train_df.join(movies_df, on='movieId', how='left').groupby(['movieId', 'title'])['rating'].median())
+ movie_avg_ratings['count'] = train_df.groupby('movieId')['userId'].count().values
+ movie_avg_ratings.reset_index(inplace=True)
+ movie_avg_ratings.set_index('movieId', inplace=True)
+
+ # Remove movies that have been rated fewer than n times
+ data = movie_avg_ratings[movie_avg_ratings['count']>count]
+ data.sort_values('rating', inplace= True,ascending=False)
+ if best == True:
+ plot = data.head(n).sort_values('rating', ascending=True)
+ title='Best Rated'
+ else:
+ plot = data.tail(n).sort_values('rating', ascending=False)
+ title='Worst Rated'
+ plt.figure(figsize=(12,6))
+ sns.scatterplot(x=plot['rating'], y=plot['title'], size=plot['count'], color=color)
+ plt.xlabel('Rating')
+ plt.ylabel('', fontsize=8)
+ plt.tick_params(axis='y', which='both', labelleft=False, labelright=True)
+ plt.title(f'Top {n} {title} Movies with Over {count} Ratings', fontsize=14)
+ plt.tight_layout()
+ st.pyplot()
+
+ # function that hasn't found a use yet
+def feat_extractor(df, col):
+ """
+ returns a list of all unique features in a DataFrame columns separated by "|"
+ """
+ df.fillna("", inplace=True)
+ feat_set = set()
+ for i in range(len(df[f'{col}'])):
+ for feat in df[f'{col}'].iloc[i].split('|'):
+ feat_set.add(feat)
+ return sorted([feat for feat in feat_set if feat != ""])
+
+def genre_frequency(df):
+ """
+ docstring
+ """
+ # Creat a dict to store values
+ genre_dict = {'genre': list(),
+ 'count': list(),}
+ # Retrieve a list of all possible genres
+ for movie in range(len(df)):
+ gens = df['genres'].iloc[movie].split('|')
+ for gen in gens:
+ if gen not in genre_dict['genre']:
+ genre_dict['genre'].append(gen)
+ # count the number of occurences of each genre
+ for genre in genre_dict['genre']:
+ count = 0
+ for movie in range(len(df)):
+ gens = df['genres'].iloc[movie].split('|')
+ if genre in gens:
+ count += 1
+ genre_dict['count'].append(count)
+
+ # Calculate metrics
+ data = pd.DataFrame(genre_dict)
+ return data
+ data = genre_frequency(movies_df)
+
+def genre_count(df):
+ plt.figure(figsize=(10,6))
+ ax = sns.barplot(y = df['genre'], x = df['count'], palette='brg', orient='h')
+ plt.title(f'Number of Movies Per Genre', fontsize=14)
+ plt.ylabel('Genre')
+ plt.xlabel('Count')
+ st.pyplot()
diff --git a/edsa_recommender.py b/edsa_recommender.py
index f1192112..1af0889f 100644
--- a/edsa_recommender.py
+++ b/edsa_recommender.py
@@ -1,112 +1,292 @@
-"""
-
- Streamlit webserver-based Recommender Engine.
-
- Author: Explore Data Science Academy.
-
- Note:
- ---------------------------------------------------------------------
- Please follow the instructions provided within the README.md file
- located within the root of this repository for guidance on how to use
- this script correctly.
-
- NB: !! Do not remove/modify the code delimited by dashes !!
-
- This application is intended to be partly marked in an automated manner.
- Altering delimited code may result in a mark of 0.
- ---------------------------------------------------------------------
-
- Description: This file is used to launch a minimal streamlit web
- application. You are expected to extend certain aspects of this script
- and its dependencies as part of your predict project.
-
- For further help with the Streamlit framework, see:
-
- https://docs.streamlit.io/en/latest/
-
-"""
-# Streamlit dependencies
-import streamlit as st
-
-# Data handling dependencies
-import pandas as pd
-import numpy as np
-
-# Custom Libraries
-from utils.data_loader import load_movie_titles
-from recommenders.collaborative_based import collab_model
-from recommenders.content_based import content_model
-
-# Data Loading
-title_list = load_movie_titles('resources/data/movies.csv')
-
-# App declaration
-def main():
-
- # DO NOT REMOVE the 'Recommender System' option below, however,
- # you are welcome to add more options to enrich your app.
- page_options = ["Recommender System","Solution Overview"]
-
- # -------------------------------------------------------------------
- # ----------- !! THIS CODE MUST NOT BE ALTERED !! -------------------
- # -------------------------------------------------------------------
- page_selection = st.sidebar.selectbox("Choose Option", page_options)
- if page_selection == "Recommender System":
- # Header contents
- st.write('# Movie Recommender Engine')
- st.write('### EXPLORE Data Science Academy Unsupervised Predict')
- st.image('resources/imgs/Image_header.png',use_column_width=True)
- # Recommender System algorithm selection
- sys = st.radio("Select an algorithm",
- ('Content Based Filtering',
- 'Collaborative Based Filtering'))
-
- # User-based preferences
- st.write('### Enter Your Three Favorite Movies')
- movie_1 = st.selectbox('Fisrt Option',title_list[14930:15200])
- movie_2 = st.selectbox('Second Option',title_list[25055:25255])
- movie_3 = st.selectbox('Third Option',title_list[21100:21200])
- fav_movies = [movie_1,movie_2,movie_3]
-
- # Perform top-10 movie recommendation generation
- if sys == 'Content Based Filtering':
- if st.button("Recommend"):
- try:
- with st.spinner('Crunching the numbers...'):
- top_recommendations = content_model(movie_list=fav_movies,
- top_n=10)
- st.title("We think you'll like:")
- for i,j in enumerate(top_recommendations):
- st.subheader(str(i+1)+'. '+j)
- except:
- st.error("Oops! Looks like this algorithm does't work.\
- We'll need to fix it!")
-
-
- if sys == 'Collaborative Based Filtering':
- if st.button("Recommend"):
- try:
- with st.spinner('Crunching the numbers...'):
- top_recommendations = collab_model(movie_list=fav_movies,
- top_n=10)
- st.title("We think you'll like:")
- for i,j in enumerate(top_recommendations):
- st.subheader(str(i+1)+'. '+j)
- except:
- st.error("Oops! Looks like this algorithm does't work.\
- We'll need to fix it!")
-
-
- # -------------------------------------------------------------------
-
- # ------------- SAFE FOR ALTERING/EXTENSION -------------------
- if page_selection == "Solution Overview":
- st.title("Solution Overview")
- st.write("Describe your winning approach on this page")
-
- # You may want to add more sections here for aspects such as an EDA,
- # or to provide your business pitch.
-
-
-if __name__ == '__main__':
- main()
+"""
+
+ Streamlit webserver-based Recommender Engine.
+
+ Author: Explore Data Science Academy.
+
+ Note:
+ ---------------------------------------------------------------------
+ Please follow the instructions provided within the README.md file
+ located within the root of this repository for guidance on how to use
+ this script correctly.
+
+ NB: !! Do not remove/modify the code delimited by dashes !!
+
+ This application is intended to be partly marked in an automated manner.
+ Altering delimited code may result in a mark of 0.
+ ---------------------------------------------------------------------
+
+ Description: This file is used to launch a minimal streamlit web
+ application. You are expected to extend certain aspects of this script
+ and its dependencies as part of your predict project.
+
+ For further help with the Streamlit framework, see:
+
+ https://docs.streamlit.io/en/latest/
+
+"""
+# Streamlit dependencies
+import streamlit as st
+
+# Data handling dependencies
+import pandas as pd
+import numpy as np
+
+# Data Visulization
+import matplotlib.pyplot as plt
+
+# Custom Libraries
+from utils import data_loader as dl
+from eda import eda_functions as eda
+from recommenders.collaborative_based import collab_model
+from recommenders.content_based import content_model
+st.set_option('deprecation.showPyplotGlobalUse', False)
+import warnings
+warnings.simplefilter(action='ignore')
+
+page_bg_img = """
+
+"""
+st.markdown(page_bg_img, unsafe_allow_html=True)
+
+path_to_s3 = ('https://media.githubusercontent.com/media/LPTsilo/Team_ES2_Unsupervised_Predict/main/')
+
+# Data Loading
+
+
+# Loading a css stylesheet
+def load_css(file_name):
+ with open(file_name) as f:
+ st.markdown(f'', unsafe_allow_html=True)
+load_css("resources/css/style.css")
+
+# App declaration
+def main():
+
+ # DO NOT REMOVE the 'Recommender System' option below, however,
+ # you are welcome to add more options to enrich your app.
+ page_options = [ "Recommender System", "Introduction", "Exploratory Data Analysis", "Solution Overview"]
+
+################################################################################
+################################ MODEL #########################################
+################################################################################
+
+ # -------------------------------------------------------------------
+ # ----------- !! THIS CODE MUST NOT BE ALTERED !! -------------------
+ # -------------------------------------------------------------------
+ page_selection = st.sidebar.selectbox("Select Page", page_options)
+ if page_selection == "Recommender System":
+ title_list = dl.load_movie_titles('https://media.githubusercontent.com/media/LPTsilo/Team_ES2_Unsupervised_Predict/main/movies.csv')
+ # Header contents
+ st.write('# Movie Recommender Engine')
+ st.write('### EXPLORE Data Science Academy Unsupervised Predict')
+ st.image('resources/imgs/Image_header.png',use_column_width=True)
+ # Recommender System algorithm selection
+ sys = st.radio("Select an algorithm",
+ ('Content Based Filtering',
+ 'Collaborative Based Filtering'))
+
+ # User-based preferences
+ # movie_list = pd.merge(df_train, title_list, on = 'movieId', how ='left').groupby('title')['ratings'].mean()
+ st.write('### Enter Your Three Favorite Movies')
+ movie_1 = st.selectbox('First Option',title_list[14930:15200])
+ movie_2 = st.selectbox('Second Option',title_list[25055:25255])
+ movie_3 = st.selectbox('Third Option',title_list[21100:21200])
+ fav_movies = [movie_1,movie_2,movie_3]
+
+ # Perform top-10 movie recommendation generation
+ if sys == 'Content Based Filtering':
+ if st.button("Recommend"):
+ try:
+ with st.spinner('Crunching the numbers...'):
+ top_recommendations = content_model(movie_list=fav_movies,
+ top_n=10)
+ st.title("We think you'll like:")
+ for i,j in enumerate(top_recommendations):
+ st.subheader(str(i+1)+'. '+j)
+ except:
+ st.error("Oops! Looks like this algorithm does't work.\
+ We'll need to fix it!")
+
+
+ if sys == 'Collaborative Based Filtering':
+ if st.button("Recommend"):
+ try:
+ with st.spinner('Crunching the numbers...'):
+ top_recommendations = collab_model(movie_list=fav_movies,
+ top_n=10)
+ st.title("We think you'll like:")
+ for i,j in enumerate(top_recommendations):
+ st.subheader(str(i+1)+'. '+j)
+ except:
+ st.error("Oops! Looks like this algorithm does't work.\
+ We'll need to fix it!")
+ # -------------------------------------------------------------------
+
+################################################################################
+################################ Solution Overview #############################
+################################################################################
+
+ # ------------- SAFE FOR ALTERING/EXTENSION -------------------
+ if page_selection == "Solution Overview":
+ st.title("Solution Overview")
+ st.markdown(open('resources/markdown/solution.md').read(), unsafe_allow_html=True)
+ st.image('resources/imgs/models.png')
+
+################################################################################
+################################ EDA ###########################################
+################################################################################
+
+ # ------------- EDA -------------------------------------------
+ if page_selection == "Exploratory Data Analysis":
+ page_options_eda = ["User Interactions", "Movies", "Genres", "Directors"]
+ page_selection_eda = st.selectbox("Select Feature", page_options_eda)
+ if page_selection_eda == "User Interactions":
+ st.sidebar.markdown(open('resources/markdown/eda/userint.md').read(), unsafe_allow_html=True)
+
+ # Most Active
+ st.subheader("Most Active Users")
+ df_train = dl.load_dataframe('https://media.githubusercontent.com/media/LPTsilo/Team_ES2_Unsupervised_Predict/main/train.csv', index=None)
+ top_user = st.checkbox('Include top user',value=False)
+
+ ## include top user
+ if top_user == True:
+ ratings = df_train
+ else:
+ ratings = df_train[df_train['userId']!=72315]
+
+ ## choose top k(select number of users rated)
+ n = st.number_input('Select number of users (1-50)',min_value=5, max_value=50, step = 5, value=10)
+ ratings_plot = eda.user_ratings_count(ratings, n)
+ if n>=10:
+ plt.xticks(rotation=45)
+ plt.tight_layout()
+ st.pyplot()
+
+ st.write("User 72315 has rated an extreme number of movies relative to other users. For EDA purposes, this user can be removed above to make interpretation easier.")
+
+ # Ratings Distribution
+ st.subheader('Ratings Distribution')
+ eda.number_users_per_rating(ratings)
+ plt.tight_layout()
+ st.pyplot()
+ st.write(open('resources/markdown/eda/ratings_dist.md').read(), unsafe_allow_html=True)
+
+ # Rating v number of ratings
+ st.subheader('Ratings trends')
+ eda.mean_ratings_scatter(ratings, column ='movieId')
+ plt.title('Mean movie rating by number of ratings received')
+ plt.tight_layout()
+ st.pyplot()
+ st.write('it seems like The more ratings a movie has, the more highly it is likely to be rated. This confirms our intuitive understanding that the more highly rated a movie is, the more likely is that viewers will recommend the movie to each other. In other words, people generally try to avoid maing bad recommendations')
+
+ if page_selection_eda == "Movies":
+ st.sidebar.markdown(open('resources/markdown/eda/movies.md').read(), unsafe_allow_html=True)
+ counts = st.number_input('Choose min ratings', min_value=0, max_value=15000, value = 10000, step=1000)
+ ns= st.number_input('Choose n movies', min_value=5, max_value=20, value=10,step=5)
+ st.subheader('Best and Worst Movies by Genre')
+ eda.plot_ratings(count=counts, n=ns, color='#4D17A0', best=True, method='mean')
+ st.pyplot()
+ st.write('By filtering movies with less than 10000 ratings, we find that the most popular movies are unsurprising titles. The Shawshank Redemption and The Godfather unsurprisingly top the list. What is interesting is that Movies made post 2000 do not feature often. Do users have a preference to Older movies?')
+
+ eda.plot_ratings(count=counts, n=ns, color='#4DA017', best=False, method='mean')
+ #plt.tight_layout()
+ st.pyplot()
+ st.write('Obviously, users did not like Battlefield too much and with 1200 ratings, they really wanted it to be known. It is interesting how many sequels appear in the list')
+
+
+ if page_selection_eda == "Directors":
+ st.sidebar.markdown(open('resources/markdown/eda/directors.md').read(), unsafe_allow_html=True)
+ imdb_df = dl.load_dataframe('resources/data/imdb_data.csv', index=None)
+
+ directors=eda.count_directors(imdb_df)
+
+ nt= st.number_input('Choose n directors', min_value=5, max_value=20, value=10,step=5)
+ st.subheader('Most Common Directors')
+ eda.feature_count(directors.head(nt), 'director')
+ plt.title('Number of movies per director')
+ plt.tight_layout()
+ st.pyplot()
+ st.write('Once again we need to calculate a mean rating for each director in order to determine who is the most popular')
+
+ directors = eda.dir_mean(directors)
+
+ st.subheader('Most popular directors')
+ eda.feat_popularity(directors.head(nt), 'Director')
+ plt.tight_layout()
+ st.pyplot()
+
+ st.write('Immediately, we see some very well known names, Stephen King and Quentin Tarantino are unsurprisingly top of the list. It begs the question, who are the worst rated directors?')
+ st.subheader('Least popular directors')
+ eda.feat_popularity(directors.tail(nt), 'Director')
+ plt.tight_layout()
+ st.pyplot()
+ st.write('It is unfortunate to find Tyler Perry and Akira Toriyama so poorly rated. Tyler Perry is best known for his Madea series of movies. As we saw from the least popular movies, sequels do not perform well and Madea has numerous sequels.')
+
+ if page_selection_eda == "Genres":
+ st.sidebar.markdown(open('resources/markdown/eda/genres.md').read(), unsafe_allow_html=True)
+ st.subheader('Genre Distribution')
+ movies_df = dl.load_dataframe('resources/data/movies.csv', index=None)
+ genres= eda.feature_frequency(movies_df, 'genres')
+
+ eda.feature_count(genres.sort_values(by = 'count', ascending=False), 'genres')
+ st.pyplot()
+ st.write('Drama is the most frequently occuring genre in the database. Approximately 5000 movies have missing genres. We can use the IMDB and TMDB IDs together with the APIs to fill missing data. Further, IMAX is not a genre but rather a proprietary system for mass-viewings.')
+ st.write('The above figure does not tell us anything about the popularity of the genres, lets calculate a mean rating and append it to the Data')
+ genres['mean_rating']=eda.mean_calc(genres)
+ show_data = st.checkbox('Show raw genre data?')
+ if show_data:
+ st.write(genres.sort_values('mean_rating', ascending=False))
+ st.write('Film-Noir describes Hollywood crime dramas, particularly those that emphasize cynical attitudes and sexual motivations. The 1940s and 1950s are generally regarded as the "classic period" of American film-noir. These movies have the highest ratings but this may be as a result of its niche audence. The same logic can be applied to IMAX movies, as such, we will only include genres with a count of 500 or more.')
+ eda.genre_popularity(genres.sort_values(by='mean_rating'))
+ st.pyplot()
+ st.write('The scores are almost evenly distributed with the exceptions of Documentaries, War, Drama, Musicals, and Romance and Thriller, Action, Sci-Fi, and Horror, which rate higher than average and below average respectively.')
+
+################################################################################
+################################ Introduction ##################################
+################################################################################
+
+ if page_selection == "Introduction":
+ st.sidebar.markdown(open('resources/markdown/introduction/contrib.md').read(), unsafe_allow_html=True)
+ st.markdown("Team ES2 Data Flex", unsafe_allow_html=True)
+ st.image('resources/imgs/team_logo.jpg',use_column_width=True)
+
+ info_pages = ["Select Option", "General Information"]
+ info_page_selection = st.selectbox("", info_pages)
+
+ if info_page_selection == "Select Option":
+ st.info("Welcome! Select an option from the menu above to get started.")
+
+ if info_page_selection == "General Information":
+ st.info("Read more about the project and the data that was used to solve the problem at hand.")
+ st.markdown(open('resources/markdown/introduction/general_information/intro.md').read(), unsafe_allow_html=True)
+
+ definitions = st.checkbox("Show definitions")
+ see_raw = st.checkbox("Show data")
+
+ if definitions:
+ st.write(open('resources/markdown/introduction/general_information/data_def.md', encoding='utf8').read(), unsafe_allow_html=True)
+ if see_raw:
+ st.write(dl.load_dataframe('resources/data/ratings.csv', index='userId').head(10))
+ st.write(dl.load_dataframe('resources/data/movies.csv',index='movieId').head(10))
+
+if __name__ == '__main__':
+ main()
diff --git a/recommenders/collaborative_based.py b/recommenders/collaborative_based.py
index 861b5d8f..dee0f2f8 100644
--- a/recommenders/collaborative_based.py
+++ b/recommenders/collaborative_based.py
@@ -1,148 +1,178 @@
-"""
-
- Collaborative-based filtering for item recommendation.
-
- Author: Explore Data Science Academy.
-
- Note:
- ---------------------------------------------------------------------
- Please follow the instructions provided within the README.md file
- located within the root of this repository for guidance on how to use
- this script correctly.
-
- NB: You are required to extend this baseline algorithm to enable more
- efficient and accurate computation of recommendations.
-
- !! You must not change the name and signature (arguments) of the
- prediction function, `collab_model` !!
-
- You must however change its contents (i.e. add your own collaborative
- filtering algorithm), as well as altering/adding any other functions
- as part of your improvement.
-
- ---------------------------------------------------------------------
-
- Description: Provided within this file is a baseline collaborative
- filtering algorithm for rating predictions on Movie data.
-
-"""
-
-# Script dependencies
-import pandas as pd
-import numpy as np
-import pickle
-import copy
-from surprise import Reader, Dataset
-from surprise import SVD, NormalPredictor, BaselineOnly, KNNBasic, NMF
-from sklearn.metrics.pairwise import cosine_similarity
-from sklearn.feature_extraction.text import CountVectorizer
-
-# Importing data
-movies_df = pd.read_csv('resources/data/movies.csv',sep = ',')
-ratings_df = pd.read_csv('resources/data/ratings.csv')
-ratings_df.drop(['timestamp'], axis=1,inplace=True)
-
-# We make use of an SVD model trained on a subset of the MovieLens 10k dataset.
-model=pickle.load(open('resources/models/SVD.pkl', 'rb'))
-
-def prediction_item(item_id):
- """Map a given favourite movie to users within the
- MovieLens dataset with the same preference.
-
- Parameters
- ----------
- item_id : int
- A MovieLens Movie ID.
-
- Returns
- -------
- list
- User IDs of users with similar high ratings for the given movie.
-
- """
- # Data preprosessing
- reader = Reader(rating_scale=(0, 5))
- load_df = Dataset.load_from_df(ratings_df,reader)
- a_train = load_df.build_full_trainset()
-
- predictions = []
- for ui in a_train.all_users():
- predictions.append(model.predict(iid=item_id,uid=ui, verbose = False))
- return predictions
-
-def pred_movies(movie_list):
- """Maps the given favourite movies selected within the app to corresponding
- users within the MovieLens dataset.
-
- Parameters
- ----------
- movie_list : list
- Three favourite movies selected by the app user.
-
- Returns
- -------
- list
- User-ID's of users with similar high ratings for each movie.
-
- """
- # Store the id of users
- id_store=[]
- # For each movie selected by a user of the app,
- # predict a corresponding user within the dataset with the highest rating
- for i in movie_list:
- predictions = prediction_item(item_id = i)
- predictions.sort(key=lambda x: x.est, reverse=True)
- # Take the top 10 user id's from each movie with highest rankings
- for pred in predictions[:10]:
- id_store.append(pred.uid)
- # Return a list of user id's
- return id_store
-
-# !! DO NOT CHANGE THIS FUNCTION SIGNATURE !!
-# You are, however, encouraged to change its content.
-def collab_model(movie_list,top_n=10):
- """Performs Collaborative filtering based upon a list of movies supplied
- by the app user.
-
- Parameters
- ----------
- movie_list : list (str)
- Favorite movies chosen by the app user.
- top_n : type
- Number of top recommendations to return to the user.
-
- Returns
- -------
- list (str)
- Titles of the top-n movie recommendations to the user.
-
- """
-
- indices = pd.Series(movies_df['title'])
- movie_ids = pred_movies(movie_list)
- df_init_users = ratings_df[ratings_df['userId']==movie_ids[0]]
- for i in movie_ids :
- df_init_users=df_init_users.append(ratings_df[ratings_df['userId']==i])
- # Getting the cosine similarity matrix
- cosine_sim = cosine_similarity(np.array(df_init_users), np.array(df_init_users))
- idx_1 = indices[indices == movie_list[0]].index[0]
- idx_2 = indices[indices == movie_list[1]].index[0]
- idx_3 = indices[indices == movie_list[2]].index[0]
- # Creating a Series with the similarity scores in descending order
- rank_1 = cosine_sim[idx_1]
- rank_2 = cosine_sim[idx_2]
- rank_3 = cosine_sim[idx_3]
- # Calculating the scores
- score_series_1 = pd.Series(rank_1).sort_values(ascending = False)
- score_series_2 = pd.Series(rank_2).sort_values(ascending = False)
- score_series_3 = pd.Series(rank_3).sort_values(ascending = False)
- # Appending the names of movies
- listings = score_series_1.append(score_series_1).append(score_series_3).sort_values(ascending = False)
- recommended_movies = []
- # Choose top 50
- top_50_indexes = list(listings.iloc[1:50].index)
- # Removing chosen movies
- top_indexes = np.setdiff1d(top_50_indexes,[idx_1,idx_2,idx_3])
- for i in top_indexes[:top_n]:
- recommended_movies.append(list(movies_df['title'])[i])
- return recommended_movies
+"""
+
+ Collaborative-based filtering for item recommendation.
+
+ Author: Explore Data Science Academy.
+
+ Note:
+ ---------------------------------------------------------------------
+ Please follow the instructions provided within the README.md file
+ located within the root of this repository for guidance on how to use
+ this script correctly.
+
+ NB: You are required to extend this baseline algorithm to enable more
+ efficient and accurate computation of recommendations.
+
+ !! You must not change the name and signature (arguments) of the
+ prediction function, `collab_model` !!
+
+ You must however change its contents (i.e. add your own collaborative
+ filtering algorithm), as well as altering/adding any other functions
+ as part of your improvement.
+
+ ---------------------------------------------------------------------
+
+ Description: Provided within this file is a baseline collaborative
+ filtering algorithm for rating predictions on Movie data.
+
+"""
+
+# Script dependencies
+import pandas as pd
+import numpy as np
+import scipy as sp
+import pickle
+import copy
+from surprise import Reader, Dataset, SVD
+from sklearn.metrics.pairwise import cosine_similarity
+from sklearn.feature_extraction.text import CountVectorizer
+
+# Importing data
+#movies_df = pd.read_csv('/home/explore-student/unsupervised_data/unsupervised_movie_data/movies.csv',sep = ',',delimiter=',')
+#ratings_df = pd.read_csv('/home/explore-student/unsupervised_data/unsupervised_movie_data/train.csv')
+movies_df = pd.read_csv('resources/data/movies.csv',sep = ',')
+ratings_df = pd.read_csv('resources/data/ratings.csv')
+ratings_df.drop(['timestamp'], axis=1, inplace=True)
+
+# We make use of an SVD model trained on a subset of the MovieLens 10k dataset.
+model=pickle.load(open('resources/models/SVD.pkl', 'rb'))
+
+def prediction_item(item_id):
+ """Map a given favourite movie to users within the
+ MovieLens dataset with the same preference.
+
+ Parameters
+ ----------
+ item_id : int
+ A MovieLens Movie ID.
+
+ Returns
+ -------
+ list
+ User IDs of users with similar high ratings for the given movie.
+
+ """
+ # Data preprosessing
+ reader = Reader(rating_scale=(0, 5))
+ load_df = Dataset.load_from_df(ratings_df,reader)
+ a_train = load_df.build_full_trainset()
+
+ predictions = []
+ for ui in a_train.all_users():
+ predictions.append(model.predict(iid=item_id,uid=ui, verbose = False))
+ return predictions
+
+def pred_movies(movie_list):
+ """Maps the given favourite movies selected within the app to corresponding
+ users within the MovieLens dataset.
+
+ Parameters
+ ----------
+ movie_list : list
+ Three favourite movies selected by the app user.
+
+ Returns
+ -------
+ list
+ User-ID's of users with similar high ratings for each movie.
+
+ """
+ # Store the id of users
+ id_store=[]
+ # For each movie selected by a user of the app,
+ # predict a corresponding user within the dataset with the highest rating
+ for i in movie_list:
+ predictions = prediction_item(item_id = i)
+ predictions.sort(key=lambda x: x.est, reverse=True)
+ # Take the top 10 user id's from each movie with highest rankings
+ for pred in predictions[:10]:
+ id_store.append(pred.uid)
+ # Return a list of user id's
+ return id_store
+
+# !! DO NOT CHANGE THIS FUNCTION SIGNATURE !!
+# You are, however, encouraged to change its content.
+def collab_model(movie_list,top_n=10):
+ """Performs Collaborative filtering based upon a list of movies supplied
+ by the app user.
+
+ Parameters
+ ----------
+ movie_list : list (str)
+ Favorite movies chosen by the app user.
+ top_n : type
+ Number of top recommendations to return to the user.
+
+ Returns
+ -------
+ list (str)
+ Titles of the top-n movie recommendations to the user.
+
+ """
+ names = movies_df.copy()
+ names.set_index('movieId',inplace=True)
+ indices = pd.Series(names['title'])
+ users_ids = pred_movies(movie_list)
+ # Get movie IDs and ratings for top users
+ df_init_users = ratings_df[ratings_df['userId']==users_ids[0]]
+ for i in users_ids[1:]:
+ df_init_users = df_init_users.append(ratings_df[ratings_df['userId']==i])
+ # Include predictions for chosen movies
+ for j in movie_list:
+ a = pd.DataFrame(prediction_item(j))
+ for i in set(df_init_users['userId']):
+ mid = indices[indices == j].index[0]
+ est = a['est'][a['uid']==i].values[0]
+ df_init_users = df_init_users.append(pd.Series([int(i),int(mid),est], index=['userId','movieId','rating']), ignore_index=True)
+ # Remove duplicate entries
+ df_init_users.drop_duplicates(inplace=True)
+ #Create pivot table
+ util_matrix = df_init_users.pivot_table(index=['userId'], columns=['movieId'], values='rating')
+ # Fill Nan values with 0's and save the utility matrix in scipy's sparse matrix format
+ util_matrix.fillna(0, inplace=True)
+ util_matrix_sparse = sp.sparse.csr_matrix(util_matrix.values)
+ # Compute the similarity matrix using the cosine similarity metric
+ user_similarity = cosine_similarity(util_matrix_sparse.T)
+ # Save the matrix as a dataframe to allow for easier indexing
+ user_sim_df = pd.DataFrame(user_similarity, index = util_matrix.columns, columns = util_matrix.columns)
+ user_similarity = cosine_similarity(np.array(df_init_users), np.array(df_init_users))
+ user_sim_df = pd.DataFrame(user_similarity, index = df_init_users['movieId'].values.astype(int), columns = df_init_users['movieId'].values.astype(int))
+ # Remove duplicate rows from matrix
+ user_sim_df = user_sim_df.loc[~user_sim_df.index.duplicated(keep='first')]
+ # Transpose matrix
+ user_sim_df = user_sim_df.T
+ # Find IDs of chosen load_movie_titles
+ idx_1 = indices[indices == movie_list[0]].index[0]
+ idx_2 = indices[indices == movie_list[1]].index[0]
+ idx_3 = indices[indices == movie_list[2]].index[0]
+ # Creating a Series with the similarity scores in descending order
+ rank_1 = user_sim_df[idx_1]
+ rank_2 = user_sim_df[idx_2]
+ rank_3 = user_sim_df[idx_3]
+ # Calculating the scores
+ score_series_1 = pd.Series(rank_1).sort_values(ascending = False)
+ score_series_2 = pd.Series(rank_2).sort_values(ascending = False)
+ score_series_3 = pd.Series(rank_3).sort_values(ascending = False)
+ # Appending the names of movies
+ listings = score_series_1.append(score_series_2).append(score_series_3).sort_values(ascending = False)
+ # Choose top 50
+ top_50_indexes = list(listings.iloc[1:50].index)
+ # Removing chosen movies
+ top_indexes = np.setdiff1d(top_50_indexes,[idx_1,idx_2,idx_3])
+ # Get titles of recommended movies
+ recommended_movies = []
+ for i in top_indexes[:top_n]:
+ recommended_movies.append(list(movies_df[movies_df['movieId']==i]['title']))
+ # Return list of movies
+ recommended_movies = [val for sublist in recommended_movies for val in sublist]
+ return recommended_movies
diff --git a/recommenders/content_based.py b/recommenders/content_based.py
index ed7df363..77292686 100644
--- a/recommenders/content_based.py
+++ b/recommenders/content_based.py
@@ -1,112 +1,122 @@
-"""
-
- Content-based filtering for item recommendation.
-
- Author: Explore Data Science Academy.
-
- Note:
- ---------------------------------------------------------------------
- Please follow the instructions provided within the README.md file
- located within the root of this repository for guidance on how to use
- this script correctly.
-
- NB: You are required to extend this baseline algorithm to enable more
- efficient and accurate computation of recommendations.
-
- !! You must not change the name and signature (arguments) of the
- prediction function, `content_model` !!
-
- You must however change its contents (i.e. add your own content-based
- filtering algorithm), as well as altering/adding any other functions
- as part of your improvement.
-
- ---------------------------------------------------------------------
-
- Description: Provided within this file is a baseline content-based
- filtering algorithm for rating predictions on Movie data.
-
-"""
-
-# Script dependencies
-import os
-import pandas as pd
-import numpy as np
-from sklearn.metrics.pairwise import cosine_similarity
-from sklearn.feature_extraction.text import CountVectorizer
-
-# Importing data
-movies = pd.read_csv('resources/data/movies.csv', sep = ',')
-ratings = pd.read_csv('resources/data/ratings.csv')
-movies.dropna(inplace=True)
-
-def data_preprocessing(subset_size):
- """Prepare data for use within Content filtering algorithm.
-
- Parameters
- ----------
- subset_size : int
- Number of movies to use within the algorithm.
-
- Returns
- -------
- Pandas Dataframe
- Subset of movies selected for content-based filtering.
-
- """
- # Split genre data into individual words.
- movies['keyWords'] = movies['genres'].str.replace('|', ' ')
- # Subset of the data
- movies_subset = movies[:subset_size]
- return movies_subset
-
-# !! DO NOT CHANGE THIS FUNCTION SIGNATURE !!
-# You are, however, encouraged to change its content.
-def content_model(movie_list,top_n=10):
- """Performs Content filtering based upon a list of movies supplied
- by the app user.
-
- Parameters
- ----------
- movie_list : list (str)
- Favorite movies chosen by the app user.
- top_n : type
- Number of top recommendations to return to the user.
-
- Returns
- -------
- list (str)
- Titles of the top-n movie recommendations to the user.
-
- """
- # Initializing the empty list of recommended movies
- recommended_movies = []
- data = data_preprocessing(27000)
- # Instantiating and generating the count matrix
- count_vec = CountVectorizer()
- count_matrix = count_vec.fit_transform(data['keyWords'])
- indices = pd.Series(data['title'])
- cosine_sim = cosine_similarity(count_matrix, count_matrix)
- # Getting the index of the movie that matches the title
- idx_1 = indices[indices == movie_list[0]].index[0]
- idx_2 = indices[indices == movie_list[1]].index[0]
- idx_3 = indices[indices == movie_list[2]].index[0]
- # Creating a Series with the similarity scores in descending order
- rank_1 = cosine_sim[idx_1]
- rank_2 = cosine_sim[idx_2]
- rank_3 = cosine_sim[idx_3]
- # Calculating the scores
- score_series_1 = pd.Series(rank_1).sort_values(ascending = False)
- score_series_2 = pd.Series(rank_2).sort_values(ascending = False)
- score_series_3 = pd.Series(rank_3).sort_values(ascending = False)
- # Getting the indexes of the 10 most similar movies
- listings = score_series_1.append(score_series_1).append(score_series_3).sort_values(ascending = False)
-
- # Store movie names
- recommended_movies = []
- # Appending the names of movies
- top_50_indexes = list(listings.iloc[1:50].index)
- # Removing chosen movies
- top_indexes = np.setdiff1d(top_50_indexes,[idx_1,idx_2,idx_3])
- for i in top_indexes[:top_n]:
- recommended_movies.append(list(movies['title'])[i])
- return recommended_movies