Datawhale 实践项目 天池赛中零基础入门推荐系统 Task01 赛题理解+Baseline 笔记[让我看看]

1赛题理解+Baseline

1.1 赛题理解

赛题理解是切入一道赛题的基础，会影响后续特征工程和模型构建等各种工作，也影响着后续发展工作的方向，正确了解赛题背后的思想以及赛题业务逻辑的清晰，有利于花费更少时间构建更为有效的特征模型， 在各种比赛中， 赛题理解都是极其重要且必须走好的第一步， 今天我们就从赛题的理解出发， 首先了解一下这次赛题的概况和数据，从中分析赛题以及大致的处理方式， 其次我们了解模型评测的指标，最后对赛题的理解整理一些经验。

PS:认识理解项目背景的重要性,这会为后面的特征构建与模型建立打好基础,也许这就是"扣好数据分析这衣服的第一颗扣子" .哈哈哈

1.2 赛题简介

此次比赛是新闻推荐场景下的用户行为预测挑战赛， 该赛题是以新闻APP中的新闻推荐为背景， 目的是要求我们根据用户历史浏览点击新闻文章的数据信息预测用户未来的点击行为， 即用户的最后一次点击的新闻文章， 这道赛题的设计初衷是引导大家了解推荐系统中的一些业务背景， 解决实际问题。

1.3 数据概况

该数据来自某新闻APP平台的用户交互数据，包括30万用户，近300万次点击，共36万多篇不同的新闻文章，同时每篇新闻文章有对应的embedding向量表示。为了保证比赛的公平性，从中抽取20万用户的点击日志数据作为训练集，5万用户的点击日志数据作为测试集A，5万用户的点击日志数据作为测试集B。具体数据表和参数， 大家可以参考赛题说明。下面说一下拿到这样的数据如何进行理解， 来有效的开展下一步的工作。

