knn电影推荐算法评估

Question

knn电影推荐算法评估准确率，召回率和F1

```python
 
import pandas as pd
# usecols 允许选择自己选择的特征，并通过dtype设定对应类型
movies_df=pd.read_csv('D:/Datamovies/ml-latest-small/movies.csv', 
                      usecols=['movieId','title'], 
                      dtype={'movieId':'int32','title':'str'})
movies_df.head()
ratings_df=pd.read_csv('D:/Datamovies/ml-latest-small/ratings.csv',
                       usecols=['userId', 'movieId', 'rating','timestamp'],
                       dtype={'userId': 'int32', 'movieId': 'int32', 'rating': 'float32'})
ratings_df.head()
# 检查缺失值
movies_df.isnull().sum()
ratings_df.isnull().sum()  #条目数
print("Movies:",movies_df.shape)#获取数组或矩阵维度
print("Ratings:",ratings_df.shape)
#合并列上的数据帧‘movieID’
# movies_df.info()
# ratings_df.info()
movies_merged_df=movies_df.merge(ratings_df, on='movieId')
movies_merged_df.head()
#添加衍生特征
#通过按电影标题对用户评分进行分组来创建'Average Rating' & 'Rating Count'列。
movies_average_rating=movies_merged_df.groupby('title')['rating']\
           .mean().sort_values(ascending=False)\
            .reset_index().rename(columns={'rating':'Average Rating'})
movies_average_rating.head()
movies_rating_count=movies_merged_df.groupby('title')['rating']\
              .count().sort_values(ascending=True)\
               .reset_index().rename(columns={'rating':'Rating Count'}) #ascending=False
movies_rating_count_avg=movies_rating_count.merge(movies_average_rating, on='title')
movies_rating_count_avg.head()
# 导入可视化库
import seaborn as sns
import matplotlib.pyplot as plt
sns.set(font_scale = 1)
plt.rcParams["axes.grid"] = False
plt.style.use('dark_background')
%matplotlib inline

# 绘制图形
plt.figure(figsize=(12,4))
plt.hist(movies_rating_count_avg['Rating Count'],bins=80,color='tab:purple')
plt.ylabel('Ratings Count(Scaled)',fontsize=16)
plt.savefig('D:/Datamovies/ml-latest-small/ratingcounthist.jpg')

plt.figure(figsize=(12,4))
plt.hist(movies_rating_count_avg['Average Rating'],bins=80,color='tab:purple')
plt.ylabel('Average Rating',fontsize=16)
plt.savefig('D:/Datamovies/ml-latest-small/avgratinghist.jpg')
plot=sns.jointplot(x='Average Rating',
                   y='Rating Count',
                   data=movies_rating_count_avg,
                   alpha=0.5, 
                   color='tab:pink')
plot.savefig('D:/Datamovies/ml-latest-small/joinplot.jpg')

pd.set_option('display.float_format', lambda x: '%.3f' % x)#设置显示选项，让所有浮点数以三位小数显示
rating_with_RatingCount=movies_merged_df.merge(movies_rating_count_avg,on='title')#将movies_merged_df和movies_rating_count_avg按title列合并
print(rating_with_RatingCount['Rating Count'].describe())
popularity_threshold = 50
popular_movies= rating_with_RatingCount[
          rating_with_RatingCount['Rating Count']>=popularity_threshold]#根据popularity_threshold中的值从rating_with_RatingCount中筛选出大于等于50的电影
popular_movies.head()
# popular_movies.shape
print(popular_movies['Rating Count'].describe())
import os
movie_features_df=popular_movies.pivot_table(
      index='title',columns='userId',values='rating').fillna(0)
movie_features_df.to_excel('D:/Datamovies/ml-latest-small/output.xlsx')
movie_features_df.head()
from scipy.sparse import csr_matrix
movie_features_df_matrix = csr_matrix(movie_features_df.values)
from sklearn.neighbors import NearestNeighbors#寻找一个点的 K 个最近邻居。它返回每个点的邻居的索引和到邻居的距离
model_knn = NearestNeighbors(metric = 'cosine',
                             algorithm = 'brute')
model_knn.fit(movie_features_df_matrix)
import numpy as np
query_index = np.random.choice(movie_features_df.shape[0])
distances, indices = model_knn.kneighbors(movie_features_df.iloc[query_index,:].values.reshape(1, -1),
                                          n_neighbors = 6)
for i in range(0, len(distances.flatten())):
    if i == 0:
        print('Recommendations for {0}:\n'
              .format(movie_features_df.index[query_index]))
    else:
        print('{0}: {1}, with distance of {2}:'
              .format(i, movie_features_df.index[indices.flatten()[i]],
                      distances.flatten()[i]))

```

Answer 1

m0_56062032 下午好🌅🌅🌅
本答案参考ChatGPT-3.5

根据你的问题，你想评估knn电影推荐算法的准确率、召回率和F1值。评估knn算法的准确率、召回率和F1值需要有样本的真实标签作为对比，然而在我们的示例代码中，并没有提供电影的真实评分标签。因此，我们需要修改代码来评估算法的准确率、召回率和F1值。

以下是解决方案：

1. 获取真实的电影评分标签数据集：为了评估算法的准确率、召回率和F1值，你需要准备一个包含电影真实评分标签的数据集。这可以是从 Internet 或其他来源获取的电影评分数据集。

2. 将数据集划分为训练集和测试集：根据获取的数据集，你需要将数据集划分为训练集和测试集。训练集用于训练knn算法，并找到电影之间的相似度。测试集用于评估knn算法的预测准确性。

3. 修改knn算法的推荐逻辑：根据电影之间的相似度，修改knn算法的推荐逻辑，使其能够根据用户的历史评分推荐电影。

4. 计算预测准确率、召回率和F1值：使用测试集中的真实标签与knn算法预测的标签进行比较，计算预测准确率、召回率和F1值。准确率可以通过计算预测正确的电影数量与总预测电影数量的比例来获得。召回率可以通过计算预测正确的电影数量与测试集中实际电影数量的比例来获得。F1值可以通过准确率和召回率的加权平均值来获得。

以下是修改后的代码示例：

# 导入必要的库
from sklearn.metrics import classification_report

# 创建训练集和测试集
train_data = movie_features_df.iloc[:100]  # 假设训练集包含前100个电影
test_data = movie_features_df.iloc[100:]  # 假设测试集包含剩余的电影

# 训练knn模型
model_knn.fit(train_data)

# 根据训练的模型预测测试集中的电影评分
predicted_ratings = []
for i in range(len(test_data)):
    distances, indices = model_knn.kneighbors(test_data.iloc[i,:].values.reshape(1, -1),
                                              n_neighbors = 6)
    # 根据电影之间的相似度预测电影评分
    predicted_rating = np.mean(train_data.iloc[indices.flatten(), :].values)
    predicted_ratings.append(predicted_rating)

# 对比预测值和真实值，计算准确率、召回率和F1值
true_ratings = test_data.values
predicted_ratings = np.asarray(predicted_ratings)
predicted_ratings = np.reshape(predicted_ratings, true_ratings.shape)

print(classification_report(true_ratings.flatten(), predicted_ratings.flatten()))

请注意，上述代码仅供参考，你可能需要根据你的数据集和具体需求进行调整和修改。