一种基于共现的推荐算法

参考原文《亚马逊推荐系统20年》

现有所有用户的购物列表：

user1: G　　A　　B
user2: X　　C　　Y
user3: X　　E　　F
user4: X　　M　　Y　　Q　　N　　J　　H
user5: W　　Y
user6: L　　E　　Z　　W

现在要计算商品X的相似商品。

思路：要计算X和Y的相似度直接计算p(Y|X)即可。根据极大似然估计

$$\begin{equation} p(Y|X)=\frac{count(X,Y)}{count(X)}=\frac{2}{3} \label{orig} \end{equation}$$

公式($\ref{orig}$)有2个问题：

1. 如果Y是一个很热门的商品，则它倾向于和任意商品共现。也就是说如果$count(X,Y)$比较大，并不能直接说明X和Y的相关度就大，也可能是因为Y商品非常地热门。
2. 对于热衷于购物的用户，她会买很多东西，这些东西之间不一定有相关度。也就是说如果一个用户购物比较少，我们倾向于认为这些商品之间的相关度比较高；如果一个用户购物比较多，我们倾向于认为这些商品之间的相关度比较低。

符号约定：

$N_{XY}$：同时购买了商品X和Y的用户数

$p(Y)$：总体而言，商品Y被购买的概率。$p(Y)=\frac{Y被购买的次数}{卖出去的商品总数}$

$C_X$：购买了商品X的用户集合

$c$：$C_X$中的一个用户

$|c|$：用户$c$购物的总数减去用户$c$购买X的次数

先假设商品X和Y相互独立，则用户$c$除了买X外还买了$|c|$件其他商品，每次购买都看成是一次伯努力试验：是否购买商品Y。则用户$c$没有购买Y的概率为：

$$(1-p(Y))^{|c|}$$

用户$c$购买Y的期望为：

$$1-(1-p(Y))^{|c|}$$

用户集合$C_X$购买Y的期望次数为：

$$\begin{equation}E_{XY}=\sum_{c \in C_X}\left[1-(1-p(Y))^{|c|}\right]  \label{E} \end{equation}$$

实际上X和Y可能不是相互独立的，它们之间的相关度为：

$$\begin{equation} relevance(X,Y)=\frac{N_{XY}-E_{XY}}{\sqrt{E_{XY}}} \label{R} \end{equation}$$

联合($\ref{E}$)式和($\ref{R}$)式可知：$p(Y)越大（即Y越热门），X和Y的相关度越低；$$|c|$越大（即用户的购物列表越长），X和Y的相关度越低。正好解决（或者说缓和）了本文一开头提出的那2个问题。

?

# coding=utf-8

__author__ = "orisun"

 

import math

from collections import defaultdict

 

target_position = set(

    [3218357, 3222919, 3050675, 3097961, 3202165, 3122457, 2747795])  # 要为这些职位生成推荐

deliver_list_dict = defaultdict(list)  # 包含target_position的投递列表

deliver_prob_dict = {}

 

 

def deliverCount(deliverFile):

    """统计每个职位被投递的概率

    """

    global target_position

    global deliver_list_dict

    global deliver_prob_dict

 

    total_deliver = 0  # 总投递次数

    deliver_count_dict = defaultdict(int)  # 每个职位被投递的次数

    with open(deliverFile, 'r') as f_in:

        for line in f_in:

            arr = line.strip().split()

            if len(arr) > 1:

                deliver_set = set()

                for ele in arr[1:]:

                    brr = ele.split(",")

                    if len(brr) == 3:

                        if "1" == brr[0]:

                            pid = int(brr[1])

                            total_deliver += 1

                            deliver_count_dict[pid] += 1

                            deliver_set.add(pid)

                for target in target_position:

                    if target in deliver_set:

                        deliver_list_dict[target].append(list(deliver_set))

    for pid, cnt in deliver_count_dict.items():

        deliver_prob_dict[pid] = 1.0 * cnt / total_deliver

 

 

def recForPosition(pid):

    global deliver_list_dict

    global deliver_prob_dict

 

    if pid in deliver_list_dict:

        deliver_list_list = deliver_list_dict[pid]

        cooccur_count_dict = defaultdict(int)

        expect_count_dict = defaultdict(float)

        for deliver_list in deliver_list_list:

            for deliver in deliver_list:

                if deliver != pid:

                    cooccur_count_dict[deliver] += 1

                    expect_count_dict[deliver] += 1 - \

                        math.pow(

                            1 - deliver_prob_dict[deliver], len(deliver_list) - 1)

        relevant_dict = {}

        for deliver, cnt in cooccur_count_dict.items():

            relevant_dict[deliver] = 1.0 * (cnt - len(deliver_list_list) * expect_count_dict[

                                            deliver]) / math.sqrt(expect_count_dict[deliver])

        # 只取相关度最高的前50个作为推荐

        return sorted(relevant_dict.items(), cmp=lambda x, y: cmp(y[1], x[1]))[:50]

    return None

 

if __name__ == '__main__':

    deliverCount("/data/orisun/dnn_for_rec/behavior/allBehavior.txt")

    for target in target_position:

        print "neighbors of position", target

        print recForPosition(target)