0
0

Deep Interest Evolution Network(DIEN)专题3:代码解析之模型训练和模型结构

接上一节数据处理，本节将详细介绍训练和网络模型部分的代码,为了配合python3的执行，部分代码做了修改，先给出整个train.py的加注解代码：

  1. import numpy
  2. from data_iterator import DataIterator
  3. import tensorflow as tf
  4. from model import *
  5. import time
  6. import random
  7. import sys
  8. from utils import *
  10. EMBEDDING_DIM = 18
  11. HIDDEN_SIZE = 18 * 2
  12. ATTENTION_SIZE = 18 * 2
  13. best_auc = 0.0
  15. def prepare_data(input, target, maxlen = None, return_neg = False):
  16.     # x: a list of sentences
  17.     # input: N个训练样本，每一行格式如下： 
  18.     # 用户id[0], 商品id[1], 商品分类[2]，之前点过商品（n个)[3]，之前点个商品分类（n个）[4]，没点过商品（n*5个）[5]，没点过商品分类（n*5个）[6]
  19.     # label: 正样本或者负样本
  20.     lengths_x = [len(s[4]) for s in input] # N, 每个样本之前点击商品的个数
  21.     seqs_mid = [inp[3] for inp in input] # N*n, 之前点过商品序列
  22.     seqs_cat = [inp[4] for inp in input] # N * n, 之前点过商品分类序列
  23.     noclk_seqs_mid = [inp[5] for inp in input] # N * n * 5, 之前没点过商品序列 
  24.     noclk_seqs_cat = [inp[6] for inp in input] # N * n * 5, 之前没点过商品分类
  26.     if maxlen is not None:
  27.         new_seqs_mid = []
  28.         new_seqs_cat = []
  29.         new_noclk_seqs_mid = []
  30.         new_noclk_seqs_cat = []
  31.         new_lengths_x = []
  32.         for l_x, inp in zip(lengths_x, input): # zip生成组元组成的list，长度与最小list长度一致
  33.             if l_x > maxlen:
  34.                 new_seqs_mid.append(inp[3][l_x - maxlen:])
  35.                 new_seqs_cat.append(inp[4][l_x - maxlen:])
  36.                 new_noclk_seqs_mid.append(inp[5][l_x - maxlen:])
  37.                 new_noclk_seqs_cat.append(inp[6][l_x - maxlen:])
  38.                 new_lengths_x.append(maxlen)
  39.             else:
  40.                 new_seqs_mid.append(inp[3])
  41.                 new_seqs_cat.append(inp[4])
  42.                 new_noclk_seqs_mid.append(inp[5])
  43.                 new_noclk_seqs_cat.append(inp[6])
  44.                 new_lengths_x.append(l_x)
  45.         lengths_x = new_lengths_x
  46.         seqs_mid = new_seqs_mid
  47.         seqs_cat = new_seqs_cat
  48.         noclk_seqs_mid = new_noclk_seqs_mid
  49.         noclk_seqs_cat = new_noclk_seqs_cat
  51.         if len(lengths_x) < 1:
  52.             return None, None, None, None
  54.     n_samples = len(seqs_mid) # 样本数 N
  55.     maxlen_x = numpy.max(lengths_x) # 之前最多的点击样本个数；
  56.     if maxlen_x <= 1:
  57.         maxlen_x = 2
  58.     neg_samples = len(noclk_seqs_mid[0][0]) # 每一次之前点击行为对应的负样本个数
  60.     mid_his = numpy.zeros((n_samples, maxlen_x)).astype('int64') # N * maxLen_x 之前点击item id 序列
  61.     cat_his = numpy.zeros((n_samples, maxlen_x)).astype('int64') # N * maxLen_x 之前点击item 分类 序列
  62.     noclk_mid_his = numpy.zeros((n_samples, maxlen_x, neg_samples)).astype('int64') # N * maxLen_x * ngsample(5), 之前每次点击对应负样本
  63.     noclk_cat_his = numpy.zeros((n_samples, maxlen_x, neg_samples)).astype('int64') # N * maxLen_x * ngsample(5), 之前每次点击对应负样本分类
  64.     mid_mask = numpy.zeros((n_samples, maxlen_x)).astype('float32') # N * maxLen_x 实际之前点击序列长度
  65.     for idx, [s_x, s_y, no_sx, no_sy] in enumerate(zip(seqs_mid, seqs_cat, noclk_seqs_mid, noclk_seqs_cat)):
  66.         mid_mask[idx, :lengths_x[idx]] = 1. # 第idx个样本，前lengths_x[idx]置为1，即有点击的位置置为1.
  67.         mid_his[idx, :lengths_x[idx]] = s_x # 第idx个样本，之前点过的商品id序列
  68.         cat_his[idx, :lengths_x[idx]] = s_y # 第idx个样本，之前点过的商品分类序列
  69.         noclk_mid_his[idx, :lengths_x[idx], :] = no_sx # 第idx个样本，没点过负样本id
  70.         noclk_cat_his[idx, :lengths_x[idx], :] = no_sy # 第idx个样本，没点过负样本分类
  72.     uids = numpy.array([inp[0] for inp in input]) # N，用户id
  73.     mids = numpy.array([inp[1] for inp in input]) # N，商品id
  74.     cats = numpy.array([inp[2] for inp in input]) # N，商品分类
  76.     if return_neg:
  77.         return uids, mids, cats, mid_his, cat_his, mid_mask, numpy.array(target), numpy.array(lengths_x), noclk_mid_his, noclk_cat_his
  78.         # uids: N, 用户id
  79.         # mids: N, 商品 item id
  80.         # cats: N, 商品分类
  81.         # mid_his: N * maxLen_x 之前点击item id 序列
  82.         # cat_his: N * maxLen_x 之前点击item 分类 序列
  83.         # mid_mask: N * maxLen_x 实际之前点击序列长度
  84.         # numpy.array(target): N * 2, label 正样本 [1,0] or 负样本 [0,1]
  85.         # numpy.array(lengths_x):N, 实际之前点击样本序列长度
  86.         # noclk_mid_his:N * maxLen_x * ngsample(5), 之前每次点击对应负样本
  87.         # noclk_cat_his:N * maxLen_x * ngsample(5), 之前每次点击对应负样本分类
  88.     else:
  89.         return uids, mids, cats, mid_his, cat_his, mid_mask, numpy.array(target), numpy.array(lengths_x)
  91. def eval(sess, test_data, model, model_path):
  93.     loss_sum = 0.
  94.     accuracy_sum = 0.
  95.     aux_loss_sum = 0.
  96.     nums = 0
  97.     stored_arr = []
  98.     for src, tgt in test_data:
  99.         nums += 1
  100.         uids, mids, cats, mid_his, cat_his, mid_mask, target, sl, noclk_mids, noclk_cats = prepare_data(src, tgt, return_neg=True)
  101.         # uids: N, 用户id
  102.         # mids: N, 商品 item id
  103.         # cats: N, 商品分类
  104.         # mid_his: N * maxLen_x 之前点击item id 序列
  105.         # cat_his: N * maxLen_x 之前点击item 分类 序列
  106.         # mid_mask: N * maxLen_x 实际之前点击序列长度
  107.         # target: N * 2, label 正样本 [1,0] or 负样本 [0,1]
  108.         # sl:N, 实际之前点击样本序列长度
  109.         # noclk_mids: N * maxLen_x * ngsample(5), 之前每次点击对应负样本
  110.         # noclk_cats: N * maxLen_x * ngsample(5), 之前每次点击对应负样本分类
  111.         prob, loss, acc, aux_loss = model.calculate(sess, [uids, mids, cats, mid_his, cat_his, mid_mask, target, sl, noclk_mids, noclk_cats])
  112.         loss_sum += loss
  113.         aux_loss_sum = aux_loss
  114.         accuracy_sum += acc
  115.         prob_1 = prob[:, 0].tolist()
  116.         target_1 = target[:, 0].tolist()
  117.         for p ,t in zip(prob_1, target_1):
  118.             stored_arr.append([p, t])
  119.     test_auc = calc_auc(stored_arr)
  120.     accuracy_sum = accuracy_sum / nums
  121.     loss_sum = loss_sum / nums
  122.     aux_loss_sum / nums
  123.     global best_auc
  124.     if best_auc < test_auc:
  125.         best_auc = test_auc
  126.         model.save(sess, model_path)
  127.     return test_auc, loss_sum, accuracy_sum, aux_loss_sum
  129. def train(
  130.         train_file = "local_train_splitByUser",
  131.         test_file = "local_test_splitByUser",
  132.         #第一行：label 0, 用户id, 商品id（未点击，负样本）, 商品分类, 之前点击过所有商品id，之前点击过所有商品分类
  133.         #第二行：label 1, 用户id, 商品id（点击过，正样本）, 商品分类, 之前点击过所有商品id，之前点击过所有商品分类 
  134.         uid_voc = "uid_voc.pkl",
  135.         mid_voc = "mid_voc.pkl",
  136.         cat_voc = "cat_voc.pkl",
  137.         batch_size = 128,
  138.         maxlen = 100,
  139.         test_iter = 100,
  140.         save_iter = 100,
  141.         model_type = 'DNN',
  142.     seed = 2,
  143. ):
  144.     model_path = "dnn_save_path/ckpt_noshuff" + model_type + str(seed)
  145.     best_model_path = "dnn_best_model/ckpt_noshuff" + model_type + str(seed)
  146.     gpu_options = tf.GPUOptions(allow_growth=True)
  147.     with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess:
  148.         train_data = DataIterator(train_file, uid_voc, mid_voc, cat_voc, batch_size, maxlen, shuffle_each_epoch=False)
  149.         test_data = DataIterator(test_file, uid_voc, mid_voc, cat_voc, batch_size, maxlen)
  150.         n_uid, n_mid, n_cat = train_data.get_n() # 用户数、商品数和分类数
  151.         if model_type == 'DNN':
  152.             model = Model_DNN(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE)
  153.         elif model_type == 'PNN':
  154.             model = Model_PNN(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE)
  155.         elif model_type == 'Wide':
  156.             model = Model_WideDeep(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE)
  157.         elif model_type == 'DIN':
  158.             model = Model_DIN(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE)
  159.         elif model_type == 'DIN-V2-gru-att-gru':
  160.             model = Model_DIN_V2_Gru_att_Gru(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE)
  161.         elif model_type == 'DIN-V2-gru-gru-att':
  162.             model = Model_DIN_V2_Gru_Gru_att(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE)
  163.         elif model_type == 'DIN-V2-gru-qa-attGru':
  164.             model = Model_DIN_V2_Gru_QA_attGru(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE)
  165.         elif model_type == 'DIN-V2-gru-vec-attGru':
  166.             model = Model_DIN_V2_Gru_Vec_attGru(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE)
  167.         elif model_type == 'DIEN':
  168.             model = Model_DIN_V2_Gru_Vec_attGru_Neg(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE)
  169.         else:
  170.             print ("Invalid model_type : %s", model_type)
  171.             return
  172.         # model = Model_DNN(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE)
  173.         sess.run(tf.global_variables_initializer())
  174.         sess.run(tf.local_variables_initializer())
  175.         sys.stdout.flush()
  176.         print('test_auc: %.4f ---- test_loss: %.4f ---- test_accuracy: %.4f ---- test_aux_loss: %.4f' % eval(sess, test_data, model, best_model_path))
  177.         sys.stdout.flush()
  179.         start_time = time.time()
  180.         iter = 0
  181.         lr = 0.001
  182.         for itr in range(3):
  183.             loss_sum = 0.0
  184.             accuracy_sum = 0.
  185.             aux_loss_sum = 0.
  186.             for src, tgt in train_data:
  187.                 # src : 用户id, 商品id, 商品分类，之前点过商品（n个)，之前点个商品分类（n个），没点过商品（n*5个），没点过商品分类（n*5个）
  188.                 # label: 正样本或者负样本
  189.                 uids, mids, cats, mid_his, cat_his, mid_mask, target, sl, noclk_mids, noclk_cats = prepare_data(src, tgt, maxlen, return_neg=True)
  190.                 loss, acc, aux_loss = model.train(sess, [uids, mids, cats, mid_his, cat_his, mid_mask, target, sl, lr, noclk_mids, noclk_cats])
  191.                 loss_sum += loss
  192.                 accuracy_sum += acc
  193.                 aux_loss_sum += aux_loss
  194.                 iter += 1
  195.                 sys.stdout.flush()
  196.                 if (iter % test_iter) == 0:
  197.                     print('iter: %d ----> train_loss: %.4f ---- train_accuracy: %.4f ---- tran_aux_loss: %.4f' % \
  198.                                           (iter, loss_sum / test_iter, accuracy_sum / test_iter, aux_loss_sum / test_iter))
  199.                     print('                                                                                          test_auc: %.4f ----test_loss: %.4f ---- test_accuracy: %.4f ---- test_aux_loss: %.4f' % eval(sess, test_data, model, best_model_path))
  200.                     loss_sum = 0.0
  201.                     accuracy_sum = 0.0
  202.                     aux_loss_sum = 0.0
  203.                 if (iter % save_iter) == 0:
  204.                     print('save model iter: %d' %(iter))
  205.                     model.save(sess, model_path+"--"+str(iter))
  206.             lr *= 0.5
  208. def test(
  209.         train_file = "local_train_splitByUser",
  210.         test_file = "local_test_splitByUser",
  211.         uid_voc = "uid_voc.pkl",
  212.         mid_voc = "mid_voc.pkl",
  213.         cat_voc = "cat_voc.pkl",
  214.         batch_size = 128,
  215.         maxlen = 100,
  216.         model_type = 'DNN',
  217.     seed = 2
  218. ):
  220.     model_path = "dnn_best_model/ckpt_noshuff" + model_type + str(seed)
  221.     gpu_options = tf.GPUOptions(allow_growth=True)
  222.     with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess:
  223.         train_data = DataIterator(train_file, uid_voc, mid_voc, cat_voc, batch_size, maxlen)
  224.         test_data = DataIterator(test_file, uid_voc, mid_voc, cat_voc, batch_size, maxlen)
  225.         n_uid, n_mid, n_cat = train_data.get_n()
  226.         if model_type == 'DNN':
  227.             model = Model_DNN(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE)
  228.         elif model_type == 'PNN':
  229.             model = Model_PNN(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE)
  230.         elif model_type == 'Wide':
  231.             model = Model_WideDeep(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE)
  232.         elif model_type == 'DIN':
  233.             model = Model_DIN(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE)
  234.         elif model_type == 'DIN-V2-gru-att-gru':
  235.             model = Model_DIN_V2_Gru_att_Gru(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE)
  236.         elif model_type == 'DIN-V2-gru-gru-att':
  237.             model = Model_DIN_V2_Gru_Gru_att(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE)
  238.         elif model_type == 'DIN-V2-gru-qa-attGru':
  239.             model = Model_DIN_V2_Gru_QA_attGru(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE)
  240.         elif model_type == 'DIN-V2-gru-vec-attGru':
  241.             model = Model_DIN_V2_Gru_Vec_attGru(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE)
  242.         elif model_type == 'DIEN':
  243.             model = Model_DIN_V2_Gru_Vec_attGru_Neg(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE)
  244.         else:
  245.             print ("Invalid model_type : %s", model_type)
  246.             return
  247.         model.restore(sess, model_path)
  248.         print('test_auc: %.4f ----test_loss: %.4f ---- test_accuracy: %.4f ---- test_aux_loss: %.4f' % eval(sess, test_data, model, model_path))
  250. if __name__ == '__main__':
  251.     if len(sys.argv) == 4:
  252.         SEED = int(sys.argv[3])
  253.     else:
  254.         SEED = 3
  255.     tf.set_random_seed(SEED)
  256.     numpy.random.seed(SEED)
  257.     random.seed(SEED)
  258.     if sys.argv[1] == 'train':
  259.         train(model_type=sys.argv[2], seed=SEED)
  260.     elif sys.argv[1] == 'test':
  261.         test(model_type=sys.argv[2], seed=SEED)
  262.     else:
  263.         print('do nothing...')

