推荐算法学习2-MXNET 实现movielen 融合个性化推荐

上篇文章记录了使用矩阵分解的方法来做个性化推荐。本篇文章参考了 http://book.paddlepaddle.org/08.recommender_system/ 上面的融合推荐算法，由于本人目前的精力放在学习MXNET上，所以将其用mxnet进行改写了。由于时间关系，暂时省略了原算法中对title的向量提取，预计下一篇会补充对title的CNN向量提取。

1. 数据准备

 MovieLens 百万数据集（ml-1m）。ml-1m 数据集包含了 6,000 位用户对 4,000 部电影的 1,000,000 条评价（评分范围 1~5 分，均为整数），由 GroupLens Research 实验室搜集整理。提示：原数据的分割符是'::', 可以用文本工具打开，替换成','或者'\t', 这样在使用pandas加载的时候能使用C库，否则加载数据非常慢。

1）movies.dat 每列分别是movieid, title, categories, 例如：1Toy Story (1995) Animation|Children's|Comedy。

需要注意的是电影类型也就是电影标签，一部电影可以有多个标签。比如上面的电影，类型是三种Animation，Children's，Comedy。

2）ratings.dat 每列分别是userid, movieid, score, time-stamp，表示用户对电影的评分。最后一列时间数据本例未使用

3）users.dat 是记录用户profile，分别是userid, gender, age 年龄段, job 职业类型，最后一列不知道是什么东东，本例未使用。

2. 自定义 DataIter和DataBatch，用于装载训练数据

跟上篇案例的类似，只是做了一点小变化，data.append(mx.nd.array(np.array(_data.tolist()),self.ctx))

import mxnet as mx
import numpy as np
class SimpleBatch(object):
    def __init__(self, data, label, pad=0):
        self.data = data
        self.label = label
        self.pad = pad

class SimpleBatch(object):
    def __init__(self, data, label, pad=0):
        self.data = data
        self.label = label
        self.pad = pad
class CustDataIter2:
    def __init__(self, data_names, data_gen, data_shape,
                 label_names, label_gen, label_shape,ctx,  batch_size,total_batches):
        self.data_names = data_names
        self.label_names = label_names
        self.data_gen = data_gen
        self.label_gen = label_gen
        self.data_shape = data_shape
        self.label_shape = label_shape
        self.batch_size = batch_size
        self.total_batches = total_batches
        self.cur_batch = 0
        self.ctx = ctx

    def __iter__(self):
        return self

    def reset(self):
        self.cur_batch = 0

    def __next__(self):
        return self.next()

    @property
    def provide_data(self):
        return zip(self.data_names,self.data_shape)

    @property
    def provide_label(self):
        return zip(self.label_names,self.label_shape)

    def next(self):
        if self.cur_batch < self.total_batches:
            data = []
            for tdata in self.data_gen:
                _data = tdata[self.cur_batch*self.batch_size:(self.cur_batch+1)*self.batch_size]
                data.append(mx.nd.array(np.array(_data.tolist()),self.ctx))
            assert len(data) > 0, "Empty batch data."
            label = []
            for tlabel in self.label_gen:
                _label = tlabel[self.cur_batch*self.batch_size:(self.cur_batch+1)*self.batch_size]
                label.append(mx.nd.array(_label,self.ctx))
            assert len(label) > 0, "Empty batch label."
            self.cur_batch += 1
            # print('Return batch %d' % self.cur_batch)
            return SimpleBatch(data, label)
        else:
            raise StopIteration
           

3. 加载训练数据

分别有3个文件要装入，性别不是int型，所以需要进行变换。

def LoadRatingData(fname,delimiter='::'):
    df = pd.read_csv(fname,header=None,delimiter=delimiter,names=['userid','itemid','score','timestamp'])
    return df

def gendercoding(x):
    if x =='M':
        return 2
    else:
        return 1

def LoadUserData(fname,delimiter='::'):
    df = pd.read_csv(fname,header=None,delimiter=delimiter,names=['userid','gender','age','job','other'],index_col=0)
    df['gender'] = df['gender'].apply(gendercoding)
    return df

def LoadItemData(fname,delimiter='::'):
    df = pd.read_csv(fname,header=None,delimiter=delimiter,names=['itemid','title','cat'],index_col=0)
    return df
           

4. encoding 电影类型

前面提到电影的类型是string，并且是多个值，例如Animation|Children's|Comedy。所以需要把这个值映射成一个向量来表示。 首先建立词典：

