精华内容
下载资源
问答
  • Python实现音乐推荐系统源码及测试数据
  • Python实现音乐推荐系统【跟着迪哥学python】数据+源代码,需要的自取
  • Python实现音乐推荐系统【跟着迪哥学python

    千次阅读 热门讨论 2021-01-07 22:09:27
    Python实现音乐推荐系统 文章目录Python实现音乐推荐系统推荐系统数据读取对每一个用户,分别统计他的播放总量对于每一首歌,分别统计它的播放总量看看目前的排行情况取其中一部分数(按大小排好序的了,这些应该是...

    Python实现音乐推荐系统


    推荐系统

    首先对音乐数据集进行数据清洗和特征提取,基于矩阵分解方式来进行音乐推荐。

    • 音乐数据处理

    读取音乐数据集,并统计其各项指标,选择有价值的信息当做我们的特征

    • 基于商品相似性的推荐

    选择相似度计算方法,通过相似度来计算推荐结果

    • 基于SVD矩阵分解的推荐

    使用矩阵分解方法,快速高效得到推荐结果

    import pandas as pd
    import numpy as np
    import time
    import sqlite3
    
    data_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_matrix
    
    small_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.values
    
    data_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, Vt
    
    def compute_estimated_matrix(urm, U, S, Vt, uTest, K, test):
        rightTerm = S*Vt 
        max_recommendation = 250
        estimatedRatings = 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, :]*rightTerm
            estimatedRatings[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 = 1
        for 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 = 1
        for 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音乐推荐

    千次阅读 2018-07-13 23:43:28
    推荐系统示例——音乐推荐 本次,我们专注于构建推荐系统,以寻找用户感兴趣的商品、音乐和电影。以推荐音乐为例, 我们将调用一些包,搭建模型,用于推荐歌曲。 在这项任务中,我们将研究和探索人们听音乐的情况...

    推荐系统示例——音乐推荐

    本次,我们专注于构建推荐系统,以寻找用户感兴趣的商品、音乐和电影。以推荐音乐为例, 我们将调用一些包,搭建模型,用于推荐歌曲。

    在这项任务中,我们将研究和探索人们听音乐的情况,以及歌曲的而相关信息,做出模型,并对指定用户做推荐。 在此过程中,我们将学习如何使用最重要的数据操作放方法groupby。

    数据的导入与预处理

    import graphlab #导入graphlab包
    song_data = graphlab.SFrame.read_csv('song_data.csv',verbose = False) #数据导入
    users = song_data['user_id'].unique() #user_id唯一化,看总共有几个用户
    
    song_data.head(2)
    user_id song_id listen_count title artist
    b80344d063b5ccb3212f76538
    f3d9e43d87dca9e …
    SOAKIMP12A8C130995 1 The Cove Jack Johnson
    b80344d063b5ccb3212f76538
    f3d9e43d87dca9e …
    SOBBMDR12A8C13253B 2 Entre Dos Aguas Paco De Lucia
    song
    The Cove - Jack Johnson
    Entre Dos Aguas - Paco De
    Lucia …

    根据歌手统计用户和收听次数

    我们可以用unique方法,去掉用户数组中重复的元素,即选择数据列中的唯一元素。 下面,我们可以简单地count听过某首歌的用户总数,一个用户听过同一个歌手多首歌,自然是算一个用户。我们要统计用户数的歌手有:’Kanye West’、’Kanye West’、’Foo Fighters’、’Taylor Swift’和’Lady GaGa’。 因为数目比较少,我就单列出来,而不使用循环了。

    song_preference_users = song_data[song_data['artist'] == 'Kanye West']['user_id'].unique()
    len(song_preference_users)
    2522
    song_preference_users = song_data[song_data['artist'] == 'Foo Fighters']['user_id'].unique()
    len(song_preference_users)
    2055
    song_preference_users = song_data[song_data['artist'] == 'Taylor Swift']['user_id'].unique()
    len(song_preference_users)
    3246
    song_preference_users = song_data[song_data['artist'] == 'Lady GaGa']['user_id'].unique()
    len(song_preference_users)
    2928
    len(users)
    66346
    

    对于每个歌手,我们可以计算其音乐被收听的总的次数,从而来判断这个歌手是否受欢迎。从结果中可以看出,最受欢迎的歌手是Kings Of Leon,最不受欢迎的歌手是William Tabbert。

    artist_listen_num = song_data.groupby(key_columns='artist', operations={'total_count': graphlab.aggregate.SUM('listen_count')})
    artist_listen_num.head(1)
    print artist_listen_num.sort('total_count',ascending = False)
    print artist_listen_num.sort('total_count',ascending = True)
    +————————+————-+ | artist | total_count | +————————+————-+ | Kings Of Leon | 43218 | | Dwight Yoakam | 40619 | | Björk | 38889 | | Coldplay | 35362 | | Florence + The Machine | 33387 | | Justin Bieber | 29715 | | Alliance Ethnik | 26689 | | OneRepublic | 25754 | | Train | 25402 | | The Black Keys | 22184 | +————————+————-+ [3375 rows x 2 columns] Note: Only the head of the SFrame is printed. You can use print_rows(num_rows=m, num_columns=n) to print more rows and columns. +——————————-+————-+ | artist | total_count | +——————————-+————-+ | William Tabbert | 14 | | Reel Feelings | 24 | | Beyoncé feat. Bun B and Sl… | 26 | | Diplo | 30 | | Boggle Karaoke | 30 | | harvey summers | 31 | | Nâdiya | 36 | | Kanye West / Talib Kweli /… | 38 | | Aneta Langerova | 38 | | Jody Bernal | 38 | +——————————-+————-+ [3375 rows x 2 columns] Note: Only the head of the SFrame is printed. You can use print_rows(num_rows=m, num_columns=n) to print more rows and columns.

    建立模型,寻找最(不)值得推荐的歌曲

    下面,我们建立personal_model模型模型,并根据建立的模型给全部或者部分用户做推荐。
    接着我们来统计,这些推荐的歌曲中,哪些是personal_model模型推荐最多的歌曲,那个是推荐最少的歌曲。

    train_data,test_data = song_data.random_split(.8,seed=0) #分割数据
    personalized_model = graphlab.item_similarity_recommender.create(train_data,
                                                                    user_id='user_id',
                                                                    item_id='song',verbose = False);#,target='listen_count')
    #新建一个item_similarity_recommender模型
    #user_id作为推荐使用的i
    #personalized_model.recommend(users=[users[0]])
    #personalized_model.get_similar_items(['With Or Without You - U2']) #列出相似的歌曲
    
    Recsys training: model = item_similarity
    subset_test_users = test_data['user_id'].unique()#[0:10000];
    recommend_result  = personalized_model.recommend(subset_test_users, k=1,verbose = False);
    recommend_result.head(3);
    recommanded_song_count = recommend_result.groupby(['song'], graphlab.aggregate.COUNT);
    recommanded_song_count.head(2)
    song Count
    Your Star - The All-
    American Rejects …
    1
    The Climb - Miley Cyrus 6

    song_count_sort = recommanded_song_count.sort('Count',ascending = False)
    song_count_sort.head(3)
    #recommanded_song_count.sort('Count',ascending = True)
    song Count
    Undo - Björk 2504
    Secrets - OneRepublic 2251
    Revelry - Kings Of Leon 1321

    可以看出,Undo - Björk的歌曲是推荐得最多的。这首歌曲的歌手是 Björk,并不是是最受欢迎歌手Kings Of Leon。主要是因为,我们在选最受欢迎歌手的时候,考虑到了一个用户听多次的情况。而我们在建立模型的时候,并没有考虑每个人对于同一首歌的收听次数,只在意其听没听。故而,若Kings Of Leon被单用户听的次数比较多,而Undo的听众比较多,就会造成这种不一致。我们也可以使用target='listen_count',来设置模型的rating。

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 188
精华内容 75
关键字:

python音乐推荐系统

python 订阅