Recommender System

1import pandas as pd
2from sklearn.feature_extraction.text import TfidfVectorizer
3from sklearn.metrics.pairwise import linear_kernel 
4import json
5import csv
6
7with open('data/big_data.json') as json_file:
8    data = json.load(json_file)
9
10ds = pd.DataFrame(data)
11
12tf = TfidfVectorizer(analyzer='word', ngram_range=(1, 3), min_df=0, stop_words='english')
13tfidf_matrix = tf.fit_transform(ds['content'])
14cosine_similarities = linear_kernel(tfidf_matrix, tfidf_matrix)
15
16results = {}
17
18for idx, row in ds.iterrows():
19    similar_indices = cosine_similarities[idx].argsort()[:-100:-1]
20    similar_items = [(cosine_similarities[idx][i], ds['id'][i]) for i in similar_indices]
21
22    results[row['id']] = similar_items[1:]
23
24def item(id):
25    return ds.loc[ds['id'] == id]['id'].tolist()[0]
26
27def recommend(item_id, num):
28    print("Recommending " + str(num) + " products similar to " + item(item_id) + "...")
29    print("-------")
30    recs = results[item_id][:num]
31    for rec in recs:
32        print("Recommended: " + item(rec[1]) + " (score:" + str(rec[0]) + ")")
33
34recommend(item_id='129035', num=5)
35

1ratings = df_matrix.values
2sparsity = float(len(ratings.nonzero()[0]))
3sparsity /= (ratings.shape[0] * ratings.shape[1])
4sparsity *= 100
5print('Sparsity: {:4.2f}%'.format(sparsity))
6

