Python SVD.recommend方法代码示例

# 需要导入模块: from recsys.algorithm.factorize import SVD [as 别名]
# 或者: from recsys.algorithm.factorize.SVD import recommend [as 别名]
def main():
    svd = SVD()
    train = Data()
    test = Data()
    train.load('randUser/rate1.csv', force=True, sep=',', format={'col':0, 'row':1, 'value':2, 'ids':int})
    test.load('randUser/rate1.csv', force=True, sep=',', format={'col':0, 'row':1, 'value':2, 'ids':int})
    svd.set_data(train)
    svd.compute(k=100, min_values=0.5, pre_normalize=False, mean_center=True, post_normalize=True)

    # rmse = RMSE()
    # mae = MAE()
    # for rating, item_id, user_id in test.get():
    #     try:
    #         pred_rating = svd.predict(item_id, user_id)
    #         rmse.add(rating, pred_rating)
    #         mae.add(rating, pred_rating)
    #     except KeyError:
    #         continue
    # print 'RMSE=%s' % rmse.compute()
    # print 'MAE=%s' % mae.compute()

    # test = make_test()
    # print precision_and_recall(test, svd)
    # rec_list = svd.recommend(200, n=5, only_unknowns=False, is_row=False)
    print svd.recommend(1, n=5, only_unknowns=False, is_row=False)

# 需要导入模块: from recsys.algorithm.factorize import SVD [as 别名]
# 或者: from recsys.algorithm.factorize.SVD import recommend [as 别名]
def recommend(dimension=100): 
    svd = SVD()
    svd.load_data(filename='rating.dat',
                sep='\t',
                format={'col':2, 'row':1, 'value':0, 'ids': int})

    k = dimension
    svd.compute(k=k, min_values=1, pre_normalize=None, mean_center=True, post_normalize=True)
    
    game_recdict={}
    for item in svd.recommend(1, is_row=False):
        appid=item[0]
        game=Game(appid)
        if (game.success==1):
            game_recdict[game.rec]=[game.appid, game.genre, game.name, game.img]
        
    sorted_list=sorted(game_recdict.keys(), reverse=True)
    print ("Games Recommended:")
    for i in sorted_list:
        # image
        urllib.urlretrieve(game_recdict[i][3], "local-filename.jpg")
        image = plt.imread("local-filename.jpg")
        plt.imshow(image)
        plt.show()
    
        #name
        print game_recdict[i][2]

# 需要导入模块: from recsys.algorithm.factorize import SVD [as 别名]
# 或者: from recsys.algorithm.factorize.SVD import recommend [as 别名]
def recommended_files(user):
    if not type(user) is str:
        user = unidecode.unidecode(user)
    if db.done_users.find_one({'user':user})['recommended']==False:
        user_files = db.user_list.find({'user':user})
        f = open('./dc_recom.dat','a')
        for u in user_files:
            f.write(u['user'] + '::' + u['tth'])
            f.write('\n')
        f.close()
        db.done_users.update({'user': user}, {'user':user, 'recommended': True})

    data = Data()
    data.load('./dc_recom.dat', sep='::', format={'col':1,'row':0})
    svd = SVD()
    svd.set_data(data)
    svd.compute(k=1000,min_values=0, pre_normalize=None, mean_center=False, post_normalize=True)
    similar_users = [i[0] for i in svd.similar(user,n=10)]

    newdata = Data()
    for i in range(0,len(similar_users),1):
        files = db.user_list.find({'user':similar_users[i]})
        for f in files:
            newdata.add_tuple((1.0,similar_users[i],f['tth']))
    svd.set_data(newdata)
    svd.compute(k=1000,min_values=0, pre_normalize=None, mean_center=False, post_normalize=True)
    recoms = svd.recommend(user,is_row=True,only_unknowns=True,n=100)

    res = []
    c_res = 0
    for p in recoms:
        flag=0
        for r in res:
            if similar(db.tths.find_one({'tth':p[0]})['name'],db.tths.find_one({'tth':r[0]})['name']):
                flag = 1
                break
        if flag == 0:
            res.append(p)
            c_res += 1
            if c_res > 10:
                k = []
                for i in res:
                    try:
                        j = 'magnet:?xt=urn:tree:tiger:'+i[0] + "&dn=" + unidecode.unidecode(db.tths.find_one({'tth': i[0]})['name'])
                    except:
                        j = 'magnet:?xt=urn:tree:tiger:'+i[0]
                    k.append(j)
                return k
    k = []
    for i in res:
        try:
            j = 'magnet:?xt=urn:tree:tiger:'+i[0] + "&dn=" + unidecode.unidecode(db.tths.find_one({'tth': i[0]})['name'])
        except:
            j = 'magnet:?xt=urn:tree:tiger:'+i[0]
        k.append(j)

    return k