训练数据获取

首先介绍下如何读取之前生成的训练数据并迭代获取这些数据生成最终的训练数据。

样本数据获取和迭代

训练和测试样本数据获取代码：

  1. train_data = DataIterator(train_file, uid_voc, mid_voc, cat_voc, batch_size, maxlen, shuffle_each_epoch=False)
  2. test_data = DataIterator(test_file, uid_voc, mid_voc, cat_voc, batch_size, maxlen)

这里通过DataIterator类来获取训练和测试样本数据，DataIterator的定义在data_iterator.py，详细注解代码如下：

  1. import numpy
  2. import json
  3. import _pickle as pkl
  4. import random
  6. import gzip
  8. import shuffle
  10. def unicode_to_utf8(d):
  11.     return dict((key.encode("UTF-8"), value) for (key,value) in d.items())
  13. def load_dict(filename):
  14.     try:
  15.         with open(filename, 'rb') as f:
  16.             return unicode_to_utf8(json.load(f))
  17.     except:
  18.         with open(filename, 'rb') as f:
  19.             #return unicode_to_utf8(pkl.load(f))
  20.             return pkl.load(f)
  22. def fopen(filename, mode='r'):
  23.     if filename.endswith('.gz'):
  24.         return gzip.open(filename, mode)
  25.     return open(filename, mode)
  27. class DataIterator:
  29.     def __init__(self, source, # local_train_splitByUser 
  30.                 #第一行：label 0, 用户id, 商品id（未点击，负样本）, 商品分类, 之前点击过所有商品id，之前点击过所有商品分类
  31.                 #第二行：label 1, 用户id, 商品id（点击过，正样本）, 商品分类, 之前点击过所有商品id，之前点击过所有商品分类 
  32.                  uid_voc, # 用户 id 编号，uid_voc.pkl
  33.                  mid_voc, # item id 编号，mid_voc.pkl
  34.                  cat_voc, # cat id 编号，cat_voc.pkl
  35.                  batch_size=128,
  36.                  maxlen=100,
  37.                  skip_empty=False,
  38.                  shuffle_each_epoch=False,
  39.                  sort_by_length=True,
  40.                  max_batch_size=20,
  41.                  minlen=None):
  42.         if shuffle_each_epoch:
  43.             self.source_orig = source
  44.             self.source = shuffle.main(self.source_orig, temporary=True)
  45.         else:
  46.             self.source = fopen(source, 'r')
  47.         self.source_dicts = []
  48.         for source_dict in [uid_voc, mid_voc, cat_voc]:
  49.             self.source_dicts.append(load_dict(source_dict)) # uid_voc, mid_voc 和 cat_voc；
  51.         f_meta = open("item-info", "r")
  52.         # (文件 item-info 保存字段): 商品item id, 商品分类 cat（某个名词，例如：Cables & Accessories)
  53.         meta_map = {} # item id 和 商品分类 cat的映射
  54.         for line in f_meta:
  55.             arr = line.strip().split("\t")
  56.             if arr[0] not in meta_map:
  57.                 meta_map[arr[0]] = arr[1]
  58.         self.meta_id_map ={}
  59.         for key in meta_map:
  60.             val = meta_map[key] # item id 对应的 item cate
  61.             if key in self.source_dicts[1]:
  62.                 mid_idx = self.source_dicts[1][key] # item id 对应的编号
  63.             else:
  64.                 mid_idx = 0
  65.             if val in self.source_dicts[2]:
  66.                 cat_idx = self.source_dicts[2][val] # cate id 对应的编号
  67.             else:
  68.                 cat_idx = 0
  69.             self.meta_id_map[mid_idx] = cat_idx #item id 编号 和 cat id 编号对应
  71.         f_review = open("reviews-info", "r")
  72.         #（文件reviews-info保存字段）：user id, 商品item id, rating of the product（商品等级,浮点数）, 时间戳
  73.         self.mid_list_for_random = []
  74.         for line in f_review:
  75.             arr = line.strip().split("\t")
  76.             tmp_idx = 0
  77.             if arr[1] in self.source_dicts[1]: # mid_voc
  78.                 tmp_idx = self.source_dicts[1][arr[1]]
  79.             self.mid_list_for_random.append(tmp_idx) # item id 的编号
  81.         self.batch_size = batch_size
  82.         self.maxlen = maxlen
  83.         self.minlen = minlen
  84.         self.skip_empty = skip_empty
  86.         self.n_uid = len(self.source_dicts[0]) # 用户数
  87.         self.n_mid = len(self.source_dicts[1]) # 商品 item数
  88.         self.n_cat = len(self.source_dicts[2]) # 商品分类数
  90.         self.shuffle = shuffle_each_epoch
  91.         self.sort_by_length = sort_by_length
  93.         self.source_buffer = []
  94.         self.k = batch_size * max_batch_size
  96.         self.end_of_data = False
  98.     def get_n(self):
  99.         return self.n_uid, self.n_mid, self.n_cat
  101.     def __iter__(self):
  102.         return self
  104.     def reset(self):
  105.         if self.shuffle:
  106.             self.source= shuffle.main(self.source_orig, temporary=True)
  107.         else:
  108.             self.source.seek(0)
  110.     def __next__(self):
  111.         if self.end_of_data:
  112.             self.end_of_data = False
  113.             self.reset()
  114.             raise StopIteration
  116.         source = []
  117.         target = []
  119.         if len(self.source_buffer) == 0:
  120.             for k_ in range(self.k):
  121.                 ss = self.source.readline()
  122.                 #第一行：label 0, 用户id, 商品id（未点击，负样本）, 商品分类, 之前点击过所有商品id，之前点击过所有商品分类
  123.                 #第二行：label 1, 用户id, 商品id（点击过，正样本）, 商品分类, 之前点击过所有商品id，之前点击过所有商品分类                
  124.                 if ss == "":
  125.                     break
  126.                 self.source_buffer.append(ss.strip("\n").split("\t"))
  127.                 # list: label, 用户id, 商品id, 商品分类, 之前点击过所有商品id, 之前点击过所有商品分类
  129.             # sort by  history behavior length
  130.             if self.sort_by_length: # true
  131.                 his_length = numpy.array([len(s[4].split("")) for s in self.source_buffer])
  132.                 tidx = his_length.argsort()
  134.                 _sbuf = [self.source_buffer[i] for i in tidx]
  135.                 self.source_buffer = _sbuf # 按照之前点击商品个数排序
  136.             else:
  137.                 self.source_buffer.reverse()
  139.         if len(self.source_buffer) == 0:
  140.             self.end_of_data = False
  141.             self.reset()
  142.             raise StopIteration
  144.         try:
  146.             # actual work here
  147.             while True:
  149.                 # read from source file and map to word index
  150.                 try:
  151.                     ss = self.source_buffer.pop() # label, 用户id, 商品id, 商品分类, 之前点击过所有商品id, 之前点击过所有商品分类
  152.                 except IndexError:
  153.                     break
  155.                 uid = self.source_dicts[0][ss[1]] if ss[1] in self.source_dicts[0] else 0 # 用户id编号
  156.                 mid = self.source_dicts[1][ss[2]] if ss[2] in self.source_dicts[1] else 0 # 产品id编号
  157.                 cat = self.source_dicts[2][ss[3]] if ss[3] in self.source_dicts[2] else 0 # 分类编号
  158.                 tmp = []
  159.                 for fea in ss[4].split(""):
  160.                     m = self.source_dicts[1][fea] if fea in self.source_dicts[1] else 0
  161.                     tmp.append(m)
  162.                 mid_list = tmp # 所有点击过的产品id编号
  164.                 tmp1 = []
  165.                 for fea in ss[5].split(""):
  166.                     c = self.source_dicts[2][fea] if fea in self.source_dicts[2] else 0
  167.                     tmp1.append(c)
  168.                 cat_list = tmp1 # 所有点击过的产品分类编号
  170.                 # read from source file and map to word index
  172.                 #if len(mid_list) > self.maxlen:
  173.                 #    continue
  174.                 if self.minlen != None:
  175.                     if len(mid_list) <= self.minlen:
  176.                         continue
  177.                 if self.skip_empty and (not mid_list):
  178.                     continue
  180.                 noclk_mid_list = []
  181.                 noclk_cat_list = []
  182.                 for pos_mid in mid_list:
  183.                     noclk_tmp_mid = []
  184.                     noclk_tmp_cat = []
  185.                     noclk_index = 0
  186.                     while True:
  187.                         noclk_mid_indx = random.randint(0, len(self.mid_list_for_random)-1)
  188.                         noclk_mid = self.mid_list_for_random[noclk_mid_indx]
  189.                         if noclk_mid == pos_mid:
  190.                             continue
  191.                         noclk_tmp_mid.append(noclk_mid)
  192.                         noclk_tmp_cat.append(self.meta_id_map[noclk_mid])
  193.                         noclk_index += 1
  194.                         if noclk_index >= 5:
  195.                             break
  196.                     noclk_mid_list.append(noclk_tmp_mid)
  197.                     noclk_cat_list.append(noclk_tmp_cat)
  198.                 source.append([uid, mid, cat, mid_list, cat_list, noclk_mid_list, noclk_cat_list])
  199.                 #用户id, 商品id, 商品分类，之前点过商品（n个)，之前点个商品分类（n个），没点过商品（n*5个），没点过商品分类（n*5个）
  200.                 target.append([float(ss[0]), 1-float(ss[0])])
  201.                 #label, 正样本或者负样本
  202.                 if len(source) >= self.batch_size or len(target) >= self.batch_size:
  203.                     break
  204.         except IOError:
  205.             self.end_of_data = True
  207.         # all sentence pairs in maxibatch filtered out because of length
  208.         if len(source) == 0 or len(target) == 0:
  209.             source, target = self.next()
  211.         return source, target
  212.         #source: N个样本，对于每个样本有如下字段：
  213.         #    用户id, 商品id, 商品分类，之前点过商品（n个)，之前点个商品分类（n个），没点过商品（n*5个），没点过商品分类（n*5个）
  214.         #label: N个样本的label: [0,1] 或者 [1,0]

