Merge pull request #171 from guru4elephant/add_go

Add go

core/general-server/op/general_text_infer_op.cpp

+// 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 <algorithm>
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include "core/general-server/op/general_text_infer_op.h"
+#include "core/general-server/op/general_infer_op.h"
+#include "core/general-server/op/general_text_reader_op.h"
+#include "core/general-server/op/general_reader_op.h"
+#include "core/predictor/framework/infer.h"
+#include "core/predictor/framework/memory.h"
+#include "core/predictor/framework/resource.h"
+#include "core/util/include/timer.h"
+
+namespace baidu {
+namespace paddle_serving {
+namespace serving {
+
+using baidu::paddle_serving::serving::GENERAL_MODEL_NAME;
+using baidu::paddle_serving::Timer;
+using baidu::paddle_serving::predictor::MempoolWrapper;
+using baidu::paddle_serving::predictor::general_model::Tensor;
+using baidu::paddle_serving::predictor::general_model::Response;
+using baidu::paddle_serving::predictor::general_model::Request;
+using baidu::paddle_serving::predictor::general_model::FetchInst;
+using baidu::paddle_serving::predictor::InferManager;
+using baidu::paddle_serving::predictor::PaddleGeneralModelConfig;
+
+int GeneralTextInferOp::inference() {
+  const GeneralTextReaderOutput *reader_out =
+      get_depend_argument<GeneralTextReaderOutput>("general_text_reader_op");
+  if (!reader_out) {
+    LOG(ERROR) << "Failed mutable depended argument, op:"
+               << "general_text_reader_op";
+    return -1;
+  }
+
+  int reader_status = reader_out->reader_status;
+  if (reader_status != 0) {
+    LOG(ERROR) << "Read request wrong.";
+    return -1;
+  }
+
+  const TensorVector *in = &reader_out->tensor_vector;
+  TensorVector *out = butil::get_object<TensorVector>();
+  int batch_size = 0;
+  if (in->at(0).lod.size() == 1) {
+    batch_size = in->at(0).lod[0].size() - 1;
+  } else {
+    batch_size = in->at(0).shape[0];
+  }
+  VLOG(2) << "infer batch size: " << batch_size;
+  // infer
+  Timer timeline;
+  double infer_time = 0.0;
+  timeline.Start();
+  if (InferManager::instance().infer(GENERAL_MODEL_NAME, in, out, batch_size)) {
+    LOG(ERROR) << "Failed do infer in fluid model: " << GENERAL_MODEL_NAME;
+    return -1;
+  }
+  timeline.Pause();
+  infer_time = timeline.ElapsedUS();
+
+  const Request *req = dynamic_cast<const Request *>(get_request_message());
+
+  VLOG(2) << "start to call load general model_conf op";
+  baidu::paddle_serving::predictor::Resource &resource =
+      baidu::paddle_serving::predictor::Resource::instance();
+
+  VLOG(2) << "get resource pointer done.";
+  std::shared_ptr<PaddleGeneralModelConfig> model_config =
+      resource.get_general_model_config();
+
+  std::vector<int> fetch_index;
+  fetch_index.resize(req->fetch_var_names_size());
+  for (int i = 0; i < req->fetch_var_names_size(); ++i) {
+    fetch_index[i] =
+        model_config->_fetch_alias_name_to_index[req->fetch_var_names(i)];
+  }
+  
+  // response inst with only fetch_var_names
+  Response *res = mutable_data<Response>();
+
+  res->set_mean_infer_us(infer_time);
+
+  for (int i = 0; i < batch_size; ++i) {
+    FetchInst *fetch_inst = res->add_insts();
+    for (auto & idx : fetch_index) {
+      Tensor *tensor = fetch_inst->add_tensor_array();
+      // currently only response float tensor or lod_tensor
+      tensor->set_elem_type(1);
+      if (model_config->_is_lod_fetch[idx]) {
+        VLOG(2) << "out[" << idx << " is lod_tensor";
+        tensor->add_shape(-1);
+      } else {
+        VLOG(2) << "out[" << idx << "] is tensor";
+        for (int k = 1; k < out->at(idx).shape.size(); ++k) {
+          VLOG(2) << "shape[" << k - 1 << "]: "
+                  << out->at(idx).shape[k];
+          tensor->add_shape(out->at(idx).shape[k]);
+        }
+      }
+    }
+  }
+
+  int var_idx = 0;
+  for (auto & idx : fetch_index) {
+    float *data_ptr = static_cast<float *>(out->at(idx).data.data());
+    int cap = 1;
+    for (int j = 1; j < out->at(idx).shape.size(); ++j) {
+      cap *= out->at(idx).shape[j];
+    }
+    if (model_config->_is_lod_fetch[idx]) {
+      for (int j = 0; j < batch_size; ++j) {
+        for (int k = out->at(idx).lod[0][j];
+             k < out->at(idx).lod[0][j + 1]; k++) {
+          res->mutable_insts(j)->mutable_tensor_array(var_idx)->add_float_data(
+              data_ptr[k]);
+        }
+      }
+    } else {
+      for (int j = 0; j < batch_size; ++j) {
+        for (int k = j * cap; k < (j + 1) * cap; ++k) {
+          res->mutable_insts(j)->mutable_tensor_array(var_idx)->add_float_data(
+              data_ptr[k]);
+        }
+      }
+    }
+    var_idx++;
+  }
+  return 0;
+}
+DEFINE_OP(GeneralTextInferOp);
+
+}  // namespace serving
+}  // namespace paddle_serving
+}  // namespace baidu