1from rest_framework import viewsets, status
2from .models import Movie, Rating, Customer, Recommendation
3from .serializers import MovieSerializer, RatingSerializer, UserSerializer, GroupSerializer, CustomerSerializer, RecommendationSerializer
4from rest_framework.response import Response
5from rest_framework.decorators import action
6from django.contrib.auth.models import User, Group
7from rest_framework.authentication import TokenAuthentication
8from rest_framework.permissions import IsAuthenticated, AllowAny
9from pandas import Series
10from lenskit.algorithms import Recommender
11from lenskit.algorithms.user_knn import UserUser
12import lenskit.datasets as ds
13
14
15class CustomerViewSet(viewsets.ModelViewSet):
16    queryset = Customer.objects.all()
17    serializer_class = CustomerSerializer
18    authentication_classes = (TokenAuthentication,)
19    permission_classes = (IsAuthenticated,)
20
21@action(methods=['GET'], detail=False)
22    def recommendations(self, request):
23        if 'genre' in request.data:
24            genre = request.data['genre']
25        else:
26            genre = 'All'
27
28        user = request.user
29        ratings = Rating.objects.filter(user=user.id)
30        user_dict = {} #dictionary of user ratings
31
32        name = user.username
33        #print('name', name)
34
35        #Deleting the recommendations resulted from previous requests before generating new ones
36        Recommendation.objects.filter(name=name).delete()
37
38        for rating in ratings:
39            stars = rating.stars
40            movieId = int(rating.movie.movieId)
41            user_dict[movieId] = stars
42        #print(user_dict)
43
44        data = ds.MovieLens('datasets/')
45        user_user = UserUser(15, min_nbrs=3)
46        algo = Recommender.adapt(user_user)
47        algo.fit(data.ratings)
48        #print(algo)
49        #print(data.ratings)
50
51        """
52        Recommendations are generated based on a user that is not included in a training set (hence, their id is -1),
53        and a pandas.Series obtained from the ratings dictionary.
54        """
55        recs = algo.recommend(user=-1, ratings=Series(user_dict))
56        #print(recs)
57
58        #Parsing the resulting DataFrame and saving recommendations as objects
59        for index, row in recs.iterrows():
60            #print(row['item'])
61            movieId = row['item']
62            stars = row['score']
63
64            if genre == 'All':
65                Recommendation.objects.create(name=name, movieId=movieId, pred_stars=stars)
66            if genre != 'All' and genre in movie.genres:
67                Recommendation.objects.create(name=name, movieId=movieId, pred_stars=stars)
68
69            #Stopping at 20 recommended items
70            count = Recommendation.objects.filter(name=name).count()
71            #print('count', count)
72            if count >= 20:
73                break
74
75        #Returning the movies ordered by the predicted ratings for them
76        recs = Recommendation.objects.filter(name=name).order_by('-pred_stars')
77        rec_movies = []
78        for rec in recs:
79            mov = Movie.objects.get(movieId=rec.movieId)
80            rec_movies.append(mov)
81
82        serializer = MovieSerializer(rec_movies, many=True)
83        return Response(serializer.data, status=status.HTTP_200_OK)
84
85
86class GroupViewSet(viewsets.ModelViewSet):
87    queryset = Group.objects.all()
88    serializer_class = GroupSerializer
89    authentication_classes = (TokenAuthentication,)
90    permission_classes = (IsAuthenticated, )
91
92    @action(methods=['GET'], detail=True)
93    def recommendations(self, request, pk=None):
94        if 'genre' in request.data:
95            genre = request.data['genre']
96        else:
97            genre = 'All'
98
99        #Checking if the user belongs to the group
100        group = Group.objects.get(id=pk)
101        users = group.user_set.all()
102        #print(users)
103        user = request.user
104        #print(user)
105
106        if user in users:
107            # Deleting the recommendations resulted from previous requests before generating new ones
108            Recommendation.objects.filter(name=group.name).delete()
109
110            rating_dict = {} #a dictionary of average ratings for the group
111            for user in users:
112                ratings = Rating.objects.filter(user=user.id)
113                for rating in ratings:
114                    stars = rating.stars
115                    movieId = int(rating.movie.movieId)
116
117                    """
118                    If the movie has already been rated by another member (i.e. a rating for it exists in the 
119                    dictionary), an average rating is computed
120                    """
121                    if movieId in rating_dict:
122                        x = rating_dict[movieId][0]
123                        y = rating_dict[movieId][1]
124                        x = (x * y + stars) / (y+1)
125                        y += 1
126                        rating_dict[movieId][0] = x
127                        rating_dict[movieId][1] = y
128                    #If not, the individual rating is simply insteted into the dictionary
129                    else:
130                        rating_dict[movieId] = [stars, 1]
131
132            #Training the ML algorithm
133            data = ds.MovieLens('datasets/')
134            user_user = UserUser(15, min_nbrs=3)
135            algo = Recommender.adapt(user_user)
136            algo.fit(data.ratings)
137
138            for key in rating_dict.keys():
139                x = rating_dict[key][0]
140                rating_dict[key] = x
141            #print(rating_dict)
142
143            #Requesting recommendations for the hybrid user
144            recs = algo.recommend(user=-1, ratings=Series(rating_dict))
145            #print(recs)
146
147            genre = request.data['genre']
148            name = group.name
149
150            #Parsing the resulting DataFrame and saving the recommendations as objects
151            for index, row in recs.iterrows():
152                print(row['item'])
153                movie = Movie.objects.get(movieId=str(int(row['item'])))
154                stars = row['score']
155                name = group.name
156                if genre == 'All':
157                    Recommendation.objects.create(name=name, movieId=movie.movieId, pred_stars=stars)
158                if genre != 'All' and genre in movie.genres:
159                    Recommendation.objects.create(name=name, movieId=movie.movieId, pred_stars=stars)
160
161                #Stopping at 20 recommendations
162                count = Recommendation.objects.filter(name=name).count()
163                print('count', count)
164                if count >= 20:
165                    break
166
167            #Returning movies ordered by the predicted score for the group
168            recs = Recommendation.objects.filter(name=name).order_by('-pred_stars')
169            rec_movies = []
170            for rec in recs:
171                mov = Movie.objects.get(movieId=rec.movieId)
172                rec_movies.append(mov)
173            serializer = MovieSerializer(rec_movies, many=True)
174
175            return Response(serializer.data, status=status.HTTP_200_OK)
176
177        else:
178            response = {'message': 'You are not a member of this group'}
179            return Response(response, status=status.HTTP_400_BAD_REQUEST)
180