def build_categories_dic(cate):
    cat_dic={}
    cat_index = {}
    cat_vocab = []
    index = 0
    for s in cate:
        s = s.split('|')
        for x in s:
            if cat_dic.get(x) == None:
                cat_dic[x]=1
                cat_vocab.append(x)
                cat_index[x]=index
                index += 1
            else:
                cat_dic[x] += 1
    return (cat_dic,cat_vocab,cat_index)
           

然后把类型string，转换成对应的词典的index，再使用sklearn包的oneHotEncoder转成0，1编码的向量

def featureTags(catid):
    cat_dic,cat_vocab,cat_index = build_categories_dic(catid)
    encoded_cat=[]
    for cat in catid:
        s = cat.split('|')
        t = []
        for tag in s:
            index = cat_index.get(tag)
            t.append(index)
        encoded_cat.append(t)
    df_cat = pd.DataFrame(encoded_cat).fillna(0)
    return df_cat

def encodeTag(df):
    catid = df['cat']
    itemid = df.index
    catfeatures = featureTags(catid).as_matrix()
    enc = preprocessing.OneHotEncoder(sparse=False)
    x_out = enc.fit_transform(catfeatures)
    s = [i for i in x_out]
    return pd.Series(s,index=itemid,name='encoded_cat')
           

5. 定义网络

参考原文的算法，暂时忽略了title这个属性

余弦相似度损失函数，并且rescale到1-5：

def calc_cos_sim(a,b,min=1,max=5):
    x = mx.symbol.sum_axis( a*b, axis = 1)
    y = mx.symbol.sqrt(mx.symbol.sum_axis( mx.symbol.square(a), axis = 1)) * mx.symbol.sqrt(mx.symbol.sum_axis( mx.symbol.square(b), axis = 1))
    cos = x/y
    rescale = cos*(max-min)+min
    return rescale
           

定义网络结构

def get_one_layer_mlp( max_userid,  max_itemid,max_gender,max_age, max_job, k=64,):
    # user profile
    userid = mx.symbol.Variable('userid')
    gender = mx.symbol.Variable('gender')
    age = mx.symbol.Variable('age')
    job = mx.symbol.Variable('job')

    #times profile
    itemid = mx.symbol.Variable('itemid')
    # title = mx.symbol.Variable('title')
    cat = mx.symbol.Variable('cat')


    score = mx.symbol.Variable('score')
    # user latent features
    userid = mx.symbol.Embedding(data = userid, input_dim = max_userid, output_dim = k,name='userid_Embedding')
    userid = mx.symbol.FullyConnected(data = userid, num_hidden = k)
    userid = mx.symbol.Activation(data = userid, act_type="relu")

    gender = mx.symbol.Embedding(data = gender, input_dim = max_gender, output_dim = k/4,name='gender_Embedding')
    gender = mx.symbol.FullyConnected(data = gender, num_hidden = k/4)
    gender = mx.symbol.Activation(data = gender, act_type="relu")

    age = mx.symbol.Embedding(data = age, input_dim = max_age, output_dim = k/4,name='age_Embedding')
    age = mx.symbol.FullyConnected(data =age, num_hidden =  k/4)
    age = mx.symbol.Activation(data = age, act_type="relu")

    job = mx.symbol.Embedding(data = job, input_dim = max_job, output_dim = k/2,name='job_Embedding')
    job = mx.symbol.FullyConnected(data =job, num_hidden = k/2)
    job = mx.symbol.Activation(data = job, act_type="relu")

    user =  mx.symbol.concat(userid,gender,age,job,dim=1)

    # item latent features
    itemid = mx.symbol.Embedding(data = itemid, input_dim = max_itemid, output_dim = k,name='itemid_Embedding')
    itemid = mx.symbol.FullyConnected(data = itemid, num_hidden = k)
    itemid = mx.symbol.Activation(data = itemid, act_type="relu")

    cat = mx.symbol.FullyConnected(data = cat, num_hidden = k,name='cat_Fc')

    item = mx.symbol.concat(itemid,cat,dim=1)
    pred = calc_cos_sim(user,item,1,5)
    pred = mx.symbol.Flatten(data = pred)
    # loss layer
    pred = mx.symbol.LinearRegressionOutput(data = pred, label = score)
    return pred
           

网络结构如下：

6. 训练函数