分别打开训练文件local_train_splitByUser和测试文件local_test_splitByUser，之前的数据处理部分已经给出了说明，这两个文件的格式是每两行对应一个用户点击行为的正负样本对，格式如下：

  1. #第一行：label 0, 用户id, 商品id（未点击，负样本）, 商品分类, 之前点击过所有商品id，之前点击过所有商品分类
  2. #第二行：label 1, 用户id, 商品id（点击过，正样本）, 商品分类, 之前点击过所有商品id，之前点击过所有商品分类

uid_voc、mid_voc和cat_voc分别为用户id、商品item id 和商品分类的编号，__next__函数实现了for循环取样本的功能，具体处理流程已经给出了详细的代码注释，最终返回source和target两个变量，存储内容如下：

  1. #返回变量1，source: N个样本，对于每个样本有如下字段：
  2. #   用户id, 商品id, 商品分类，之前点过商品（n个)，之前点个商品分类（n个），没点过商品（n*5个），没点过商品分类（n*5个）
  3. #返回变量2，label: N个样本的label: [0,1] 或者 [1,0]

数据准备

在获取训练和测试样本数据后，还要进一步对数据做准备和处理，准备处理部分代码如下：

  1. for src, tgt in train_data:
  2.     # src : 用户id, 商品id, 商品分类，之前点过商品（n个)，之前点个商品分类（n个），没点过商品（n*5个），没点过商品分类（n*5个）
  3.     # label: 正样本或者负样本
  4.     uids, mids, cats, mid_his, cat_his, mid_mask, target, sl, noclk_mids, noclk_cats = prepare_data(src, tgt, maxlen, return_neg=True)