1from rest_framework import viewsets, status
2from .models import Movie, Rating, Customer, Recommendation
3from .serializers import MovieSerializer, RatingSerializer, UserSerializer, GroupSerializer, CustomerSerializer, RecommendationSerializer
4from rest_framework.response import Response
5from rest_framework.decorators import action
6from django.contrib.auth.models import User, Group
7from rest_framework.authentication import TokenAuthentication
8from rest_framework.permissions import IsAuthenticated, AllowAny
9from pandas import Series
10from lenskit.algorithms import Recommender
11from lenskit.algorithms.user_knn import UserUser
12import lenskit.datasets as ds
13
14
15class CustomerViewSet(viewsets.ModelViewSet):
16    queryset = Customer.objects.all()
17    serializer_class = CustomerSerializer
18    authentication_classes = (TokenAuthentication,)
19    permission_classes = (IsAuthenticated,)
20
21@action(methods=['GET'], detail=False)
22    def recommendations(self, request):
23        if 'genre' in request.data:
24            genre = request.data['genre']
25        else:
26            genre = 'All'
27
28        user = request.user
29        ratings = Rating.objects.filter(user=user.id)
30        user_dict = {} #dictionary of user ratings
31
32        name = user.username
33        #print('name', name)
34
35        #Deleting the recommendations resulted from previous requests before generating new ones
36        Recommendation.objects.filter(name=name).delete()
37
38        for rating in ratings:
39            stars = rating.stars
40            movieId = int(rating.movie.movieId)
41            user_dict[movieId] = stars
42        #print(user_dict)
43
44        data = ds.MovieLens('datasets/')
45        user_user = UserUser(15, min_nbrs=3)
46        algo = Recommender.adapt(user_user)
47        algo.fit(data.ratings)
48        #print(algo)
49        #print(data.ratings)
50
51        """
52        Recommendations are generated based on a user that is not included in a training set (hence, their id is -1),
53        and a pandas.Series obtained from the ratings dictionary.
54        """
55        recs = algo.recommend(user=-1, ratings=Series(user_dict))
56        #print(recs)
57
58        #Parsing the resulting DataFrame and saving recommendations as objects
59        for index, row in recs.iterrows():
60            #print(row['item'])
61            movieId = row['item']
62            stars = row['score']
63
64            if genre == 'All':
65                Recommendation.objects.create(name=name, movieId=movieId, pred_stars=stars)
66            if genre != 'All' and genre in movie.genres:
67                Recommendation.objects.create(name=name, movieId=movieId, pred_stars=stars)
68
69            #Stopping at 20 recommended items
70            count = Recommendation.objects.filter(name=name).count()
71            #print('count', count)
72            if count >= 20:
73                break
74
75        #Returning the movies ordered by the predicted ratings for them
76        recs = Recommendation.objects.filter(name=name).order_by('-pred_stars')
77        rec_movies = []
78        for rec in recs:
79            mov = Movie.objects.get(movieId=rec.movieId)
80            rec_movies.append(mov)
81
82        serializer = MovieSerializer(rec_movies, many=True)
83        return Response(serializer.data, status=status.HTTP_200_OK)
84
85
86class GroupViewSet(viewsets.ModelViewSet):
87    queryset = Group.objects.all()
88    serializer_class = GroupSerializer
89    authentication_classes = (TokenAuthentication,)
90    permission_classes = (IsAuthenticated, )
91
92    @action(methods=['GET'], detail=True)
93    def recommendations(self, request, pk=None):
94        if 'genre' in request.data:
95            genre = request.data['genre']
96        else:
97            genre = 'All'
98
99        #Checking if the user belongs to the group
100        group = Group.objects.get(id=pk)
101        users = group.user_set.all()
102        #print(users)
103        user = request.user
104        #print(user)
105
106        if user in users:
107            # Deleting the recommendations resulted from previous requests before generating new ones
108            Recommendation.objects.filter(name=group.name).delete()
109
110            rating_dict = {} #a dictionary of average ratings for the group
111            for user in users:
112                ratings = Rating.objects.filter(user=user.id)
113                for rating in ratings:
114                    stars = rating.stars
115                    movieId = int(rating.movie.movieId)
116
117                    """
118                    If the movie has already been rated by another member (i.e. a rating for it exists in the 
119                    dictionary), an average rating is computed
120                    """
121                    if movieId in rating_dict:
122                        x = rating_dict[movieId][0]
123                        y = rating_dict[movieId][1]
124                        x = (x * y + stars) / (y+1)
125                        y += 1
126                        rating_dict[movieId][0] = x
127                        rating_dict[movieId][1] = y
128                    #If not, the individual rating is simply insteted into the dictionary
129                    else:
130                        rating_dict[movieId] = [stars, 1]
131
132            #Training the ML algorithm
133            data = ds.MovieLens('datasets/')
134            user_user = UserUser(15, min_nbrs=3)
135            algo = Recommender.adapt(user_user)
136            algo.fit(data.ratings)
137
138            for key in rating_dict.keys():
139                x = rating_dict[key][0]
140                rating_dict[key] = x
141            #print(rating_dict)
142
143            #Requesting recommendations for the hybrid user
144            recs = algo.recommend(user=-1, ratings=Series(rating_dict))
145            #print(recs)
146
147            genre = request.data['genre']
148            name = group.name
149
150            #Parsing the resulting DataFrame and saving the recommendations as objects
151            for index, row in recs.iterrows():
152                print(row['item'])
153                movie = Movie.objects.get(movieId=str(int(row['item'])))
154                stars = row['score']
155                name = group.name
156                if genre == 'All':
157                    Recommendation.objects.create(name=name, movieId=movie.movieId, pred_stars=stars)
158                if genre != 'All' and genre in movie.genres:
159                    Recommendation.objects.create(name=name, movieId=movie.movieId, pred_stars=stars)
160
161                #Stopping at 20 recommendations
162                count = Recommendation.objects.filter(name=name).count()
163                print('count', count)
164                if count >= 20:
165                    break
166
167            #Returning movies ordered by the predicted score for the group
168            recs = Recommendation.objects.filter(name=name).order_by('-pred_stars')
169            rec_movies = []
170            for rec in recs:
171                mov = Movie.objects.get(movieId=rec.movieId)
172                rec_movies.append(mov)
173            serializer = MovieSerializer(rec_movies, many=True)
174
175            return Response(serializer.data, status=status.HTTP_200_OK)
176
177        else:
178            response = {'message': 'You are not a member of this group'}
179            return Response(response, status=status.HTTP_400_BAD_REQUEST)
180[
181    {
182        "id": 17521,
183        "movieId": "318",
184        "title": "Shawshank Redemption, The (1994)",
185        "genres": "Crime|Drama",
186        "link": "https://www.imdb.com/title/tt0111161/",
187        "average_rating": 4.487138263665595,
188        "no_ratings": 311,
189        "poster": "/default-movie.jpg"
190    },
191    {
192        "id": 17503,
193        "movieId": "296",
194        "title": "Pulp Fiction (1994)",
195        "genres": "Comedy|Crime|Drama|Thriller",
196        "link": "https://www.imdb.com/title/tt0110912/",
197        "average_rating": 4.256172839506172,
198        "no_ratings": 324,
199        "poster": "/default-movie.jpg"
200    },
201    ...
202]
203

