精华内容
下载资源
问答
  • jdata_sql_basic-源码

    2021-03-30 17:31:36
    jdata_sql_basic
  • jdata_shop.csv

    2020-03-04 12:18:59
    jdata,用户购买意向预测 使用数据集。这是商铺表。网上有用户提供,但是要的积分太多了。我要恶性竞争一下。其余资源 链接:https://pan.baidu.com/s/1yZCHFf2EmF0p3hFuewA1Ug 提取码:23ty
  • jdata_product.csv

    2019-05-27 10:16:59
    2019京东JDATA算法大赛(用户对品类下店铺的购买预测)商品表,比赛总结:https://drguo.blog.csdn.net/article/details/90514911。 其余数据下载:https://pan.baidu.com/s/1mQf-haFZP38er7FMDxpQWg 提取码:mxlo
  • JData京东算法大赛入门程序
  • JDATA 腾讯广告赛

    2017-10-09 05:17:30
    JDATA与腾讯社交广告赛个人小结
    • 本文是京东JData算法大赛-高潜用户购买意向预测和腾讯社交广告高校算法大赛的经历和总结

    JDATA

    • 任务:通过数据挖掘的技术和机器学习的算法,构建用户购买商品的预测模型,输出高潜用户和目标商品的匹配结果,为精准营销提供高质量的目标群体
    • 参赛队伍4240 我的排名342

    JDATA算是我第一次参加的大型带奖金比赛 =#= 大约是2017.4月我被我的好友机器变得更残忍拉入机器学习的坑。然后推荐我去kaggle打入门的house prices和digit recognizer。这时候JDATA已经开赛了,但萌新入门,完全不会。

    还是先看kaggle上的kernels做入门题吧。4.16把houseprice做到1100名。在做house price时还不会处理非数值型数据,就简单把数值型的筛出来,然后用SVM跑了下。pandas也基本不会用(当时只是会python基础语法)。代码仅仅50行吧。

    好歹有了点成绩,虽然很烂,但也可以稍稍激励下自己嘛。digit recognizer 到没有做出来,debug也不成功,放弃了。

    这时候,JDATA也开了3星期左右了。 想着混混感受下氛围的原则,下载数据,准备开搞。在群里潜水了一段时间,发现有规则和模型2条路。模型,暂时不会用,先试试规则吧。比如前几周加到购物车但没有购买的,作为目标用户的购买意向物品。试了几个,发现效果还可以,最好的提交排名达到了600名。怎么办,语法有瓶颈而且规则确实不熟悉,不知道该怎么提分了。还是看看模型吧。


    数据放在几个表里,怎么才能提到一起呢,merge一下。非数值型的如月份怎么办,先不管,凉拌,把数值型的弄到一起,用svm和linear regression跑了下 == 不出所料,很烂。这时候知识不够了,上网看看有人介绍思路没。发现了个时间滑动窗口特征的构造。(那个时候还不会自己写,于是找了个处理时间的框架,把代码改了用)。好了,时间处理好了。模型跑一跑,吐血,还是不怎么样,没有到前500。看了下群里推荐xgboost(当时也不了解这是什么,只知道这个工具包很厉害)。想着,下载安装跑一遍,看看效果。结果安装xgboost就让我弄了2天 = =(拖延症 + 烦躁)。好了, 开始运行(也不会调参),发现我的8G内存跑的炸了- -

    好吧,不能全数据跑,就截取几个时间点做train吧。然后请教了下别人设置的参数,直接放进去(别打我),再加上debug看kernel,进复赛了 (开心!)

    然而发现复赛数据集实在是大,放弃继续弄JDATA了。

    腾讯社交广告赛

    • 任务:预测App广告点击后被激活的概率:pCVR=P(conversion=1 | Ad,User,Context),即给定广告、用户和上下文情况下广告被点击后发生激活的概率。

    • 1500个参赛队 排名120

    这是紧接着JDATA后的比赛,推荐算法类的。在打完JDATA后,知道了如何建立模型,对时间进行操作,但如何特征工程其实还是一头雾水。比赛中,尝试了tfidf、笛卡尔积特征。效果不错

    比赛中2次差点放弃,1内存8G实在是吃力,2成绩在自己努力下波动性提高,名次却平稳增长== 欲哭无泪。
    训练集构造:
    * 滑窗
    * tfidf特征:主要是用作处理< userID,AppID >这样的一对多 并由此延伸出< userID,cate1,cate2 >这样的tfidf特征
    * 笛卡儿积特征:主要是两两一起的统计特征

    采用xgboost单模型(那时仍然不会调参、哭)

    好歹擦边进了复赛= = 然后苦于数据集太大和要期末考试,没有继续打了。

    总结:

    1. 扯淡一个人比赛,又苦又累,新人更是如此,还好我有个朋友可以帮我指明下一步该如何提高。和大佬组队就可以打酱油啦~ 但收获可能会少些,毕竟他们目前的知识比我高太多,难以消化。
    2. 需要提高编程能力: 内存并不是瓶颈,采用数据抽样,就可以解决内存计算问题而且提高了效率。
    3. 这2次比赛都没有很好的特征工程,要从业务出发,多想。
    4. 调参和stacking都很重要(这部分调参可以写个库)
    5. 有真实数据使用真是太爽啦,比赛有了进步就是好事~
    展开全文
  • jdata2019top20的总结,干货满满,能学到很多东西
  • 2018年京东JDATA算法 大赛:"如期而至"-用户购买时间预测,方案分享-附件资源
  • 表1:sku基本信息表(jdata_sku_basic_info) 表2:用户基本信息表(jdata_user_basic_info) 表3:用户行为表(jdata_user_action) 表4:用户订单表(jdata_u...

    年前做的,也是学习别人的作品作为记录

     

    一、赛题

      

    表1:sku基本信息表(jdata_sku_basic_info)

     

     

     

     

    表2:用户基本信息表(jdata_user_basic_info)

     

     

     

     

     

    表3:用户行为表(jdata_user_action)

     

     

     

     

     

     

    表4:用户订单表(jdata_user_order)

     

     

     

     

     

    表5:评论分数数据表(jdata_user_comment_score)

     

     

     

     

    数据说明:

     

     

     

    任务:

    根据提供的数据,预测未来一个月内最有可能购买目标品类的用户,并预测首次购买日期

     

     

    二、思路

      1.提取数据及预处理        data_load.py

        ①加载数据

        ②将日期转为pandas形式,处理分别得到年月日

        ③统计订单评价等级和次数

        ④得到三个dataframe

    Jdata_user_order:user_id,sku_id,o_id,o_date,o_area,o_sku_num,o_date_y,o_date_m,           o_date_d,price,cate,para_1,para_2,para_3,score_level_1_count,score_level_2_count,

            Score_level_3_count,cost

    Jdata_user_action:user_id,sku_id,a_date,a_num,a_type,a_date_y,a_date_m,a_date_d,price,cate,para_1,para_2,para_3

     

    Jdata_user_basic_info:user_id,age_-1,age_1,age_2,age_3,age_4,age_5,age_6,sex_0,sex_1,sex_2,user_lv_cd_1, user_lv_cd_2, user_lv_cd_3, user_lv_cd_4, user_lv_cd_5

        ⑤特征选择     feat_main.py  feature.py

     


    参考特征:

    与购买相关的特征:

    订单数/商品数/商品种类/购买次数/有购买行为的天数/有购买行为的月数

    与浏览和收藏相关的特征:

    行为(浏览或收藏)商品数/行为(浏览或收藏)商品种类/行为(浏览或收藏)天数/收藏商品数/收藏商品种类/有收藏行为的天数

    地理信息:

    用户下单过的地点数/用户订单数最大的地点编号

    参数信息:

    用户所购买商品price/para1/para2/para3的最大值最小值平均值中位数

    用户花费:

    用户的总花费

    用户购买集中度:

    用户购买集中度=购买的商品次数/购买的商品种类

    用户商品忠诚度:

    用户购买同一sku的最大次数

    用户购买转化率:

    用户购买转化率=用户购买的商品种类/用户有行为(浏览或收藏)的商品种类

    日期特征:

    购买的最小的day/最大的day/平均的day

    近3个月/5个月 月首购买日期的最大、最小、平均、中位数

     

    三、代码

    不知道博客园怎么上传文件,zzz

    先不上传了

    转载于:https://www.cnblogs.com/1113127139aaa/p/10385916.html

    展开全文
  • 【浪叫兽】京东JData算法赛经验总结

    万次阅读 2017-04-03 17:45:35
    申明:本文由浪叫兽对京东JData算法大赛的总结,行文略微口语化,但是不得不说,真正琢磨过数据的人才能发  现更多内在的东西。Mark,学习一下。 0.055规则很简单的,就是type5 大于 2,就这一条就可以了。...

    申明:本文由浪叫兽对京东JData算法大赛的总结,行文略微口语化,但是不得不说,真正琢磨过数据的人才能发

              现更多内在的东西。Mark,学习一下。


    0.055规则很简单的,就是type5 大于 2,就这一条就可以了。我们搞的是kdd,主要是知识发现,所以大多是重

     eda(探索分析) etl(数据清洗),数据清洗和探索,使用现有的数据挖掘框架。重头戏还是在eda etl,我们只是使用框架,重复 eda etl


    你没发现老王经常说的一句话吗,为啥比你分高,说明数据里面还有规律你没找到,你坚信你不比别人笨,就探索

    数据,就一点能和第一拉进距离,我觉得吧老王经常重复这句话对我启发也很大,我们都是在一个挖掘框架体系下

    堆积代码而已,本身就是没有跳出发现阶段,既然是发现,越高的人不过是多了份运气 ,比你早发现规律,但是

    时间上你努力应该是要追平差距,重复性的去对数据和结果进行eda,不过比赛很有套路的是要看评分标准。


    在给大家一个全局性的京东赛方案,看你们要玩规则还是模型,主要京东赛 你要设计好评分公式 ,我们都知道京

    东赛要滑动,带来最大的困扰是 正负样本的问题。规则走的是细挖,模型走的是多次过滤,控制阀值,设计好整

    体的框架在探索特征,加入第一层和第二层分别看效果,这是模型的路子。




    第一个是看第一层的模型输出的个数 能不能解决正负比,在看后面的最高分设定阈值,就是说我理论上都对了,


    能达到什么分evalpf3(gz[(gz.user_id.isin(gz_true.user_id))&(gz.pred > 0.5)],gz_true)。评分给上,如果都对 


    能多少分,以预测概率为大于 0.5的阀值为准,那么我降低要求,我只要第一层分出的,最高分越高,我就考虑降


    低阀值,你第二层的理论最高分就高上去了。



    但你要考虑第一层输出的答案个数,这个比你直接堆积获得的正负比是不在一个档次,就这个思想就决定了你要高

    别人一筹了,当然依次可以设计 第二层,第三层 ,这就是模型的建模思路了。在说规则把,你们都说规则不可以

    解释,但是如果大家都用的同一个测试集,一样的优化思路,和模型也是相当的威力,我给大家举一个例子。


             基础规则大家都知道,加入了购物车的 不会重复购买,这些我们自然给打上


    这里我们就需要控制输出个数了 ,首先我用我的规则给你们演示,看看我这个输出的答案是多少,不过规则我把

    8天的都卷进来了,有点耗内存




    看见没有,规则 只要输出 230 个就线下 0.046  ,这个规则我提交过,说明这条规则就放出几百个答案



    我们加上我们要分析的大头,就是  都加入过购物车的



    先开一个区间,最后一天加入购物车的。



    看见没有输出的个数又多了几百个,分也上去了,用户个数也多了 ,这个正负比我们还是能接受的 10 个里面 有一个 是对的人 

    我们开一个区间,就是前面两天加入了购物车的都提交,看看线下得分:


           答案个数为 1000 个,对的user_id67 个,评分又多了 ,所以你看看京东赛的聊天记录  有人会说加了两天的购物车 的规则会更好,并不是线下测试不出来的,这个正负样本比我们还能接受 ,继续在放一个区间


    其实我们这里总体来说是一条规则 ,就是加入了购物车的 ,这个是整体的基础规则

    答案个数 1600 多个,对了80 多个用户,这里要是你想夺 0.1,就考虑对这个1600 个用户继续加细分规则

    类似这种


    我给第一天的加上限制规则,运行



         发现答案少了200 多个,线下分也低了,那么很简单的思,我把大于 改为小于,这逻辑大家都知道吧


          不过有点打脸的是这个区间好像在前面的区间包含了,所以应该 三天的都加上



          反复实验只能证明这个区间可以提高比例



    所以上肉眼看看


            这样就看看取什么值合理了,反正整体的思路就是开大区间之后做细分 ,控制输出的个数的准确率,如果有什么好规则能删除一些 user_id 和 sku_id ,细分下去的困难就越小,模型是我输出10000 个都行,我在用第二层优化,规则是  我宁愿只输出 200个,但是我要保证正确率。特征决定模型的上线,对规则和模型算法来说是一样的。

            规则对分布和概率,要有深刻的认识,真心能玩到老王那样的程度了 ,这种探索是家常便饭,有时候我都搞不清到底是规则让人弱智还是模型让人弱智 ,还是都让人玩久了变弱智,概率分布召回,准确率,其实大家都是在玩这几个玩意而已,并没什么高尚的,耐心细心 加上很深刻的知道我们不过是在一个框架里面发现东西而已,人家说 cv就是cv ,stacking 就是 stacking,他就是一个框架里面的工具。
     
    通过看评分,看你放了多少个样本进来


    就这个规则来说,你就放了  1600 多个,对了  86 个,你自己算算,把这个规则过滤后放入模型训练



    和你放出这么多个,对了 713 个,怎么样能让你走好下一步,你自己权衡



    总比你放入全集   样本严重失去平衡来的好把,这些是没人会告诉你们的 ,反过来



           我就用规则的这几百个,加入到 我最后的答案里面 ,本来 最后一天大家 一个是  0.210 ,一个是 0.209 ,我前期故意保留这个规则得分,最后一天绝杀0.211 ,这不就是规则党喜欢干的么,计算规则的得分具体能增加多少,以达到绝杀的目的,或是  0.20  0.21 ,我看你还努力,我直接 加到 0.22 了,你觉得提升 0.001 都难的情况下,我干到了 一次提高  0.22 ,士气上是不是压倒趋势,还有前期我用规则把样本搞到了50:1 ,而你 一直是100:1 的模型,我随便训练就秒杀你啊,这些东西你们在外面是听不到的  ,而且这个也是我自己一直在思考规则和模型的区别做的一个小总结,至于大家玩比赛喜欢怎么玩,喜欢什么战略,很难摸清楚的。就规则来说: 

            我加了这个细分,我线下是降低了,但是我完全可以提交一下,说不好 线上就是涨的呢,那我就保留这个区间的值呗,或者你完全可以继续线下干到 0.2 ,这里就存在先验试探了,你本身不知道这个规则是会让线上上升的,但是你通过测试,保留了这个区间的取值,而你线下是降低的,这不就是耍流氓吗,而且随着你的规则到了0.2,你这个试探性区间就毫无影响了,规则和模型都可以干这种事情。
            以信心知道  你不比第一名差,拉近距离到前十,剩下的很多就看看算了,除非是换数据后的第一次得分,其实换数据也不一定知道有没有用了技巧,最终可能获胜在一个小知识点上,全局上说不好前 20 都可能是一个解决方案,是大局上的,只是细致的内容不一样而已,我们做的工作是发现,本身就不是什么高大上的玩意。套路上的东西 一点就会了,实在不会看看博客也行了 。
            这么多规则一点一点堆起来效果是有了,线上会不会有点乱?不要细分过厉害啊,硬是扣那一个值是 11  还是 12,实在有疑惑,你就提交呗,线上会给你反馈的,这很舒服的事情啊,反正不要细分太严重了 ,规则一样有过拟合啊,而且值 一样可以用算法调优的。


           比方说我决定了,我就用这些特征了,那我写一个网格,for,我给 一个 步长,是  1 2 3 4 5 6 7 8 9 10 ,还是  2 4 6 7 8 10,我线下暴力一下,不就可以了,细分的 1 2 3 4 5 6 7 8 9 10 ,我发现这个长度过低,线下好,线上差了,我试试 下一个步长呗。我只用四月份数据,规则和机器学习一样,都可以优化寻参,没你们想的那么无脑了,不同的比赛 要设计不同的规则 ,还有优化方向和有效特征,特征个数过多,也是头疼的,说不好规则认为预测5 天的 label置信度不高,我就预测三天的,那就用最后三天建规则啊,这也是个活的东西,我发现五天线下 0.1,线上 0.6,三天线下0.7,线上 0.55 ,我明显会去用三天建规则啊。谁傻用五天啊,所以这个也是个拟合成分,看看参赛者是什么心态了,我们玩数据讲究的就是一个理,怎么分高怎么干,至于道德,很多人只认钱的,就我玩比赛一年了,这些东西东西从来没人总结过,都是我自己琢磨出来的,你们听过类似的比赛技巧 ??数据比赛圈很多不道德的行为的,且行且看。
            有时候你就是到了 20 名 也不要觉的 第一名的方案比你好,要知道自己是学习的就可以了,其实前三可能就有一个菜鸟,运气好,干到前面去了,比方说我,走一次运就上去了哈,本身也没比你们厉害多少。
            这种合理对于挖掘来说就是正当的思考过程,反正以后找到什么漏子,不要喷我就行了,我个人学识尚浅,有的东西不一定说的对,其实也不要误解规则党了,规则党和模型党本来就是一起了,都是探索而已:


    滑窗


           滑窗的话,你看看隐马尔可夫的那个,公式怎么简化的,就一下明白了,这样滑窗的方法还是很多的。

          首先你假设 后面一天的数据只和窗口有关系,用五天来说就是你可以把 5天的数据堆在一起,1 - 5 天的数据变成 5 列,后面的一天的结果拼接给堆积好的那天就行了。一般你只滑一次会有问题,那么你就要叠加在往前面的一天的,这样样本就是卷起来一样,按一天天的叠加上去了,不过这个都是我的理解,至于是不是这样解释我也不清楚


           比方说一天有 6 个特征,我滑五天就有 5 * 6 列,卷积越多,内存足够大,效果越好。这个是我理解的 一个卷的行为,至于是不是  理论上的卷积,我没看过理论书。滑窗之后由之前的 六列特征变成30,在一天天的堆积上去,这训练样本就很明显的有一个滑 一个卷的过程。







    展开全文
  • 赛题网址:https://jdata.jd.com/html/detail.html?id=8 赛题背景 京东零售集团坚持“以信赖为基础、以客户为中心的价值创造”这一经营理念,在不同的消费场景和连接终端上,在正确的时间、正确的地点为3亿多活跃.....

    前言

            偶然间在群里看到有人发了这个比赛,查了一下才知道这是京东举行的第三届JDATA算法大赛,可我从来没有听说过,有种被时代抛弃的感觉😢。我自从2016年参加了阿里天池的几个比赛之后就没有关注过这方面,一是工作比较忙,二是自己变懒了,唉。听说腾讯每年也举办什么广告算法大赛,感兴趣的同学可以参加一下,此外还有kaggle等等。这次比赛也只是打了个酱油,毕竟工作了,没有上学时那么多时间,而且现在的同学都太厉害了😆。虽然成绩不怎么样(89/1401),但我觉得这个流程还是值得记录和分享一下的。需注意的是,特征工程决定上限,而其余步骤只是逼近这个上限。最后,期待大佬们的分享~

    赛题介绍

    赛题:https://jdata.jd.com/html/detail.html?id=8
    数据:https://download.csdn.net/download/dr_guo/11207507
    在这里插入图片描述
    赛题背景

    京东零售集团坚持“以信赖为基础、以客户为中心的价值创造”这一经营理念,在不同的消费场景和连接终端上,在正确的时间、正确的地点为3亿多活跃用户提供最适合的产品和服务。目前,京东零售集团第三方平台签约商家超过21万个,实现了全品类覆盖,为维持商家生态繁荣、多样和有序,全面满足消费者一站式购物需求,需要对用户购买行为进行更精准地分析和预测。基于此,本赛题提供来自用户、商家、商品等多方面数据信息,包括商家和商品自身的内容信息、评论信息以及用户与之丰富的互动行为。参赛队伍需要通过数据挖掘技术和机器学习算法,构建用户购买商家中相关品类的预测模型,输出用户和店铺、品类的匹配结果,为精准营销提供高质量的目标群体。同时,希望参赛队伍通过本次比赛,挖掘数据背后潜在的意义,为电商生态平台的商家、用户提供多方共赢的智能解决方案。

    01 /评分

    参赛者提交的结果文件中包含对所有用户购买意向的预测结果。对每一个用户的预测结果包括两方面:
    (1)该用户2018-04-16到2018-04-22是否对品类有购买,提交的结果文件中仅包含预测为下单的用户和品类(预测为未下单的用户和品类无须在结果中出现)。评测时将对提交结果中重复的“用户-品类”做排重处理,若预测正确,则评测算法中置label=1,不正确label=0。
    (2)如果用户对品类有购买,还需要预测对该品类下哪个店铺有购买,若店铺预测正确,则评测算法中置pred=1,不正确pred=0。
    对于参赛者提交的结果文件,按如下公式计算得分:score=0.4F11+0.6F12
    此处的F1值定义为:
    在这里插入图片描述
    其中:Precise为准确率,Recall为召回率; F11 是label=1或0的F1值,F12 是pred=1或0的F1值。

    02 /赛题数据

    2.1 训练数据
    提供2018-02-01到2018-04-15用户集合U中的用户,对商品集合S中部分商品的行为、评价、用户数据。
    2.2 预测数据
    提供 2018-04-16 到 2018-04-22 预测用户U对哪些品类和店铺有购买,用户对品类下的店铺只会购买一次。
    2.3 数据表说明
    在这里插入图片描述

    1)行为数据(jdata_action)
    在这里插入图片描述
    2)评论数据(jdata_comment)
    在这里插入图片描述
    3)商品数据(jdata_product)
    在这里插入图片描述
    4)商家店铺数据(jdata_shop)
    在这里插入图片描述
    5)用户数据(jdata_user)
    在这里插入图片描述

    03 /任务描述及作品要求

    3.1 任务描述
    对于训练集中出现的每一个用户,参赛者的模型需要预测该用户在未来7天内对某个目标品类下某个店铺的购买意向。

    3.2 作品要求
    提交的CSV文件要求如下:

    1. UTF-8无BOM格式编码;
    2. 第一行为字段名,即:user_id,cate,shop_id(数据使用英文逗号分隔)
      其中:user_id:用户表(jdata_user)中用户ID;cate:商品表(jdata_product)中商品sku_id对应的品类cate ;shop_id:商家表(jdata_shop)中店铺ID;
    3. 结果不存在重复的记录行数,否则无效;
      对于预测出没有购买意向的用户,在提交的CSV文件中不要包含该用户的信息。
      提交结果示例如下图:
      在这里插入图片描述

    步骤汇总

    这是我自己总结的流程,如有不对,欢迎交流指正。

    1.查看分析数据

    2.数据清洗

    3.构造数据集(特征工程)

    开始自己选的特征连0.03都上不去,后来看到Cookly 洪鹏飞开源的baseline,我基于他写的删了很多特征又加了一点特征,分数可能都没有他的baseline高,但没办法,笔记本跑不动。我测试了一下我的笔记本最高只能处理300维,说到这我要吐槽一下京东了,能不能跟阿里一样提供开发环境,我好多想法受限于硬件无法实现。
    在这里插入图片描述
    下面是代码,需要注意的是,我构造了三个数据集,分别是训练集、测试集和预测集。预测集这个大家可能没有听说过,因为往往都叫测试集,但我觉得这样叫有点乱,所以给它起了个名叫预测集,专门用来预测最终结果。测试集也有点不一样,测试集应与训练集完全不相关,用来评估模型的表现,而且用的次数不能太多。理论上讲,模型在测试集的表现与在预测集上的表现应该是差不多的。此外,训练集也可以划分为训练集和验证集,但是很多时候都没有真正的测试集,而是把训练集划分为训练集和测试集或是划分为训练集、验证集和测试集。是不是感觉有点乱,我说的也不一定对,但只需记住一点,我们只用测试集去评估模型的表现,并不会去调整优化模型,慢慢体会吧。

    import pandas as pd
    import os
    import pickle
    import datetime
    import re
    import numpy as np
    
    jdata_action_file_dir = "../../jdata/jdata_action.csv"
    jdata_comment_file_dir = "../../jdata/jdata_comment.csv"
    jdata_product_file_dir = "../../jdata/jdata_product.csv"
    jdata_shop_file_dir = "../../jdata/jdata_shop.csv"
    jdata_user_file_dir = "../../jdata/jdata_user.csv"
    
    # 减少内存使用
    def reduce_mem_usage(df, verbose=True):
        numerics = ['int16', 'int32', 'int64', 'float16', 'float32', 'float64']
        start_mem = df.memory_usage().sum() / 1024 ** 2
        for col in df.columns:
            col_type = df[col].dtypes
            if col_type in numerics:
                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)
        end_mem = df.memory_usage().sum() / 1024 ** 2
        if verbose:
            print('Mem. usage decreased to {:5.2f} Mb ({:.1f}% reduction)'.format(end_mem, 100 * (start_mem - end_mem) / start_mem))
        return df
    
    # 行为数据
    jdata_action = reduce_mem_usage(pd.read_csv(jdata_action_file_dir))
    jdata_action.drop_duplicates(inplace=True)
    del jdata_action['module_id']
    
    # 视B榜数据而定,是否删除购物车记录(A榜数据只有8号后的购物车记录)
    jdata_action = jdata_action[-jdata_action['type'].isin([5])]
    
    # 评论数据
    # jdata_comment = reduce_mem_usage(pd.read_csv(jdata_comment_file_dir))
    
    # 商品数据
    jdata_product = reduce_mem_usage(pd.read_csv(jdata_product_file_dir))
    
    # 商家店铺数据
    jdata_shop = reduce_mem_usage(pd.read_csv(jdata_shop_file_dir))
    
    # 用户数据
    jdata_user = reduce_mem_usage(pd.read_csv(jdata_user_file_dir))
    
    Mem. usage decreased to 745.30 Mb (47.5% reduction)
    Mem. usage decreased to  5.72 Mb (57.5% reduction)
    Mem. usage decreased to  0.24 Mb (57.1% reduction)
    Mem. usage decreased to 38.35 Mb (65.3% reduction)
    
    def go_split(s, symbol='-: '):
        # 拼接正则表达式
        symbol = "[" + symbol + "]+"
        # 一次性分割字符串
        result = re.split(symbol, s)
        # 去除空字符
        return [x for x in result if x]
    def get_hour(start, end):
        d = datetime.datetime(*[int(float(i)) for i in go_split(start)]) - datetime.datetime(*[int(float(i)) for i in go_split(end)])
        n = int(d.days*24 + d.seconds/60/60)
        return n
    def get_first_hour_gap(x):
        return get_hour(end_day, min(x))
    def get_last_hour_gap(x):
        return get_hour(end_day, max(x))
    def get_act_days(x):
        return len(set([i[:10] for i in x]))
    

    构造训练集-特征1天-用户品类店铺候选集7天-label7天(预测7天)

    • ‘2018-03-29’-‘2018-04-04’
    def get_train_set(end_day):
        
        # 合并数据
        jdata_data = jdata_action.merge(jdata_product, on=['sku_id'])
        
        # 候选集 7天
        # '2018-03-29'-'2018-04-04'
        train_set = jdata_data[(jdata_data['action_time'] >= '2018-03-29 00:00:00')
                               & (jdata_data['action_time'] <= '2018-04-04 23:59:59')][
            ['user_id', 'cate', 'shop_id']].drop_duplicates()
        
        # label 7天
        # '2018-04-05'-'2018-04-11'
        train_buy = jdata_data[(jdata_data['action_time'] >= '2018-04-05 00:00:00')
                               & (jdata_data['action_time'] <= '2018-04-11 23:59:59')
                               & (jdata_data['type'] == 2)][['user_id', 'cate', 'shop_id']].drop_duplicates()
        train_buy['label'] = 1
        train_set = train_set.merge(train_buy, on=['user_id', 'cate', 'shop_id'], how='left').fillna(0)
        print('标签准备完毕!')
        
    
        # 提取特征 2018-04-04 1天
        start_day = '2018-04-04 00:00:00'
        for gb_c in [['user_id'],  # 用户
                     ['cate'],  # 品类
                     ['shop_id'],  # 店铺
                     ['user_id', 'cate'],  # 用户-品类
                     ['user_id', 'shop_id'],  # 用户-店铺
                     ['cate', 'shop_id'],  # 品类-店铺
                     ['user_id', 'cate', 'shop_id']]:  # 用户-品类-店铺
            print(gb_c)
            
            action_temp = jdata_data[(jdata_data['action_time'] >= start_day)
                                     & (jdata_data['action_time'] <= end_day)]
    
            # 特征函数
            features_dict = {
                'sku_id': [np.size, lambda x: len(set(x))],
                'type': lambda x: len(set(x)),
                'brand': lambda x: len(set(x)),
                'shop_id': lambda x: len(set(x)),
                'cate': lambda x: len(set(x)),
                'action_time': [
                    get_first_hour_gap,  # first_hour_gap
                    get_last_hour_gap,  # last_hour_gap
                    get_act_days  # act_days
                ]
    
            } 
            features_columns = [c +'_' + '_'.join(gb_c)
                                for c in ['sku_cnt', 'sku_nq', 'type_nq', 'brand_nq', 'shop_nq', 'cate_nq', 'first_hour_gap', 'last_hour_gap', 'act_days']]
            f_temp = action_temp.groupby(gb_c).agg(features_dict).reset_index()
            # print(f_temp.columns)
            f_temp.columns = gb_c + features_columns
            # print(f_temp.columns)
            train_set = train_set.merge(f_temp, on=gb_c, how='left')
    
            for type_ in [1, 2, 3, 4, 5]:  # 1:浏览 2:下单 3:关注 4:评论 5:加购物车
                action_temp = jdata_data[(jdata_data['action_time'] >= start_day)
                                         & (jdata_data['action_time'] <= end_day)
                                         & (jdata_data['type'] == type_)]
                features_dict = {
                    'sku_id': [np.size, lambda x: len(set(x))],
                    'type': lambda x: len(set(x)),
                    'brand': lambda x: len(set(x)),
                    'shop_id': lambda x: len(set(x)),
                    'cate': lambda x: len(set(x)),
                    'action_time': [
                        get_first_hour_gap,  # first_hour_gap
                        get_last_hour_gap,  # last_hour_gap
                        get_act_days  # act_days
                    ]
                }
                features_columns = [c +'_' + '_'.join(gb_c) + '_type_' + str(type_)
                                    for c in ['sku_cnt', 'sku_nq', 'type_nq', 'brand_nq', 'shop_nq', 'cate_nq', 'first_hour_gap', 'last_hour_gap', 'act_days']]
                f_temp = action_temp.groupby(gb_c).agg(features_dict).reset_index()
                if len(f_temp) == 0:
                    continue
                f_temp.columns = gb_c + features_columns
                train_set = train_set.merge(f_temp, on=gb_c, how='left')
            # 浏览、关注、评论购买比,加购物车特征很重要,视B榜数据而定
            train_set['buybro_ratio_' + '_'.join(gb_c)] = train_set['sku_cnt_' + '_'.join(gb_c) + '_type_' + str(2)]/train_set['sku_cnt_' + '_'.join(gb_c) + '_type_' + str(1)]
            train_set['buyfocus_ratio_' + '_'.join(gb_c)] = train_set['sku_cnt_' + '_'.join(gb_c) + '_type_' + str(2)]/train_set['sku_cnt_' + '_'.join(gb_c) + '_type_' + str(3)]
            train_set['buycom_ratio_' + '_'.join(gb_c)] = train_set['sku_cnt_' + '_'.join(gb_c) + '_type_' + str(2)]/train_set['sku_cnt_' + '_'.join(gb_c) + '_type_' + str(4)]
            # train_set['buycart_ratio_' + '_'.join(gb_c)] = train_set['sku_cnt_' + '_'.join(gb_c) + '_type_' + str(2)]/train_set['sku_cnt_' + '_'.join(gb_c) + '_type_' + str(5)]
    
        # 用户特征
        uid_info_col = ['user_id', 'age', 'sex', 'user_lv_cd', 'city_level', 'province', 'city', 'county']
        train_set = train_set.merge(jdata_user[uid_info_col], on=['user_id'], how='left')
        print('用户特征准备完毕!')
    
        # 店铺特征
        shop_info_col = ['shop_id', 'fans_num', 'vip_num', 'shop_score']
        train_set = train_set.merge(jdata_shop[shop_info_col], on=['shop_id'], how='left')
        print('店铺特征准备完毕!')
    
        return train_set
    
    end_day = '2018-04-04 23:59:59'
    train_set = get_train_set(end_day)
    train_set.to_hdf('datasets/train_set.h5', key='train_set', mode='w')
    print(train_set.shape)  # (1560852, 350)
    # print(list(train_set.columns))
    del train_set
    
    标签准备完毕!
    ['user_id']
    ['cate']
    ['shop_id']
    ['user_id', 'cate']
    ['user_id', 'shop_id']
    ['cate', 'shop_id']
    ['user_id', 'cate', 'shop_id']
    用户特征准备完毕!
    店铺特征准备完毕!
    (1560852, 350)
    
    from collections import Counter
    train_set = pd.read_hdf('datasets/train_set.h5', key='train_set')
    y_train = train_set['label'].values
    c = Counter(y_train)
    del train_set, y_train
    print(c) 
    
    Counter({0.0: 1546311, 1.0: 14541})
    

    构造测试集-特征1天-用户品类店铺候选集7天-label7天(预测7天)

    • ‘2018-04-02’-‘2018-04-08’
    • 因为0327-28两天浏览数据严重缺失,训练集从0329开始到0404,与测试集重了三天,理论上训练集与测试集应完全不相关
    def get_test_set(end_day):
        
        # 合并数据
        jdata_data = jdata_action.merge(jdata_product, on=['sku_id'])
        
        # 候选集 7天
        # '2018-04-02'-'2018-04-08'
        test_set = jdata_data[(jdata_data['action_time'] >= '2018-04-02 00:00:00')
                               & (jdata_data['action_time'] <= '2018-04-08 23:59:59')][
            ['user_id', 'cate', 'shop_id']].drop_duplicates()
        
        # label 7天
        # '2018-04-09'-'2018-04-15'
        test_buy = jdata_data[(jdata_data['action_time'] >= '2018-04-09 00:00:00')
                               & (jdata_data['action_time'] <= '2018-04-15 23:59:59')
                               & (jdata_data['type'] == 2)][['user_id', 'cate', 'shop_id']].drop_duplicates()
        test_buy['label'] = 1
        test_set = test_set.merge(test_buy, on=['user_id', 'cate', 'shop_id'], how='left').fillna(0)
        print('标签准备完毕!')
        
        # 提取特征 2018-04-08 1天
        start_day = '2018-04-08 00:00:00'
        for gb_c in [['user_id'],  # 用户
                     ['cate'],  # 品类
                     ['shop_id'],  # 店铺
                     ['user_id', 'cate'],  # 用户-品类
                     ['user_id', 'shop_id'],  # 用户-店铺
                     ['cate', 'shop_id'],  # 品类-店铺
                     ['user_id', 'cate', 'shop_id']]:  # 用户-品类-店铺
            print(gb_c)
            
            action_temp = jdata_data[(jdata_data['action_time'] >= start_day)
                                     & (jdata_data['action_time'] <= end_day)]
    
            # 特征函数
            features_dict = {
                'sku_id': [np.size, lambda x: len(set(x))],
                'type': lambda x: len(set(x)),
                'brand': lambda x: len(set(x)),
                'shop_id': lambda x: len(set(x)),
                'cate': lambda x: len(set(x)),
                'action_time': [
                    get_first_hour_gap,  # first_hour_gap
                    get_last_hour_gap,  # last_hour_gap
                    get_act_days  # act_days
                ]
    
            } 
            features_columns = [c +'_' + '_'.join(gb_c)
                                for c in ['sku_cnt', 'sku_nq', 'type_nq', 'brand_nq', 'shop_nq', 'cate_nq', 'first_hour_gap', 'last_hour_gap', 'act_days']]
            f_temp = action_temp.groupby(gb_c).agg(features_dict).reset_index()
            # print(f_temp.columns)
            f_temp.columns = gb_c + features_columns
            # print(f_temp.columns)
            test_set = test_set.merge(f_temp, on=gb_c, how='left')
    
            for type_ in [1, 2, 3, 4, 5]:  # 1:浏览 2:下单 3:关注 4:评论 5:加购物车
                action_temp = jdata_data[(jdata_data['action_time'] >= start_day)
                                         & (jdata_data['action_time'] <= end_day)
                                         & (jdata_data['type'] == type_)]
                features_dict = {
                    'sku_id': [np.size, lambda x: len(set(x))],
                    'type': lambda x: len(set(x)),
                    'brand': lambda x: len(set(x)),
                    'shop_id': lambda x: len(set(x)),
                    'cate': lambda x: len(set(x)),
                    'action_time': [
                        get_first_hour_gap,  # first_hour_gap
                        get_last_hour_gap,  # last_hour_gap
                        get_act_days  # act_days
                    ]
                }
                features_columns = [c +'_' + '_'.join(gb_c) + '_type_' + str(type_)
                                    for c in ['sku_cnt', 'sku_nq', 'type_nq', 'brand_nq', 'shop_nq', 'cate_nq', 'first_hour_gap', 'last_hour_gap', 'act_days']]
                f_temp = action_temp.groupby(gb_c).agg(features_dict).reset_index()
                if len(f_temp) == 0:
                    continue
                f_temp.columns = gb_c + features_columns
                test_set = test_set.merge(f_temp, on=gb_c, how='left')
            # 浏览、关注、评论购买比,加购物车特征很重要,视B榜数据而定
            test_set['buybro_ratio_' + '_'.join(gb_c)] = test_set['sku_cnt_' + '_'.join(gb_c) + '_type_' + str(2)]/test_set['sku_cnt_' + '_'.join(gb_c) + '_type_' + str(1)]
            test_set['buyfocus_ratio_' + '_'.join(gb_c)] = test_set['sku_cnt_' + '_'.join(gb_c) + '_type_' + str(2)]/test_set['sku_cnt_' + '_'.join(gb_c) + '_type_' + str(3)]
            test_set['buycom_ratio_' + '_'.join(gb_c)] = test_set['sku_cnt_' + '_'.join(gb_c) + '_type_' + str(2)]/test_set['sku_cnt_' + '_'.join(gb_c) + '_type_' + str(4)]
            # test_set['buycart_ratio_' + '_'.join(gb_c)] = test_set['sku_cnt_' + '_'.join(gb_c) + '_type_' + str(2)]/test_set['sku_cnt_' + '_'.join(gb_c) + '_type_' + str(5)]
    
        # 用户特征
        uid_info_col = ['user_id', 'age', 'sex', 'user_lv_cd', 'city_level', 'province', 'city', 'county']
        test_set = test_set.merge(jdata_user[uid_info_col], on=['user_id'], how='left')
        print('用户特征准备完毕!')
    
        # 店铺特征
        shop_info_col = ['shop_id', 'fans_num', 'vip_num', 'shop_score']
        test_set = test_set.merge(jdata_shop[shop_info_col], on=['shop_id'], how='left')
        print('店铺特征准备完毕!')
    
        return test_set
    
    end_day = '2018-04-08 23:59:59'
    test_set = get_test_set(end_day)
    test_set.to_hdf('datasets/test_set.h5', key='test_set', mode='w')
    print(test_set.shape)  # (1560848, 350)
    del test_set
    
    标签准备完毕!
    ['user_id']
    ['cate']
    ['shop_id']
    ['user_id', 'cate']
    ['user_id', 'shop_id']
    ['cate', 'shop_id']
    ['user_id', 'cate', 'shop_id']
    用户特征准备完毕!
    店铺特征准备完毕!
    (1560848, 350)
    
    from collections import Counter
    test_set = pd.read_hdf('datasets/test_set.h5', key='test_set')
    y_train = test_set['label'].values
    c = Counter(y_train)
    del test_set, y_train
    print(c) 
    
    Counter({0.0: 1545471, 1.0: 15377})
    

    构造预测集-特征1天-用户品类店铺候选集7天

    • ‘2018-04-09’-‘2018-04-15’
    def get_pre_set(end_day):
        
        # 合并数据
        jdata_data = jdata_action.merge(jdata_product, on=['sku_id'])
        
        # 预测集 7天
        # '2018-04-09'-'2018-04-15' 
        pre_set = jdata_data[(jdata_data['action_time'] >= '2018-04-09 00:00:00')
                               & (jdata_data['action_time'] <= '2018-04-15 23:59:59')][
            ['user_id', 'cate', 'shop_id']].drop_duplicates()
        
        # 提取特征 2018-04-15 1天
        start_day = '2018-04-15 00:00:00'
        for gb_c in [['user_id'],  # 用户
                     ['cate'],  # 品类
                     ['shop_id'],  # 店铺
                     ['user_id', 'cate'],  # 用户-品类
                     ['user_id', 'shop_id'],  # 用户-店铺
                     ['cate', 'shop_id'],  # 品类-店铺
                     ['user_id', 'cate', 'shop_id']]:  # 用户-品类-店铺
            print(gb_c)
            
            action_temp = jdata_data[(jdata_data['action_time'] >= start_day)
                                     & (jdata_data['action_time'] <= end_day)]
    
            # 特征函数
            features_dict = {
                'sku_id': [np.size, lambda x: len(set(x))],
                'type': lambda x: len(set(x)),
                'brand': lambda x: len(set(x)),
                'shop_id': lambda x: len(set(x)),
                'cate': lambda x: len(set(x)),
                'action_time': [
                    get_first_hour_gap,  # first_hour_gap
                    get_last_hour_gap,  # last_hour_gap
                    get_act_days  # act_days
                ]
    
            } 
            features_columns = [c +'_' + '_'.join(gb_c)
                                for c in ['sku_cnt', 'sku_nq', 'type_nq', 'brand_nq', 'shop_nq', 'cate_nq', 'first_hour_gap', 'last_hour_gap', 'act_days']]
            f_temp = action_temp.groupby(gb_c).agg(features_dict).reset_index()
            # print(f_temp.columns)
            f_temp.columns = gb_c + features_columns
            # print(f_temp.columns)
            pre_set = pre_set.merge(f_temp, on=gb_c, how='left')
    
            for type_ in [1, 2, 3, 4, 5]:  # 1:浏览 2:下单 3:关注 4:评论 5:加购物车
                action_temp = jdata_data[(jdata_data['action_time'] >= start_day)
                                         & (jdata_data['action_time'] <= end_day)
                                         & (jdata_data['type'] == type_)]
                features_dict = {
                    'sku_id': [np.size, lambda x: len(set(x))],
                    'type': lambda x: len(set(x)),
                    'brand': lambda x: len(set(x)),
                    'shop_id': lambda x: len(set(x)),
                    'cate': lambda x: len(set(x)),
                    'action_time': [
                        get_first_hour_gap,  # first_hour_gap
                        get_last_hour_gap,  # last_hour_gap
                        get_act_days  # act_days
                    ]
                }
                features_columns = [c +'_' + '_'.join(gb_c) + '_type_' + str(type_)
                                    for c in ['sku_cnt', 'sku_nq', 'type_nq', 'brand_nq', 'shop_nq', 'cate_nq', 'first_hour_gap', 'last_hour_gap', 'act_days']]
                f_temp = action_temp.groupby(gb_c).agg(features_dict).reset_index()
                if len(f_temp) == 0:
                    continue
                f_temp.columns = gb_c + features_columns
                pre_set = pre_set.merge(f_temp, on=gb_c, how='left')
            # 浏览、关注、评论购买比,加购物车特征很重要,视B榜数据而定
            pre_set['buybro_ratio_' + '_'.join(gb_c)] = pre_set['sku_cnt_' + '_'.join(gb_c) + '_type_' + str(2)]/pre_set['sku_cnt_' + '_'.join(gb_c) + '_type_' + str(1)]
            pre_set['buyfocus_ratio_' + '_'.join(gb_c)] = pre_set['sku_cnt_' + '_'.join(gb_c) + '_type_' + str(2)]/pre_set['sku_cnt_' + '_'.join(gb_c) + '_type_' + str(3)]
            pre_set['buycom_ratio_' + '_'.join(gb_c)] = pre_set['sku_cnt_' + '_'.join(gb_c) + '_type_' + str(2)]/pre_set['sku_cnt_' + '_'.join(gb_c) + '_type_' + str(4)]
            # pre_set['buycart_ratio_' + '_'.join(gb_c)] = pre_set['sku_cnt_' + '_'.join(gb_c) + '_type_' + str(2)]/pre_set['sku_cnt_' + '_'.join(gb_c) + '_type_' + str(5)]
    
        # 用户特征
        uid_info_col = ['user_id', 'age', 'sex', 'user_lv_cd', 'city_level', 'province', 'city', 'county']
        pre_set = pre_set.merge(jdata_user[uid_info_col], on=['user_id'], how='left')
        print('用户特征准备完毕!')
    
        # 店铺特征
        shop_info_col = ['shop_id', 'fans_num', 'vip_num', 'shop_score']
        pre_set = pre_set.merge(jdata_shop[shop_info_col], on=['shop_id'], how='left')
        print('店铺特征准备完毕!')
    
        return pre_set
    
    end_day = '2018-04-15 23:59:59'
    pre_set = get_pre_set(end_day)
    pre_set.to_hdf('datasets/pre_set.h5', key='pre_set', mode='w')
    print(pre_set.shape)  
    print(list(pre_set.columns))
    del pre_set
    
    ['user_id']
    ['cate']
    ['shop_id']
    ['user_id', 'cate']
    ['user_id', 'shop_id']
    ['cate', 'shop_id']
    ['user_id', 'cate', 'shop_id']
    用户特征准备完毕!
    店铺特征准备完毕!
    (1569270, 349)
    ['user_id', 'cate', 'shop_id', 'sku_cnt_user_id', 'sku_nq_user_id', 'type_nq_user_id', 'brand_nq_user_id', 'shop_nq_user_id', 'cate_nq_user_id', 'first_hour_gap_user_id', 'last_hour_gap_user_id', 'act_days_user_id', 'sku_cnt_user_id_type_1', 'sku_nq_user_id_type_1', 'type_nq_user_id_type_1', 'brand_nq_user_id_type_1', 'shop_nq_user_id_type_1', 'cate_nq_user_id_type_1', 'first_hour_gap_user_id_type_1', 'last_hour_gap_user_id_type_1', 'act_days_user_id_type_1', 'sku_cnt_user_id_type_2', 'sku_nq_user_id_type_2', 'type_nq_user_id_type_2', 'brand_nq_user_id_type_2', 'shop_nq_user_id_type_2', 'cate_nq_user_id_type_2', 'first_hour_gap_user_id_type_2', 'last_hour_gap_user_id_type_2', 'act_days_user_id_type_2', 'sku_cnt_user_id_type_3', 'sku_nq_user_id_type_3', 'type_nq_user_id_type_3', 'brand_nq_user_id_type_3', 'shop_nq_user_id_type_3', 'cate_nq_user_id_type_3', 'first_hour_gap_user_id_type_3', 'last_hour_gap_user_id_type_3', 'act_days_user_id_type_3', 'sku_cnt_user_id_type_4', 'sku_nq_user_id_type_4', 'type_nq_user_id_type_4', 'brand_nq_user_id_type_4', 'shop_nq_user_id_type_4', 'cate_nq_user_id_type_4', 'first_hour_gap_user_id_type_4', 'last_hour_gap_user_id_type_4', 'act_days_user_id_type_4', 'buybro_ratio_user_id', 'buyfocus_ratio_user_id', 'buycom_ratio_user_id', 'sku_cnt_cate', 'sku_nq_cate', 'type_nq_cate', 'brand_nq_cate', 'shop_nq_cate', 'cate_nq_cate', 'first_hour_gap_cate', 'last_hour_gap_cate', 'act_days_cate', 'sku_cnt_cate_type_1', 'sku_nq_cate_type_1', 'type_nq_cate_type_1', 'brand_nq_cate_type_1', 'shop_nq_cate_type_1', 'cate_nq_cate_type_1', 'first_hour_gap_cate_type_1', 'last_hour_gap_cate_type_1', 'act_days_cate_type_1', 'sku_cnt_cate_type_2', 'sku_nq_cate_type_2', 'type_nq_cate_type_2', 'brand_nq_cate_type_2', 'shop_nq_cate_type_2', 'cate_nq_cate_type_2', 'first_hour_gap_cate_type_2', 'last_hour_gap_cate_type_2', 'act_days_cate_type_2', 'sku_cnt_cate_type_3', 'sku_nq_cate_type_3', 'type_nq_cate_type_3', 'brand_nq_cate_type_3', 'shop_nq_cate_type_3', 'cate_nq_cate_type_3', 'first_hour_gap_cate_type_3', 'last_hour_gap_cate_type_3', 'act_days_cate_type_3', 'sku_cnt_cate_type_4', 'sku_nq_cate_type_4', 'type_nq_cate_type_4', 'brand_nq_cate_type_4', 'shop_nq_cate_type_4', 'cate_nq_cate_type_4', 'first_hour_gap_cate_type_4', 'last_hour_gap_cate_type_4', 'act_days_cate_type_4', 'buybro_ratio_cate', 'buyfocus_ratio_cate', 'buycom_ratio_cate', 'sku_cnt_shop_id', 'sku_nq_shop_id', 'type_nq_shop_id', 'brand_nq_shop_id', 'shop_nq_shop_id', 'cate_nq_shop_id', 'first_hour_gap_shop_id', 'last_hour_gap_shop_id', 'act_days_shop_id', 'sku_cnt_shop_id_type_1', 'sku_nq_shop_id_type_1', 'type_nq_shop_id_type_1', 'brand_nq_shop_id_type_1', 'shop_nq_shop_id_type_1', 'cate_nq_shop_id_type_1', 'first_hour_gap_shop_id_type_1', 'last_hour_gap_shop_id_type_1', 'act_days_shop_id_type_1', 'sku_cnt_shop_id_type_2', 'sku_nq_shop_id_type_2', 'type_nq_shop_id_type_2', 'brand_nq_shop_id_type_2', 'shop_nq_shop_id_type_2', 'cate_nq_shop_id_type_2', 'first_hour_gap_shop_id_type_2', 'last_hour_gap_shop_id_type_2', 'act_days_shop_id_type_2', 'sku_cnt_shop_id_type_3', 'sku_nq_shop_id_type_3', 'type_nq_shop_id_type_3', 'brand_nq_shop_id_type_3', 'shop_nq_shop_id_type_3', 'cate_nq_shop_id_type_3', 'first_hour_gap_shop_id_type_3', 'last_hour_gap_shop_id_type_3', 'act_days_shop_id_type_3', 'sku_cnt_shop_id_type_4', 'sku_nq_shop_id_type_4', 'type_nq_shop_id_type_4', 'brand_nq_shop_id_type_4', 'shop_nq_shop_id_type_4', 'cate_nq_shop_id_type_4', 'first_hour_gap_shop_id_type_4', 'last_hour_gap_shop_id_type_4', 'act_days_shop_id_type_4', 'buybro_ratio_shop_id', 'buyfocus_ratio_shop_id', 'buycom_ratio_shop_id', 'sku_cnt_user_id_cate', 'sku_nq_user_id_cate', 'type_nq_user_id_cate', 'brand_nq_user_id_cate', 'shop_nq_user_id_cate', 'cate_nq_user_id_cate', 'first_hour_gap_user_id_cate', 'last_hour_gap_user_id_cate', 'act_days_user_id_cate', 'sku_cnt_user_id_cate_type_1', 'sku_nq_user_id_cate_type_1', 'type_nq_user_id_cate_type_1', 'brand_nq_user_id_cate_type_1', 'shop_nq_user_id_cate_type_1', 'cate_nq_user_id_cate_type_1', 'first_hour_gap_user_id_cate_type_1', 'last_hour_gap_user_id_cate_type_1', 'act_days_user_id_cate_type_1', 'sku_cnt_user_id_cate_type_2', 'sku_nq_user_id_cate_type_2', 'type_nq_user_id_cate_type_2', 'brand_nq_user_id_cate_type_2', 'shop_nq_user_id_cate_type_2', 'cate_nq_user_id_cate_type_2', 'first_hour_gap_user_id_cate_type_2', 'last_hour_gap_user_id_cate_type_2', 'act_days_user_id_cate_type_2', 'sku_cnt_user_id_cate_type_3', 'sku_nq_user_id_cate_type_3', 'type_nq_user_id_cate_type_3', 'brand_nq_user_id_cate_type_3', 'shop_nq_user_id_cate_type_3', 'cate_nq_user_id_cate_type_3', 'first_hour_gap_user_id_cate_type_3', 'last_hour_gap_user_id_cate_type_3', 'act_days_user_id_cate_type_3', 'sku_cnt_user_id_cate_type_4', 'sku_nq_user_id_cate_type_4', 'type_nq_user_id_cate_type_4', 'brand_nq_user_id_cate_type_4', 'shop_nq_user_id_cate_type_4', 'cate_nq_user_id_cate_type_4', 'first_hour_gap_user_id_cate_type_4', 'last_hour_gap_user_id_cate_type_4', 'act_days_user_id_cate_type_4', 'buybro_ratio_user_id_cate', 'buyfocus_ratio_user_id_cate', 'buycom_ratio_user_id_cate', 'sku_cnt_user_id_shop_id', 'sku_nq_user_id_shop_id', 'type_nq_user_id_shop_id', 'brand_nq_user_id_shop_id', 'shop_nq_user_id_shop_id', 'cate_nq_user_id_shop_id', 'first_hour_gap_user_id_shop_id', 'last_hour_gap_user_id_shop_id', 'act_days_user_id_shop_id', 'sku_cnt_user_id_shop_id_type_1', 'sku_nq_user_id_shop_id_type_1', 'type_nq_user_id_shop_id_type_1', 'brand_nq_user_id_shop_id_type_1', 'shop_nq_user_id_shop_id_type_1', 'cate_nq_user_id_shop_id_type_1', 'first_hour_gap_user_id_shop_id_type_1', 'last_hour_gap_user_id_shop_id_type_1', 'act_days_user_id_shop_id_type_1', 'sku_cnt_user_id_shop_id_type_2', 'sku_nq_user_id_shop_id_type_2', 'type_nq_user_id_shop_id_type_2', 'brand_nq_user_id_shop_id_type_2', 'shop_nq_user_id_shop_id_type_2', 'cate_nq_user_id_shop_id_type_2', 'first_hour_gap_user_id_shop_id_type_2', 'last_hour_gap_user_id_shop_id_type_2', 'act_days_user_id_shop_id_type_2', 'sku_cnt_user_id_shop_id_type_3', 'sku_nq_user_id_shop_id_type_3', 'type_nq_user_id_shop_id_type_3', 'brand_nq_user_id_shop_id_type_3', 'shop_nq_user_id_shop_id_type_3', 'cate_nq_user_id_shop_id_type_3', 'first_hour_gap_user_id_shop_id_type_3', 'last_hour_gap_user_id_shop_id_type_3', 'act_days_user_id_shop_id_type_3', 'sku_cnt_user_id_shop_id_type_4', 'sku_nq_user_id_shop_id_type_4', 'type_nq_user_id_shop_id_type_4', 'brand_nq_user_id_shop_id_type_4', 'shop_nq_user_id_shop_id_type_4', 'cate_nq_user_id_shop_id_type_4', 'first_hour_gap_user_id_shop_id_type_4', 'last_hour_gap_user_id_shop_id_type_4', 'act_days_user_id_shop_id_type_4', 'buybro_ratio_user_id_shop_id', 'buyfocus_ratio_user_id_shop_id', 'buycom_ratio_user_id_shop_id', 'sku_cnt_cate_shop_id', 'sku_nq_cate_shop_id', 'type_nq_cate_shop_id', 'brand_nq_cate_shop_id', 'shop_nq_cate_shop_id', 'cate_nq_cate_shop_id', 'first_hour_gap_cate_shop_id', 'last_hour_gap_cate_shop_id', 'act_days_cate_shop_id', 'sku_cnt_cate_shop_id_type_1', 'sku_nq_cate_shop_id_type_1', 'type_nq_cate_shop_id_type_1', 'brand_nq_cate_shop_id_type_1', 'shop_nq_cate_shop_id_type_1', 'cate_nq_cate_shop_id_type_1', 'first_hour_gap_cate_shop_id_type_1', 'last_hour_gap_cate_shop_id_type_1', 'act_days_cate_shop_id_type_1', 'sku_cnt_cate_shop_id_type_2', 'sku_nq_cate_shop_id_type_2', 'type_nq_cate_shop_id_type_2', 'brand_nq_cate_shop_id_type_2', 'shop_nq_cate_shop_id_type_2', 'cate_nq_cate_shop_id_type_2', 'first_hour_gap_cate_shop_id_type_2', 'last_hour_gap_cate_shop_id_type_2', 'act_days_cate_shop_id_type_2', 'sku_cnt_cate_shop_id_type_3', 'sku_nq_cate_shop_id_type_3', 'type_nq_cate_shop_id_type_3', 'brand_nq_cate_shop_id_type_3', 'shop_nq_cate_shop_id_type_3', 'cate_nq_cate_shop_id_type_3', 'first_hour_gap_cate_shop_id_type_3', 'last_hour_gap_cate_shop_id_type_3', 'act_days_cate_shop_id_type_3', 'sku_cnt_cate_shop_id_type_4', 'sku_nq_cate_shop_id_type_4', 'type_nq_cate_shop_id_type_4', 'brand_nq_cate_shop_id_type_4', 'shop_nq_cate_shop_id_type_4', 'cate_nq_cate_shop_id_type_4', 'first_hour_gap_cate_shop_id_type_4', 'last_hour_gap_cate_shop_id_type_4', 'act_days_cate_shop_id_type_4', 'buybro_ratio_cate_shop_id', 'buyfocus_ratio_cate_shop_id', 'buycom_ratio_cate_shop_id', 'sku_cnt_user_id_cate_shop_id', 'sku_nq_user_id_cate_shop_id', 'type_nq_user_id_cate_shop_id', 'brand_nq_user_id_cate_shop_id', 'shop_nq_user_id_cate_shop_id', 'cate_nq_user_id_cate_shop_id', 'first_hour_gap_user_id_cate_shop_id', 'last_hour_gap_user_id_cate_shop_id', 'act_days_user_id_cate_shop_id', 'sku_cnt_user_id_cate_shop_id_type_1', 'sku_nq_user_id_cate_shop_id_type_1', 'type_nq_user_id_cate_shop_id_type_1', 'brand_nq_user_id_cate_shop_id_type_1', 'shop_nq_user_id_cate_shop_id_type_1', 'cate_nq_user_id_cate_shop_id_type_1', 'first_hour_gap_user_id_cate_shop_id_type_1', 'last_hour_gap_user_id_cate_shop_id_type_1', 'act_days_user_id_cate_shop_id_type_1', 'sku_cnt_user_id_cate_shop_id_type_2', 'sku_nq_user_id_cate_shop_id_type_2', 'type_nq_user_id_cate_shop_id_type_2', 'brand_nq_user_id_cate_shop_id_type_2', 'shop_nq_user_id_cate_shop_id_type_2', 'cate_nq_user_id_cate_shop_id_type_2', 'first_hour_gap_user_id_cate_shop_id_type_2', 'last_hour_gap_user_id_cate_shop_id_type_2', 'act_days_user_id_cate_shop_id_type_2', 'sku_cnt_user_id_cate_shop_id_type_3', 'sku_nq_user_id_cate_shop_id_type_3', 'type_nq_user_id_cate_shop_id_type_3', 'brand_nq_user_id_cate_shop_id_type_3', 'shop_nq_user_id_cate_shop_id_type_3', 'cate_nq_user_id_cate_shop_id_type_3', 'first_hour_gap_user_id_cate_shop_id_type_3', 'last_hour_gap_user_id_cate_shop_id_type_3', 'act_days_user_id_cate_shop_id_type_3', 'sku_cnt_user_id_cate_shop_id_type_4', 'sku_nq_user_id_cate_shop_id_type_4', 'type_nq_user_id_cate_shop_id_type_4', 'brand_nq_user_id_cate_shop_id_type_4', 'shop_nq_user_id_cate_shop_id_type_4', 'cate_nq_user_id_cate_shop_id_type_4', 'first_hour_gap_user_id_cate_shop_id_type_4', 'last_hour_gap_user_id_cate_shop_id_type_4', 'act_days_user_id_cate_shop_id_type_4', 'buybro_ratio_user_id_cate_shop_id', 'buyfocus_ratio_user_id_cate_shop_id', 'buycom_ratio_user_id_cate_shop_id', 'age', 'sex', 'user_lv_cd', 'city_level', 'province', 'city', 'county', 'fans_num', 'vip_num', 'shop_score']
    

    4.特征选择

    特征选择使用随机森林,下面的代码输出特征重要度排名。

    from model.feat_columns import *
    from sklearn.model_selection import train_test_split
    from sklearn.ensemble import RandomForestClassifier
    import numpy as np
    from sklearn.preprocessing import Imputer
    
    """
    使用随机森林进行特征选择
    """
    train_set = pd.read_hdf('../datasets/test_set.h5', key='test_set')
    # train_set = pd.read_hdf('../../datasets/train_set.h5', key='train_set')
    X = train_set[feat_columns].values
    print(X.shape)  # 7day-1 (1560848, 349) (1560848, 328)  7day-7 (1560852, 349)
    
    y = train_set['label'].values
    
    # 如果用全量数据跑不动
    seed = 3
    test_size = 0.3
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=seed)
    
    clf = RandomForestClassifier(random_state=seed)
    # 缺失值填充
    X_train = Imputer().fit_transform(X_train)
    print('fit...')
    clf.fit(X_train, y_train)
    print('done')
    importance = clf.feature_importances_
    indices = np.argsort(importance)[::-1]
    features = train_set[feat_columns].columns
    l = []
    for i in range(X_train.shape[1]):
        print(("%2d) %-*s %f" % (i + 1, 30, features[indices[i]], importance[indices[i]])))
        l.append(features[indices[i]])
    print(l)
    

    5.模型选择

    首先判断一下你要处理的问题属于哪一类,是分类、聚类还是回归等等。确定好类别后,再通过验证集来查看此类中各个算法的表现,从而选择合适的模型。因为目前比赛常用且效果最好的只有lightgbm和xgboost,所以我此次并没有进行模型选择,就用了这两个算法。大家可以查一下sklearn.model_selection包的相关文档。

    from sklearn.model_selection import train_test_split
    from sklearn.model_selection import KFold,StratifiedKFold
    from sklearn.model_selection import StratifiedShuffleSplit
    from sklearn.model_selection import LeaveOneOut
    from sklearn.model_selection import cross_val_score
    

    6.参数选择

    import xgboost as xgb
    from sklearn.model_selection import GridSearchCV
    from collections import Counter
    from model.feat_columns import *
    
    
    train_set = pd.read_hdf('../../datasets/train_set.h5', key='train_set')
    
    X_train = train_set[feat_columns].values
    y_train = train_set['label'].values
    c = Counter(y_train)
    # n = c[0] / 16 / c[1]  # 8
    n = c[0] / c[1]  # 129.56
    
    print(n)
    
    parameters = {
        'max_depth': [5, 10, 15, 20, 25],
        'learning_rate': [0.01, 0.02, 0.05, 0.1, 0.15],
        'n_estimators': [500, 1000, 2000, 3000, 5000],
        'min_child_weight': [0, 2, 5, 10, 20],
        'max_delta_step': [0, 0.2, 0.6, 1, 2],
        'subsample': [0.6, 0.7, 0.8, 0.85, 0.95],
        'colsample_bytree': [0.5, 0.6, 0.7, 0.8, 0.9],
        'reg_alpha': [0, 0.25, 0.5, 0.75, 1],
        'reg_lambda': [0.2, 0.4, 0.6, 0.8, 1],
        'scale_pos_weight': [0.2, 0.4, 0.6, 0.8, 1, 8, n]
    
    }
    
    xlf = xgb.XGBClassifier(max_depth=10,
                            learning_rate=0.01,
                            n_estimators=2000,
                            silent=True,
                            objective='binary:logistic',
                            nthread=12,
                            gamma=0,
                            min_child_weight=1,
                            max_delta_step=0,
                            subsample=0.85,
                            colsample_bytree=0.7,
                            colsample_bylevel=1,
                            reg_alpha=0,
                            reg_lambda=1,
                            scale_pos_weight=1,
                            seed=1440,
                            missing=None)
    
    gsearch = GridSearchCV(xlf, param_grid=parameters, scoring='accuracy', cv=3)
    gsearch.fit(X_train, y_train)
    
    print("Best score: %0.3f" % gsearch.best_score_)
    print("Best parameters set:")
    best_parameters = gsearch.best_estimator_.get_params()
    for param_name in sorted(parameters.keys()):
        print("\t%s: %r" % (param_name, best_parameters[param_name]))
    

    7.模型训练与评估

    选好特征、模型和参数后开始对模型进行训练和评估,最后再使用前面的测试集(不是这里训练集划分的测试集)查看模型效果。

    import pickle
    from collections import Counter
    from sklearn.metrics import accuracy_score
    from sklearn.model_selection import train_test_split
    from xgboost import XGBClassifier
    from model.feat_columns import *
    
    threshold = 0.3
    
    train_set = pd.read_hdf('../../datasets/train_set.h5', key='train_set')
    
    '''
    pos_sample = train_set[train_set['label'] == 1]
    n = len(pos_sample)
    print(n)
    neg_sample = train_set[train_set['label'] == 0].sample(n=n, random_state=1)
    del train_set
    train_set = pos_sample.append(neg_sample)
    '''
    
    X = train_set[feat_columns].values
    print(X.shape)  # 7day  (1560852, 349)
    
    y = train_set['label'].values
    c = Counter(y)  # Counter({0.0: 1545471, 1.0: 15377})
    print(c)
    
    train_metrics = train_set[['user_id', 'cate', 'shop_id', 'label']]
    del train_set
    
    # split data into train and test sets
    seed = 3
    test_size = 0.33
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=seed)
    
    c = Counter(y_train)
    print(c)  # 7day Counter({0.0: 1035454, 1.0: 10314})
    
    # c[0] / 16 / c[1]  8 | c[0] / c[1]  129.56
    clf = XGBClassifier(max_depth=5, min_child_weight=6, scale_pos_weight=c[0] / 16 / c[1], n_estimators=100, nthread=12,
                        seed=0, subsample=0.5)
    eval_set = [(X_test, y_test)]
    
    clf.fit(X_train, y_train, early_stopping_rounds=10, eval_metric="logloss", eval_set=eval_set, verbose=True)
    # make predictions for test data
    y_pred = clf.predict(X_test)
    predictions = [round(value) for value in y_pred]
    # evaluate predictions
    accuracy = accuracy_score(y_test, predictions)
    print("Accuracy: %.2f%%" % (accuracy * 100.0))
    
    y_train_predict = clf.predict_proba(X)[:, 1]
    # y_train_predict = clf.predict(X)
    # train_metrics['pre_label'] = y_train_predict
    train_metrics['pred_prob'] = y_train_predict
    
    # pred = train_metrics[train_metrics['pre_label'] == 1]
    pred = train_metrics[train_metrics['pred_prob'] > threshold]
    truth = train_metrics[train_metrics['label'] == 1]
    print('X train pred num is:', len(pred))
    
    print("训练集分数:")
    get_final_score(pred, truth)
    del train_metrics
    pickle.dump(clf, open('../user_model/baseline.pkl', 'wb'))
    
    # clf = pickle.load(open('../user_model/baseline.pkl', 'rb'))
    

    8.模型融合

    模型融合就是训练多个模型,然后按照一定的方法整合多个模型输出的结果,常用的有加权平均、投票、学习法等等,请自行百度。模型融合的结果往往优于单个模型,常用于最后的成绩提升。我此次只是对lightgbm和xgboost两个算法预测出的概率进行简单的加权求和,然后取了topN的结果进行提交。


    参考链接:

    • https://mp.weixin.qq.com/s/IWsHchH4Gx0zfDC5rmQmAA
    • https://zhuanlan.zhihu.com/p/64357013
    • https://zhuanlan.zhihu.com/p/47807544
    展开全文
  • 因为项目需要和自己的兴趣,几个月前结合模板解析神速的ArtTemplate,自己写了个框架取名JData,多多指教啊~~~因为一直没时间写文档,为了能够更方便地使用和避免我把代码忘了,今天抽空把文档写了。  项目已经...
  • 表1:SKU基本信息表(jdata_sku_basic_info)1. 读取数据,并获取部分特征的最大值,最小值,均值和中位数2. df.info()给出DataFrame数据的基本信息3. df.column.values 以array形式返回指定column的所有取值4. df....
  • 写在前面 感谢太白南路点子王、安之zh、小幸运,特别...代码在此:完整方案代码 数据在此:https://pan.baidu.com/s/1x13RezqXoKUuZkafhyw9Fg 提取码:txmj JDATA竞赛详情页​jdata.jd.com正文 赛题背景 京东零售...
  • 本文给出2019JDATA比赛亚军的完整方案和完整代码,直接学习代码,没有比这个更“硬核”的了。代码在此:https://github.com/anzhizh/2019-...
  • 去年6月份和实习生一起参加京东jdata2018算法大赛,取得了17名的成绩,本来以为这个成绩对于第一次参加算法大赛的我们来说已经算是不错了,但在听了决赛答辩之后感觉今后的路还很长,需要学习的东西太多,现在把我们...
  • 表3:用户行为表(jdata_user_action)1. 读取数据,并获取数据基本信息2. 获取部分特征的频率统计和最大/最小值3. 获取行为次数的统计
  • 表2:用户基本信息表(jdata_user_basic_info)1. 读取数据,并获取DataFrame数据特征2. df.column.value_count() 以Series形式返回指定列的不同取值的频率
  • JData-rank37-master.zip

    2019-08-12 10:39:57
    京东数据挖掘大赛数据,用于用户购买意向预测的数据,感兴趣来下载吧
  • 表5:评论分数数据表(jdata_user_comment_score)1. 读取数据,并获取数据基本信息2. 获取评分等级分布,没有-1即没有空评论3. 按o_id进行groupby分组,其中第一个元素是o_id的取值,第二个是对应的分组结果...
  • Kaggle的数据挖掘比赛近年来很火,以至于中国兴起了很多很多类似的比赛,做了两个这种类型的比赛了,Jdata用户商品购买预测和用户位置精准预测,积累了相当多的比赛经验了,虽然两次成绩都不是特别好,59/4590 和 ...
  • Jdata大数据竞赛总结

    千次阅读 2017-07-10 09:45:07
    P:候选的商品子集(JData_Product.csv),P是S的子集; U:用户集合; A:用户对S的行为数据集合; C:S的评价数据。 训练数据部分: 提供2016-02-01到2016-04-15日用户集合U中的用户,对商品集合S...
  • 6月6日,由京东集团和英特尔联合主办,创造算法大赛单体赛参赛人数世界纪录的京东JData算法大赛举行了线下决赛,60万元大奖和Special offer均已名花有主,针对“高潜用户购买意向预测”的命题,参赛队伍“鲁班七号”...
  • 表4:用户订单表(jdata_user_order)1. 读取数据,并获取数据基本信息2. values_counts()获取下单区域和下单件数信息3. 使用groupby()进行分组,分组完返回一个GroupBy对象,它实际上还没有进行任何计算. 可调用....
  • @Author : Jasperyang@School : BUPT这篇文章同时在知乎里放着~写在前面Kaggle的数据挖掘比赛近年来很火,以至于中国兴起了很多很多类似的比赛,做了两个这种类型的比赛了,Jdata用户商品购买预测和用户位置精准...
  • Jdata2019比赛小结

    2019-05-20 16:27:08
    占个坑,回来再填。

空空如也

空空如也

1 2 3 4 5 ... 13
收藏数 247
精华内容 98
关键字:

jdata