主要通过prepare_data函数实现：

  1. def prepare_data(input, target, maxlen = None, return_neg = False):
  2.     # x: a list of sentences
  3.     # input: N个训练样本，每一行格式如下： 
  4.     # 用户id[0], 商品id[1], 商品分类[2]，之前点过商品（n个)[3]，之前点个商品分类（n个）[4]，没点过商品（n*5个）[5]，没点过商品分类（n*5个）[6]
  5.     # label: 正样本或者负样本
  6.     lengths_x = [len(s[4]) for s in input] # N, 每个样本之前点击商品的个数
  7.     seqs_mid = [inp[3] for inp in input] # N*n, 之前点过商品序列
  8.     seqs_cat = [inp[4] for inp in input] # N * n, 之前点过商品分类序列
  9.     noclk_seqs_mid = [inp[5] for inp in input] # N * n * 5, 之前没点过商品序列 
  10.     noclk_seqs_cat = [inp[6] for inp in input] # N * n * 5, 之前没点过商品分类
  12.     if maxlen is not None:
  13.         new_seqs_mid = []
  14.         new_seqs_cat = []
  15.         new_noclk_seqs_mid = []
  16.         new_noclk_seqs_cat = []
  17.         new_lengths_x = []
  18.         for l_x, inp in zip(lengths_x, input): # zip生成组元组成的list，长度与最小list长度一致
  19.             if l_x > maxlen:
  20.                 new_seqs_mid.append(inp[3][l_x - maxlen:])
  21.                 new_seqs_cat.append(inp[4][l_x - maxlen:])
  22.                 new_noclk_seqs_mid.append(inp[5][l_x - maxlen:])
  23.                 new_noclk_seqs_cat.append(inp[6][l_x - maxlen:])
  24.                 new_lengths_x.append(maxlen)
  25.             else:
  26.                 new_seqs_mid.append(inp[3])
  27.                 new_seqs_cat.append(inp[4])
  28.                 new_noclk_seqs_mid.append(inp[5])
  29.                 new_noclk_seqs_cat.append(inp[6])
  30.                 new_lengths_x.append(l_x)
  31.         lengths_x = new_lengths_x
  32.         seqs_mid = new_seqs_mid
  33.         seqs_cat = new_seqs_cat
  34.         noclk_seqs_mid = new_noclk_seqs_mid
  35.         noclk_seqs_cat = new_noclk_seqs_cat
  37.         if len(lengths_x) < 1:
  38.             return None, None, None, None
  40.     n_samples = len(seqs_mid) # 样本数 N
  41.     maxlen_x = numpy.max(lengths_x) # 之前最多的点击样本个数；
  42.     if maxlen_x <= 1:
  43.         maxlen_x = 2
  44.     neg_samples = len(noclk_seqs_mid[0][0]) # 每一次之前点击行为对应的负样本个数
  46.     mid_his = numpy.zeros((n_samples, maxlen_x)).astype('int64') # N * maxLen_x 之前点击item id 序列
  47.     cat_his = numpy.zeros((n_samples, maxlen_x)).astype('int64') # N * maxLen_x 之前点击item 分类 序列
  48.     noclk_mid_his = numpy.zeros((n_samples, maxlen_x, neg_samples)).astype('int64') # N * maxLen_x * ngsample(5), 之前每次点击对应负样本
  49.     noclk_cat_his = numpy.zeros((n_samples, maxlen_x, neg_samples)).astype('int64') # N * maxLen_x * ngsample(5), 之前每次点击对应负样本分类
  50.     mid_mask = numpy.zeros((n_samples, maxlen_x)).astype('float32') # N * maxLen_x 实际之前点击序列长度
  51.     for idx, [s_x, s_y, no_sx, no_sy] in enumerate(zip(seqs_mid, seqs_cat, noclk_seqs_mid, noclk_seqs_cat)):
  52.         mid_mask[idx, :lengths_x[idx]] = 1. # 第idx个样本，前lengths_x[idx]置为1，即有点击的位置置为1.
  53.         mid_his[idx, :lengths_x[idx]] = s_x # 第idx个样本，之前点过的商品id序列
  54.         cat_his[idx, :lengths_x[idx]] = s_y # 第idx个样本，之前点过的商品分类序列
  55.         noclk_mid_his[idx, :lengths_x[idx], :] = no_sx # 第idx个样本，没点过负样本id
  56.         noclk_cat_his[idx, :lengths_x[idx], :] = no_sy # 第idx个样本，没点过负样本分类
  58.     uids = numpy.array([inp[0] for inp in input]) # N，用户id
  59.     mids = numpy.array([inp[1] for inp in input]) # N，商品id
  60.     cats = numpy.array([inp[2] for inp in input]) # N，商品分类
  62.     if return_neg:
  63.         return uids, mids, cats, mid_his, cat_his, mid_mask, numpy.array(target), numpy.array(lengths_x), noclk_mid_his, noclk_cat_his
  64.         # uids: N, 用户id
  65.         # mids: N, 商品 item id
  66.         # cats: N, 商品分类
  67.         # mid_his: N * maxLen_x 之前点击item id 序列
  68.         # cat_his: N * maxLen_x 之前点击item 分类 序列
  69.         # mid_mask: N * maxLen_x 实际之前点击序列长度
  70.         # numpy.array(target): N * 2, label 正样本 [1,0] or 负样本 [0,1]
  71.         # numpy.array(lengths_x):N, 实际之前点击样本序列长度
  72.         # noclk_mid_his:N * maxLen_x * ngsample(5), 之前每次点击对应负样本
  73.         # noclk_cat_his:N * maxLen_x * ngsample(5), 之前每次点击对应负样本分类
  74.     else:
  75.         return uids, mids, cats, mid_his, cat_his, mid_mask, numpy.array(target), numpy.array(lengths_x)