1from rest_framework import viewsets, status
2from .models import Movie, Rating, Customer, Recommendation
3from .serializers import MovieSerializer, RatingSerializer, UserSerializer, GroupSerializer, CustomerSerializer, RecommendationSerializer
4from rest_framework.response import Response
5from rest_framework.decorators import action
6from django.contrib.auth.models import User, Group
7from rest_framework.authentication import TokenAuthentication
8from rest_framework.permissions import IsAuthenticated, AllowAny
9from pandas import Series
10from lenskit.algorithms import Recommender
11from lenskit.algorithms.user_knn import UserUser
12import lenskit.datasets as ds
13
14
15class CustomerViewSet(viewsets.ModelViewSet):
16    queryset = Customer.objects.all()
17    serializer_class = CustomerSerializer
18    authentication_classes = (TokenAuthentication,)
19    permission_classes = (IsAuthenticated,)
20
21@action(methods=['GET'], detail=False)
22    def recommendations(self, request):
23        if 'genre' in request.data:
24            genre = request.data['genre']
25        else:
26            genre = 'All'
27
28        user = request.user
29        ratings = Rating.objects.filter(user=user.id)
30        user_dict = {} #dictionary of user ratings
31
32        name = user.username
33        #print('name', name)
34
35        #Deleting the recommendations resulted from previous requests before generating new ones
36        Recommendation.objects.filter(name=name).delete()
37
38        for rating in ratings:
39            stars = rating.stars
40            movieId = int(rating.movie.movieId)
41            user_dict[movieId] = stars
42        #print(user_dict)
43
44        data = ds.MovieLens('datasets/')
45        user_user = UserUser(15, min_nbrs=3)
46        algo = Recommender.adapt(user_user)
47        algo.fit(data.ratings)
48        #print(algo)
49        #print(data.ratings)
50
51        """
52        Recommendations are generated based on a user that is not included in a training set (hence, their id is -1),
53        and a pandas.Series obtained from the ratings dictionary.
54        """
55        recs = algo.recommend(user=-1, ratings=Series(user_dict))
56        #print(recs)
57
58        #Parsing the resulting DataFrame and saving recommendations as objects
59        for index, row in recs.iterrows():
60            #print(row['item'])
61            movieId = row['item']
62            stars = row['score']
63
64            if genre == 'All':
65                Recommendation.objects.create(name=name, movieId=movieId, pred_stars=stars)
66            if genre != 'All' and genre in movie.genres:
67                Recommendation.objects.create(name=name, movieId=movieId, pred_stars=stars)
68
69            #Stopping at 20 recommended items
70            count = Recommendation.objects.filter(name=name).count()
71            #print('count', count)
72            if count >= 20:
73                break
74
75        #Returning the movies ordered by the predicted ratings for them
76        recs = Recommendation.objects.filter(name=name).order_by('-pred_stars')
77        rec_movies = []
78        for rec in recs:
79            mov = Movie.objects.get(movieId=rec.movieId)
80            rec_movies.append(mov)
81
82        serializer = MovieSerializer(rec_movies, many=True)
83        return Response(serializer.data, status=status.HTTP_200_OK)
84
85
86class GroupViewSet(viewsets.ModelViewSet):
87    queryset = Group.objects.all()
88    serializer_class = GroupSerializer
89    authentication_classes = (TokenAuthentication,)
90    permission_classes = (IsAuthenticated, )
91
92    @action(methods=['GET'], detail=True)
93    def recommendations(self, request, pk=None):
94        if 'genre' in request.data:
95            genre = request.data['genre']
96        else:
97            genre = 'All'
98
99        #Checking if the user belongs to the group
100        group = Group.objects.get(id=pk)
101        users = group.user_set.all()
102        #print(users)
103        user = request.user
104        #print(user)
105
106        if user in users:
107            # Deleting the recommendations resulted from previous requests before generating new ones
108            Recommendation.objects.filter(name=group.name).delete()
109
110            rating_dict = {} #a dictionary of average ratings for the group
111            for user in users:
112                ratings = Rating.objects.filter(user=user.id)
113                for rating in ratings:
114                    stars = rating.stars
115                    movieId = int(rating.movie.movieId)
116
117                    """
118                    If the movie has already been rated by another member (i.e. a rating for it exists in the 
119                    dictionary), an average rating is computed
120                    """
121                    if movieId in rating_dict:
122                        x = rating_dict[movieId][0]
123                        y = rating_dict[movieId][1]
124                        x = (x * y + stars) / (y+1)
125                        y += 1
126                        rating_dict[movieId][0] = x
127                        rating_dict[movieId][1] = y
128                    #If not, the individual rating is simply insteted into the dictionary
129                    else:
130                        rating_dict[movieId] = [stars, 1]
131
132            #Training the ML algorithm
133            data = ds.MovieLens('datasets/')
134            user_user = UserUser(15, min_nbrs=3)
135            algo = Recommender.adapt(user_user)
136            algo.fit(data.ratings)
137
138            for key in rating_dict.keys():
139                x = rating_dict[key][0]
140                rating_dict[key] = x
141            #print(rating_dict)
142
143            #Requesting recommendations for the hybrid user
144            recs = algo.recommend(user=-1, ratings=Series(rating_dict))
145            #print(recs)
146
147            genre = request.data['genre']
148            name = group.name
149
150            #Parsing the resulting DataFrame and saving the recommendations as objects
151            for index, row in recs.iterrows():
152                print(row['item'])
153                movie = Movie.objects.get(movieId=str(int(row['item'])))
154                stars = row['score']
155                name = group.name
156                if genre == 'All':
157                    Recommendation.objects.create(name=name, movieId=movie.movieId, pred_stars=stars)
158                if genre != 'All' and genre in movie.genres:
159                    Recommendation.objects.create(name=name, movieId=movie.movieId, pred_stars=stars)
160
161                #Stopping at 20 recommendations
162                count = Recommendation.objects.filter(name=name).count()
163                print('count', count)
164                if count >= 20:
165                    break
166
167            #Returning movies ordered by the predicted score for the group
168            recs = Recommendation.objects.filter(name=name).order_by('-pred_stars')
169            rec_movies = []
170            for rec in recs:
171                mov = Movie.objects.get(movieId=rec.movieId)
172                rec_movies.append(mov)
173            serializer = MovieSerializer(rec_movies, many=True)
174
175            return Response(serializer.data, status=status.HTTP_200_OK)
176
177        else:
178            response = {'message': 'You are not a member of this group'}
179            return Response(response, status=status.HTTP_400_BAD_REQUEST)
180[
181    {
182        "id": 17521,
183        "movieId": "318",
184        "title": "Shawshank Redemption, The (1994)",
185        "genres": "Crime|Drama",
186        "link": "https://www.imdb.com/title/tt0111161/",
187        "average_rating": 4.487138263665595,
188        "no_ratings": 311,
189        "poster": "/default-movie.jpg"
190    },
191    {
192        "id": 17503,
193        "movieId": "296",
194        "title": "Pulp Fiction (1994)",
195        "genres": "Comedy|Crime|Drama|Thriller",
196        "link": "https://www.imdb.com/title/tt0110912/",
197        "average_rating": 4.256172839506172,
198        "no_ratings": 324,
199        "poster": "/default-movie.jpg"
200    },
201    ...
202]
203[]
204