# 需要导入模块: from recsys.algorithm.factorize import SVD [as 别名]
# 或者: from recsys.algorithm.factorize.SVD import recommend [as 别名]
def quickstart():
    svd = SVD()
    recsys.algorithm.VERBOSE = True

    # load movielens data
    dat_file = 'ml-1m/ratings.dat'
    svd.load_data(filename=dat_file, sep='::', format={'col':0, 'row':1, 'value':2, 'ids': int})

    # compute svd
    k = 100
    svd.compute(k=k, min_values=10, pre_normalize=None, mean_center=True,
        post_normalize=True)

    pdb.set_trace()

    # movie id's
    ITEMID1 = 1      # toy story
    ITEMID2 = 1221   # godfather II

    # get movies similar to toy story
    svd.similar(ITEMID1)

    # get predicted rating for given user & movie
    MIN_RATING = 0.0
    MAX_RATING = 5.0
    USERID = 1
    ITEMID = 1

    # get predicted rating
    pred = svd.predict(ITEMID, USERID, MIN_RATING, MAX_RATING)
    actual = svd.get_matrix().value(ITEMID, USERID)
    print 'predicted rating = {0}'.format(pred)
    print 'actual rating = {0}'.format(actual)

    # which users should see Toy Story?
    svd.recommend(ITEMID)

# 需要导入模块: from recsys.algorithm.factorize import SVD [as 别名]
# 或者: from recsys.algorithm.factorize.SVD import recommend [as 别名]
def get_feeds():
	movielist = {}
	with sqlite3.connect('data/data100.db') as con:
		cur = con.cursor()
		cur.execute("SELECT * FROM ratings WHERE user_id = ?", (request.get_cookie('session_user', secret='recsys')[0],))
		if cur.fetchone():
			cur.execute("SELECT ratings, movie_id, user_id FROM ratings")
			rating_results = cur.fetchall()
			d = Data()
			d.set(rating_results)
			# with open('data/tmp.dat', 'a') as f:
			# 	for l in rating_results:
			# 		f.write('%d,%d,%d\n' % (l[0], l[1], l[2]))
			svd = SVD()
			# svd.load_data(filename='data/tmp.dat', sep=',', format={'col': 0, 'row': 1, 'value': 2, 'ids':int})
			svd.set_data(d)
			recommendations = [str(s[0]) for s in svd.recommend(request.get_cookie('session_user', secret='recsys')[0], is_row=False)]
			cur.execute("SELECT * FROM movies WHERE movie_id IN (%s)" % (', '.join(recommendations)))
			similar_movies = cur.fetchall()
			for m in similar_movies:
				movielist[m] = {
					'mid': m[0],
					'title': m[1],
					'description': m[2],
					'image': m[3],
					'year': m[4]
				}
		else:
			cur.execute("SELECT * FROM movies")
			movies = cur.fetchall()
			for m in movies:
				cur.execute("SELECT AVG(ratings) FROM ratings WHERE movie_id = ?", (m[0],))
				avg = cur.fetchone()[0]
				movielist[avg] = {
					'mid': m[0],
					'title': m[1],
					'description': m[2],
					'image': m[3],
					'year': m[4]
				}
	session_user = request.get_cookie('session_user', secret='recsys') if 'session_user' in request.cookies else None
	return template('static/feeds.html', movielist=movielist, session_user=session_user)

# 需要导入模块: from recsys.algorithm.factorize import SVD [as 别名]
# 或者: from recsys.algorithm.factorize.SVD import recommend [as 别名]
def recommend_for_content(content_id):
    svd = SVD(filename='./models/recommender.zip')
    return svd.recommend(content_id)

# 需要导入模块: from recsys.algorithm.factorize import SVD [as 别名]
# 或者: from recsys.algorithm.factorize.SVD import recommend [as 别名]

from boto.s3.connection import S3Connection
import urllib2

db = DBConn()
conn = S3Connection('AKIAI6F6HFFENFWSPN4Q', 'aP0OOVDj96AFUEr9vbHalvvNZz7rNNXyyH0Wof7i')
bucket = conn.get_bucket('elasticbeanstalk-us-west-2-501394068089')