max_len = 100，表示用户历史点击商品的截断长度为100，即最长历史击样本序列长度为100，代码同样给出了详细注释，最终返回变量：uids, mids, cats, mid_his, cat_his, mid_mask, target, sl, noclk_mids, noclk_cats，定义如下：

  1. # uids: N, 用户id
  2. # mids: N, 商品 item id
  3. # cats: N, 商品分类
  4. # mid_his: N * maxLen_x 之前点击item id 序列
  5. # cat_his: N * maxLen_x 之前点击item 分类 序列
  6. # mid_mask: N * maxLen_x 实际之前点击序列长度
  7. # target: N * 2, label 正样本 [1,0] or 负样本 [0,1]
  8. # sl:N, 实际之前点击样本序列长度
  9. # noclk_mids: N * maxLen_x * ngsample(5), 之前每次点击对应负样本
  10. # noclk_cats: N * maxLen_x * ngsample(5), 之前每次点击对应负样本分类

这是模型训练需要的全部数据。

模型结构

模型定义代码如下：

  1. model = Model_DIN_V2_Gru_Vec_attGru_Neg(n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE)

基础网络结构

网络结构类Model_DIN_V2_Gru_Vec_attGru_Neg定义在model.py文件：

  1. class Model_DIN_V2_Gru_Vec_attGru_Neg(Model):
  2.     def __init__(self, n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE, use_negsampling=True):
  3.         # 用户id数，商品id数，商品分类数，18，18 * 2，18 * 2
  4.         super(Model_DIN_V2_Gru_Vec_attGru_Neg, self).__init__(n_uid, n_mid, n_cat,
  5.                                                           EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE,
  6.                                                           use_negsampling)
  8.         # RNN layer(-s)
  9.         with tf.name_scope('rnn_1'):
  10.             # item_his_eb: 之前点过商品embedding 和 分类embedding拼接在一起，[batch_size, n, EMBEDDING_DIM * 2]
  11.             # [batch_size,]， 实际之前点击样本序列长度
  12.             #  HIDDEN_SIZE 32
  13.             rnn_outputs, _ = dynamic_rnn(GRUCell(HIDDEN_SIZE), inputs=self.item_his_eb,
  14.                                          sequence_length=self.seq_len_ph, dtype=tf.float32,
  15.                                          scope="gru1")
  16.             # [batch_size, n, HIDDEN_SIZE]
  17.             tf.summary.histogram('GRU_outputs', rnn_outputs)
  18.         # rnn_outputs[:, :-1, :]:上一时刻embedding特征，[batch_size, n - 1, HIDDEN_SIZE]
  19.         # item_his_eb[:, 1:, :]:当前时刻的embedding特征，[batch_size, n - 1, EMBEDDING_DIM * 2]
  20.         # noclk_item_his_eb[:, 1:, :]:每次点击行为取第0个为负样本，[batch_size, n - 1, EMBEDDING_DIM * 2]
  21.         # 每一个样本，有效的点击序列个数:[batch_size, n - 1]
  22.         aux_loss_1 = self.auxiliary_loss(rnn_outputs[:, :-1, :], self.item_his_eb[:, 1:, :],
  23.                                          self.noclk_item_his_eb[:, 1:, :],
  24.                                          self.mask[:, 1:], stag="gru")
  25.         self.aux_loss = aux_loss_1
  27.         # Attention layer
  28.         with tf.name_scope('Attention_layer_1'):
  29.             # item_eb：mid embedding 和 cat embedding拼接在一起，[batch_size, EMBEDDING_DIM * 2]
  30.             # rnn_outputs：GRU1输出的用户兴趣状态，[batch_size, n, HIDDEN_SIZE]
  31.             att_outputs, alphas = din_fcn_attention(self.item_eb, rnn_outputs, ATTENTION_SIZE, self.mask,
  32.                                                     softmax_stag=1, stag='1_1', mode='LIST', return_alphas=True)
  33.             # 输出：ouput: [batch_size, n, HIDDEN_SIZE] 
  34.             # 每个样本用户之前每一个行为兴趣特征和当前item的权重，即注意力分数：scores: [batch_size, n]
  35.             tf.summary.histogram('alpha_outputs', alphas)
  37.         with tf.name_scope('rnn_2'):
  38.             rnn_outputs2, final_state2 = dynamic_rnn(VecAttGRUCell(HIDDEN_SIZE), inputs=rnn_outputs,
  39.                                                      att_scores = tf.expand_dims(alphas, -1),
  40.                                                      sequence_length=self.seq_len_ph, dtype=tf.float32,
  41.                                                      scope="gru2")
  42.             # 实现AUGRU，输出：[batch_size, HIDDEN_SIZE]
  43.             tf.summary.histogram('GRU2_Final_State', final_state2)
  45.         inp = tf.concat([self.uid_batch_embedded, self.item_eb, self.item_his_eb_sum, self.item_eb * self.item_his_eb_sum, final_state2], 1)
  46.         # uid_batch_embedded： [batch_size, EMBEDDING_DIM]用户特征embedding
  47.         # item_eb： mid embedding 和 cat embedding拼接在一起，[batch_size, EMBEDDING_DIM * 2]
  48.         # item_his_eb_sum：之前行为embedding求和[batch_size, EMBEDDING_DIM * 2]
  49.         # final_state2：attention兴趣层提提权求和
  50.         # 所有特征拼接的一起，送入全连接网络
  51.         self.build_fcn_net(inp, use_dice=True)

