Model backend

.github/workflows/test.yml

@@ -0,0 +1,32 @@
+name: test
+on:
+  push:
+   branches:
+    - master
+  pull_request:
+    branches: 
+      - master
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.10"]
+        os: [ubuntu-latest, macOS-latest, windows-latest]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Installing and Running tests
+        run: |
+          pip install -r requirements.txt
+          black .
+          cd test
+          coverage run -m test_prediction
+          coverage run -m -a test_search
+          coverage run -m -a test_sentiment
+          coverage json
+        env: 
+          CI: true

.gitignore

@@ -132,5 +132,6 @@ dmypy.json
 .DS_Store
 .vscode
 
-
-
+experiment_results
+index.html
+loadingHandler.css

Code/prediction_scripts/item_based.py

@@ -1,40 +1,79 @@
 import pandas as pd
 import warnings
 import os
+from sklearn.metrics.pairwise import cosine_similarity
 
 app_dir = os.path.dirname(os.path.abspath(__file__))
 code_dir = os.path.dirname(app_dir)
 project_dir = os.path.dirname(code_dir)
 
 warnings.filterwarnings("ignore")
 
+from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
 
-def recommendForNewUser(user_rating):
+
+def getSentimentScores(sentence):
+    sid_obj = SentimentIntensityAnalyzer()
+
+    sentiment_dict = sid_obj.polarity_scores(sentence)
+
+    if sentiment_dict["compound"] >= 0.05:
+        return "Supportive"
+
+    elif sentiment_dict["compound"] <= -0.05:
+        return "Critical"
+
+    else:
+        return "Neutral"
+
+
+def recommendForNewUser(user_rating, num_recommendations=10):
     ratings = pd.read_csv(project_dir + "/data/ratings.csv")
     movies = pd.read_csv(project_dir + "/data/movies.csv")