core/general-server/op/general_text_infer_op.h

+// 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.
+
+#pragma once
+#include <vector>
+#ifdef BCLOUD
+#ifdef WITH_GPU
+#include "paddle/paddle_inference_api.h"
+#else
+#include "paddle/fluid/inference/api/paddle_inference_api.h"
+#endif
+#else
+#include "paddle_inference_api.h"  // NOLINT
+#endif
+#include "core/general-server/general_model_service.pb.h"
+
+namespace baidu {
+namespace paddle_serving {
+namespace serving {
+
+class GeneralTextInferOp
+    : public baidu::paddle_serving::predictor::OpWithChannel<
+          baidu::paddle_serving::predictor::general_model::Response> {
+ public:
+  typedef std::vector<paddle::PaddleTensor> TensorVector;
+
+  DECLARE_OP(GeneralTextInferOp);
+
+  int inference();
+};
+
+}  // namespace serving
+}  // namespace paddle_serving
+}  // namespace baidu

core/general-server/op/general_text_reader_op.cpp

+// 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.
+
+#include <algorithm>
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include "core/general-server/op/general_text_reader_op.h"
+#include "core/predictor/framework/infer.h"
+#include "core/predictor/framework/memory.h"
+
+namespace baidu {
+namespace paddle_serving {
+namespace serving {
+
+using baidu::paddle_serving::predictor::MempoolWrapper;
+using baidu::paddle_serving::predictor::general_model::Tensor;
+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<const Request *>(get_request_message());
+
+  int batch_size = req->insts_size();
+  int input_var_num = 0;
+
+  std::vector<int64_t> elem_type;
+  std::vector<int64_t> elem_size;
+  std::vector<int64_t> capacity;
+
+  GeneralTextReaderOutput *res = mutable_data<GeneralTextReaderOutput>();
+  TensorVector *in = &res->tensor_vector;
+
+  if (!res) {
+    LOG(ERROR) << "Failed get op tls reader object output";
+  }
+
+  if (batch_size <= 0) {
+    res->reader_status = -1;
+    return 0;
+  }
+
+  int var_num = req->insts(0).tensor_array_size();
+  VLOG(2) << "var num: " << var_num;
+  // read config
+
+  VLOG(2) << "start to call load general model_conf op";
+  baidu::paddle_serving::predictor::Resource &resource =
+      baidu::paddle_serving::predictor::Resource::instance();
+
+  VLOG(2) << "get resource pointer done.";
+  std::shared_ptr<PaddleGeneralModelConfig> model_config =
+      resource.get_general_model_config();
+
+  VLOG(2) << "print general model config done.";
+
+  elem_type.resize(var_num);
+  elem_size.resize(var_num);
+  capacity.resize(var_num);
+  for (int i = 0; i < var_num; ++i) {
+    paddle::PaddleTensor lod_tensor;
+    elem_type[i] = req->insts(0).tensor_array(i).elem_type();
+    VLOG(2) << "var[" << i << "] has elem type: " << elem_type[i];
+    if (elem_type[i] == 0) {  // int64
+      elem_size[i] = sizeof(int64_t);
+      lod_tensor.dtype = paddle::PaddleDType::INT64;
+    } else {
+      elem_size[i] = sizeof(float);
+      lod_tensor.dtype = paddle::PaddleDType::FLOAT32;
+    }
+
+    if (req->insts(0).tensor_array(i).shape(0) == -1) {
+      lod_tensor.lod.resize(1);
+      lod_tensor.lod[0].push_back(0);
+      VLOG(2) << "var[" << i << "] is lod_tensor";
+    } else {
+      lod_tensor.shape.push_back(batch_size);
+      capacity[i] = 1;
+      for (int k = 0; k < req->insts(0).tensor_array(i).shape_size(); ++k) {
+        int dim = req->insts(0).tensor_array(i).shape(k);
+        VLOG(2) << "shape for var[" << i << "]: " << dim;
+        capacity[i] *= dim;
+        lod_tensor.shape.push_back(dim);
+      }
+      VLOG(2) << "var[" << i << "] is tensor, capacity: " << capacity[i];
+    }
+    lod_tensor.name = model_config->_feed_name[i];
+    in->push_back(lod_tensor);
+  }
+
+  for (int i = 0; i < var_num; ++i) {
+    if (in->at(i).lod.size() == 1) {
+      for (int j = 0; j < batch_size; ++j) {
+        const Tensor &tensor = req->insts(j).tensor_array(i);
+        int data_len = tensor.int_data_size();
+        int cur_len = in->at(i).lod[0].back();
+        in->at(i).lod[0].push_back(cur_len + data_len);
+      }
+      in->at(i).data.Resize(in->at(i).lod[0].back() * elem_size[i]);
+      in->at(i).shape = {in->at(i).lod[0].back(), 1};
+      VLOG(2) << "var[" << i
+              << "] is lod_tensor and len=" << in->at(i).lod[0].back();
+    } else {
+      in->at(i).data.Resize(batch_size * capacity[i] * elem_size[i]);
+      VLOG(2) << "var[" << i
+              << "] is tensor and capacity=" << batch_size * capacity[i];
+    }
+  }
+
+  for (int i = 0; i < var_num; ++i) {
+    if (elem_type[i] == 0) {
+      int64_t *dst_ptr = static_cast<int64_t *>(in->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();
+             ++k) {
+          dst_ptr[offset + k] =
+              req->insts(j).tensor_array(i).int_data(k);
+        }
+        if (in->at(i).lod.size() == 1) {
+          offset = in->at(i).lod[0][j + 1];
+        } else {
+          offset += capacity[i];
+        }
+      }
+    } else {
+      float *dst_ptr = static_cast<float *>(in->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();
+             ++k) {
+          dst_ptr[offset + k] =
+              req->insts(j).tensor_array(i).int_data(k);
+        }
+        if (in->at(i).lod.size() == 1) {
+          offset = in->at(i).lod[0][j + 1];
+        } else {
+          offset += capacity[i];
+        }
+      }
+    }
+  }
+
+  VLOG(2) << "read data from client success";
+  return 0;
+}
+DEFINE_OP(GeneralTextReaderOp);
+}  // namespace serving
+}  // namespace paddle_serving
+}  // namespace baidu

