Skip to content

P
Paddle

PaddlePaddle / Paddle
1 年多 前同步成功

通知 2308
Star 20932
Fork 5423
P
Paddle
已关闭
Opened by saxon_zh@saxon_zhOwner

python实现的RankNet, 用C++ 加载预测

Created by: aturbofly

这个是我python实现的RankNet 模型训练： `from future import print_function import os import logging import paddle import paddle.fluid as fluid import numpy as np from dataset import popin_samples import math import gzip

import sys

try: from paddle.fluid.contrib.trainer import * from paddle.fluid.contrib.inferencer import * except ImportError: print( "In the fluid 1.0, the trainer and inferencer are moving to paddle.fluid.contrib", file=sys.stderr) from paddle.fluid.trainer import * from paddle.fluid.inferencer import *

logger = logging.getLogger("paddle") logger.setLevel(logging.INFO)

BATCH_SIZE = 20

def half_ranknet(name_prefix, input_dim): """ parameter in same name will be shared in paddle framework, these parameters in ranknet can be used in shared state, e.g. left network and right network shared parameters in detail https://github.com/PaddlePaddle/Paddle/blob/develop/doc/design/api.md """ # data layer data = fluid.layers.data(name_prefix + "_data",shape = [input_dim], dtype='float32')

# hidden layer
hd1 = fluid.layers.fc(input=data,
                      name=name_prefix + "_hidden",
                      size=10,
                      act='tanh',
                      param_attr=None)

# fully connected layer and output layer
output = fluid.layers.fc(input=hd1,
                         name=name_prefix + "_score",
                         size=1,
                         act=None,#paddle.activation.Linear(),
                         param_attr=None)
return data, output

def train(use_cuda, save_dirname, is_local): label = fluid.layers.data("label", shape=[1]) input_dim = 801 left_data, output_left = half_ranknet("left", input_dim) right_data, output_right = half_ranknet("right", input_dim)

loss = fluid.layers.rank_loss(
    # https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/fluid/layers/nn.py
    name="cost", left=output_left, right=output_right, label=label)

sgd_optimizer = fluid.optimizer.SGD(learning_rate = 0.001)
sgd_optimizer.minimize(loss)

train_reader = paddle.batch(paddle.reader.shuffle(popin_samples.train, buf_size=500),
                        batch_size=BATCH_SIZE)

test_reader = paddle.batch(
paddle.reader.shuffle(popin_samples.test, buf_size=500),
batch_size=BATCH_SIZE
)

#feed_order = ["label", "left_data", "right_data"]
place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
exe = fluid.Executor(place)
feeder = fluid.DataFeeder(feed_list = [label, left_data, right_data], place=place)


def train_loop(main_program):
    exe.run(fluid.default_startup_program())

    PASS_NUM = 100

    for pass_id in range(PASS_NUM):
        for data in train_reader():
            sum_loss = 0.0
            avg_loss_value = exe.run(main_program,
                                     feed=feeder.feed(data),
                                     fetch_list=[loss])

            print(avg_loss_value)
            for tt in avg_loss_value[0]:
                sum_loss += tt[0]
            print(sum_loss)
            if sum_loss < 1.0:
                if save_dirname is not None:
                    fluid.io.save_inference_model(save_dirname,["left_data", "right_data"],[output_left, output_right], exe)
                return

            if math.isnan(float(sum_loss)):
                sys.exit("got NaN loss, training failed.")

if is_local:
    train_loop(fluid.default_main_program())

def main(use_cuda, is_local=True): if use_cuda and not fluid.core.is_compiled_with_cuda(): return

    # Directory for saving the trained model
save_dirname = "ranknet.inference.model"

train(use_cuda, save_dirname, is_local)

if name == 'main': main(False)`

执行后得到存储的结果：

