DIN算法代码详细解读

首先给出论文的地址：Deep Interest Network for Click-Through Rate Prediction
然后给出两篇对论文进行了详细介绍的文章：
1 _0 n+ b9 ^% d) [3 F' o! b! Q王喆：推荐系统中的注意力机制——阿里深度兴趣网络（DIN）
8 _- P0 x; p( _  E. Y2 Z梁勇：推荐系统遇上深度学习(十八)-探秘阿里深度兴趣网络浅析及实现
建议先读完上面两篇文章，对模型有大概的了解之后再来读本篇文章。本文主要从代码的层面出发，逐行去分析理解论文中思想的具体实现。
本文使用的代码地址为：zhougr1993/DeepInterestNetwork
# O8 A. n* G" V5 F% ?开始！
源码介绍


# u  ]/ _0 _8 m5 P1 E0 r" x- r
论 文 中 用 的 是 Amazon Product Data 数 据 ， 包 含 两 个 文 件 reviews_Electronics_5.json和 meta_Electronics.json。具体数据形式在本文最后有展 示。文件格式链接中有说明，其中 reviews 主要是用户买了相关商品产生的上下 文信息，包括商品 id, 时间，评论等。meta 文件是关于商品本身的信息，包括商 品 id, 名称，类别，买了还买等信息。其中 meta 部分为商品信息，reviewer 为点 击者信息，转换为 dataframe 格式之后的具体字段如下：
( H$ c- `9 F# x7 {meta_df: ['asin','imUrl','description','categories','title','price','salesRank','related','brand']
" I! r) i' v& p& Mreviews_df: ['reviewerID', 'asin', 'reviewerName', 'helpful', 'reviewText','overall', 'summary', 'unixReviewTime','reviewTime']
源码解析

/ [- Z& Z5 I! C9 M8 V一、数据预处理

4 n3 G9 A0 s* ^# f, H9 ?$ f
3 c; c$ y. _9 @& _: B: q! z二、生成正负样本
1 @% v; M/ H0 N" b5 H2 L9 l: E

build_dataset.py代码详解如下：
. s: l1 }+ Y0 d9 |0 p1 himport random
import pickle
random.seed(1234)
8 `* b1 n* g2 N, R2 n+ \withopen('C:/Users/Administrator/Desktop/raw_data/remap.pkl','rb')asf:
    reviews_df=pickle.load(f)
+ ]/ W9 w2 y8 b! _  J% `2 }    cate_list=pickle.load(f)
9 H0 O$ l2 k2 }; q; Y    user_count,item_count,cate_count,example_count=pickle.load(f)
'''
pos_list（每个点击者点击的商品 ID 组成的 list)例如： [8] [9,6,4,5] [3] [8]
'''
train_set=[]
test_set=[]
5 D' L5 W1 }! Q+ r; Z; h9 gfor reviewerID,histinreviews_df.groupby('reviewerID'):
    pos_list=hist['asin'].tolist()
    defgen_neg():
        #取每个用户点击列表的第一个商品
        neg=pos_list[0]
" r: h- F# T' x: N+ g        while neg in pos_list:
            #随机初始化，即给点击者随机初始化一个商品，item_count-1 为商品数
; K  M( _! g' o            neg=random.randint(0,item_count-1)
6 J# p) w; T- s: T        return neg
! o4 P* e  B2 a$ U/ C    neg_list=[gen_neg() for i in range(len(pos_list))]

3 z; h' }7 k" N#如果用户点击的商品数大于 1，则循环
' m0 O) K* t0 n" D! ]& S8 yfor i in range(1,len(pos_list)):
; e" X8 V9 F4 m+ }# m% O3 u    hist=pos_list[:i]
    #print(hist)
    '''
1 o7 e) U* ?/ b: ?* g+ {% I    #下面的 if 语句控制正负样本的个数和格式），例如某用户点击过 abcd 四 个商品，
7 L0 f" r( y+ R- y# {5 N, R    则最终生成的样本为：(其中 X 为随机初始化的某商品 ID)
    ((user_id,a,(b,1)) （user_id,a,(X,0)) （user_id,(a,b),(c,1))
* v5 w2 N7 O: ]- G    user_id,(a,b),(X0)) （user_id,(a,b,c),(d,1)) （user_id,(a,b,c),(X,0))
& e; }# c0 b- }    '''
    if i != len(pos_list) - 1:
        train_set.append((reviewerID,hist,pos_list,1))
6 A. j9 U0 ?7 q( A8 B- x  L        print(train_set)
( n4 B( R& |- R9 z; t        train_set.append((reviewerID,hist,neg_list,0))
        print(train_set)
    #验证集格式(user_id,a,(b,X))
  m' y2 b" b5 R0 G0 G    else:
" M, X( ]( E, o8 M: x        label=(pos_list,neg_list)
, [! c4 c* P3 h* ~0 m        print(label)
        test_set.append((reviewerID,hist,label))
5 a' y+ i3 Y& r$ K5 W% m; k        print(test_set)
( K2 p1 w! o2 U" m, i0 c5 E
( b7 S; |! I+ u+ u1 P. S#最终的数据集里点击商品数小于 1 的数据删除掉了
9 I# L+ Y% @# D" _random.shuffle(train_set)
random.shuffle(test_set)
assertlen(test_set)==user_count

with open('dataset.pkl','wb') as f:
3 t! b! L+ q" N9 Y4 d6 ^" gpickle.dump(train_set,f,pickle.HIGHEST_PROTOCOL)
pickle.dump(test_set,f,pickle.HIGHEST_PROTOCOL)
pickle.dump(cate_list,f,pickle.HIGHEST_PROTOCOL)
pickle.dump((user_count, item_count, cate_count), f, pickle.HIGHEST_PROTOCOL)三、模型部分（包括attention机制实现）
8 U! R/ `/ A8 ]
5 J, v% T! `7 J下面介绍本算法的核心model.py文件，每行关键的代码都给出了注释。
$ m0 C1 {; K; e, S2 J0 f9 B+ Pimport tensorflow as tf
* ^; V3 _" W, nfrom Dice import dice

+ E9 I$ m2 ^, B9 aclass Model(object):
    def __init__(self,user_count,item_count,cate_count,cate_list):
        # shape: [B],  user id。 (B：batch size)
- G, A- ~* V) }4 Y& f9 N        self.u = tf.placeholder(tf.int32, [None, ])
% }  X0 k+ r3 i6 S, S        # shape: [B]  i: 正样本的item
( v6 M9 G8 a: L+ ~        self.i = tf.placeholder(tf.int32, [None, ])
/ z( p; w6 V4 ^' u+ K        # shape: [B]  j: 负样本的item
9 u* m5 t. a* D( z) T, C        self.j = tf.placeholder(tf.int32, [None, ])
- u& |- [+ K; L, b0 v0 T        # shape: [B], y: label
5 N' t$ p' |6 a' Z* R3 V- Q7 F        self.y = tf.placeholder(tf.float32, [None, ])
+ I6 r* }; p7 M' _2 `1 }        # shape: [B, T] #用户行为特征(User Behavior)中的item序列。T为序列长度
/ f. W, E# n7 g        self.hist_i = tf.placeholder(tf.int32, [None, None])
        # shape: [B]; sl：sequence length，User Behavior中序列的真实序列长度（？）