1from rest_framework import viewsets, status
2from .models import Movie, Rating, Customer, Recommendation
3from .serializers import MovieSerializer, RatingSerializer, UserSerializer, GroupSerializer, CustomerSerializer, RecommendationSerializer
4from rest_framework.response import Response
5from rest_framework.decorators import action
6from django.contrib.auth.models import User, Group
7from rest_framework.authentication import TokenAuthentication
8from rest_framework.permissions import IsAuthenticated, AllowAny
9from pandas import Series
10from lenskit.algorithms import Recommender
11from lenskit.algorithms.user_knn import UserUser
12import lenskit.datasets as ds
13
14
15class CustomerViewSet(viewsets.ModelViewSet):
16    queryset = Customer.objects.all()
17    serializer_class = CustomerSerializer
18    authentication_classes = (TokenAuthentication,)
19    permission_classes = (IsAuthenticated,)
20
21@action(methods=['GET'], detail=False)
22    def recommendations(self, request):
23        if 'genre' in request.data:
24            genre = request.data['genre']
25        else:
26            genre = 'All'
27
28        user = request.user
29        ratings = Rating.objects.filter(user=user.id)
30        user_dict = {} #dictionary of user ratings
31
32        name = user.username
33        #print('name', name)
34
35        #Deleting the recommendations resulted from previous requests before generating new ones
36        Recommendation.objects.filter(name=name).delete()
37
38        for rating in ratings:
39            stars = rating.stars
40            movieId = int(rating.movie.movieId)
41            user_dict[movieId] = stars
42        #print(user_dict)
43
44        data = ds.MovieLens('datasets/')
45        user_user = UserUser(15, min_nbrs=3)
46        algo = Recommender.adapt(user_user)
47        algo.fit(data.ratings)
48        #print(algo)
49        #print(data.ratings)
50
51        """
52        Recommendations are generated based on a user that is not included in a training set (hence, their id is -1),
53        and a pandas.Series obtained from the ratings dictionary.
54        """
55        recs = algo.recommend(user=-1, ratings=Series(user_dict))
56        #print(recs)
57
58        #Parsing the resulting DataFrame and saving recommendations as objects
59        for index, row in recs.iterrows():
60            #print(row['item'])
61            movieId = row['item']
62            stars = row['score']
63
64            if genre == 'All':
65                Recommendation.objects.create(name=name, movieId=movieId, pred_stars=stars)
66            if genre != 'All' and genre in movie.genres:
67                Recommendation.objects.create(name=name, movieId=movieId, pred_stars=stars)
68
69            #Stopping at 20 recommended items
70            count = Recommendation.objects.filter(name=name).count()
71            #print('count', count)
72            if count >= 20:
73                break
74
75        #Returning the movies ordered by the predicted ratings for them
76        recs = Recommendation.objects.filter(name=name).order_by('-pred_stars')
77        rec_movies = []
78        for rec in recs:
79            mov = Movie.objects.get(movieId=rec.movieId)
80            rec_movies.append(mov)
81
82        serializer = MovieSerializer(rec_movies, many=True)
83        return Response(serializer.data, status=status.HTTP_200_OK)
84
85
86class GroupViewSet(viewsets.ModelViewSet):
87    queryset = Group.objects.all()
88    serializer_class = GroupSerializer
89    authentication_classes = (TokenAuthentication,)
90    permission_classes = (IsAuthenticated, )
91
92    @action(methods=['GET'], detail=True)
93    def recommendations(self, request, pk=None):
94        if 'genre' in request.data:
95            genre = request.data['genre']
96        else:
97            genre = 'All'
98
99        #Checking if the user belongs to the group
100        group = Group.objects.get(id=pk)
101        users = group.user_set.all()
102        #print(users)
103        user = request.user
104        #print(user)
105
106        if user in users:
107            # Deleting the recommendations resulted from previous requests before generating new ones
108            Recommendation.objects.filter(name=group.name).delete()
109
110            rating_dict = {} #a dictionary of average ratings for the group
111            for user in users:
112                ratings = Rating.objects.filter(user=user.id)
113                for rating in ratings:
114                    stars = rating.stars
115                    movieId = int(rating.movie.movieId)
116
117                    """
118                    If the movie has already been rated by another member (i.e. a rating for it exists in the 
119                    dictionary), an average rating is computed
120                    """
121                    if movieId in rating_dict:
122                        x = rating_dict[movieId][0]
123                        y = rating_dict[movieId][1]
124                        x = (x * y + stars) / (y+1)
125                        y += 1
126                        rating_dict[movieId][0] = x
127                        rating_dict[movieId][1] = y
128                    #If not, the individual rating is simply insteted into the dictionary
129                    else:
130                        rating_dict[movieId] = [stars, 1]
131
132            #Training the ML algorithm
133            data = ds.MovieLens('datasets/')
134            user_user = UserUser(15, min_nbrs=3)
135            algo = Recommender.adapt(user_user)
136            algo.fit(data.ratings)
137
138            for key in rating_dict.keys():
139                x = rating_dict[key][0]
140                rating_dict[key] = x
141            #print(rating_dict)
142
143            #Requesting recommendations for the hybrid user
144            recs = algo.recommend(user=-1, ratings=Series(rating_dict))
145            #print(recs)
146
147            genre = request.data['genre']
148            name = group.name
149
150            #Parsing the resulting DataFrame and saving the recommendations as objects
151            for index, row in recs.iterrows():
152                print(row['item'])
153                movie = Movie.objects.get(movieId=str(int(row['item'])))
154                stars = row['score']
155                name = group.name
156                if genre == 'All':
157                    Recommendation.objects.create(name=name, movieId=movie.movieId, pred_stars=stars)
158                if genre != 'All' and genre in movie.genres:
159                    Recommendation.objects.create(name=name, movieId=movie.movieId, pred_stars=stars)
160
161                #Stopping at 20 recommendations
162                count = Recommendation.objects.filter(name=name).count()
163                print('count', count)
164                if count >= 20:
165                    break
166
167            #Returning movies ordered by the predicted score for the group
168            recs = Recommendation.objects.filter(name=name).order_by('-pred_stars')
169            rec_movies = []
170            for rec in recs:
171                mov = Movie.objects.get(movieId=rec.movieId)
172                rec_movies.append(mov)
173            serializer = MovieSerializer(rec_movies, many=True)
174
175            return Response(serializer.data, status=status.HTTP_200_OK)
176
177        else:
178            response = {'message': 'You are not a member of this group'}
179            return Response(response, status=status.HTTP_400_BAD_REQUEST)
180[
181    {
182        "id": 17521,
183        "movieId": "318",
184        "title": "Shawshank Redemption, The (1994)",
185        "genres": "Crime|Drama",
186        "link": "https://www.imdb.com/title/tt0111161/",
187        "average_rating": 4.487138263665595,
188        "no_ratings": 311,
189        "poster": "/default-movie.jpg"
190    },
191    {
192        "id": 17503,
193        "movieId": "296",
194        "title": "Pulp Fiction (1994)",
195        "genres": "Comedy|Crime|Drama|Thriller",
196        "link": "https://www.imdb.com/title/tt0110912/",
197        "average_rating": 4.256172839506172,
198        "no_ratings": 324,
199        "poster": "/default-movie.jpg"
200    },
201    ...
202]
203[]
204Empty DataFrame
205Columns: [item, score]
206Index: []
207

