feat : upload project

app.py

@@ -0,0 +1,58 @@
+import streamlit as st
+import pickle
+from utils import fetch_poster, recommend, improved_recommendations
+
+st.header('Movie Recommender System Using Machine Learning')
+# Load movies_df
+with open('src/movies_df.pkl', 'rb') as f:
+    movies = pickle.load(f)
+
+# Load cosine_sim
+with open('src/cosine_sim.pkl', 'rb') as f:
+    similarity = pickle.load(f)
+
+movie_list = movies['title'].values
+selected_movie = st.selectbox(
+    "Type or select a movie from the dropdown",
+    movie_list
+)
+
+if st.button('Show Recommendation'):
+    recommended_movie_names, recommended_movie_posters = recommend(selected_movie,movies,similarity)
+    num_cols = 5
+    num_recommendations = 10
+
+    col_list = st.columns(num_cols)
+
+    for i in range(num_recommendations):
+        col_index = i % num_cols
+        with col_list[col_index]:
+            st.text(recommended_movie_names[i])
+            st.image(recommended_movie_posters[i])
+
+if st.button('Show Improved Recommendations'):
+    recommendations = improved_recommendations(selected_movie,movies,similarity)
+    
+    if recommendations is not None:
+        recommended_movie_ids = recommendations['id'].tolist()
+        recommended_movie_names = recommendations['title'].tolist()
+        recommended_movie_posters = []
+        
+        for movie_id in recommended_movie_ids:
+            recommended_movie_posters.append(fetch_poster(movie_id))
+
+        num_recommendations = len(recommended_movie_ids)
+        num_cols = 5
+        
+        # Calculate the number of rows needed
+        num_rows = (num_recommendations + num_cols - 1) // num_cols
+
+        for row in range(num_rows):
+            col_list = st.columns(num_cols)
+            start_index = row * num_cols
+            end_index = min((row + 1) * num_cols, num_recommendations)
+            
+            for i in range(start_index, end_index):
+                with col_list[i - start_index]:
+                    st.text(recommended_movie_names[i])
+                    st.image(recommended_movie_posters[i])

requirements.txt

@@ -0,0 +1,8 @@
+streamlit
+requests
+python-dotenv
+pandas
+numpy
+matplotlib
+difflib
+pickle

src/.gitignore

@@ -0,0 +1,2 @@
+cosine_sim.pkl
+movies_df.pkl

utils.py

@@ -0,0 +1,77 @@
+import os
+import pickle
+import requests
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Access the TMDB API key from the environment variables
+TMDB_API_KEY = os.getenv("TMDB_API_KEY")
+
+def fetch_poster(movie_id):
+    url = f"https://api.themoviedb.org/3/movie/{movie_id}?api_key={TMDB_API_KEY}&language=en-US"
+    try:
+        response = requests.get(url)
+        response.raise_for_status() # Raises an HTTPError if the response was unsuccessful
+        data = response.json()
+        poster_path = data.get('poster_path') # Use .get() to avoid KeyError if 'poster_path' is missing
+        if poster_path:
+            full_path = f"https://image.tmdb.org/t/p/w500/{poster_path}"
+            return full_path
+        else:
+            st.warning(f"No poster found for movie ID: {movie_id}")
+            return None
+    except requests.exceptions.HTTPError as errh:
+        st.error(f"HTTP Error: {errh}")
+    except requests.exceptions.ConnectionError as errc:
+        st.error(f"Error Connecting: {errc}")
+    except requests.exceptions.Timeout as errt:
+        st.error(f"Timeout Error: {errt}")
+    except requests.exceptions.RequestException as err:
+        st.error(f"Something went wrong: {err}")
+    return None
+
+def recommend(movie,movies,similarity):
+    index = movies[movies['title'] == movie].index[0]
+    distances = sorted(list(enumerate(similarity[index])), reverse=True, key=lambda x: x[1])
+    recommended_movie_names = []
+    recommended_movie_posters = []
+    for i in distances[1:11]:  # Modify the loop to iterate over 10 distances
+        # fetch the movie poster
+        movie_id = movies.iloc[i[0]].id
+        recommended_movie_posters.append(fetch_poster(movie_id))
+        recommended_movie_names.append(movies.iloc[i[0]].title)
+
+    return recommended_movie_names, recommended_movie_posters
+
+def improved_recommendations(title,movies,similarity):
+    index = movies[movies['title'] == title].index
+    if len(index) == 0:
+        st.warning(f"No movie found with the title '{title}'.")
+        return None
+    
+    idx = index[0]
+    sim_scores = list(enumerate(similarity[idx]))
+    sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)
+    sim_scores = sim_scores[1:26]
+    movie_indices = [i[0] for i in sim_scores]
+
+    movies_qualified = movies.iloc[movie_indices][['id','title', 'vote_count', 'vote_average', 'year']]
+    vote_counts = movies_qualified[movies_qualified['vote_count'].notnull()]['vote_count'].astype('int')
+    vote_averages = movies_qualified[movies_qualified['vote_average'].notnull()]['vote_average'].astype('int')
+    C = vote_averages.mean()
+    m = vote_counts.quantile(0.60)
+
+    def weighted_rating(x, C=C, m=m):
+        v = x['vote_count']
+        R = x['vote_average']
+        return (v / (v + m) * R) + (m / (m + v) * C)
+
+    qualified_movies = movies_qualified[(movies_qualified['vote_count'] >= m) & (movies_qualified['vote_count'].notnull()) & (movies_qualified['vote_average'].notnull())]
+    qualified_movies['vote_count'] = qualified_movies['vote_count'].astype('int')
+    qualified_movies['vote_average'] = qualified_movies['vote_average'].astype('int')
+    qualified_movies['wr'] = qualified_movies.apply(lambda x: weighted_rating(x), axis=1)
+    qualified_movies = qualified_movies.sort_values('wr', ascending=False).head(10)
+
+    return qualified_movies