test=develop, debug

123malin · 123malin · commit fe0ed2dfd1c7 · 2021-04-19T12:00:48.000+08:00
diff --git a/models/treebased/README.md b/models/treebased/README.md
@@ -1,28 +1,36 @@
-# Paddle-TDM
+# Paddle TDM解决方案
 
-TDM召回方法来源于阿里妈妈团队在`KDD2018`发表的论文[Learning Tree-based Deep Model for Recommender Systems](https://arxiv.org/pdf/1801.02294.pdf)，本示例代码提供了基于PaddlePaddle实现的TreeBased推荐搜索算法，主要包含以下组成：
+本示例代码提供了基于PaddlePaddle实现的[TDM](https://arxiv.org/pdf/1801.02294.pdf)推荐搜索算法。TDM模型是为大规模推荐系统设计的、能承载任意先进模型来高效检索用户兴趣的推荐算法解决方案。该方案基于树结构，提出了一套对用户兴趣度量进行层次化建模与检索的方法论，使得系统能直接利高级深度学习模型在全库范围内检索用户兴趣。其基本原理是使用树结构对全库item进行索引，然后训练深度模型以支持树上的逐层检索，从而将大规模推荐中全库检索的复杂度由O(n)（n为所有item的量级）下降至O(log n)。
 
-- 基于fake数据集，适用于快速调试的paddle-tdm模型。主要用于理解paddle-tdm的设计原理，高效上手设计适合您的使用场景的模型。
 
-以上内容将随paddle版本迭代不断更新，欢迎您关注该代码库。
+## 快速开始
 
-## TDM设计思路
+基于demo数据集，快速上手TDM模型，为您后续设计适合特定使用场景的模型做准备。
 
-### 基本概念
-TDM是为大规模推荐系统设计的、能承载任意先进模型来高效检索用户兴趣的推荐算法解决方案。TDM基于树结构，提出了一套对用户兴趣度量进行层次化建模与检索的方法论，使得系统能直接利高级深度学习模型在全库范围内检索用户兴趣。其基本原理是使用树结构对全库item进行索引，然后训练深度模型以支持树上的逐层检索，从而将大规模推荐中全库检索的复杂度由O(n)（n为所有item的量级）下降至O(log n)。
+假定您PaddleRec所在目录为${PaddleRec_Home}。
 
-### 核心问题
+- Step1: 进入tree-based模型库文件夹下，完成demo数据集的切分、建树等准备工作。
 
-1. 如何构建树结构？
-2. 如何基于树结构做深度学习模型的训练？
-3. 如何基于树及模型进行高效检索？
+```shell
+cd ${PaddleRec_Home}/models/treebased/
+./data_prepare.sh demo
+```
+demo数据集预处理一键命令为 `./data_prepare.sh demo` 。若对具体的数据处理、建树细节感兴趣，请查看    `data_prepare.sh` 脚本。这一步完成后，您会在 `${PaddleRec_Home}/models/treebased/` 目录下得到一个名为 `demo_data`的目录，该目录结构如下：
 
-### PaddlePaddle的TDM方案
+```
+├── treebased
+├── demo_data
+|   ├── samples                      JTM Tree-Learning算法所需，
+|   |   ├── samples_{item_id}.json   记录了所有和 `item_id` 相关的训练集样本。
+|   ├── train_data                   训练集目录
+|   ├── test_data                    测试集目录
+|   ├── ItemCate.txt                 记录所有item的类别信息，用于初始化建树。
+|   ├── Stat.txt                     记录所有item在训练集中出现的频次信息，用于采样。
+|   ├── tree.pb                      初始化化树文件
+```
 
-1. 树结构的数据，来源于各个业务的实际场景，构造方式各有不同，paddle-TDM一期暂不提供统一的树的构造流程，但会统一树构造好之后，输入paddle网络的数据组织形式。业务方可以使用任意工具构造自己的树，生成指定的数据格式，参与tdm网络训练。
-2. 网络训练中，有三个核心问题:
-   
-   - 如何组网？答：paddle封装了大量的深度学习OP，用户可以根据需求设计自己的网络结构。
-   - 训练数据如何组织？答：tdm的训练数据主要为：`user/query emb` 加 `item`的正样本，`item`需要映射到树的某个叶子节点。用户只需准备符合该构成的数据即可。负样本的生成，会基于用户提供的树结构，以及paddle提供的`tdm-sampler op`完成高效的负采样，并自动添加相应的label，参与tdm中深度学习模型的训练。
-   - 大规模的数据与模型训练如何实现？答：基于paddle优秀的大规模参数服务器分布式能力，可以实现高效的分布式训练。基于paddle-fleet api，学习门槛极低，且可以灵活的支持增量训练，流式训练等业务需求。
-3. 训练好模型后，可以基于paddle，将检索与打分等流程都融入paddle的组网中，生成inference_model与参数文件，基于PaddlePaddle的预测库或者PaddleLite进行快速部署与高效检索。
+- Step2: 快速运行。config.yaml中配置了模型训练所有的超参，运行方式同PaddleRec其他模型静态图运行方式。当前树模型暂不支持动态图运行模式。
+
+```shell
+python -u ../../../tools/static_trainer.py -m config.yaml 
+```
diff --git a/models/treebased/builder/tree_index_builder.py b/models/treebased/builder/tree_index_builder.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from paddle.fluid.proto import index_dataset_pb2
+from paddle.distributed.fleet.proto import index_dataset_pb2
 import numpy as np
 import struct
 import argparse
@@ -97,20 +97,20 @@ def build(self, output_filename, ids, codes, data=None, id_offset=None):
         min_code = 0
         max_code = codes[-1]
         while max_code > 0:
-            min_code = min_code * 2 + 1
-            max_code = int((max_code - 1) / 2)
+            min_code = min_code * self.branch + 1
+            max_code = int((max_code - 1) / self.branch)
 
         for i in range(len(codes)):
             while codes[i] < min_code:
-                codes[i] = codes[i] * 2 + 1
+                codes[i] = codes[i] * self.branch + 1
 
         filter_set = set()
         max_level = 0
         tree_meta = index_dataset_pb2.TreeMeta()
 
         with open(output_filename, 'wb') as f:
             for id, code in zip(ids, codes):
-                node = index_dataset_pb2.Node()
+                node = index_dataset_pb2.IndexNode()
                 node.id = id
                 node.is_leaf = True
                 node.probability = 1.0
@@ -126,7 +126,7 @@ def build(self, output_filename, ids, codes, data=None, id_offset=None):
 
                 for ancessor in ancessors:
                     if ancessor not in filter_set:
-                        node = index_dataset_pb2.Node()
+                        node = index_dataset_pb2.IndexNode()
                         node.id = id_offset + ancessor  # id = id_offset + code
                         node.is_leaf = False
                         node.probability = 1.0
@@ -146,7 +146,7 @@ def build(self, output_filename, ids, codes, data=None, id_offset=None):
     def _ancessors(self, code):
         ancs = []
         while code > 0:
-            code = int((code - 1) / 2)
+            code = int((code - 1) / self.branch)
             ancs.append(code)
         return ancs
 
diff --git a/models/treebased/data_prepare.sh b/models/treebased/data_prepare.sh
@@ -8,5 +8,9 @@ then
     python builder/tree_index_builder.py --mode "by_category" --branch 2 --input "demo_data/ItemCate.txt" --output "demo_data/tree.pb"
 elif [[ ${type} = "user_behaviour" ]]
 then
+   # wget --no-check-certificate https://paddlerec.bj.bcebos.com/tree-based/data/UserBehavior.csv.zip -O data/UserBehavior.csv.zip
+   # unzip -d data/ data/UserBehavior.csv.zip
+   # python data/data_cutter.py --input "./data/UserBehavior.csv" --train "./data/ub_train.csv" --test "./data/ub_test.csv" --number 10000
+    python data/data_generator.py --train_file "data/ub_train.csv" --test_file "data/ub_test.csv" --item_cate_filename "ub_data_new/ItemCate.txt" --stat_file "ub_data_new/Stat.txt" --train_dir "ub_data_new/train_data" --test_dir "ub_data_new/test_data" --sample_dir "ub_data_new/samples" --parall 32 --train_sample_seg_cnt 400 --seq_len 70 --min_seq_len 6
     echo "ub"
 fi
diff --git a/models/treebased/tdm/config.yaml b/models/treebased/tdm/config.yaml
@@ -30,7 +30,7 @@ runner:
 
   train_batch_size: 100  # 30000
   epochs: 5
-  print_interval: 1000   # 1000
+  print_interval: 10   # 1000
   model_save_path: "tdm_demo_output"
 
 # hyper parameters of user-defined network
@@ -40,7 +40,8 @@ hyper_parameters:
     class: Adam
     learning_rate: 0.001
     strategy: async
-  
+ 
+  with_att: False
   # tree
   sparse_feature_num: 5171136
   node_emb_size: 24
diff --git a/models/treebased/tdm/config_ub.yaml b/models/treebased/tdm/config_ub.yaml
@@ -40,6 +40,7 @@ hyper_parameters:
     learning_rate: 0.001
     strategy: async
   
+  with_att: False
   # tree
   sparse_feature_num: 9357374
   node_emb_size: 24
diff --git a/models/treebased/tdm/model.py b/models/treebased/tdm/model.py
@@ -140,6 +140,7 @@ def dnn_model_define(user_input,
                      fea_groups="20,20,10,10,2,2,2,1,1,1",
                      active_op='prelu',
                      use_batch_norm=True,
+                     with_att=False,
                      is_infer=False,
                      topk=10):
     fea_groups = [int(s) for s in fea_groups.split(',')]
@@ -148,30 +149,37 @@ def dnn_model_define(user_input,
 
     layer_data = []
     # start att
-    att_user_input = paddle.concat(
-        user_input, axis=1)  # [bs, total_group_length, emb_size]
-    att_node_input = fluid.layers.expand(
-        unit_id_emb, expand_times=[1, total_group_length, 1])
-    att_din = paddle.concat(
-        [att_user_input, att_user_input * att_node_input, att_node_input],
-        axis=2)
-
-    att_active_op = 'prelu'
-    att_layer_arr = []
-    att_layer1 = FullyConnected3D(
-        3 * node_emb_size, 36, active_op=att_active_op, version=1)
-    att_layer_arr.append(att_layer1)
-    att_layer2 = FullyConnected3D(36, 1, active_op=att_active_op, version=2)
-    att_layer_arr.append(att_layer2)
-
-    layer_data.append(att_din)
-    for layer in att_layer_arr:
-        layer_data.append(layer.call(layer_data[-1]))
-    att_dout = layer_data[-1]
-
-    att_dout = fluid.layers.expand(
-        att_dout, expand_times=[1, 1, node_emb_size])
-    user_input = att_user_input * att_dout
+    if with_att:
+        print("TDM Attention DNN")
+        att_user_input = paddle.concat(
+            user_input, axis=1)  # [bs, total_group_length, emb_size]
+        att_node_input = fluid.layers.expand(
+            unit_id_emb, expand_times=[1, total_group_length, 1])
+        att_din = paddle.concat(
+            [att_user_input, att_user_input * att_node_input, att_node_input],
+            axis=2)
+
+        att_active_op = 'prelu'
+        att_layer_arr = []
+        att_layer1 = FullyConnected3D(
+            3 * node_emb_size, 36, active_op=att_active_op, version=1)
+        att_layer_arr.append(att_layer1)
+        att_layer2 = FullyConnected3D(
+            36, 1, active_op=att_active_op, version=2)
+        att_layer_arr.append(att_layer2)
+
+        layer_data.append(att_din)
+        for layer in att_layer_arr:
+            layer_data.append(layer.call(layer_data[-1]))
+        att_dout = layer_data[-1]
+
+        att_dout = fluid.layers.expand(
+            att_dout, expand_times=[1, 1, node_emb_size])
+        user_input = att_user_input * att_dout
+    else:
+        print("TDM DNN")
+        user_input = paddle.concat(
+            user_input, axis=1)  # [bs, total_group_length, emb_size]
     # end att
 
     idx = 0
@@ -207,13 +215,13 @@ def dnn_model_define(user_input,
     layer_arr.append(layer2)
     layer3 = paddle_dnn_layer(
         64,
-        32,
+        24,
         active_op=active_op,
         use_batch_norm=use_batch_norm,
         version="%d_%s" % (3, net_version))
     layer_arr.append(layer3)
     layer4 = paddle_dnn_layer(
-        32,
+        24,
         2,
         active_op='',
         use_batch_norm=False,
diff --git a/models/treebased/tdm/reader.py b/models/treebased/tdm/reader.py
@@ -22,7 +22,7 @@
 import sys
 import paddle.distributed.fleet as fleet
 import logging
-from paddle.distributed.fleet.data_generator import TreeIndex
+from paddle.distributed.fleet.dataset import TreeIndex
 
 logging.basicConfig(
     format='%(asctime)s - %(levelname)s - %(message)s', level=logging.INFO)
@@ -41,27 +41,23 @@ def init(self, config):
         self.with_hierachy = config.get("hyper_parameters.with_hierachy", True)
         self.seed = config.get("hyper_parameters.seed", 0)
 
-        self.set_tree_layerwise_sampler(
-            self.tree_name,
-            self.sample_layer_counts,
-            range(self.item_nums),
-            self.item_nums,
-            self.item_nums + 1,
-            start_sample_layer=self.start_sample_layer,
-            seed=self.seed,
-            with_hierarchy=self.with_hierachy)
+        self.tree = TreeIndex(
+            config.get("hyper_parameters.tree_name"),
+            config.get("hyper_parameters.tree_path"))
+        self.tree.init_layerwise_sampler(self.sample_layer_counts,
+                                         self.start_sample_layer, self.seed)
 
     def line_process(self, line):
-        history_ids = [[0]] * (self.item_nums + 2)
+        history_ids = [0] * (self.item_nums)
         features = line.strip().split("\t")
         item_id = int(features[1])
         for item in features[2:]:
             slot, feasign = item.split(":")
             slot_id = int(slot.split("_")[1])
-            history_ids[slot_id - 1] = [int(feasign)]
-        history_ids[-2] = [item_id]
-        history_ids[-1] = [1]
-        return history_ids
+            history_ids[slot_id - 1] = int(feasign)
+        res = self.tree.layerwise_sample([history_ids], [item_id],
+                                         self.with_hierachy)
+        return res
 
     def generate_sample(self, line):
         "Dataset Generator"
@@ -73,7 +69,9 @@ def reader():
                 feature_name.append("item_" + str(i + 1))
             feature_name.append("unit_id")
             feature_name.append("label")
-            yield zip(feature_name, output_list)
+            for _ in output_list:
+                output = [[item] for item in _]
+                yield zip(feature_name, output)
 
         return reader
 
@@ -87,8 +85,5 @@ def reader():
     config = yaml_helper.load_yaml(yaml_path)
 
     r = MyDataset()
-    tree = TreeIndex(
-        config.get("hyper_parameters.tree_name"),
-        config.get("hyper_parameters.tree_path"))
     r.init(config)
     r.run_from_stdin()
diff --git a/models/treebased/tdm/static_model.py b/models/treebased/tdm/static_model.py
@@ -35,6 +35,7 @@ def _init_hyper_parameters(self):
         self.item_nums = self.config.get("hyper_parameters.item_nums", 69)
         self.fea_group = self.config.get("hyper_parameters.fea_group",
                                          "20,20,10,10,2,2,2,1,1,1")
+        self.with_att = self.config.get("hyper_parameters.with_att", False)
 
     def create_feeds(self, is_infer=False):
         user_input = [
@@ -80,7 +81,8 @@ def net(self, input, is_infer=False):
             unit_id_emb,
             input[-1],
             node_emb_size=self.node_emb_size,
-            fea_groups=self.fea_group)
+            fea_groups=self.fea_group,
+            with_att=self.with_att)
         self._cost = avg_cost
 
         self.inference_target_var = softmax_prob