1inferred_vector = model.infer_vector(news_1)
2sims = model.dv.most_similar([inferred_vector], topn=5)
3

1!pip install pyspark==3.0.1 py4j==0.10.9
2from pyspark.sql import SparkSession
3from pyspark import SparkContext 
4appName="Collaborative Filtering with PySpark"
5from pyspark.sql.types import StructType,StructField,IntegerType,StringType,LongType
6from pyspark.sql.functions import col
7from pyspark.ml.recommendation import ALS
8from google.colab import drive
9drive.mount ('/content/gdrive')
10
11spark = SparkSession.builder.appName(appName).getOrCreate()
12sc = spark.sparkContext
13
14userArtistData1=sc.textFile("/content/gdrive/My Drive/data/user_artist_data_small.txt")
15
16
17schema_user_artist = StructType([StructField("userId",StringType(),True),StructField("artistId",StringType(),True),StructField("playCount",StringType(),True)])
18
19userArtistRDD = userArtistData1.map(lambda k: k.split())
20
21user_artist_df = spark.createDataFrame(userArtistRDD,schema_user_artist,['userId','artistId','playCount']) 
22
23ua = user_artist_df.alias('ua') 
24(training, test) = ua.randomSplit([0.8, 0.2])  #Training the model
25als = ALS(maxIter=5, implicitPrefs=True,userCol="userId", itemCol="artistId", ratingCol="playCount",coldStartStrategy="drop")
26
27model = als.fit(training)# predict using the testing datatset
28
29predictions = model.transform(test)
30predictions.show()
31