ld_occurrences_key = bucket.get_key('files/data/ld_occurrences.dat')
ld_occurrences_path = ld_occurrences_key.generate_url(3600, query_auth=True, force_http=True)
ld_occurrences_content = urllib2.urlopen(ld_occurrences_path).read()

svd = SVD()
svd.load_data(filename=ld_occurrences_content, sep='::', format={'col':0, 'row':1, 'value':2, 'ids': str})
all_items = svd.recommend(USER_ID, n=10, only_unknowns=False, is_row=False)
for index, relevance in all_items:
    print index, items[index].get_data()['name'], relevance

# genres = db.get_genres(USER_ID)
# if len(genres['genres']) > 0:
#     pred_items = myFunctions.get_items_user_genre(items, all_items, genres)[:50]
# else:
#     pred_items = all_items[:50]
#
# for index, relevance in pred_items:
#     print index, items[index].get_data()['name'], items[index].get_data()['genres'], relevance


#
# start_time = time.time()

# 需要导入模块: from recsys.algorithm.factorize import SVD [as 别名]
# 或者: from recsys.algorithm.factorize.SVD import recommend [as 别名]
class NewsRec():
	def __init__(self):
		self.svd = SVD()
		self.test_set = []

	def load_data(self,filename = 'train_set_for_svd'):
		self.svd.load_data(filename,sep='\t',format={'value':0,'row':2,'col':1,'ids':int})
	
	def load_test(self,filename = 'test_set_for_svd'):
		with open(filename,'r') as f:
			for line in f:
				strs = line.split('\t')
				self.test_set.append((int(strs[1]),int(strs[2])))

	def recom(self,user_id,recom_num=3,only_unknown=True):
		try:
			#index = self.svd._matrix._matrix.col_index(user_id)
			index = user_id
			return self.svd.recommend(index,recom_num,only_unknowns=only_unknown,is_row=False)
		except IndexError as e:
			return -1

	def compute(self,k = 100):
		self.svd.compute(k=k, min_values=None, pre_normalize=None, mean_center=False, post_normalize=True)

	def test(self,recom_num=3):
		hit_cnt = 0
		self.ret = []
		for user,item in self.test_set:
			re = self.recom(user,recom_num)
			#print re
			if type(re) !=	type([]):
				continue
			try:
				#item_index = self.svd._matrix._matrix.row_index(item)
				item_index = item
			except KeyError as e:
				continue
			for rec_index,rec_rate in re:
				self.ret.append((user,rec_index))
				if item_index == rec_index:
					hit_cnt += 1
		if hit_cnt == 0:
			return
		user_sum = len(self.test_set)
		recom_sum = recom_num * user_sum
		precise = float(hit_cnt) / recom_sum
		recall = float(hit_cnt) / user_sum
		f = 2.0 / (( 1.0 / precise) + (1.0 / recall))
		print 'hit:',hit_cnt
		print 'precise:',precise
		print 'recall:',recall
		print 'F:',f

	def print_ret(self,filename):
		string = ["userid,newsid\n"]
		for user,item in self.ret:
			string.append(str(user))
			string.append(',')
			string.append(str(item))
			string.append('\n')
		with open(filename,'w') as f:
			f.write("".join(string))