其父类为model类，定义同样在model.py：

  1. class Model(object):
  2.     def __init__(self, n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_SIZE, ATTENTION_SIZE, use_negsampling = False):
  3.         with tf.name_scope('Inputs'):
  4.             self.mid_his_batch_ph = tf.placeholder(tf.int32, [None, None], name='mid_his_batch_ph')
  5.             self.cat_his_batch_ph = tf.placeholder(tf.int32, [None, None], name='cat_his_batch_ph')
  6.             self.uid_batch_ph = tf.placeholder(tf.int32, [None, ], name='uid_batch_ph')
  7.             self.mid_batch_ph = tf.placeholder(tf.int32, [None, ], name='mid_batch_ph')
  8.             self.cat_batch_ph = tf.placeholder(tf.int32, [None, ], name='cat_batch_ph')
  9.             self.mask = tf.placeholder(tf.float32, [None, None], name='mask')
  10.             self.seq_len_ph = tf.placeholder(tf.int32, [None], name='seq_len_ph')
  11.             self.target_ph = tf.placeholder(tf.float32, [None, None], name='target_ph')
  12.             self.lr = tf.placeholder(tf.float64, [])
  13.             self.use_negsampling =use_negsampling
  14.             if use_negsampling:
  15.                 self.noclk_mid_batch_ph = tf.placeholder(tf.int32, [None, None, None], name='noclk_mid_batch_ph') #generate 3 item IDs from negative sampling.
  16.                 self.noclk_cat_batch_ph = tf.placeholder(tf.int32, [None, None, None], name='noclk_cat_batch_ph')
  18.         # Embedding layer
  19.         with tf.name_scope('Embedding_layer'):
  20.             # uid embedding 层
  21.             self.uid_embeddings_var = tf.get_variable("uid_embedding_var", [n_uid, EMBEDDING_DIM])
  22.             tf.summary.histogram('uid_embeddings_var', self.uid_embeddings_var)
  23.             self.uid_batch_embedded = tf.nn.embedding_lookup(self.uid_embeddings_var, self.uid_batch_ph)
  25.             #mid embedding 层
  26.             self.mid_embeddings_var = tf.get_variable("mid_embedding_var", [n_mid, EMBEDDING_DIM])
  27.             tf.summary.histogram('mid_embeddings_var', self.mid_embeddings_var)
  28.             self.mid_batch_embedded = tf.nn.embedding_lookup(self.mid_embeddings_var, self.mid_batch_ph)
  29.             self.mid_his_batch_embedded = tf.nn.embedding_lookup(self.mid_embeddings_var, self.mid_his_batch_ph)
  30.             if self.use_negsampling:
  31.                 self.noclk_mid_his_batch_embedded = tf.nn.embedding_lookup(self.mid_embeddings_var, self.noclk_mid_batch_ph)
  32.                 # [batch_size, n, 5, EMBEDDING_DIM]
  33.             # cat embedding 层
  34.             self.cat_embeddings_var = tf.get_variable("cat_embedding_var", [n_cat, EMBEDDING_DIM])
  35.             tf.summary.histogram('cat_embeddings_var', self.cat_embeddings_var)
  36.             self.cat_batch_embedded = tf.nn.embedding_lookup(self.cat_embeddings_var, self.cat_batch_ph)
  37.             self.cat_his_batch_embedded = tf.nn.embedding_lookup(self.cat_embeddings_var, self.cat_his_batch_ph)
  38.             if self.use_negsampling:
  39.                 self.noclk_cat_his_batch_embedded = tf.nn.embedding_lookup(self.cat_embeddings_var, self.noclk_cat_batch_ph)
  40.                 # [batch_size, n, 5, EMBEDDING_DIM]
  42.         self.item_eb = tf.concat([self.mid_batch_embedded, self.cat_batch_embedded], 1)
  43.         # mid embedding 和 cat embedding拼接在一起，[batch_size, EMBEDDING_DIM * 2]
  44.         self.item_his_eb = tf.concat([self.mid_his_batch_embedded, self.cat_his_batch_embedded], 2)
  45.         # 之前点过商品embedding 和 分类embedding拼接在一起，[batch_size, n, EMBEDDING_DIM * 2]
  46.         self.item_his_eb_sum = tf.reduce_sum(self.item_his_eb, 1) # 之前行为embedding求和[batch_size, EMBEDDING_DIM * 2]
  47.         if self.use_negsampling:
  48.             self.noclk_item_his_eb = tf.concat(
  49.                 [self.noclk_mid_his_batch_embedded[:, :, 0, :], self.noclk_cat_his_batch_embedded[:, :, 0, :]], -1)# 0 means only using the first negative item ID. 3 item IDs are inputed in the line 24.
  50.             # 每次点击行为取第0个为负样本，[batch_size, n, EMBEDDING_DIM * 2]
  51.             self.noclk_item_his_eb = tf.reshape(self.noclk_item_his_eb,
  52.                                                 [-1, tf.shape(self.noclk_mid_his_batch_embedded)[1], 36])# cat embedding 18 concate item embedding 18.
  53.             self.noclk_his_eb = tf.concat([self.noclk_mid_his_batch_embedded, self.noclk_cat_his_batch_embedded], -1)
  54.             # [batch_size, n, 5, EMBEDDING_DIM * 2]
  55.             self.noclk_his_eb_sum_1 = tf.reduce_sum(self.noclk_his_eb, 2)
  56.             # [batch_size, n, EMBEDDING_DIM * 2]
  57.             self.noclk_his_eb_sum = tf.reduce_sum(self.noclk_his_eb_sum_1, 1)
  58.             # [batch_size, EMBEDDING_DIM * 2]
  60.     def build_fcn_net(self, inp, use_dice = False):
  61.         bn1 = tf.layers.batch_normalization(inputs=inp, name='bn1')
  62.         dnn1 = tf.layers.dense(bn1, 200, activation=None, name='f1')
  63.         if use_dice:
  64.             dnn1 = dice(dnn1, name='dice_1')
  65.         else:
  66.             dnn1 = prelu(dnn1, 'prelu1')
  68.         dnn2 = tf.layers.dense(dnn1, 80, activation=None, name='f2')
  69.         if use_dice:
  70.             dnn2 = dice(dnn2, name='dice_2')
  71.         else:
  72.             dnn2 = prelu(dnn2, 'prelu2')
  73.         dnn3 = tf.layers.dense(dnn2, 2, activation=None, name='f3')
  74.         self.y_hat = tf.nn.softmax(dnn3) + 0.00000001
  76.         with tf.name_scope('Metrics'):
  77.             # Cross-entropy loss and optimizer initialization
  78.             ctr_loss = - tf.reduce_mean(tf.log(self.y_hat) * self.target_ph)
  79.             self.loss = ctr_loss
  80.             if self.use_negsampling:
  81.                 self.loss += self.aux_loss
  82.             tf.summary.scalar('loss', self.loss)
  83.             self.optimizer = tf.train.AdamOptimizer(learning_rate=self.lr).minimize(self.loss)
  85.             # Accuracy metric
  86.             self.accuracy = tf.reduce_mean(tf.cast(tf.equal(tf.round(self.y_hat), self.target_ph), tf.float32))
  87.             tf.summary.scalar('accuracy', self.accuracy)
  89.         self.merged = tf.summary.merge_all()
  91.     def auxiliary_loss(self, h_states, click_seq, noclick_seq, mask, stag = None):
  92.         # h_states:上一时刻embedding特征，[batch_size, n - 1, HIDDEN_SIZE]
  93.         # click_seq: 当前时刻的embedding特征，[batch_size, n - 1, HIDDEN_SIZE]
  94.         # noclick_seq: 每次点击行为取第0个为负样本，[batch_size, n - 1, EMBEDDING_DIM * 2]
  95.         # mask: 每一个样本，有效的点击序列个数，[batch_size, n - 1]
  96.         mask = tf.cast(mask, tf.float32)
  97.         click_input_ = tf.concat([h_states, click_seq], -1) # [batch_size, n - 1, HIDDEN_SIZE * 2]
  98.         noclick_input_ = tf.concat([h_states, noclick_seq], -1) # [batch_size, n - 1, HIDDEN_SIZE * 2]
  99.         click_prop_ = self.auxiliary_net(click_input_, stag = stag)[:, :, 0] # [batch_size, n - 1]
  100.         noclick_prop_ = self.auxiliary_net(noclick_input_, stag = stag)[:, :, 0] # [batch_size, n - 1]
  101.         click_loss_ = - tf.reshape(tf.log(click_prop_), [-1, tf.shape(click_seq)[1]]) * mask
  102.         noclick_loss_ = - tf.reshape(tf.log(1.0 - noclick_prop_), [-1, tf.shape(noclick_seq)[1]]) * mask
  103.         loss_ = tf.reduce_mean(click_loss_ + noclick_loss_)
  104.         return loss_
  106.     def auxiliary_net(self, in_, stag='auxiliary_net'):
  107.         # [batch_size, n - 1, HIDDEN_SIZE * 2]
  108.         bn1 = tf.layers.batch_normalization(inputs=in_, name='bn1' + stag, reuse=tf.AUTO_REUSE)
  109.         dnn1 = tf.layers.dense(bn1, 100, activation=None, name='f1' + stag, reuse=tf.AUTO_REUSE)
  110.         dnn1 = tf.nn.sigmoid(dnn1)
  111.         dnn2 = tf.layers.dense(dnn1, 50, activation=None, name='f2' + stag, reuse=tf.AUTO_REUSE)
  112.         dnn2 = tf.nn.sigmoid(dnn2)
  113.         dnn3 = tf.layers.dense(dnn2, 2, activation=None, name='f3' + stag, reuse=tf.AUTO_REUSE)
  114.         y_hat = tf.nn.softmax(dnn3) + 0.00000001
  115.         return y_hat
  117.     def train(self, sess, inps):
  118.         if self.use_negsampling:
  119.             loss, accuracy, aux_loss, _ = sess.run([self.loss, self.accuracy, self.aux_loss, self.optimizer], feed_dict={
  120.                 self.uid_batch_ph: inps[0],
  121.                 self.mid_batch_ph: inps[1],
  122.                 self.cat_batch_ph: inps[2],
  123.                 self.mid_his_batch_ph: inps[3],
  124.                 self.cat_his_batch_ph: inps[4],
  125.                 self.mask: inps[5],
  126.                 self.target_ph: inps[6],
  127.                 self.seq_len_ph: inps[7],
  128.                 self.lr: inps[8],
  129.                 self.noclk_mid_batch_ph: inps[9],
  130.                 self.noclk_cat_batch_ph: inps[10],
  131.             })
  132.             return loss, accuracy, aux_loss
  133.         else:
  134.             loss, accuracy, _ = sess.run([self.loss, self.accuracy, self.optimizer], feed_dict={
  135.                 self.uid_batch_ph: inps[0],
  136.                 self.mid_batch_ph: inps[1],
  137.                 self.cat_batch_ph: inps[2],
  138.                 self.mid_his_batch_ph: inps[3],
  139.                 self.cat_his_batch_ph: inps[4],
  140.                 self.mask: inps[5],
  141.                 self.target_ph: inps[6],
  142.                 self.seq_len_ph: inps[7],
  143.                 self.lr: inps[8],
  144.             })
  145.             return loss, accuracy, 0
  147.     def calculate(self, sess, inps):
  148.         if self.use_negsampling:
  149.             probs, loss, accuracy, aux_loss = sess.run([self.y_hat, self.loss, self.accuracy, self.aux_loss], feed_dict={
  150.                 self.uid_batch_ph: inps[0], # [uids[0], mids[1], cats[2], mid_his[3], cat_his[4], mid_mask[5], target[6], sl, noclk_mids, noclk_cats]
  151.                 self.mid_batch_ph: inps[1],
  152.                 self.cat_batch_ph: inps[2],
  153.                 self.mid_his_batch_ph: inps[3],
  154.                 self.cat_his_batch_ph: inps[4],
  155.                 self.mask: inps[5],
  156.                 self.target_ph: inps[6],
  157.                 self.seq_len_ph: inps[7],
  158.                 self.noclk_mid_batch_ph: inps[8],
  159.                 self.noclk_cat_batch_ph: inps[9],
  160.             })
  161.             return probs, loss, accuracy, aux_loss
  162.         else:
  163.             probs, loss, accuracy = sess.run([self.y_hat, self.loss, self.accuracy], feed_dict={
  164.                 self.uid_batch_ph: inps[0],
  165.                 self.mid_batch_ph: inps[1],
  166.                 self.cat_batch_ph: inps[2],
  167.                 self.mid_his_batch_ph: inps[3],
  168.                 self.cat_his_batch_ph: inps[4],
  169.                 self.mask: inps[5],
  170.                 self.target_ph: inps[6],
  171.                 self.seq_len_ph: inps[7]
  172.             })
  173.             return probs, loss, accuracy, 0
  175.     def save(self, sess, path):
  176.         saver = tf.train.Saver()
  177.         saver.save(sess, save_path=path)
  179.     def restore(self, sess, path):
  180.         saver = tf.train.Saver()
  181.         saver.restore(sess, save_path=path)
  182.         print('model restored from %s' % path)