. a4 B- }: ^4 _        self.sl = tf.placeholder(tf.int32, [None, ])
        #learning rate
; U6 k# t% L) S8 V        self.lr = tf.placeholder(tf.float64, [])
9 Z3 c1 F  ?- A, U( k( ^        
        hidden_units = 128
2 q' \& R# }5 _2 b6 s8 b        # shape: [U, H], user_id的embedding weight. U是user_id的hash bucket size
        user_emb_w = tf.get_variable("user_emb_w", [user_count, hidden_units])

        # shape: [I, H//2], item_id的embedding weight. I是item_id的hash bucket size
. x2 h( O- l6 q5 g; P        item_emb_w = tf.get_variable("item_emb_w", [item_count, hidden_units // 2])  # [I, H//2]
* `  ]; U5 t6 t" T
' t$ j0 C5 |. J5 z2 B- t$ U        # shape: [I], bias
, U* W: E. D7 u& z+ f1 V; p, D. b        item_b = tf.get_variable("item_b", [item_count],initializer=tf.constant_initializer(0.0))
2 i+ w  e, G9 m2 V0 \+ V$ _        # shape: [C, H//2], cate_id的embedding weight.
/ D3 L( J  v) j1 W- e        cate_emb_w = tf.get_variable("cate_emb_w", [cate_count, hidden_units // 2])

        # shape: [C, H//2]
        cate_list = tf.convert_to_tensor(cate_list, dtype=tf.int64)

, B: r  B) r/ w        # 从cate_list中取出正样本的cate
3 k% R, k8 ]% m! L9 u! ?        ic = tf.gather(cate_list, self.i)
        # 正样本的embedding，正样本包括item和cate
0 w! e# j- G" B, E* R) _0 ?7 M        i_emb = tf.concat(values=[tf.nn.embedding_lookup(item_emb_w, self.i),tf.nn.embedding_lookup(cate_emb_w, ic),], axis=1)
& K$ m- C% n' T9 _3 {6 V; [        # 偏置b
" }* T& D( n) f9 V6 S0 s        i_b = tf.gather(item_b, self.i)
3 F9 g8 K, S+ Y/ s        
        # 从cate_list中取出负样本的cate
        jc = tf.gather(cate_list, self.j)
        # 负样本的embedding，负样本包括item和cate
        j_emb = tf.concat([tf.nn.embedding_lookup(item_emb_w, self.j),tf.nn.embedding_lookup(cate_emb_w, jc),], axis=1)
! W. V) b* Q/ g# r) F        # 偏置b
        j_b = tf.gather(item_b, self.j)

        # 用户行为序列(User Behavior)中的cate序列
        hc = tf.gather(cate_list, self.hist_i)
5 X! H( w+ x' ]
# F) U% O! c( h: o2 r8 {! f( K# X* M        # 用户行为序列(User Behavior)的embedding，包括item序列和cate序列
        h_emb = tf.concat([tf.nn.embedding_lookup(item_emb_w, self.hist_i),tf.nn.embedding_lookup(cate_emb_w, hc),], axis=2)
7 {+ u) |7 L+ i% }( _0 m: K        # attention操作
6 f$ M' U7 R, X& F, y+ X        hist_i = attention(i_emb, h_emb, self.sl)  
4 x0 u& W9 D! s, o( d. W) j        # -- attention end ---
5 Z6 }  S2 z8 {5 e
        hist = tf.layers.batch_normalization(inputs=hist)
* N( R& `: T6 e9 i        hist = tf.reshape(hist,[-1,hidden_units])
/ {+ v9 ?' a' D2 Q# ?        #添加一层全连接层，hist为输入，hidden_units为输出维数
4 Y2 A8 K! Z3 x$ ?7 u: T! }        hist = tf.layers.dense(hist,hidden_units)

        u_emb = hist

0 N; A- w" X$ y8 }# C0 d% m        #下面两个全连接用来计算y'，i为正样本，j为负样本
& X3 V1 q: x5 |# O' ^0 K: e        # fcn begin
        din_i = tf.concat([u_emb, i_emb], axis=-1)
1 m: G3 ~# M9 Y; E        din_i = tf.layers.batch_normalization(inputs=din_i, name='b1')
        d_layer_1_i = tf.layers.dense(din_i, 80, activation=None, name='f1')
        d_layer_1_i = dice(d_layer_1_i, name='dice_1_i')
        d_layer_2_i = tf.layers.dense(d_layer_1_i, 40, activation=None, name='f2')
        d_layer_2_i = dice(d_layer_2_i, name='dice_2_i')
        d_layer_3_i = tf.layers.dense(d_layer_2_i, 1, activation=None, name='f3')

; `& P$ r/ \. ^7 y; [7 w9 J        din_j = tf.concat([u_emb, j_emb], axis=-1)
1 O# Y* u0 w6 a        din_j = tf.layers.batch_normalization(inputs=din_j, name='b1', reuse=True)
        d_layer_1_j = tf.layers.dense(din_j, 80, activation=None, name='f1', reuse=True)
. y4 Q- b, H. s! }7 @9 Q+ ^; C0 @6 M        d_layer_1_j = dice(d_layer_1_j, name='dice_1_j')
( c! O) A5 L0 i# A" v        d_layer_2_j = tf.layers.dense(d_layer_1_j, 40, activation=None, name='f2', reuse=True)
5 f5 |: d+ }! G; t6 b# D! A        d_layer_2_j = dice(d_layer_2_j, name='dice_2_j')
% @8 c' P9 ^+ o1 {4 |        d_layer_3_j = tf.layers.dense(d_layer_2_j, 1, activation=None, name='f3', reuse=True)

        d_layer_3_i = tf.reshape(d_layer_3_i, [-1])
" ], @6 i2 _* S; ^- N! j        d_layer_3_j = tf.reshape(d_layer_3_j, [-1])
; w# ~% r1 g& @) c
, F6 C8 S4 o8 H3 B2 h2 U9 i# D        #预测的（y正-y负）
3 g5 ]/ G4 I9 J5 _+ M  n        x = i_b - j_b + d_layer_3_i - d_layer_3_j  # [B]
        #预测的（y正）
+ B  t. k- |* M) f        self.logits = i_b + d_layer_3_i

% ^7 K/ Y, R  Z
* }; b- h: H/ W$ v* L+ L        # logits for all item:
        u_emb_all = tf.expand_dims(u_emb, 1)
. @( Y. A  }$ c        u_emb_all = tf.tile(u_emb_all, [1, item_count, 1])
        #将所有的除u_emb_all外的embedding，concat到一起
        all_emb = tf.concat([item_emb_w,tf.nn.embedding_lookup(cate_emb_w, cate_list)], axis=1)
) n" e: i) t  h9 ]% q& @        all_emb = tf.expand_dims(all_emb, 0)
) ?7 g. i9 ~2 F5 r        all_emb = tf.tile(all_emb, [512, 1, 1])
: g5 f( W/ K9 L/ z, ^' u+ @        # 将所有的embedding，concat到一起
4 x* b( S7 z, \( t        din_all = tf.concat([u_emb_all, all_emb], axis=-1)
        din_all = tf.layers.batch_normalization(inputs=din_all, name='b1', reuse=True)
        d_layer_1_all = tf.layers.dense(din_all, 80, activation=None, name='f1', reuse=True)
        d_layer_1_all = dice(d_layer_1_all, name='dice_1_all')
7 U& Q% C. O# P: F5 S9 X        d_layer_2_all = tf.layers.dense(d_layer_1_all, 40, activation=None, name='f2', reuse=True)
- p( }! F( ~5 u8 ?* a+ `) ^5 r. @        d_layer_2_all = dice(d_layer_2_all, name='dice_2_all')
1 b; O- r8 T1 |# h1 `0 u        d_layer_3_all = tf.layers.dense(d_layer_2_all, 1, activation=None, name='f3', reuse=True)
        d_layer_3_all = tf.reshape(d_layer_3_all, [-1, item_count])
+ z* ]2 y5 u& n1 g
        self.logits_all = tf.sigmoid(item_b + d_layer_3_all)
* T% r0 r7 v3 }0 V) P        # -- fcn end -------

        self.mf_auc = tf.reduce_mean(tf.to_float(x > 0))
        self.score_i = tf.sigmoid(i_b + d_layer_3_i)
        self.score_j = tf.sigmoid(j_b + d_layer_3_j)
        self.score_i = tf.reshape(self.score_i, [-1, 1])
1 b4 M# u2 w, O; N* a        self.score_j = tf.reshape(self.score_j, [-1, 1])
1 j. ^/ @! W) w6 G6 W' j) `        self.p_and_n = tf.concat([self.score_i, self.score_j], axis=-1)
# A2 v$ P" M# L4 Z  x, |3 m) G
        # Step variable
        self.global_step = tf.Variable(0, trainable=False, name='global_step')
) F/ @( F3 v% u9 Q        self.global_epoch_step = tf.Variable(0, trainable=False, name='global_epoch_step')
' e1 Z7 D1 }( \2 m) o" R        self.global_epoch_step_op = tf.assign(self.global_epoch_step, self.global_epoch_step + 1)
  O& @! G; B. z* Z9 M' V
2 n* d$ {8 \: T        # loss and train
( r) |4 x; S3 v        self.loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=self.logits,labels=self.y))
        trainable_params = tf.trainable_variables()
        self.train_op = tf.train.GradientDescentOptimizer(learning_rate=self.lr).minimize(self.loss)