core/general-server/op/general_text_reader_op.h

+// 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.
+
+#pragma once
+#include <vector>
+#ifdef BCLOUD
+#ifdef WITH_GPU
+#include "paddle/paddle_inference_api.h"
+#else
+#include "paddle/fluid/inference/api/paddle_inference_api.h"
+#endif
+#else
+#include "paddle_inference_api.h"  // NOLINT
+#endif
+#include <string>
+#include "core/predictor/framework/resource.h"
+#include "core/general-server/general_model_service.pb.h"
+#include "core/general-server/load_general_model_service.pb.h"
+
+namespace baidu {
+namespace paddle_serving {
+namespace serving {
+
+struct GeneralTextReaderOutput {
+  std::vector<paddle::PaddleTensor> tensor_vector;
+  int reader_status = 0;
+
+  void Clear() {
+    size_t tensor_count = tensor_vector.size();
+    for (size_t ti = 0; ti < tensor_count; ++ti) {
+      tensor_vector[ti].shape.clear();
+    }
+    tensor_vector.clear();
+  }
+  std::string ShortDebugString() const { return "Not implemented!"; }
+};
+
+class GeneralTextReaderOp :
+    public baidu::paddle_serving::predictor::OpWithChannel<
+    GeneralTextReaderOutput> {
+ public:
+  typedef std::vector<paddle::PaddleTensor> TensorVector;
+
+  DECLARE_OP(GeneralTextReaderOp);
+
+  int inference();
+};
+
+}  // namespace serving
+}  // namespace paddle_serving
+}  // namespace baidu