兴趣提取层（Interest Extractor Layer）

兴趣提取层部分代码实现如下：

  1. # RNN layer(-s)
  2. with tf.name_scope('rnn_1'):
  3.     # item_his_eb: 之前点过商品embedding 和 分类embedding拼接在一起，[batch_size, n, EMBEDDING_DIM * 2]
  4.     # [batch_size,]， 实际之前点击样本序列长度
  5.     #  HIDDEN_SIZE 32
  6.     rnn_outputs, _ = dynamic_rnn(GRUCell(HIDDEN_SIZE), inputs=self.item_his_eb,
  7.                                     sequence_length=self.seq_len_ph, dtype=tf.float32,
  8.                                     scope="gru1")
  9.     # [batch_size, n, HIDDEN_SIZE]
  10.     tf.summary.histogram('GRU_outputs', rnn_outputs)
  11. # rnn_outputs[:, :-1, :]:上一时刻embedding特征，[batch_size, n - 1, HIDDEN_SIZE]
  12. # item_his_eb[:, 1:, :]:当前时刻的embedding特征，[batch_size, n - 1, EMBEDDING_DIM * 2]
  13. # noclk_item_his_eb[:, 1:, :]:每次点击行为取第0个为负样本，[batch_size, n - 1, EMBEDDING_DIM * 2]
  14. # 每一个样本，有效的点击序列个数:[batch_size, n - 1]
  15. aux_loss_1 = self.auxiliary_loss(rnn_outputs[:, :-1, :], self.item_his_eb[:, 1:, :],
  16.                                     self.noclk_item_his_eb[:, 1:, :],
  17.                                     self.mask[:, 1:], stag="gru")
  18. self.aux_loss = aux_loss_1

可以看到，首先将用户之前点击item 的embedding送入以GRU为核的rnn结构中，获取每一步的兴趣状态向量rnn_outputs。

接着将0到n-2时刻的rnn_outputs[:, :-1, :]，1到n-1时刻（早一个时刻）的点击商品embedding向量item_his_eb[:, 1:, :]对应负样本点击商品embedding向量noclk_item_his_eb[:, 1:, :]以及标识历史点击序列长度mask[:, 1:]送入auxiliary loss函数，auxiliary loss的实现代码如下：

  1. def auxiliary_loss(self, h_states, click_seq, noclick_seq, mask, stag = None):
  2.     # h_states:上一时刻embedding特征，[batch_size, n - 1, HIDDEN_SIZE]
  3.     # click_seq: 当前时刻的embedding特征，[batch_size, n - 1, HIDDEN_SIZE]
  4.     # noclick_seq: 每次点击行为取第0个为负样本，[batch_size, n - 1, EMBEDDING_DIM * 2]
  5.     # mask: 每一个样本，有效的点击序列个数，[batch_size, n - 1]
  6.     mask = tf.cast(mask, tf.float32)
  7.     click_input_ = tf.concat([h_states, click_seq], -1) # [batch_size, n - 1, HIDDEN_SIZE * 2]
  8.     noclick_input_ = tf.concat([h_states, noclick_seq], -1) # [batch_size, n - 1, HIDDEN_SIZE * 2]
  9.     click_prop_ = self.auxiliary_net(click_input_, stag = stag)[:, :, 0] # [batch_size, n - 1]
  10.     noclick_prop_ = self.auxiliary_net(noclick_input_, stag = stag)[:, :, 0] # [batch_size, n - 1]
  11.     click_loss_ = - tf.reshape(tf.log(click_prop_), [-1, tf.shape(click_seq)[1]]) * mask
  12.     noclick_loss_ = - tf.reshape(tf.log(1.0 - noclick_prop_), [-1, tf.shape(noclick_seq)[1]]) * mask
  13.     loss_ = tf.reduce_mean(click_loss_ + noclick_loss_)
  14.     return loss_

第一层rnn返回的状态序列rnn_outputs为模型化兴趣变化过程的兴趣序列。

兴趣进化层 （Interest Evolving Layer）实现

兴趣进化层 （Interest Evolving Layer）实现代码如下：

  1. # Attention layer
  2. with tf.name_scope('Attention_layer_1'):
  3.     # item_eb：mid embedding 和 cat embedding拼接在一起，[batch_size, EMBEDDING_DIM * 2]
  4.     # rnn_outputs：GRU1输出的用户兴趣状态，[batch_size, n, HIDDEN_SIZE]
  5.     att_outputs, alphas = din_fcn_attention(self.item_eb, rnn_outputs, ATTENTION_SIZE, self.mask,
  6.                                             softmax_stag=1, stag='1_1', mode='LIST', return_alphas=True)
  7.     # 输出：ouput: [batch_size, n, HIDDEN_SIZE] 
  8.     # 每个样本用户之前每一个行为兴趣特征和当前item的权重，即注意力分数：scores: [batch_size, n]
  9.     tf.summary.histogram('alpha_outputs', alphas)
  11. with tf.name_scope('rnn_2'):
  12.     rnn_outputs2, final_state2 = dynamic_rnn(VecAttGRUCell(HIDDEN_SIZE), inputs=rnn_outputs,
  13.                                                 att_scores = tf.expand_dims(alphas, -1),
  14.                                                 sequence_length=self.seq_len_ph, dtype=tf.float32,
  15.                                                 scope="gru2")
  16.     # 实现AUGRU，输出：[batch_size, HIDDEN_SIZE]
  17.     tf.summary.histogram('GRU2_Final_State', final_state2)
  19. inp = tf.concat([self.uid_batch_embedded, self.item_eb, self.item_his_eb_sum, self.item_eb * self.item_his_eb_sum, final_state2], 1)
  20. # uid_batch_embedded： [batch_size, EMBEDDING_DIM]用户特征embedding
  21. # item_eb： mid embedding 和 cat embedding拼接在一起，[batch_size, EMBEDDING_DIM * 2]
  22. # item_his_eb_sum：之前行为embedding求和[batch_size, EMBEDDING_DIM * 2]
  23. # final_state2：attention兴趣层提提权求和
  24. # 所有特征拼接的一起，送入全连接网络
  25. self.build_fcn_net(inp, use_dice=True)