# 需要导入模块: from recsys.algorithm.factorize import SVD [as 别名]
# 或者: from recsys.algorithm.factorize.SVD import recommend [as 别名]
class RecommendationSystem():
    # To run on your own machine, you need to initialize with your datapath to the frontend folder
    def __init__(self, sc, datapath='/media/psf/Home/CS/GIT_HUB/Movie-Recommendation-Project/frontend/', rating_file='ratings_small.csv', complete_rating_file='ratings.csv', movie_file='movies.csv', detail_file='modified.csv', model='movielens_small'):
        self.sc = sc
        self.start = True
        self.rating_file = datapath+rating_file
        self.complete_rating_file = datapath+complete_rating_file
        self.movie_file = datapath+movie_file
        self.detail_file = datapath+detail_file
        self.integration_folder = datapath
        self.svd = SVD(filename=datapath+model)
        self.svd.load_data(filename=self.rating_file, sep=',', format={'col': 0, 'row': 1, 'value': 2, 'ids': int})
        self.svd.create_matrix()
        self.ia = imdb.IMDb(accessSystem='http')

        # als stuff
        self.sqlContext = SQLContext(self.sc)
        self.movie_data = self.sc.textFile(self.movie_file)
        self.ratings_data = self.sc.textFile(self.complete_rating_file).map(lambda line: line.split(",")).map(lambda x: (int(x[0]), int(x[1]), float(x[2])))
        self.als_model_path = datapath + 'Model_Collaborative_Filtering'
        self.als_model = MatrixFactorizationModel.load(sc, self.als_model_path)
        self.movie_df = self.sqlContext.read.load(datapath+'tables/movies')
        self.detail_df = self.sqlContext.read.load(datapath+'tables/detail')
        self.rating_df = self.sqlContext.read.load(datapath+'tables/ratings')


    # call this function to get all recommendations
    def get_all_recomm(self, userid, moviename):
        movieid = self.get_movie_id(moviename)

        # all recommendation algorithms return a list of movie ids
        recom1 = self.svd_recomm(userid, only_unknown=True)
        recom2 = self.svd_similar(movieid)
        recom3 = self.als_new(userid)

        #get info about the movie based on movie ids
        brief_info1 = self.get_brief_list(recom1)
        brief_info2 = self.get_brief_list(recom2)
        brief_info3 = self.get_brief_list(recom3)

        # print to terminal
        for l1 in brief_info1:
            print l1
        for l2 in brief_info2:
            print l2
        for l3 in brief_info3:
            print l3

        return [brief_info1, brief_info2, brief_info3]

    # get movie id based on movie name input
    def get_movie_id(self, moviename):
        r = self.movie_df.where(self.movie_df['name'].startswith(moviename)).first()

        # return movie id 1 if not found
        if r is None:
            return 1

        return r['movieId']

    # svd recommendation algorithm based on the user's rating history, set only_known to True for unseen movies
    def svd_recomm(self, userid, only_unknown):
        user_found = False
        ratings = open(self.rating_file, 'r')
        for rating_row in ratings:
            rating_item = rating_row.split(',')
            if int(rating_item[0]) == userid:
                user_found = True
                break

        ratings.close()
        if not user_found:
            return None

        # output format: (movieid, similarity value)
        if only_unknown:
            similar_list = self.svd.recommend(userid, n=10, only_unknowns=True, is_row=True)
        else:
            similar_list = self.svd.recommend(userid, n=10, only_unknowns=False, is_row=False)

        movieid_list = self.get_id_list(similar_list)
        return movieid_list

    # svd recommendation algorithm based on similar movie
    def svd_similar(self, movieid):
        movie_found = False
        movies = open(self.movie_file, 'r')
        for movie_row in movies:
            row_item = movie_row.split(',')
            if int(row_item[0]) == movieid:
                movie_found = True
                break

        movies.close()
        if not movie_found:
            return None

        similar_list = self.svd.similar(movieid)
        movieid_list = self.get_id_list(similar_list)
        return movieid_list
#.........这里部分代码省略.........

# 需要导入模块: from recsys.algorithm.factorize import SVD [as 别名]
# 或者: from recsys.algorithm.factorize.SVD import recommend [as 别名]
                user = db.get_user_id(USER_ID=USER_ID)
                live_feedback = db.get_live_feedback_user(USER_ID)
                counts = dict()
                for feedback in live_feedback:
                    index = svd._matrix.get().row_index(str(feedback['artist_id']).encode('utf-8'))
                    artist_count = svd._matrix.get_value(str(feedback['artist_id']).encode('utf-8'), str(user["_id"]).encode('utf-8'))
                    counts[index] = artist_count

                sorted_indexes = sorted(counts.items(), key=operator.itemgetter(1), reverse=True)
                for index, artist_count in sorted_indexes:
                    GT_DECISION.append(index)

                TP, FP, TN, FN = 0, 0, 0, 0

                pred_items = svd.recommend(str(user['_id']).encode('utf-8'), n=10, only_unknowns=False, is_row=False)
                for item_id, relevance in pred_items:
                    index = svd._matrix.get().row_index(str(item_id).encode('utf-8'))
                    TEST_DECISION.append(index)

                    if str(item_id).encode('utf-8') in LIKED:
                        TP += 1
                    elif str(item_id).encode('utf-8') in DISLIKED:
                        FP += 1


                FN = len(LIKED) - TP
                TN = len(DISLIKED) - FP

                if TP == 0:
                    p = 0.0

# 需要导入模块: from recsys.algorithm.factorize import SVD [as 别名]
# 或者: from recsys.algorithm.factorize.SVD import recommend [as 别名]
    return 'Hello World!'