1!pip install pyspark==3.0.1 py4j==0.10.9
2from pyspark.sql import SparkSession
3from pyspark import SparkContext 
4appName="Collaborative Filtering with PySpark"
5from pyspark.sql.types import StructType,StructField,IntegerType,StringType,LongType
6from pyspark.sql.functions import col
7from pyspark.ml.recommendation import ALS
8from google.colab import drive
9drive.mount ('/content/gdrive')
10
11spark = SparkSession.builder.appName(appName).getOrCreate()
12sc = spark.sparkContext
13
14userArtistData1=sc.textFile("/content/gdrive/My Drive/data/user_artist_data_small.txt")
15
16
17schema_user_artist = StructType([StructField("userId",StringType(),True),StructField("artistId",StringType(),True),StructField("playCount",StringType(),True)])
18
19userArtistRDD = userArtistData1.map(lambda k: k.split())
20
21user_artist_df = spark.createDataFrame(userArtistRDD,schema_user_artist,['userId','artistId','playCount']) 
22
23ua = user_artist_df.alias('ua') 
24(training, test) = ua.randomSplit([0.8, 0.2])  #Training the model
25als = ALS(maxIter=5, implicitPrefs=True,userCol="userId", itemCol="artistId", ratingCol="playCount",coldStartStrategy="drop")
26
27model = als.fit(training)# predict using the testing datatset
28
29predictions = model.transform(test)
30predictions.show()
31IllegalArgumentException: requirement failed: Column userId must be of type numeric but was actually of type string.
32