core/general-server/proto/general_model_service.proto

@@ -21,8 +21,10 @@ option cc_generic_services = true;
 
 message Tensor {
   repeated bytes data = 1;
-  optional int32 elem_type = 2;
-  repeated int32 shape = 3;
+  repeated int32 int_data = 2;
+  repeated float float_data = 3;
+  optional int32 elem_type = 4;
+  repeated int32 shape = 5;
 };
 
 message FeedInst {

core/sdk-cpp/proto/general_model_service.proto

@@ -20,9 +20,11 @@ package baidu.paddle_serving.predictor.general_model;
 option cc_generic_services = true;
 
 message Tensor {
-  repeated bytes data = 1;
-  optional int32 elem_type = 2;
-  repeated int32 shape = 3;
+  repeated bytes data = 1; // most general format
+  repeated int32 int_data = 2; // for simple debug only
+  repeated float float_data = 3; // for simple debug only
+  optional int32 elem_type = 4; // support int64, float32
+  repeated int32 shape = 5;
 };
 
 message FeedInst {

go/client_app/acc.go

+package main
+
+import (
+       "io"
+       "os"
+       "fmt"
+       "bufio"
+       "strings"
+       "strconv"
+)
+
+func main() {
+     score_file := os.Args[1]
+     fi, err := os.Open(score_file)
+     if err != nil {
+     	fmt.Print(err)
+     }
+
+     defer fi.Close()
+     br := bufio.NewReader(fi)     
+
+     total := int(0)
+     acc := int(0)
+     for {
+     	 line, err := br.ReadString('\n')
+	 if err == io.EOF {
+	    break
+	 }
+
+	 line = strings.Trim(line, "\n")
+	 s := strings.Split(line, "\t")
+	 prob_str := strings.Trim(s[0], " ")
+	 label_str := strings.Trim(s[1], " ")
+	 prob, err := strconv.ParseFloat(prob_str, 32)
+	 if err != nil {
+	    panic(err)
+	 }
+	 label, err := strconv.ParseFloat(label_str, 32)
+	 if err != nil {
+	    panic(err)
+	 }
+	 if (prob - 0.5) * (label - 0.5) > 0 {
+	    acc++
+	 }
+	 total++
+    }
+    fmt.Println("total num: ", total)
+    fmt.Println("acc num: ", acc)
+    fmt.Println("acc: ", float32(acc) / float32(total))    
+}
\ No newline at end of file

go/client_app/imdb_client.go

+//   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.
+
+package main
+
+import (
+       "io"
+       "fmt"
+       "strings"
+       "bufio"
+       "strconv"
+       "os"
+       "serving_client"
+)
+
+func main() {
+     var config_file_path string
+     config_file_path = os.Args[1]
+     handle := serving_client.LoadModelConfig(config_file_path)
+     handle = serving_client.Connect("127.0.0.1", "9292", handle)
+
+     test_file_path := os.Args[2]
+     fi, err := os.Open(test_file_path)
+     if err != nil {
+     	fmt.Print(err)
+     }
+
+     defer fi.Close()
+     br := bufio.NewReader(fi)
+
+     fetch := []string{"cost", "acc", "prediction"}     
+
+     var result map[string][]float32
+
+     for {
+     	 line, err := br.ReadString('\n')
+	 if err == io.EOF {
+	    break
+	 }
+
+	 line = strings.Trim(line, "\n")
+
+	 var words = []int64{}
+
+	 s := strings.Split(line, " ")
+	 value, err := strconv.Atoi(s[0])
+	 var feed_int_map map[string][]int64
+
+	 for _, v := range s[1:value + 1] {
+	     int_v, _ := strconv.Atoi(v)
+	     words = append(words, int64(int_v))
+	 }
+
+	 label, err := strconv.Atoi(s[len(s)-1])
+
+	 if err != nil {
+	    panic(err)
+	 }
+
+	 feed_int_map = map[string][]int64{}
+	 feed_int_map["words"] = words
+	 feed_int_map["label"] = []int64{int64(label)}
+	 
+	 result = serving_client.Predict(handle,
+	 	 feed_int_map, fetch)
+	 fmt.Println(result["prediction"][1], "\t", int64(label))
+     }
+}
\ No newline at end of file

go/proto/general_model_config.pb.go

+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: general_model_config.proto
+
+package baidu_paddle_serving_configure
+
+import (
+	fmt "fmt"
+	proto "github.com/golang/protobuf/proto"
+	math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+
+type FeedVar struct {
+	Name                 *string  `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	AliasName            *string  `protobuf:"bytes,2,opt,name=alias_name,json=aliasName" json:"alias_name,omitempty"`
+	IsLodTensor          *bool    `protobuf:"varint,3,opt,name=is_lod_tensor,json=isLodTensor,def=0" json:"is_lod_tensor,omitempty"`
+	FeedType             *int32   `protobuf:"varint,4,opt,name=feed_type,json=feedType,def=0" json:"feed_type,omitempty"`
+	Shape                []int32  `protobuf:"varint,5,rep,name=shape" json:"shape,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *FeedVar) Reset()         { *m = FeedVar{} }
+func (m *FeedVar) String() string { return proto.CompactTextString(m) }
+func (*FeedVar) ProtoMessage()    {}
+func (*FeedVar) Descriptor() ([]byte, []int) {
+	return fileDescriptor_efa52beffa29d37a, []int{0}
+}
+
+func (m *FeedVar) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_FeedVar.Unmarshal(m, b)
+}
+func (m *FeedVar) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_FeedVar.Marshal(b, m, deterministic)
+}
+func (m *FeedVar) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FeedVar.Merge(m, src)
+}
+func (m *FeedVar) XXX_Size() int {
+	return xxx_messageInfo_FeedVar.Size(m)
+}
+func (m *FeedVar) XXX_DiscardUnknown() {
+	xxx_messageInfo_FeedVar.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FeedVar proto.InternalMessageInfo
+
+const Default_FeedVar_IsLodTensor bool = false
+const Default_FeedVar_FeedType int32 = 0
+
+func (m *FeedVar) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *FeedVar) GetAliasName() string {
+	if m != nil && m.AliasName != nil {
+		return *m.AliasName
+	}
+	return ""
+}
+
+func (m *FeedVar) GetIsLodTensor() bool {
+	if m != nil && m.IsLodTensor != nil {
+		return *m.IsLodTensor
+	}
+	return Default_FeedVar_IsLodTensor
+}
+
+func (m *FeedVar) GetFeedType() int32 {
+	if m != nil && m.FeedType != nil {
+		return *m.FeedType
+	}
+	return Default_FeedVar_FeedType
+}
+
+func (m *FeedVar) GetShape() []int32 {
+	if m != nil {
+		return m.Shape
+	}
+	return nil
+}
+
+type FetchVar struct {
+	Name                 *string  `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	AliasName            *string  `protobuf:"bytes,2,opt,name=alias_name,json=aliasName" json:"alias_name,omitempty"`
+	IsLodTensor          *bool    `protobuf:"varint,3,opt,name=is_lod_tensor,json=isLodTensor,def=0" json:"is_lod_tensor,omitempty"`
+	Shape                []int32  `protobuf:"varint,4,rep,name=shape" json:"shape,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *FetchVar) Reset()         { *m = FetchVar{} }
+func (m *FetchVar) String() string { return proto.CompactTextString(m) }
+func (*FetchVar) ProtoMessage()    {}
+func (*FetchVar) Descriptor() ([]byte, []int) {
+	return fileDescriptor_efa52beffa29d37a, []int{1}
+}
+
+func (m *FetchVar) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_FetchVar.Unmarshal(m, b)
+}
+func (m *FetchVar) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_FetchVar.Marshal(b, m, deterministic)
+}
+func (m *FetchVar) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FetchVar.Merge(m, src)
+}
+func (m *FetchVar) XXX_Size() int {
+	return xxx_messageInfo_FetchVar.Size(m)
+}
+func (m *FetchVar) XXX_DiscardUnknown() {
+	xxx_messageInfo_FetchVar.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FetchVar proto.InternalMessageInfo
+
+const Default_FetchVar_IsLodTensor bool = false
+
+func (m *FetchVar) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *FetchVar) GetAliasName() string {
+	if m != nil && m.AliasName != nil {
+		return *m.AliasName
+	}
+	return ""
+}
+
+func (m *FetchVar) GetIsLodTensor() bool {
+	if m != nil && m.IsLodTensor != nil {
+		return *m.IsLodTensor
+	}
+	return Default_FetchVar_IsLodTensor
+}
+
+func (m *FetchVar) GetShape() []int32 {
+	if m != nil {
+		return m.Shape
+	}
+	return nil
+}
+
+type GeneralModelConfig struct {
+	FeedVar              []*FeedVar  `protobuf:"bytes,1,rep,name=feed_var,json=feedVar" json:"feed_var,omitempty"`
+	FetchVar             []*FetchVar `protobuf:"bytes,2,rep,name=fetch_var,json=fetchVar" json:"fetch_var,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+	XXX_unrecognized     []byte      `json:"-"`
+	XXX_sizecache        int32       `json:"-"`
+}
+
+func (m *GeneralModelConfig) Reset()         { *m = GeneralModelConfig{} }
+func (m *GeneralModelConfig) String() string { return proto.CompactTextString(m) }
+func (*GeneralModelConfig) ProtoMessage()    {}
+func (*GeneralModelConfig) Descriptor() ([]byte, []int) {
+	return fileDescriptor_efa52beffa29d37a, []int{2}
+}
+
+func (m *GeneralModelConfig) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_GeneralModelConfig.Unmarshal(m, b)
+}
+func (m *GeneralModelConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_GeneralModelConfig.Marshal(b, m, deterministic)
+}
+func (m *GeneralModelConfig) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GeneralModelConfig.Merge(m, src)
+}
+func (m *GeneralModelConfig) XXX_Size() int {
+	return xxx_messageInfo_GeneralModelConfig.Size(m)
+}
+func (m *GeneralModelConfig) XXX_DiscardUnknown() {
+	xxx_messageInfo_GeneralModelConfig.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GeneralModelConfig proto.InternalMessageInfo
+
+func (m *GeneralModelConfig) GetFeedVar() []*FeedVar {
+	if m != nil {
+		return m.FeedVar
+	}
+	return nil
+}
+
+func (m *GeneralModelConfig) GetFetchVar() []*FetchVar {
+	if m != nil {
+		return m.FetchVar
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*FeedVar)(nil), "baidu.paddle_serving.configure.FeedVar")
+	proto.RegisterType((*FetchVar)(nil), "baidu.paddle_serving.configure.FetchVar")
+	proto.RegisterType((*GeneralModelConfig)(nil), "baidu.paddle_serving.configure.GeneralModelConfig")
+}
+
+func init() { proto.RegisterFile("general_model_config.proto", fileDescriptor_efa52beffa29d37a) }
+
+var fileDescriptor_efa52beffa29d37a = []byte{
+	// 283 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0xd0, 0x31, 0x4b, 0xc4, 0x30,
+	0x14, 0x07, 0x70, 0x72, 0x6d, 0xb9, 0xf6, 0x1d, 0x2e, 0xc1, 0xa1, 0x08, 0x1e, 0xe5, 0x16, 0xe3,
+	0x52, 0xc4, 0xf1, 0x46, 0xc5, 0x73, 0x51, 0x87, 0x72, 0xb8, 0x86, 0xd8, 0xbc, 0xb6, 0x81, 0x5c,
+	0x53, 0x92, 0xde, 0xc1, 0x2d, 0x7e, 0x13, 0xf1, 0xab, 0x4a, 0x93, 0x43, 0x9c, 0x74, 0x72, 0x7b,
+	0x79, 0xff, 0xf0, 0xde, 0xe3, 0x07, 0x17, 0x2d, 0xf6, 0x68, 0x85, 0xe6, 0x3b, 0x23, 0x51, 0xf3,
+	0xda, 0xf4, 0x8d, 0x6a, 0xcb, 0xc1, 0x9a, 0xd1, 0xd0, 0xe5, 0x9b, 0x50, 0x72, 0x5f, 0x0e, 0x42,
+	0x4a, 0x8d, 0xdc, 0xa1, 0x3d, 0xa8, 0xbe, 0x2d, 0xc3, 0x97, 0xbd, 0xc5, 0xd5, 0x07, 0x81, 0xf9,
+	0x06, 0x51, 0xbe, 0x0a, 0x4b, 0x29, 0xc4, 0xbd, 0xd8, 0x61, 0x4e, 0x0a, 0xc2, 0xb2, 0xca, 0xd7,
+	0xf4, 0x12, 0x40, 0x68, 0x25, 0x1c, 0xf7, 0xc9, 0xcc, 0x27, 0x99, 0xef, 0xbc, 0x4c, 0xf1, 0x35,
+	0x9c, 0x29, 0xc7, 0xb5, 0x91, 0x7c, 0xc4, 0xde, 0x19, 0x9b, 0x47, 0x05, 0x61, 0xe9, 0x3a, 0x69,
+	0x84, 0x76, 0x58, 0x2d, 0x94, 0x7b, 0x32, 0x72, 0xeb, 0x13, 0xba, 0x84, 0xac, 0x41, 0x94, 0x7c,
+	0x3c, 0x0e, 0x98, 0xc7, 0x05, 0x61, 0xc9, 0x9a, 0xdc, 0x54, 0xe9, 0xd4, 0xdb, 0x1e, 0x07, 0xa4,
+	0xe7, 0x90, 0xb8, 0x4e, 0x0c, 0x98, 0x27, 0x45, 0xc4, 0x92, 0x2a, 0x3c, 0x56, 0xef, 0x90, 0x6e,
+	0x70, 0xac, 0xbb, 0xff, 0xbf, 0xef, 0x7b, 0x7f, 0xfc, 0x73, 0xff, 0x27, 0x01, 0xfa, 0x18, 0x78,
+	0x9f, 0x27, 0xdd, 0x7b, 0x2f, 0x47, 0xef, 0xc0, 0x1f, 0xce, 0x0f, 0xc2, 0xe6, 0xa4, 0x88, 0xd8,
+	0xe2, 0xf6, 0xaa, 0xfc, 0x5d, 0xba, 0x3c, 0x29, 0x57, 0xf3, 0xe6, 0xc4, 0xfd, 0x30, 0x81, 0x8c,
+	0x75, 0xe7, 0x87, 0xcc, 0xfc, 0x10, 0xf6, 0xf7, 0x90, 0x60, 0x31, 0xb9, 0x85, 0xea, 0x2b, 0x00,
+	0x00, 0xff, 0xff, 0x08, 0x27, 0x9c, 0x1a, 0xfe, 0x01, 0x00, 0x00,
+}

go/serving_client/serving_client_api.go

+//   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.
+
+package serving_client
+
+import (
+       "bytes"
+       "encoding/json"
+       "io/ioutil"
+       "log"
+       "net/http"
+       pb "general_model"
+       "github.com/golang/protobuf/proto"
+)
+
+type Tensor struct {
+     Data   []byte `json:"data"`
+     FloatData	   []float32 `json:"float_data"`
+     IntData	   []int64 `json:"int_data"`
+     ElemType	int `json:"elem_type"`
+     Shape	[]int `json:"shape"`
+}
+
+type FeedInst struct {
+     TensorArray     []Tensor `json:"tensor_array"`
+}
+
+type FetchInst struct {
+     TensorArray      []Tensor `json:"tensor_array"`
+}
+
+type Request struct {
+     Insts   []FeedInst `json:"insts"`
+     FetchVarNames	[]string `json:"fetch_var_names"`
+}
+
+type Response struct {
+     Insts    []FetchInst `json:"insts"`
+     MeanInferUs	  float32 `json:"mean_infer_us"`
+}
+
+type Handle struct {
+     Url    string
+     Port   string
+     FeedAliasNameMap	map[string]string
+     FeedShapeMap	map[string][]int
+     FeedNameMap   map[string]int
+     FeedAliasNames	   []string
+     FetchNameMap  map[string]int
+     FetchAliasNameMap	map[string]string
+}
+
+func LoadModelConfig(config string) Handle {
+     in, err := ioutil.ReadFile(config)
+     if err != nil {
+     	log.Fatalln("Failed to read general model: ", err)
+     }
+     general_model_config := &pb.GeneralModelConfig{}
+     if err := proto.Unmarshal(in, general_model_config); err != nil {
+     	log.Fatalln("Failed to parse GeneralModelConfig: ", err)
+     }
+     log.Println("read protobuf succeed")
+     handle := Handle{}
+     handle.FeedNameMap = map[string]int{}
+     handle.FeedAliasNameMap = map[string]string{}
+     handle.FeedShapeMap = map[string][]int{}
+     handle.FetchNameMap = map[string]int{}
+     handle.FetchAliasNameMap = map[string]string{}
+     handle.FeedAliasNames = []string{}
+
+     for i, v := range general_model_config.FeedVar {
+     	 handle.FeedNameMap[*v.Name] = i
+	 tmp_array := []int{}
+	 for _, vv := range v.Shape {
+	     tmp_array = append(tmp_array, int(vv))
+	 }
+	 handle.FeedShapeMap[*v.Name] = tmp_array
+	 handle.FeedAliasNameMap[*v.AliasName] = *v.Name
+	 handle.FeedAliasNames = append(handle.FeedAliasNames, *v.AliasName)
+     }
+
+     for i, v := range general_model_config.FetchVar {
+     	 handle.FetchNameMap[*v.Name] = i
+	 handle.FetchAliasNameMap[*v.AliasName] = *v.Name
+     }
+
+     return handle
+}
+
+func Connect(url string, port string, handle Handle) Handle {
+     handle.Url = url
+     handle.Port = port
+     return handle
+}
+
+func Predict(handle Handle, int_feed_map map[string][]int64, fetch []string) map[string][]float32 {
+     contentType := "application/json;charset=utf-8"
+
+     var tensor_array []Tensor
+     var inst FeedInst
+     tensor_array = []Tensor{}
+     inst = FeedInst{}
+
+     for i := 0; i < len(handle.FeedAliasNames); i++ {
+     	 key_i := handle.FeedAliasNames[i]
+	 var tmp Tensor
+	 tmp.IntData = []int64{}
+	 tmp.Shape = []int{}
+	 tmp.IntData = int_feed_map[key_i]
+	 tmp.ElemType = 0
+	 tmp.Shape = handle.FeedShapeMap[key_i]
+	 tensor_array = append(tensor_array, tmp)
+     }
+
+     inst.TensorArray = tensor_array
+
+     req := &Request{
+     	 Insts: []FeedInst{inst},
+	 FetchVarNames: fetch}
+
+     b, err := json.Marshal(req)
+
+     body := bytes.NewBuffer(b)
+
+     var post_address bytes.Buffer
+     post_address.WriteString("http://")
+     post_address.WriteString(handle.Url)
+     post_address.WriteString(":")
+     post_address.WriteString(handle.Port)
+     post_address.WriteString("/GeneralModelService/inference")
+
+     resp, err := http.Post(post_address.String(), contentType, body)
+     if err != nil {
+     	log.Println("Post failed:", err)
+     }
+
+     defer resp.Body.Close()
+
+     content, err := ioutil.ReadAll(resp.Body)
+     if err != nil {
+      	log.Println("Read failed:", err)
+     }
+
+     response_json := Response{}
+     err = json.Unmarshal([]byte(content), &response_json)
+
+     var result map[string][]float32
+     result = map[string][]float32{}
+     for i, v := range fetch {
+     	 result[v] = response_json.Insts[0].TensorArray[i].FloatData
+     }
+     
+     return result
+}

python/paddle_serving_server/__init__.py

@@ -23,12 +23,12 @@ from version import serving_server_version
 
 class OpMaker(object):
     def __init__(self):
-        self.op_dict = {
-            "general_infer": "GeneralInferOp",
-            "general_reader": "GeneralReaderOp",
-            "general_single_kv": "GeneralSingleKVOp",
-            "general_dist_kv": "GeneralDistKVOp"
-        }
+        self.op_dict = {"general_infer":"GeneralInferOp",
+                        "general_text_infer":"GeneralTextInferOp",
+                        "general_reader":"GeneralReaderOp",
+                        "general_text_reader":"GeneralTextReaderOp",
+                        "general_single_kv":"GeneralSingleKVOp",
+                        "general_dist_kv":"GeneralDistKVOp"}
 
     # currently, inputs and outputs are not used
     # when we have OpGraphMaker, inputs and outputs are necessary