@app.route("/rec")
def rectest():


    svd = SVD()
    svd.load_data(filename, sep="::", format={"col":0, "row":1, "value":2, "ids": int})




if __name__ == '__main__':
    #app.run()
    #import os
    #print os.getcwd()
    import time
    start_time = time.time()

    svd = SVD()
    data = svd.load_data(filename, sep="::", format={"col":0, "row":1, "value":2, "ids": int})
    K = 100
    svd.compute(k=K, min_values=10, pre_normalize=None, mean_center=True, post_normalize=True, savefile=None)
    #print data
    #r = svd.predict(200, 1, MIN_VALUE=0, MAX_VALUE=5.0)
    r = svd.recommend(1, n=10, only_unknowns=True, is_row=False )
    print r


    time_consumed = time.time() - start_time
    print time_consumed

# 需要导入模块: from recsys.algorithm.factorize import SVD [as 别名]
# 或者: from recsys.algorithm.factorize.SVD import recommend [as 别名]
         user_found = True
         break 
 if (movie_found):
     for movie_row in movie_lens:
         row_item = movie_row.split(',')
         if (int(row_item[0]) == movie_id):
             print ("Movie name is: " + row_item[1])
             break
 if ( user_found == False):
     print "User not found. Please enter a valid user ID\n"
     continue
 #if we reach here, we definitely have a valid movie and user id. Continue with svd recommendation.
 #Getting movies similar to the given movie
 #similar_list = svd.similar(movie_id)
 #GEtting recommended movies
 similar_list = svd.recommend(USERID, n=10, only_unknowns=True, is_row=True)
 #Similar list is a list of similar movies. Format of Tuple (movie_id, similarity_value)
 ratings_file = open('ratings_small.csv', 'r+')
 movie_lens = open('movies.csv', 'r+')
 movie_list = []
 #print similar_list
 for movie in similar_list:
     ratings_file = open('ratings_small.csv', 'r+')
     movie_lens = open('movies.csv', 'r+')
     similar_movie_id = int(movie[0])
     #print movie[0]
     for movie_row in movie_lens:
         movie_item = movie_row.split(',')
         if (int(movie_item[0]) == similar_movie_id):
             movie_name = movie_item[1]
             break

# 需要导入模块: from recsys.algorithm.factorize import SVD [as 别名]
# 或者: from recsys.algorithm.factorize.SVD import recommend [as 别名]
class RecommendationSystem():
    #def __init__(self, spark_context, rating_file='ratings_small.csv', movie_file='movies.csv', detail_file='modified.csv', model='movielens_small'):
    def __init__(self, rating_file='ratings_small.csv', movie_file='movies.csv', detail_file='modified.csv', model='movielens_small'):
        self.start = True
        self.rating_file = rating_file
        self.movie_file = movie_file
        self.detail_file = detail_file
        self.svd = SVD(filename=model)
        self.svd.load_data(filename=rating_file, sep=',', format={'col': 0, 'row': 1, 'value': 2, 'ids': int})
        self.svd.create_matrix()
        self.ia = imdb.IMDb(accessSystem='http')

    def get_all_recomm(self, userid, movieid):
        recom1 = self.svd_recomm(userid, only_unknown=False)
        recom2 = self.svd_recomm(userid, only_unknown=True)
        recom3 = self.svd_similar(movieid)

        brief_info1 = self.get_brief_list(recom1)
        brief_info2 = self.get_brief_list(recom2)
        brief_info3 = self.get_brief_list(recom3)

        return [brief_info1, brief_info2, brief_info3]

    def svd_recomm(self, userid, only_unknown):
        user_found = False
        ratings = open(self.rating_file, 'r')
        for rating_row in ratings:
            rating_item = rating_row.split(',')
            if int(rating_item[0]) == userid:
                user_found = True
                break

        ratings.close()
        if not user_found:
            return None

        #output format: (movieid, similarity value)
        if only_unknown:
            similar_list = self.svd.recommend(userid, n=10, only_unknowns=True, is_row=True)
        else:
            similar_list = self.svd.recommend(userid, n=10, only_unknowns=False, is_row=False)

        movieid_list = self.get_id_list(similar_list)
        return movieid_list

    def svd_similar(self, movieid):
        movie_found = False
        movies = open(self.movie_file, 'r')
        for movie_row in movies:
            row_item = movie_row.split(',')
            if (int(row_item[0]) == movieid):
                movie_found = True
                break

        movies.close()
        if not movie_found:
            return None

        similar_list = self.svd.similar(movieid)
        movieid_list = self.get_id_list(similar_list)
        return movieid_list

    def get_id_list(self, l):
        movieid_list = []
        for s in l:
            movieid_list.append(s[0])
        return movieid_list

    def get_detail(self, imdb_id):
        #print type(imdb_id)
        m = self.ia.get_movie(str(imdb_id))

        cover = m.get('cover url')
        if cover:
            path = "Images/" + str(imdb_id) + ".jpg"
            urllib.urlretrieve(cover, path)

        return m

    def get_brief_list(self, movieList):
        info_list = []
        for m in movieList:
            info = self.get_brief(m)
            info_list.append(info)
        return info_list

    def get_brief(self, movieid):
        info = {}
        info['title'] = 'unknown'
        info['genre'] = 'unknown'
        info['rating'] = 0
        info['imdb_id'] = 1
        info['director'] = 'unknown'
        info['cast'] = 'unknown'

        movies = open(self.movie_file, 'r')
        for m in movies:
            row_item = m.split(',')
            if int(row_item[0]) == movieid:
                info['title'] = str(row_item[1].strip())
