def test_cosine_similarity(self):
vector_x = [4.75, 4.5, 5, 4.25, 4]
vector_y = [4, 3, 5, 2, 1]
user_sim = UserSimilarity()
self.assertAlmostEqual(0.935, user_sim.cosine_similarity(vector_x, vector_y), places=3)
def test_cosine_similarity(self):
vector_x = [4.75, 4.5, 5, 4.25, 4]
vector_y = [4, 3, 5, 2, 1]
user_sim = UserSimilarity()
self.assertAlmostEqual(0.935,
user_sim.cosine_similarity(vector_x, vector_y),
places=3)
class UserWrapper:
def __init__(self, db=None):
if db == None:
client = MongoClient(config.db_config['host'],
config.db_config['port'])
self.db = client.hypertarget_ads
else:
self.db = db
self.user_similarity = UserSimilarity(self.db)
self.slope_one = SlopeOne(self.db)
def get_user(self, user_id):
user_id = int(user_id)
user = self.db.users.find_one({'id': user_id}, {'_id': 0})
return user
def get_next_id(self):
max_id = self.db.users.find({}, {
'id': 1,
'_id': 0
}).sort([('id', -1)]).limit(1)[0]['id']
return int(max_id) + 1
def register_user(self, data):
user = {
'age': data['age'],
'sex': data['sex'],
'occupation': data['occupation'],
'id': self.get_next_id(),
'zip_code': data['zip_code']
}
self.user_similarity.update_user_similarity(user)
self.db.users.insert(user)
return
def rate_movie(self, data):
self.slope_one.update_deviation(data)
new_rating = {'rating': data['rating'], 'timestamp': time.time()}
key = 'ratings.' + str(data['movie_id'])
self.db.users.update({'id': data['user_id']},
{'$set': {
key: new_rating
}})
return
def test_k_neighbours(self):
usersimilarity = UserSimilarity(self.db)
result = usersimilarity.find_k_nearest(479, 3)
if result is False:
print "Test Case: K NEIGHBOURS: FAIL"
else:
print "Test Case: K NEIGHBOURS: PASS"
return result
def test_k_neighbours(self):
usersimilarity = UserSimilarity(self.db)
result = usersimilarity.find_k_nearest(479, 3)
if result is False:
print "Test Case: K NEIGHBOURS: FAIL"
else:
print "Test Case: K NEIGHBOURS: PASS"
return result
def __init__(self, db=None):
if db == None:
client = MongoClient(config.db_config['host'],
config.db_config['port'])
self.db = client.hypertarget_ads
else:
self.db = db
self.user_similarity = UserSimilarity(self.db)
self.slope_one = SlopeOne(self.db)
def test_change_range(self):
old_range_min = 0
old_range_max = 100
new_range_min = 0
new_range_max = 1
old_value = 80
user_sim = UserSimilarity()
self.assertAlmostEqual(
0.8, user_sim.change_range(old_value, old_range_max, old_range_min, new_range_max, new_range_min), places=1
)
class UserWrapper:
def __init__(self, db=None):
if db == None:
client = MongoClient(config.db_config["host"], config.db_config["port"])
self.db = client.hypertarget_ads
else:
self.db = db
self.user_similarity = UserSimilarity(self.db)
self.slope_one = SlopeOne(self.db)
def get_user(self, user_id):
user_id = int(user_id)
user = self.db.users.find_one({"id": user_id}, {"_id": 0})
return user
def get_next_id(self):
max_id = self.db.users.find({}, {"id": 1, "_id": 0}).sort([("id", -1)]).limit(1)[0]["id"]
return int(max_id) + 1
def register_user(self, data):
user = {
"age": data["age"],
"sex": data["sex"],
"occupation": data["occupation"],
"id": self.get_next_id(),
"zip_code": data["zip_code"],
}
self.user_similarity.update_user_similarity(user)
self.db.users.insert(user)
return
def rate_movie(self, data):
self.slope_one.update_deviation(data)
new_rating = {"rating": data["rating"], "timestamp": time.time()}
key = "ratings." + str(data["movie_id"])
self.db.users.update({"id": data["user_id"]}, {"$set": {key: new_rating}})
return
def __init__(self, db=None):
if db == None:
client = MongoClient(config.db_config['host'],
config.db_config['port'])
self.db = client.hypertarget_ads
else:
self.db = db
self.user_similarity = UserSimilarity(self.db)
self.slope_one = SlopeOne(self.db)
self.pool = Pool(processes=10)
self.recommended_movies = {}
def test_change_range(self):
old_range_min = 0
old_range_max = 100
new_range_min = 0
new_range_max = 1
old_value = 80
user_sim = UserSimilarity()
self.assertAlmostEqual(0.8,
user_sim.change_range(old_value, old_range_max,
old_range_min,
new_range_max,
new_range_min),
places=1)
def __init__(self, db=None):
if db == None:
client = MongoClient(config.db_config["host"], config.db_config["port"])
self.db = client.hypertarget_ads
else:
self.db = db
self.user_similarity = UserSimilarity(self.db)
self.slope_one = SlopeOne(self.db)
def __init__(self, db = None):
if db == None:
client = MongoClient(config.db_config['host'], config.db_config['port'])
self.db = client.hypertarget_ads
else:
self.db = db
self.user_similarity = UserSimilarity(self.db)
self.slope_one = SlopeOne(self.db)
self.pool = Pool(processes = 10)
self.recommended_movies = {}
class Recommendare:
def __init__(self, db=None):
if db == None:
client = MongoClient(config.db_config['host'],
config.db_config['port'])
self.db = client.hypertarget_ads
else:
self.db = db
self.user_similarity = UserSimilarity(self.db)
self.slope_one = SlopeOne(self.db)
self.pool = Pool(processes=10)
self.recommended_movies = {}
def user_prediction(self, user_id, movie, neighbour):
if not movie in self.recommended_movies.keys():
self.recommended_movies[movie] = {
'slope_rating':
self.slope_one.predict_rating(user_id, int(movie)),
'neighbours': []
}
self.recommended_movies[movie]['neighbours'].append({
'neighbour_id':
neighbour['user_id'],
'neighbour_rating':
self.user_similarity.get_user_rating_for(neighbour['user_id'],
movie),
'neighbour_similarity':
neighbour['similarity']
})
def rate_neighbours_movies(self, user_id, count):
neighbours = self.user_similarity.get_neighbours_movies(user_id, k=3)
all_movies = []
for neighbour in neighbours:
all_movies.append(set(neighbour['movies']))
temp = set.intersection(*all_movies)
if len(temp) >= count:
all_movies = temp
else:
all_movies = set.union(*all_movies)
for neighbour in neighbours:
for n_movie in neighbour['movies']:
if n_movie in all_movies:
self.pool.apply_async(self.user_prediction,
(user_id, n_movie, neighbour))
self.pool.close()
self.pool.join()
def get_recommended_movies(self, user_id, count):
if len(self.recommended_movies) == 0:
self.rate_neighbours_movies(user_id, count)
return self.recommended_movies
def recommend(self, user_id, count):
movies_list = self.get_recommended_movies(user_id, count)
recommendations = []
for movie in movies_list:
num = 0
den = 0
for neighbour in movies_list[movie]['neighbours']:
num += neighbour['neighbour_similarity'] * neighbour[
'neighbour_rating']
den += neighbour['neighbour_similarity']
if den == 0:
predicted_rating = 0
else:
predicted_rating = num / float(den)
if predicted_rating == 0:
predicted_rating = movies_list[movie]['slope_rating']
else:
predicted_rating = (
predicted_rating +
movies_list[movie]['slope_rating']) / float(2)
recommendations.append((movie, predicted_rating))
return sorted(recommendations, key=itemgetter(1), reverse=True)[:count]
from pymongo import MongoClient
from usersimilarity import UserSimilarity
from slopeone import SlopeOne
client = MongoClient('localhost', 27017)
db = client.hypertarget_ads
slope = SlopeOne(db)
similarity = UserSimilarity(db)
slope.dump_deviation_matrix()
similarity.dump_similarity_matrix()
'movie_id': 515,
'user_id': 944,
}
rate2 = {
'rating': 4,
'movie_id': 515,
'user_id': 945,
}
rate3 = {
'rating': 4,
'movie_id': 515,
'user_id': 946,
}
uw.rate_movie(rate1)
uw.rate_movie(rate2)
uw.rate_movie(rate3)
so = SlopeOne(db)
print so.predict_rating(946, 500)
"""
client = MongoClient('localhost', 27017)
db = client.hypertarget_ads
us = UserSimilarity(db)
us.dump_similarity_matrix()
class Recommendare:
def __init__(self, db = None):
if db == None:
client = MongoClient(config.db_config['host'], config.db_config['port'])
self.db = client.hypertarget_ads
else:
self.db = db
self.user_similarity = UserSimilarity(self.db)
self.slope_one = SlopeOne(self.db)
self.pool = Pool(processes = 10)
self.recommended_movies = {}
def user_prediction(self, user_id, movie, neighbour):
if not movie in self.recommended_movies.keys():
self.recommended_movies[movie] = {
'slope_rating': self.slope_one.predict_rating(user_id, int(movie)),
'neighbours': []
}
self.recommended_movies[movie]['neighbours'].append({
'neighbour_id': neighbour['user_id'],
'neighbour_rating': self.user_similarity.get_user_rating_for(neighbour['user_id'], movie),
'neighbour_similarity': neighbour['similarity']
})
def rate_neighbours_movies(self, user_id, count):
neighbours = self.user_similarity.get_neighbours_movies(user_id, k = 3)
all_movies = []
for neighbour in neighbours:
all_movies.append(set(neighbour['movies']))
temp = set.intersection(*all_movies)
if len(temp) >= count:
all_movies = temp
else:
all_movies = set.union(*all_movies)
for neighbour in neighbours:
for n_movie in neighbour['movies']:
if n_movie in all_movies:
self.pool.apply_async(self.user_prediction, (user_id, n_movie, neighbour))
self.pool.close()
self.pool.join()
def get_recommended_movies(self, user_id, count):
if len(self.recommended_movies) == 0:
self.rate_neighbours_movies(user_id, count)
return self.recommended_movies
def recommend(self, user_id, count):
movies_list = self.get_recommended_movies(user_id, count)
recommendations = []
for movie in movies_list:
num = 0
den = 0
for neighbour in movies_list[movie]['neighbours']:
num += neighbour['neighbour_similarity'] * neighbour['neighbour_rating']
den += neighbour['neighbour_similarity']
if den == 0:
predicted_rating = 0
else:
predicted_rating = num / float(den)
if predicted_rating == 0:
predicted_rating = movies_list[movie]['slope_rating']
else:
predicted_rating = (predicted_rating + movies_list[movie]['slope_rating']) / float(2)
recommendations.append((movie, predicted_rating))
return sorted(recommendations, key = itemgetter(1), reverse = True)[:count]
