python音乐推荐系统_音乐推荐系统
音樂頻道推薦業務，支持各個產品業務和策略。這里我先使用CB+CF+LR實現推薦部分，下面具體展開：
一、推薦系統流程圖
CB，CF算法在召回階段使用，推薦出來的item是粗排的，利用LR算法，可以將CB，CF召回來的item進行精排，然后選擇分數最高，給用戶推薦出來。后續我們可以采用矩陣分解、聚類、深度學習算法來實現對候選集合的召回。
二、推薦系統思路詳解
話不多說，這里先放上代碼思路：
1、數據預處理(用戶畫像數據、物品元數據、用戶行為數據)
2、召回(CB、CF算法)
3、LR訓練模型的數據準備，即用戶特征數據，物品特征數據
4、模型準備，即通過LR算法訓練模型數據得到w，b
5、推薦系統流程：
(1)解析請求：userid，itemid
(2)加載模型：加載排序模型(model.w，model.b)
(3)檢索候選集合：利用cb，cf去redis里面檢索數據庫，得到候選集合
(4)獲取用戶特征：userid
(5)獲取物品特征：itemid
(6)打分(邏輯回歸，深度學習)，排序
(7)top-n過濾
(8)數據包裝(itemid->name)，返回
三、推薦系統實現
3.1、數據預處理
(1)用戶畫像數據：user_profile.data
userid，性別，年齡，收入，地域
(2)物品(音樂)元數據：music_metaitemid，name，desc，時長，地域，標簽
(3)用戶行為數據：user_watch_pref.sml
userid，itemid，該用戶對該物品的收聽時長，點擊時間(小時)
首先，將3份數據融合到一份數據中
執行python gen_base.py
1 #coding=utf-8
2
3 '''
4 總體思路：處理原始的數據：1、用戶畫像數據 2、物品元數據 3、用戶行為數據5 把三類數據統一到一個文件里面，供后面cb、cf算法進行計算權重6 '''
7
8 importsys9
10 #找到三類原始數據文件，用戶畫像數據、物品元數據，用戶行為數據
11 user_action_data = '../data/user_watch_pref.sml'
12 music_meta_data = '../data/music_meta'
13 user_profile_data = '../data/user_profile.data'
14
15 #將三類處理后的元數據放到新的文件里面，這里我們需要定一個文件名，路徑
16 output_file = '../data/merge_base.data'
17
18 #將3份數據merge后的結果輸出，供下游數據處理
19 ofile = open(output_file, 'w')20
21 #step 1. 處理物品元數據，將處理后的結果放入字典里面，key是itemid，value為物品對應的信息，為最后寫入做準備
22 item_info_dict ={}23 with open(music_meta_data, 'r') as fd:24 for line infd:25 ss = line.strip().split('\001')26 if len(ss) != 6:27 continue
28 itemid, name, desc, total_timelen, location, tags =ss29 item_info_dict[itemid] = '\001'.join([name, desc, total_timelen, location, tags])30
31 #step 2. 處理用戶畫像數據，將處理后的結果放入字典里面，key是用戶id，value是用戶信息
32 user_profile_dict ={}33 with open(user_profile_data, 'r') as fd:34 for line infd:35 ss = line.strip().split(',')36 if len(ss) != 5:37 continue
38 userid, gender, age, salary, location =ss39 user_profile_dict[userid] = '\001'.join([gender, age, salary, location])40
41 #step 3. 寫入最后的信息，將用戶行為數據進行處理，把step1和step2得到的數據一并歸納在文件里面
42 with open(user_action_data, 'r') as fd:43 for line infd:44 ss = line.strip().split('\001')45 if len(ss) != 4:46 continue
47 userid, itemid, watch_len, hour =ss48
49 if userid not inuser_profile_dict:50 continue
51
52 if itemid not initem_info_dict:53 continue
54
55 ofile.write('\001'.join([userid, itemid, watch_len, hour, \56 user_profile_dict[userid], item_info_dict[itemid]]))57 ofile.write("\n")58
59 ofile.close()
得到類似下面數據merge_base.data
01e3fdf415107cd6046a07481fbed499^A6470209102^A1635^A21^A男^A36-45^A20000-100000^A內蒙古^A黃家駒1993演唱會高清視頻^A^A1969^A^A演唱會
3.2、【召回】CB算法
(1)以token itemid score形式整理訓練數據利用jieba分詞，對item name進行中文分詞
python gen_cb_train.py
1 #coding=utf-8
2
3 '''
4 總體思路：將初始化好的用戶，物品，用戶行為數據進行處理，目的是為了得到token，itemid，score，我們知道生成的數據里面的name，5 將itemName進行分詞，得到tfidf權重，同時將desc進行分詞，處理name和desc，我們在元數據中還有已經分類好的tags，tags已經切分好6 了沒必要再次進行切分，只需要用idf詞表查處權重即可，但是對于name、desc、tags這三個分詞結果，我們對name的結果應該更加偏重一7 點，所以分別對這三類得出的分數再次進行分數權重劃分，最后得到cb的初始數據8 '''
9
10 importsys11 sys.path.append('../')12 reload(sys)13 sys.setdefaultencoding('utf-8')14
15 importjieba16 importjieba.posseg17 importjieba.analyse18
19
20 #讀入初始數據
21 input_file = "../data/merge_base.data"
22
23 #輸出cb訓練數據
24 output_file = '../data/cb_train.data'
25 ofile = open(output_file, 'w')26
27 #定義三類的權重分數
28 RATIO_FOR_NAME = 0.9
29 RATIO_FOR_DESC = 0.1
30 RATIO_FOR_TAGS = 0.05
31
32
33 #為tags讀入idf權重值
34 idf_file = '../data/idf.txt'
35 idf_dict ={}36 with open(idf_file, 'r') as fd:37 for line infd:38 token, idf_score = line.strip().split(' ')39 idf_dict[token] =idf_score40
41 #開始處理初始數據
42 itemid_set =set()43 with open(input_file, 'r') as fd:44 for line infd:45 ss = line.strip().split('\001')46 #用戶行為
47 userid =ss[0].strip()48 itemid = ss[1].strip()49 watch_len = ss[2].strip()50 hour = ss[3].strip()51 #用戶畫像
52 gender = ss[4].strip()53 age = ss[5].strip()54 salary = ss[6].strip()55 user_location = ss[7].strip()56 #物品元數據
57 name = ss[8].strip()58 desc = ss[9].strip()59 total_timelen = ss[10].strip()60 item_location = ss[11].strip()61 tags = ss[12].strip()62
63 #對item去重，相同的itemid不用再計算，因為都一樣，這里用到continue特性，當不同的時候才繼續執行下面的代碼
64 if itemid not initemid_set:65 itemid_set.add(itemid)66 else:67 continue
68
69 #去掉重復后的itemid，然后我們進行分詞，計算權重，放到字典里面
70 token_dict ={}71 #對name統計
72 for a in jieba.analyse.extract_tags(name, withWeight=True):73 token =a[0]74 score = float(a[1])75 token_dict[token] = score *RATIO_FOR_NAME76
77 #對desc進行分詞，這里需要注意的是描述一般會含有name中的詞，這里我們把有的詞的分數進行相加，沒有的放入
78 for a in jieba.analyse.extract_tags(desc, withWeight=True):79 token =a[0]80 score = float(a[1])81 if token intoken_dict:82 token_dict[token] += score *RATIO_FOR_DESC83 else:84 token_dict[token] = score *RATIO_FOR_DESC85
86 #對tags 進行分數計算
87 for tag in tags.strip().split(','):88 if tag not inidf_dict:89 continue
90 else:91 if tag intoken_dict:92 token_dict[tag] += float(idf_dict[tag]) *RATIO_FOR_TAGS93 else:94 token_dict[tag] = float(idf_dict[tag]) *RATIO_FOR_TAGS95
96 #循環遍歷token_dict，輸出toke，itemid，score
97 for k, v intoken_dict.items():98 token =k.strip()99 score =str(v)100 ofile.write(','.join([token, itemid, score]))101 ofile.write("\n")102
103
104 ofile.close()
得到如下數據：
翻譯,4090309101,0.561911164569(最后一個是一個不是傳統的TF-IDF,因為分出的詞在name,desc,tag里面他的重要性是不一樣的)
(2)用協同過濾算法跑出item-item數據
相似的item配對，II矩陣的形成。相似度計算，我們要用到MapReduce的框架來進行，只要是用到shuffle階段，對map出來的結果排序，reduce進行兩兩配對，這里就是主要的wordcount邏輯，主要說下注意的部分：我們需要把兩兩分數的過濾掉，或是把itemA和itemB相同的item過濾掉，因為這部分數據沒有任何意義
map階段：
#!usr/bin/python#-*- coding: UTF-8 -*-
'''總體思路：這里需要把初始化后的結果進行map排序，為了后續兩兩取 pair對，所以這里我們需要進行map，其實什么也不用操作輸出即可'''
importsysimportrefor line insys.stdin:
ss= line.strip().split(',')if len(ss) != 3:continuer1= u'[a-zA-Z0-9’!"#$%&\'()*+,-./:;<=>?@，。?★、…【】《》？“”‘’！[\\]^_`{|}~]+'ss[0]= re.sub(r1,'',ss[0])if len(ss[0]) ==0:continue
print ','.join([ss[0], ss[1], ss[2]])
reduce階段：
#!usr/bin/python#-*- coding: UTF-8 -*
'''我們前面已經在pair reduce之前我們做過map操作，輸出以token，item，score輸出，所以排序是token排好的序
這里我們相當于求的是II矩陣，所以是根相同的token的item進行相似度計算
思路：
1、進行user統計，若相同，把相同的user的item和score放入list里面
2、不相同，開始進行兩兩配對，循環該list，進行兩兩配對，求出相似度'''
importsysimportmath
cur_token=None
item_score_list=[]for line insys.stdin:
ss= line.strip().split(',')
itemid= ss[1]
score= float(ss[2])if len(ss) != 3:continue
if cur_token ==None:
cur_token=ss[0]if cur_token !=ss[0]:#這里需要注意的是range的區間前閉后開，同時注意range中即使前閉后開，剛開始是從0即列表里面的第一個，循環到列表最后一個的前一個
for i in range(0,len(item_score_list)-1):for j in range(i+1,len(item_score_list)):
item_a,score_a=item_score_list[i]
item_b,score_b=item_score_list[j]#score = float(score_a * score_b)/float(math.sqrt(pow(score_a,2))*math.sqrt(pow(score_b,2)))
#輸出兩遍的目的是為了形成II矩陣的對稱
score = float(score_a*score_b)if item_a ==item_b:continue
if score < 0.08:continue
print "%s\t%s\t%s" %(item_a, item_b, score)print "%s\t%s\t%s" %(item_b, item_a, score)
cur_token=ss[0]
item_score_list=[]
item_score_list.append((itemid,float(score)))for i in range(0, len(item_score_list) - 1):for j in range(i + 1, len(item_score_list)):
item_a, score_a=item_score_list[i]
item_b, score_b=item_score_list[j]#score = (score_a * score_b) / (math.sqrt(pow(score_a, 2)) * math.sqrt(pow(score_b, 2))
#輸出兩遍的目的是為了形成II矩陣的對稱
score = float(score_a *score_b)if item_a ==item_b:continue
if score < 0.08:continue
print "%s\t%s\t%s" %(item_a, item_b, score)print "%s\t%s\t%s" % (item_b, item_a, score)
最后得到基于cb的ii矩陣
(3)對數據格式化，item-> item list形式，整理出KV形式python gen_reclist.py
1 #coding=utf-8
2 '''
3 思路：我們已經通過CB算法得到itemA，itemB，score，然后我們需要把放入到redis庫，存入的方法，4 我們以itemA為key與itemA有相似度的itemB，和分數，以value的形式存入內存庫5 1、創建一個字典，將key放入itemA，value 放入與A對應的不同b和分數6 2、循環遍歷字典，將key加上前綴CB，value以從大到小的分數進行排序，并且相同的item以——分割，item和score間用：分割7 '''
8
9 importsys10
11 infile = '../data/cb.result'
12 outfile = '../data/cb_reclist.redis'
13
14 ofile = open(outfile, 'w')15
16 MAX_RECLIST_SIZE = 100
17 PREFIX = 'CB_'
18
19 rec_dict ={}20 with open(infile, 'r') as fd:21 for line infd:22 itemid_A, itemid_B, sim_score = line.strip().split('\t')23
24 #判斷itemA在不在該字典里面，若不在，創建一個key為itemA的列表，把與itemA相關聯的itemB和score添加進去
25 if itemid_A not inrec_dict:26 rec_dict[itemid_A] =[]27 rec_dict[itemid_A].append((itemid_B, sim_score))28
29 #循環遍歷字典，格式化數據，把itemB和score中間以：分割，不同的itemB以_分割
30 for k, v inrec_dict.items():31 key_item = PREFIX +k32
33 #接下來格式化數據，將數據以從大到小排列后再格式化
34 #排序,由于數據量大，我們只取100個
35 #排好序后，我們來格式化數據
36 reclist_result = '_'.join([':'.join([tu[0], str(round(float(tu[1]), 6))]) \37 for tu in sorted(v, key=lambda x: x[1], reverse=True)[:MAX_RECLIST_SIZE]])38
39 ofile.write(' '.join(['SET', key_item, reclist_result]))40 ofile.write("\n")41
42 ofile.close()
類似如下數據：
SET CB_5305109176 726100303:0.393048_953500302:0.393048_6193109237:0.348855
(4)灌庫(redis)
下載redis-2.8.3.tar.gz安裝包
進行源碼編譯(需要C編譯yum install
gcc-c++ )，執行make，然后會在src目錄中，得到bin文件(redis-server
服務器，redis-cli 客戶端)
啟動redis
server服務兩種方法：
]# ./src/redis-server
]#后臺方式啟動 nohup
./redis-server &
然后換一個終端執行：]# ./src/redis-cli，連接服務
接下來灌數據(批量灌)：
需要安裝unix2dos(yum install unix2dos)(格式轉換)
]# cat cb_reclist.redis |
/usr/local/src/redis-2.8.3/src/redis-cli --pipe 這樣是會報大量異常，所以需要用下面的方式去做,完了再使用管道插入(注意redis安裝目錄)
unix2dos cb_reclist.redis
cat cb_reclist.redis | /usr/local/src/redis/redis-2.8.3/src/redis-cli --pipe
驗證：]# ./src/redis-cli
執行：127.0.0.1:6379> get CB_5305109176
"726100303:0.393048_953500302:0.393048_6193109237:0.348855"
3.3、【召回】CF算法
(1)以userid itemid score形式整理訓練數據
python gen_cf_train.py
1 #coding=utf-8
2 '''
3 總體思路：首先和cb一樣，對處理完的用戶元數據，物品元數據，行為數據進行cf數據準備工作，我們的目的事輸出：4 user，item score，其中主要是的到用戶對item的score，這里score怎么算呢，當然是用戶收聽的音樂的時常和總的時5 長相除的到6 '''
7
8 importsys9
10 input_file = "../data/merge_base.data"
11
12 #輸出cf訓練數據
13 output_file = '../data/cf_train.data'
14 ofile = open(output_file, 'w')15
16 key_dict ={}17 with open(input_file, 'r') as fd:18 for line infd:19 ss = line.strip().split('\001')20 #用戶行為
21 userid =ss[0].strip()22 itemid = ss[1].strip()23 watch_len = ss[2].strip()24 hour = ss[3].strip()25 #用戶畫像
26 gender = ss[4].strip()27 age = ss[5].strip()28 salary = ss[6].strip()29 user_location = ss[7].strip()30 #物品元數據
31 name = ss[8].strip()32 desc = ss[9].strip()33 total_timelen = ss[10].strip()34 item_location = ss[11].strip()35 tags = ss[12].strip()36 #拼接key，為了將同一個用戶對相同物品的時長全部得到，需要做個聚合
37 key = '_'.join([userid, itemid])38 if key not inkey_dict:39 key_dict[key] =[]40 key_dict[key].append((int(watch_len), int(total_timelen)))41
42 #循環處理相同用戶對相同item的分數
43 for k, v inkey_dict.items():44 t_finished =045 t_all =046 #對為key進行分數聚合
47 for vv inv:48 t_finished +=vv[0]49 t_all += vv[1]50
51 #得到userid對item的最終分數
52 score = float(t_finished) /float(t_all)53 userid, itemid = k.strip().split('_')54
55
56 ofile.write(','.join([userid, itemid, str(score)]))57 ofile.write("\n")58
59 ofile.close()
得到如下數據：
(2)用協同過濾算法跑出item-item數據
II矩陣數據準備，歸一化，取pair對，計算總和
這里我們準備redis數據分為這么幾個部分，我們來一一解析一下，當然這部分的數據需要利用到MapReduce框架，進行map和reduce排序。
歸一化
歸一化階段我們主要是將相同的item進行單位模計算，因為后續我們要用到cos相似度計算公式，將相同的item的分數進行平方和再開根號，最后進行單位化。
map階段，只要將轉數據換成item，user，score ，因為我們要在reduce階段進行相同item單位化，要充分用到shuffle階段的排序。
1 #!usr/bin/python
2 #-*- coding: UTF-8 -*-
3 '''
4 思路：轉換成i，u，s的矩陣5 '''
6 importsys7
8 for line insys.stdin:9 ss = line.strip().split(',')10 if len(ss) != 3:11 continue
12 u , i , s =ss13 print '\t'.join([i,u,s])
reduce階段，我們需要將相同item平方和相加開根號，然后再單位化計算，最后輸出。
1 #!usr/bin/python
2 #-*- coding: UTF-8 -*-
3 '''
4 在map的基礎上將每個item進行歸一化，map已經將相同的item排好序，這里我們根據map的結果進行給先平方再開根號：5 思路 ：6 1、截取字符串，取出item，user，socre7 2、在for循環中進行判斷，當前的item和下一個是否相同，要是相同，將相同的放到列表(user，score)列表里面，否則往下執行8 3、若不相同，循環user和score列表，計算模計算，然后再次循環，進行單位化計算9 '''
10
11 importsys12 importmath13
14 cur_item =None15 user_score_list =[]16 for line insys.stdin:17 ss = line.strip().split('\t')18 if len(ss) != 3:19 continue
20
21 item =ss[0]22 userid = ss[1]23 score = ss[2]24
25 #wordcount判斷，當前和下一個是否相同，相同添加到列表，不相同進行歸一化計算
26 if cur_item ==None:27 cur_item =item28 if cur_item !=item:29 #定義sum
30 sum = 0.0
31 #循環列表進行模向量計算
32 for ss inuser_score_list:33 user,s =ss34 sum += pow(s,2)35 sum =math.sqrt(sum)36
37 #單位化計算
38 for touple inuser_score_list:39 u,s =touple40 #進行單位化完成后，我們輸出重置成原來的user-item-score輸出
41 print "%s\t%s\t%s" % (u, cur_item, float(s /sum))42
43 #初始化這兩個變量
44 cur_item =item45 user_score_list =[]46
47 user_score_list.append((userid,float(score)))48
49 #定義sum
50 sum = 0.0
51 #循環列表進行模向量計算
52 for ss inuser_score_list:53 user,s =ss54 sum += pow(s,2)55 sum =math.sqrt(sum)56 #單位化計算
57 for touple inuser_score_list:58 u,s =touple59 #進行單位化完成后，我們輸出重置成原來的user-item-score輸出
60 print "%s\t%s\t%s" % (u, cur_item, float(s / sum))
兩兩取pair對
兩兩取pair對，我們在map階段，其實什么都不用做，保證輸出user，itemid，score即可。
map階段
1 #!usr/bin/python
2 #-*- coding: UTF-8 -*-
3
4 #在進行pair取對之前，什么都不需要做，輸出就行
5
6 importsys7
8 for line insys.stdin:9 u, i, s = line.strip().split('\t')10 print "%s\t%s\t%s" % (u, i, s)
reduce階段，我們需要將同一個用戶下面的item進行兩兩取對，因為我們要形成II矩陣，就必須以user為參考單位，相反形成uu矩陣，就必須以item參考，所以將同一個用戶下的item進行兩兩取對，并將分數相乘，就得到臨時這個相似度，因為還沒有對相同pair對的分數相加，這個是最后一步要做的。
1 #!usr/bin/python
2 #-*- coding: UTF-8 -*-
3
4 '''
5 思路：進行map排好序之后，我們的會得到相同user對應的不同item和score，這里我們主要的思路是進行相同用戶兩兩取pair6 1、進行判斷，當前用戶和下一個用戶是不是一樣，若是不一樣，我們進行兩兩取對，形成ii矩陣7 2、若是相同，我們將不同的item和score放入list里面8 '''
9
10 importsys11
12 cur_user =None13 item_score_list =[]14 for line insys.stdin:15 user,item,score = line.strip().split('\t')16
17 if cur_user ==None:18 cur_user=user19
20 if cur_user !=user:21
22 #進行兩兩pair，利用range函數
23 for i in range(0,len(item_score_list)-1):24 for j in range(i+1,len(item_score_list)):25 item_a, score_a =item_score_list[i]26 item_b, score_b =item_score_list[j]27 #輸出兩遍的目的是為了形成II矩陣的對稱
28 print "%s\t%s\t%s" % (item_a, item_b, score_a *score_b)29 print "%s\t%s\t%s" % (item_b, item_a, score_a *score_b)30
31 cur_user =user32 item_score_list =[]33
34 item_score_list.append((item,float(score)))35
36 #進行兩兩pair，利用range函數
37 for i in range(0,len(item_score_list)-1):38 for j in range(i+1,len(item_score_list)):39 item_a, score_a =item_score_list[i]40 item_b, score_b =item_score_list[j]41 #輸出兩遍的目的是為了形成II矩陣的對稱
42 print "%s\t%s\t%s" % (item_a, item_b, score_a *score_b)43 print "%s\t%s\t%s" % (item_b, item_a, score_a * score_b)
進行最終分數求和
我們最后的階段是要將相同pair的分數相加才能得到兩個item的相似度
map階段，這里我們因為要將相同item對排序到一起，就要將pair組成一個key進行排序，將同一個partition后數據放倒一個reduce桶中，再說一下MapReduce框架中國年shuffle階段，key只是做排序，partition只是做分區，不要搞混了。
1 #!usr/bin/python
2 #-*- coding: UTF-8 -*-
3
4 '''
5 sum的map中，我們需要把相同的itemA，itemB組成key，為了使相同的key能夠在shuffle階段分配到同一個reduce中，6 因為是計算item的相似度，要把相同的相加7 '''
8
9 importsys10
11 for line insys.stdin:12 item_a,item_b,score = line.strip().split('\t')13 key = '#'.join([item_a,item_b])14 print '%s\t%s' %(key,score)
reduce階段主要任務就是將相同的item的pair對相加.
#!usr/bin/python#-*- coding: UTF-8 -*-
'''思路：將相同的item的分數進行相加，得到最后的相似度'''
importsys
cur_item=None
score= 0.0
for line insys.stdin:
item, s= line.strip().split('\t')if notcur_item:
cur_item=itemif cur_item !=item:
ss= item.split("#")if len(ss) != 2:continueitem_a, item_b=ssprint "%s\t%s\t%s" %(item_a, item_b, score)
cur_item=item
score= 0.0score+=float(s)
ss= item.split("#")if len(ss) != 2:
sys.exit()
item_a, item_b=ssprint "%s\t%s\t%s" % (item_a, item_b, score)
最后得到基于cf的ii矩陣
(3)對數據格式化，item-> item list形式，整理出KV形式
python gen_reclist.py
1 #coding=utf-8
2 '''
3 思路：這個處理的邏輯和CB中完全一樣，不一樣的是redis的key是CF開頭4 '''
5
6 importsys7
8 infile = '../data/cf.result'
9 outfile = '../data/cf_reclist.redis'
10
11 ofile = open(outfile, 'w')12
13 MAX_RECLIST_SIZE = 100
14 PREFIX = 'CF_'
15
16 rec_dict ={}17 with open(input_file,'r') as fd:18 for line infd:19 itemid_A, itemid_B, score = line.strip().split('\t')20
21 #判斷itemA在不在該字典里面，若不在，創建一個key為itemA的列表，把與itemA相關聯的itemB和score添加進去
22 if itemid_A not inrec_dict:23 rec_dict[itemid_A] =[]24 rec_dict[itemid_A].append((itemid_B, score))25
26 #循環遍歷字典，格式化數據，把itemB和score中間以：分割，不同的itemB以_分割
27 for k,v inrec_dict.items():28 key = PREFIX+k29 #接下來格式化數據，將數據以從大到小排列后再格式化
30 #排序,由于數據量大，我們只取100個
31 list = sorted(v,key=lambda x:x[1],reverse=True)[:MAX_RECLIST_SIZE]32 #拍好序后，我們來格式化數據
33 result = '_'.join([':'.join([str(val[0]),str(round(float(val[1]),6))]) for val inlist])34
35 ofile.write(' '.join(['SET',key,result]))36 ofile.write("\n")37
38 ofile.close()
類似如下數據：
(4)灌庫
unix2dos cf_reclist.redis
cat cf_reclist.redis | /usr/local/src/redis-2.8.3/src/redis-cli --pipe
驗證:
3.4、LR訓練模型的數據準備
準備我們自己的訓練數據
進入pre_data_for_rankmodel目錄：
gen_samples.py
1 #coding=utf-8
2
3
4 '''
5 思路：這里我們經過cb，cf算法，將數據已經放到內存庫，召回部分已經完成，接下來我們需要做排序模型，為邏輯回歸準備樣本數據6 1、處理第一次將用戶元數據，物品元數據，用戶行為數據一起歸并的數據，也就是merge_base.data,我們在這里需要得到用戶畫像7 數據，用戶信息數據，標簽數據8 2、收取樣本，標簽，用戶畫像信息，物品信息9 3、抽取用戶畫像信息，對性別和年齡生成樣本數據10 4、抽取item特征信息，分詞獲得token，score，做樣本數據11 5、拼接樣本，生成最終的樣本信息，作為模型進行訓練12 '''
13
14 importsys15 sys.path.append('../')16 reload(sys)17 sys.setdefaultencoding('utf-8')18
19 importjieba20 importjieba.analyse21 importjieba.posseg22
23 merge_base_infile = '../data/merge_base.data'
24 output_file = '../data/samples.data'
25
26 #我們這里需要再生成兩個文件，一個是用戶樣本和item樣本，因為要對實時推薦的化，必須使用這兩個樣本
27 output_user_feature_file = '../data/user_feature.data'
28 output_item_feature_file = '../data/item_feature.data'
29
30 #這里生成個類似name和id對應的字典信息
31 output_itemid_to_name_file = '../data/name_id.dict'
32
33
34 #定義函數，來獲取各類數據
35 defget_base_samples(infile):36 #放待處理樣本數據
37 ret_samples_list =[]38 #放user用戶數據
39 user_info_set =set()40 #放物品數據
41 item_info_set =set()42 item_name2id ={}43 item_id2name ={}44
45 with open(infile, 'r') as fd:46 for line infd:47 ss = line.strip().split('\001')48 if len(ss) != 13:49 continue
50 userid =ss[0].strip()51 itemid = ss[1].strip()52 #這兩個時間為了計算label而使用
53 watch_time = ss[2].strip()54 total_time = ss[10].strip()55
56 #用戶數據
57 gender = ss[4].strip()58 age = ss[5].strip()59 user_feature = '\001'.join([userid, gender, age])60
61 #物品數據
62 name = ss[8].strip()63 item_feature = '\001'.join([itemid, name])64
65 #計算標簽
66 label = float(watch_time) /float(total_time)67 final_label = '0'
68
69 if label >= 0.82:70 final_label = '1'
71 elif label <= 0.3:72 final_label = '0'
73 else:74 continue
75
76 #接下來裝在數據，并返回結果，首先我們裝在itemid2name和itemname2id
77 item_name2id[name] =itemid78 item_id2name[itemid] =name79
80 #裝在待處理的標簽數據
81 ret_samples_list.append([final_label, user_feature, item_feature])82
83 user_info_set.add(user_feature)84 item_info_set.add(name)85
86 returnret_samples_list, user_info_set, item_info_set, item_name2id, item_id2name87
88
89 #step 1 程序的入口，開始調用函數，開始處理文件，得到相應的數據
90 base_sample_list, user_info_set, item_info_set, item_name2id, item_id2name =\91 get_base_samples(merge_base_infile)92
93
94 #step 2 抽取用戶畫像信息，用戶標簽轉換，將年齡和age進行轉換，用于樣本使用
95 user_fea_dict ={}96 for info inuser_info_set:97 userid, gender, age = info.strip().split('\001')98
99 #設置標簽idx，將男(1)和女(0)用數劇的形式表示，權重都設置為1
100 idx = 0 #default 女
101 if gender == '男':102 idx = 1
103 #將標簽和權重拼接起來
104 gender_fea = ':'.join([str(idx), '1'])105
106 #性別設置完成，我們接下來設置年齡，將年齡進行劃分，0-18，19-25，26-35，36-45
107 idx =0108 if age == '0-18':109 idx =0110 elif age == '19-25':111 idx = 1
112 elif age == '26-35':113 idx = 2
114 elif age == '36-45':115 idx = 3
116 else:117 idx = 4
118
119 idx += 2
120
121 age_fea = ':'.join([str(idx), '1'])122
123 user_fea_dict[userid] = ' '.join([gender_fea, age_fea])124
125 #step 3 抽取物品特征，這里我們要用到分詞，將name進行分詞，并且把分詞后的token轉換成id，這里就需要我們來做生成tokenid詞表
126 token_set =set()127 item_fs_dict ={}128 for name initem_info_set:129 token_score_list =[]130 for x,w in jieba.analyse.extract_tags(name,withWeight=True):131 token_score_list.append((x,w))132 token_set.add(x)133 item_fs_dict[name] =token_score_list134
135 #進行token2id的轉換
136 token_id_dict ={}137 #這里我們要用到剛剛利用set去重過的token列表，生成tokenid的字典表
138 for s inenumerate(list(token_set)):139 token_id_dict[s[1]] =s[0]140
141 #接下來，我們需要把第三步生成的item_fs_dict中name對應的token全部替換成id，然后當作字典，為下面的全量替換做準備
142 item_fea_dict ={}143 user_feature_offset = 10
144 for name ,fea initem_fs_dict.items():145 token_score_list =[]146 for (token,score) infea:147 if token not intoken_id_dict:148 continue
149 token_id = token_id_dict[token] +user_feature_offset150 token_score_list.append(':'.join([str(token_id),str(score)]))151
152 #接下來輸出到字典中
153 item_fea_dict[name] = ' '.join(token_score_list)154
155 #step 4 將第一步輸出的樣本數據整體替換并且替換user_feature和item_feature,并輸出到文件中
156 ofile = open(output_file,'w')157 for (label,userfea,itemfea) inbase_sample_list:158 userid = userfea.strip().split('\001')[0]159 item_name = itemfea.strip().split('\001')[1]160
161 if userid not inuser_fea_dict:162 continue
163 if item_name not initem_fea_dict:164 continue
165
166 ofile.write(' '.join([label,user_fea_dict[userid],item_fea_dict[item_name]]))167 ofile.write('\n')168
169 ofile.close()170
171 #step 5 為了能夠實時使用userfeatre，我們需要輸出一下
172 out_put_file = open(output_user_feature_file,'w')173 for userid,fea inuser_fea_dict.items():174 out_put_file.write('\t'.join([userid,fea]))175 out_put_file.write('\n')176 out_put_file.close()177
178 #step 6 輸出item_feature
179 out_file = open(output_item_feature_file,'w')180 for name,fea initem_fea_dict.items():181 if name not initem_name2id:182 continue
183 itemid =item_name2id[name]184 out_file.write('\t'.join([itemid,fea]))185 out_file.write('\n')186
187 #step 7 輸出id2name的對應的字典
188 o_file = open(output_itemid_to_name_file,'w')189 for id,name initem_id2name.items():190 o_file.write('\t'.join([id,name]))191 o_file.write('\n')192 o_file.close()
得到如下數據：
3.5、模型準備
1 #-*- coding: UTF-8 -*-
2 '''
3 思路：這里我們要用到我們的數據，就需要我們自己寫load_data的部分，4 首先定義main，方法入口，然后進行load_data的編寫5 其次調用該方法的到x訓練x測試，y訓練，y測試，使用L1正則化或是L2正則化使得到結果更加可靠6 輸出wegiht，和b偏置7 '''
8 importsys9 importnumpy as np10 from scipy.sparse importcsr_matrix11
12 from sklearn.model_selection importtrain_test_split13 from sklearn.linear_model importLogisticRegression14
15 input_file = sys.argv[1]16
17 defload_data():18 #由于在計算過程用到矩陣計算，這里我們需要根據我們的數據設置行，列，和訓練的數據準備
19 #標簽列表
20 target_list =[]21 #行數列表
22 fea_row_list =[]23 #特征列表
24 fea_col_list =[]25 #分數列表
26 data_list =[]27
28 #設置行號計數器
29 row_idx =030 max_col =031
32 with open(input_file,'r') as fd:33 for line infd:34 ss = line.strip().split(' ')35 #標簽
36 label =ss[0]37 #特征
38 fea = ss[1:]39
40 #將標簽放入標簽列表中
41 target_list.append(int(label))42
43 #開始循環處理特征：
44 for fea_score infea:45 sss = fea_score.strip().split(':')46 if len(sss) != 2:47 continue
48 feature, score =sss49 #增加行
50 fea_row_list.append(row_idx)51 #增加列
52 fea_col_list.append(int(feature))53 #填充分數
54 data_list.append(float(score))55 if int(feature) >max_col:56 max_col =int(feature)57
58 row_idx += 1
59
60 row =np.array(fea_row_list)61 col =np.array(fea_col_list)62 data =np.array(data_list)63
64 fea_datasets = csr_matrix((data, (row, col)), shape=(row_idx, max_col + 1))65
66 x_train, x_test, y_train, y_test = train_test_split(fea_datasets, s, test_size=0.2, random_state=0)67
68 returnx_train, x_test, y_train, y_test69
70 defmain():71 x_train,x_test,y_train,y_test =load_data()72 #用L2正則話防止過擬合
73 model = LogisticRegression(penalty='l2')74 #模型訓練
75 model.fit(x_train,y_train)76
77 ff_w = open('model.w', 'w')78 ff_b = open('model.b', 'w')79
80 #寫入訓練出來的W
81 for w_list inmodel.coef_:82 for w inw_list:83 print >> ff_w, "w:", w84 #寫入訓練出來的B
85 for b inmodel.intercept_:86 print >> ff_b, "b:", b87 print "precision:", model.score(x_test, y_test)88 print "MSE:", np.mean((model.predict(x_test) - y_test) ** 2)89
90 if __name__ == '__main__':91 main()
好了，所有的一切都準備好了，我們下來就進行推薦系統的實現
3.6、推薦系統實現
推薦系統demo流程
(1)解析請求：userid，itemid
(2)加載模型：加載排序模型(model.w，model.b)
(3)檢索候選集合：利用cb，cf去redis里面檢索數據庫，得到候選集合
(4)獲取用戶特征：userid
(5)獲取物品特征：itemid
(6)打分(邏輯回歸，深度學習)，排序
(7)top-n過濾
(8)數據包裝(itemid->name)，返回
推薦系統的實現主要就是我們前面說的這幾部分，思路很明確，需要大家細細看下代碼。
main.py
1 #coding=utf-8
2 importweb3 importsys4 importredis5 importjson6 importmath7
8 urls =(9 '/', 'index',10 '/test', 'test',11 )12
13 app =web.application(urls, globals())14
15 #加載user特征
16 user_fea_dict ={}17 with open('../data/user_feature.data') as fd:18 for line infd:19 userid, fea_list_str = line.strip().split('\t')20 user_fea_dict[userid] =fea_list_str21
22
23 #加載item特征
24 item_fea_dict ={}25 with open('../data/item_feature.data') as fd:26 for line infd:27 ss = line.strip().split('\t')28 if len(ss) != 2:29 continue
30 itemid, fea_list_str =ss31 item_fea_dict[itemid] =fea_list_str32
33 classindex:34 defGET(self):35 r = redis.Redis(host='master', port=6379,db=0)36 #step 1 : 解析請求，上面我們已經得到userid，itemid
37 params =web.input()38 userid = params.get('userid', '')39 req_itemid = params.get('itemid', '')40
41 #step 2 : 加載模型
42 model_w_file_path = '../rankmodel/model.w'
43 model_b_file_path = '../rankmodel/model.b'
44
45 model_w_list =[]46 model_b =0.47 with open (model_w_file_path, 'r') as fd:48 for line infd:49 ss = line.strip().split(' ')50 if len(ss) != 3:51 continue
52 model_w_list.append(float(ss[2].strip()))53
54 with open (model_b_file_path, 'r') as fd:55 for line infd:56 ss = line.strip().split(' ')57 model_b = float(ss[2].strip())58
59 #step 3 : 檢索候選(match)，這里我們分兩次，cb，cf
60 #將檢索回來的item全部放到recallitem列表里面
61 rec_item_mergeall =[]62 #3.1 cf
63 cf_recinfo = 'null'
64 key = '_'.join(['CF', req_itemid])65 ifr.exists(key):66 cf_recinfo =r.get(key)67
68 if len(cf_recinfo) > 6:69 for cf_iteminfo in cf_recinfo.strip().split('_'):70 item, score = cf_iteminfo.strip().split(':')71 rec_item_mergeall.append(item)72
73 #3.2 cb
74 cb_recinfo = 'null'
75 key = '_'.join(['CB', req_itemid])76 ifr.exists(key):77 cb_recinfo =r.get(key)78 if len(cb_recinfo) > 6:79 for cb_iteminfo in cb_recinfo.strip().split('_'):80 item, score = cb_iteminfo.strip().split(':')81 rec_item_mergeall.append(item)82
83 #step 4: 獲取用戶特征,將獲取的用戶特征處理后放到字典里面，方便后續計算內積
84 user_fea = ''
85 if userid inuser_fea_dict:86 user_fea =user_fea_dict[userid]87
88 u_fea_dict ={}89 for fea_idx in user_fea.strip().split(' '):90 ss = fea_idx.strip().split(':')91 if len(ss) != 2:92 continue
93 idx =int(ss[0].strip())94 score = float(ss[1].strip())95 u_fea_dict[idx] =score96
97 #step 5: 獲取物品的特征 ,循環遍歷剛剛得到itemid，判斷item是否在item特征中，若在開始進行處理
98 rec_list =[]99 for itemid inrec_item_mergeall:100 if itemid initem_fea_dict:101 item_fea =item_fea_dict[itemid]102
103 i_fea_dict =dict()104 for fea_idx in item_fea.strip().split(' '):105 ss = fea_idx.strip().split(':')106 if len(ss) != 2:107 continue
108 idx =int(ss[0].strip())109 score = float(ss[1].strip())110 i_fea_dict[idx] =score111
112 #我們得到召回item對應的特征和用戶的特征，我們接下來根據模型求出來的w，b，進行打分
113 wx_score =0.114 #這里我們求個內積，wx，然后做sigmoid，先將兩個字典拼接起來，然后計算分數
115 for fea, score in dict(u_fea_dict.items() +i_fea_dict.items()).items():116 wx_score += (score *model_w_list[fea])117
118 #計算sigmoid: 1 / (1 + exp(-wx))
119 final_rec_score = 1 / (1 + math.exp(-(wx_score +model_b)))120 #將itemid和分數放入列表中，方便后續排序
121 rec_list.append((itemid, final_rec_score))122
123 #step 6 : 精排序(rank)
124 rec_sort_list = sorted(rec_list, key=lambda x:x[1], reverse=True)125
126 #step 7 : 過濾(filter)
127 rec_fitler_list = rec_sort_list[:10]128
129 #step 8 : 返回+包裝(return)，進行將itemid轉換成name
130
131 item_dict ={}132 with open('../data/name_id.dict', 'r') as fd:133 for line infd:134 raw_itemid, name = line.strip().split('\t')135 item_dict[raw_itemid] =name136
137 ret_list =[]138 for tup inrec_fitler_list:139 req_item_name =item_dict[req_itemid]140 item_name =item_dict[tup[0]]141 item_rank_score = str(tup[1])142 ret_list.append('->'.join([req_item_name, item_name, item_rank_score]))143
144 ret = '\n'.join(ret_list)145
146 returnret147
148 classtest:149 defGET(self):150 printweb.input()151 return '222'
152
153 if __name__ == "__main__":154 app.run()
驗證：
192.168.150.10:9999/?userid=00370d83b51febe3e8ae395afa95c684&itemid=3880409156
下面附上一張完整的音樂推薦系統流程結構圖：
總結
以上是生活随笔為你收集整理的python音乐推荐系统_音乐推荐系统的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 掘金浏览器插件安装图文教程
- 下一篇： python xpath定位打印元素_p