`1.4 评价方式理解

理解评价方式， 我们需要结合着最后的提交文件来看， 根据sample.submit.csv， 我们最后提交的格式是针对每个用户， 我们都会给出五篇文章的推荐结果，按照点击概率从前往后排序。 而真实的每个用户最后一次点击的文章只会有一篇的真实答案， 所以我们就看我们推荐的这五篇里面是否有命中真实答案的。比如对于user1来说， 我们的提交会是：

user1, article1, article2, article3, article4, article5.

评价指标的公式如下：

假如article1就是真实的用户点击文章，也就是article1命中， 则s(user1,1)=1, s(user1,2-4)都是0， 如果article2是用户点击的文章， 则s(user,2)=1/2,s(user,1,3,4,5)都是0。也就是score(user)=命中第几条的倒数。如果都没中， 则score(user1)=0。 这个是合理的， 因为我们希望的就是命中的结果尽量靠前， 而此时分数正好比较高。

1.5 Baseline

1.5.1 导包

开始上菜

import time,math,os
from tqdm import tqdm
import gc
import pickle
import random
from datetime import datetime
from operator import itemgetter
import numpy as np
import warnings
from collections import defaultdict
warnings.filterwarnings('ignore')
import pandas as pd

设置一下路径

data_path = './data/'
save_path = './tmp_results/'

1.5.2 df节省内存函数

def reduce_men(df):
    starttime = time.time()
    numerics = ['int16','int32','int64','float16','float32','float64']
    start_men = df.memory_usage().sum() / 1024**2
    for col in df.columns:
        if col_type in numerics:
            c_min = df[col].min()
            c_max = df[col].max()
            if pd.isnull(c_min) or pd.isnull(c_max):
                continue
            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)
    end_mem = df.memory_usage().sum() / 1024**2
    print('-- Mem. usage decreased to {:5.2f} Mb ({:.1f}% reduction),time spend:{:2.2f} min'.format(end_mem,
                                                                                                           100*(start_mem-end_mem)/start_mem,
                                                                                                           (time.time()-starttime)/60))
    return df

1.5.3 读取采样或全量数据

# debug 模式:从训练集中划出一部分数据来调试代码
def get_all_click_sample(data_path,sample_nums=100000):
    '''
       训练集中采样一部分数据调试
       data_path : 原数据的存储路径
       sample_nums : 采样数目(这里由于机器的内存限制,可以采用用户做)??
    '''
    all_click = pd.read_csv(data_path + 'train_click_log.csv')
    all_user_ids = all_click.user_id.unique()
                                  # 1
    sample_user_ids = np.random.choice(all_user_ids,size = sample_nums,replace = False)                                      # 2
    all_click = all_click[all_click['user_id'].isin(sample_user_ids)]

    all_click = all_click.drop_duplicates(['user_id','click_article_id','click_timestamp'])
    return all_click

思考
本来想all_click =all_click.drop_duplicates([‘user_id’,‘click_article_id’,‘click_timestamp’])
既然drop_duplicates可以删除所选列中出现重复的,只保留第一条
那为什么要做前面的步骤,想了一下有以下几点

1 这是想随机抽取sample_nums数量 用户id唯一的数据
2 要做到1 就要先刷选用户id唯一的存在,用random.choice方法选出唯一的编号all_click
3 然后用isin()方法筛选用户id唯一的并存在all_click中
4 然后再筛选user_id,click_article_id,click_timestamp唯一的数据集
5 完成了get_all_click_sample这个函数

1 np.random.choice(a, size, replace, p)
其作用是按要求生成一个一维数组 a是生成一维数组的来源，可以是int类型，可以是数组，也可以是list size 为从a中抽取的个数，即生成数组的维度 replace 表示从a中是否不重复抽取，默认可重复 p 给出抽取概率，默认随机

2 isin()函数

这个函数就是用来清洗数据，删选过滤掉DataFrame中一些行。

# 读取点击数据，这里分成线上和线下，如果是为了获取线上提交结果应该讲测试集中的点击数据合并到总的数据中
# 如果是为了线下验证模型的有效性或者特征的有效性，可以只使用训练集
def get_all_click_df(data_path='./',offline=True):
    if offline:
        all_click = pd.read_csv(data_path + 'train_click_log.csv')
    else:
        trn_click = pd.read_csv(data_path + 'train_click_log.csv')
        tst_click = pd.read_csv(data_path + 'testA_click_log.csv')
        
        all_click = trn_click.append(tst_click)
        
    all_click = all_click.drop_duplicates((['user_id','click_article_id','click_timestamp']))
    return all_click

# 全量训练集
all_click_df = get_all_click_df(offline = False)

1.5.4 获取 用户 - 文章 - 点击时间字典

# 根据点击时间获取用户的点击文章序列   {user1: {item1: time1, item2: time2..}...}
def get_user_item_time(click_df):
    
    click_df = click_df.sort_values('click_timestamp')
    
    def make_item_time_pair(df):
        return list(zip(df['click_article_id'],df['click_timestamp']))
    
    user_item_time_df = click_df.groupby('user_id')['click_article_id', 'click_timestamp']\
    .apply(lambda x: make_item_time_pair(x))\
    .reset_index().rename(columns={0: 'item_time_list'})
    
    user_item_time_dict = dict(zip(user_item_time_df['user_id'],user_item_time_df['item_time_list']))
    
    return user_item_time_dict

**(1)**zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

**(2)**在jupyter notebook中可以解决换行的问题

1.5.5 itemCF的物品相似度计算

def itemcf_sim(df):
    '''
        文章与文章之间的相似性矩阵计算
        :param df:   数据表
        :item_created_time_dict  :  文章创建时间的字典
        return  文章与文章的相似性矩阵
        思路:  基于物品的协同过滤(详细请参考上一期推荐系统的组队学习,)
        在多路召回部分 会加上关联规则的召回策略
    '''
    user_item_time_dict = get_user_item_time(df)
    #计算物品相似度
    i2i_sim = {}
    item_cnt = defaultdict(int)
    #defaultdict的作用是在于，当字典里的key不存在但被查找时，返回的不是keyError而是一个默认值
    #Tqdm 是一个快速，可扩展的Python进度条，可以在 Python 长循环中添加一个进度提示信息，用户只需要封装任意的迭代器 tqdm(iterator)。使用pip就可以安装。
    for user,item_time_list in tqdm(user_item_time_dict.items()):
        # 在基于商品的协同过滤优化的时候可以考虑时间因素
        for i ,i_click_time in item_time_list:
            item_cnt[i] += 1
            i2i_sim.setdefault(i,{})
            for j,j_click_time in item_time_list:
                if(i == j):
                    continue
                i2i_sim[i].setdefault(j,0)
    #Python 字典 setdefault() 函数和 get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值

                i2i_sim[i][j] += 1 /math.log(len(item_time_list) + 1) #???

    i2i_sim_ = i2i_sim.copy()
    for i, related_items in i2i_sim.items():
        for j ,wij in related_items.items():
            i2i_sim_[i][j] = wij / math.sqrt(item_cnt[i] * item_cnt[j])

    # 将得到的相似性矩阵保存到本地
    pickle.dump(i2i_sim_,open(save_path + 'itemcf_i2i_sim.pkl','wb'))

    return i2i_sim_

查看一下具体是什么
sort()里面的关键字用法

1.5.6 itemCF 的文章推荐

# 基于商品的召回i2i
def item_based_recommend(user_id, user_item_time_dict, i2i_sim, sim_item_topk, recall_item_num, item_topk_click):
    """
        基于文章协同过滤的召回
        :param user_id: 用户id
        :param user_item_time_dict: 字典, 根据点击时间获取用户的点击文章序列   {user1: {item1: time1, item2: time2..}...}
        :param i2i_sim: 字典，文章相似性矩阵
        :param sim_item_topk: 整数， 选择与当前文章最相似的前k篇文章
        :param recall_item_num: 整数， 最后的召回文章数量
        :param item_topk_click: 列表，点击次数最多的文章列表，用户召回补全        
        return: 召回的文章列表 {(item1:score1), (item2: score2)...}
        注意: 基于物品的协同过滤(详细请参考上一期推荐系统基础的组队学习)， 在多路召回部分会加上关联规则的召回策略
    """
    
    # 获取用户历史交互的文章
    user_hist_items = user_item_time_dict[user_id]
    user_hist_items_ = {user_id for user_id, _ in user_hist_items}
    
    item_rank = {}
    for loc, (i, click_time) in enumerate(user_hist_items):
        for j, wij in sorted(i2i_sim[i].items(), key=lambda x: x[1], reverse=True)[:sim_item_topk]:
            if j in user_hist_items_:
                continue
                
            item_rank.setdefault(j, 0)
            item_rank[j] +=  wij
    
    # 不足10个，用热门商品补全
    if len(item_rank) < recall_item_num:
        for i, item in enumerate(item_topk_click):
            if item in item_rank.items(): # 填充的item应该不在原来的列表中
                continue
            item_rank[item] = - i - 100 # 随便给个负数就行
            if len(item_rank) == recall_item_num:
                break
    
    item_rank = sorted(item_rank.items(), key=lambda x: x[1], reverse=True)[:recall_item_num]
        
    return item_rank

1.5.7 给每个用户根据物品的协同过滤推荐文章

# 定义
user_recall_items_dict = collections.defaultdict(dict)

# 获取 用户 - 文章 - 点击时间的字典
user_item_time_dict = get_user_item_time(all_click_df)

# 去取文章相似度
i2i_sim = pickle.load(open(save_path + 'itemcf_i2i_sim.pkl', 'rb'))

# 相似文章的数量
sim_item_topk = 10

# 召回文章数量
recall_item_num = 10

# 用户热度补全
item_topk_click = get_item_topk_click(all_click_df, k=50)

for user in tqdm(all_click_df['user_id'].unique()):
    user_recall_items_dict[user] = item_based_recommend(user, user_item_time_dict, i2i_sim, 
                                                        sim_item_topk, recall_item_num, item_topk_click)

1.5.8 召回字典转换成df

# 将字典的形式转换成df
user_item_score_list = []

for user, items in tqdm(user_recall_items_dict.items()):
    for item, score in items:
        user_item_score_list.append([user, item, score])

recall_df = pd.DataFrame(user_item_score_list, columns=['user_id', 'click_article_id', 'pred_score'])

1.5.9 生成提交文件

# 生成提交文件
def submit(recall_df, topk=5, model_name=None):
    recall_df = recall_df.sort_values(by=['user_id', 'pred_score'])
    recall_df['rank'] = recall_df.groupby(['user_id'])['pred_score'].rank(ascending=False, method='first')
    
    # 判断是不是每个用户都有5篇文章及以上
    tmp = recall_df.groupby('user_id').apply(lambda x: x['rank'].max())
    assert tmp.min() >= topk
    
    del recall_df['pred_score']
    submit = recall_df[recall_df['rank'] <= topk].set_index(['user_id', 'rank']).unstack(-1).reset_index()
    
    submit.columns = [int(col) if isinstance(col, int) else col for col in submit.columns.droplevel(0)]
    # 按照提交格式定义列名
    submit = submit.rename(columns={'': 'user_id', 1: 'article_1', 2: 'article_2', 
                                                  3: 'article_3', 4: 'article_4', 5: 'article_5'})
    
    save_name = save_path + model_name + '_' + datetime.today().strftime('%m-%d') + '.csv'
    submit.to_csv(save_name, index=False, header=True)

# 获取测试集
tst_click = pd.read_csv(data_path + 'testA_click_log.csv')
tst_users = tst_click['user_id'].unique()

# 从所有的召回数据中将测试集中的用户选出来
tst_recall = recall_df[recall_df['user_id'].isin(tst_users)]

# 生成提交文件
submit(tst_recall, topk=5, model_name='itemcf_baseline')

有点蒙了后面 傻傻分不清了

提交结果到阿里天池