-    user = pd.DataFrame(user_rating)
-    userMovieID = movies[movies["title"].isin(user["title"])]
-    userRatings = pd.merge(userMovieID, user)
-
-    moviesGenreFilled = movies.copy(deep=True)
-    copyOfMovies = movies.copy(deep=True)
-    for index, row in copyOfMovies.iterrows():
-        copyOfMovies.at[index, "genres"] = row["genres"].split("|")
-    for index, row in copyOfMovies.iterrows():
-        for genre in row["genres"]:
-            moviesGenreFilled.at[index, genre] = 1
-    moviesGenreFilled = moviesGenreFilled.fillna(0)
-
-    userGenre = moviesGenreFilled[moviesGenreFilled.movieId.isin(userRatings.movieId)]
-    userGenre.drop(["movieId", "title", "genres"], axis=1, inplace=True)
-    userProfile = userGenre.T.dot(userRatings.rating.to_numpy())
-    moviesGenreFilled.set_index(moviesGenreFilled.movieId)
-    moviesGenreFilled.drop(["movieId", "title", "genres"], axis=1, inplace=True)
-
-    recommendations = (moviesGenreFilled.dot(userProfile)) / userProfile.sum()
-    joinMoviesAndRecommendations = movies.copy(deep=True)
-    joinMoviesAndRecommendations["recommended"] = recommendations
-    joinMoviesAndRecommendations.sort_values(
-        by="recommended", ascending=False, inplace=True
+
+    average_ratings = ratings.groupby("movieId")["rating"].mean().reset_index()
+    movies = movies.merge(average_ratings, on="movieId", how="left")
+    movies.rename(columns={"rating": "average_rating"}, inplace=True)
+
+    user_movie_titles = [movie["title"] for movie in user_rating]
+    userMovieID = movies[movies["title"].isin(user_movie_titles)]
+    userRatings = pd.merge(userMovieID, pd.DataFrame(user_rating))
+
+    genre_columns = movies["genres"].str.get_dummies("|")
+
+    moviesGenreFilled = pd.concat([movies, genre_columns], axis=1)
+
+    moviesGenreFilled.drop(["genres"], axis=1, inplace=True)
+
+    cosine_sim = cosine_similarity(genre_columns, genre_columns)
+
+    similarity_df = pd.DataFrame(
+        cosine_sim, index=movies["movieId"], columns=movies["movieId"]
     )
-    return [x for x in joinMoviesAndRecommendations["title"]][:201]
+
+    similar_movies = {}
+    for movie_id in userRatings["movieId"]:
+        similar_scores = (
+            similarity_df.loc[movie_id]
+            .sort_values(ascending=False)[1 : num_recommendations + 1]
+            .index.tolist()
+        )
+        similar_movies[movie_id] = similar_scores
+
+    recommendations = []
+    for similar_movie_ids in similar_movies.values():
+        recommended_movies = []
+        for sim_movie_id in similar_movie_ids:
+            sim_movie_title = movies[movies["movieId"] == sim_movie_id]["title"].values[
+                0
+            ]
+            recommended_movies.append(
+                {"title": sim_movie_title, "rating": 5.0}
+            )  # Replace 5.0 with the actual rating
+        recommendations.extend(recommended_movies)
+
+    # Sort recommendations by some criteria, e.g., rating
+    recommendations.sort(key=lambda x: x["rating"], reverse=True)
+
+    # Return a list of recommended movies (titles and ratings)
+    return recommendations[:num_recommendations]

Code/recommenderapp/app.py

@@ -2,12 +2,16 @@
 from flask_cors import CORS, cross_origin
 import json
 import sys
-import csv
 import time
 
+import os
+import pandas as pd
+
+
 sys.path.append("../../")
-from Code.prediction_scripts.item_based import recommendForNewUser
+from Code.prediction_scripts.item_based import getSentimentScores, recommendForNewUser
 from search import Search
+from comments import Comments
 
 app = Flask(__name__)
 app.secret_key = "secret key"
@@ -17,20 +21,27 @@
 
 @app.route("/")
 def landing_page():
+    return render_template("loading.html")
+
+
+@app.route("/home")
+def redirected():
     return render_template("landing_page.html")
 
 
 @app.route("/predict", methods=["POST"])
 def predict():
     data = json.loads(request.data)  # contains movies
     data1 = data["movie_list"]
+    data1 = [s[:-1] for s in data1]
     training_data = []
     for movie in data1:
         movie_with_rating = {"title": movie, "rating": 5.0}
         training_data.append(movie_with_rating)
     recommendations = recommendForNewUser(training_data)
-    recommendations = recommendations[:10]
+    recommendations = recommendations[:5]
     resp = {"recommendations": recommendations}
+    print(recommendations)  # Add this line for debugging
     return resp
 
 
@@ -50,16 +61,39 @@ def search():
 @app.route("/feedback", methods=["POST"])
 def feedback():
     data = json.loads(request.data)
-    with open("experiment_results/feedback_{}.csv".format(int(time.time())), "w") as f:
-        for key in data.keys():
-            f.write("%s - %s\n" % (key, data[key]))
-    print(data)
+
+    comments = Comments()
+    comments.setComments(data)
+
+    app_dir = os.path.dirname(os.path.abspath(__file__))
+    code_dir = os.path.dirname(app_dir)
+    project_dir = os.path.dirname(code_dir)
+    movies = pd.read_csv(project_dir + "/data/movies.csv")
+    with open(project_dir + "/data/ratings.csv", "a") as f:
+        for key, value in data.items():
+            if type(data[key]) is list:
+                # Find the movieId corresponding to the movie title
+                movieId = movies.loc[movies["title"] == key, "movieId"].values[0]
+                rating = int(data[key][0])
+                userId = ""
+                timestamp = int(time.time())
+                if rating != 0:
+                    f.write("{},{},{},{}\n".format(userId, movieId, rating, timestamp))
+
     return data
 
 
+@app.route("/comments/<movie>")
+def comments(movie):
+    comments = Comments()
+    movie_entries = comments.getComments(movie)
+    return render_template("view_comments.html", movie_entries=movie_entries)
+
+
 @app.route("/success")
 def success():
     return render_template("success.html")
 
+
 if __name__ == "__main__":
     app.run(port=5000, debug=True)

Code/recommenderapp/comments.py

@@ -0,0 +1,46 @@
+import pandas as pd
+
+import os
+import csv
+import datetime
+
+from Code.prediction_scripts.item_based import getSentimentScores
+
+app_dir = os.path.dirname(os.path.abspath(__file__))
+code_dir = os.path.dirname(app_dir)
+project_dir = os.path.dirname(code_dir)
+file_path = project_dir + "/data/comments.csv"
+
+
+class Comments:
+    def __init__(self):
+        pass
+
+    def getComments(self, movie):
+        df = pd.read_csv(file_path)
+        movie_entries = df[df["movieName"] == movie]
+        return movie_entries
+
+    def setComments(self, data):
+        # Putting data into comments.csv
+        all_rows = []
+        username, emailId = data["username"], data["emailId"]
+        for key, value in data.items():
+            if type(value) is list:
+                if (
+                    type(value[1]) is str and len(value[1]) > 0
+                ):  # Save only those fields that are populated
+                    all_rows.append(
+                        [
+                            username,
+                            emailId,
+                            key,
+                            value[1],
+                            getSentimentScores(value[1]),
+                            datetime.datetime.now(),
+                        ]
+                    )
+        with open(file_path, mode="a", newline="") as file:
+            writer = csv.writer(file)
+            for row in all_rows:
+                writer.writerow(row)

Code/recommenderapp/search.py

@@ -1,8 +1,5 @@
 import pandas as pd
 
-# from app import app
-from flask import jsonify, request, render_template
-import sys
 import os
 
 app_dir = os.path.dirname(os.path.abspath(__file__))
@@ -11,7 +8,6 @@
 
 
 class Search:
-
     df = pd.read_csv(project_dir + "/data/movies.csv")
 
     def __init__(self):
@@ -48,7 +44,3 @@ def results(self, word):
 
     def resultsTop10(self, word):
         return self.results(word)[:10]
-
-
-if __name__ == "__main__":
-    app.run()

Code/recommenderapp/static/css/comments.css

@@ -0,0 +1,26 @@
+body {
+  margin:100px;
+  background: #abbaab;  /* fallback for old browsers */
+  background: -webkit-linear-gradient(to right, #ffffff, #abbaab);  /* Chrome 10-25, Safari 5.1-6 */
+  background: linear-gradient(to right, #ffffff, #abbaab); /* W3C, IE 10+/ Edge, Firefox 16+, Chrome 26+, Opera 12+, Safari 7+ */
+}
+
+.card-container {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.card {
+  box-shadow: 0 4px 8px 0 rgba(0, 0, 0, 0.2);
+  transition: 0.3s;
+  width: 40%;
+}
+
+.card:hover {
+  box-shadow: 0 8px 16px 0 rgba(0, 0, 0, 0.2);
+}
+
+.container {
+  padding: 2px 16px;
+}