推荐算法_CIKM-2019-AnalytiCup 冠军源码解读

最近在帮一初创app写推荐系统，顺便学习一波用户兴趣高速检索的冠军算法。

写总结前贴出冠军代码的git地址：https://github.com/ChuanyuXue/CIKM-2019-AnalytiCup

该算法分三步：基于Apririo的item_CF、特征提取、排序。

先看第一步，item_CF可以说是很传统的算法了。该步被作者分为七个部分：

1、generate_user_logs：把用户分组，并在每个组中统计用户的行为日志，以方便后续的并行化处理

import multiprocessing as mp
import time
import pandas as pd
import numpy as np

def reduce_mem_usage(df):
    """ iterate through all the columns of a dataframe and modify the data type
        to reduce memory usage.        
    """
    start_mem = df.memory_usage().sum() 
    print('Memory usage of dataframe is {:.2f} MB'.format(start_mem))
    
    for col in df.columns:
        col_type = df[col].dtype
        
        if col_type != object:
            c_min = df[col].min()
            c_max = df[col].max()
            if str(col_type)[:3] == 'int':
                if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max:
                    df[col] = df[col].astype(np.int8)
                elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max:
                    df[col] = df[col].astype(np.int16)
                elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max:
                    df[col] = df[col].astype(np.int32)
                elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max:
                    df[col] = df[col].astype(np.int64)  
            else:
                if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max:
                    df[col] = df[col].astype(np.float16)
                elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max:
                    df[col] = df[col].astype(np.float32)
                else:
                    df[col] = df[col].astype(np.float64)
        else:
            df[col] = df[col].astype('category')

    end_mem = df.memory_usage().sum() 
    print('Memory usage after optimization is: {:.2f} MB'.format(end_mem))
    print('Decreased by {:.1f}%'.format(100 * (start_mem - end_mem) / start_mem))
    
    return df

def generate_logs_for_each_group(matrix, q):
    user_log = dict()
    for row in matrix:
        user_log.setdefault(row[0], [])
        user_log[row[0]].append(row[1])
    print('This batc is finished')
    q.put(user_log)

reduce_mem_usage()使用了机器学习中panda输入数据通用的内存优化方法，通过memory_usage().sum()统计矩阵的内存使用量，np.iinfo().min()/max()分别用于找到一个列表中的最小/大数，这里np.iinfo(int8).min()/max()的作用类似于找到该数据类型的最小/大值，比较矩阵中的数据是否处于该区间，若处于，则通过astype()的方法改变数据类型，使其运算占用的内存空间最小；在循环遍历的过程中，要保证数据的类型是由范围由小到大排序的。

generate_logs_for_each_group用于构建用户日记字典，其中setdefault()用于在用户日志字典中添加键与对应的默认值；

主函数：

data = reduce_mem_usage(pd.read_csv(path+'user_behavior.csv', header=None))
user = pd.read_csv(path+'user.csv', header=None)
item = pd.read_csv(path+'item.csv', header=None)

data['day'] = data[3] // 86400
data['hour'] = data[3] // 3600 % 24

data = data.drop(3, axis=1)

data.columns = ['userID','itemID','behavoir','day','hour']
user.columns = ['userID', 'sex', 'age', 'ability']
item.columns = ['itemID', 'category', 'shop', 'band']

data = data.drop_duplicates(['userID','itemID'],keep="last")
data = data.sort_values(['day','hour'], ascending=True).reset_index(drop=True)

users = list(set(user['userID']))