7 X7 p6 S: x. i2 H7 _# r    def train(self,sess,uij,l):
- H1 Q2 u  N7 `6 R! t        loss,_ = sess.run([self.loss,self.train_op],feed_dict={
# F3 ]7 |  [/ o8 l2 l% {            #self.u : uij[0],
' w0 f2 x8 ^+ r$ X: o# R- y: H2 t            self.i : uij[1],
            self.y : uij[2],
            self.hist_i : uij[3],
            self.sl : uij[4],
            self.lr : l
7 \) A+ v: I  ^( _! g        })
$ t. @" F( R0 G: b+ c9 n        return loss

% h* V. v$ }7 v4 ^4 n) d- M    def eval(self, sess, uij):
1 W, f) N6 y6 Z& Y) H2 |, J        u_auc, socre_p_and_n = sess.run([self.mf_auc, self.p_and_n], feed_dict={
            #self.u: uij[0],
            self.i: uij[1],#正样本
0 d* I: h" B; \( S( L$ t            self.j: uij[2],#负样本
            self.hist_i: uij[3],
            self.sl: uij[4],
+ i; y( R) m: O6 h9 ~        })
        return u_auc, socre_p_and_n

    def test(self, sess, uid, hist_i, sl):
        return sess.run(self.logits_all, feed_dict={
            self.u: uid,
            self.hist_i: hist_i,
            self.sl: sl,
9 T) \8 Z$ D4 d$ z3 K" p1 }        })

% L- h, o+ V+ ^. ]8 y/ F( U    def save(self, sess, path):
& x9 Z' ?1 T/ o2 m$ U' {        saver = tf.train.Saver()
5 o6 J( a. k, A3 _& j1 Q( B7 b        saver.save(sess, save_path=path)

    def restore(self, sess, path):
        saver = tf.train.Saver()
* L5 e: N3 i, M2 w8 p7 ^, w        saver.restore(sess, save_path=path)

def extract_axis_1(data, ind):
    batch_range = tf.range(tf.shape(data)[0])
    indices = tf.stack([batch_range, ind], axis=1)
    res = tf.gather_nd(data, indices)
7 V/ x( e3 e- B% m    return res

9 ?5 n! U  _2 F3 R#item_embedding,history_behivior_embedding,sequence_length
" l* Y* H# l6 Z  a6 G2 sdef attention(queries,keys,keys_length):
9 \+ c/ g. N7 _6 [    '''
0 w: }$ K7 Q' ?        queries:     [B, H]    [batch_size,embedding_size]
3 o8 J7 L+ L5 r, v7 u  S        keys:        [B, T, H]   [batch_size,T,embedding_size]
        keys_length: [B]        [batch_size]
# X9 B4 i7 u2 p        #T为历史行为序列长度
! a+ E0 L; C9 N% {& ?    '''
* U; d3 X" l0 f6 o
    #(?,32)->(None,32)->32
2 O  a4 W/ c. P    # tile()函数是用来对张量(Tensor)进行扩展的，其特点是对当前张量内的数据进行一定规则的复制。最终的输出张量维度不变
$ O- S8 z+ U2 w% d) ~    # tf.shape(keys)[1]==T
    # 对queries的维度进行reshape
% |) I$ b" M2 O0 g7 |    # (?,T,32)这里是为了让queries和keys的维度相同而做的操作
    # (?,T,128)把u和v以及u v的element wise差值向量合并起来作为输入，
9 d+ m. F) G! J1 H9 F4 R  d    # 然后喂给全连接层，最后得出两个item embedding，比如u和v的权重，即g(Vi,Va)
4 [+ p2 R1 m" ^2 B$ i
    queries_hidden_units = queries.get_shape().as_list()[-1]
0 ]( L7 U; L, X    queries = tf.tile(queries,[1,tf.shape(keys)[1]])
6 H, i' O, U" O: l9 w3 G# u( b    queries = tf.reshape(queries,[-1,tf.shape(keys)[1],queries_hidden_units])
    din_all = tf.concat([queries,keys,queries-keys,queries * keys],axis=-1) # B*T*4H
- g: b. I! v7 @, h' @
7 z* U9 D8 d) S/ U5 g    # 三层全链接(d_layer_3_all为训练出来的atteneion权重）
    d_layer_1_all = tf.layers.dense(din_all, 80, activation=tf.nn.sigmoid, name='f1_att')
# }8 N& I+ [, w; d+ g9 |$ V    d_layer_2_all = tf.layers.dense(d_layer_1_all, 40, activation=tf.nn.sigmoid, name='f2_att')
1 ^/ N- j' W8 w3 B6 a5 k. L    d_layer_3_all = tf.layers.dense(d_layer_2_all, 1, activation=None, name='f3_att') #B*T*1
8 k, r4 B# m9 H
( N  @) O4 `/ ]0 x! n: S    #为了让outputs维度和keys的维度一致
& h- N4 a2 `, n4 U7 F* o    outputs = tf.reshape(d_layer_3_all,[-1,1,tf.shape(keys)[1]]) #B*1*T

! k4 T/ S0 A# t: z" w3 K+ c5 [" S2 f    #  bool类型 tf.shape(keys)[1]为历史行为序列的最大长度，keys_length为人为设定的参数，
  o: E5 Q" j7 a' v. Y( I    #  如tf.sequence_mask(5，3)  即为array[True,True,True,False,False]
* p7 Q6 J- d7 u) V4 c0 V    #  函数的作用是为了后面补齐行为序列，获取等长的行为序列做铺垫
; E5 t6 l( R$ L  j  Q    key_masks = tf.sequence_mask(keys_length,tf.shape(keys)[1])

' [, u6 ]; W, T8 |1 F, @    #在第二维增加一维，也就是由B*T变成B*1*T
    key_masks = tf.expand_dims(key_masks,1) # B*1*T

- l% Z  {1 A6 `& A: R$ d    #tf.ones_like新建一个与output类型大小一致的tensor，设置填充值为一个很小的值，而不是0,padding的mask后补一个很小的负数，这样softmax之后就会接近0
    paddings = tf.ones_like(outputs) * (-2 ** 32 + 1)

    #填充，获取等长的行为序列
