Python实现音乐推荐系统【跟着迪哥学python】
2024-04-24 14:59:09
Python实现音乐推荐系统
文章目录
- Python实现音乐推荐系统
- 推荐系统
- 数据读取
- 对每一个用户，分别统计他的播放总量
- 对于每一首歌，分别统计它的播放总量
- 看看目前的排行情况
- 取其中一部分数（按大小排好序的了，这些应该是比较重要的数据），作为我们的实验数据
- 加入音乐详细信息
- 我们现有的数据
- 清洗数据集
- 展示最流行的歌曲
- 最受欢迎的releases
- 最受欢迎的歌手
- 用户播放过歌曲量的分布
- 开始构建推荐系统
- 简单暴力，排行榜单推荐，对新用户来说解决冷启动问题
- 基于歌曲相似度的推荐
- 计算相似度得到推荐结果
- 基于矩阵分解（SVD）的推荐
- 使用SVD方法来进行矩阵分解
推荐系统
首先对音乐数据集进行数据清洗和特征提取，基于矩阵分解方式来进行音乐推荐。
- 音乐数据处理
读取音乐数据集，并统计其各项指标，选择有价值的信息当做我们的特征
- 基于商品相似性的推荐
选择相似度计算方法，通过相似度来计算推荐结果
- 基于SVD矩阵分解的推荐
使用矩阵分解方法，快速高效得到推荐结果
import pandas as pd
import numpy as np
import time
import sqlite3data_home = './'
我们的数据中有一部分是数据库文件，使用sqlite3工具包来帮助我们进行数据的读取，关于数据的路径这个大家可以根据自己情况来设置。
先来看一下我们的数据长什么样子吧，对于不同格式的数据read_csv有很多参数可以来选择，例如分隔符与列名：
数据读取
在数据中只需要用户，歌曲，播放量
triplet_dataset = pd.read_csv(filepath_or_buffer=data_home+'train_triplets.txt', sep='\t', header=None, names=['user','song','play_count'])
数据规模还是蛮大的
triplet_dataset.shape
(48373586, 3)
数据占用内存与各指标格式
triplet_dataset.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 48373586 entries, 0 to 48373585
Data columns (total 3 columns):
user object
song object
play_count int64
dtypes: int64(1), object(2)
memory usage: 1.1+ GB
如果想更详细的了解数据的情况，可以打印其info信息，来观察不同列的类型以及整体占用内存，这里教大家一个比较实用的技巧，如果拿到的数据非常大，对数据进行处理的时候可能会出现内存溢出的错误，这里最简单的方法就是设置下数据个格式，比如将float64用float32来替代，这样可以大大节省内存开销。
原始数据
triplet_dataset.head(n=10)
| user | song | play_count | |
|---|---|---|---|
| 0 | b80344d063b5ccb3212f76538f3d9e43d87dca9e | SOAKIMP12A8C130995 | 1 |
| 1 | b80344d063b5ccb3212f76538f3d9e43d87dca9e | SOAPDEY12A81C210A9 | 1 |
| 2 | b80344d063b5ccb3212f76538f3d9e43d87dca9e | SOBBMDR12A8C13253B | 2 |
| 3 | b80344d063b5ccb3212f76538f3d9e43d87dca9e | SOBFNSP12AF72A0E22 | 1 |
| 4 | b80344d063b5ccb3212f76538f3d9e43d87dca9e | SOBFOVM12A58A7D494 | 1 |
| 5 | b80344d063b5ccb3212f76538f3d9e43d87dca9e | SOBNZDC12A6D4FC103 | 1 |
| 6 | b80344d063b5ccb3212f76538f3d9e43d87dca9e | SOBSUJE12A6D4F8CF5 | 2 |
| 7 | b80344d063b5ccb3212f76538f3d9e43d87dca9e | SOBVFZR12A6D4F8AE3 | 1 |
| 8 | b80344d063b5ccb3212f76538f3d9e43d87dca9e | SOBXALG12A8C13C108 | 1 |
| 9 | b80344d063b5ccb3212f76538f3d9e43d87dca9e | SOBXHDL12A81C204C0 | 1 |
对每一个用户，分别统计他的播放总量
数据中有用户的编号，歌曲编号，已经用户对该歌曲播放的次数。
有了基础数据之后，我们还可以统计出关于用户与歌曲的各项指标，例如对每一个用户，分别统计他的播放总量，代码如下：
output_dict = {}
with open(data_home+'train_triplets.txt') as f:for line_number, line in enumerate(f):#找到当前的用户user = line.split('\t')[0]#得到其播放量数据play_count = int(line.split('\t')[2])#如果字典中已经有该用户信息，在其基础上增加当前的播放量if user in output_dict:play_count +=output_dict[user]output_dict.update({user:play_count})output_dict.update({user:play_count})
# 统计 用户-总播放量
output_list = [{'user':k,'play_count':v} for k,v in output_dict.items()]
#转换成DF格式
play_count_df = pd.DataFrame(output_list)
#排序
play_count_df = play_count_df.sort_values(by = 'play_count', ascending = False)
构建一个字典结构来统计不同用户分别播放的总数，这需要我们把数据集遍历一遍。当我们的数据集比较庞大的时候，每一步操作都可能花费较长时间，后续操作中如果稍有不慎可能还得重头再来一遍，这就得不偿失了，最好还是把中间结果保存下来，既然我们已经把结果转换成df格式，直接使用to_csv()函数就可以完成保存的操作。
play_count_df.to_csv(path_or_buf='user_playcount_df.csv', index = False)
对于每一首歌，分别统计它的播放总量
#统计方法跟上述类似
output_dict = {}
with open(data_home+'train_triplets.txt') as f:for line_number, line in enumerate(f):#找到当前歌曲song = line.split('\t')[1]#找到当前播放次数play_count = int(line.split('\t')[2])#统计每首歌曲被播放的总次数if song in output_dict:play_count +=output_dict[song]output_dict.update({song:play_count})output_dict.update({song:play_count})
output_list = [{'song':k,'play_count':v} for k,v in output_dict.items()]
#转换成df格式
song_count_df = pd.DataFrame(output_list)
song_count_df = song_count_df.sort_values(by = 'play_count', ascending = False)
song_count_df.to_csv(path_or_buf='song_playcount_df.csv', index = False)
看看目前的排行情况
play_count_df = pd.read_csv(filepath_or_buffer='user_playcount_df.csv')
play_count_df.head(n =10)
| play_count | user | |
|---|---|---|
| 0 | 13132 | 093cb74eb3c517c5179ae24caf0ebec51b24d2a2 |
| 1 | 9884 | 119b7c88d58d0c6eb051365c103da5caf817bea6 |
| 2 | 8210 | 3fa44653315697f42410a30cb766a4eb102080bb |
| 3 | 7015 | a2679496cd0af9779a92a13ff7c6af5c81ea8c7b |
| 4 | 6494 | d7d2d888ae04d16e994d6964214a1de81392ee04 |
| 5 | 6472 | 4ae01afa8f2430ea0704d502bc7b57fb52164882 |
| 6 | 6150 | b7c24f770be6b802805ac0e2106624a517643c17 |
| 7 | 5656 | 113255a012b2affeab62607563d03fbdf31b08e7 |
| 8 | 5620 | 6d625c6557df84b60d90426c0116138b617b9449 |
| 9 | 5602 | 99ac3d883681e21ea68071019dba828ce76fe94d |
song_count_df = pd.read_csv(filepath_or_buffer='song_playcount_df.csv')
song_count_df.head(10)
| play_count | song | |
|---|---|---|
| 0 | 726885 | SOBONKR12A58A7A7E0 |
| 1 | 648239 | SOAUWYT12A81C206F1 |
| 2 | 527893 | SOSXLTC12AF72A7F54 |
| 3 | 425463 | SOFRQTD12A81C233C0 |
| 4 | 389880 | SOEGIYH12A6D4FC0E3 |
| 5 | 356533 | SOAXGDH12A8C13F8A1 |
| 6 | 292642 | SONYKOW12AB01849C9 |
| 7 | 274627 | SOPUCYA12A8C13A694 |
| 8 | 268353 | SOUFTBI12AB0183F65 |
| 9 | 244730 | SOVDSJC12A58A7A271 |
最受欢迎的一首歌曲有726885次播放。
刚才大家也看到了，这个音乐数据量集十分庞大，考虑到执行过程的时间消耗以及矩阵稀疏性问题，我们依据播放量指标对数据集进行了截取。因为有些注册用户可能只是关注了一下之后就不再登录平台，这些用户对我们建模不会起促进作用，反而增大了矩阵的稀疏性。对于歌曲也是同理，可能有些歌曲根本无人问津。由于之前已经对用户与歌曲播放情况进行了排序，所以我们分别选择了其中的10W名用户和3W首歌曲，关于截取的合适比例大家也可以通过观察选择数据的播放量占总体的比例来设置。
取其中一部分数（按大小排好序的了，这些应该是比较重要的数据），作为我们的实验数据
#10W名用户的播放量占总体的比例
total_play_count = sum(song_count_df.play_count)
print ((float(play_count_df.head(n=100000).play_count.sum())/total_play_count)*100)
play_count_subset = play_count_df.head(n=100000)
40.8807280500655
(float(song_count_df.head(n=30000).play_count.sum())/total_play_count)*100
78.39315366645269
song_count_subset = song_count_df.head(n=30000)
前3W首歌的播放量占到了总体的78.39%
现在已经有了这10W名忠实用户和3W首经典歌曲，接下来我们就要对原始数据集进行过滤清洗，说白了就是在原始数据集中剔除掉不包含这些用户以及歌曲的数据。
取10W个用户，3W首歌
user_subset = list(play_count_subset.user)
song_subset = list(song_count_subset.song)
过滤掉其他用户数据
#读取原始数据集
triplet_dataset = pd.read_csv(filepath_or_buffer=data_home+'train_triplets.txt',sep='\t', header=None, names=['user','song','play_count'])
#只保留有这10W名用户的数据，其余过滤掉
triplet_dataset_sub = triplet_dataset[triplet_dataset.user.isin(user_subset) ]
del(triplet_dataset)
#只保留有这3W首歌曲的数据，其余也过滤掉
triplet_dataset_sub_song = triplet_dataset_sub[triplet_dataset_sub.song.isin(song_subset)]
del(triplet_dataset_sub)
triplet_dataset_sub_song.to_csv(path_or_buf=data_home+'triplet_dataset_sub_song.csv', index=False)
当前我们的数据量
triplet_dataset_sub_song.shape
(10774558, 3)
数据样本个数此时只有原来的1/4不到，但是我们过滤掉的样本都是稀疏数据不利于建模，所以当拿到了数据之后对数据进行清洗和预处理工作还是非常有必要的，不单单提升计算的速度，还会影响最终的结果。
triplet_dataset_sub_song.head(n=10)
| user | song | play_count | |
|---|---|---|---|
| 498 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOADQPP12A67020C82 | 12 |
| 499 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOAFTRR12AF72A8D4D | 1 |
| 500 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOANQFY12AB0183239 | 1 |
| 501 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOAYATB12A6701FD50 | 1 |
| 502 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOBOAFP12A8C131F36 | 7 |
| 503 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOBONKR12A58A7A7E0 | 26 |
| 504 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOBZZDU12A6310D8A3 | 7 |
| 505 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOCAHRT12A8C13A1A4 | 5 |
| 506 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SODASIJ12A6D4F5D89 | 1 |
| 507 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SODEAWL12AB0187032 | 8 |
加入音乐详细信息
我们目前拿到的数据只有播放次数，可利用的信息实在太少了，对每首歌来说正常情况都应该有一份详细信息，例如歌手，发布时间，主题等，这些信息都存在一份数据库格式文件中，接下来我们就通过sqlite工具包来读取这些数据：
conn = sqlite3.connect(data_home+'track_metadata.db')
cur = conn.cursor()
cur.execute("SELECT name FROM sqlite_master WHERE type='table'")
cur.fetchall()
[('songs',)]
track_metadata_df = pd.read_sql(con=conn, sql='select * from songs')
track_metadata_df_sub = track_metadata_df[track_metadata_df.song_id.isin(song_subset)]
track_metadata_df_sub.to_csv(path_or_buf=data_home+'track_metadata_df_sub.csv', index=False)
track_metadata_df_sub.shape
(30447, 14)
我们现有的数据
triplet_dataset_sub_song = pd.read_csv(filepath_or_buffer=data_home+'triplet_dataset_sub_song.csv',encoding = "ISO-8859-1")
track_metadata_df_sub = pd.read_csv(filepath_or_buffer=data_home+'track_metadata_df_sub.csv',encoding = "ISO-8859-1")
triplet_dataset_sub_song.head()
| user | song | play_count | |
|---|---|---|---|
| 0 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOADQPP12A67020C82 | 12 |
| 1 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOAFTRR12AF72A8D4D | 1 |
| 2 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOANQFY12AB0183239 | 1 |
| 3 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOAYATB12A6701FD50 | 1 |
| 4 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOBOAFP12A8C131F36 | 7 |
track_metadata_df_sub.head()
| track_id | title | song_id | release | artist_id | artist_mbid | artist_name | duration | artist_familiarity | artist_hotttnesss | year | track_7digitalid | shs_perf | shs_work | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | TRMMGCB128E079651D | Get Along (Feat: Pace Won) (Instrumental) | SOHNWIM12A67ADF7D9 | Charango | ARU3C671187FB3F71B | 067102ea-9519-4622-9077-57ca4164cfbb | Morcheeba | 227.47383 | 0.819087 | 0.533117 | 2002 | 185967 | -1 | 0 |
| 1 | TRMMGTX128F92FB4D9 | Viejo | SOECFIW12A8C144546 | Caraluna | ARPAAPH1187FB3601B | f69d655c-ffd6-4bee-8c2a-3086b2be2fc6 | Bacilos | 307.51302 | 0.595554 | 0.400705 | 0 | 6825058 | -1 | 0 |
| 2 | TRMMGDP128F933E59A | I Say A Little Prayer | SOGWEOB12AB018A4D0 | The Legendary Hi Records Albums_ Volume 3: Ful... | ARNNRN31187B9AE7B7 | fb7272ba-f130-4f0a-934d-6eeea4c18c9a | Al Green | 133.58975 | 0.779490 | 0.599210 | 1978 | 5211723 | -1 | 11898 |
| 3 | TRMMHBF12903CF6E59 | At the Ball_ That's All | SOJGCRL12A8C144187 | Best of Laurel & Hardy - The Lonesome Pine | AR1FEUF1187B9AF3E3 | 4a8ae4fd-ad6f-4912-851f-093f12ee3572 | Laurel & Hardy | 123.71546 | 0.438709 | 0.307120 | 0 | 8645877 | -1 | 0 |
| 4 | TRMMHKG12903CDB1B5 | Black Gold | SOHNFBA12AB018CD1D | Total Life Forever | ARVXV1J1187FB5BF88 | 6a65d878-fcd0-42cf-aff9-ca1d636a8bcc | Foals | 386.32444 | 0.842578 | 0.514523 | 2010 | 9007438 | -1 | 0 |
清洗数据集
去除掉无用的和重复的，数据清洗是很重要的一步
# 去掉无用的信息
del(track_metadata_df_sub['track_id'])
del(track_metadata_df_sub['artist_mbid'])
# 去掉重复的
track_metadata_df_sub = track_metadata_df_sub.drop_duplicates(['song_id'])
# 将这份音乐信息数据和我们之前的播放数据整合到一起
triplet_dataset_sub_song_merged = pd.merge(triplet_dataset_sub_song, track_metadata_df_sub, how='left', left_on='song', right_on='song_id')
# 可以自己改变列名
triplet_dataset_sub_song_merged.rename(columns={'play_count':'listen_count'},inplace=True)
# 去掉不需要的指标
del(triplet_dataset_sub_song_merged['song_id'])
del(triplet_dataset_sub_song_merged['artist_id'])
del(triplet_dataset_sub_song_merged['duration'])
del(triplet_dataset_sub_song_merged['artist_familiarity'])
del(triplet_dataset_sub_song_merged['artist_hotttnesss'])
del(triplet_dataset_sub_song_merged['track_7digitalid'])
del(triplet_dataset_sub_song_merged['shs_perf'])
del(triplet_dataset_sub_song_merged['shs_work'])
搞定数据，来看看它长什么样子吧
triplet_dataset_sub_song_merged.head(n=10)
| user | song | listen_count | title | release | artist_name | year | |
|---|---|---|---|---|---|---|---|
| 0 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOADQPP12A67020C82 | 12 | You And Me Jesus | Tribute To Jake Hess | Jake Hess | 2004 |
| 1 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOAFTRR12AF72A8D4D | 1 | Harder Better Faster Stronger | Discovery | Daft Punk | 2007 |
| 2 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOANQFY12AB0183239 | 1 | Uprising | Uprising | Muse | 0 |
| 3 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOAYATB12A6701FD50 | 1 | Breakfast At Tiffany's | Home | Deep Blue Something | 1993 |
| 4 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOBOAFP12A8C131F36 | 7 | Lucky (Album Version) | We Sing. We Dance. We Steal Things. | Jason Mraz & Colbie Caillat | 0 |
| 5 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOBONKR12A58A7A7E0 | 26 | You're The One | If There Was A Way | Dwight Yoakam | 1990 |
| 6 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOBZZDU12A6310D8A3 | 7 | Don't Dream It's Over | Recurring Dream_ Best Of Crowded House (Domest... | Crowded House | 1986 |
| 7 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOCAHRT12A8C13A1A4 | 5 | S.O.S. | SOS | Jonas Brothers | 2007 |
| 8 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SODASIJ12A6D4F5D89 | 1 | The Invisible Man | The Invisible Man | Michael Cretu | 1985 |
| 9 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SODEAWL12AB0187032 | 8 | American Idiot [feat. Green Day & The Cast Of ... | The Original Broadway Cast Recording 'American... | Green Day | 0 |
现在的数据看起来工整多了，不光有用户对某个音乐作品的播放量，还有该音乐作品的名字和发布专辑，以及作者名字和发布时间。
现在我们只是大体了解了数据中各个指标的含义，对其具体内容还没有加以分析，我们在之前介绍推荐系统的时候提到过冷启动问题，就是一个新用户来了不知道给他推荐什么好，这时候就可以利用排行榜单了。可以统计最受欢迎的歌曲和歌手是哪些：
展示最流行的歌曲
import matplotlib.pyplot as plt; plt.rcdefaults()
import numpy as np
import matplotlib.pyplot as plt
#按歌曲名字来统计其播放量的总数
popular_songs = triplet_dataset_sub_song_merged[['title','listen_count']].groupby('title').sum().reset_index()
#对结果进行排序
popular_songs_top_20 = popular_songs.sort_values('listen_count', ascending=False).head(n=20)#转换成list格式方便画图
objects = (list(popular_songs_top_20['title']))
#设置位置
y_pos = np.arange(len(objects))
#对应结果值
performance = list(popular_songs_top_20['listen_count'])
#绘图
plt.bar(y_pos, performance, align='center', alpha=0.5)
plt.xticks(y_pos, objects, rotation='vertical')
plt.ylabel('Item count')
plt.title('Most popular songs')plt.show()
这里展示了最受欢迎的歌曲，使用groupby函数可以很方便的对每首歌曲统计其播放情况，我们求的是总和也就是总播放量。这份排行数据就可以当做最受欢迎歌曲来推荐给用户了。
同样的方法我们还可以对专辑和歌手的播放情况分别进行统计：
最受欢迎的releases
#按专辑名字来统计播放总量
popular_release = triplet_dataset_sub_song_merged[['release','listen_count']].groupby('release').sum().reset_index()
#排序
popular_release_top_20 = popular_release.sort_values('listen_count', ascending=False).head(n=20)objects = (list(popular_release_top_20['release']))
y_pos = np.arange(len(objects))
performance = list(popular_release_top_20['listen_count'])
#绘图
plt.bar(y_pos, performance, align='center', alpha=0.5)
plt.xticks(y_pos, objects, rotation='vertical')
plt.ylabel('Item count')
plt.title('Most popular Release')plt.show()
最受欢迎的歌手
#按歌手来统计其播放总量
popular_artist = triplet_dataset_sub_song_merged[['artist_name','listen_count']].groupby('artist_name').sum().reset_index()
#排序
popular_artist_top_20 = popular_artist.sort_values('listen_count', ascending=False).head(n=20)objects = (list(popular_artist_top_20['artist_name']))
y_pos = np.arange(len(objects))
performance = list(popular_artist_top_20['listen_count'])
#绘图
plt.bar(y_pos, performance, align='center', alpha=0.5)
plt.xticks(y_pos, objects, rotation='vertical')
plt.ylabel('Item count')
plt.title('Most popular Artists')plt.show()
用户播放过歌曲量的分布
user_song_count_distribution = triplet_dataset_sub_song_merged[['user','title']].groupby('user').count().reset_index().sort_values(
by='title',ascending = False)
user_song_count_distribution.title.describe()
count 99996.000000
mean 107.749890
std 79.742561
min 1.000000
25% 53.000000
50% 89.000000
75% 141.000000
max 1189.000000
Name: title, dtype: float64
x = user_song_count_distribution.title
n, bins, patches = plt.hist(x, 50, facecolor='green', alpha=0.75)
plt.xlabel('Play Counts')
plt.ylabel('Num of Users')
plt.title(r'$\mathrm{Histogram\ of\ User\ Play\ Count\ Distribution}\ $')
plt.grid(True)
plt.show()
绝大多数用户播放歌曲的数量在100左右，关于数据的处理和介绍已经给大家都分析过了，接下来我们要做的就是构建一个能实际进行推荐的程序了。
开始构建推荐系统
import Recommenders as Recommenders
from sklearn.model_selection import train_test_split
简单暴力，排行榜单推荐，对新用户来说解决冷启动问题
最简单的推荐方式就是排行榜单了，这里我们创建了一个函数，需要我们传入的是原始数据，用户列名，待统计的指标（例如按歌曲名字，歌手名字，专辑名字。选择统计哪项指标得到的排行榜单）：
triplet_dataset_sub_song_merged_set = triplet_dataset_sub_song_merged
train_data, test_data = train_test_split(triplet_dataset_sub_song_merged_set, test_size = 0.40, random_state=0)
train_data.head()
| user | song | listen_count | title | release | artist_name | year | |
|---|---|---|---|---|---|---|---|
| 1901799 | 28866ea8a809d5d46273cd0989c5515c660ef8c7 | SOEYVHS12AB0181D31 | 1 | Monster | The Fame Monster | Lady GaGa | 2009 |
| 4815185 | c9608a24a2a40e0ec38993a70532e7bb56eff22b | SOKIYKQ12A8AE464FC | 2 | Fight For Your Life | Made In NYC | The Casualties | 2000 |
| 10513026 | 24f0b09c133a6a0fe42f097734215dceb468d449 | SOETFVO12AB018DFF3 | 1 | Free Style (feat. Kevo_ Mussilini & Lyrical 187) | A Bad Azz Mix Tape | Z-RO | 0 |
| 2659073 | 4da3c59a0af73245cea000fd5efa30384182bfcb | SOAXJOU12A6D4F6685 | 1 | Littlest Things | Alright_ Still | Lily Allen | 2006 |
| 5506263 | b46c5ed385cad7ecea8af6214f440d19de6eb6c2 | SOXBCAY12AB0189EE0 | 1 | La trama y el desenlace | Amar la trama | Jorge Drexler | 2010 |
def create_popularity_recommendation(train_data, user_id, item_id):#根据指定的特征来统计其播放情况，可以选择歌曲名，专辑名，歌手名train_data_grouped = train_data.groupby([item_id]).agg({user_id: 'count'}).reset_index()#为了直观展示，我们用得分来表示其结果train_data_grouped.rename(columns = {user_id: 'score'},inplace=True)#排行榜单需要排序train_data_sort = train_data_grouped.sort_values(['score', item_id], ascending = [0,1])#加入一项排行等级，表示其推荐的优先级train_data_sort['Rank'] = train_data_sort['score'].rank(ascending=0, method='first')#返回指定个数的推荐结果popularity_recommendations = train_data_sort.head(20)return popularity_recommendations
recommendations = create_popularity_recommendation(triplet_dataset_sub_song_merged,'user','title')
得到推荐结果
recommendations
| title | score | Rank | |
|---|---|---|---|
| 19580 | Sehr kosmisch | 18626 | 1.0 |
| 5780 | Dog Days Are Over (Radio Edit) | 17635 | 2.0 |
| 27314 | You're The One | 16085 | 3.0 |
| 19542 | Secrets | 15138 | 4.0 |
| 18636 | Revelry | 14945 | 5.0 |
| 25070 | Undo | 14687 | 6.0 |
| 7530 | Fireflies | 13085 | 7.0 |
| 9640 | Hey_ Soul Sister | 12993 | 8.0 |
| 25216 | Use Somebody | 12793 | 9.0 |
| 9921 | Horn Concerto No. 4 in E flat K495: II. Romanc... | 12346 | 10.0 |
| 24291 | Tive Sim | 11831 | 11.0 |
| 3629 | Canada | 11598 | 12.0 |
| 23468 | The Scientist | 11529 | 13.0 |
| 4194 | Clocks | 11357 | 14.0 |
| 12135 | Just Dance | 11058 | 15.0 |
| 26974 | Yellow | 10919 | 16.0 |
| 16438 | OMG | 10818 | 17.0 |
| 9844 | Home | 10512 | 18.0 |
| 3295 | Bulletproof | 10383 | 19.0 |
| 4760 | Creep (Explicit) | 10246 | 20.0 |
返回了一份前20的歌曲排行榜单，其中的得分这里只是进行了简单的播放计算，在设计的时候也可以综合考虑更多的指标，比如综合计算歌曲发布年份，歌手的流行程度等。
基于歌曲相似度的推荐
接下来就要进行相似度的计算来推荐歌曲了，为了加快代码的运行速度，选择了其中一部分数据来进行实验。
song_count_subset = song_count_df.head(n=5000)
user_subset = list(play_count_subset.user)
song_subset = list(song_count_subset.song)
triplet_dataset_sub_song_merged_sub = triplet_dataset_sub_song_merged[triplet_dataset_sub_song_merged.song.isin(song_subset)]
triplet_dataset_sub_song_merged_sub.head()
| user | song | listen_count | title | release | artist_name | year | |
|---|---|---|---|---|---|---|---|
| 0 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOADQPP12A67020C82 | 12 | You And Me Jesus | Tribute To Jake Hess | Jake Hess | 2004 |
| 1 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOAFTRR12AF72A8D4D | 1 | Harder Better Faster Stronger | Discovery | Daft Punk | 2007 |
| 2 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOANQFY12AB0183239 | 1 | Uprising | Uprising | Muse | 0 |
| 3 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOAYATB12A6701FD50 | 1 | Breakfast At Tiffany's | Home | Deep Blue Something | 1993 |
| 4 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOBOAFP12A8C131F36 | 7 | Lucky (Album Version) | We Sing. We Dance. We Steal Things. | Jason Mraz & Colbie Caillat | 0 |
计算相似度得到推荐结果
import Recommenders as Recommenders
train_data, test_data = train_test_split(triplet_dataset_sub_song_merged_sub, test_size = 0.30, random_state=0)
is_model = Recommenders.item_similarity_recommender_py()
is_model.create(train_data, 'user', 'title')
user_id = list(train_data.user)[7]
user_items = is_model.get_user_items(user_id)
心的同学应该观察到了，我们首先导入了Recommenders，像是一个自定义的工具包，这里就包括了我们接下来要使用的所有函数，由于接下来进行计算的代码量较大，直接在notebook中进行展示比较麻烦，所有我们自己写了一个.py文件，所有的实际计算操作都在这里完成了。
大家在实践这份代码的时候，可以选择一个合适的IDE，因为notebook并不支持debug操作。拿到了一份陌生的代码而且量又比较大的时候，最好先通过debug的方式一行代码一行代码来执行，这样可以更清晰的熟悉整个函数做了一件什么事，如果直接看整体对于初学的同学们来说可能会有点难度，建议大家选择一个趁手的IDE例如pycharm,eclipse等都是不错的。
整体的代码量还是比较多，我先从整体上介绍这段代码做了一件什么事，大家在自己玩的时候最好按照我之前说的还是debug一遍更舒服。首先我们要针对某一个用户进行推荐，那必然得先得到他都听过哪些歌曲，通过这些已被听过的歌曲跟整个数据集中的歌曲进行对比，看哪些歌曲跟用户已听过的比较类似，推荐的就是这些类似的。如何计算呢？例如当前用户听过了66首歌曲，整个数据集中有4879个歌曲，我们要做的就是构建一个[66,4879]的矩阵，其中每一个值表示用户听过的每一个歌曲和数据集中每一个歌曲的相似度。这里使用Jaccard相似系数，矩阵中[i,j]的含义就是用户听过的第i首歌曲这些歌曲被哪些人听过，比如有3000人听过，数据集中的j歌曲被哪些人听过，比如有5000人听过。Jaccard相似系数就要求：
说白了就是如果两个歌曲很相似，那其受众应当是一致的，交集/并集的比例应该比较大，如果两个歌曲没啥相关性，其值应当就比较小了。
上述代码中计算了矩阵[66,4879]中每一个位置的值应当是多少，在最后推荐的时候我们还应当注意一件事对于数据集中每一个待推荐的歌曲都需要跟该用户所有听过的歌曲计算其Jaccard值，例如歌曲j需要跟用户听过的66个歌曲计算其值，最终是否推荐的得分值还得进行处理，即把这66个值加在一起，最终求一个平均值，来代表该歌曲的推荐得分。
#执行推荐
is_model.recommend(user_id)
No. of unique songs for the user: 66
no. of unique songs in the training set: 4879
Non zero values in cooccurence_matrix :290327
| user_id | song | score | rank | |
|---|---|---|---|---|
| 0 | a974fc428825ed071281302d6976f59bfa95fe7e | Put Your Head On My Shoulder (Album Version) | 0.026334 | 1 |
| 1 | a974fc428825ed071281302d6976f59bfa95fe7e | The Strength To Go On | 0.025176 | 2 |
| 2 | a974fc428825ed071281302d6976f59bfa95fe7e | Come Fly With Me (Album Version) | 0.024447 | 3 |
| 3 | a974fc428825ed071281302d6976f59bfa95fe7e | Moondance (Album Version) | 0.024118 | 4 |
| 4 | a974fc428825ed071281302d6976f59bfa95fe7e | Kotov Syndrome | 0.023311 | 5 |
| 5 | a974fc428825ed071281302d6976f59bfa95fe7e | Use Somebody | 0.023104 | 6 |
| 6 | a974fc428825ed071281302d6976f59bfa95fe7e | Lucky (Album Version) | 0.022930 | 7 |
| 7 | a974fc428825ed071281302d6976f59bfa95fe7e | Secrets | 0.022889 | 8 |
| 8 | a974fc428825ed071281302d6976f59bfa95fe7e | Clocks | 0.022562 | 9 |
| 9 | a974fc428825ed071281302d6976f59bfa95fe7e | Sway (Album Version) | 0.022359 | 10 |
基于矩阵分解（SVD）的推荐
相似度计算的方法看起来比较简单就是实现出来，但是当数据较大的时候计算的时间消耗实在太大了，对每一个用户都需要多次遍历整个数据集来进行计算，矩阵分解的方法是当下更常使用的方法。
奇异值分解(Singular Value Decomposition，SVD)是矩阵分解中一个经典方法，接下来我们的推荐就可以SVD来进行计算，奇异值分解的基本出发点跟我们之前讲的隐语义模型有些类似都是将大矩阵转换成小矩阵的组合,基本形式如下图所示：
对矩阵进行SVD分解，将得到USV
重新计算 USV的结果得到A2 来比较下A2和A的差异，看起来差异是有的，但是并不大，所以我们可以近似来代替
在SVD中我们所需的数据是用户对商品的打分，但是我们现在的数据集中只有用户播放歌曲的情况并没有实际的打分值，所以我们还得自己来定义一下用户对每个歌曲的评分值。如果一个用户喜欢某个歌曲，那应该经常播放这个歌曲，相反如果不喜欢某个歌曲，那播放次数肯定就比较少了。
用户对歌曲的打分值，定义为：用户播放该歌曲数量/该用户播放总量。代码如下：
triplet_dataset_sub_song_merged_sum_df = triplet_dataset_sub_song_merged[['user','listen_count']].groupby('user').sum().reset_index()
triplet_dataset_sub_song_merged_sum_df.rename(columns={'listen_count':'total_listen_count'},inplace=True)
triplet_dataset_sub_song_merged = pd.merge(triplet_dataset_sub_song_merged,triplet_dataset_sub_song_merged_sum_df)
triplet_dataset_sub_song_merged.head()
| user | song | listen_count | title | release | artist_name | year | total_listen_count | |
|---|---|---|---|---|---|---|---|---|
| 0 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOADQPP12A67020C82 | 12 | You And Me Jesus | Tribute To Jake Hess | Jake Hess | 2004 | 329 |
| 1 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOAFTRR12AF72A8D4D | 1 | Harder Better Faster Stronger | Discovery | Daft Punk | 2007 | 329 |
| 2 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOANQFY12AB0183239 | 1 | Uprising | Uprising | Muse | 0 | 329 |
| 3 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOAYATB12A6701FD50 | 1 | Breakfast At Tiffany's | Home | Deep Blue Something | 1993 | 329 |
| 4 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOBOAFP12A8C131F36 | 7 | Lucky (Album Version) | We Sing. We Dance. We Steal Things. | Jason Mraz & Colbie Caillat | 0 | 329 |
triplet_dataset_sub_song_merged['fractional_play_count'] = triplet_dataset_sub_song_merged['listen_count']/triplet_dataset_sub_song_merged['total_listen_count']
大概是这样
triplet_dataset_sub_song_merged[triplet_dataset_sub_song_merged.user =='d6589314c0a9bcbca4fee0c93b14bc402363afea'][['user','song','listen_count','fractional_play_count']].head()
| user | song | listen_count | fractional_play_count | |
|---|---|---|---|---|
| 0 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOADQPP12A67020C82 | 12 | 0.036474 |
| 1 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOAFTRR12AF72A8D4D | 1 | 0.003040 |
| 2 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOANQFY12AB0183239 | 1 | 0.003040 |
| 3 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOAYATB12A6701FD50 | 1 | 0.003040 |
| 4 | d6589314c0a9bcbca4fee0c93b14bc402363afea | SOBOAFP12A8C131F36 | 7 | 0.021277 |
from scipy.sparse import coo_matrixsmall_set = triplet_dataset_sub_song_merged
user_codes = small_set.user.drop_duplicates().reset_index()
song_codes = small_set.song.drop_duplicates().reset_index()
user_codes.rename(columns={'index':'user_index'}, inplace=True)
song_codes.rename(columns={'index':'song_index'}, inplace=True)
song_codes['so_index_value'] = list(song_codes.index)
user_codes['us_index_value'] = list(user_codes.index)
small_set = pd.merge(small_set,song_codes,how='left')
small_set = pd.merge(small_set,user_codes,how='left')
mat_candidate = small_set[['us_index_value','so_index_value','fractional_play_count']]
data_array = mat_candidate.fractional_play_count.values
row_array = mat_candidate.us_index_value.values
col_array = mat_candidate.so_index_value.valuesdata_sparse = coo_matrix((data_array, (row_array, col_array)),dtype=float)
data_sparse
<99996x30000 sparse matrix of type '<class 'numpy.float64'>'with 10774558 stored elements in COOrdinate format>
上面代码先根据用户进行分组，计算每个用户的总的播放总量，然后用每首歌的播放总量相处，得到每首歌的分值，最后一列特征fractional_play_count就是用户对每首歌曲的评分值。
有了评分值之后就可以来构建矩阵了，这里有一些小问题需要处理一下，原始数据中无论是用户ID还是歌曲ID都是很长一串，这表达起来不太方便，需要重新对其制作索引。
user_codes[user_codes.user =='2a2f776cbac6df64d6cb505e7e834e01684673b6']
| user_index | user | us_index_value | |
|---|---|---|---|
| 27516 | 2981434 | 2a2f776cbac6df64d6cb505e7e834e01684673b6 | 27516 |
使用SVD方法来进行矩阵分解
矩阵构造好了之后我们就要执行SVD矩阵分解了，这里还需要一些额外的工具包来帮助我们完成计算，scipy就是其中一个好帮手了，里面已经封装好了SVD计算方法。
import math as mt
from scipy.sparse.linalg import * #used for matrix multiplication
from scipy.sparse.linalg import svds
from scipy.sparse import csc_matrix
def compute_svd(urm, K):U, s, Vt = svds(urm, K)dim = (len(s), len(s))S = np.zeros(dim, dtype=np.float32)for i in range(0, len(s)):S[i,i] = mt.sqrt(s[i])U = csc_matrix(U, dtype=np.float32)S = csc_matrix(S, dtype=np.float32)Vt = csc_matrix(Vt, dtype=np.float32)return U, S, Vtdef compute_estimated_matrix(urm, U, S, Vt, uTest, K, test):rightTerm = S*Vt max_recommendation = 250estimatedRatings = np.zeros(shape=(MAX_UID, MAX_PID), dtype=np.float16)recomendRatings = np.zeros(shape=(MAX_UID,max_recommendation ), dtype=np.float16)for userTest in uTest:prod = U[userTest, :]*rightTermestimatedRatings[userTest, :] = prod.todense()recomendRatings[userTest, :] = (-estimatedRatings[userTest, :]).argsort()[:max_recommendation]return recomendRatings
在执行SVD的时候需要我们额外指定一个指标K值，其含义就是我们选择前多少个特征值来做近似代表，也就是S矩阵中的数量。如果K值较大整体的计算效率会慢一些但是会更接近真实结果，这个值还需要我们自己来衡量一下。
K=50
urm = data_sparse
MAX_PID = urm.shape[1]
MAX_UID = urm.shape[0]U, S, Vt = compute_svd(urm, K)
这里我们选择K值等于50，其中PID表示我们最开始选择的部分歌曲，UID表示我们选择的部分用户。
执行过程中，可以打印出各个矩阵的大小，这里强烈建议大家将代码复制到IDE中，打上断点一行一行的走下面，观察其中每一个变量的值，这对理解整个流程是非常有帮助的。
接下来我们需要选择待测试用户了：
uTest = [4,5,6,7,8,873,23]
随便选择一些用户就好，这里表示用户的索引编号，接下来需要对每一个用户计算其对我们候选集中3W首歌曲的喜好程度，说白了就是估计他对这3W首歌的评分值应该等于多少，前面我们通过SVD矩阵分解已经计算所需各个小矩阵了，接下来把其还原回去就可以啦：
uTest = [4,5,6,7,8,873,23]uTest_recommended_items = compute_estimated_matrix(urm, U, S, Vt, uTest, K, True)
for user in uTest:print("当前待推荐用户编号 {}". format(user))rank_value = 1for i in uTest_recommended_items[user,0:10]:song_details = small_set[small_set.so_index_value == i].drop_duplicates('so_index_value')[['title','artist_name']]print("推荐编号： {} 推荐歌曲： {} 作者： {}".format(rank_value, list(song_details['title'])[0],list(song_details['artist_name'])[0]))rank_value+=1
当前待推荐用户编号 4
推荐编号： 1 推荐歌曲： Fireflies 作者： Charttraxx Karaoke
推荐编号： 2 推荐歌曲： Hey_ Soul Sister 作者： Train
推荐编号： 3 推荐歌曲： OMG 作者： Usher featuring will.i.am
推荐编号： 4 推荐歌曲： Lucky (Album Version) 作者： Jason Mraz & Colbie Caillat
推荐编号： 5 推荐歌曲： Vanilla Twilight 作者： Owl City
推荐编号： 6 推荐歌曲： Crumpshit 作者： Philippe Rochard
推荐编号： 7 推荐歌曲： Billionaire [feat. Bruno Mars] (Explicit Album Version) 作者： Travie McCoy
推荐编号： 8 推荐歌曲： Love Story 作者： Taylor Swift
推荐编号： 9 推荐歌曲： TULENLIEKKI 作者： M.A. Numminen
推荐编号： 10 推荐歌曲： Use Somebody 作者： Kings Of Leon
当前待推荐用户编号 5
推荐编号： 1 推荐歌曲： Sehr kosmisch 作者： Harmonia
推荐编号： 2 推荐歌曲： Ain't Misbehavin 作者： Sam Cooke
推荐编号： 3 推荐歌曲： Dog Days Are Over (Radio Edit) 作者： Florence + The Machine
推荐编号： 4 推荐歌曲： Revelry 作者： Kings Of Leon
推荐编号： 5 推荐歌曲： Undo 作者： Björk
推荐编号： 6 推荐歌曲： Cosmic Love 作者： Florence + The Machine
推荐编号： 7 推荐歌曲： Home 作者： Edward Sharpe & The Magnetic Zeros
推荐编号： 8 推荐歌曲： You've Got The Love 作者： Florence + The Machine
推荐编号： 9 推荐歌曲： Bring Me To Life 作者： Evanescence
推荐编号： 10 推荐歌曲： Tighten Up 作者： The Black Keys
当前待推荐用户编号 6
推荐编号： 1 推荐歌曲： Crumpshit 作者： Philippe Rochard
推荐编号： 2 推荐歌曲： Marry Me 作者： Train
推荐编号： 3 推荐歌曲： Hey_ Soul Sister 作者： Train
推荐编号： 4 推荐歌曲： Lucky (Album Version) 作者： Jason Mraz & Colbie Caillat
推荐编号： 5 推荐歌曲： One On One 作者： the bird and the bee
推荐编号： 6 推荐歌曲： I Never Told You 作者： Colbie Caillat
推荐编号： 7 推荐歌曲： Canada 作者： Five Iron Frenzy
推荐编号： 8 推荐歌曲： Fireflies 作者： Charttraxx Karaoke
推荐编号： 9 推荐歌曲： TULENLIEKKI 作者： M.A. Numminen
推荐编号： 10 推荐歌曲： Bring Me To Life 作者： Evanescence
当前待推荐用户编号 7
推荐编号： 1 推荐歌曲： Behind The Sea [Live In Chicago] 作者： Panic At The Disco
推荐编号： 2 推荐歌曲： The City Is At War (Album Version) 作者： Cobra Starship
推荐编号： 3 推荐歌曲： Dead Souls 作者： Nine Inch Nails
推荐编号： 4 推荐歌曲： Una Confusion 作者： LU
推荐编号： 5 推荐歌曲： Home 作者： Edward Sharpe & The Magnetic Zeros
推荐编号： 6 推荐歌曲： Climbing Up The Walls 作者： Radiohead
推荐编号： 7 推荐歌曲： Tighten Up 作者： The Black Keys
推荐编号： 8 推荐歌曲： Tive Sim 作者： Cartola
推荐编号： 9 推荐歌曲： West One (Shine On Me) 作者： The Ruts
推荐编号： 10 推荐歌曲： Cosmic Love 作者： Florence + The Machine
当前待推荐用户编号 8
推荐编号： 1 推荐歌曲： Undo 作者： Björk
推荐编号： 2 推荐歌曲： Canada 作者： Five Iron Frenzy
推荐编号： 3 推荐歌曲： Better To Reign In Hell 作者： Cradle Of Filth
推荐编号： 4 推荐歌曲： Unite (2009 Digital Remaster) 作者： Beastie Boys
推荐编号： 5 推荐歌曲： Behind The Sea [Live In Chicago] 作者： Panic At The Disco
推荐编号： 6 推荐歌曲： Rockin' Around The Christmas Tree 作者： Brenda Lee
推荐编号： 7 推荐歌曲： Devil's Slide 作者： Joe Satriani
推荐编号： 8 推荐歌曲： Revelry 作者： Kings Of Leon
推荐编号： 9 推荐歌曲： 16 Candles 作者： The Crests
推荐编号： 10 推荐歌曲： Catch You Baby (Steve Pitron & Max Sanna Radio Edit) 作者： Lonnie Gordon
当前待推荐用户编号 873
推荐编号： 1 推荐歌曲： The Scientist 作者： Coldplay
推荐编号： 2 推荐歌曲： Yellow 作者： Coldplay
推荐编号： 3 推荐歌曲： Clocks 作者： Coldplay
推荐编号： 4 推荐歌曲： Fix You 作者： Coldplay
推荐编号： 5 推荐歌曲： In My Place 作者： Coldplay
推荐编号： 6 推荐歌曲： Shiver 作者： Coldplay
推荐编号： 7 推荐歌曲： Speed Of Sound 作者： Coldplay
推荐编号： 8 推荐歌曲： Creep (Explicit) 作者： Radiohead
推荐编号： 9 推荐歌曲： Sparks 作者： Coldplay
推荐编号： 10 推荐歌曲： Use Somebody 作者： Kings Of Leon
当前待推荐用户编号 23
推荐编号： 1 推荐歌曲： Garden Of Eden 作者： Guns N' Roses
推荐编号： 2 推荐歌曲： Don't Speak 作者： John Dahlbäck
推荐编号： 3 推荐歌曲： Master Of Puppets 作者： Metallica
推荐编号： 4 推荐歌曲： TULENLIEKKI 作者： M.A. Numminen
推荐编号： 5 推荐歌曲： Bring Me To Life 作者： Evanescence
推荐编号： 6 推荐歌曲： Kryptonite 作者： 3 Doors Down
推荐编号： 7 推荐歌曲： Make Her Say 作者： Kid Cudi / Kanye West / Common
推荐编号： 8 推荐歌曲： Night Village 作者： Deep Forest
推荐编号： 9 推荐歌曲： Better To Reign In Hell 作者： Cradle Of Filth
推荐编号： 10 推荐歌曲： Xanadu 作者： Olivia Newton-John;Electric Light Orchestra
这里对每一个用户都得到了其对应的推荐结果，并且将结果按照得分值进行排序。
本章我们选择了音乐数据集来进行个性化推荐任务，首先对数据进行预处理和整合，选择两种方法分别完成推荐任务。在相似度计算中根据用户所听过的歌曲在候选集中选择与其最相似的歌曲，存在的问题就是计算时间消耗太多，每一个用户都需要重新计算一遍才能得出推荐结果。在SVD矩阵分解的方法中，我们首先构建评分矩阵，对其进行SVD分解，然后选择待推荐用户，还原得到其对所有歌曲的估测评分值，最后排序返回结果即可。
uTest = [27513]
#Get estimated rating for test user
print("Predictied ratings:")
uTest_recommended_items = compute_estimated_matrix(urm, U, S, Vt, uTest, K, True)
Predictied ratings:
for user in uTest:print("当前待推荐用户编号 {}". format(user))rank_value = 1for i in uTest_recommended_items[user,0:10]:song_details = small_set[small_set.so_index_value == i].drop_duplicates('so_index_value')[['title','artist_name']]print("推荐编号： {} 推荐歌曲： {} 作者： {}".format(rank_value, list(song_details['title'])[0],list(song_details['artist_name'])[0]))rank_value+=1
Recommendation for user with user id 27513
The number 1 recommended song is Master Of Puppets BY Metallica
The number 2 recommended song is Garden Of Eden BY Guns N' Roses
The number 3 recommended song is Bring Me To Life BY Evanescence
The number 4 recommended song is Kryptonite BY 3 Doors Down
The number 5 recommended song is Make Her Say BY Kid Cudi / Kanye West / Common
The number 6 recommended song is Night Village BY Deep Forest
The number 7 recommended song is Savior BY Rise Against
The number 8 recommended song is Good Things BY Rich Boy / Polow Da Don / Keri Hilson
The number 9 recommended song is Bleed It Out [Live At Milton Keynes] BY Linkin Park
The number 10 recommended song is Uprising BY Muse
Python实现音乐推荐系统【跟着迪哥学python】相关推荐
- 跟着迪哥学python 经管之家_跟着迪哥学Python数据分析与机器学习实战
本书结合了机器学习.数据分析和Python语言,通过案例以通俗易懂的方式讲解了如何将算法应用到实际任务. 全书共20章,大致分为4个部分.第一部分介绍了Python的工具包,包括科学计算库Numpy. ...
- 跟着迪哥学python 经管之家_跟着迪哥学：Python数据分析与机器学习实战
领取成功 您已领取成功! 您可以进入Android/iOS/Kindle平台的多看阅读客户端,刷新个人中心的已购列表,即可下载图书,享受精品阅读时光啦! - | 回复不要太快哦~ 回复内容不能为空哦 ...
- 跟着迪哥学python 经管之家_经管之家俱乐部：市面上并不多见的经管学习圈子！...
" 每一行都有每一行的门道和技巧 每一行都存在着独有的规律.玩法与规则 --却并不那么容易为外人所知 经济管理领域就是世界上汇聚了最多聪明人也最烧脑的领域之一,这里有无数大师.大咖.牛人.学 ...
- 跟着鸟哥学Linux系列笔记1
跟着鸟哥学Linux系列笔记0-扫盲之概念 跟着鸟哥学Linux系列笔记0-如何解决问题 装完linux之后,接下来一步就是进行相关命令的学习了 第五章:首次登录与在线求助man page 1. X ...
- python Django音乐推荐系统
python Django音乐推荐系统 PythonDjango音乐系统 后端:python Django 数据库:mysql 前端:html css js等 涉及功能: 登录.注册.播放音乐.音乐推 ...
- 『跟着雨哥学AI』系列之八：趣味案例——有关NLP任务数据预处理的那些事儿...
点击左上方蓝字关注我们 课程简介: "跟着雨哥学AI"是百度飞桨开源框架近期针对高层API推出的系列课.本课程由多位资深飞桨工程师精心打造,不仅提供了从数据处理.到模型组网.模型训 ...
- 『跟着雨哥学AI』系列之七：趣味案例——动手制作专属证件照
点击左上方蓝字关注我们 课程简介: "跟着雨哥学AI"是百度飞桨开源框架近期针对高层API推出的系列课.本课程由多位资深飞桨工程师精心打造,不仅提供了从数据处理.到模型组网.模型训 ...
- 跟着官网学Python(8):输入输出
"Python输入.输出.文件读写以及异常知识." 01 面临问题 继续跟着官网学Python,第7章输入输出. 前面已经基本学完Python的语法部分,也学会如何使用轮子,但是编 ...
- 『跟着雨哥学AI』系列之六：趣味案例——基于U-Net的宠物图像分割
点击左上方蓝字关注我们 课程简介: "跟着雨哥学AI"是百度飞桨开源框架近期针对高层API推出的系列课.本课程由多位资深飞桨工程师精心打造,不仅提供了从数据处理.到模型组网.模型训 ...
- 跟着鬼哥学爬虫-10-python微信-5-加上了人工智能回复！
跟着鬼哥学爬虫-10-python微信-5-加上了人工智能回复! 其实人工智能回复,现在网上有很多开源的机器学习,AI学习的框架,但是最重要的一点就是没有语料,也就是没有相互回答的数据内容. 所以这个 ...
最新文章
- 创建节约内存的JavaBean
- 用jdk在cmd下运行编译java程序
- 来宾可以删除服务器文件怎么设置密码,服务器来宾用用户设置密码
- bugzilla迁移需要修改的文件
- JDK1.7安装配置环境变量+图文说明Jmeter安装
- 1.9 matlab字符与字符串
- 人工智能的炒作_解密人工智能：是炒作还是我们期望太高
- php创建mysql计划任务_有关创建PHP-MySQL后台任务的建议
- 基于Huffman算法的文件解压缩
- 怎么测试服务器端口是否对外开放_从零开始内建你的安全测试流程
- 计算机开机后黑屏 只有鼠标,开机黑屏只有鼠标
- 什么高大填空四个字动人_雅思考试的技巧？雅思听力part4填空做题技巧分享
- 网络安全管理解决方案
- Spring学习资料
- dlib实现人脸关键点检测检测方法
- 视频编码中CBR编码和VBR编码
- python游戏寻路_游戏服务端寻路的思路与实现
- 小程序支付“”商户号该产品权限未开通，请前往商户平台产品中心检查后重试“”解决方案
- 第四方汇聚支付接口对接Php
- Word2010中插入自定义的图片作为项目符号