user_groups = [users[i: i + len(users) // CPU_NUMS] for i in range(0, len(users), len(users) // CPU_NUMS)]

q = mp.Queue()
for groupID in range(len(user_groups)):
    matrix = data[data['userID'].isin(user_groups[groupID])][['userID','itemID']].values
    task = mp.Process(target=generate_logs_for_each_group, args=(matrix, q, ))
    task.start()
    
start_time = time.time()
print('Waiting for the son processing')
while q.qsize() != len(user_groups):
    pass
end_time = time.time()
print("Over, the time cost is:"  + str(end_time - start_time))
for i in range(len(user_groups))：
　　 temp = q.get()
　　 f = open('full_logs/userlogs_group' + str(i) + '.txt','w')
　　 f.write(str(temp))
　　 f.close()

主函数执行数据的导入与处理。这里要注意的就是整个用户组根据CPU的数量被分为几组，以多进程的方式执行generate_logs_for_each_group，生成行首为userID，后跟itemID的矩阵；

最后将生成的用户日志写入文件。

2、generate_hot_table：生成中间文件hot_map（统计的商品的出现次数）、upwardmap与downward_map（商品id映射到实数集[0, m]，其中m代表商品总数）与usersActivity_map（用户活跃度）。

import pandas as pd
import numpy as np

# round2 train的路径
path = '../ECommAI_EUIR_round2_train_20190816/'
data = pd.read_csv(path + 'user_behavior.csv',header=None)

data.columns = ['userID','itemID','behavior','timestamp']
data['day'] = data['timestamp'] // 86400
data['hour'] = data['timestamp'] // 3600 % 24

user_times = data[['itemID','userID']].groupby('userID', as_index=False).count()

user_times.columns = ['userID','itemCount']

user_times_map = dict(zip(user_times['userID'], user_times['itemCount']))

len(user_times_map)

f = open('usersActivity_map.txt', 'w')
f.write(str(user_times_map))
f.close()

 这段代码使用groupby().count()对数据按userID进行分类，并对每组数目进行统计，统计所得的数标签为'itemCount'，随后与userID一起被写入字典，作为用户活跃度map写入文件；

from sklearn import preprocessing
le = preprocessing.LabelEncoder()
item['encoding'] = le.fit_transform(item['itemID'])

upward_map = dict(zip(item['itemID'], item['encoding']))
downward_map = dict(zip(item['encoding'], item['itemID']))

在这里preprocessing.LabelEncoder()被用于给商品编号，fit_transform对商品编号序列进行归一化处理，最后生成商品id映射。

temp = data[['itemID','behavior']].groupby('itemID',as_index=False).count()
hot_map = dict(zip(temp['itemID'], temp['behavior']))

groupby().count()用法同上。按商品id分组统计，算出商品出现次数。

文件的最后是保存文件函数，不多做解释。

def save_to_file(trans_map, file_path):
    trans_map = str(trans_map)
    f = open(file_path, 'w')
    f.write(trans_map)
    f.close()

save_to_file(hot_map,'hot_items_map.txt')

save_to_file(upward_map,'upward_map.txt')

save_to_file(downward_map,'downward_map.txt')

 3、generate_original_matrix：统计每个group中的相似度矩阵。

import pandas as pd
import numpy as np
import sys
from scipy.sparse import lil_matrix
import scipy as scp
import time
%load_ext Cython

ITEM_NUM = 4318201

def get_logs_from_hardisk(path):
    f = open(path, 'r')
    a = f.read()
    dict_name = eval(a)
    f.close()
    return dict_name


f = open('usersActivity_map.txt', 'r')
m = f.read()
user_times_map = eval(m)
f.close()

导入数据，不多解释。

import datetime
import math

cpdef calculate_matrix(mat, list user_logs, dict user_times_map):
    cdef int index, i1, i2, count
    cdef list item_log
    cdef tuple u
    
    count = 0
    for u in user_logs:
        count += 1
        if count % 1000 == 0:
            print('The %d'%count + ' users are finished.')
            print(datetime.datetime.now().strftime('%H:%M:%S'))
            
        item_log = u[1]   

        for index, i1 in enumerate(item_log):
            for i2 in item_log[(index+1): ]:
                weight = 1/(math.log(1+user_times_map[u[0]]))
                mat[i1, i2] += weight
                mat[i2, i1] += weight
    return mat

这部分数据用于计算物品相似度矩阵，在第一个文件生成用户行为日志中，对每一行进行计算，每个用户的item序列对应每行中第二个元素开始的列表；循环遍历物品列表，将物品与所有它之后的物品的相似度加w，w为用户对推荐系统的贡献度，由之前的第二个文件生成的用户活跃度表提供参数，计算公式为：

$w_u=frac{1}{log(l_u+1)}$

其中l_u为用户活跃度。下面是计算相似度矩阵的主函数：

user_logs = get_logs_from_hardisk('full_logs/userlogs_group0.txt')
f = open('upward_map.txt','r')
upward_map = eval(f.read())
f.close()
for u in user_logs:
    user_logs[u] = [int(upward_map[x]) for x in user_logs[u]]
user_logs = list(user_logs.items())


for i in range(0, len(user_logs), 10000):
    print('The %d '%i + ' batch is started!')
    print('--------------------------------')
    mat = lil_matrix((ITEM_NUM+1, ITEM_NUM+1), dtype=float)
    mat = calculate_matrix(mat, user_logs[i: i + 10000], user_times_map)
    scp.sparse.save_npz('tmpData/sparse_matrix_%d_batch_group0.npz'%i, mat.tocsr())
    print('save successfully')
    print('--------------------------------')

调入用户日志，调入itemID-实数的文件（用于规范矩阵、减小矩阵规模），将用户日志中的itemID用1~m的实数代替；使用lil_matrix()新建矩阵，分组计算物品相似度，并将相似度矩阵文件保存，第三步操作到此结束。

 4、Merge：将多个group中的相似性矩阵合并。

import pandas as pd
import numpy as np
from scipy.sparse import *
import scipy
import os

path = 'tmpData/'

lenth = 359850
for i in range(0, 12):
    mat = None
    start = lenth * i
    end = lenth * (i + 1)
    count = 0
    for name in os.listdir('tmpData/'):
        if name[-3:] == 'npz':
            if mat == None:
                mat = load_npz(path + name)[start: end]
            else:
                mat += load_npz(path + name)[start: end]
        count += 1
    scipy.sparse.save_npz('commonMatrix/common_matrix_from_%d_to_%d.npz'%(start, end), mat)
    print('save success for %d batch'%i)
    print('-------------------------')

功能官方文档写的很明显了。主要思想就是分段合并相加相似度矩阵。

5、Save_sparse_to_dense：将相似性矩阵转化为可供快速检索的哈希结构。

import numpy as np
from scipy.sparse import *
import os

os.listdir('commonMatrix/')

for name in os.listdir('commonMatrix/'):
    mat = load_npz('commonMatrix/' + name).tolil()
    l = []
    for i in range(mat.shape[0]):
        _, a, b = find(mat[i])
        index = np.where(b > 1.5)
        #l.append(sorted(list(zip(a[index], b[index])),key= lambda x:x[1], reverse=True))
        
        c = np.array( [round(x,3) for x in b] )
        l.append(sorted(list(zip(a[index], c[index])),key= lambda x:x[1], reverse=True))
        
    l = str(l)
    f = open('common_dense_valued_small/' + name, 'w')
    f.write(l)
    f.close()
    print('finished')

 这段矩阵转哈希表程序首先读入相似度矩阵，对矩阵的每一行进行处理，使用mat()将数组转换成矩阵，使用find()找到非零元素的下标并储存值，下一步将非零元素中大于1.5的元素排序（我也不知道为什么要取1.5 可能是为了降低运算量而作的剪枝），地址和数值被加入表项中。

 6、6_Sta_for_SparseMatrix：用于对相似度的改进

import pandas as pd
import numpy as np
import time
from scipy.sparse import *
import os
import re

## 统计每个商品的打分次数（用train）
f = open('hot_items_map.txt', 'r')
rating_times_map = eval(f.read())
f.close()


item_dict = {}

for name in os.listdir('common_dense_valued_small/'):
    start_time = time.time()
    f = open('common_dense_valued_small/' + name, 'r')
    l = f.read()
    l = eval(l)
    f.close()
    end_time = time.time()
    print('load file: %d sec'%((end_time - start_time)))    
    
    name = re.findall(r'd+', name)
    start = int(name[0])
    end = int(name[1])

    
    start_time = time.time()
    
    
    for i in range(start, end):
        tmp_list = []
        [tmp_list.append( (x[0], round(x[1] / rating_times_map[i], 4) ) ) for x in l[i - start] if x[0] != i]
        if len(tmp_list) > 0:
            item_dict[i] = sorted(tmp_list,key=lambda x:x[1], reverse=True)[:500]
            
    end_time = time.time()
    print('This batch is finished, time cost: %d sec'%((end_time - start_time)))

这个文件涉及正则表达式和上一个文件生成的哈希表，首先读入之前生成的商品热度表与哈希表，通过正则表达式findall()读出文件名中的开始item序号与结束item序号（文件命名按分组区间，如：'common_matrix_from_3598500_to_3958350.npz'）遍历这个区间内item的哈希表，每个item i、j之间的相似度都除以i的商品热度，作为热度过高的商品的惩罚（若一件商品很热门，则不管用户喜不喜欢，用户对其作出行为的可能性都很大，极有可能出现在不同用户的行为列表中，这样会使得相似度偏大）。将惩罚处理过的哈希表装入item_dict中。

最后，将生成的item_dict写入文件。

f = open('item_Apriori.txt','w')
f.write(str(item_dict))
f.close()

7、generate_recall：官方没有写特别说明，个人理解为这是最后的数据召回。

import pandas as pd
import numpy as np

def load_data(path):
    user = pd.read_csv(path + 'user.csv',header=None)
    item = pd.read_csv(path + 'item.csv',header=None)
    data = pd.read_csv(path + 'user_behavior.csv',header=None)

    data.columns = ['userID','itemID','behavior','timestamp']
    data['day'] = data['timestamp'] // 86400
    data['hour'] = data['timestamp'] // 3600 % 24

    ## 生成behavior的加权
    data['day_hour'] = data['day'] + data['hour'] / float(24)
    data.loc[data['behavior']=='pv','behavior'] = 1
    data.loc[data['behavior']=='fav','behavior'] = 2
    data.loc[data['behavior']=='cart','behavior'] = 3
    data.loc[data['behavior']=='buy','behavior'] = 1
    max_day = max(data['day'])
    min_day = min(data['day'])
    data['behavior'] = (1 - (max_day-data['day_hour']+2)/(max_day-min_day+2)) * data['behavior'] 

    item.columns = ['itemID','category','shop','brand']
    user.columns = ['userID','sex','age','ability']

    data = pd.merge(left=data, right=item, on='itemID',how='left')
    data = pd.merge(left=data, right=user, on='userID',how='left')

    return user, item, data

首先还是熟悉的数据导入操作，与前面不同的是这里加入了用户行为权值，通过.loc方法将数值赋值到数据矩阵相应的行。最后使用merge()对用户行为数据、用户数据与商品数据进行拼接，这样一条信息就包含用户（ID、性别、年龄etc）、商品（品牌、价格、店家etc）、行为信息了。

def get_recall_list(train, targetDay, k=300):
    train_logs = dict()
    
    if targetDay > max(train['day']):
        for row in train[['userID','itemID','behavior']].values:
            train_logs.setdefault(row[0], dict())
            if row[1] in upward_map:
                train_logs[row[0]].setdefault(upward_map[row[1]],0)
                train_logs[row[0]][upward_map[row[1]]] = max(train_logs[row[0]][upward_map[row[1]]],row[2])
    else:
        user_List_test = set(train.loc[train['day']==targetDay,'userID'])
        train = train[train['day'] < targetDay]
        
        for row in train[['userID','itemID','behavior']].values:
            if row[0] in user_List_test:
                train_logs.setdefault(row[0], dict())
                if row[1] in upward_map:
                    train_logs[row[0]].setdefault(upward_map[row[1]],0)
                    train_logs[row[0]][upward_map[row[1]]] = max(train_logs[row[0]][upward_map[row[1]]],row[2])

    for each_user in train_logs:
        sum_value = sum(train_logs[each_user].values())
        if sum_value > 0:
            for each_item in train_logs[each_user]:
                train_logs[each_user][each_item] /= sum_value            

    result_logs = dict()    
    for u in train_logs:
        result_logs.setdefault(u, list())
        for i in set(train_logs[u].keys()):
            if i in item_dict:
                tmp_list = [ (x[0], train_logs[u][i]*x[1]) for x in item_dict[i]]
                result_logs[u] += tmp_list
            
    for u in result_logs:
        result_logs[u] = get_unique_inorder([(downward_map[x[0]], x[1]) for x in sorted(result_logs[u], key=lambda x:x[1], reverse=True)
                          if x[0] not in train_logs[u]], k=300)  
    
    return result_logs

这部分可以说是代码中的核心部分了，倘若要计算的日期大于最大时间戳，则在训练文件中加入用户ID-空字典的键值对，如果该条信息中用户作出行为，则在itemID-编号字典中找出编号作为用户ID-dict()中，字典的键，之前的行为权值取最大值作为值加入。

若预测天数小于最大时间戳，则取数据矩阵中天数是目标天数以前的数据，取目标天数数据作为测试集（代码示例中并未用到）；之后所做的与预测大于最大时间戳的操作相同。

对于训练集[(uesrID，itemID, value),……]中的每个user，首先将其键下所有的值相加，在用各个值除以相加所得的和，这步起到数据归一化的作用。

然后是生成对于每个用户物品最终分值的一步，每个用户所对应的每批产生过行为的商品，将归一化的行为权值乘以矩阵中每个与每个物品的相似度，所得结果就是对这个用户而言，每个商品的兴趣度，以[用户，[(商品，兴趣度)……]]排列。

接着将生成的序列降序排序，同时调用downward_map将编号映射回itemID，使用get_unique_inorder()去重，最终result_logs就是对每个用户来说兴趣度最大的300个商品列表矩阵。

最后是几个格式变换函数：

def generate_pairs(recall):
    result = []
    for u in recall:
        for i in recall[u]:
            result.append([u,i[0],i[1]])
    return result

def reshape_recall_to_dataframe(recall):
    result = generate_pairs(recall)
    result = pd.DataFrame(result)
    result.columns = ['userID','itemID','apriori']
    return result

在主函数中，召回矩阵首先从[ [用户，[(商品，兴趣度)……] ] ……]的格式转换为[ [用户，商品，兴趣度]……]，再被加注标签，最后写入csv文件：

#path = './'
path = '../ECommAI_EUIR_round2_train_20190816/'

## The target date(16 means online, 15 means underline test, 14 means underline train)
targetday = 15

## The lenth of recall list, the default is 300
lenth = 300

## The name of generated recall file

name = 'recall_list_round2_%dday_%dlenth.csv'%(targetday, lenth)


user, item, data = load_data(path = path)   

#tempory_path = './tempory_file/'
tempory_path = './'
f = open(tempory_path + 'upward_map.txt','r')

upward_map = f.read()
upward_map = eval(upward_map)
f.close()
    
f = open(tempory_path + 'downward_map.txt','r')
downward_map = f.read()
downward_map = eval(downward_map)
f.close()

f = open(tempory_path + 'item_Apriori.txt','r')
tmp = f.read()
item_dict = eval(tmp)
f.close()

recall_logs = get_recall_list(data, targetDay=targetday, k=lenth)

recall_df = reshape_recall_to_dataframe(recall_logs)

temp = pd.merge(left=recall_df, right=data[data['day'] == targetday][['userID','itemID','behavior']], 
         on=['userID','itemID'], how='left').rename(columns={'behavior':'label'})

len(set(recall_df['userID']) & set(data[data['day'] == targetday]['userID']))

len(set(recall_df['userID']))

recall_df.to_csv(name, index=False)

其中还穿插着一些行为引入的操作；至此，基于apriori的itemCF源码分析就结束了。

给我的感受是整个itemCF中数学统计的原理非常简单，代码的精巧体现在对多维度数据的处理和利用上。