1!pip install pyspark==3.0.1 py4j==0.10.9
2from pyspark.sql import SparkSession
3from pyspark import SparkContext 
4appName="Collaborative Filtering with PySpark"
5from pyspark.sql.types import StructType,StructField,IntegerType,StringType,LongType
6from pyspark.sql.functions import col
7from pyspark.ml.recommendation import ALS
8from google.colab import drive
9drive.mount ('/content/gdrive')
10
11spark = SparkSession.builder.appName(appName).getOrCreate()
12sc = spark.sparkContext
13
14userArtistData1=sc.textFile("/content/gdrive/My Drive/data/user_artist_data_small.txt")
15
16
17schema_user_artist = StructType([StructField("userId",StringType(),True),StructField("artistId",StringType(),True),StructField("playCount",StringType(),True)])
18
19userArtistRDD = userArtistData1.map(lambda k: k.split())
20
21user_artist_df = spark.createDataFrame(userArtistRDD,schema_user_artist,['userId','artistId','playCount']) 
22
23ua = user_artist_df.alias('ua') 
24(training, test) = ua.randomSplit([0.8, 0.2])  #Training the model
25als = ALS(maxIter=5, implicitPrefs=True,userCol="userId", itemCol="artistId", ratingCol="playCount",coldStartStrategy="drop")
26
27model = als.fit(training)# predict using the testing datatset
28
29predictions = model.transform(test)
30predictions.show()
31IllegalArgumentException: requirement failed: Column userId must be of type numeric but was actually of type string.
32TypeError: field userId: IntegerType can not accept object '1059637' in type <class 'str'>
33

1while True:
2    user_input3 = input('Please enter movie title: ')
3    if user_input3 == 'done':
4        break
5    try:
6        print(' ')
7        print(get_input_movie(user_input3))
8        print(get_input_movie(user_input3, cosine_sim1))
9        # print(get_input_movie(user_input3), get_input_movie(user_input3,cosine_sim1))
10        print(' ')
11    except KeyError or ValueError:
12        print('Check your movie title spelling, capitalization and try again.')
13        print(' ')
14        continue
15

1while True:
2    user_input3 = input('Please enter movie title: ')
3    if user_input3 == 'done':
4        break
5    try:
6        print(' ')
7        print(get_input_movie(user_input3))
8        print(get_input_movie(user_input3, cosine_sim1))
9        # print(get_input_movie(user_input3), get_input_movie(user_input3,cosine_sim1))
10        print(' ')
11    except KeyError or ValueError:
12        print('Check your movie title spelling, capitalization and try again.')
13        print(' ')
14        continue
15Please enter movie title: Casino
16
1734652       The Under-Gifted
1828155             The Plague
1912738    The Incredible Hulk
2041823      The Ugly Duckling
2144976           12 Feet Deep
22Name: Title, dtype: object
231177        GoodFellas
241192       Raging Bull
2525900    The Big Shave
26109        Taxi Driver
277617      Mean Streets
28Name: Title, dtype: object
29

1while True:
2    user_input3 = input('Please enter movie title: ')
3    if user_input3 == 'done':
4        break
5    try:
6        print(' ')
7        print(get_input_movie(user_input3))
8        print(get_input_movie(user_input3, cosine_sim1))
9        # print(get_input_movie(user_input3), get_input_movie(user_input3,cosine_sim1))
10        print(' ')
11    except KeyError or ValueError:
12        print('Check your movie title spelling, capitalization and try again.')
13        print(' ')
14        continue
15Please enter movie title: Casino
16
1734652       The Under-Gifted
1828155             The Plague
1912738    The Incredible Hulk
2041823      The Ugly Duckling
2144976           12 Feet Deep
22Name: Title, dtype: object
231177        GoodFellas
241192       Raging Bull
2525900    The Big Shave
26109        Taxi Driver
277617      Mean Streets
28Name: Title, dtype: object
29Please enter movie title: Casino
30 
3134652       The Under-Gifted
3228155             The Plague
3312738    The Incredible Hulk
3441823      The Ugly Duckling
3544976           12 Feet Deep
361177              GoodFellas
371192             Raging Bull
3825900          The Big Shave
39109              Taxi Driver
407617            Mean Streets
41

1while True:
2    user_input3 = input('Please enter movie title: ')
3    if user_input3 == 'done':
4        break
5    print(get_input_movie(user_input3))
6