$ u0 m/ `$ e$ s9 G# m# C1 x; \    # tf.where(condition， x, y),condition是bool型值，True/False，返回值是对应元素，condition中元素为True的元素替换为x中的元素，为False的元素替换为y中对应元素
& w  N# T& G/ l" X2 p7 ]* I    #由于是替换，返回值的维度，和condition，x ， y都是相等的。
5 z2 h3 M9 N( i0 j: p" O- z: E6 [    outputs = tf.where(key_masks,outputs,paddings) # B * 1 * T
, \8 s4 K3 O$ I4 d* Y0 C
    # Scale（缩放）
5 L# W/ f. c+ h0 n, N0 @    outputs = outputs / (keys.get_shape().as_list()[-1] ** 0.5)
4 F9 v/ K4 @* T' K& }0 E. e    # Activation
    outputs = tf.nn.softmax(outputs) # B * 1 * T
! [# m. z  d) {* X1 S1 M, N    # Weighted Sum outputs=g(Vi,Va)   keys=Vi
    #这步为公式中的g(Vi*Va)*Vi
0 o4 K/ d1 X) D' ?    outputs = tf.matmul(outputs,keys) # B * 1 * H 三维矩阵相乘，相乘发生在后两维，即 B * (( 1 * T ) * ( T * H ))

    return outputs
下一篇文章中将详细讲述在实际的业务中，如何应用DIN算法，敬请期待。

请问一下，model里面正负样本怎么理解？谢谢

用户购买了商品为正样本，没购买过的为负样本。

请作者尽快更新，我正在认真膜拜你的大作。对我很有帮助。

请教两个问题：
1 Scale（缩放）是除以根号H，这样的原理是什么呢？
2 outputs = tf.nn.softmax(outputs)
* C5 L8 ]8 G! m文章里说不做softmax，以保持attention强度，代码里为啥有呢？而且计算复杂度很高。
: E$ z5 ~: o9 |) b8 B) `谢谢

没有实现自适应正则损失函数呀

不用softmax，是合理的

你好,din中为啥这里没有emb行向量的weighted sum，这在代码里体现了了吗？我看了源代码和您解释的这个，并没发现。

亲，有没有找到自适应正则如何实现的code？可以发我下吗？

1，代码中：u_emb = hist，即u_emb被历史行为代替了，但是文章的图中，却说user_emb最后输入到MLP中了，这里您怎么看？
& u' r6 y* p/ N: E- Q2，cate_emb_w是候选集，还是类别？