diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000000000000000000000000000000000000..0be48fdfa288531f997acc81d3145c3fb5b966d2 --- /dev/null +++ b/.travis.yml @@ -0,0 +1,14 @@ +language: generic +sudo: required +dist: trusty +os: + - linux +env: + - COMPILE_TYPE=CPU DOCKERFILE_CPU=$PWD/tools/Dockerfile.ci +services: + - docker +before_install: + - docker build -f ${DOCKERFILE_CPU} -t serving-img:${COMPILE_TYPE} . +install: + - if [ $COMPILE_TYPE == "CPU" ]; then docker run -it -v $PWD:/Serving serving-img:${COMPILE_TYPE} /bin/bash Serving/tools/serving_check_style.sh ; fi; + - docker run -it -v $PWD:/Serving serving-img:${COMPILE_TYPE} /bin/bash Serving/tools/serving_build.sh $COMPILE_TYPE diff --git a/core/configure/CMakeLists.txt b/core/configure/CMakeLists.txt index e6d461d6cf32a95e21c65d8cace7d864347f7ff4..685eff01837cbc86dab33524b14e796f6f7573f2 100644 --- a/core/configure/CMakeLists.txt +++ b/core/configure/CMakeLists.txt @@ -87,4 +87,3 @@ add_custom_command(TARGET general_model_config_py_proto POST_BUILD WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) endif() endif() - diff --git a/core/configure/include/configure_parser.h b/core/configure/include/configure_parser.h index c69b86050f4024700e79fe88d9a1ca4f64978c5b..3f23776878d738e2d5076ce52424acc5bae575ea 100644 --- a/core/configure/include/configure_parser.h +++ b/core/configure/include/configure_parser.h @@ -20,16 +20,16 @@ namespace baidu { namespace paddle_serving { namespace configure { - int read_proto_conf(const std::string &conf_full_path, - google::protobuf::Message *conf); - - int read_proto_conf(const std::string &conf_path, - const std::string &conf_file, - google::protobuf::Message *conf); - - int write_proto_conf(google::protobuf::Message *message, - const std::string &output_path, - const std::string &output_file); +int read_proto_conf(const std::string &conf_full_path, + google::protobuf::Message *conf); + +int read_proto_conf(const std::string &conf_path, + const std::string &conf_file, + google::protobuf::Message *conf); + +int write_proto_conf(google::protobuf::Message *message, + const std::string &output_path, + const std::string &output_file); } // namespace configure } // namespace paddle_serving diff --git a/core/cube/cube-server/src/server.cpp b/core/cube/cube-server/src/server.cpp index f431e4a377109a13cf4585308fd27ac207460109..fba542d84f0f7108d0535dfab103d2a18defa148 100644 --- a/core/cube/cube-server/src/server.cpp +++ b/core/cube/cube-server/src/server.cpp @@ -12,9 +12,9 @@ // See the License for the specific language governing permissions and // limitations under the License. +#include "core/cube/cube-server/include/cube/server.h" #include #include "core/cube/cube-server/include/cube/framework.h" -#include "core/cube/cube-server/include/cube/server.h" namespace rec { namespace mcube { diff --git a/core/general-client/include/general_model.h b/core/general-client/include/general_model.h index 0e042d1880acd15151d3476d6061fb759f92e11b..5a941c54d614ef3859e9bb3fe293ae343a7a3f27 100644 --- a/core/general-client/include/general_model.h +++ b/core/general-client/include/general_model.h @@ -84,19 +84,14 @@ class PredictorClient { PredictorRes& predict_res, // NOLINT const int& pid); - std::vector> predict( - const std::vector>& float_feed, - const std::vector& float_feed_name, - const std::vector>& int_feed, - const std::vector& int_feed_name, - const std::vector& fetch_name); - - std::vector>> batch_predict( + int batch_predict( const std::vector>>& float_feed_batch, const std::vector& float_feed_name, const std::vector>>& int_feed_batch, const std::vector& int_feed_name, - const std::vector& fetch_name); + const std::vector& fetch_name, + PredictorRes& predict_res_batch, // NOLINT + const int& pid); private: PredictorApi _api; diff --git a/core/general-client/src/general_model.cpp b/core/general-client/src/general_model.cpp index 9fafe0abc59ce543cfc1783003296d68102d0c8d..d1ad58d462025c205eb669b3aa50864051d414ba 100644 --- a/core/general-client/src/general_model.cpp +++ b/core/general-client/src/general_model.cpp @@ -264,26 +264,22 @@ int PredictorClient::predict(const std::vector> &float_feed, return 0; } -std::vector>> PredictorClient::batch_predict( +int PredictorClient::batch_predict( const std::vector>> &float_feed_batch, const std::vector &float_feed_name, const std::vector>> &int_feed_batch, const std::vector &int_feed_name, - const std::vector &fetch_name) { + const std::vector &fetch_name, + PredictorRes &predict_res_batch, + const int &pid) { int batch_size = std::max(float_feed_batch.size(), int_feed_batch.size()); - std::vector>> fetch_result_batch; - if (fetch_name.size() == 0) { - return fetch_result_batch; - } + predict_res_batch._int64_map.clear(); + predict_res_batch._float_map.clear(); Timer timeline; int64_t preprocess_start = timeline.TimeStampUS(); - fetch_result_batch.resize(batch_size); int fetch_name_num = fetch_name.size(); - for (int bi = 0; bi < batch_size; bi++) { - fetch_result_batch[bi].resize(fetch_name_num); - } _api.thrd_clear(); _predictor = _api.fetch_predictor("general_model"); @@ -371,20 +367,36 @@ std::vector>> PredictorClient::batch_predict( } else { client_infer_end = timeline.TimeStampUS(); postprocess_start = client_infer_end; - + for (auto &name : fetch_name) { + predict_res_batch._int64_map[name].resize(batch_size); + predict_res_batch._float_map[name].resize(batch_size); + } for (int bi = 0; bi < batch_size; bi++) { for (auto &name : fetch_name) { int idx = _fetch_name_to_idx[name]; int len = res.insts(bi).tensor_array(idx).data_size(); - VLOG(2) << "fetch name: " << name; - VLOG(2) << "tensor data size: " << len; - fetch_result_batch[bi][idx].resize(len); - VLOG(2) - << "fetch name " << name << " index " << idx << " first data " - << *(const float *)res.insts(bi).tensor_array(idx).data(0).c_str(); - /* - TBA - */ + if (_fetch_name_to_type[name] == 0) { + int len = res.insts(bi).tensor_array(idx).int64_data_size(); + VLOG(2) << "fetch tensor : " << name << " type: int64 len : " << len; + predict_res_batch._int64_map[name][bi].resize(len); + VLOG(2) << "fetch name " << name << " index " << idx << " first data " + << res.insts(bi).tensor_array(idx).int64_data(0); + for (int i = 0; i < len; ++i) { + predict_res_batch._int64_map[name][bi][i] = + res.insts(bi).tensor_array(idx).int64_data(i); + } + } else if (_fetch_name_to_type[name] == 1) { + int len = res.insts(bi).tensor_array(idx).float_data_size(); + VLOG(2) << "fetch tensor : " << name + << " type: float32 len : " << len; + predict_res_batch._float_map[name][bi].resize(len); + VLOG(2) << "fetch name " << name << " index " << idx << " first data " + << res.insts(bi).tensor_array(idx).float_data(0); + for (int i = 0; i < len; ++i) { + predict_res_batch._float_map[name][bi][i] = + res.insts(bi).tensor_array(idx).float_data(i); + } + } } } postprocess_end = timeline.TimeStampUS(); @@ -393,6 +405,7 @@ std::vector>> PredictorClient::batch_predict( if (FLAGS_profile_client) { std::ostringstream oss; oss << "PROFILE\t" + << "pid:" << pid << "\t" << "prepro_0:" << preprocess_start << " " << "prepro_1:" << preprocess_end << " " << "client_infer_0:" << client_infer_start << " " @@ -411,7 +424,7 @@ std::vector>> PredictorClient::batch_predict( fprintf(stderr, "%s\n", oss.str().c_str()); } - return fetch_result_batch; + return 0; } } // namespace general_model diff --git a/core/general-client/src/general_model_main.cpp b/core/general-client/src/general_model_main.cpp index d5090b1f410f02d12c82f0f66d18183080fdf469..9fd6ac2158d81c77ea3a7b0ac8beee31189877e4 100644 --- a/core/general-client/src/general_model_main.cpp +++ b/core/general-client/src/general_model_main.cpp @@ -17,18 +17,18 @@ #include "core/general-client/include/general_model.h" -using namespace std; +using namespace std; // NOLINT using baidu::paddle_serving::general_model::PredictorClient; using baidu::paddle_serving::general_model::FetchedMap; -int main(int argc, char * argv[]) { - PredictorClient * client = new PredictorClient(); +int main(int argc, char* argv[]) { + PredictorClient* client = new PredictorClient(); client->init("inference.conf"); client->set_predictor_conf("./", "predictor.conf"); client->create_predictor(); - std::vector > float_feed; - std::vector > int_feed; + std::vector> float_feed; + std::vector> int_feed; std::vector float_feed_name; std::vector int_feed_name = {"words", "label"}; std::vector fetch_name = {"cost", "acc", "prediction"}; @@ -53,13 +53,14 @@ int main(int argc, char * argv[]) { cin >> label; int_feed.push_back({label}); - FetchedMap result; - client->predict( - float_feed, float_feed_name, - int_feed, int_feed_name, fetch_name, - &result); + client->predict(float_feed, + float_feed_name, + int_feed, + int_feed_name, + fetch_name, + &result); cout << label << "\t" << result["prediction"][1] << endl; diff --git a/core/general-client/src/pybind_general_model.cpp b/core/general-client/src/pybind_general_model.cpp index 287fa2dcb55344a6e71bf8e76171de5f94e89de5..0d0ca7bd8fab7785e96ad11e43b109bf118d5c52 100644 --- a/core/general-client/src/pybind_general_model.cpp +++ b/core/general-client/src/pybind_general_model.cpp @@ -90,12 +90,16 @@ PYBIND11_MODULE(serving_client, m) { const std::vector>> &int_feed_batch, const std::vector &int_feed_name, - const std::vector &fetch_name) { + const std::vector &fetch_name, + PredictorRes &predict_res_batch, + const int &pid) { return self.batch_predict(float_feed_batch, float_feed_name, int_feed_batch, int_feed_name, - fetch_name); + fetch_name, + predict_res_batch, + pid); }); } diff --git a/core/general-server/op/general_copy_op.cpp b/core/general-server/op/general_copy_op.cpp index 8fc63f7af22feed12a5316f4173b3d7add3bcc5a..a7f7d2904343bb9203fada6872994ed8916346bd 100644 --- a/core/general-server/op/general_copy_op.cpp +++ b/core/general-server/op/general_copy_op.cpp @@ -69,8 +69,7 @@ int GeneralCopyOp::inference() { for (int i = 0; i < out->size(); ++i) { int64_t *src_ptr = static_cast(in->at(i).data.data()); - out->at(i).data.Resize( - out->at(i).lod[0].back() * sizeof(int64_t)); + out->at(i).data.Resize(out->at(i).lod[0].back() * sizeof(int64_t)); out->at(i).shape = {out->at(i).lod[0].back(), 1}; int64_t *tgt_ptr = static_cast(out->at(i).data.data()); for (int j = 0; j < out->at(i).lod[0].back(); ++j) { diff --git a/core/general-server/op/general_copy_op.h b/core/general-server/op/general_copy_op.h index 38fb25c28df11bf8d1d075c093148aef64b2f722..89627ffb9e4d15bbcbfa6c7fc3a608ada03dad6e 100644 --- a/core/general-server/op/general_copy_op.h +++ b/core/general-server/op/general_copy_op.h @@ -24,23 +24,22 @@ #include "paddle_inference_api.h" // NOLINT #endif #include -#include "core/predictor/framework/resource.h" -#include "core/general-server/op/general_infer_helper.h" #include "core/general-server/general_model_service.pb.h" +#include "core/general-server/op/general_infer_helper.h" +#include "core/predictor/framework/resource.h" namespace baidu { namespace paddle_serving { namespace serving { -class GeneralCopyOp : - public baidu::paddle_serving::predictor::OpWithChannel { +class GeneralCopyOp + : public baidu::paddle_serving::predictor::OpWithChannel { public: typedef std::vector TensorVector; DECLARE_OP(GeneralCopyOp); int inference(); - }; } // namespace serving diff --git a/core/general-server/op/general_infer_op.h b/core/general-server/op/general_infer_op.h index 6c8d9fdc415122baf3eb94aaea5167579835737e..ff0b210ad7c6824a7e8a61e9ac504a65eafa4c58 100644 --- a/core/general-server/op/general_infer_op.h +++ b/core/general-server/op/general_infer_op.h @@ -39,7 +39,6 @@ class GeneralInferOp DECLARE_OP(GeneralInferOp); int inference(); - }; } // namespace serving diff --git a/core/general-server/op/general_reader_op.cpp b/core/general-server/op/general_reader_op.cpp index 93f6cfbb41b11de6a24d5acbfdc986a85d029b64..8695da2591a30725d5b2390ad287f9ceae40052b 100644 --- a/core/general-server/op/general_reader_op.cpp +++ b/core/general-server/op/general_reader_op.cpp @@ -188,8 +188,7 @@ int GeneralReaderOp::inference() { for (int j = 0; j < batch_size; ++j) { int elem_num = req->insts(j).tensor_array(i).int64_data_size(); for (int k = 0; k < elem_num; ++k) { - dst_ptr[offset + k] = - req->insts(j).tensor_array(i).int64_data(k); + dst_ptr[offset + k] = req->insts(j).tensor_array(i).int64_data(k); } if (out->at(i).lod.size() == 1) { offset = out->at(i).lod[0][j + 1]; @@ -203,8 +202,7 @@ int GeneralReaderOp::inference() { for (int j = 0; j < batch_size; ++j) { int elem_num = req->insts(j).tensor_array(i).float_data_size(); for (int k = 0; k < elem_num; ++k) { - dst_ptr[offset + k] = - req->insts(j).tensor_array(i).float_data(k); + dst_ptr[offset + k] = req->insts(j).tensor_array(i).float_data(k); } if (out->at(i).lod.size() == 1) { offset = out->at(i).lod[0][j + 1]; diff --git a/core/general-server/op/general_reader_op.h b/core/general-server/op/general_reader_op.h index 137fad98083ff6e136ea0446bd0c985a556b62de..c45d6ad5139a7a9a267f1c6556028a99295500de 100644 --- a/core/general-server/op/general_reader_op.h +++ b/core/general-server/op/general_reader_op.h @@ -24,24 +24,23 @@ #include "paddle_inference_api.h" // NOLINT #endif #include -#include "core/predictor/framework/resource.h" -#include "core/general-server/op/general_infer_helper.h" #include "core/general-server/general_model_service.pb.h" #include "core/general-server/load_general_model_service.pb.h" +#include "core/general-server/op/general_infer_helper.h" +#include "core/predictor/framework/resource.h" namespace baidu { namespace paddle_serving { namespace serving { -class GeneralReaderOp : public baidu::paddle_serving::predictor::OpWithChannel< - GeneralBlob> { +class GeneralReaderOp + : public baidu::paddle_serving::predictor::OpWithChannel { public: typedef std::vector TensorVector; DECLARE_OP(GeneralReaderOp); int inference(); - }; } // namespace serving diff --git a/core/general-server/op/general_response_op.cpp b/core/general-server/op/general_response_op.cpp index 6d9b797123be6a3731ebc83b14ebca1d522d59e6..c5248227bf230f766d4c2bf3f4f5f44d11e378db 100644 --- a/core/general-server/op/general_response_op.cpp +++ b/core/general-server/op/general_response_op.cpp @@ -122,8 +122,7 @@ int GeneralResponseOp::inference() { } else { for (int j = 0; j < batch_size; ++j) { FetchInst *fetch_p = res->mutable_insts(j); - fetch_p->mutable_tensor_array(var_idx)->add_int64_data( - data_ptr[0]); + fetch_p->mutable_tensor_array(var_idx)->add_int64_data(data_ptr[0]); } } } @@ -143,16 +142,15 @@ int GeneralResponseOp::inference() { if (var_size == batch_size) { for (int j = 0; j < batch_size; ++j) { for (int k = j * cap; k < (j + 1) * cap; ++k) { - FetchInst * fetch_p = res->mutable_insts(j); + FetchInst *fetch_p = res->mutable_insts(j); fetch_p->mutable_tensor_array(var_idx)->add_float_data( data_ptr[k]); } } } else { for (int j = 0; j < batch_size; ++j) { - FetchInst * fetch_p = res->mutable_insts(j); - fetch_p->mutable_tensor_array(var_idx)->add_float_data( - data_ptr[0]); + FetchInst *fetch_p = res->mutable_insts(j); + fetch_p->mutable_tensor_array(var_idx)->add_float_data(data_ptr[0]); } } } diff --git a/core/general-server/op/general_response_op.h b/core/general-server/op/general_response_op.h index 95b9f7708df82dc1ce750cb4067b79c8ca60fd05..4b0f6ed17b5a66dbda7bccef25cec03bf044e6c5 100644 --- a/core/general-server/op/general_response_op.h +++ b/core/general-server/op/general_response_op.h @@ -39,7 +39,6 @@ class GeneralResponseOp DECLARE_OP(GeneralResponseOp); int inference(); - }; } // namespace serving diff --git a/core/general-server/op/general_text_reader_op.cpp b/core/general-server/op/general_text_reader_op.cpp index 81df8171d30d7ebd2c208ad31cda5aea0564c50e..154e975d314a72515624b7bbf1aff85f70b8b5d3 100644 --- a/core/general-server/op/general_text_reader_op.cpp +++ b/core/general-server/op/general_text_reader_op.cpp @@ -12,11 +12,11 @@ // See the License for the specific language governing permissions and // limitations under the License. +#include "core/general-server/op/general_text_reader_op.h" #include #include #include #include -#include "core/general-server/op/general_text_reader_op.h" #include "core/predictor/framework/infer.h" #include "core/predictor/framework/memory.h" #include "core/util/include/timer.h" @@ -32,7 +32,6 @@ using baidu::paddle_serving::predictor::general_model::Request; using baidu::paddle_serving::predictor::general_model::FeedInst; using baidu::paddle_serving::predictor::PaddleGeneralModelConfig; - int GeneralTextReaderOp::inference() { // reade request from client const Request *req = dynamic_cast(get_request_message()); @@ -132,11 +131,9 @@ int GeneralTextReaderOp::inference() { int64_t *dst_ptr = static_cast(out->at(i).data.data()); int offset = 0; for (int j = 0; j < batch_size; ++j) { - for (int k = 0; - k < req->insts(j).tensor_array(i).int_data_size(); + for (int k = 0; k < req->insts(j).tensor_array(i).int_data_size(); ++k) { - dst_ptr[offset + k] = - req->insts(j).tensor_array(i).int_data(k); + dst_ptr[offset + k] = req->insts(j).tensor_array(i).int_data(k); } if (out->at(i).lod.size() == 1) { offset = out->at(i).lod[0][j + 1]; @@ -148,11 +145,9 @@ int GeneralTextReaderOp::inference() { float *dst_ptr = static_cast(out->at(i).data.data()); int offset = 0; for (int j = 0; j < batch_size; ++j) { - for (int k = 0; - k < req->insts(j).tensor_array(i).int_data_size(); + for (int k = 0; k < req->insts(j).tensor_array(i).int_data_size(); ++k) { - dst_ptr[offset + k] = - req->insts(j).tensor_array(i).int_data(k); + dst_ptr[offset + k] = req->insts(j).tensor_array(i).int_data(k); } if (out->at(i).lod.size() == 1) { offset = out->at(i).lod[0][j + 1]; diff --git a/core/general-server/op/general_text_reader_op.h b/core/general-server/op/general_text_reader_op.h index 80573a15cbbacf0d2682ea1b225ef7732d54e9ad..ca134256fce4aaa003f4b07033d4c471ebdb59b7 100644 --- a/core/general-server/op/general_text_reader_op.h +++ b/core/general-server/op/general_text_reader_op.h @@ -24,17 +24,17 @@ #include "paddle_inference_api.h" // NOLINT #endif #include -#include "core/predictor/framework/resource.h" -#include "core/general-server/op/general_infer_helper.h" #include "core/general-server/general_model_service.pb.h" #include "core/general-server/load_general_model_service.pb.h" +#include "core/general-server/op/general_infer_helper.h" +#include "core/predictor/framework/resource.h" namespace baidu { namespace paddle_serving { namespace serving { -class GeneralTextReaderOp : - public baidu::paddle_serving::predictor::OpWithChannel { +class GeneralTextReaderOp + : public baidu::paddle_serving::predictor::OpWithChannel { public: typedef std::vector TensorVector; diff --git a/core/general-server/op/general_text_response_op.h b/core/general-server/op/general_text_response_op.h index 5efefefb77e03f73d321cb1f2c91c7e183cb5a6b..52f7bbf0f7d76122bad14cf513302f70c35aa1d8 100644 --- a/core/general-server/op/general_text_response_op.h +++ b/core/general-server/op/general_text_response_op.h @@ -40,7 +40,6 @@ class GeneralTextResponseOp DECLARE_OP(GeneralTextResponseOp); int inference(); - }; } // namespace serving diff --git a/core/general-server/proto/general_model_service.proto b/core/general-server/proto/general_model_service.proto index 871f5de69eab227f433971cc34de961888cb2a6d..09e2854d540f9c70cfbe6b3f5e3d0b185bdf9d12 100644 --- a/core/general-server/proto/general_model_service.proto +++ b/core/general-server/proto/general_model_service.proto @@ -28,13 +28,9 @@ message Tensor { repeated int32 shape = 6; }; -message FeedInst { - repeated Tensor tensor_array = 1; -}; +message FeedInst { repeated Tensor tensor_array = 1; }; -message FetchInst { - repeated Tensor tensor_array = 1; -}; +message FetchInst { repeated Tensor tensor_array = 1; }; message Request { repeated FeedInst insts = 1; diff --git a/core/kvdb/include/kvdb/kvdb_impl.h b/core/kvdb/include/kvdb/kvdb_impl.h index cab06cad12b8740977c5681e2594905dbf5f476b..95437d6eb6ac42700400573ce0aff6f1c594b7c8 100644 --- a/core/kvdb/include/kvdb/kvdb_impl.h +++ b/core/kvdb/include/kvdb/kvdb_impl.h @@ -27,11 +27,11 @@ // limitations under the License. #pragma once -#include +#include // NOLINT +#include #include #include #include -#include class AbstractKVDB; class FileReader; class ParamDict; @@ -65,7 +65,7 @@ class FileReader { std::string data; FILE *stream = nullptr; const int max_buffer = 256; - char buffer[max_buffer]; + char buffer[max_buffer]; // NOLINT cmd.append(" 2>&1"); stream = popen(cmd.c_str(), "r"); if (stream) { @@ -76,7 +76,8 @@ class FileReader { return data; }; std::string cmd = "md5sum " + this->filename_; - // TODO: throw exception if error occurs during execution of shell command + // NOLINT TODO: throw exception if error occurs during execution of shell + // command std::string md5val = getCmdOut(cmd); this->time_stamp_ = md5val == this->last_md5_val_ ? this->time_stamp_ @@ -93,7 +94,7 @@ class FileReader { return this->time_stamp_; } - inline virtual ~FileReader(){}; + inline virtual ~FileReader() {} private: std::string filename_; @@ -128,7 +129,7 @@ class ParamDict { virtual ~ParamDict(); private: - std::function(std::string)> read_func_; + std::function(std::string)> read_func_; // NOLINT std::vector file_reader_lst_; AbsKVDBPtr front_db, back_db; }; @@ -139,5 +140,5 @@ class ParamDictMgr { void InsertParamDict(std::string, ParamDictPtr); private: - std::unordered_map ParamDictMap; + std::unordered_map ParamDictMap; // NOLINT }; diff --git a/core/kvdb/include/kvdb/paddle_rocksdb.h b/core/kvdb/include/kvdb/paddle_rocksdb.h index f11e11d1164eec6bc2f7f073a39bca7ff442c756..5aa82689850e12215d2984823cd24b194e97cc9c 100644 --- a/core/kvdb/include/kvdb/paddle_rocksdb.h +++ b/core/kvdb/include/kvdb/paddle_rocksdb.h @@ -25,7 +25,7 @@ class RocksDBWrapper { public: - RocksDBWrapper(std::string db_name); + RocksDBWrapper(std::string db_name); // NOLINT std::string Get(std::string key); bool Put(std::string key, std::string value); @@ -33,6 +33,7 @@ class RocksDBWrapper { static std::shared_ptr RocksDBWrapperFactory( std::string db_name = "SparseMatrix"); void Close(); + private: rocksdb::DB *db_; std::string db_name_; diff --git a/core/kvdb/src/mock_param_dict_impl.cpp b/core/kvdb/src/mock_param_dict_impl.cpp index 5f76ebcea3d46271fcc1e9ce187007e1c2e5143b..106bda3ecdea4b3744da08e710126dba906f6204 100644 --- a/core/kvdb/src/mock_param_dict_impl.cpp +++ b/core/kvdb/src/mock_param_dict_impl.cpp @@ -16,7 +16,7 @@ #include #include #include -#include +#include // NOLINT #include "core/kvdb/include/kvdb/rocksdb_impl.h" std::vector ParamDict::GetDictReaderLst() { @@ -33,8 +33,10 @@ void ParamDict::SetFileReaderLst(std::vector lst) { std::vector ParamDict::GetSparseValue(std::string feasign, std::string slot) { - auto BytesToFloat = [](uint8_t* byte_array) { return *((float*)byte_array); }; - // TODO: the concatation of feasign and slot is TBD. + auto BytesToFloat = [](uint8_t* byte_array) { + return *((float*)byte_array); // NOLINT + }; + // NOLINT TODO: the concatation of feasign and slot is TBD. std::string result = front_db->Get(feasign + slot); std::vector value; if (result == "NOT_FOUND") return value; @@ -87,7 +89,7 @@ bool ParamDict::InsertSparseValue(std::string feasign, value.push_back(raw_values_ptr[i]); } back_db->Set(key, value); - // TODO: change stateless to stateful + // NOLINT TODO: change stateless to stateful return true; } @@ -140,5 +142,4 @@ void ParamDict::CreateKVDB() { this->back_db->CreateDB(); } -ParamDict::~ParamDict() { -} +ParamDict::~ParamDict() {} diff --git a/core/kvdb/src/paddle_rocksdb.cpp b/core/kvdb/src/paddle_rocksdb.cpp index a60b93c7ef980a8c6f3b1b77b1d500bfb5829160..2238d41d4e932ca72ce538842a2f3e8876dcba59 100644 --- a/core/kvdb/src/paddle_rocksdb.cpp +++ b/core/kvdb/src/paddle_rocksdb.cpp @@ -51,7 +51,7 @@ void RocksDBWrapper::SetDBName(std::string db_name) { void RocksDBWrapper::Close() { if (db_ != nullptr) { db_->Close(); - delete(db_); + delete (db_); db_ = nullptr; } } diff --git a/core/kvdb/src/rockskvdb_impl.cpp b/core/kvdb/src/rockskvdb_impl.cpp index 4b2c177a373d71593dce039642ca9092c01e01ab..9e6cdd6bc9011f14af21b988018f4a74ac8d2750 100644 --- a/core/kvdb/src/rockskvdb_impl.cpp +++ b/core/kvdb/src/rockskvdb_impl.cpp @@ -32,12 +32,8 @@ void RocksKVDB::Set(std::string key, std::string value) { return; } -void RocksKVDB::Close() { - this->db_->Close(); -} +void RocksKVDB::Close() { this->db_->Close(); } std::string RocksKVDB::Get(std::string key) { return this->db_->Get(key); } -RocksKVDB::~RocksKVDB() { - this->db_->Close(); -} +RocksKVDB::~RocksKVDB() { this->db_->Close(); } diff --git a/core/pdcodegen/src/pdcodegen.cpp b/core/pdcodegen/src/pdcodegen.cpp index 007c43c65ca8431982a3f1574df96f558b25f94c..af4081a985ece584f82120799fc9a384f83830be 100644 --- a/core/pdcodegen/src/pdcodegen.cpp +++ b/core/pdcodegen/src/pdcodegen.cpp @@ -15,14 +15,14 @@ #include #include "boost/algorithm/string.hpp" #include "boost/scoped_ptr.hpp" +#include "core/pdcodegen/pds_option.pb.h" +#include "core/pdcodegen/plugin/strutil.h" +#include "core/pdcodegen/plugin/substitute.h" #include "google/protobuf/compiler/code_generator.h" #include "google/protobuf/compiler/plugin.h" #include "google/protobuf/descriptor.h" #include "google/protobuf/io/printer.h" #include "google/protobuf/io/zero_copy_stream.h" -#include "core/pdcodegen/pds_option.pb.h" -#include "core/pdcodegen/plugin/strutil.h" -#include "core/pdcodegen/plugin/substitute.h" using std::string; using google::protobuf::Descriptor; using google::protobuf::FileDescriptor; @@ -115,7 +115,8 @@ class PdsCodeGenerator : public CodeGenerator { printer.Print("#include \"core/predictor/common/inner_common.h\"\n"); printer.Print("#include \"core/predictor/framework/service.h\"\n"); printer.Print("#include \"core/predictor/framework/manager.h\"\n"); - printer.Print("#include \"core/predictor/framework/service_manager.h\"\n"); + printer.Print( + "#include \"core/predictor/framework/service_manager.h\"\n"); } if (generate_stub) { printer.Print("#include \n"); @@ -845,7 +846,8 @@ class PdsCodeGenerator : public CodeGenerator { printer.Print("#include \"core/predictor/common/inner_common.h\"\n"); printer.Print("#include \"core/predictor/framework/service.h\"\n"); printer.Print("#include \"core/predictor/framework/manager.h\"\n"); - printer.Print("#include \"core/predictor/framework/service_manager.h\"\n"); + printer.Print( + "#include \"core/predictor/framework/service_manager.h\"\n"); } if (generate_stub) { printer.Print("#include \n"); diff --git a/core/predictor/common/inner_common.h b/core/predictor/common/inner_common.h index 4d9b2c19ba0c0dd2e6b6c9aa994cf3a66e90fce8..96b8a8027070da559e239cdc5f6057d534ff3412 100644 --- a/core/predictor/common/inner_common.h +++ b/core/predictor/common/inner_common.h @@ -52,9 +52,9 @@ #include "glog/raw_logging.h" +#include "core/configure/general_model_config.pb.h" #include "core/configure/include/configure_parser.h" #include "core/configure/server_configure.pb.h" -#include "core/configure/general_model_config.pb.h" #include "core/predictor/common/constant.h" #include "core/predictor/common/types.h" diff --git a/core/predictor/framework/dag_view.cpp b/core/predictor/framework/dag_view.cpp index 42a61b0885b7ecd9c4061c8bde24879d998a1ec1..743e73418b535776e651bd1500509ffcad0e0618 100644 --- a/core/predictor/framework/dag_view.cpp +++ b/core/predictor/framework/dag_view.cpp @@ -45,7 +45,7 @@ int DagView::init(Dag* dag, const std::string& service_name) { << "at:" << si; return ERR_MEM_ALLOC_FAILURE; } - VLOG(2) << "stage[" << si << "] name: " << stage->full_name; + VLOG(2) << "stage[" << si << "] name: " << stage->full_name; VLOG(2) << "stage[" << si << "] node size: " << stage->nodes.size(); vstage->full_name = service_name + NAME_DELIMITER + stage->full_name; uint32_t node_size = stage->nodes.size(); @@ -74,7 +74,7 @@ int DagView::init(Dag* dag, const std::string& service_name) { LOG(WARNING) << "Failed init op, type:" << node->type; return ERR_INTERNAL_FAILURE; } - + op->set_full_name(service_name + NAME_DELIMITER + node->full_name); vnode->conf = node; vnode->op = op; @@ -85,9 +85,9 @@ int DagView::init(Dag* dag, const std::string& service_name) { VLOG(2) << "set op pre name: \n" << "current op name: " << vstage->nodes.back()->op->op_name() << " previous op name: " - << _view[si-1]->nodes.back()->op->op_name(); + << _view[si - 1]->nodes.back()->op->op_name(); vstage->nodes.back()->op->set_pre_node_name( - _view[si-1]->nodes.back()->op->op_name()); + _view[si - 1]->nodes.back()->op->op_name()); } _view.push_back(vstage); } diff --git a/core/predictor/framework/factory.h b/core/predictor/framework/factory.h index 033bfb71d92a7c60fab25e589c2aac5fef58d8fd..8d5fc9a1c40b047351f38a1136728ee179a191ed 100644 --- a/core/predictor/framework/factory.h +++ b/core/predictor/framework/factory.h @@ -16,8 +16,8 @@ #include #include #include -#include "glog/raw_logging.h" #include "core/predictor/common/inner_common.h" +#include "glog/raw_logging.h" namespace baidu { namespace paddle_serving { namespace predictor { diff --git a/core/predictor/framework/resource.cpp b/core/predictor/framework/resource.cpp index 98571ad7fd0aeac0d82a7b3ff88b9a33ade3c65c..943b1715109bf85108d338bce7e286d410ede494 100644 --- a/core/predictor/framework/resource.cpp +++ b/core/predictor/framework/resource.cpp @@ -197,13 +197,10 @@ int Resource::general_model_initialize(const std::string& path, for (int i = 0; i < feed_var_num; ++i) { _config->_feed_name[i] = model_config.feed_var(i).name(); _config->_feed_alias_name[i] = model_config.feed_var(i).alias_name(); - VLOG(2) << "feed var[" << i << "]: " - << _config->_feed_name[i]; - VLOG(2) << "feed var[" << i << "]: " - << _config->_feed_alias_name[i]; + VLOG(2) << "feed var[" << i << "]: " << _config->_feed_name[i]; + VLOG(2) << "feed var[" << i << "]: " << _config->_feed_alias_name[i]; _config->_feed_type[i] = model_config.feed_var(i).feed_type(); - VLOG(2) << "feed type[" << i << "]: " - << _config->_feed_type[i]; + VLOG(2) << "feed type[" << i << "]: " << _config->_feed_type[i]; if (model_config.feed_var(i).is_lod_tensor()) { VLOG(2) << "var[" << i << "] is lod tensor"; diff --git a/core/predictor/framework/resource.h b/core/predictor/framework/resource.h index 05820f9f8b0282260ce3d81d4634ddd20bd360a8..eedd4fc19edcd0dd528445198a53c5c67d88dbc8 100644 --- a/core/predictor/framework/resource.h +++ b/core/predictor/framework/resource.h @@ -13,10 +13,10 @@ // limitations under the License. #pragma once +#include #include #include #include -#include #include "core/cube/cube-api/include/cube_api.h" #include "core/kvdb/include/kvdb/paddle_rocksdb.h" #include "core/predictor/common/inner_common.h" @@ -36,15 +36,15 @@ class PaddleGeneralModelConfig { public: std::vector _feed_name; std::vector _feed_alias_name; - std::vector _feed_type; // 0 int64, 1 float - std::vector _is_lod_feed; // true lod tensor + std::vector _feed_type; // 0 int64, 1 float + std::vector _is_lod_feed; // true lod tensor std::vector _is_lod_fetch; // whether a fetch var is lod_tensor - std::vector _capacity; // capacity for each tensor - /* - feed_shape_ for feeded variable - feed_shape_[i][j] represents the jth dim for ith input Tensor - if is_lod_feed_[i] == False, feed_shape_[i][0] = -1 - */ + std::vector _capacity; // capacity for each tensor + /* + feed_shape_ for feeded variable + feed_shape_[i][j] represents the jth dim for ith input Tensor + if is_lod_feed_[i] == False, feed_shape_[i][0] = -1 + */ std::vector> _feed_shape; std::vector _fetch_name; diff --git a/core/predictor/src/pdserving.cpp b/core/predictor/src/pdserving.cpp index f0fedacf63b250ec3dd742744dc01d67d567f653..fe8693de9349ac1c4c2ae94a07e21dc8be448da3 100644 --- a/core/predictor/src/pdserving.cpp +++ b/core/predictor/src/pdserving.cpp @@ -99,8 +99,8 @@ static void g_change_server_port() { if (read_proto_conf(FLAGS_inferservice_path.c_str(), FLAGS_inferservice_file.c_str(), &conf) != 0) { - VLOG(2) << "failed to load configure[" << FLAGS_inferservice_path - << "," << FLAGS_inferservice_file << "]."; + VLOG(2) << "failed to load configure[" << FLAGS_inferservice_path << "," + << FLAGS_inferservice_file << "]."; return; } uint32_t port = conf.port(); @@ -157,8 +157,7 @@ int main(int argc, char** argv) { mkdir(FLAGS_log_dir.c_str(), 0777); ret = stat(FLAGS_log_dir.c_str(), &st_buf); if (ret != 0) { - VLOG(2) << "Log path " << FLAGS_log_dir - << " not exist, and create fail"; + VLOG(2) << "Log path " << FLAGS_log_dir << " not exist, and create fail"; return -1; } } diff --git a/core/predictor/unittest/test_message_op.h b/core/predictor/unittest/test_message_op.h index 5b4a2e5fb4732cad43545ee96750d1385da9b621..6ff8fc426f7e836024e0b00527da19d41a6dc862 100644 --- a/core/predictor/unittest/test_message_op.h +++ b/core/predictor/unittest/test_message_op.h @@ -15,8 +15,8 @@ #pragma once #include #include "core/predictor/framework/channel.h" -#include "core/predictor/op/op.h" #include "core/predictor/msg_data.pb.h" +#include "core/predictor/op/op.h" namespace baidu { namespace paddle_serving { diff --git a/core/predictor/unittest/test_server_manager.cpp b/core/predictor/unittest/test_server_manager.cpp index df28e2ee3e39465aae44801d3968763817f9ddaa..07f02256ab77bef86e094e25573527aad3bca058 100644 --- a/core/predictor/unittest/test_server_manager.cpp +++ b/core/predictor/unittest/test_server_manager.cpp @@ -13,7 +13,7 @@ // limitations under the License. #include "core/predictor/unittest/test_server_manager.h" // TestServerManager -#include // FLAGS +#include // FLAGS #include #include "core/predictor/framework/server.h" // ServerManager diff --git a/core/sdk-cpp/include/common.h b/core/sdk-cpp/include/common.h index f6a600cd4024c5b14c1aa774b5199d1ecc754c28..8cfe979ed0be026a7dd0ddf8fb569513292501ee 100644 --- a/core/sdk-cpp/include/common.h +++ b/core/sdk-cpp/include/common.h @@ -53,9 +53,9 @@ #include "json2pb/json_to_pb.h" #endif +#include "core/configure/general_model_config.pb.h" #include "core/configure/include/configure_parser.h" #include "core/configure/sdk_configure.pb.h" -#include "core/configure/general_model_config.pb.h" #include "core/sdk-cpp/include/utils.h" diff --git a/core/sdk-cpp/include/config_manager.h b/core/sdk-cpp/include/config_manager.h index 44134716e9f4ae5ba14175061cf858d854d8b42e..6cd50e7fffdc33edf7a6d62e12e9c337126e41d4 100644 --- a/core/sdk-cpp/include/config_manager.h +++ b/core/sdk-cpp/include/config_manager.h @@ -32,9 +32,9 @@ class EndpointConfigManager { EndpointConfigManager() : _last_update_timestamp(0), _current_endpointmap_id(1) {} - int create(const std::string & sdk_desc_str); + int create(const std::string& sdk_desc_str); - int load(const std::string & sdk_desc_str); + int load(const std::string& sdk_desc_str); int create(const char* path, const char* file); diff --git a/core/sdk-cpp/include/factory.h b/core/sdk-cpp/include/factory.h index 7e9e22278c48e5fd40138443ab6cdb06f21a5d00..4a3d988afcd981dd92eca5f65c3f254d5f2255d5 100644 --- a/core/sdk-cpp/include/factory.h +++ b/core/sdk-cpp/include/factory.h @@ -16,9 +16,9 @@ #include #include #include -#include "glog/raw_logging.h" #include "core/sdk-cpp/include/common.h" #include "core/sdk-cpp/include/stub_impl.h" +#include "glog/raw_logging.h" namespace baidu { namespace paddle_serving { diff --git a/core/sdk-cpp/include/predictor_sdk.h b/core/sdk-cpp/include/predictor_sdk.h index 6b2e8a2c4ed7b6cef219ebce1a8016b780b795a7..65d806722014c14b0cbb1ccfbd4510f861ef0467 100644 --- a/core/sdk-cpp/include/predictor_sdk.h +++ b/core/sdk-cpp/include/predictor_sdk.h @@ -31,7 +31,7 @@ class PredictorApi { int register_all(); - int create(const std::string & sdk_desc_str); + int create(const std::string& sdk_desc_str); int create(const char* path, const char* file); diff --git a/core/sdk-cpp/proto/general_model_service.proto b/core/sdk-cpp/proto/general_model_service.proto index 95c2abf0717fb12e87c45b01a925afb67085f38c..827bb880ad0fe55caef3aeac4bc596ae896b776d 100644 --- a/core/sdk-cpp/proto/general_model_service.proto +++ b/core/sdk-cpp/proto/general_model_service.proto @@ -28,13 +28,9 @@ message Tensor { repeated int32 shape = 6; }; -message FeedInst { - repeated Tensor tensor_array = 1; -}; +message FeedInst { repeated Tensor tensor_array = 1; }; -message FetchInst { - repeated Tensor tensor_array = 1; -}; +message FetchInst { repeated Tensor tensor_array = 1; }; message Request { repeated FeedInst insts = 1; diff --git a/core/sdk-cpp/src/endpoint.cpp b/core/sdk-cpp/src/endpoint.cpp index fe0bf024a24c6a8d959bd0b96319027388457207..517fe6dd806319f024cf343b41bb819967180d6d 100644 --- a/core/sdk-cpp/src/endpoint.cpp +++ b/core/sdk-cpp/src/endpoint.cpp @@ -35,8 +35,7 @@ int Endpoint::initialize(const EndpointInfo& ep_info) { return -1; } _variant_list.push_back(var); - VLOG(2) << "Succ create variant: " << vi - << ", endpoint:" << _endpoint_name; + VLOG(2) << "Succ create variant: " << vi << ", endpoint:" << _endpoint_name; } return 0; diff --git a/core/sdk-cpp/src/predictor_sdk.cpp b/core/sdk-cpp/src/predictor_sdk.cpp index c9f4a6944bb451093d3e84dcac3c13b43f29a9c6..36eb18669f87f9b1570f5a9af510192c0e3e1532 100644 --- a/core/sdk-cpp/src/predictor_sdk.cpp +++ b/core/sdk-cpp/src/predictor_sdk.cpp @@ -30,7 +30,7 @@ int PredictorApi::register_all() { return 0; } -int PredictorApi::create(const std::string & api_desc_str) { +int PredictorApi::create(const std::string& api_desc_str) { VLOG(2) << api_desc_str; if (register_all() != 0) { LOG(ERROR) << "Failed do register all!"; diff --git a/core/sdk-cpp/src/variant.cpp b/core/sdk-cpp/src/variant.cpp index ae1d787bfc2bd3b4ca57eb9d8043cd40744b9c50..6f9be664b2c2900488296863e4a3e2d3eb3ea861 100644 --- a/core/sdk-cpp/src/variant.cpp +++ b/core/sdk-cpp/src/variant.cpp @@ -54,7 +54,7 @@ int Variant::initialize(const EndpointInfo& ep_info, if (_stub_map.size() > 0) { VLOG(2) << "Initialize variants from VariantInfo" - << ", stubs count: " << _stub_map.size(); + << ", stubs count: " << _stub_map.size(); return 0; } diff --git a/core/util/CMakeLists.txt b/core/util/CMakeLists.txt index 7d3b2fd56a44be5d06f2ee16f0f111a01ceeb9d2..290f2bbc7cafded2ea06f15cf06da750e481f821 100644 --- a/core/util/CMakeLists.txt +++ b/core/util/CMakeLists.txt @@ -1,3 +1,2 @@ include(src/CMakeLists.txt) add_library(utils ${util_srcs}) - diff --git a/core/util/include/timer.h b/core/util/include/timer.h index 9d547bc102b987f898887b0b2659b1d8e6942c24..6b91a27f7a5d415d16bb7dca504e2ef6f4520121 100644 --- a/core/util/include/timer.h +++ b/core/util/include/timer.h @@ -15,7 +15,6 @@ limitations under the License. */ #pragma once #include - namespace baidu { namespace paddle_serving { diff --git a/core/util/src/CMakeLists.txt b/core/util/src/CMakeLists.txt index 0a45dc9e9319f7a3df04ad08eda432616bc363f7..8b1d4f5e81adba4ba6ebed90977850ea8bc572c1 100644 --- a/core/util/src/CMakeLists.txt +++ b/core/util/src/CMakeLists.txt @@ -1,3 +1,2 @@ FILE(GLOB srcs ${CMAKE_CURRENT_LIST_DIR}/*.cc) LIST(APPEND util_srcs ${srcs}) - diff --git a/doc/COMPILE.md b/doc/COMPILE.md index e93d0b7e5b906213e6a3ff9f149b372c22b1c80e..99aa5ff8c271d7386119f55863030ac15a234d44 100644 --- a/doc/COMPILE.md +++ b/doc/COMPILE.md @@ -1,5 +1,13 @@ # 如何编译PaddleServing +### 编译环境设置 +- os: CentOS 6u3 +- gcc: 4.8.2及以上 +- go: 1.9.2及以上 +- git：2.17.1及以上 +- cmake：3.2.2及以上 +- python：2.7.2及以上 + ### 获取代码 ``` python @@ -9,6 +17,12 @@ git submodule update --init --recursive ### 编译Server部分 +#### PYTHONROOT设置 +``` shell +# 例如python的路径为/usr/bin/python，可以设置PYTHONROOT +export PYTHONROOT=/usr/ +``` + #### 集成CPU版本Paddle Inference Library ``` shell cmake -DPYTHON_INCLUDE_DIR=$PYTHONROOT/include/python2.7/ -DPYTHON_LIBRARIES=$PYTHONROOT/lib/libpython2.7.so -DPYTHON_EXECUTABLE=/home/users/dongdaxiang/software/baidu/third-party/python/bin/python -DCLIENT_ONLY=OFF .. @@ -28,3 +42,5 @@ cmake -DPYTHON_INCLUDE_DIR=$PYTHONROOT/include/python2.7/ -DPYTHON_LIBRARIES=$PY make -j10 ``` +### 安装wheel包 +无论是client端还是server端，编译完成后，安装python/dist/下的whl包即可 diff --git a/doc/CONTRIBUTE.md b/doc/CONTRIBUTE.md index a7ebba0a4369470d2e46d3d82c72026d2c122b5e..d788ac275eb5c4c0d580bd14b7fd49076f641723 100644 --- a/doc/CONTRIBUTE.md +++ b/doc/CONTRIBUTE.md @@ -152,4 +152,3 @@ GLOG_minloglevel=1 bin/serving 2 -ERROR 3 - FATAL (Be careful as FATAL log will generate a coredump) - diff --git a/doc/IMDB_GO_CLIENT.md b/doc/IMDB_GO_CLIENT.md index ec3a3a8c1e62e8a787dfc17d9057f42cffa8b7af..5b10192597f393d65f1387bfb39615e1777ec2d6 100644 --- a/doc/IMDB_GO_CLIENT.md +++ b/doc/IMDB_GO_CLIENT.md @@ -193,6 +193,3 @@ total num: 25000 acc num: 22014 acc: 0.88056 ``` - - - diff --git a/doc/NEW_OPERATOR.md b/doc/NEW_OPERATOR.md index 8ff4b3e2e945e09f6a896e6c0a505b94e1b0be8f..f839be94aaa2ae9993d935c0af69bcde33b9d66f 100644 --- a/doc/NEW_OPERATOR.md +++ b/doc/NEW_OPERATOR.md @@ -143,6 +143,3 @@ self.op_dict = { "general_dist_kv": "GeneralDistKVOp" } ``` - - - diff --git a/doc/SERVER_DAG.md b/doc/SERVER_DAG.md index 12566d612bf2f0e391283ec58df12a53752333ba..fd15140f183dac1d414c6fffe8df250500db24b3 100644 --- a/doc/SERVER_DAG.md +++ b/doc/SERVER_DAG.md @@ -54,10 +54,3 @@ op_seq_maker.add_op(dist_kv_op) op_seq_maker.add_op(general_infer_op) op_seq_maker.add_op(general_response_op) ``` - - - - - - - diff --git a/paddle_inference/inferencer-fluid-cpu/include/fluid_cpu_engine.h b/paddle_inference/inferencer-fluid-cpu/include/fluid_cpu_engine.h index 7a7291a067da53764d4bbad5106fbc8ea672d012..24148e374e51cb42cb0d8d1423e0ca009e9e8294 100644 --- a/paddle_inference/inferencer-fluid-cpu/include/fluid_cpu_engine.h +++ b/paddle_inference/inferencer-fluid-cpu/include/fluid_cpu_engine.h @@ -21,8 +21,8 @@ #include #include "core/configure/include/configure_parser.h" #include "core/configure/inferencer_configure.pb.h" -#include "paddle_inference_api.h" // NOLINT #include "core/predictor/framework/infer.h" +#include "paddle_inference_api.h" // NOLINT namespace baidu { namespace paddle_serving { @@ -336,7 +336,7 @@ class SigmoidModel { return -1; } VLOG(2) << "load sigmoid_b [" << _sigmoid_b._params[0] << "] [" - << _sigmoid_b._params[1] << "]."; + << _sigmoid_b._params[1] << "]."; _exp_max_input = exp_max; _exp_min_input = exp_min; return 0; @@ -373,7 +373,7 @@ class SigmoidFluidModel { clone_model.reset(new SigmoidFluidModel()); clone_model->_sigmoid_core = _sigmoid_core; clone_model->_fluid_core = _fluid_core->Clone(); - return std::move(clone_model); + return std::move(clone_model); // NOLINT } public: @@ -459,7 +459,7 @@ class FluidCpuWithSigmoidCore : public FluidFamilyCore { } protected: - std::unique_ptr _core; + std::unique_ptr _core; // NOLINT }; class FluidCpuNativeDirWithSigmoidCore : public FluidCpuWithSigmoidCore { diff --git a/paddle_inference/inferencer-fluid-gpu/include/fluid_gpu_engine.h b/paddle_inference/inferencer-fluid-gpu/include/fluid_gpu_engine.h index ca546207c47693d17d1ad5904d51f9888e0c5a04..a3fa365444a40d505b16b22e702d4a8b69699073 100644 --- a/paddle_inference/inferencer-fluid-gpu/include/fluid_gpu_engine.h +++ b/paddle_inference/inferencer-fluid-gpu/include/fluid_gpu_engine.h @@ -23,8 +23,8 @@ #include #include "core/configure/include/configure_parser.h" #include "core/configure/inferencer_configure.pb.h" -#include "paddle_inference_api.h" // NOLINT #include "core/predictor/framework/infer.h" +#include "paddle_inference_api.h" // NOLINT DECLARE_int32(gpuid); @@ -334,13 +334,13 @@ class SigmoidModel { return -1; } VLOG(2) << "load sigmoid_w [" << _sigmoid_w._params[0] << "] [" - << _sigmoid_w._params[1] << "]."; + << _sigmoid_w._params[1] << "]."; if (0 != _sigmoid_b.init(2, 1, sigmoid_b_file) || 0 != _sigmoid_b.load()) { LOG(ERROR) << "load params sigmoid_b failed."; return -1; } VLOG(2) << "load sigmoid_b [" << _sigmoid_b._params[0] << "] [" - << _sigmoid_b._params[1] << "]."; + << _sigmoid_b._params[1] << "]."; _exp_max_input = exp_max; _exp_min_input = exp_min; return 0; diff --git a/python/examples/bert/batching.py b/python/examples/bert/batching.py new file mode 100644 index 0000000000000000000000000000000000000000..5ec5f320cf5ec7bd0ab4624d9b39ef936553c774 --- /dev/null +++ b/python/examples/bert/batching.py @@ -0,0 +1,126 @@ +#coding:utf-8 +# Copyright (c) 2019 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. +"""Mask, padding and batching.""" + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import numpy as np + + +def prepare_batch_data(insts, + total_token_num, + max_seq_len=128, + pad_id=None, + cls_id=None, + sep_id=None, + mask_id=None, + return_input_mask=True, + return_max_len=True, + return_num_token=False): + """ + 1. generate Tensor of data + 2. generate Tensor of position + 3. generate self attention mask, [shape: batch_size * max_len * max_len] + """ + + batch_src_ids = [inst[0] for inst in insts] + batch_sent_ids = [inst[1] for inst in insts] + batch_pos_ids = [inst[2] for inst in insts] + labels_list = [] + # compatible with squad, whose example includes start/end positions, + # or unique id + + for i in range(3, len(insts[0]), 1): + labels = [inst[i] for inst in insts] + labels = np.array(labels).astype("int64").reshape([-1, 1]) + labels_list.append(labels) + + out = batch_src_ids + # Second step: padding + src_id, self_input_mask = pad_batch_data( + out, pad_idx=pad_id, max_seq_len=max_seq_len, return_input_mask=True) + pos_id = pad_batch_data( + batch_pos_ids, + pad_idx=pad_id, + max_seq_len=max_seq_len, + return_pos=False, + return_input_mask=False) + sent_id = pad_batch_data( + batch_sent_ids, + pad_idx=pad_id, + max_seq_len=max_seq_len, + return_pos=False, + return_input_mask=False) + + return_list = [src_id, pos_id, sent_id, self_input_mask] + labels_list + + return return_list if len(return_list) > 1 else return_list[0] + + +def pad_batch_data(insts, + pad_idx=0, + max_seq_len=128, + return_pos=False, + return_input_mask=False, + return_max_len=False, + return_num_token=False, + return_seq_lens=False): + """ + Pad the instances to the max sequence length in batch, and generate the + corresponding position data and input mask. + """ + return_list = [] + #max_len = max(len(inst) for inst in insts) + max_len = max_seq_len + # Any token included in dict can be used to pad, since the paddings' loss + # will be masked out by weights and make no effect on parameter gradients. + + inst_data = np.array([ + list(inst) + list([pad_idx] * (max_len - len(inst))) for inst in insts + ]) + return_list += [inst_data.astype("int64").reshape([-1, max_len, 1])] + + # position data + if return_pos: + inst_pos = np.array([ + list(range(0, len(inst))) + [pad_idx] * (max_len - len(inst)) + for inst in insts + ]) + + return_list += [inst_pos.astype("int64").reshape([-1, max_len, 1])] + + if return_input_mask: + # This is used to avoid attention on paddings. + input_mask_data = np.array( + [[1] * len(inst) + [0] * (max_len - len(inst)) for inst in insts]) + input_mask_data = np.expand_dims(input_mask_data, axis=-1) + return_list += [input_mask_data.astype("float32")] + + if return_max_len: + return_list += [max_len] + + if return_num_token: + num_token = 0 + for inst in insts: + num_token += len(inst) + return_list += [num_token] + + if return_seq_lens: + seq_lens = np.array([len(inst) for inst in insts]) + return_list += [seq_lens.astype("int64").reshape([-1, 1])] + + return return_list if len(return_list) > 1 else return_list[0] diff --git a/python/examples/bert/benchmark.py b/python/examples/bert/benchmark.py index 9e8af21cc622986e0cf8233a827341030900ff6b..e770dae0d4c4078eb06d37c27ea0805594c7bd7c 100644 --- a/python/examples/bert/benchmark.py +++ b/python/examples/bert/benchmark.py @@ -1,3 +1,5 @@ +# -*- coding: utf-8 -*- +# # Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -11,55 +13,59 @@ # 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. +# pylint: disable=doc-string-missing +from __future__ import unicode_literals, absolute_import +import os import sys +import time from paddle_serving_client import Client -from paddle_serving_client.metric import auc from paddle_serving_client.utils import MultiThreadRunner -import time -from bert_client import BertService +from paddle_serving_client.utils import benchmark_args +from batching import pad_batch_data +import tokenization +import requests +import json +from bert_reader import BertReader +args = benchmark_args() -def predict(thr_id, resource): - bc = BertService( - model_name="bert_chinese_L-12_H-768_A-12", - max_seq_len=20, - do_lower_case=True) - bc.load_client(resource["conf_file"], resource["server_endpoint"]) - thread_num = resource["thread_num"] - file_list = resource["filelist"] - line_id = 0 - result = [] - label_list = [] - dataset = [] - for fn in file_list: - fin = open(fn) - for line in fin: - if line_id % thread_num == thr_id - 1: - dataset.append(line.strip()) - line_id += 1 - fin.close() - - start = time.time() - fetch = ["pooled_output"] - for inst in dataset: - fetch_map = bc.run_general([[inst]], fetch) - result.append(fetch_map["pooled_output"]) - end = time.time() - return [result, label_list, [end - start]] +def single_func(idx, resource): + fin = open("data-c.txt") + if args.request == "rpc": + reader = BertReader(vocab_file="vocab.txt", max_seq_len=20) + config_file = './serving_client_conf/serving_client_conf.prototxt' + fetch = ["pooled_output"] + client = Client() + client.load_client_config(args.model) + client.connect([resource["endpoint"][idx % 4]]) -if __name__ == '__main__': - conf_file = sys.argv[1] - data_file = sys.argv[2] - thread_num = sys.argv[3] - resource = {} - resource["conf_file"] = conf_file - resource["server_endpoint"] = ["127.0.0.1:9292"] - resource["filelist"] = [data_file] - resource["thread_num"] = int(thread_num) + start = time.time() + for line in fin: + feed_dict = reader.process(line) + result = client.predict(feed=feed_dict, fetch=fetch) + end = time.time() + elif args.request == "http": + start = time.time() + header = {"Content-Type": "application/json"} + for line in fin: + #dict_data = {"words": "this is for output ", "fetch": ["pooled_output"]} + dict_data = {"words": line, "fetch": ["pooled_output"]} + r = requests.post( + 'http://{}/bert/prediction'.format(resource["endpoint"][0]), + data=json.dumps(dict_data), + headers=header) + end = time.time() + return [[end - start]] - thread_runner = MultiThreadRunner() - result = thread_runner.run(predict, int(sys.argv[3]), resource) - print("total time {} s".format(sum(result[-1]) / len(result[-1]))) +if __name__ == '__main__': + multi_thread_runner = MultiThreadRunner() + endpoint_list = [ + "127.0.0.1:9494", "127.0.0.1:9495", "127.0.0.1:9496", "127.0.0.1:9497" + ] + #endpoint_list = endpoint_list + endpoint_list + endpoint_list + #result = multi_thread_runner.run(single_func, args.thread, {"endpoint":endpoint_list}) + result = single_func(0, {"endpoint": endpoint_list}) + print(result) diff --git a/python/examples/bert/bert_client.py b/python/examples/bert/bert_client.py index 7ac7f4fd8676e853547aa05b99222820c764b5ab..343a6e013fd9508e3d4d6baf180bd625fa676e78 100644 --- a/python/examples/bert/bert_client.py +++ b/python/examples/bert/bert_client.py @@ -1,4 +1,5 @@ # coding:utf-8 +# pylint: disable=doc-string-missing import os import sys import numpy as np @@ -9,6 +10,9 @@ import time from paddlehub.common.logger import logger import socket from paddle_serving_client import Client +from paddle_serving_client.utils import MultiThreadRunner +from paddle_serving_client.utils import benchmark_args +args = benchmark_args() _ver = sys.version_info is_py2 = (_ver[0] == 2) @@ -122,36 +126,30 @@ class BertService(): return fetch_map_batch -def test(): +def single_func(idx, resource): bc = BertService( model_name='bert_chinese_L-12_H-768_A-12', max_seq_len=20, show_ids=False, do_lower_case=True) - server_addr = ["127.0.0.1:9292"] config_file = './serving_client_conf/serving_client_conf.prototxt' fetch = ["pooled_output"] + server_addr = [resource["endpoint"][idx]] bc.load_client(config_file, server_addr) batch_size = 1 - batch = [] - for line in sys.stdin: - if batch_size == 1: - result = bc.run_general([[line.strip()]], fetch) - print(result) - else: - if len(batch) < batch_size: - batch.append([line.strip()]) - else: - result = bc.run_batch_general(batch, fetch) - batch = [] - for r in result: - print(r) - if len(batch) > 0: - result = bc.run_batch_general(batch, fetch) - batch = [] - for r in result: - print(r) + start = time.time() + fin = open("data-c.txt") + for line in fin: + result = bc.run_general([[line.strip()]], fetch) + end = time.time() + return [[end - start]] if __name__ == '__main__': - test() + multi_thread_runner = MultiThreadRunner() + result = multi_thread_runner.run(single_func, args.thread, { + "endpoint": [ + "127.0.0.1:9494", "127.0.0.1:9495", "127.0.0.1:9496", + "127.0.0.1:9497" + ] + }) diff --git a/python/examples/bert/bert_reader.py b/python/examples/bert/bert_reader.py new file mode 100644 index 0000000000000000000000000000000000000000..366c19b5dc7de7e14979124272329b8ba00fdb3c --- /dev/null +++ b/python/examples/bert/bert_reader.py @@ -0,0 +1,72 @@ +# Copyright (c) 2020 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. +# pylint: disable=doc-string-missing +from batching import pad_batch_data +import tokenization + + +class BertReader(): + def __init__(self, vocab_file="", max_seq_len=128): + self.vocab_file = vocab_file + self.tokenizer = tokenization.FullTokenizer(vocab_file=vocab_file) + self.max_seq_len = max_seq_len + self.vocab = self.tokenizer.vocab + self.pad_id = self.vocab["[PAD]"] + self.cls_id = self.vocab["[CLS]"] + self.sep_id = self.vocab["[SEP]"] + self.mask_id = self.vocab["[MASK]"] + + def pad_batch(self, token_ids, text_type_ids, position_ids): + batch_token_ids = [token_ids] + batch_text_type_ids = [text_type_ids] + batch_position_ids = [position_ids] + + padded_token_ids, input_mask = pad_batch_data( + batch_token_ids, + max_seq_len=self.max_seq_len, + pad_idx=self.pad_id, + return_input_mask=True) + padded_text_type_ids = pad_batch_data( + batch_text_type_ids, + max_seq_len=self.max_seq_len, + pad_idx=self.pad_id) + padded_position_ids = pad_batch_data( + batch_position_ids, + max_seq_len=self.max_seq_len, + pad_idx=self.pad_id) + return padded_token_ids, padded_position_ids, padded_text_type_ids, input_mask + + def process(self, sent): + text_a = tokenization.convert_to_unicode(sent) + tokens_a = self.tokenizer.tokenize(text_a) + if len(tokens_a) > self.max_seq_len - 2: + tokens_a = tokens_a[0:(self.max_seq_len - 2)] + tokens = [] + text_type_ids = [] + tokens.append("[CLS]") + text_type_ids.append(0) + for token in tokens_a: + tokens.append(token) + text_type_ids.append(0) + token_ids = self.tokenizer.convert_tokens_to_ids(tokens) + position_ids = list(range(len(token_ids))) + p_token_ids, p_pos_ids, p_text_type_ids, input_mask = \ + self.pad_batch(token_ids, text_type_ids, position_ids) + feed_result = { + "input_ids": p_token_ids.reshape(-1).tolist(), + "position_ids": p_pos_ids.reshape(-1).tolist(), + "segment_ids": p_text_type_ids.reshape(-1).tolist(), + "input_mask": input_mask.reshape(-1).tolist() + } + return feed_result diff --git a/python/examples/bert/bert_web_service.py b/python/examples/bert/bert_web_service.py new file mode 100644 index 0000000000000000000000000000000000000000..a420b6652b26389a1b6bf10314ac5adb5876d015 --- /dev/null +++ b/python/examples/bert/bert_web_service.py @@ -0,0 +1,38 @@ +# coding=utf-8 +# Copyright (c) 2020 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. +# pylint: disable=doc-string-missing +from paddle_serving_server_gpu.web_service import WebService +from bert_reader import BertReader +import sys +import os + + +class BertService(WebService): + def load(self): + self.reader = BertReader(vocab_file="vocab.txt", max_seq_len=20) + + def preprocess(self, feed={}, fetch=[]): + feed_res = self.reader.process(feed["words"].encode("utf-8")) + return feed_res, fetch + + +bert_service = BertService(name="bert") +bert_service.load() +bert_service.load_model_config(sys.argv[1]) +gpu_ids = os.environ["CUDA_VISIBLE_DEVICES"] +gpus = [int(x) for x in gpu_ids.split(",")] +bert_service.set_gpus(gpus) +bert_service.prepare_server(workdir="workdir", port=9494, device="gpu") +bert_service.run_server() diff --git a/python/examples/bert/prepare_model.py b/python/examples/bert/prepare_model.py index b5f80a78feb07a0617bec3833bbe1cf3884d7dea..70902adf9268d1071c79eb27216dcc2ea9a11a49 100644 --- a/python/examples/bert/prepare_model.py +++ b/python/examples/bert/prepare_model.py @@ -11,14 +11,16 @@ # 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. - +# pylint: disable=doc-string-missing import paddlehub as hub import paddle.fluid as fluid +import sys import paddle_serving_client.io as serving_io model_name = "bert_chinese_L-12_H-768_A-12" module = hub.Module(model_name) -inputs, outputs, program = module.context(trainable=True, max_seq_len=20) +inputs, outputs, program = module.context( + trainable=True, max_seq_len=int(sys.argv[1])) place = fluid.core_avx.CPUPlace() exe = fluid.Executor(place) input_ids = inputs["input_ids"] @@ -34,10 +36,12 @@ feed_var_names = [ target_vars = [pooled_output, sequence_output] -serving_io.save_model("serving_server_model", "serving_client_conf", { - "input_ids": input_ids, - "position_ids": position_ids, - "segment_ids": segment_ids, - "input_mask": input_mask, -}, {"pooled_output": pooled_output, - "sequence_output": sequence_output}, program) +serving_io.save_model( + "bert_seq{}_model".format(sys.argv[1]), + "bert_seq{}_client".format(sys.argv[1]), { + "input_ids": input_ids, + "position_ids": position_ids, + "segment_ids": segment_ids, + "input_mask": input_mask, + }, {"pooled_output": pooled_output, + "sequence_output": sequence_output}, program) diff --git a/python/examples/bert/tokenization.py b/python/examples/bert/tokenization.py new file mode 100644 index 0000000000000000000000000000000000000000..0d84ed38468207e853e5270a59179b4274900cb0 --- /dev/null +++ b/python/examples/bert/tokenization.py @@ -0,0 +1,441 @@ +# coding=utf-8 +# Copyright 2018 The Google AI Language Team Authors. +# +# 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. +"""Tokenization classes.""" + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import collections +import io +import unicodedata +import six +import sentencepiece as spm +import pickle + + +def convert_to_unicode(text): # pylint: disable=doc-string-with-all-args + """Converts `text` to Unicode (if it's not already), assuming utf-8 input.""" + if six.PY3: + if isinstance(text, str): + return text + elif isinstance(text, bytes): + return text.decode("utf-8", "ignore") + else: + raise ValueError("Unsupported string type: %s" % (type(text))) + elif six.PY2: + if isinstance(text, str): + return text.decode("utf-8", "ignore") + elif isinstance(text, unicode): # noqa + return text + else: + raise ValueError("Unsupported string type: %s" % (type(text))) + else: + raise ValueError("Not running on Python2 or Python 3?") + + +def printable_text(text): # pylint: disable=doc-string-with-all-args + """Returns text encoded in a way suitable for print or `tf.logging`.""" + + # These functions want `str` for both Python2 and Python3, but in one case + # it's a Unicode string and in the other it's a byte string. + if six.PY3: + if isinstance(text, str): + return text + elif isinstance(text, bytes): + return text.decode("utf-8", "ignore") + else: + raise ValueError("Unsupported string type: %s" % (type(text))) + elif six.PY2: + if isinstance(text, str): + return text + elif isinstance(text, unicode): # noqa + return text.encode("utf-8") + else: + raise ValueError("Unsupported string type: %s" % (type(text))) + else: + raise ValueError("Not running on Python2 or Python 3?") + + +def load_vocab(vocab_file): # pylint: disable=doc-string-with-all-args, doc-string-with-returns + """Loads a vocabulary file into a dictionary.""" + vocab = collections.OrderedDict() + fin = io.open(vocab_file, "r", encoding="UTF-8") + for num, line in enumerate(fin): + items = convert_to_unicode(line.strip()).split("\t") + if len(items) > 2: + break + token = items[0] + index = items[1] if len(items) == 2 else num + token = token.strip() + vocab[token] = int(index) + fin.close() + return vocab + + +def convert_by_vocab(vocab, items): + """Converts a sequence of [tokens|ids] using the vocab.""" + output = [] + for item in items: + output.append(vocab[item]) + return output + + +def convert_tokens_to_ids(vocab, tokens): + return convert_by_vocab(vocab, tokens) + + +def convert_ids_to_tokens(inv_vocab, ids): + return convert_by_vocab(inv_vocab, ids) + + +def whitespace_tokenize(text): + """Runs basic whitespace cleaning and splitting on a peice of text.""" + text = text.strip() + if not text: + return [] + tokens = text.split() + return tokens + + +class FullTokenizer(object): + """Runs end-to-end tokenziation.""" + + def __init__(self, + vocab_file, + do_lower_case=True, + use_sentence_piece_vocab=False): + self.vocab = load_vocab(vocab_file) + self.inv_vocab = {v: k for k, v in self.vocab.items()} + self.basic_tokenizer = BasicTokenizer(do_lower_case=do_lower_case) + self.use_sentence_piece_vocab = use_sentence_piece_vocab + self.wordpiece_tokenizer = WordpieceTokenizer( + vocab=self.vocab, + use_sentence_piece_vocab=self.use_sentence_piece_vocab) + + def tokenize(self, text): + split_tokens = [] + for token in self.basic_tokenizer.tokenize(text): + for sub_token in self.wordpiece_tokenizer.tokenize(token): + split_tokens.append(sub_token) + + return split_tokens + + def convert_tokens_to_ids(self, tokens): + return convert_by_vocab(self.vocab, tokens) + + def convert_ids_to_tokens(self, ids): + return convert_by_vocab(self.inv_vocab, ids) + + +class CharTokenizer(object): + """Runs end-to-end tokenziation.""" + + def __init__(self, vocab_file, do_lower_case=True): + self.vocab = load_vocab(vocab_file) + self.inv_vocab = {v: k for k, v in self.vocab.items()} + self.wordpiece_tokenizer = WordpieceTokenizer(vocab=self.vocab) + + def tokenize(self, text): + split_tokens = [] + for token in text.lower().split(" "): + for sub_token in self.wordpiece_tokenizer.tokenize(token): + split_tokens.append(sub_token) + + return split_tokens + + def convert_tokens_to_ids(self, tokens): + return convert_by_vocab(self.vocab, tokens) + + def convert_ids_to_tokens(self, ids): + return convert_by_vocab(self.inv_vocab, ids) + + +class WSSPTokenizer(object): # pylint: disable=doc-string-missing + def __init__(self, vocab_file, sp_model_dir, word_dict, ws=True, + lower=True): + self.vocab = load_vocab(vocab_file) + self.inv_vocab = {v: k for k, v in self.vocab.items()} + self.ws = ws + self.lower = lower + self.dict = pickle.load(open(word_dict, 'rb')) + self.sp_model = spm.SentencePieceProcessor() + self.window_size = 5 + self.sp_model.Load(sp_model_dir) + + def cut(self, chars): # pylint: disable=doc-string-missing + words = [] + idx = 0 + while idx < len(chars): + matched = False + for i in range(self.window_size, 0, -1): + cand = chars[idx:idx + i] + if cand in self.dict: + words.append(cand) + matched = True + break + if not matched: + i = 1 + words.append(chars[idx]) + idx += i + return words + + def tokenize(self, text, unk_token="[UNK]"): # pylint: disable=doc-string-missing + text = convert_to_unicode(text) + if self.ws: + text = [s for s in self.cut(text) if s != ' '] + else: + text = text.split(' ') + if self.lower: + text = [s.lower() for s in text] + text = ' '.join(text) + tokens = self.sp_model.EncodeAsPieces(text) + in_vocab_tokens = [] + for token in tokens: + if token in self.vocab: + in_vocab_tokens.append(token) + else: + in_vocab_tokens.append(unk_token) + return in_vocab_tokens + + def convert_tokens_to_ids(self, tokens): + return convert_by_vocab(self.vocab, tokens) + + def convert_ids_to_tokens(self, ids): + return convert_by_vocab(self.inv_vocab, ids) + + +class BasicTokenizer(object): + """Runs basic tokenization (punctuation splitting, lower casing, etc.).""" + + def __init__(self, do_lower_case=True): + """Constructs a BasicTokenizer. + + Args: + do_lower_case: Whether to lower case the input. + """ + self.do_lower_case = do_lower_case + + def tokenize(self, text): # pylint: disable=doc-string-with-all-args, doc-string-with-returns + """Tokenizes a piece of text.""" + text = convert_to_unicode(text) + text = self._clean_text(text) + + # This was added on November 1st, 2018 for the multilingual and Chinese + # models. This is also applied to the English models now, but it doesn't + # matter since the English models were not trained on any Chinese data + # and generally don't have any Chinese data in them (there are Chinese + # characters in the vocabulary because Wikipedia does have some Chinese + # words in the English Wikipedia.). + text = self._tokenize_chinese_chars(text) + + orig_tokens = whitespace_tokenize(text) + split_tokens = [] + for token in orig_tokens: + if self.do_lower_case: + token = token.lower() + token = self._run_strip_accents(token) + split_tokens.extend(self._run_split_on_punc(token)) + + output_tokens = whitespace_tokenize(" ".join(split_tokens)) + return output_tokens + + def _run_strip_accents(self, text): + """Strips accents from a piece of text.""" + text = unicodedata.normalize("NFD", text) + output = [] + for char in text: + cat = unicodedata.category(char) + if cat == "Mn": + continue + output.append(char) + return "".join(output) + + def _run_split_on_punc(self, text): + """Splits punctuation on a piece of text.""" + chars = list(text) + i = 0 + start_new_word = True + output = [] + while i < len(chars): + char = chars[i] + if _is_punctuation(char): + output.append([char]) + start_new_word = True + else: + if start_new_word: + output.append([]) + start_new_word = False + output[-1].append(char) + i += 1 + + return ["".join(x) for x in output] + + def _tokenize_chinese_chars(self, text): + """Adds whitespace around any CJK character.""" + output = [] + for char in text: + cp = ord(char) + if self._is_chinese_char(cp): + output.append(" ") + output.append(char) + output.append(" ") + else: + output.append(char) + return "".join(output) + + def _is_chinese_char(self, cp): + """Checks whether CP is the codepoint of a CJK character.""" + # This defines a "chinese character" as anything in the CJK Unicode block: + # https://en.wikipedia.org/wiki/CJK_Unified_Ideographs_(Unicode_block) + # + # Note that the CJK Unicode block is NOT all Japanese and Korean characters, + # despite its name. The modern Korean Hangul alphabet is a different block, + # as is Japanese Hiragana and Katakana. Those alphabets are used to write + # space-separated words, so they are not treated specially and handled + # like the all of the other languages. + if ((cp >= 0x4E00 and cp <= 0x9FFF) or # + (cp >= 0x3400 and cp <= 0x4DBF) or # + (cp >= 0x20000 and cp <= 0x2A6DF) or # + (cp >= 0x2A700 and cp <= 0x2B73F) or # + (cp >= 0x2B740 and cp <= 0x2B81F) or # + (cp >= 0x2B820 and cp <= 0x2CEAF) or + (cp >= 0xF900 and cp <= 0xFAFF) or # + (cp >= 0x2F800 and cp <= 0x2FA1F)): # + return True + + return False + + def _clean_text(self, text): + """Performs invalid character removal and whitespace cleanup on text.""" + output = [] + for char in text: + cp = ord(char) + if cp == 0 or cp == 0xfffd or _is_control(char): + continue + if _is_whitespace(char): + output.append(" ") + else: + output.append(char) + return "".join(output) + + +class WordpieceTokenizer(object): + """Runs WordPiece tokenziation.""" + + def __init__(self, + vocab, + unk_token="[UNK]", + max_input_chars_per_word=100, + use_sentence_piece_vocab=False): + self.vocab = vocab + self.unk_token = unk_token + self.max_input_chars_per_word = max_input_chars_per_word + self.use_sentence_piece_vocab = use_sentence_piece_vocab + + def tokenize(self, text): # pylint: disable=doc-string-with-all-args + """Tokenizes a piece of text into its word pieces. + + This uses a greedy longest-match-first algorithm to perform tokenization + using the given vocabulary. + + For example: + input = "unaffable" + output = ["un", "##aff", "##able"] + + Args: + text: A single token or whitespace separated tokens. This should have + already been passed through `BasicTokenizer. + + Returns: + A list of wordpiece tokens. + """ + + text = convert_to_unicode(text) + + output_tokens = [] + for token in whitespace_tokenize(text): + chars = list(token) + if len(chars) > self.max_input_chars_per_word: + output_tokens.append(self.unk_token) + continue + + is_bad = False + start = 0 + sub_tokens = [] + while start < len(chars): + end = len(chars) + cur_substr = None + while start < end: + substr = "".join(chars[start:end]) + if start == 0 and self.use_sentence_piece_vocab: + substr = u'\u2581' + substr + if start > 0 and not self.use_sentence_piece_vocab: + substr = "##" + substr + if substr in self.vocab: + cur_substr = substr + break + end -= 1 + if cur_substr is None: + is_bad = True + break + sub_tokens.append(cur_substr) + start = end + + if is_bad: + output_tokens.append(self.unk_token) + else: + output_tokens.extend(sub_tokens) + return output_tokens + + +def _is_whitespace(char): + """Checks whether `chars` is a whitespace character.""" + # \t, \n, and \r are technically contorl characters but we treat them + # as whitespace since they are generally considered as such. + if char == " " or char == "\t" or char == "\n" or char == "\r": + return True + cat = unicodedata.category(char) + if cat == "Zs": + return True + return False + + +def _is_control(char): + """Checks whether `chars` is a control character.""" + # These are technically control characters but we count them as whitespace + # characters. + if char == "\t" or char == "\n" or char == "\r": + return False + cat = unicodedata.category(char) + if cat.startswith("C"): + return True + return False + + +def _is_punctuation(char): + """Checks whether `chars` is a punctuation character.""" + cp = ord(char) + # We treat all non-letter/number ASCII as punctuation. + # Characters such as "^", "$", and "`" are not in the Unicode + # Punctuation class but we treat them as punctuation anyways, for + # consistency. + if ((cp >= 33 and cp <= 47) or (cp >= 58 and cp <= 64) or + (cp >= 91 and cp <= 96) or (cp >= 123 and cp <= 126)): + return True + cat = unicodedata.category(char) + if cat.startswith("P"): + return True + return False diff --git a/python/examples/criteo_ctr/README.md b/python/examples/criteo_ctr/README.md index 3b7743bcebe9872881c9f9e73c77c97ea3a6dbb0..7a9947941538dd026fc0bc2b1965df0cdbb8e41b 100644 --- a/python/examples/criteo_ctr/README.md +++ b/python/examples/criteo_ctr/README.md @@ -1,2 +1 @@ # CTR task on Criteo Dataset - diff --git a/python/examples/criteo_ctr/args.py b/python/examples/criteo_ctr/args.py index a30398e33de4618282988bc2dc990a3a099a91b7..30124d4ebd9cd27cdb4580e654a8a47c55b178bf 100644 --- a/python/examples/criteo_ctr/args.py +++ b/python/examples/criteo_ctr/args.py @@ -1,90 +1,105 @@ +# Copyright (c) 2020 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. +# pylint: disable=doc-string-missing import argparse + def parse_args(): - parser = argparse.ArgumentParser(description="PaddlePaddle CTR example") - parser.add_argument( - '--train_data_path', - type=str, - default='./data/raw/train.txt', - help="The path of training dataset") - parser.add_argument( - '--sparse_only', - type=bool, - default=False, - help="Whether we use sparse features only") - parser.add_argument( - '--test_data_path', - type=str, - default='./data/raw/valid.txt', - help="The path of testing dataset") - parser.add_argument( - '--batch_size', - type=int, - default=1000, - help="The size of mini-batch (default:1000)") - parser.add_argument( - '--embedding_size', - type=int, - default=10, - help="The size for embedding layer (default:10)") - parser.add_argument( - '--num_passes', - type=int, - default=10, - help="The number of passes to train (default: 10)") - parser.add_argument( - '--model_output_dir', - type=str, - default='models', - help='The path for model to store (default: models)') - parser.add_argument( - '--sparse_feature_dim', - type=int, - default=1000001, - help='sparse feature hashing space for index processing') - parser.add_argument( - '--is_local', - type=int, - default=1, - help='Local train or distributed train (default: 1)') - parser.add_argument( - '--cloud_train', - type=int, - default=0, - help='Local train or distributed train on paddlecloud (default: 0)') - parser.add_argument( - '--async_mode', - action='store_true', - default=False, - help='Whether start pserver in async mode to support ASGD') - parser.add_argument( - '--no_split_var', - action='store_true', - default=False, - help='Whether split variables into blocks when update_method is pserver') - parser.add_argument( - '--role', - type=str, - default='pserver', # trainer or pserver - help='The path for model to store (default: models)') - parser.add_argument( - '--endpoints', - type=str, - default='127.0.0.1:6000', - help='The pserver endpoints, like: 127.0.0.1:6000,127.0.0.1:6001') - parser.add_argument( - '--current_endpoint', - type=str, - default='127.0.0.1:6000', - help='The path for model to store (default: 127.0.0.1:6000)') - parser.add_argument( - '--trainer_id', - type=int, - default=0, - help='The path for model to store (default: models)') - parser.add_argument( - '--trainers', - type=int, - default=1, - help='The num of trianers, (default: 1)') - return parser.parse_args() + parser = argparse.ArgumentParser(description="PaddlePaddle CTR example") + parser.add_argument( + '--train_data_path', + type=str, + default='./data/raw/train.txt', + help="The path of training dataset") + parser.add_argument( + '--sparse_only', + type=bool, + default=False, + help="Whether we use sparse features only") + parser.add_argument( + '--test_data_path', + type=str, + default='./data/raw/valid.txt', + help="The path of testing dataset") + parser.add_argument( + '--batch_size', + type=int, + default=1000, + help="The size of mini-batch (default:1000)") + parser.add_argument( + '--embedding_size', + type=int, + default=10, + help="The size for embedding layer (default:10)") + parser.add_argument( + '--num_passes', + type=int, + default=10, + help="The number of passes to train (default: 10)") + parser.add_argument( + '--model_output_dir', + type=str, + default='models', + help='The path for model to store (default: models)') + parser.add_argument( + '--sparse_feature_dim', + type=int, + default=1000001, + help='sparse feature hashing space for index processing') + parser.add_argument( + '--is_local', + type=int, + default=1, + help='Local train or distributed train (default: 1)') + parser.add_argument( + '--cloud_train', + type=int, + default=0, + help='Local train or distributed train on paddlecloud (default: 0)') + parser.add_argument( + '--async_mode', + action='store_true', + default=False, + help='Whether start pserver in async mode to support ASGD') + parser.add_argument( + '--no_split_var', + action='store_true', + default=False, + help='Whether split variables into blocks when update_method is pserver') + parser.add_argument( + '--role', + type=str, + default='pserver', # trainer or pserver + help='The path for model to store (default: models)') + parser.add_argument( + '--endpoints', + type=str, + default='127.0.0.1:6000', + help='The pserver endpoints, like: 127.0.0.1:6000,127.0.0.1:6001') + parser.add_argument( + '--current_endpoint', + type=str, + default='127.0.0.1:6000', + help='The path for model to store (default: 127.0.0.1:6000)') + parser.add_argument( + '--trainer_id', + type=int, + default=0, + help='The path for model to store (default: models)') + parser.add_argument( + '--trainers', + type=int, + default=1, + help='The num of trianers, (default: 1)') + return parser.parse_args() diff --git a/python/examples/criteo_ctr/criteo_reader.py b/python/examples/criteo_ctr/criteo_reader.py index 06f90d275d083e0c7cc915d718fa5368a783ee7a..2a80af78a9c2033bf246f703ca70a817ab786af3 100644 --- a/python/examples/criteo_ctr/criteo_reader.py +++ b/python/examples/criteo_ctr/criteo_reader.py @@ -1,11 +1,31 @@ +# Copyright (c) 2020 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. +# pylint: disable=doc-string-missing + import sys import paddle.fluid.incubate.data_generator as dg + class CriteoDataset(dg.MultiSlotDataGenerator): def setup(self, sparse_feature_dim): self.cont_min_ = [0, -3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] - self.cont_max_ = [20, 600, 100, 50, 64000, 500, 100, 50, 500, 10, 10, 10, 50] - self.cont_diff_ = [20, 603, 100, 50, 64000, 500, 100, 50, 500, 10, 10, 10, 50] + self.cont_max_ = [ + 20, 600, 100, 50, 64000, 500, 100, 50, 500, 10, 10, 10, 50 + ] + self.cont_diff_ = [ + 20, 603, 100, 50, 64000, 500, 100, 50, 500, 10, 10, 10, 50 + ] self.hash_dim_ = sparse_feature_dim # here, training data are lines with line_index < train_idx_ self.train_idx_ = 41256555 @@ -23,8 +43,9 @@ class CriteoDataset(dg.MultiSlotDataGenerator): dense_feature.append((float(features[idx]) - self.cont_min_[idx - 1]) / \ self.cont_diff_[idx - 1]) for idx in self.categorical_range_: - sparse_feature.append([hash(str(idx) + features[idx]) % self.hash_dim_]) - + sparse_feature.append( + [hash(str(idx) + features[idx]) % self.hash_dim_]) + return dense_feature, sparse_feature, [int(features[0])] def infer_reader(self, filelist, batch, buf_size): @@ -32,16 +53,17 @@ class CriteoDataset(dg.MultiSlotDataGenerator): for fname in filelist: with open(fname.strip(), "r") as fin: for line in fin: - dense_feature, sparse_feature, label = self._process_line(line) + dense_feature, sparse_feature, label = self._process_line( + line) #yield dense_feature, sparse_feature, label yield [dense_feature] + sparse_feature + [label] + import paddle batch_iter = paddle.batch( paddle.reader.shuffle( local_iter, buf_size=buf_size), batch_size=batch) return batch_iter - def generate_sample(self, line): def data_iter(): @@ -54,6 +76,7 @@ class CriteoDataset(dg.MultiSlotDataGenerator): return data_iter + if __name__ == "__main__": criteo_dataset = CriteoDataset() criteo_dataset.setup(int(sys.argv[1])) diff --git a/python/examples/criteo_ctr/local_train.py b/python/examples/criteo_ctr/local_train.py index a3cf57c8df68fa8b943b1e754141fdaa4c786eb7..bbc940750c5f608b47300a9a33f9e48bfb4344b1 100644 --- a/python/examples/criteo_ctr/local_train.py +++ b/python/examples/criteo_ctr/local_train.py @@ -1,3 +1,18 @@ +# Copyright (c) 2020 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. +# pylint: disable=doc-string-missing + from __future__ import print_function from args import parse_args @@ -17,15 +32,17 @@ def train(): dense_input = fluid.layers.data( name="dense_input", shape=[dense_feature_dim], dtype='float32') sparse_input_ids = [ - fluid.layers.data(name="C" + str(i), shape=[1], lod_level=1, dtype="int64") - for i in range(1, 27)] + fluid.layers.data( + name="C" + str(i), shape=[1], lod_level=1, dtype="int64") + for i in range(1, 27) + ] label = fluid.layers.data(name='label', shape=[1], dtype='int64') #nn_input = None if sparse_only else dense_input nn_input = dense_input predict_y, loss, auc_var, batch_auc_var = dnn_model( - nn_input, sparse_input_ids, label, - args.embedding_size, args.sparse_feature_dim) + nn_input, sparse_input_ids, label, args.embedding_size, + args.sparse_feature_dim) optimizer = fluid.optimizer.SGD(learning_rate=1e-4) optimizer.minimize(loss) @@ -36,16 +53,17 @@ def train(): dataset.set_use_var([dense_input] + sparse_input_ids + [label]) python_executable = "python" - pipe_command = "{} criteo_reader.py {}".format( - python_executable, args.sparse_feature_dim) + pipe_command = "{} criteo_reader.py {}".format(python_executable, + args.sparse_feature_dim) dataset.set_pipe_command(pipe_command) dataset.set_batch_size(128) thread_num = 10 dataset.set_thread(thread_num) - whole_filelist = ["raw_data/part-%d" % x for x in - range(len(os.listdir("raw_data")))] + whole_filelist = [ + "raw_data/part-%d" % x for x in range(len(os.listdir("raw_data"))) + ] dataset.set_filelist(whole_filelist[:thread_num]) dataset.load_into_memory() @@ -53,8 +71,7 @@ def train(): epochs = 1 for i in range(epochs): exe.train_from_dataset( - program=fluid.default_main_program(), - dataset=dataset, debug=True) + program=fluid.default_main_program(), dataset=dataset, debug=True) print("epoch {} finished".format(i)) import paddle_serving_client.io as server_io @@ -63,9 +80,9 @@ def train(): feed_var_dict["sparse_{}".format(i)] = sparse fetch_var_dict = {"prob": predict_y} - server_io.save_model( - "ctr_serving_model", "ctr_client_conf", - feed_var_dict, fetch_var_dict, fluid.default_main_program()) + server_io.save_model("ctr_serving_model", "ctr_client_conf", feed_var_dict, + fetch_var_dict, fluid.default_main_program()) + if __name__ == '__main__': train() diff --git a/python/examples/criteo_ctr/network_conf.py b/python/examples/criteo_ctr/network_conf.py index 429921da0f11edd2fe5296667271135ce53a5808..ec5eb7d55ab59965e474842015301b3a9088d91e 100644 --- a/python/examples/criteo_ctr/network_conf.py +++ b/python/examples/criteo_ctr/network_conf.py @@ -1,17 +1,33 @@ +# Copyright (c) 2020 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. +# pylint: disable=doc-string-missing + import paddle.fluid as fluid import math -def dnn_model(dense_input, sparse_inputs, label, - embedding_size, sparse_feature_dim): +def dnn_model(dense_input, sparse_inputs, label, embedding_size, + sparse_feature_dim): def embedding_layer(input): emb = fluid.layers.embedding( input=input, is_sparse=True, is_distributed=False, size=[sparse_feature_dim, embedding_size], - param_attr=fluid.ParamAttr(name="SparseFeatFactors", - initializer=fluid.initializer.Uniform())) + param_attr=fluid.ParamAttr( + name="SparseFeatFactors", + initializer=fluid.initializer.Uniform())) return fluid.layers.sequence_pool(input=emb, pool_type='sum') def mlp_input_tensor(emb_sums, dense_tensor): @@ -21,18 +37,30 @@ def dnn_model(dense_input, sparse_inputs, label, return fluid.layers.concat(emb_sums + [dense_tensor], axis=1) def mlp(mlp_input): - fc1 = fluid.layers.fc(input=mlp_input, size=400, act='relu', - param_attr=fluid.ParamAttr(initializer=fluid.initializer.Normal( - scale=1 / math.sqrt(mlp_input.shape[1])))) - fc2 = fluid.layers.fc(input=fc1, size=400, act='relu', - param_attr=fluid.ParamAttr(initializer=fluid.initializer.Normal( - scale=1 / math.sqrt(fc1.shape[1])))) - fc3 = fluid.layers.fc(input=fc2, size=400, act='relu', - param_attr=fluid.ParamAttr(initializer=fluid.initializer.Normal( - scale=1 / math.sqrt(fc2.shape[1])))) - pre = fluid.layers.fc(input=fc3, size=2, act='softmax', - param_attr=fluid.ParamAttr(initializer=fluid.initializer.Normal( - scale=1 / math.sqrt(fc3.shape[1])))) + fc1 = fluid.layers.fc(input=mlp_input, + size=400, + act='relu', + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Normal( + scale=1 / math.sqrt(mlp_input.shape[1])))) + fc2 = fluid.layers.fc(input=fc1, + size=400, + act='relu', + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Normal( + scale=1 / math.sqrt(fc1.shape[1])))) + fc3 = fluid.layers.fc(input=fc2, + size=400, + act='relu', + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Normal( + scale=1 / math.sqrt(fc2.shape[1])))) + pre = fluid.layers.fc(input=fc3, + size=2, + act='softmax', + param_attr=fluid.ParamAttr( + initializer=fluid.initializer.Normal( + scale=1 / math.sqrt(fc3.shape[1])))) return pre emb_sums = list(map(embedding_layer, sparse_inputs)) diff --git a/python/examples/criteo_ctr/test_client.py b/python/examples/criteo_ctr/test_client.py index 71bbb8365de65a256b9fcdb834ef7e885a5e63f4..40111928fa3d2be3a86af065b88af8b9549744ff 100644 --- a/python/examples/criteo_ctr/test_client.py +++ b/python/examples/criteo_ctr/test_client.py @@ -1,3 +1,18 @@ +# Copyright (c) 2020 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. +# pylint: disable=doc-string-missing + from paddle_serving_client import Client import paddle import sys @@ -13,9 +28,12 @@ batch = 1 buf_size = 100 dataset = criteo.CriteoDataset() dataset.setup(1000001) -test_filelists = ["{}/part-%d".format(sys.argv[2]) % x - for x in range(len(os.listdir(sys.argv[2])))] -reader = dataset.infer_reader(test_filelists[len(test_filelists)-40:], batch, buf_size) +test_filelists = [ + "{}/part-%d".format(sys.argv[2]) % x + for x in range(len(os.listdir(sys.argv[2]))) +] +reader = dataset.infer_reader(test_filelists[len(test_filelists) - 40:], batch, + buf_size) label_list = [] prob_list = [] @@ -25,4 +43,3 @@ for data in reader(): feed_dict["sparse_{}".format(i - 1)] = data[0][i] fetch_map = client.predict(feed=feed_dict, fetch=["prob"]) print(fetch_map) - diff --git a/python/examples/criteo_ctr/test_server.py b/python/examples/criteo_ctr/test_server.py index 984001084a3c8691092be69a163a9f78515127a6..34f859daab4c808aa9d50d2109a81a69eed96df6 100644 --- a/python/examples/criteo_ctr/test_server.py +++ b/python/examples/criteo_ctr/test_server.py @@ -1,3 +1,18 @@ +# Copyright (c) 2020 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. +# pylint: disable=doc-string-missing + import os import sys from paddle_serving_server import OpMaker diff --git a/python/examples/fit_a_line/README.md b/python/examples/fit_a_line/README.md index fedd40891c1f128b3eac93d71de2c88ba23bd2d9..da0ec8f3564577c76134325c4d943a8fecaeaa55 100644 --- a/python/examples/fit_a_line/README.md +++ b/python/examples/fit_a_line/README.md @@ -19,4 +19,4 @@ python -m paddle_serving_server.web_serve --model uci_housing_model/ --thread 10 Prediction through http post ``` shell curl -H "Content-Type:application/json" -X POST -d '{"x": [0.0137, -0.1136, 0.2553, -0.0692, 0.0582, -0.0727, -0.1583, -0.0584, 0.6283, 0.4919, 0.1856, 0.0795, -0.0332], "fetch":["price"]}' http://127.0.0.1:9393/uci/prediction -``` \ No newline at end of file +``` diff --git a/python/examples/fit_a_line/benchmark.py b/python/examples/fit_a_line/benchmark.py index b68d37e6e1e9166e01730427324c8743bd8dc08e..0ddda2a095eb8542887ea592a79b16665f2daa15 100644 --- a/python/examples/fit_a_line/benchmark.py +++ b/python/examples/fit_a_line/benchmark.py @@ -11,6 +11,8 @@ # 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. +# pylint: disable=doc-string-missing + from paddle_serving_client import Client from paddle_serving_client.utils import MultiThreadRunner from paddle_serving_client.utils import benchmark_args @@ -21,28 +23,35 @@ import requests args = benchmark_args() + def single_func(idx, resource): if args.request == "rpc": client = Client() client.load_client_config(args.model) client.connect([args.endpoint]) - train_reader = paddle.batch(paddle.reader.shuffle( - paddle.dataset.uci_housing.train(), buf_size=500), batch_size=1) + train_reader = paddle.batch( + paddle.reader.shuffle( + paddle.dataset.uci_housing.train(), buf_size=500), + batch_size=1) start = time.time() for data in train_reader(): fetch_map = client.predict(feed={"x": data[0][0]}, fetch=["price"]) end = time.time() return [[end - start]] elif args.request == "http": - train_reader = paddle.batch(paddle.reader.shuffle( - paddle.dataset.uci_housing.train(), buf_size=500), batch_size=1) + train_reader = paddle.batch( + paddle.reader.shuffle( + paddle.dataset.uci_housing.train(), buf_size=500), + batch_size=1) start = time.time() for data in train_reader(): - r = requests.post('http://{}/uci/prediction'.format(args.endpoint), - data = {"x": data[0]}) + r = requests.post( + 'http://{}/uci/prediction'.format(args.endpoint), + data={"x": data[0]}) end = time.time() return [[end - start]] + multi_thread_runner = MultiThreadRunner() result = multi_thread_runner.run(single_func, args.thread, {}) print(result) diff --git a/python/examples/fit_a_line/local_train.py b/python/examples/fit_a_line/local_train.py index fae6f72c7ddbd6d0d0e7c6742d1234ae4f6398cb..900b4a674a96434f4e848d1d4fd8f2ebed79f148 100644 --- a/python/examples/fit_a_line/local_train.py +++ b/python/examples/fit_a_line/local_train.py @@ -1,12 +1,31 @@ +# Copyright (c) 2020 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. +# pylint: disable=doc-string-missing + import sys import paddle import paddle.fluid as fluid -train_reader = paddle.batch(paddle.reader.shuffle( - paddle.dataset.uci_housing.train(), buf_size=500), batch_size=16) +train_reader = paddle.batch( + paddle.reader.shuffle( + paddle.dataset.uci_housing.train(), buf_size=500), + batch_size=16) -test_reader = paddle.batch(paddle.reader.shuffle( - paddle.dataset.uci_housing.test(), buf_size=500), batch_size=16) +test_reader = paddle.batch( + paddle.reader.shuffle( + paddle.dataset.uci_housing.test(), buf_size=500), + batch_size=16) x = fluid.data(name='x', shape=[None, 13], dtype='float32') y = fluid.data(name='y', shape=[None, 1], dtype='float32') @@ -26,11 +45,9 @@ import paddle_serving_client.io as serving_io for pass_id in range(30): for data_train in train_reader(): - avg_loss_value, = exe.run( - fluid.default_main_program(), - feed=feeder.feed(data_train), - fetch_list=[avg_loss]) - -serving_io.save_model( - "uci_housing_model", "uci_housing_client", - {"x": x}, {"price": y_predict}, fluid.default_main_program()) + avg_loss_value, = exe.run(fluid.default_main_program(), + feed=feeder.feed(data_train), + fetch_list=[avg_loss]) + +serving_io.save_model("uci_housing_model", "uci_housing_client", {"x": x}, + {"price": y_predict}, fluid.default_main_program()) diff --git a/python/examples/fit_a_line/test_client.py b/python/examples/fit_a_line/test_client.py index 21e662ed9efed389a4e04259e989bfba8c0fa922..442ed230bc3d75c9ec3b5eac160b3a53ac31cd83 100644 --- a/python/examples/fit_a_line/test_client.py +++ b/python/examples/fit_a_line/test_client.py @@ -1,15 +1,31 @@ +# Copyright (c) 2020 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. +# pylint: disable=doc-string-missing + from paddle_serving_client import Client -import paddle import sys client = Client() client.load_client_config(sys.argv[1]) client.connect(["127.0.0.1:9393"]) -test_reader = paddle.batch(paddle.reader.shuffle( - paddle.dataset.uci_housing.test(), buf_size=500), batch_size=1) +import paddle +test_reader = paddle.batch( + paddle.reader.shuffle( + paddle.dataset.uci_housing.test(), buf_size=500), + batch_size=1) for data in test_reader(): fetch_map = client.predict(feed={"x": data[0][0]}, fetch=["price"]) print("{} {}".format(fetch_map["price"][0], data[0][1][0])) - diff --git a/python/examples/fit_a_line/test_server.py b/python/examples/fit_a_line/test_server.py index 7f90f18cb9d879947d677b73a0278ada1372dad0..3293be0610e497aa91fbf902e0045bdf907f0efc 100644 --- a/python/examples/fit_a_line/test_server.py +++ b/python/examples/fit_a_line/test_server.py @@ -1,3 +1,18 @@ +# Copyright (c) 2020 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. +# pylint: disable=doc-string-missing + import os import sys from paddle_serving_server import OpMaker diff --git a/python/examples/imdb/benchmark.py b/python/examples/imdb/benchmark.py index 1254ed21fd8ff30acdb9e8192b26b7918da315bc..05459257ef1bd231b41f8239cc42739e2299d72f 100644 --- a/python/examples/imdb/benchmark.py +++ b/python/examples/imdb/benchmark.py @@ -11,6 +11,7 @@ # 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. +# pylint: disable=doc-string-missing import sys import time @@ -22,6 +23,7 @@ from paddle_serving_client.utils import benchmark_args args = benchmark_args() + def single_func(idx, resource): imdb_dataset = IMDBDataset() imdb_dataset.load_resource(args.vocab) @@ -40,18 +42,21 @@ def single_func(idx, resource): fin = open(fn) for line in fin: word_ids, label = imdb_dataset.get_words_and_label(line) - fetch_map = client.predict(feed={"words": word_ids}, - fetch=["prediction"]) + fetch_map = client.predict( + feed={"words": word_ids}, fetch=["prediction"]) elif args.request == "http": for fn in filelist: fin = open(fn) for line in fin: word_ids, label = imdb_dataset.get_words_and_label(line) - r = requests.post("http://{}/imdb/prediction".format(args.endpoint), - data={"words": word_ids}) + r = requests.post( + "http://{}/imdb/prediction".format(args.endpoint), + data={"words": word_ids, + "fetch": ["prediction"]}) end = time.time() return [[end - start]] + multi_thread_runner = MultiThreadRunner() result = multi_thread_runner.run(single_func, args.thread, {}) print(result) diff --git a/python/examples/imdb/imdb_reader.py b/python/examples/imdb/imdb_reader.py index cad28ab2cdcc2983bb74bc721ec837b0b6e5fe88..38a46c5cf3cc3d7216c47c290876951e99253115 100644 --- a/python/examples/imdb/imdb_reader.py +++ b/python/examples/imdb/imdb_reader.py @@ -11,6 +11,7 @@ # 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. +# pylint: disable=doc-string-missing import sys import os @@ -18,6 +19,7 @@ import paddle import re import paddle.fluid.incubate.data_generator as dg + class IMDBDataset(dg.MultiSlotDataGenerator): def load_resource(self, dictfile): self._vocab = {} @@ -42,7 +44,7 @@ class IMDBDataset(dg.MultiSlotDataGenerator): send = '|'.join(line.split('|')[:-1]).lower().replace("
", " ").strip() label = [int(line.split('|')[-1])] - + words = [x for x in self._pattern.split(send) if x and x != " "] feas = [ self._vocab[x] if x in self._vocab else self._unk_id for x in words @@ -56,9 +58,11 @@ class IMDBDataset(dg.MultiSlotDataGenerator): for line in fin: feas, label = self.get_words_and_label(line) yield feas, label + import paddle batch_iter = paddle.batch( - paddle.reader.shuffle(local_iter, buf_size=buf_size), + paddle.reader.shuffle( + local_iter, buf_size=buf_size), batch_size=batch) return batch_iter @@ -66,13 +70,15 @@ class IMDBDataset(dg.MultiSlotDataGenerator): def memory_iter(): for i in range(1000): yield self.return_value + def data_iter(): feas, label = self.get_words_and_label(line) yield ("words", feas), ("label", label) + return data_iter + if __name__ == "__main__": imdb = IMDBDataset() imdb.load_resource("imdb.vocab") imdb.run_from_stdin() - diff --git a/python/examples/imdb/imdb_web_service_demo.sh b/python/examples/imdb/imdb_web_service_demo.sh index 0b69a3532b7e8a924c5b19eb7e483e63226ee945..05d1b729c64359025119e443ed601c902a87ae4d 100644 --- a/python/examples/imdb/imdb_web_service_demo.sh +++ b/python/examples/imdb/imdb_web_service_demo.sh @@ -3,4 +3,3 @@ tar -xzf imdb_service.tar.gz wget --no-check-certificate https://fleet.bj.bcebos.com/text_classification_data.tar.gz tar -zxvf text_classification_data.tar.gz python text_classify_service.py serving_server_model/ workdir imdb.vocab - diff --git a/python/examples/imdb/local_train.py b/python/examples/imdb/local_train.py index 53692298a2b4caefb92f0a686bd020feaf3fa168..b5b460732a916de73c3af86ca2abd3c002287773 100644 --- a/python/examples/imdb/local_train.py +++ b/python/examples/imdb/local_train.py @@ -11,6 +11,7 @@ # 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. +# pylint: disable=doc-string-missing import os import sys import paddle diff --git a/python/examples/imdb/nets.py b/python/examples/imdb/nets.py index 3b451d16bca7aca1b505a464fe85bcf0568964c6..4f2d2af6a60e97ba6c23897041a987bf26d430c7 100644 --- a/python/examples/imdb/nets.py +++ b/python/examples/imdb/nets.py @@ -1,3 +1,18 @@ +# Copyright (c) 2020 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. +# pylint: disable=doc-string-missing, doc-string-with-all-args, doc-string-with-returns + import sys import time import numpy as np @@ -13,10 +28,9 @@ def bow_net(data, hid_dim=128, hid_dim2=96, class_dim=2): - """ - bow net - """ - emb = fluid.layers.embedding(input=data, size=[dict_dim, emb_dim], is_sparse=True) + """ bow net. """ + emb = fluid.layers.embedding( + input=data, size=[dict_dim, emb_dim], is_sparse=True) bow = fluid.layers.sequence_pool(input=emb, pool_type='sum') bow_tanh = fluid.layers.tanh(bow) fc_1 = fluid.layers.fc(input=bow_tanh, size=hid_dim, act="tanh") @@ -37,10 +51,9 @@ def cnn_net(data, hid_dim2=96, class_dim=2, win_size=3): - """ - conv net - """ - emb = fluid.layers.embedding(input=data, size=[dict_dim, emb_dim], is_sparse=True) + """ conv net. """ + emb = fluid.layers.embedding( + input=data, size=[dict_dim, emb_dim], is_sparse=True) conv_3 = fluid.nets.sequence_conv_pool( input=emb, @@ -67,9 +80,7 @@ def lstm_net(data, hid_dim2=96, class_dim=2, emb_lr=30.0): - """ - lstm net - """ + """ lstm net. """ emb = fluid.layers.embedding( input=data, size=[dict_dim, emb_dim], @@ -103,9 +114,7 @@ def gru_net(data, hid_dim2=96, class_dim=2, emb_lr=400.0): - """ - gru net - """ + """ gru net. """ emb = fluid.layers.embedding( input=data, size=[dict_dim, emb_dim], diff --git a/python/examples/imdb/test_client.py b/python/examples/imdb/test_client.py index bb0b9790669173abf2761a5d900dce15d91a5d71..a938de196f9e12d0a5f66cae1ff53f3e3e615162 100644 --- a/python/examples/imdb/test_client.py +++ b/python/examples/imdb/test_client.py @@ -11,6 +11,7 @@ # 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. +# pylint: disable=doc-string-missing from paddle_serving_client import Client from imdb_reader import IMDBDataset import sys @@ -31,4 +32,3 @@ for line in sys.stdin: fetch = ["acc", "cost", "prediction"] fetch_map = client.predict(feed=feed, fetch=fetch) print("{} {}".format(fetch_map["prediction"][1], label[0])) - diff --git a/python/examples/imdb/test_client_batch.py b/python/examples/imdb/test_client_batch.py index 76de78106e04d78dc64edb728440ea0c974dc102..972b2c9609ca690542fa802f187fb30ed0467a04 100644 --- a/python/examples/imdb/test_client_batch.py +++ b/python/examples/imdb/test_client_batch.py @@ -11,6 +11,7 @@ # 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. +# pylint: disable=doc-string-missing from paddle_serving_client import Client import sys diff --git a/python/examples/imdb/text_classify_service.py b/python/examples/imdb/text_classify_service.py index 8a6836f0646c5d2bbeeb672c28f16486f6bdd8c2..33399360b2da0fabba9084f2a9088e30571f10a3 100755 --- a/python/examples/imdb/text_classify_service.py +++ b/python/examples/imdb/text_classify_service.py @@ -11,17 +11,20 @@ # 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. +# pylint: disable=doc-string-missing + from paddle_serving_server.web_service import WebService from imdb_reader import IMDBDataset import sys + class IMDBService(WebService): def prepare_dict(self, args={}): if len(args) == 0: exit(-1) self.dataset = IMDBDataset() self.dataset.load_resource(args["dict_file_path"]) - + def preprocess(self, feed={}, fetch=[]): if "words" not in feed: exit(-1) @@ -29,8 +32,9 @@ class IMDBService(WebService): res_feed["words"] = self.dataset.get_words_only(feed["words"])[0] return res_feed, fetch + imdb_service = IMDBService(name="imdb") imdb_service.load_model_config(sys.argv[1]) imdb_service.prepare_server(workdir=sys.argv[2], port=9393, device="cpu") -imdb_service.prepare_dict({"dict_file_path":sys.argv[3]}) +imdb_service.prepare_dict({"dict_file_path": sys.argv[3]}) imdb_service.run_server() diff --git a/python/examples/util/get_acc.py b/python/examples/util/get_acc.py index ce4885a657365ee09c69f98ca7675fdc68fbf7a3..91796478eaabdbcee89985660521b388d43a0065 100644 --- a/python/examples/util/get_acc.py +++ b/python/examples/util/get_acc.py @@ -1,3 +1,18 @@ +# Copyright (c) 2020 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. +# pylint: disable=doc-string-missing + import sys import os diff --git a/python/paddle_serving_client/__init__.py b/python/paddle_serving_client/__init__.py index bea80f84bc9d29cabe4f31af612c694980b71d09..c77034b5ce9c811d3a5b0c42701b191870ffe45c 100644 --- a/python/paddle_serving_client/__init__.py +++ b/python/paddle_serving_client/__init__.py @@ -199,6 +199,7 @@ class Client(object): float_feed_names = [] fetch_names = [] counter = 0 + batch_size = len(feed_batch) for feed in feed_batch: int_slot = [] float_slot = [] @@ -221,15 +222,21 @@ class Client(object): if key in self.fetch_names_: fetch_names.append(key) - result_batch = self.client_handle_.batch_predict( + result_batch = self.result_handle_ + res = self.client_handle_.batch_predict( float_slot_batch, float_feed_names, int_slot_batch, int_feed_names, - fetch_names) + fetch_names, result_batch, self.pid) result_map_batch = [] - for result in result_batch: + for index in range(batch_size): result_map = {} for i, name in enumerate(fetch_names): - result_map[name] = result[i] + if self.fetch_names_to_type_[name] == int_type: + result_map[name] = result_batch.get_int64_by_name(name)[ + index] + elif self.fetch_names_to_type_[name] == float_type: + result_map[name] = result_batch.get_float_by_name(name)[ + index] result_map_batch.append(result_map) return result_map_batch diff --git a/python/paddle_serving_client/io/__init__.py b/python/paddle_serving_client/io/__init__.py index 347240d608aa3c00bc4a3543cd2430842c249533..f1a3dcf612e34d83387163d9fea491a7dca2c579 100644 --- a/python/paddle_serving_client/io/__init__.py +++ b/python/paddle_serving_client/io/__init__.py @@ -11,6 +11,7 @@ # 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. +# pylint: disable=doc-string-missing from paddle.fluid import Executor from paddle.fluid.compiler import CompiledProgram @@ -22,6 +23,7 @@ from paddle.fluid.io import save_inference_model from ..proto import general_model_config_pb2 as model_conf import os + def save_model(server_model_folder, client_config_folder, feed_var_dict, @@ -32,8 +34,12 @@ def save_model(server_model_folder, feed_var_names = [feed_var_dict[x].name for x in feed_var_dict] target_vars = fetch_var_dict.values() - save_inference_model(server_model_folder, feed_var_names, - target_vars, executor, main_program=main_program) + save_inference_model( + server_model_folder, + feed_var_names, + target_vars, + executor, + main_program=main_program) config = model_conf.GeneralModelConfig() @@ -67,7 +73,7 @@ def save_model(server_model_folder, fetch_var.fetch_type = 0 if fetch_var_dict[key].dtype == core.VarDesc.VarType.FP32: - fetch_var.fetch_type = 1 + fetch_var.fetch_type = 1 if fetch_var.is_lod_tensor: fetch_var.shape.extend([-1]) @@ -82,15 +88,15 @@ def save_model(server_model_folder, cmd = "mkdir -p {}".format(client_config_folder) os.system(cmd) - with open("{}/serving_client_conf.prototxt".format(client_config_folder), "w") as fout: + with open("{}/serving_client_conf.prototxt".format(client_config_folder), + "w") as fout: fout.write(str(config)) - with open("{}/serving_server_conf.prototxt".format(server_model_folder), "w") as fout: + with open("{}/serving_server_conf.prototxt".format(server_model_folder), + "w") as fout: fout.write(str(config)) - with open("{}/serving_client_conf.stream.prototxt".format(client_config_folder), "wb") as fout: + with open("{}/serving_client_conf.stream.prototxt".format( + client_config_folder), "wb") as fout: fout.write(config.SerializeToString()) - with open("{}/serving_server_conf.stream.prototxt".format(server_model_folder), "wb") as fout: + with open("{}/serving_server_conf.stream.prototxt".format( + server_model_folder), "wb") as fout: fout.write(config.SerializeToString()) - - - - diff --git a/python/paddle_serving_client/metric/acc.py b/python/paddle_serving_client/metric/acc.py index d1f4329679b6c8d68ae80b08d9da2d57790a87ab..b225b4ec62373ae4003bae67aaf6e14a89204337 100644 --- a/python/paddle_serving_client/metric/acc.py +++ b/python/paddle_serving_client/metric/acc.py @@ -11,6 +11,8 @@ # 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. +# pylint: disable=doc-string-missing + def acc(prob, label, threshold): # we support prob is the probability for label to be one @@ -21,5 +23,3 @@ def acc(prob, label, threshold): if (prob - threshold) * (label - prob) > 0: right += 1 return float(right) / total - - diff --git a/python/paddle_serving_client/metric/auc.py b/python/paddle_serving_client/metric/auc.py index 8b021cff3a4276f624721aed1b44a43ef09abd3f..ebd77fb5c6d3b009a6bfd925624526c2f2afd41d 100644 --- a/python/paddle_serving_client/metric/auc.py +++ b/python/paddle_serving_client/metric/auc.py @@ -11,6 +11,8 @@ # 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. +# pylint: disable=doc-string-missing, doc-string-with-all-args, doc-string-with-returns + def tied_rank(x): """ @@ -24,21 +26,22 @@ def tied_rank(x): score : list of numbers The tied rank f each element in x """ - sorted_x = sorted(zip(x,range(len(x)))) + sorted_x = sorted(zip(x, range(len(x)))) r = [0 for k in x] cur_val = sorted_x[0][0] last_rank = 0 for i in range(len(sorted_x)): if cur_val != sorted_x[i][0]: cur_val = sorted_x[i][0] - for j in range(last_rank, i): - r[sorted_x[j][1]] = float(last_rank+1+i)/2.0 + for j in range(last_rank, i): + r[sorted_x[j][1]] = float(last_rank + 1 + i) / 2.0 last_rank = i - if i==len(sorted_x)-1: - for j in range(last_rank, i+1): - r[sorted_x[j][1]] = float(last_rank+i+2)/2.0 + if i == len(sorted_x) - 1: + for j in range(last_rank, i + 1): + r[sorted_x[j][1]] = float(last_rank + i + 2) / 2.0 return r + def auc(actual, posterior): """ Computes the area under the receiver-operater characteristic (AUC) @@ -56,10 +59,9 @@ def auc(actual, posterior): The mean squared error between actual and posterior """ r = tied_rank(posterior) - num_positive = len([0 for x in actual if x==1]) - num_negative = len(actual)-num_positive - sum_positive = sum([r[i] for i in range(len(r)) if actual[i]==1]) - auc = ((sum_positive - num_positive*(num_positive+1)/2.0) / - (num_negative*num_positive)) + num_positive = len([0 for x in actual if x == 1]) + num_negative = len(actual) - num_positive + sum_positive = sum([r[i] for i in range(len(r)) if actual[i] == 1]) + auc = ((sum_positive - num_positive * (num_positive + 1) / 2.0) / + (num_negative * num_positive)) return auc - diff --git a/python/paddle_serving_client/utils/__init__.py b/python/paddle_serving_client/utils/__init__.py index 62642314fa8f7f0ece778e34ff78fe3b2f039dfa..7d39f37acf4a65c7dfd982eec15048123133353b 100644 --- a/python/paddle_serving_client/utils/__init__.py +++ b/python/paddle_serving_client/utils/__init__.py @@ -11,18 +11,26 @@ # 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. +# pylint: disable=doc-string-missing import os import sys import subprocess import argparse from multiprocessing import Pool + def benchmark_args(): parser = argparse.ArgumentParser("benchmark") parser.add_argument("--thread", type=int, default=10, help="concurrecy") - parser.add_argument("--model", type=str, default="", help="model for evaluation") - parser.add_argument("--endpoint", type=str, default="127.0.0.1:9292", help="endpoint of server") - parser.add_argument("--request", type=str, default="rpc", help="mode of service") + parser.add_argument( + "--model", type=str, default="", help="model for evaluation") + parser.add_argument( + "--endpoint", + type=str, + default="127.0.0.1:9292", + help="endpoint of server") + parser.add_argument( + "--request", type=str, default="rpc", help="mode of service") return parser.parse_args() diff --git a/python/paddle_serving_server/serve.py b/python/paddle_serving_server/serve.py index fe9dcd4dc8cb7cea51a0ac180796c340a22ef8ae..c86c3f46b3b3ef83fb5fe630031cf28a95c52649 100644 --- a/python/paddle_serving_server/serve.py +++ b/python/paddle_serving_server/serve.py @@ -19,16 +19,26 @@ Usage: """ import argparse -def parse_args(): + +def parse_args(): # pylint: disable=doc-string-missing parser = argparse.ArgumentParser("serve") - parser.add_argument("--thread", type=int, default=10, help="Concurrency of server") - parser.add_argument("--model", type=str, default="", help="Model for serving") - parser.add_argument("--port", type=int, default=9292, help="Port the server") - parser.add_argument("--workdir", type=str, default="workdir", help="Working dir of current service") - parser.add_argument("--device", type=str, default="cpu", help="Type of device") + parser.add_argument( + "--thread", type=int, default=10, help="Concurrency of server") + parser.add_argument( + "--model", type=str, default="", help="Model for serving") + parser.add_argument( + "--port", type=int, default=9292, help="Port the server") + parser.add_argument( + "--workdir", + type=str, + default="workdir", + help="Working dir of current service") + parser.add_argument( + "--device", type=str, default="cpu", help="Type of device") return parser.parse_args() -def start_standard_model(): + +def start_standard_model(): # pylint: disable=doc-string-missing args = parse_args() thread_num = args.thread model = args.model @@ -59,5 +69,6 @@ def start_standard_model(): server.prepare_server(workdir=workdir, port=port, device=device) server.run_server() + if __name__ == "__main__": start_standard_model() diff --git a/python/paddle_serving_server/web_serve.py b/python/paddle_serving_server/web_serve.py index 337584c8b9c6501dc7448b98937b390c441dc53f..46437ad5e53288c6ab03b32ea8882e1b3cfa66a3 100644 --- a/python/paddle_serving_server/web_serve.py +++ b/python/paddle_serving_server/web_serve.py @@ -21,19 +21,31 @@ import argparse from multiprocessing import Pool, Process from .web_service import WebService -def parse_args(): + +def parse_args(): # pylint: disable=doc-string-missing parser = argparse.ArgumentParser("web_serve") - parser.add_argument("--thread", type=int, default=10, help="Concurrency of server") - parser.add_argument("--model", type=str, default="", help="Model for serving") - parser.add_argument("--port", type=int, default=9292, help="Port the server") - parser.add_argument("--workdir", type=str, default="workdir", help="Working dir of current service") - parser.add_argument("--device", type=str, default="cpu", help="Type of device") - parser.add_argument("--name", type=str, default="default", help="Default service name") + parser.add_argument( + "--thread", type=int, default=10, help="Concurrency of server") + parser.add_argument( + "--model", type=str, default="", help="Model for serving") + parser.add_argument( + "--port", type=int, default=9292, help="Port the server") + parser.add_argument( + "--workdir", + type=str, + default="workdir", + help="Working dir of current service") + parser.add_argument( + "--device", type=str, default="cpu", help="Type of device") + parser.add_argument( + "--name", type=str, default="default", help="Default service name") return parser.parse_args() + if __name__ == "__main__": args = parse_args() service = WebService(name=args.name) service.load_model_config(args.model) - service.prepare_server(workdir=args.workdir, port=args.port, device=args.device) + service.prepare_server( + workdir=args.workdir, port=args.port, device=args.device) service.run_server() diff --git a/python/paddle_serving_server/web_service.py b/python/paddle_serving_server/web_service.py index 00c060f1b207a2de3f45a46483819ef4ff9aa5c9..a0300a0802e740e7c6e4d4d8f3b3c7c5a8862d3b 100755 --- a/python/paddle_serving_server/web_service.py +++ b/python/paddle_serving_server/web_service.py @@ -12,11 +12,14 @@ # See the License for the specific language governing permissions and # limitations under the License. #!flask/bin/python +# pylint: disable=doc-string-missing + from flask import Flask, request, abort from multiprocessing import Pool, Process from paddle_serving_server import OpMaker, OpSeqMaker, Server from paddle_serving_client import Client + class WebService(object): def __init__(self, name="default_service"): self.name = name @@ -38,7 +41,7 @@ class WebService(object): server.set_num_threads(16) server.load_model_config(self.model_config) server.prepare_server( - workdir=self.workdir, port=self.port+1, device=self.device) + workdir=self.workdir, port=self.port + 1, device=self.device) server.run_server() def prepare_server(self, workdir="", port=9393, device="cpu"): @@ -51,8 +54,9 @@ class WebService(object): client_service = Client() client_service.load_client_config( "{}/serving_server_conf.prototxt".format(self.model_config)) - client_service.connect(["127.0.0.1:{}".format(self.port+1)]) + client_service.connect(["127.0.0.1:{}".format(self.port + 1)]) service_name = "/" + self.name + "/prediction" + @app_instance.route(service_name, methods=['POST']) def get_prediction(): if not request.json: @@ -60,16 +64,24 @@ class WebService(object): if "fetch" not in request.json: abort(400) feed, fetch = self.preprocess(request.json, request.json["fetch"]) + if "fetch" in feed: + del feed["fetch"] fetch_map = client_service.predict(feed=feed, fetch=fetch) - fetch_map = self.postprocess(feed=request.json, fetch=fetch, fetch_map=fetch_map) + fetch_map = self.postprocess( + feed=request.json, fetch=fetch, fetch_map=fetch_map) return fetch_map - app_instance.run(host="127.0.0.1", port=self.port, threaded=False, processes=1) + + app_instance.run(host="0.0.0.0", + port=self.port, + threaded=False, + processes=1) def run_server(self): import socket localIP = socket.gethostbyname(socket.gethostname()) print("web service address:") - print("http://{}:{}/{}/prediction".format(localIP, self.port, self.name)) + print("http://{}:{}/{}/prediction".format(localIP, self.port, + self.name)) p_rpc = Process(target=self._launch_rpc_service) p_web = Process(target=self._launch_web_service) p_rpc.start() @@ -82,4 +94,3 @@ class WebService(object): def postprocess(self, feed={}, fetch=[], fetch_map={}): return fetch_map - diff --git a/python/paddle_serving_server_gpu/__init__.py b/python/paddle_serving_server_gpu/__init__.py index 4372884a290bb98faf4416c2cb0e872bc4c76003..ffa8e6eb5b2f3d38d2d2a6525a39356dd014e5d1 100644 --- a/python/paddle_serving_server_gpu/__init__.py +++ b/python/paddle_serving_server_gpu/__init__.py @@ -11,6 +11,7 @@ # 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. +# pylint: disable=doc-string-missing import os from .proto import server_configure_pb2 as server_sdk @@ -21,6 +22,28 @@ import socket import paddle_serving_server_gpu as paddle_serving_server from version import serving_server_version from contextlib import closing +import argparse + + +def serve_args(): + parser = argparse.ArgumentParser("serve") + parser.add_argument( + "--thread", type=int, default=10, help="Concurrency of server") + parser.add_argument( + "--model", type=str, default="", help="Model for serving") + parser.add_argument( + "--port", type=int, default=9292, help="Port of the starting gpu") + parser.add_argument( + "--workdir", + type=str, + default="workdir", + help="Working dir of current service") + parser.add_argument( + "--device", type=str, default="gpu", help="Type of device") + parser.add_argument("--gpu_ids", type=str, default="", help="gpu ids") + parser.add_argument( + "--name", type=str, default="default", help="Default service name") + return parser.parse_args() class OpMaker(object): @@ -126,7 +149,8 @@ class Server(object): self.model_config_path = model_config_path self.engine.name = "general_model" - self.engine.reloadable_meta = model_config_path + "/fluid_time_file" + #self.engine.reloadable_meta = model_config_path + "/fluid_time_file" + self.engine.reloadable_meta = self.workdir + "/fluid_time_file" os.system("touch {}".format(self.engine.reloadable_meta)) self.engine.reloadable_type = "timestamp_ne" self.engine.runtime_thread_num = 0 @@ -154,6 +178,7 @@ class Server(object): self.infer_service_conf.services.extend([infer_service]) def _prepare_resource(self, workdir): + self.workdir = workdir if self.resource_conf == None: with open("{}/{}".format(workdir, self.general_model_config_fn), "w") as fout: @@ -217,6 +242,7 @@ class Server(object): if not self.check_port(port): raise SystemExit("Prot {} is already used".format(port)) + self.set_port(port) self._prepare_resource(workdir) self._prepare_engine(self.model_config_path, device) self._prepare_infer_service(port) diff --git a/python/paddle_serving_server_gpu/serve.py b/python/paddle_serving_server_gpu/serve.py index 1a88797b285c0b168e52e54755da3b7ea5bad434..104c9973105a6e4248b261ac03b26132f753cff5 100644 --- a/python/paddle_serving_server_gpu/serve.py +++ b/python/paddle_serving_server_gpu/serve.py @@ -17,36 +17,23 @@ Usage: Example: python -m paddle_serving_server.serve --model ./serving_server_model --port 9292 """ +import os import argparse +from multiprocessing import Pool, Process +from paddle_serving_server_gpu import serve_args -def parse_args(): - parser = argparse.ArgumentParser("serve") - parser.add_argument( - "--thread", type=int, default=10, help="Concurrency of server") - parser.add_argument( - "--model", type=str, default="", help="Model for serving") - parser.add_argument( - "--port", type=int, default=9292, help="Port the server") - parser.add_argument( - "--workdir", - type=str, - default="workdir", - help="Working dir of current service") - parser.add_argument( - "--device", type=str, default="gpu", help="Type of device") - parser.add_argument("--gpuid", type=int, default=0, help="Index of GPU") - return parser.parse_args() - - -def start_standard_model(): - args = parse_args() +def start_gpu_card_model(gpuid, args): # pylint: disable=doc-string-missing + gpuid = int(gpuid) + device = "gpu" + port = args.port + if gpuid == -1: + device = "cpu" + elif gpuid >= 0: + port = args.port + gpuid thread_num = args.thread model = args.model - port = args.port - workdir = args.workdir - device = args.device - gpuid = args.gpuid + workdir = "{}_{}".format(args.workdir, gpuid) if model == "": print("You must specify your serving model") @@ -69,9 +56,33 @@ def start_standard_model(): server.load_model_config(model) server.prepare_server(workdir=workdir, port=port, device=device) - server.set_gpuid(gpuid) + if gpuid >= 0: + server.set_gpuid(gpuid) server.run_server() +def start_multi_card(args): # pylint: disable=doc-string-missing + gpus = "" + if args.gpu_ids == "": + gpus = os.environ["CUDA_VISIBLE_DEVICES"] + else: + gpus = args.gpu_ids.split(",") + if len(gpus) <= 0: + start_gpu_card_model(-1) + else: + gpu_processes = [] + for i, gpu_id in enumerate(gpus): + p = Process( + target=start_gpu_card_model, args=( + i, + args, )) + gpu_processes.append(p) + for p in gpu_processes: + p.start() + for p in gpu_processes: + p.join() + + if __name__ == "__main__": - start_standard_model() + args = serve_args() + start_multi_card(args) diff --git a/python/paddle_serving_server_gpu/web_serve.py b/python/paddle_serving_server_gpu/web_serve.py index e7b44034797a8de75ca8dc5d97f7dc93c9671954..de7130afb90b38cc867edab8134c297ad326989d 100644 --- a/python/paddle_serving_server_gpu/web_serve.py +++ b/python/paddle_serving_server_gpu/web_serve.py @@ -17,35 +17,23 @@ Usage: Example: python -m paddle_serving_server.web_serve --model ./serving_server_model --port 9292 """ -import argparse +import os from multiprocessing import Pool, Process from .web_service import WebService - - -def parse_args(): - parser = argparse.ArgumentParser("web_serve") - parser.add_argument( - "--thread", type=int, default=10, help="Concurrency of server") - parser.add_argument( - "--model", type=str, default="", help="Model for serving") - parser.add_argument( - "--port", type=int, default=9292, help="Port the server") - parser.add_argument( - "--workdir", - type=str, - default="workdir", - help="Working dir of current service") - parser.add_argument( - "--device", type=str, default="cpu", help="Type of device") - parser.add_argument( - "--name", type=str, default="default", help="Default service name") - return parser.parse_args() - +import paddle_serving_server_gpu as serving +from paddle_serving_server_gpu import serve_args if __name__ == "__main__": - args = parse_args() - service = WebService(name=args.name) - service.load_model_config(args.model) - service.prepare_server( + args = serve_args() + web_service = WebService(name=args.name) + web_service.load_model_config(args.model) + gpu_ids = [] + if args.gpu_ids == "": + if "CUDA_VISIBLE_DEVICES" in os.environ: + gpu_ids = os.environ["CUDA_VISIBLE_DEVICES"] + if len(gpu_ids) > 0: + gpus = [int(x) for x in gpu_ids.split(",")] + web_service.set_gpus(gpus) + web_service.prepare_server( workdir=args.workdir, port=args.port, device=args.device) service.run_server() diff --git a/python/paddle_serving_server_gpu/web_service.py b/python/paddle_serving_server_gpu/web_service.py index 3f129a45853b02711f96953b0b902015d2f2d3e8..6d2039040178c118f48a09563735d97cca3c10c7 100755 --- a/python/paddle_serving_server_gpu/web_service.py +++ b/python/paddle_serving_server_gpu/web_service.py @@ -12,49 +12,92 @@ # See the License for the specific language governing permissions and # limitations under the License. #!flask/bin/python +# pylint: disable=doc-string-missing + from flask import Flask, request, abort from multiprocessing import Pool, Process from paddle_serving_server_gpu import OpMaker, OpSeqMaker, Server +import paddle_serving_server_gpu as serving from paddle_serving_client import Client +from .serve import start_multi_card +import time +import random class WebService(object): def __init__(self, name="default_service"): self.name = name + self.gpus = [] + self.rpc_service_list = [] def load_model_config(self, model_config): self.model_config = model_config - def _launch_rpc_service(self): - op_maker = OpMaker() + def set_gpus(self, gpus): + self.gpus = gpus + + def default_rpc_service(self, + workdir="conf", + port=9292, + gpuid=0, + thread_num=10): + device = "gpu" + if gpuid == -1: + device = "cpu" + op_maker = serving.OpMaker() read_op = op_maker.create('general_reader') general_infer_op = op_maker.create('general_infer') general_response_op = op_maker.create('general_response') - op_seq_maker = OpSeqMaker() + + op_seq_maker = serving.OpSeqMaker() op_seq_maker.add_op(read_op) op_seq_maker.add_op(general_infer_op) op_seq_maker.add_op(general_response_op) - server = Server() + + server = serving.Server() server.set_op_sequence(op_seq_maker.get_op_sequence()) - server.set_num_threads(16) - server.set_gpuid = self.gpuid + server.set_num_threads(thread_num) + server.load_model_config(self.model_config) - server.prepare_server( - workdir=self.workdir, port=self.port + 1, device=self.device) - server.run_server() + if gpuid >= 0: + server.set_gpuid(gpuid) + server.prepare_server(workdir=workdir, port=port, device=device) + return server + + def _launch_rpc_service(self, service_idx): + self.rpc_service_list[service_idx].run_server() def prepare_server(self, workdir="", port=9393, device="gpu", gpuid=0): self.workdir = workdir self.port = port self.device = device self.gpuid = gpuid + if len(self.gpus) == 0: + # init cpu service + self.rpc_service_list.append( + self.default_rpc_service( + self.workdir, self.port + 1, -1, thread_num=10)) + else: + for i, gpuid in enumerate(self.gpus): + self.rpc_service_list.append( + self.default_rpc_service( + "{}_{}".format(self.workdir, i), + self.port + 1 + i, + gpuid, + thread_num=10)) - def _launch_web_service(self): + def _launch_web_service(self, gpu_num): app_instance = Flask(__name__) - client_service = Client() - client_service.load_client_config( - "{}/serving_server_conf.prototxt".format(self.model_config)) - client_service.connect(["127.0.0.1:{}".format(self.port + 1)]) + client_list = [] + if gpu_num > 1: + gpu_num = 0 + for i in range(gpu_num): + client_service = Client() + client_service.load_client_config( + "{}/serving_server_conf.prototxt".format(self.model_config)) + client_service.connect(["127.0.0.1:{}".format(self.port + i + 1)]) + client_list.append(client_service) + time.sleep(1) service_name = "/" + self.name + "/prediction" @app_instance.route(service_name, methods=['POST']) @@ -64,12 +107,12 @@ class WebService(object): if "fetch" not in request.json: abort(400) feed, fetch = self.preprocess(request.json, request.json["fetch"]) - fetch_map = client_service.predict(feed=feed, fetch=fetch) + fetch_map = client_list[0].predict(feed=feed, fetch=fetch) fetch_map = self.postprocess( feed=request.json, fetch=fetch, fetch_map=fetch_map) return fetch_map - app_instance.run(host="127.0.0.1", + app_instance.run(host="0.0.0.0", port=self.port, threaded=False, processes=1) @@ -80,12 +123,21 @@ class WebService(object): print("web service address:") print("http://{}:{}/{}/prediction".format(localIP, self.port, self.name)) - p_rpc = Process(target=self._launch_rpc_service) - p_web = Process(target=self._launch_web_service) - p_rpc.start() + + rpc_processes = [] + for idx in range(len(self.rpc_service_list)): + p_rpc = Process(target=self._launch_rpc_service, args=(idx, )) + rpc_processes.append(p_rpc) + + for p in rpc_processes: + p.start() + + p_web = Process( + target=self._launch_web_service, args=(len(self.gpus), )) p_web.start() + for p in rpc_processes: + p.join() p_web.join() - p_rpc.join() def preprocess(self, feed={}, fetch=[]): return feed, fetch diff --git a/python/setup.py.in b/python/setup.py.in index 90d2fcd59ff83c3f16f01830f690b83277e2c326..af7036bdd99e05966156064dd2bcf1bb8463b716 100644 --- a/python/setup.py.in +++ b/python/setup.py.in @@ -77,4 +77,3 @@ setup( ], license='Apache 2.0', keywords=('paddle-serving serving-client deployment industrial easy-to-use')) - diff --git a/python/setup.py.server.in b/python/setup.py.server.in index b0bb7aa3703d6c4128a142191fc34578784c6789..97f02078806b20f41e917e0c385983a767a4df8c 100644 --- a/python/setup.py.server.in +++ b/python/setup.py.server.in @@ -38,7 +38,7 @@ max_version, mid_version, min_version = python_version() REQUIRED_PACKAGES = [ 'six >= 1.10.0', 'protobuf >= 3.1.0', - 'paddle_serving_client', 'flask' + 'paddle_serving_client', 'flask >= 1.1.1' ] if not find_package("paddlepaddle") and not find_package("paddlepaddle-gpu"): diff --git a/tools/Dockerfile.ci b/tools/Dockerfile.ci new file mode 100644 index 0000000000000000000000000000000000000000..c3ababc7c0ca689c53122b8e41af2e350a937eb5 --- /dev/null +++ b/tools/Dockerfile.ci @@ -0,0 +1,34 @@ +FROM centos:7.3.1611 +RUN yum -y install wget >/dev/null \ + && yum -y install gcc gcc-c++ make glibc-static which >/dev/null \ + && yum -y install git openssl-devel curl-devel bzip2-devel python-devel >/dev/null \ + && wget https://cmake.org/files/v3.2/cmake-3.2.0-Linux-x86_64.tar.gz >/dev/null \ + && tar xzf cmake-3.2.0-Linux-x86_64.tar.gz \ + && mv cmake-3.2.0-Linux-x86_64 /usr/local/cmake3.2.0 \ + && echo 'export PATH=/usr/local/cmake3.2.0/bin:$PATH' >> /root/.bashrc \ + && rm cmake-3.2.0-Linux-x86_64.tar.gz \ + && wget https://dl.google.com/go/go1.14.linux-amd64.tar.gz >/dev/null \ + && tar xzf go1.14.linux-amd64.tar.gz \ + && mv go /usr/local/go \ + && echo 'export GOROOT=/usr/local/go' >> /root/.bashrc \ + && echo 'export PATH=/usr/local/go/bin:$PATH' >> /root/.bashrc \ + && rm go1.14.linux-amd64.tar.gz \ + && yum -y install python-devel sqlite-devel >/dev/null \ + && curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py >/dev/null \ + && python get-pip.py >/dev/null \ + && pip install google protobuf setuptools wheel flask >/dev/null \ + && rm get-pip.py \ + && wget http://nixos.org/releases/patchelf/patchelf-0.10/patchelf-0.10.tar.bz2 \ + && yum -y install bzip2 >/dev/null \ + && tar -jxf patchelf-0.10.tar.bz2 \ + && cd patchelf-0.10 \ + && ./configure --prefix=/usr \ + && make >/dev/null && make install >/dev/null \ + && cd .. \ + && rm -rf patchelf-0.10* \ + && yum -y update >/dev/null \ + && yum -y install dnf >/dev/null \ + && yum -y install dnf-plugins-core >/dev/null \ + && dnf copr enable alonid/llvm-3.8.0 -y \ + && dnf install llvm-3.8.0 clang-3.8.0 compiler-rt-3.8.0 -y \ + && echo 'export PATH=/opt/llvm-3.8.0/bin:$PATH' >> /root/.bashrc diff --git a/tools/cpp_examples/demo-client/paddle_serving_client.egg-info/SOURCES.txt b/tools/cpp_examples/demo-client/paddle_serving_client.egg-info/SOURCES.txt index 2f2ba80caa9e722f8c0a9c169db01e93b3315289..6ae9aeb00eeb8e7dfd4450e8354f74b8388eae65 100644 --- a/tools/cpp_examples/demo-client/paddle_serving_client.egg-info/SOURCES.txt +++ b/tools/cpp_examples/demo-client/paddle_serving_client.egg-info/SOURCES.txt @@ -3,4 +3,4 @@ paddle_serving_client.egg-info/PKG-INFO paddle_serving_client.egg-info/SOURCES.txt paddle_serving_client.egg-info/dependency_links.txt paddle_serving_client.egg-info/not-zip-safe -paddle_serving_client.egg-info/top_level.txt \ No newline at end of file +paddle_serving_client.egg-info/top_level.txt diff --git a/tools/cpp_examples/demo-client/paddle_serving_client.egg-info/dependency_links.txt b/tools/cpp_examples/demo-client/paddle_serving_client.egg-info/dependency_links.txt index 8b137891791fe96927ad78e64b0aad7bded08bdc..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644 --- a/tools/cpp_examples/demo-client/paddle_serving_client.egg-info/dependency_links.txt +++ b/tools/cpp_examples/demo-client/paddle_serving_client.egg-info/dependency_links.txt @@ -1 +0,0 @@ - diff --git a/tools/cpp_examples/demo-client/src/general_model.cpp b/tools/cpp_examples/demo-client/src/general_model.cpp index c281c54f96eb7c92f2a221ad33b8840a210d9cac..5a6b99593a0ec3aa625fdd5e9a3698144ed18da1 100644 --- a/tools/cpp_examples/demo-client/src/general_model.cpp +++ b/tools/cpp_examples/demo-client/src/general_model.cpp @@ -12,8 +12,8 @@ // See the License for the specific language governing permissions and // limitations under the License. +#include "general_model.h" // NOLINT #include -#include "general_model.h" #include "sdk-cpp/builtin_format.pb.h" #include "sdk-cpp/include/common.h" #include "sdk-cpp/include/predictor_sdk.h" @@ -28,7 +28,7 @@ namespace baidu { namespace paddle_serving { namespace general_model { -void PredictorClient::init(const std::string & conf_file) { +void PredictorClient::init(const std::string &conf_file) { _conf_file = conf_file; std::ifstream fin(conf_file); if (!fin) { @@ -65,9 +65,8 @@ void PredictorClient::init(const std::string & conf_file) { } } -void PredictorClient::set_predictor_conf( - const std::string & conf_path, - const std::string & conf_file) { +void PredictorClient::set_predictor_conf(const std::string &conf_path, + const std::string &conf_file) { _predictor_path = conf_path; _predictor_conf = conf_file; } @@ -80,53 +79,51 @@ int PredictorClient::create_predictor() { _api.thrd_initialize(); } -void PredictorClient::predict( - const std::vector > & float_feed, - const std::vector & float_feed_name, - const std::vector > & int_feed, - const std::vector & int_feed_name, - const std::vector & fetch_name, - FetchedMap * fetch_result) { - +void PredictorClient::predict(const std::vector> &float_feed, + const std::vector &float_feed_name, + const std::vector> &int_feed, + const std::vector &int_feed_name, + const std::vector &fetch_name, + FetchedMap *fetch_result) { _api.thrd_clear(); _predictor = _api.fetch_predictor("general_model"); Request req; std::vector tensor_vec; - FeedInst * inst = req.add_insts(); - for (auto & name : float_feed_name) { + FeedInst *inst = req.add_insts(); + for (auto &name : float_feed_name) { tensor_vec.push_back(inst->add_tensor_array()); } - for (auto & name : int_feed_name) { + for (auto &name : int_feed_name) { tensor_vec.push_back(inst->add_tensor_array()); } int vec_idx = 0; - for (auto & name : float_feed_name) { + for (auto &name : float_feed_name) { int idx = _feed_name_to_idx[name]; - Tensor * tensor = tensor_vec[idx]; + Tensor *tensor = tensor_vec[idx]; for (int j = 0; j < _shape[idx].size(); ++j) { tensor->add_shape(_shape[idx][j]); } tensor->set_elem_type(1); for (int j = 0; j < float_feed[vec_idx].size(); ++j) { - tensor->add_data( - (char *)(&(float_feed[vec_idx][j])), sizeof(float)); + tensor->add_data((char *)(&(float_feed[vec_idx][j])), // NOLINT + sizeof(float)); } vec_idx++; } vec_idx = 0; - for (auto & name : int_feed_name) { + for (auto &name : int_feed_name) { int idx = _feed_name_to_idx[name]; - Tensor * tensor = tensor_vec[idx]; + Tensor *tensor = tensor_vec[idx]; for (int j = 0; j < _shape[idx].size(); ++j) { tensor->add_shape(_shape[idx][j]); } tensor->set_elem_type(0); for (int j = 0; j < int_feed[vec_idx].size(); ++j) { - tensor->add_data( - (char *)(&(int_feed[vec_idx][j])), sizeof(int64_t)); + tensor->add_data((char *)(&(int_feed[vec_idx][j])), // NOLINT + sizeof(int64_t)); } vec_idx++; } @@ -139,13 +136,13 @@ void PredictorClient::predict( LOG(ERROR) << "failed call predictor with req: " << req.ShortDebugString(); exit(-1); } else { - for (auto & name : fetch_name) { + for (auto &name : fetch_name) { int idx = _fetch_name_to_idx[name]; int len = res.insts(0).tensor_array(idx).data_size(); (*fetch_result)[name].resize(len); for (int i = 0; i < len; ++i) { - (*fetch_result)[name][i] = *(const float *) - res.insts(0).tensor_array(idx).data(i).c_str(); + (*fetch_result)[name][i] = + *(const float *)res.insts(0).tensor_array(idx).data(i).c_str(); } } } @@ -154,12 +151,12 @@ void PredictorClient::predict( } void PredictorClient::predict_with_profile( - const std::vector > & float_feed, - const std::vector & float_feed_name, - const std::vector > & int_feed, - const std::vector & int_feed_name, - const std::vector & fetch_name, - FetchedMap * fetch_result) { + const std::vector> &float_feed, + const std::vector &float_feed_name, + const std::vector> &int_feed, + const std::vector &int_feed_name, + const std::vector &fetch_name, + FetchedMap *fetch_result) { return; } diff --git a/tools/cpp_examples/demo-client/src/general_model.h b/tools/cpp_examples/demo-client/src/general_model.h index 91084a61a95b678d45a9b40d9a4566031bd37260..761438657dd1c9f47fb8b7dd6c3c8fcc5b72d66f 100644 --- a/tools/cpp_examples/demo-client/src/general_model.h +++ b/tools/cpp_examples/demo-client/src/general_model.h @@ -18,9 +18,9 @@ #include #include +#include #include #include -#include #include "sdk-cpp/builtin_format.pb.h" #include "sdk-cpp/general_model_service.pb.h" @@ -37,44 +37,40 @@ namespace general_model { typedef std::map> FetchedMap; - class PredictorClient { public: PredictorClient() {} ~PredictorClient() {} - void init(const std::string & client_conf); - void set_predictor_conf( - const std::string& conf_path, - const std::string& conf_file); + void init(const std::string& client_conf); + void set_predictor_conf(const std::string& conf_path, + const std::string& conf_file); int create_predictor(); - void predict( - const std::vector > & float_feed, - const std::vector & float_feed_name, - const std::vector > & int_feed, - const std::vector & int_feed_name, - const std::vector & fetch_name, - FetchedMap * result_map); + void predict(const std::vector>& float_feed, + const std::vector& float_feed_name, + const std::vector>& int_feed, + const std::vector& int_feed_name, + const std::vector& fetch_name, + FetchedMap* result_map); - void predict_with_profile( - const std::vector > & float_feed, - const std::vector & float_feed_name, - const std::vector > & int_feed, - const std::vector & int_feed_name, - const std::vector & fetch_name, - FetchedMap * result_map); + void predict_with_profile(const std::vector>& float_feed, + const std::vector& float_feed_name, + const std::vector>& int_feed, + const std::vector& int_feed_name, + const std::vector& fetch_name, + FetchedMap* result_map); private: PredictorApi _api; - Predictor * _predictor; + Predictor* _predictor; std::string _predictor_conf; std::string _predictor_path; std::string _conf_file; std::map _feed_name_to_idx; std::map _fetch_name_to_idx; std::map _fetch_name_to_var_name; - std::vector > _shape; + std::vector> _shape; }; } // namespace general_model diff --git a/tools/cpp_examples/demo-client/src/general_model_main.cpp b/tools/cpp_examples/demo-client/src/general_model_main.cpp index 8bf2e1793c3ac77ddff1fce5de1630b78be88318..b7171e12bd2c06e09072eac0055787f3882d4ab8 100644 --- a/tools/cpp_examples/demo-client/src/general_model_main.cpp +++ b/tools/cpp_examples/demo-client/src/general_model_main.cpp @@ -15,20 +15,20 @@ #include #include -#include "general_model.h" +#include "general_model.h" // NOLINT -using namespace std; +using namespace std; // NOLINT using baidu::paddle_serving::general_model::PredictorClient; using baidu::paddle_serving::general_model::FetchedMap; -int main(int argc, char * argv[]) { - PredictorClient * client = new PredictorClient(); +int main(int argc, char* argv[]) { + PredictorClient* client = new PredictorClient(); client->init("inference.conf"); client->set_predictor_conf("./", "predictor.conf"); client->create_predictor(); - std::vector > float_feed; - std::vector > int_feed; + std::vector> float_feed; + std::vector> int_feed; std::vector float_feed_name; std::vector int_feed_name = {"words", "label"}; std::vector fetch_name = {"cost", "acc", "prediction"}; @@ -53,13 +53,14 @@ int main(int argc, char * argv[]) { cin >> label; int_feed.push_back({label}); - FetchedMap result; - client->predict( - float_feed, float_feed_name, - int_feed, int_feed_name, fetch_name, - &result); + client->predict(float_feed, + float_feed_name, + int_feed, + int_feed_name, + fetch_name, + &result); cout << label << "\t" << result["prediction"][1] << endl; diff --git a/tools/cpp_examples/demo-client/src/load_general_model.cpp b/tools/cpp_examples/demo-client/src/load_general_model.cpp index c7d4ab193d825889e96773a026876aa4d4bb7742..ea6632b85e60c6008fdc70e1c5f9980b7862f856 100644 --- a/tools/cpp_examples/demo-client/src/load_general_model.cpp +++ b/tools/cpp_examples/demo-client/src/load_general_model.cpp @@ -18,14 +18,14 @@ #include #include "core/sdk-cpp/builtin_format.pb.h" -#include "core/sdk-cpp/load_general_model_service.pb.h" #include "core/sdk-cpp/include/common.h" #include "core/sdk-cpp/include/predictor_sdk.h" +#include "core/sdk-cpp/load_general_model_service.pb.h" using baidu::paddle_serving::sdk_cpp::Predictor; using baidu::paddle_serving::sdk_cpp::PredictorApi; -using baidu::paddle_serving::predictor:: -load_general_model_service::RequestAndResponse; +using baidu::paddle_serving::predictor::load_general_model_service:: + RequestAndResponse; int create_req(RequestAndResponse& req) { // NOLINT req.set_a(1); diff --git a/tools/cpp_examples/demo-client/src/pybind_general_model.cpp b/tools/cpp_examples/demo-client/src/pybind_general_model.cpp index 0ce939ebe0547089773ccdacaa707c1df048ffe5..dda26525a468ea73fa06ef0253e836a110247d71 100644 --- a/tools/cpp_examples/demo-client/src/pybind_general_model.cpp +++ b/tools/cpp_examples/demo-client/src/pybind_general_model.cpp @@ -1,7 +1,21 @@ +// Copyright (c) 2020 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. + #include -#include "general_model.h" +#include "general_model.h" // NOLINT -#include +#include // NOLINT namespace py = pybind11; @@ -17,28 +31,30 @@ PYBIND11_MODULE(paddle_serving_client, m) { py::class_(m, "PredictorClient", py::buffer_protocol()) .def(py::init()) .def("init", - [](PredictorClient &self, const std::string & conf) { + [](PredictorClient &self, const std::string &conf) { self.init(conf); }) .def("set_predictor_conf", - [](PredictorClient &self, const std::string & conf_path, - const std::string & conf_file) { + [](PredictorClient &self, + const std::string &conf_path, + const std::string &conf_file) { self.set_predictor_conf(conf_path, conf_file); }) .def("create_predictor", - [](PredictorClient & self) { - self.create_predictor(); - }) + [](PredictorClient &self) { self.create_predictor(); }) .def("predict", [](PredictorClient &self, - const std::vector > & float_feed, - const std::vector & float_feed_name, - const std::vector > & int_feed, - const std::vector & int_feed_name, - const std::vector & fetch_name, - FetchedMap * fetch_result) { - return self.predict(float_feed, float_feed_name, - int_feed, int_feed_name, fetch_name, + const std::vector> &float_feed, + const std::vector &float_feed_name, + const std::vector> &int_feed, + const std::vector &int_feed_name, + const std::vector &fetch_name, + FetchedMap *fetch_result) { + return self.predict(float_feed, + float_feed_name, + int_feed, + int_feed_name, + fetch_name, fetch_result); }); } diff --git a/tools/cpp_examples/demo-serving/op/bert_service_op.h b/tools/cpp_examples/demo-serving/op/bert_service_op.h index 3787501114a76c7ef35e2db54922e43399271a63..b4934d06e8e45199afb1c99cdcec5e7e490a4f5b 100644 --- a/tools/cpp_examples/demo-serving/op/bert_service_op.h +++ b/tools/cpp_examples/demo-serving/op/bert_service_op.h @@ -14,10 +14,10 @@ #pragma once #include -#include "paddle_inference_api.h" // NOLINT #include "examples/demo-serving/bert_service.pb.h" +#include "paddle_inference_api.h" // NOLINT -#include +#include // NOLINT namespace baidu { namespace paddle_serving { diff --git a/tools/cpp_examples/demo-serving/op/classify_op.cpp b/tools/cpp_examples/demo-serving/op/classify_op.cpp index 76370e2cf82e6b8996072e902e9f79192ebd67ad..27ac8ae3a4093b5bc7d95d74e98126f339cb7c7c 100644 --- a/tools/cpp_examples/demo-serving/op/classify_op.cpp +++ b/tools/cpp_examples/demo-serving/op/classify_op.cpp @@ -13,9 +13,9 @@ // limitations under the License. #include "examples/demo-serving/op/classify_op.h" -#include "examples/demo-serving/op/reader_op.h" #include "core/predictor/framework/infer.h" #include "core/predictor/framework/memory.h" +#include "examples/demo-serving/op/reader_op.h" namespace baidu { namespace paddle_serving { diff --git a/tools/cpp_examples/demo-serving/op/classify_op.h b/tools/cpp_examples/demo-serving/op/classify_op.h index be72bad6f088c4fd7cf0c479756baea6847eed3d..0d3f142833d6e2f4cf6396c1437b9910c2a4974b 100644 --- a/tools/cpp_examples/demo-serving/op/classify_op.h +++ b/tools/cpp_examples/demo-serving/op/classify_op.h @@ -14,8 +14,8 @@ #pragma once #include -#include "paddle_inference_api.h" // NOLINT #include "examples/demo-serving/image_class.pb.h" +#include "paddle_inference_api.h" // NOLINT namespace baidu { namespace paddle_serving { diff --git a/tools/cpp_examples/demo-serving/op/ctr_prediction_op.h b/tools/cpp_examples/demo-serving/op/ctr_prediction_op.h index fbcfc2048cd5296dfe436a9981d6575f1678a536..7c9e8447eb478c399d15e3543358dbb163e00477 100644 --- a/tools/cpp_examples/demo-serving/op/ctr_prediction_op.h +++ b/tools/cpp_examples/demo-serving/op/ctr_prediction_op.h @@ -14,8 +14,8 @@ #pragma once #include -#include "paddle_inference_api.h" // NOLINT #include "examples/demo-serving/ctr_prediction.pb.h" +#include "paddle_inference_api.h" // NOLINT namespace baidu { namespace paddle_serving { diff --git a/tools/cpp_examples/demo-serving/op/general_model_op.h b/tools/cpp_examples/demo-serving/op/general_model_op.h index 12a59497423d66c503f4185633cf48c2c68930ee..eb5acf3352b4069b04fc0878a54e8d84b592641c 100644 --- a/tools/cpp_examples/demo-serving/op/general_model_op.h +++ b/tools/cpp_examples/demo-serving/op/general_model_op.h @@ -25,7 +25,6 @@ #endif #include "examples/demo-serving/general_model_service.pb.h" - namespace baidu { namespace paddle_serving { namespace serving { @@ -34,7 +33,7 @@ static const char* GENERAL_MODEL_NAME = "general_model"; class GeneralModelOp : public baidu::paddle_serving::predictor::OpWithChannel< - baidu::paddle_serving::predictor::general_model::Response> { + baidu::paddle_serving::predictor::general_model::Response> { public: typedef std::vector TensorVector; diff --git a/tools/cpp_examples/demo-serving/op/kvdb_echo_op.h b/tools/cpp_examples/demo-serving/op/kvdb_echo_op.h index 1a3dd81cf551e4916e5e78418feb45f6604fa3a3..6dbb9386c3e3a36880ecd73e262eb644608ab5b6 100644 --- a/tools/cpp_examples/demo-serving/op/kvdb_echo_op.h +++ b/tools/cpp_examples/demo-serving/op/kvdb_echo_op.h @@ -13,13 +13,13 @@ // limitations under the License. #pragma once -#include "examples/demo-serving/echo_kvdb_service.pb.h" #include "core/kvdb/include/kvdb/paddle_rocksdb.h" #include "core/predictor/common/inner_common.h" #include "core/predictor/framework/channel.h" #include "core/predictor/framework/op_repository.h" #include "core/predictor/framework/resource.h" #include "core/predictor/op/op.h" +#include "examples/demo-serving/echo_kvdb_service.pb.h" namespace baidu { namespace paddle_serving { diff --git a/tools/cpp_examples/demo-serving/op/load_general_model_conf_op.h b/tools/cpp_examples/demo-serving/op/load_general_model_conf_op.h index 461d14ef6c4e235e41c234848479b195e4066ade..c07bd954475743f310d7150bd3660c7bdc4e480f 100644 --- a/tools/cpp_examples/demo-serving/op/load_general_model_conf_op.h +++ b/tools/cpp_examples/demo-serving/op/load_general_model_conf_op.h @@ -15,25 +15,23 @@ #pragma once #include -#include "examples/demo-serving/load_general_model_service.pb.h" #include "core/predictor/common/inner_common.h" #include "core/predictor/framework/channel.h" #include "core/predictor/framework/op_repository.h" -#include "core/predictor/op/op.h" #include "core/predictor/framework/resource.h" +#include "core/predictor/op/op.h" +#include "examples/demo-serving/load_general_model_service.pb.h" namespace baidu { namespace paddle_serving { namespace predictor { class LoadGeneralModelConfOp - : public OpWithChannel< - baidu::paddle_serving::predictor:: - load_general_model_service::RequestAndResponse> { + : public OpWithChannel { public: - typedef baidu::paddle_serving::predictor:: - load_general_model_service::RequestAndResponse - RequestAndResponse; + typedef baidu::paddle_serving::predictor::load_general_model_service:: + RequestAndResponse RequestAndResponse; DECLARE_OP(LoadGeneralModelConfOp); diff --git a/tools/cpp_examples/demo-serving/op/reader_op.h b/tools/cpp_examples/demo-serving/op/reader_op.h index 6cdb2399faf14fd92fcccc2b3027d97ee31ac5c1..21b1d078bed9e2cd0ea99c5e9fcdb39942d16206 100644 --- a/tools/cpp_examples/demo-serving/op/reader_op.h +++ b/tools/cpp_examples/demo-serving/op/reader_op.h @@ -15,12 +15,12 @@ #pragma once #include #include -#include "examples/demo-serving/image_class.pb.h" #include "core/predictor/builtin_format.pb.h" #include "core/predictor/common/inner_common.h" #include "core/predictor/framework/channel.h" #include "core/predictor/framework/op_repository.h" #include "core/predictor/op/op.h" +#include "examples/demo-serving/image_class.pb.h" // opencv #include "opencv/cv.h" diff --git a/tools/cpp_examples/demo-serving/op/text_classification_op.h b/tools/cpp_examples/demo-serving/op/text_classification_op.h index ab462ee54051abd8519813e256b2004c0d8a7b7f..f01ab23e22f4ff17e0e082e7a9b098f9890aa592 100644 --- a/tools/cpp_examples/demo-serving/op/text_classification_op.h +++ b/tools/cpp_examples/demo-serving/op/text_classification_op.h @@ -14,8 +14,8 @@ #pragma once #include -#include "paddle_inference_api.h" // NOLINT #include "examples/demo-serving/text_classification.pb.h" +#include "paddle_inference_api.h" // NOLINT namespace baidu { namespace paddle_serving { diff --git a/tools/cpp_examples/demo-serving/op/write_json_op.cpp b/tools/cpp_examples/demo-serving/op/write_json_op.cpp index 1b65290deeae2d19962faa4b48e43fd6c94f6483..c49fc4e4c9c359a61434973a2e6d224a5e895849 100644 --- a/tools/cpp_examples/demo-serving/op/write_json_op.cpp +++ b/tools/cpp_examples/demo-serving/op/write_json_op.cpp @@ -21,8 +21,8 @@ #include "json2pb/pb_to_json.h" #endif -#include "examples/demo-serving/op/write_json_op.h" #include "core/predictor/framework/memory.h" +#include "examples/demo-serving/op/write_json_op.h" #ifndef BCLOUD using json2pb::ProtoMessageToJson; diff --git a/tools/cpp_examples/demo-serving/op/write_json_op.h b/tools/cpp_examples/demo-serving/op/write_json_op.h index e292af3d9a051c4bd7b2dcc347bdf17db6e9cb06..7a00025224f42d42070fa988052b229317eaeab3 100644 --- a/tools/cpp_examples/demo-serving/op/write_json_op.h +++ b/tools/cpp_examples/demo-serving/op/write_json_op.h @@ -13,11 +13,11 @@ // limitations under the License. #pragma once -#include "examples/demo-serving/image_class.pb.h" #include "core/predictor/common/inner_common.h" #include "core/predictor/framework/channel.h" #include "core/predictor/framework/op_repository.h" #include "core/predictor/op/op.h" +#include "examples/demo-serving/image_class.pb.h" namespace baidu { namespace paddle_serving { diff --git a/tools/cpp_examples/demo-serving/op/write_op.cpp b/tools/cpp_examples/demo-serving/op/write_op.cpp index 3107145a8162bc79fe845e6af98f3516ed694460..793493e46762c82835b30b85fd57077f15df179e 100644 --- a/tools/cpp_examples/demo-serving/op/write_op.cpp +++ b/tools/cpp_examples/demo-serving/op/write_op.cpp @@ -16,13 +16,13 @@ #include #ifdef BCLOUD -#include "pb_to_json.h" +#include "pb_to_json.h" // NOLINT #else #include "json2pb/pb_to_json.h" #endif -#include "examples/demo-serving/op/write_op.h" #include "core/predictor/framework/memory.h" +#include "examples/demo-serving/op/write_op.h" #ifndef BCLOUD using json2pb::ProtoMessageToJson; diff --git a/tools/cpp_examples/demo-serving/op/write_op.h b/tools/cpp_examples/demo-serving/op/write_op.h index d953f80c718089a81600b031dfd8fb3954d1ec43..51b3da2e376d841885a0f75ede3ad2c56a78acb5 100644 --- a/tools/cpp_examples/demo-serving/op/write_op.h +++ b/tools/cpp_examples/demo-serving/op/write_op.h @@ -13,12 +13,12 @@ // limitations under the License. #pragma once -#include "examples/demo-serving/image_class.pb.h" #include "core/predictor/builtin_format.pb.h" #include "core/predictor/common/inner_common.h" #include "core/predictor/framework/channel.h" #include "core/predictor/framework/op_repository.h" #include "core/predictor/op/op.h" +#include "examples/demo-serving/image_class.pb.h" namespace baidu { namespace paddle_serving { diff --git a/tools/cpp_examples/demo-serving/proto/general_model_service.proto b/tools/cpp_examples/demo-serving/proto/general_model_service.proto index 1b9bfe380134eb494dbc104e0d241ffbf3f98c58..803f7aa09435ac7a5715d62d78a6e12a671c7cb5 100644 --- a/tools/cpp_examples/demo-serving/proto/general_model_service.proto +++ b/tools/cpp_examples/demo-serving/proto/general_model_service.proto @@ -25,21 +25,13 @@ message Tensor { repeated int32 shape = 3; }; -message FeedInst { - repeated Tensor tensor_array = 1; -}; +message FeedInst { repeated Tensor tensor_array = 1; }; -message FetchInst { - repeated Tensor tensor_array = 1; -}; +message FetchInst { repeated Tensor tensor_array = 1; }; -message Request { - repeated FeedInst insts = 1; -}; +message Request { repeated FeedInst insts = 1; }; -message Response { - repeated FetchInst insts = 1; -}; +message Response { repeated FetchInst insts = 1; }; service GeneralModelService { rpc inference(Request) returns (Response); diff --git a/tools/cpp_examples/elastic-ctr/client/demo/elastic_ctr.py b/tools/cpp_examples/elastic-ctr/client/demo/elastic_ctr.py index eb36a4ad25a3e4d82e5448ada132b6be85103190..b5c95440f0e7fc05e10e98c2083a49ba89fbb4c8 100644 --- a/tools/cpp_examples/elastic-ctr/client/demo/elastic_ctr.py +++ b/tools/cpp_examples/elastic-ctr/client/demo/elastic_ctr.py @@ -11,7 +11,7 @@ # 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. - +# pylint: disable=doc-string-missing from __future__ import print_function import json import sys @@ -33,8 +33,8 @@ def str2long(str): return int(str) -def tied_rank(x): - """ +def tied_rank(x): # pylint: disable=doc-string-with-all-args, doc-string-with-returns + """ Computes the tied rank of elements in x. This function computes the tied rank of elements in x. Parameters @@ -45,23 +45,23 @@ def tied_rank(x): score : list of numbers The tied rank f each element in x """ - sorted_x = sorted(zip(x,range(len(x)))) + sorted_x = sorted(zip(x, range(len(x)))) r = [0 for k in x] cur_val = sorted_x[0][0] last_rank = 0 for i in range(len(sorted_x)): if cur_val != sorted_x[i][0]: cur_val = sorted_x[i][0] - for j in range(last_rank, i): - r[sorted_x[j][1]] = float(last_rank+1+i)/2.0 + for j in range(last_rank, i): + r[sorted_x[j][1]] = float(last_rank + 1 + i) / 2.0 last_rank = i - if i==len(sorted_x)-1: - for j in range(last_rank, i+1): - r[sorted_x[j][1]] = float(last_rank+i+2)/2.0 + if i == len(sorted_x) - 1: + for j in range(last_rank, i + 1): + r[sorted_x[j][1]] = float(last_rank + i + 2) / 2.0 return r -def auc(actual, posterior): +def auc(actual, posterior): # pylint: disable=doc-string-with-all-args, doc-string-with-returns """ Computes the area under the receiver-operater characteristic (AUC) This function computes the AUC error metric for binary classification. @@ -78,11 +78,11 @@ def auc(actual, posterior): The mean squared error between actual and posterior """ r = tied_rank(posterior) - num_positive = len([0 for x in actual if x==1]) - num_negative = len(actual)-num_positive - sum_positive = sum([r[i] for i in range(len(r)) if actual[i]==1]) - auc = ((sum_positive - num_positive*(num_positive+1)/2.0) / - (num_negative*num_positive)) + num_positive = len([0 for x in actual if x == 1]) + num_negative = len(actual) - num_positive + sum_positive = sum([r[i] for i in range(len(r)) if actual[i] == 1]) + auc = ((sum_positive - num_positive * (num_positive + 1) / 2.0) / + (num_negative * num_positive)) return auc @@ -105,8 +105,8 @@ def data_reader(data_file, samples, labels): for i in range(0, len(features)): if slots[i] in sample: - sample[slots[i]].append(int(features[i]) % - CTR_EMBEDDING_TABLE_SIZE) + sample[slots[i]].append( + int(features[i]) % CTR_EMBEDDING_TABLE_SIZE) else: sample[slots[i]] = [ int(features[i]) % CTR_EMBEDDING_TABLE_SIZE @@ -117,7 +117,7 @@ def data_reader(data_file, samples, labels): sample[x] = [0] samples.append(sample) - + if __name__ == "__main__": """ main """ @@ -180,4 +180,4 @@ if __name__ == "__main__": pass idx = idx + 1 - print("auc = ", auc(labels, result_list) ) + print("auc = ", auc(labels, result_list)) diff --git a/tools/cpp_examples/elastic-ctr/serving/op/elastic_ctr_prediction_op.cpp b/tools/cpp_examples/elastic-ctr/serving/op/elastic_ctr_prediction_op.cpp index 78215d7a6ef26b21f4270af386455100e5fe2153..481a99d36f57287e508928daeab7ef2bd0a7b9d6 100644 --- a/tools/cpp_examples/elastic-ctr/serving/op/elastic_ctr_prediction_op.cpp +++ b/tools/cpp_examples/elastic-ctr/serving/op/elastic_ctr_prediction_op.cpp @@ -14,8 +14,8 @@ #include "elastic-ctr/serving/op/elastic_ctr_prediction_op.h" #include -#include #include +#include #include "cube/cube-api/include/cube_api.h" #include "predictor/framework/infer.h" #include "predictor/framework/kv_manager.h" @@ -87,7 +87,7 @@ int ElasticCTRPredictionOp::inference() { // Verify all request instances have same slots std::vector slot_ids; - for (auto x: samples[0]) { + for (auto x : samples[0]) { slot_ids.push_back(x.first); } std::sort(slot_ids.begin(), slot_ids.end()); @@ -105,9 +105,9 @@ int ElasticCTRPredictionOp::inference() { // // Later we use slot_map to index into lod_tenor array // - std::map slot_map; + std::map slot_map; // NOLINT int index = 0; - for (auto slot_id: slot_ids) { + for (auto slot_id : slot_ids) { slot_map[slot_id] = index; ++index; } @@ -121,7 +121,7 @@ int ElasticCTRPredictionOp::inference() { return 0; } - for (auto slot: samples[i]) { + for (auto slot : samples[i]) { int id = slot.first; auto x = std::find(slot_ids.begin(), slot_ids.end(), id); if (x == slot_ids.end()) { @@ -171,7 +171,7 @@ int ElasticCTRPredictionOp::inference() { feature_slot_sizes.resize(slot_ids.size()); // Iterate over each feature slot - for (auto slot_id: slot_ids) { + for (auto slot_id : slot_ids) { feature_slot_lods[slot_map[slot_id]].push_back(0); feature_slot_sizes[slot_map[slot_id]] = 0; @@ -179,8 +179,8 @@ int ElasticCTRPredictionOp::inference() { for (size_t si = 0; si < samples.size(); ++si) { Sample &sample = samples[si]; std::vector &slot = sample[slot_id]; - feature_slot_lods[slot_map[slot_id]].push_back(feature_slot_lods[slot_map[slot_id]].back() + - slot.size()); + feature_slot_lods[slot_map[slot_id]].push_back( + feature_slot_lods[slot_map[slot_id]].back() + slot.size()); feature_slot_sizes[slot_map[slot_id]] += slot.size(); for (size_t j = 0; j < slot.size(); ++j) { @@ -303,14 +303,11 @@ int ElasticCTRPredictionOp::inference() { std::vector lod_tensors; lod_tensors.resize(slot_ids.size()); - for (auto slot_id: slot_ids) { + for (auto slot_id : slot_ids) { paddle::PaddleTensor &lod_tensor = lod_tensors[slot_map[slot_id]]; char name[VARIABLE_NAME_LEN]; - snprintf(name, - VARIABLE_NAME_LEN, - "embedding_%d.tmp_0", - slot_id); + snprintf(name, VARIABLE_NAME_LEN, "embedding_%d.tmp_0", slot_id); lod_tensor.name = std::string(name); lod_tensor.dtype = paddle::PaddleDType::FLOAT32; @@ -322,7 +319,7 @@ int ElasticCTRPredictionOp::inference() { int base = 0; // Iterate over all slots - for (auto slot_id: slot_ids) { + for (auto slot_id : slot_ids) { paddle::PaddleTensor &lod_tensor = lod_tensors[slot_map[slot_id]]; std::vector> &lod = lod_tensor.lod; @@ -346,7 +343,7 @@ int ElasticCTRPredictionOp::inference() { res, -1, "Embedding vector size not expected"); return 0; #else - // sizeof(float) * CTR_PREDICTION_EMBEDDING_SIZE = 36 +// sizeof(float) * CTR_PREDICTION_EMBEDDING_SIZE = 36 #if 1 LOG(INFO) << "values[" << idx << "].buff.size != 36"; #endif diff --git a/tools/cpp_examples/elastic-ctr/serving/op/elastic_ctr_prediction_op.h b/tools/cpp_examples/elastic-ctr/serving/op/elastic_ctr_prediction_op.h index 11679c83b1b8a27447b16d8531df17083e1b4f09..39e7d97831cdec093a3cda089349363b079059fa 100644 --- a/tools/cpp_examples/elastic-ctr/serving/op/elastic_ctr_prediction_op.h +++ b/tools/cpp_examples/elastic-ctr/serving/op/elastic_ctr_prediction_op.h @@ -14,8 +14,8 @@ #pragma once #include -#include "paddle_inference_api.h" // NOLINT #include "elastic-ctr/serving/elastic_ctr_prediction.pb.h" +#include "paddle_inference_api.h" // NOLINT namespace baidu { namespace paddle_serving { @@ -33,7 +33,7 @@ class ElasticCTRPredictionOp baidu::paddle_serving::predictor::elastic_ctr::Response> { public: typedef std::vector TensorVector; - typedef std::map> Sample; + typedef std::map> Sample; // NOLINT typedef std::vector Samples; DECLARE_OP(ElasticCTRPredictionOp); diff --git a/tools/serving_build.sh b/tools/serving_build.sh new file mode 100644 index 0000000000000000000000000000000000000000..163f4f74429066581aa17cc78b3ab00947ba4d77 --- /dev/null +++ b/tools/serving_build.sh @@ -0,0 +1,124 @@ +#!/usr/bin/env bash + +function init() { + source /root/.bashrc + set -v + #export http_proxy=http://172.19.56.199:3128 + #export https_proxy=http://172.19.56.199:3128 + export PYTHONROOT=/usr + cd Serving +} + +function check_cmd() { + eval $@ + if [ $? -ne 0 ]; then + exit 1 + fi +} + +function build_client() { + local TYPE=$1 + local DIRNAME=build-client-$TYPE + mkdir $DIRNAME && cd $DIRNAME + case $TYPE in + CPU|GPU) + cmake -DPYTHON_INCLUDE_DIR=$PYTHONROOT/include/python2.7/ \ + -DPYTHON_LIBRARIES=$PYTHONROOT/lib64/libpython2.7.so \ + -DPYTHON_EXECUTABLE=$PYTHONROOT/bin/python \ + -DCLIENT_ONLY=ON .. + check_cmd "make -j2 >/dev/null" + pip install python/dist/paddle_serving_client* >/dev/null + ;; + *) + echo "error type" + exit 1 + ;; + esac + echo "build client $TYPE part finished as expected." + cd .. + rm -rf $DIRNAME +} + +function build_server() { + local TYPE=$1 + local DIRNAME=build-server-$TYPE + mkdir $DIRNAME && cd $DIRNAME + case $TYPE in + CPU) + cmake -DPYTHON_INCLUDE_DIR=$PYTHONROOT/include/python2.7/ \ + -DPYTHON_LIBRARIES=$PYTHONROOT/lib64/libpython2.7.so \ + -DPYTHON_EXECUTABLE=$PYTHONROOT/bin/python \ + -DCLIENT_ONLY=OFF .. + check_cmd "make -j2 >/dev/null" + pip install python/dist/paddle_serving_server* >/dev/null + ;; + GPU) + cmake -DPYTHON_INCLUDE_DIR=$PYTHONROOT/include/python2.7/ \ + -DPYTHON_LIBRARIES=$PYTHONROOT/lib64/libpython2.7.so \ + -DPYTHON_EXECUTABLE=$PYTHONROOT/bin/python \ + -DCLIENT_ONLY=OFF \ + -DWITH_GPU=ON .. + check_cmd "make -j2 >/dev/null" + pip install python/dist/paddle_serving_server* >/dev/null + ;; + *) + echo "error type" + exit 1 + ;; + esac + echo "build server $TYPE part finished as expected." + cd .. + rm -rf $DIRNAME +} + +function python_test_fit_a_line() { + cd fit_a_line + sh get_data.sh + local TYPE=$1 + case $TYPE in + CPU) + # test rpc + check_cmd "python test_server.py uci_housing_model/ > /dev/null &" + sleep 5 + check_cmd "python test_client.py uci_housing_client/serving_client_conf.prototxt > /dev/null" + ps -ef | grep "paddle_serving_server" | grep -v grep | awk '{print $2}' | xargs kill + # test web + check_cmd "python -m paddle_serving_server.web_serve --model uci_housing_model/ --name uci --port 9399 --name uci > /dev/null &" + sleep 5 + check_cmd "curl -H \"Content-Type:application/json\" -X POST -d '{\"x\": [0.0137, -0.1136, 0.2553, -0.0692, 0.0582, -0.0727, -0.1583, -0.0584, 0.6283, 0.4919, 0.1856, 0.0795, -0.0332], \"fetch\":[\"price\"]}' http://127.0.0.1:9399/uci/prediction" + ps -ef | grep "paddle_serving_server" | grep -v grep | awk '{print $2}' | xargs kill + ;; + GPU) + echo "not support yet" + exit 1 + ;; + *) + echo "error type" + exit 1 + ;; + esac + echo "test fit_a_line $TYPE part finished as expected." + rm -rf image kvdb log uci_housing* work* + cd .. +} + +function python_run_test() { + cd python/examples + local TYPE=$1 + # Frist time run, downloading PaddleServing components ... + python -c "from paddle_serving_server import Server; server = Server(); server.download_bin()" + python_test_fit_a_line $TYPE + echo "test python $TYPE part finished as expected." + cd ../.. +} + +function main() { + local TYPE=$1 + init + build_client $TYPE + build_server $TYPE + python_run_test $TYPE + echo "serving $TYPE part finished as expected." +} + +main $@ diff --git a/tools/serving_check_style.sh b/tools/serving_check_style.sh new file mode 100644 index 0000000000000000000000000000000000000000..8739ba7e3b0d63a1cfe4d5d6b21e721fe8e8625f --- /dev/null +++ b/tools/serving_check_style.sh @@ -0,0 +1,39 @@ +#!/usr/bin/env bash + +function init() { + source /root/.bashrc + set -v + cd Serving +} + +function abort(){ + echo "Your change doesn't follow PaddlePaddle's code style." 1>&2 + echo "Please use pre-commit to check what is wrong." 1>&2 + exit 1 +} + +function check_style() { + trap 'abort' 0 + set -e + + pip install cpplint 'pre-commit==1.10.4' + pip install --ignore-installed pylint + + export PATH=/usr/bin:$PATH + pre-commit install + clang-format --version + + if ! pre-commit run -a ; then + git diff + exit 1 + fi + + trap : 0 +} + +function main() { + init + check_style +} + +main