def train(network,data_train_iter,data_valid_iter, context, num_epoch,learning, learning_rate):
    logging.getLogger().info('network debug:%s',network.debug_str())
    model = mx.mod.Module(
        symbol = network,
        context=context,
        data_names=['userid', 'gender','age','job','itemid','cat'],
        label_names=['score']
    )
    model.fit(train_data = data_train_iter,
              eval_data =data_valid_iter,
              optimizer =learning,
              optimizer_params={'learning_rate':learning_rate},
              eval_metric ='RMSE',
              num_epoch = num_epoch,
              )
    return model

def trainingModel():
    TRAIN_DIR = 'C:/Users/chuanxie/PycharmProjects/mxnetlearn/data/movie/'
    ratingdf = LoadRatingData(TRAIN_DIR+'ml-1m/ratings.dat',delimiter='\t')
    userdf = LoadUserData(TRAIN_DIR+'ml-1m/users.dat',delimiter='\t')
    itemdf = LoadItemData(TRAIN_DIR+'ml-1m/movies.dat',delimiter='\t')
    np_encodedcat = encodeTag(itemdf)
    print ratingdf.shape,np_encodedcat.shape
    fulldf = ratingdf.join(userdf,on='userid').join(itemdf,on='itemid').join(np_encodedcat,on='itemid')

    '''reconstruct series to dataframe'''
    matrix_encoded_cat = fulldf['encoded_cat'].as_matrix()
    df_encoded_cat = np.array(matrix_encoded_cat.tolist())
    print df_encoded_cat.shape

    data = np.array([fulldf['userid'],fulldf['gender'],fulldf['age'],fulldf['job'],fulldf['itemid'],fulldf['encoded_cat']])
    print data.shape
    label = np.array([fulldf['score']])

    context = mx.gpu()
    BATCH_SIZE = 16000
    num_epoch = 100
    trainIter = CustDataIter2(['userid', 'gender','age','job','itemid','cat'],data,
                             [(BATCH_SIZE,),(BATCH_SIZE,),(BATCH_SIZE,),(BATCH_SIZE,),(BATCH_SIZE,),(BATCH_SIZE,df_encoded_cat.shape[1])],
                             ['score'],label,[(BATCH_SIZE,)],context,BATCH_SIZE,data.shape[1]/BATCH_SIZE)

    max_userid = pd.Series(fulldf['userid']).max()
    max_itemid = pd.Series(fulldf['itemid']).max()
    max_gender = pd.Series(fulldf['gender']).max()
    max_age = pd.Series(fulldf['age']).max()
    max_job = pd.Series(fulldf['job']).max()

    net =get_one_layer_mlp( max_userid=max_userid,  max_itemid=max_itemid,max_gender=max_gender,
                            max_age = max_age , max_job = max_job, k=96)
    mx.viz.plot_network(net,shape={'userid':(128,),'gender':(128,),'age':(128,),'job':(128,),'itemid':(128,),'cat':(128,73)})

    ##Train module
    train(net,trainIter,None,context,num_epoch=num_epoch,learning = 'adam',learning_rate=0.001)

if __name__ == '__main__':
    trainingModel()
           

7. 运行结果

迭代100次就能把平均根方差降到0.7X，而前一篇文章单纯使用矩阵分解的算法迭代了1000次也只能达到0.9X，可见融合模型不仅加入了客户的行为数据，还融合了客户的自然属性，电影的自然属性，数据更加全面，因而准确度越高 INFO:root:Epoch[91] Train-RMSE=0.765856

INFO:root:Epoch[91] Time cost=7.528

INFO:root:Epoch[92] Train-RMSE=0.765861

INFO:root:Epoch[92] Time cost=7.575

INFO:root:Epoch[93] Train-RMSE=0.765705

INFO:root:Epoch[93] Time cost=7.794

INFO:root:Epoch[94] Train-RMSE=0.765217

INFO:root:Epoch[94] Time cost=7.455

INFO:root:Epoch[95] Train-RMSE=0.765055

INFO:root:Epoch[95] Time cost=7.401

INFO:root:Epoch[96] Train-RMSE=0.765331

INFO:root:Epoch[96] Time cost=7.409

INFO:root:Epoch[97] Train-RMSE=0.765364

INFO:root:Epoch[97] Time cost=7.401

INFO:root:Epoch[98] Train-RMSE=0.765842

INFO:root:Epoch[98] Time cost=7.425

INFO:root:Epoch[99] Train-RMSE=0.766367

INFO:root:Epoch[99] Time cost=7.445