attention层，输入每个样本用户的兴趣变化序列rnn_outputs和当前item的embedding item_eb，利用attention机制获取每个样本用户之前每一个行为兴趣特征和当前item的权重，返回即注意力分数：scores[batch_size, n]，attention层代码实现如下：

  1. def din_fcn_attention(query, facts, attention_size, mask, stag='null', mode='SUM', softmax_stag=1, time_major=False, return_alphas=False, forCnn=False):
  2.         # query：mid embedding 和 cat embedding拼接在一起，[batch_size, EMBEDDING_DIM * 2]
  3.         # facts：GRU1输出的用户兴趣状态，[batch_size, n, HIDDEN_SIZE]
  4.         # attention_size：36
  5.         # mask：每一个样本，有效的点击序列个数，[batch_size, n]
  6.     if isinstance(facts, tuple):
  7.         # In case of Bi-RNN, concatenate the forward and the backward RNN outputs.
  8.         facts = tf.concat(facts, 2)
  9.     if len(facts.get_shape().as_list()) == 2:
  10.         facts = tf.expand_dims(facts, 1)
  12.     if time_major:
  13.         # (T,B,D) => (B,T,D)
  14.         facts = tf.array_ops.transpose(facts, [1, 0, 2])
  15.     # Trainable parameters
  16.     mask = tf.equal(mask, tf.ones_like(mask))
  17.     facts_size = facts.get_shape().as_list()[-1]  # D value - hidden size of the RNN layer
  18.     # 上一层GRU(GRU1)的输出状态，即此层GRU（GRU2）的输入的维度大小：HIDDEN_SIZE。
  19.     querry_size = query.get_shape().as_list()[-1]
  20.     # 推荐商品 item id的embedding维度：EMBEDDING_DIM * 2。
  21.     query = tf.layers.dense(query, facts_size, activation=None, name='f1' + stag)
  22.     # 全连接，输入：[batch_size, EMBEDDING_DIM * 2] 输出：[batch_size, HIDDEN_SIZE]
  23.     query = prelu(query)
  24.     # prelu 非线性变换函数
  25.     queries = tf.tile(query, [1, tf.shape(facts)[1]])
  26.     # queries的1维不变，2维扩展为之前的n倍，即维度变为：[batch_size, HIDDEN_SIZE * n]，，对于一个推荐商品，其会生成n个重复的相同一个推荐商品的embedding向量
  27.     queries = tf.reshape(queries, tf.shape(facts))
  28.     # 维度进一步变为：[batch_size, n, HIDDEN_SIZE]
  29.     din_all = tf.concat([queries, facts, queries-facts, queries*facts], axis=-1)
  30.     # # 最后一个维度拼接到一起，拼接后变为 [batch_size, n, 4 * HIDDEN_SIZE]
  31.     d_layer_1_all = tf.layers.dense(din_all, 80, activation=tf.nn.sigmoid, name='f1_att' + stag)  
  32.     # 第一层网络，输出[batch_size, n, 80]
  33.     d_layer_2_all = tf.layers.dense(d_layer_1_all, 40, activation=tf.nn.sigmoid, name='f2_att' + stag)
  34.     # 第二层网络，输出[batch_size, n, 40]
  35.     d_layer_3_all = tf.layers.dense(d_layer_2_all, 1, activation=None, name='f3_att' + stag)
  36.     # 第三层网络，输出[batch_size, n, 1]
  37.     d_layer_3_all = tf.reshape(d_layer_3_all, [-1, 1, tf.shape(facts)[1]])
  38.     scores = d_layer_3_all
  39.     # 最后的输出为[batch_size, 1, n]
  40.     # Mask
  41.     # key_masks = tf.sequence_mask(facts_length, tf.shape(facts)[1])   # [B, T]
  42.     key_masks = tf.expand_dims(mask, 1) # [B, 1, T]
  43.     # 标识矩阵B * T个点位，哪些是true （存在之前点击过的商品）哪些是false（不存在之前点击过的商品）
  44.     #例如：tf.sequence_mask([1, 3, 2], 5)，返回值为：
  45.     # [[True, False, False, False, False],
  46.     #  [True, True, True, False, False],
  47.     #  [True, True, False, False, False]]
  48.     paddings = tf.ones_like(scores) * (-2 ** 32 + 1)
  49.     if not forCnn:
  50.         scores = tf.where(key_masks, scores, paddings)  # [B, 1, T]
  52.     # Scale
  53.     # scores = scores / (facts.get_shape().as_list()[-1] ** 0.5)
  55.     # Activation
  56.     if softmax_stag:
  57.         scores = tf.nn.softmax(scores)  # [B, 1, T]
  58.         # [batch_size, 1, n]
  59.     # Weighted sum
  60.     if mode == 'SUM':
  61.         output = tf.matmul(scores, facts)  # [B, 1, H]
  62.         # output = tf.reshape(output, [-1, tf.shape(facts)[-1]])
  63.     else:
  64.         scores = tf.reshape(scores, [-1, tf.shape(facts)[1]])
  65.         # 纬度变为： [batch_size, n], 表示没个样本每个行为的权重
  66.         output = facts * tf.expand_dims(scores, -1)
  67.         # [batch_size, n, HIDDEN_SIZE] * [batch_size, n, 1]
  68.         output = tf.reshape(output, tf.shape(facts))
  69.         # [batch_size, n, HIDDEN_SIZE]
  70.     if return_alphas:
  71.         return output, scores
  72.     return output

ouput为每个历史点击商品embedding取attention打分加权后的结果，scores为这个batch的用户之前点过商品embedding的注意力分数，这里的代码和之前介绍的DIN代码实现中attention层代码是类似的。

AUGRU层实现，AUGRU层具体原理可以参考专题1，代码如下：

  1. with tf.name_scope('rnn_2'):
  2.     rnn_outputs2, final_state2 = dynamic_rnn(VecAttGRUCell(HIDDEN_SIZE), inputs=rnn_outputs,
  3.                                                 att_scores = tf.expand_dims(alphas, -1),
  4.                                                 sequence_length=self.seq_len_ph, dtype=tf.float32,
  5.                                                 scope="gru2")
  6.     # 实现AUGRU，输出：[batch_size, HIDDEN_SIZE]
  7.     tf.summary.histogram('GRU2_Final_State', final_state2)
  9. inp = tf.concat([self.uid_batch_embedded, self.item_eb, self.item_his_eb_sum, self.item_eb * self.item_his_eb_sum, final_state2], 1)
  10. # uid_batch_embedded： [batch_size, EMBEDDING_DIM]用户特征embedding
  11. # item_eb： mid embedding 和 cat embedding拼接在一起，[batch_size, EMBEDDING_DIM * 2]
  12. # item_his_eb_sum：之前行为embedding求和[batch_size, EMBEDDING_DIM * 2]
  13. # final_state2：attention兴趣层提提权求和
  14. # 所有特征拼接的一起，送入全连接网络

dynamic_rnn的代码实现是在rnn.py，这里实现了AUGRU的核心功能，返回最终attention兴趣提权求和的状态特征final_state2，最后将所有特征拼到一起送入全连接层：

  1. def build_fcn_net(self, inp, use_dice = False):
  2.     bn1 = tf.layers.batch_normalization(inputs=inp, name='bn1')
  3.     dnn1 = tf.layers.dense(bn1, 200, activation=None, name='f1')
  4.     if use_dice:
  5.         dnn1 = dice(dnn1, name='dice_1')
  6.     else:
  7.         dnn1 = prelu(dnn1, 'prelu1')
  9.     dnn2 = tf.layers.dense(dnn1, 80, activation=None, name='f2')
  10.     if use_dice:
  11.         dnn2 = dice(dnn2, name='dice_2')
  12.     else:
  13.         dnn2 = prelu(dnn2, 'prelu2')
  14.     dnn3 = tf.layers.dense(dnn2, 2, activation=None, name='f3')
  15.     self.y_hat = tf.nn.softmax(dnn3) + 0.00000001
  17.     with tf.name_scope('Metrics'):
  18.         # Cross-entropy loss and optimizer initialization
  19.         ctr_loss = - tf.reduce_mean(tf.log(self.y_hat) * self.target_ph)
  20.         self.loss = ctr_loss
  21.         if self.use_negsampling:
  22.             self.loss += self.aux_loss
  23.         tf.summary.scalar('loss', self.loss)
  24.         self.optimizer = tf.train.AdamOptimizer(learning_rate=self.lr).minimize(self.loss)
  26.         # Accuracy metric
  27.         self.accuracy = tf.reduce_mean(tf.cast(tf.equal(tf.round(self.y_hat), self.target_ph), tf.float32))
  28.         tf.summary.scalar('accuracy', self.accuracy)
  30.     self.merged = tf.summary.merge_all()

ctr_loss和aux_loss求和得到最终的loss函数，通过优化器来优化即可完成训练。

训练模型

执行：

  1. train.py train DIEN

可以实现DIEN的训练，成功后会打印如下结果：

当然其他网络结构也有实现代码，这个不在本节介绍的范围，会在其他文章中介绍。

标签： 机器学习 深度学习 算法
本文转载自: https://blog.csdn.net/fangfanglovezhou/article/details/122972650
版权归原作者 I_belong_to_jesus 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Deep Interest Evolution Network(DIEN)专题3:代码解析之模型训练和模型结构”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？