#.........这里部分代码省略.........

# 需要导入模块: from recsys.algorithm.factorize import SVD [as 别名]
# 或者: from recsys.algorithm.factorize.SVD import recommend [as 别名]
print len(data._data)

svd.set_data(data)

k = 100
svd.compute(k=k,
            min_values=10,
            pre_normalize=None,
            mean_center=True,
            post_normalize=True)


#ITEMID1 = 1    # Toy Story (1995)
#ITEMID2 = 2355 # A bug's life (1998)

#print svd.similarity(ITEMID1, ITEMID2)
#print svd.similar(ITEMID1)

MIN_RATING = 0.0
MAX_RATING = 5.0
ITEMID = 1
USERID = 1

#print svd.predict(ITEMID, USERID, MIN_RATING, MAX_RATING)
# Predicted value 5.0
#print svd.get_matrix().value(ITEMID, USERID)
# Real value 5.0
print svd.recommend(USERID, is_row=False) #cols are users and rows are items, thus we set is_row=False
print svd.recommend(ITEMID)

# 需要导入模块: from recsys.algorithm.factorize import SVD [as 别名]
# 或者: from recsys.algorithm.factorize.SVD import recommend [as 别名]
class Recommender():
    def __init__(self, train, test):
        recsys.algorithm.VERBOSE = True
        self.train = train
        self.test = test
        self.svd = SVD()
        self.svd.set_data(train)

    def set_train(self, train):
        self.train = train

    def set_test(self, test):
        self.test = test

    def get_train(self):
        return self.train

    def get_test(self):
        return self.test

    def get_alluserid(self, dataset):
        userid_list = []
        for rating, item_id, user_id in dataset.get():
            if user_id not in userid_list:
                userid_list.append(user_id)
        return userid_list

    def get_allitemid(self, dataset):
        itemid_list = []
        for rating, item_id, user_id in dataset.get():
            if item_id not in itemid_list:
                itemid_list.append(item_id)
        return itemid_list

    def eval_rmse(self):
        # Evaluation using prediction-based metrics
        rmse = RMSE()
        mae = MAE()
        for rating, item_id, user_id in self.test.get():
            try:
                pred_rating = self.svd.predict(item_id, user_id)
                rmse.add(rating, pred_rating)
                mae.add(rating, pred_rating)
            except KeyError:
                continue
        print 'RMSE=%s' % rmse.compute()
        print 'MAE=%s' % mae.compute()

    def recommend(self, N=10, only_unknowns=False, is_row=True):
        rec_list = {}
        for rating, item_id, user_id in self.test.get():
            if user_id in self.get_alluserid(self.train):
                rec_list[user_id] = self.svd.recommend(user_id, n=N, only_unknowns=False, is_row=False)
                print rec_list[user_id]
        return rec_list

    def precisionRecall(self, rec_list2, test_dict):
        print "Start calculate precision and recall..."
        hit = 0
        n_recall = 0
        n_precision = 0
        for user, items in test_dict.items():
             if user not in self.get_alluserid(self.train):
                 continue
             rec_list = self.svd.recommend(user, n=30, only_unknowns=False, is_row=False)
             r = [i[0] for i in rec_list]
             print 'rec_list', r
             hit += len(list(set(r) & set(items.keys())))
             n_recall += len(items)
             n_precision += 30
        return [hit / (1.0 * n_recall), hit / (1.0 * n_precision)]