推荐系统基础:使用PyTorch进行矩阵分解进行动漫的推荐

anime_ratings_df=pd.read_csv("rating.csv")
anime_ratings_df.shapeprint(anime_ratings_df.head())

Counter(anime_ratings.rating)

np.mean(anime_ratings.groupby(['user_id']).count()['anime_id'])

defencode_column(column):
""" Encodes a pandas column with continous IDs"""keys=column.unique()
key_to_id= {key:idxforidx,keyinenumerate(keys)}
returnkey_to_id, np.array([key_to_id[x] forxincolumn]), len(keys)
anime_df, num_users, num_anime, user_ids, anime_ids=encode_df(train_df)
print("Number of users :", num_users)
print("Number of anime :", num_anime)
anime_df.head()

defcost(df, emb_user, emb_anime):
""" Computes mean square error"""Y=create_sparse_matrix(df, emb_user.shape[0], emb_anime.shape[0])
predicted=create_sparse_matrix(predict(df, emb_user, emb_anime), emb_user.shape[0], emb_anime.shape[0], 'prediction')
returnnp.sum((Y-predicted).power(2))/df.shape[0]

defpredict(df, emb_user, emb_anime):
""" This function computes df["prediction"] without doing (U*V^T).Computes df["prediction"] by using elementwise multiplication of the corresponding embeddings and thensum to get the prediction u_i*v_j. This avoids creating the dense matrix U*V^T."""df['prediction'] =np.sum(np.multiply(emb_anime[df['anime_id']],emb_user[df['user_id']]), axis=1)
returndf

defcreate_embeddings(n, K):
"""Creates a random numpy matrix of shape n, K with uniform values in (0, 11/K)n: number of items/usersK: number of factors in the embedding"""return11*np.random.random((n, K)) /K

defcreate_sparse_matrix(df, rows, cols, column_name="rating"):
""" Returns a sparse utility matrix"""returnsparse.csc_matrix((df[column_name].values,(df['user_id'].values, df['anime_id'].values)),shape=(rows, cols))

defgradient_descent(df, emb_user, emb_anime, iterations=2000, learning_rate=0.01, df_val=None):
"""Computes gradient descent with momentum (0.9) for given number of iterations.emb_user: the trained user embeddingemb_anime: the trained anime embedding"""Y=create_sparse_matrix(df, emb_user.shape[0], emb_anime.shape[0])
beta=0.9grad_user, grad_anime=gradient(df, emb_user, emb_anime)
v_user=grad_userv_anime=grad_animeforiinrange(iterations):
grad_user, grad_anime=gradient(df, emb_user, emb_anime)
v_user=beta*v_user+ (1-beta)*grad_userv_anime=beta*v_anime+ (1-beta)*grad_animeemb_user=emb_user-learning_rate*v_useremb_anime=emb_anime-learning_rate*v_animeif(not (i+1)%50):
print("\niteration", i+1, ":")
print("train mse:", cost(df, emb_user, emb_anime))
ifdf_valisnotNone:
print("validation mse:", cost(df_val, emb_user, emb_anime))
returnemb_user, emb_anime

defencode_new_data(valid_df, user_ids, anime_ids):
""" Encodes valid_df with the same encoding as train_df."""df_val_chosen=valid_df['anime_id'].isin(anime_ids.keys()) &valid_df['user_id'].isin(user_ids.keys())
valid_df=valid_df[df_val_chosen]
valid_df['anime_id'] =np.array([anime_ids[x] forxinvalid_df['anime_id']])
valid_df['user_id'] =np.array([user_ids[x] forxinvalid_df['user_id']])
returnvalid_df

train_mse=cost(train_df, emb_user, emb_anime)
val_mse=cost(valid_df, emb_user, emb_anime)
print(train_mse, val_mse)

valid_df[70:80].head()