image 训练时候有一个问题。就是发现loss一直没有降低。。。感觉没有收敛。 C++ 加载部分的代码： `/* Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */

/*

  • This file contains a simple demo for how to take a model for inference. */

#include <gflags/gflags.h> #include #include #include #include //NOLINT #include "ctime"

//#include "paddle/include/paddle_inference_api.h" #include "base/logging.h" #include "paddle/fluid/inference/paddle_inference_api.h"

DEFINE_string(dirname, "", "Directory of the inference model."); DEFINE_string(value, "1", "value of x."); DEFINE_bool(use_gpu, false, "Whether use gpu.");

namespace paddle { namespace demo {

void rank_test() { // set rand srand(time(NULL));

// 1. Create PaddlePredictor with a config.
NativeConfig config;
if (FLAGS_dirname.empty() || FLAGS_value.empty()) {
    printf("input --dirname=path/to/your/model --value=float");
    //LOG(INFO) << "Usage: ./simple_on_word2vec --dirname=path/to/your/model";
    exit(1);
}
config.model_dir = FLAGS_dirname;
config.use_gpu = false;
config.fraction_of_gpu_memory = 0.15;
config.device = 0;
auto predictor = CreatePaddlePredictor<NativeConfig>(config);

std::string x = FLAGS_value;
float value = atof(x.c_str());

// 2. Prepare input.
int shape = 801;
PaddleTensor tensor;
tensor.dtype = PaddleDType::FLOAT32;
tensor.shape = std::vector<int>({1, shape});
float data[shape];
memset(data, 0.0, shape * sizeof(float));

for (int i = 0; i < shape; i ++) {
    // tensor.shape.push_back(i + 1);
    data[i] = (rand() % 100) / 100.0;
}
tensor.data = PaddleBuf(data, sizeof(data));
std::vector<PaddleTensor> inputs(2, tensor);
//# 3. Run
std::vector<PaddleTensor> outputs;
CHECK(predictor->Run(inputs, &outputs));

int size = outputs.size();
printf("size:%d\n", size);
for (int i = 0; i < size; i++) {
    printf("result=%f\n", static_cast<float*>(outputs.front().data.data())[i]);
}

}

void Main(bool use_gpu) { //# 1. Create PaddlePredictor with a config. NativeConfig config; if (FLAGS_dirname.empty() || FLAGS_value.empty()) { printf("input --dirname=path/to/your/model --value=float"); //LOG(INFO) << "Usage: ./simple_on_word2vec --dirname=path/to/your/model"; exit(1); } config.model_dir = FLAGS_dirname; config.use_gpu = false; config.fraction_of_gpu_memory = 0.15; config.device = 0; auto predictor = CreatePaddlePredictor(config);

std::string x = FLAGS_value;
float value = atof(x.c_str());

float data[1] = {value};

PaddleTensor tensor;
tensor.shape = std::vector<int>({1, 13});
tensor.data = PaddleBuf(data, sizeof(data));
tensor.dtype = PaddleDType::FLOAT32;

// For simplicity, we set all the slots with the same data.
std::vector<PaddleTensor> slots(1, tensor);

//# 3. Run
std::vector<PaddleTensor> outputs;
CHECK(predictor->Run(slots, &outputs));

//# 4. Get output.
int size = outputs.size();
CHECK_EQ(size, 1UL);
// Check the output buffer size and result of each tid.
// CHECK_EQ(outputs.front().data.length(), 33168UL);
for (int i = 0; i < size; i++) {
    std::cout<< static_cast<float*>(outputs.front().data.data())[i] << std::endl;
}

}

void MainThreads(int num_threads, bool use_gpu) { // Multi-threads only support on CPU // 0. Create PaddlePredictor with a config. NativeConfig config; config.model_dir = FLAGS_dirname; config.use_gpu = use_gpu; config.fraction_of_gpu_memory = 0.15; config.device = 0; auto main_predictor = CreatePaddlePredictor(config);

std::vectorstd::thread threads; for (int tid = 0; tid < num_threads; ++tid) { threads.emplace_back(&, tid { // 1. clone a predictor which shares the same parameters auto predictor = main_predictor->Clone(); constexpr int num_batches = 3; for (int batch_id = 0; batch_id < num_batches; ++batch_id) { // 2. Dummy Input Data int64_t data[4] = {1, 2, 3, 4}; PaddleTensor tensor; tensor.shape = std::vector({4, 1}); tensor.data = PaddleBuf(data, sizeof(data)); tensor.dtype = PaddleDType::INT64;

    std::vector<PaddleTensor> inputs(4, tensor);
    std::vector<PaddleTensor> outputs;
    // 3. Run
    CHECK(predictor->Run(inputs, &outputs));

    // 4. Get output.
    CHECK_EQ(outputs.size(), 1UL);
    // Check the output buffer size and result of each tid.
    CHECK_EQ(outputs.front().data.length(), 33168UL);
    float result[5] = {0.00129761, 0.00151112, 0.000423564, 0.00108815,
                       0.000932706};
    const size_t num_elements =
        outputs.front().data.length() / sizeof(float);
    // The outputs' buffers are in CPU memory.
    for (size_t i = 0; i < std::min(static_cast<size_t>(5), num_elements);
         i++) {
        std::cout<< (static_cast<float*>(outputs.front().data.data())[i],
                 result[i], 0.001);
    }
  }
});

} for (int i = 0; i < num_threads; ++i) { threads[i].join(); } }

} // namespace demo } // namespace paddle

int main(int argc, char** argv) { google::ParseCommandLineFlags(&argc, &argv, true); paddle::demo::rank_test();

// paddle::demo::Main(false /* use_gpu*/); // paddle::demo::MainThreads(1, false /* use_gpu*/); // paddle::demo::MainThreads(4, false /* use_gpu*/); // if (FLAGS_use_gpu) { // paddle::demo::Main(true /use_gpu/); // paddle::demo::MainThreads(1, true /use_gpu/); // paddle::demo::MainThreads(4, true /use_gpu/); // } return 0; } ` 输入两个完全一样的item(特征向量)（pair?), 最后得到这样的结果: 
image

这个是什么原因？ 第一个result是左网络的输出，第二个是右网络的输出？ 两个一样的，为什么值不一样呀？ 是训练的模型有问题吗？？