diff --git a/demo-serving/data/model/paddle/fluid/ctr_prediction.tar.gz b/demo-serving/data/model/paddle/fluid/ctr_prediction.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..20fc73d0639ba6d41f8c76161ec18faf0a1570bf Binary files /dev/null and b/demo-serving/data/model/paddle/fluid/ctr_prediction.tar.gz differ diff --git a/demo-serving/data/model/paddle/fluid/ctr_prediction/__model__ b/demo-serving/data/model/paddle/fluid/ctr_prediction/__model__ new file mode 100644 index 0000000000000000000000000000000000000000..6429a2b5812bacd7aa39aedeb8913c04882d2666 Binary files /dev/null and b/demo-serving/data/model/paddle/fluid/ctr_prediction/__model__ differ diff --git a/demo-serving/data/model/paddle/fluid/ctr_prediction/__model__.prototxt b/demo-serving/data/model/paddle/fluid/ctr_prediction/__model__.prototxt new file mode 100644 index 0000000000000000000000000000000000000000..bdab55b409f18774983281e4bd0816f024b9249b --- /dev/null +++ b/demo-serving/data/model/paddle/fluid/ctr_prediction/__model__.prototxt @@ -0,0 +1,4970 @@ +blocks { + idx: 0 + parent_idx: -1 + vars { + name: "sequence_pool_17.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "C18" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "sequence_pool_20.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "sequence_pool_16.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "C6" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "sequence_pool_16.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "sequence_pool_21.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "sequence_pool_15.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "sequence_pool_11.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "sequence_pool_14.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "embedding_11.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "sequence_pool_14.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "C12" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "C2" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "sequence_pool_12.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "embedding_1.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "sequence_pool_11.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "C21" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "sequence_pool_10.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "sequence_pool_1.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "sequence_pool_15.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "fc_1.b_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: 400 + } + } + } + persistable: true + } + vars { + name: "sequence_pool_1.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "C8" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "sequence_pool_0.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "fc_3.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 2 + } + lod_level: 0 + } + } + persistable: false + } + vars { + name: "fc_3.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 2 + } + lod_level: 0 + } + } + persistable: false + } + vars { + name: "fc_3.b_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: 2 + } + } + } + persistable: true + } + vars { + name: "fc_2.w_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: 400 + dims: 400 + } + } + } + persistable: true + } + vars { + name: "fc_2.tmp_2" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 400 + } + lod_level: 0 + } + } + persistable: false + } + vars { + name: "C5" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "fc_2.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 400 + } + lod_level: 0 + } + } + persistable: false + } + vars { + name: "fc_1.tmp_2" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 400 + } + lod_level: 0 + } + } + persistable: false + } + vars { + name: "embedding_16.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "embedding_3.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "embedding_15.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "sequence_pool_13.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "C13" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "embedding_14.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "embedding_10.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "sequence_pool_10.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "C25" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "embedding_13.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "fetch" + type { + type: FETCH_LIST + } + persistable: true + } + vars { + name: "embedding_6.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "embedding_19.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "dense_input" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 13 + } + lod_level: 0 + } + } + persistable: false + } + vars { + name: "embedding_24.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "sequence_pool_3.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "embedding_7.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "embedding_18.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "sequence_pool_7.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "sequence_pool_4.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "embedding_9.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "sequence_pool_18.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "C1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "C20" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "C17" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "sequence_pool_6.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "sequence_pool_7.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "sequence_pool_24.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "sequence_pool_24.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "sequence_pool_4.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "sequence_pool_6.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "sequence_pool_2.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "sequence_pool_18.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "C19" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "sequence_pool_5.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "sequence_pool_8.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "embedding_20.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "fc_0.w_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: 273 + dims: 400 + } + } + } + persistable: true + } + vars { + name: "C7" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "embedding_22.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "sequence_pool_9.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "sequence_pool_19.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "embedding_21.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "embedding_4.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "C9" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "sequence_pool_5.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "sequence_pool_9.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "sequence_pool_0.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "sequence_pool_17.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "sequence_pool_22.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "C23" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "C16" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "fc_2.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 400 + } + lod_level: 0 + } + } + persistable: false + } + vars { + name: "embedding_12.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "sequence_pool_25.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "sequence_pool_21.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "sequence_pool_20.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "sequence_pool_2.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "C24" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "embedding_17.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "feed" + type { + type: FEED_MINIBATCH + } + persistable: true + } + vars { + name: "sequence_pool_13.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "fc_3.tmp_2" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 2 + } + lod_level: 0 + } + } + persistable: false + } + vars { + name: "C3" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "C14" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "sequence_pool_3.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "C10" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "fc_3.w_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: 400 + dims: 2 + } + } + } + persistable: true + } + vars { + name: "embedding_23.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "sequence_pool_22.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "fc_0.tmp_2" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 400 + } + lod_level: 0 + } + } + persistable: false + } + vars { + name: "C4" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "embedding_0.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "C22" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "sequence_pool_23.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + } + } + persistable: false + } + vars { + name: "C11" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "save_infer_model/scale_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 2 + } + lod_level: 0 + } + } + persistable: false + } + vars { + name: "sequence_pool_19.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "C15" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "sequence_pool_23.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "embedding_25.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "embedding_8.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "fc_0.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 400 + } + lod_level: 0 + } + } + persistable: false + } + vars { + name: "C26" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: INT64 + dims: -1 + dims: 1 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "embedding_5.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "fc_0.b_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: 400 + } + } + } + persistable: true + } + vars { + name: "sequence_pool_25.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "embedding_2.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 10 + } + lod_level: 1 + } + } + persistable: false + } + vars { + name: "fc_0.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 400 + } + lod_level: 0 + } + } + persistable: false + } + vars { + name: "concat_0.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 273 + } + lod_level: 0 + } + } + persistable: false + } + vars { + name: "fc_1.tmp_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 400 + } + lod_level: 0 + } + } + persistable: false + } + vars { + name: "sequence_pool_8.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "fc_1.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: -1 + dims: 400 + } + lod_level: 0 + } + } + persistable: false + } + vars { + name: "fc_1.w_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: 400 + dims: 400 + } + } + } + persistable: true + } + vars { + name: "sequence_pool_12.tmp_1" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + } + } + } + persistable: false + } + vars { + name: "fc_2.b_0" + type { + type: LOD_TENSOR + lod_tensor { + tensor { + data_type: FP32 + dims: 400 + } + } + } + persistable: true + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "dense_input" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 26 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_25.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 25 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_24.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 24 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_23.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 23 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_22.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 22 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_21.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 21 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_20.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 20 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_19.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 19 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_18.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 18 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_17.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 17 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_16.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 16 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_15.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 15 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_14.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 14 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_13.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 13 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_12.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 12 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_11.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 11 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_10.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 10 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_9.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 9 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_8.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 8 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_7.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 7 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_6.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 6 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_5.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 5 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_4.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 4 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_3.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 3 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_2.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 2 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_1.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 1 + } + } + ops { + inputs { + parameter: "X" + arguments: "feed" + } + outputs { + parameter: "Out" + arguments: "embedding_0.tmp_0" + } + type: "feed" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1725, in _prepend_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 845, in prepend_feed_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1000, in save_inference_model\n prepend_feed_ops(main_program, feeded_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 0 + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_0.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_0.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_0.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_1.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_1.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_1.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_2.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_2.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_2.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_3.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_3.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_3.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_4.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_4.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_4.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_5.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_5.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_5.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_6.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_6.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_6.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_7.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_7.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_7.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_8.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_8.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_8.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_9.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_9.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_9.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_10.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_10.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_10.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_11.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_11.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_11.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_12.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_12.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_12.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_13.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_13.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_13.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_14.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_14.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_14.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_15.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_15.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_15.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_16.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_16.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_16.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_17.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_17.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_17.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_18.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_18.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_18.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_19.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_19.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_19.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_20.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_20.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_20.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_21.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_21.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_21.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_22.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_22.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_22.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_23.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_23.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_23.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_24.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_24.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_24.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "embedding_25.tmp_0" + } + outputs { + parameter: "MaxIndex" + arguments: "sequence_pool_25.tmp_1" + } + outputs { + parameter: "Out" + arguments: "sequence_pool_25.tmp_0" + } + type: "sequence_pool" + attrs { + name: "is_test" + type: INT + i: 1 + } + attrs { + name: "pooltype" + type: STRING + s: "AVERAGE" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 2318, in sequence_pool\n \"is_test\": is_test})\n" + strings: " File \"save_program.py\", line 72, in embedding_layer\n seq = fluid.layers.sequence_pool(input=emb, pool_type=\'average\')\n" + strings: " File \"save_program.py\", line 86, in ctr_dnn_model\n sparse_embed_and_seq = list(map(embedding_layer, words[1:-1]))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "sequence_pool_0.tmp_0" + arguments: "sequence_pool_1.tmp_0" + arguments: "sequence_pool_2.tmp_0" + arguments: "sequence_pool_3.tmp_0" + arguments: "sequence_pool_4.tmp_0" + arguments: "sequence_pool_5.tmp_0" + arguments: "sequence_pool_6.tmp_0" + arguments: "sequence_pool_7.tmp_0" + arguments: "sequence_pool_8.tmp_0" + arguments: "sequence_pool_9.tmp_0" + arguments: "sequence_pool_10.tmp_0" + arguments: "sequence_pool_11.tmp_0" + arguments: "sequence_pool_12.tmp_0" + arguments: "sequence_pool_13.tmp_0" + arguments: "sequence_pool_14.tmp_0" + arguments: "sequence_pool_15.tmp_0" + arguments: "sequence_pool_16.tmp_0" + arguments: "sequence_pool_17.tmp_0" + arguments: "sequence_pool_18.tmp_0" + arguments: "sequence_pool_19.tmp_0" + arguments: "sequence_pool_20.tmp_0" + arguments: "sequence_pool_21.tmp_0" + arguments: "sequence_pool_22.tmp_0" + arguments: "sequence_pool_23.tmp_0" + arguments: "sequence_pool_24.tmp_0" + arguments: "sequence_pool_25.tmp_0" + arguments: "dense_input" + } + outputs { + parameter: "Out" + arguments: "concat_0.tmp_0" + } + type: "concat" + attrs { + name: "axis" + type: INT + i: 1 + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/tensor.py\", line 214, in concat\n attrs={\'axis\': axis})\n" + strings: " File \"save_program.py\", line 90, in ctr_dnn_model\n concated = fluid.layers.concat(sparse_embed_seq + words[0:1], axis=1)\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "use_mkldnn" + type: BOOLEAN + b: false + } + } + ops { + inputs { + parameter: "X" + arguments: "concat_0.tmp_0" + } + inputs { + parameter: "Y" + arguments: "fc_0.w_0" + } + outputs { + parameter: "Out" + arguments: "fc_0.tmp_0" + } + type: "mul" + attrs { + name: "x_num_col_dims" + type: INT + i: 1 + } + attrs { + name: "y_num_col_dims" + type: INT + i: 1 + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 323, in fc\n \"y_num_col_dims\": 1})\n" + strings: " File \"save_program.py\", line 97, in ctr_dnn_model\n scale=1 / math.sqrt(concated.shape[1]))))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "fc_0.tmp_0" + } + inputs { + parameter: "Y" + arguments: "fc_0.b_0" + } + outputs { + parameter: "Out" + arguments: "fc_0.tmp_1" + } + type: "elementwise_add" + attrs { + name: "axis" + type: INT + i: 1 + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 135, in append_bias_op\n attrs={\'axis\': dim_start})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 336, in fc\n pre_activation = helper.append_bias_op(pre_bias, dim_start=num_flatten_dims)\n" + strings: " File \"save_program.py\", line 97, in ctr_dnn_model\n scale=1 / math.sqrt(concated.shape[1]))))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "use_mkldnn" + type: BOOLEAN + b: false + } + attrs { + name: "x_data_format" + type: STRING + s: "" + } + attrs { + name: "y_data_format" + type: STRING + s: "" + } + } + ops { + inputs { + parameter: "X" + arguments: "fc_0.tmp_1" + } + outputs { + parameter: "Out" + arguments: "fc_0.tmp_2" + } + type: "relu" + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 159, in append_activation\n attrs=act)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 338, in fc\n return helper.append_activation(pre_activation)\n" + strings: " File \"save_program.py\", line 97, in ctr_dnn_model\n scale=1 / math.sqrt(concated.shape[1]))))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "use_mkldnn" + type: BOOLEAN + b: false + } + attrs { + name: "use_cudnn" + type: BOOLEAN + b: false + } + attrs { + name: "is_test" + type: INT + i: 1 + } + } + ops { + inputs { + parameter: "X" + arguments: "fc_0.tmp_2" + } + inputs { + parameter: "Y" + arguments: "fc_1.w_0" + } + outputs { + parameter: "Out" + arguments: "fc_1.tmp_0" + } + type: "mul" + attrs { + name: "x_num_col_dims" + type: INT + i: 1 + } + attrs { + name: "y_num_col_dims" + type: INT + i: 1 + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 323, in fc\n \"y_num_col_dims\": 1})\n" + strings: " File \"save_program.py\", line 100, in ctr_dnn_model\n scale=1 / math.sqrt(fc1.shape[1]))))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "fc_1.tmp_0" + } + inputs { + parameter: "Y" + arguments: "fc_1.b_0" + } + outputs { + parameter: "Out" + arguments: "fc_1.tmp_1" + } + type: "elementwise_add" + attrs { + name: "axis" + type: INT + i: 1 + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 135, in append_bias_op\n attrs={\'axis\': dim_start})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 336, in fc\n pre_activation = helper.append_bias_op(pre_bias, dim_start=num_flatten_dims)\n" + strings: " File \"save_program.py\", line 100, in ctr_dnn_model\n scale=1 / math.sqrt(fc1.shape[1]))))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "use_mkldnn" + type: BOOLEAN + b: false + } + attrs { + name: "x_data_format" + type: STRING + s: "" + } + attrs { + name: "y_data_format" + type: STRING + s: "" + } + } + ops { + inputs { + parameter: "X" + arguments: "fc_1.tmp_1" + } + outputs { + parameter: "Out" + arguments: "fc_1.tmp_2" + } + type: "relu" + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 159, in append_activation\n attrs=act)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 338, in fc\n return helper.append_activation(pre_activation)\n" + strings: " File \"save_program.py\", line 100, in ctr_dnn_model\n scale=1 / math.sqrt(fc1.shape[1]))))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "use_mkldnn" + type: BOOLEAN + b: false + } + attrs { + name: "use_cudnn" + type: BOOLEAN + b: false + } + attrs { + name: "is_test" + type: INT + i: 1 + } + } + ops { + inputs { + parameter: "X" + arguments: "fc_1.tmp_2" + } + inputs { + parameter: "Y" + arguments: "fc_2.w_0" + } + outputs { + parameter: "Out" + arguments: "fc_2.tmp_0" + } + type: "mul" + attrs { + name: "x_num_col_dims" + type: INT + i: 1 + } + attrs { + name: "y_num_col_dims" + type: INT + i: 1 + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 323, in fc\n \"y_num_col_dims\": 1})\n" + strings: " File \"save_program.py\", line 103, in ctr_dnn_model\n scale=1 / math.sqrt(fc2.shape[1]))))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "fc_2.tmp_0" + } + inputs { + parameter: "Y" + arguments: "fc_2.b_0" + } + outputs { + parameter: "Out" + arguments: "fc_2.tmp_1" + } + type: "elementwise_add" + attrs { + name: "axis" + type: INT + i: 1 + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 135, in append_bias_op\n attrs={\'axis\': dim_start})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 336, in fc\n pre_activation = helper.append_bias_op(pre_bias, dim_start=num_flatten_dims)\n" + strings: " File \"save_program.py\", line 103, in ctr_dnn_model\n scale=1 / math.sqrt(fc2.shape[1]))))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "use_mkldnn" + type: BOOLEAN + b: false + } + attrs { + name: "x_data_format" + type: STRING + s: "" + } + attrs { + name: "y_data_format" + type: STRING + s: "" + } + } + ops { + inputs { + parameter: "X" + arguments: "fc_2.tmp_1" + } + outputs { + parameter: "Out" + arguments: "fc_2.tmp_2" + } + type: "relu" + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 159, in append_activation\n attrs=act)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 338, in fc\n return helper.append_activation(pre_activation)\n" + strings: " File \"save_program.py\", line 103, in ctr_dnn_model\n scale=1 / math.sqrt(fc2.shape[1]))))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "use_mkldnn" + type: BOOLEAN + b: false + } + attrs { + name: "use_cudnn" + type: BOOLEAN + b: false + } + attrs { + name: "is_test" + type: INT + i: 1 + } + } + ops { + inputs { + parameter: "X" + arguments: "fc_2.tmp_2" + } + inputs { + parameter: "Y" + arguments: "fc_3.w_0" + } + outputs { + parameter: "Out" + arguments: "fc_3.tmp_0" + } + type: "mul" + attrs { + name: "x_num_col_dims" + type: INT + i: 1 + } + attrs { + name: "y_num_col_dims" + type: INT + i: 1 + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 323, in fc\n \"y_num_col_dims\": 1})\n" + strings: " File \"save_program.py\", line 106, in ctr_dnn_model\n scale=1 / math.sqrt(fc3.shape[1]))))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "fc_3.tmp_0" + } + inputs { + parameter: "Y" + arguments: "fc_3.b_0" + } + outputs { + parameter: "Out" + arguments: "fc_3.tmp_1" + } + type: "elementwise_add" + attrs { + name: "axis" + type: INT + i: 1 + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 135, in append_bias_op\n attrs={\'axis\': dim_start})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 336, in fc\n pre_activation = helper.append_bias_op(pre_bias, dim_start=num_flatten_dims)\n" + strings: " File \"save_program.py\", line 106, in ctr_dnn_model\n scale=1 / math.sqrt(fc3.shape[1]))))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "use_mkldnn" + type: BOOLEAN + b: false + } + attrs { + name: "x_data_format" + type: STRING + s: "" + } + attrs { + name: "y_data_format" + type: STRING + s: "" + } + } + ops { + inputs { + parameter: "X" + arguments: "fc_3.tmp_1" + } + outputs { + parameter: "Out" + arguments: "fc_3.tmp_2" + } + type: "softmax" + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 159, in append_activation\n attrs=act)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 338, in fc\n return helper.append_activation(pre_activation)\n" + strings: " File \"save_program.py\", line 106, in ctr_dnn_model\n scale=1 / math.sqrt(fc3.shape[1]))))\n" + strings: " File \"save_program.py\", line 156, in save_program\n loss, auc_var, batch_auc_var, train_feed_vars, inference_feed_vars, fetch_vars = ctr_dnn_model(args.embedding_size, args.sparse_feature_dim, use_py_reader=False)\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "axis" + type: INT + i: -1 + } + attrs { + name: "use_cudnn" + type: BOOLEAN + b: false + } + attrs { + name: "data_format" + type: STRING + s: "AnyLayout" + } + attrs { + name: "use_mkldnn" + type: BOOLEAN + b: false + } + attrs { + name: "is_test" + type: INT + i: 1 + } + } + ops { + inputs { + parameter: "X" + arguments: "fc_3.tmp_2" + } + outputs { + parameter: "Out" + arguments: "save_infer_model/scale_0" + } + type: "scale" + attrs { + name: "scale" + type: FLOAT + f: 1.0 + } + attrs { + name: "bias" + type: FLOAT + f: 0.0 + } + attrs { + name: "bias_after_scale" + type: BOOLEAN + b: true + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layer_helper.py\", line 43, in append_op\n return self.main_program.current_block().append_op(*args, **kwargs)\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/layers/nn.py\", line 9267, in scale\n \'bias_after_scale\': bias_after_scale\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 957, in save_inference_model\n var, 1., name=\"save_infer_model/scale_{}\".format(i))\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_role_var" + type: STRINGS + } + } + ops { + inputs { + parameter: "X" + arguments: "save_infer_model/scale_0" + } + outputs { + parameter: "Out" + arguments: "fetch" + } + type: "fetch" + attrs { + name: "op_role_var" + type: STRINGS + } + attrs { + name: "op_callstack" + type: STRINGS + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/framework.py\", line 1654, in append_op\n attrs=kwargs.get(\"attrs\", None))\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 862, in append_fetch_ops\n attrs={\'col\': i})\n" + strings: " File \"/home/wangguibao/paddle_env/paddle_release_home/python/lib/python2.7/site-packages/paddle/fluid/io.py\", line 1001, in save_inference_model\n append_fetch_ops(main_program, fetch_var_names)\n" + strings: " File \"save_program.py\", line 168, in save_program\n fluid.io.save_inference_model(model_dir, feed_var_names, fetch_vars, exe, fluid.default_main_program())\n" + strings: " File \"save_program.py\", line 195, in \n save_program()\n" + } + attrs { + name: "op_namescope" + type: STRING + s: "/" + } + attrs { + name: "op_role" + type: INT + i: 0 + } + attrs { + name: "col" + type: INT + i: 0 + } + } +} diff --git a/demo-serving/data/model/paddle/fluid/ctr_prediction/fc_0.b_0 b/demo-serving/data/model/paddle/fluid/ctr_prediction/fc_0.b_0 new file mode 100644 index 0000000000000000000000000000000000000000..90f49810363947445552bec6f78f593e519d7fbc Binary files /dev/null and b/demo-serving/data/model/paddle/fluid/ctr_prediction/fc_0.b_0 differ diff --git a/demo-serving/data/model/paddle/fluid/ctr_prediction/fc_0.w_0 b/demo-serving/data/model/paddle/fluid/ctr_prediction/fc_0.w_0 new file mode 100644 index 0000000000000000000000000000000000000000..92bd1f4ccb9936f1a15055d343c7a5d7986b7b09 Binary files /dev/null and b/demo-serving/data/model/paddle/fluid/ctr_prediction/fc_0.w_0 differ diff --git a/demo-serving/data/model/paddle/fluid/ctr_prediction/fc_1.b_0 b/demo-serving/data/model/paddle/fluid/ctr_prediction/fc_1.b_0 new file mode 100644 index 0000000000000000000000000000000000000000..34f195970349d6a60ff87bd2ccc3c9780eab51ba Binary files /dev/null and b/demo-serving/data/model/paddle/fluid/ctr_prediction/fc_1.b_0 differ diff --git a/demo-serving/data/model/paddle/fluid/ctr_prediction/fc_1.w_0 b/demo-serving/data/model/paddle/fluid/ctr_prediction/fc_1.w_0 new file mode 100644 index 0000000000000000000000000000000000000000..9e9ad468648a4ccf1d93b9d6e1fe461baeb1f93a Binary files /dev/null and b/demo-serving/data/model/paddle/fluid/ctr_prediction/fc_1.w_0 differ diff --git a/demo-serving/data/model/paddle/fluid/ctr_prediction/fc_2.b_0 b/demo-serving/data/model/paddle/fluid/ctr_prediction/fc_2.b_0 new file mode 100644 index 0000000000000000000000000000000000000000..ec0e70140412dc51456cce279da710c5afc84476 Binary files /dev/null and b/demo-serving/data/model/paddle/fluid/ctr_prediction/fc_2.b_0 differ diff --git a/demo-serving/data/model/paddle/fluid/ctr_prediction/fc_2.w_0 b/demo-serving/data/model/paddle/fluid/ctr_prediction/fc_2.w_0 new file mode 100644 index 0000000000000000000000000000000000000000..d36c884bd0809b4f8070f1ec370900ebd6ad2bdf Binary files /dev/null and b/demo-serving/data/model/paddle/fluid/ctr_prediction/fc_2.w_0 differ diff --git a/demo-serving/data/model/paddle/fluid/ctr_prediction/fc_3.b_0 b/demo-serving/data/model/paddle/fluid/ctr_prediction/fc_3.b_0 new file mode 100644 index 0000000000000000000000000000000000000000..db17430c639d8a06af3050a2bae1c8ada0f13437 Binary files /dev/null and b/demo-serving/data/model/paddle/fluid/ctr_prediction/fc_3.b_0 differ diff --git a/demo-serving/data/model/paddle/fluid/ctr_prediction/fc_3.w_0 b/demo-serving/data/model/paddle/fluid/ctr_prediction/fc_3.w_0 new file mode 100644 index 0000000000000000000000000000000000000000..400ed901ab1d089b2979d0a71fdbd319cce5604e Binary files /dev/null and b/demo-serving/data/model/paddle/fluid/ctr_prediction/fc_3.w_0 differ diff --git a/demo-serving/data/model/paddle/fluid/text_classification_lstm.tar.gz b/demo-serving/data/model/paddle/fluid/text_classification_lstm.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..5fed5ecd00be018d9199351df87aac513ee85630 Binary files /dev/null and b/demo-serving/data/model/paddle/fluid/text_classification_lstm.tar.gz differ diff --git a/demo-serving/data/model/paddle/fluid/text_classification_lstm/__model__ b/demo-serving/data/model/paddle/fluid/text_classification_lstm/__model__ new file mode 100644 index 0000000000000000000000000000000000000000..1f3e30def613ce08613bc03eb9206535adad20bb Binary files /dev/null and b/demo-serving/data/model/paddle/fluid/text_classification_lstm/__model__ differ diff --git a/demo-serving/data/model/paddle/fluid/text_classification_lstm/embedding_0.w_0 b/demo-serving/data/model/paddle/fluid/text_classification_lstm/embedding_0.w_0 new file mode 100644 index 0000000000000000000000000000000000000000..4ba93b8d5e9727aaa236812bb9403931460b6e08 Binary files /dev/null and b/demo-serving/data/model/paddle/fluid/text_classification_lstm/embedding_0.w_0 differ diff --git a/demo-serving/data/model/paddle/fluid/text_classification_lstm/fc_0.b_0 b/demo-serving/data/model/paddle/fluid/text_classification_lstm/fc_0.b_0 new file mode 100644 index 0000000000000000000000000000000000000000..6c8f5cec01554311658fe4e85c062f845ec1f06f Binary files /dev/null and b/demo-serving/data/model/paddle/fluid/text_classification_lstm/fc_0.b_0 differ diff --git a/demo-serving/data/model/paddle/fluid/text_classification_lstm/fc_0.w_0 b/demo-serving/data/model/paddle/fluid/text_classification_lstm/fc_0.w_0 new file mode 100644 index 0000000000000000000000000000000000000000..eb17c8e90947b4b9b51c94472d883fe3bf5d817b Binary files /dev/null and b/demo-serving/data/model/paddle/fluid/text_classification_lstm/fc_0.w_0 differ diff --git a/demo-serving/data/model/paddle/fluid/text_classification_lstm/fc_1.b_0 b/demo-serving/data/model/paddle/fluid/text_classification_lstm/fc_1.b_0 new file mode 100644 index 0000000000000000000000000000000000000000..026226d6afe8cb861d96e7ef82e5fc05ab05a419 Binary files /dev/null and b/demo-serving/data/model/paddle/fluid/text_classification_lstm/fc_1.b_0 differ diff --git a/demo-serving/data/model/paddle/fluid/text_classification_lstm/fc_1.w_0 b/demo-serving/data/model/paddle/fluid/text_classification_lstm/fc_1.w_0 new file mode 100644 index 0000000000000000000000000000000000000000..4fb63337152074dcc2920628805f03668827ec6e Binary files /dev/null and b/demo-serving/data/model/paddle/fluid/text_classification_lstm/fc_1.w_0 differ diff --git a/demo-serving/data/model/paddle/fluid/text_classification_lstm/fc_2.b_0 b/demo-serving/data/model/paddle/fluid/text_classification_lstm/fc_2.b_0 new file mode 100644 index 0000000000000000000000000000000000000000..bad1b820f8bfa77e55adbf96feb0b65daf0c69ff Binary files /dev/null and b/demo-serving/data/model/paddle/fluid/text_classification_lstm/fc_2.b_0 differ diff --git a/demo-serving/data/model/paddle/fluid/text_classification_lstm/fc_2.w_0 b/demo-serving/data/model/paddle/fluid/text_classification_lstm/fc_2.w_0 new file mode 100644 index 0000000000000000000000000000000000000000..1db62cae88827f3b2160b147b7d0603ce5598cab Binary files /dev/null and b/demo-serving/data/model/paddle/fluid/text_classification_lstm/fc_2.w_0 differ diff --git a/demo-serving/data/model/paddle/fluid/text_classification_lstm/lstm_0.b_0 b/demo-serving/data/model/paddle/fluid/text_classification_lstm/lstm_0.b_0 new file mode 100644 index 0000000000000000000000000000000000000000..341a37b91b936956bb8a970f854d7e13a78f4b2e Binary files /dev/null and b/demo-serving/data/model/paddle/fluid/text_classification_lstm/lstm_0.b_0 differ diff --git a/demo-serving/data/model/paddle/fluid/text_classification_lstm/lstm_0.w_0 b/demo-serving/data/model/paddle/fluid/text_classification_lstm/lstm_0.w_0 new file mode 100644 index 0000000000000000000000000000000000000000..e674d89e42d0d3cd35ceaeee886d2df2209d2d1d Binary files /dev/null and b/demo-serving/data/model/paddle/fluid/text_classification_lstm/lstm_0.w_0 differ