support int32

core/general-client/include/general_model.h

@@ -49,6 +49,8 @@ class ModelRes {
                             res._int64_value_map.end());
     _float_value_map.insert(res._float_value_map.begin(),
                             res._float_value_map.end());
+    _int32_value_map.insert(res._int32_value_map.begin(),
+                            res._int32_value_map.end());
     _shape_map.insert(res._shape_map.begin(), res._shape_map.end());
     _lod_map.insert(res._lod_map.begin(), res._lod_map.end());
   }
@@ -60,6 +62,9 @@ class ModelRes {
     _float_value_map.insert(
         std::make_move_iterator(std::begin(res._float_value_map)),
         std::make_move_iterator(std::end(res._float_value_map)));
+    _int32_value_map.insert(
+        std::make_move_iterator(std::begin(res._int32_value_map)),
+        std::make_move_iterator(std::end(res._int32_value_map)));
     _shape_map.insert(std::make_move_iterator(std::begin(res._shape_map)),
                       std::make_move_iterator(std::end(res._shape_map)));
     _lod_map.insert(std::make_move_iterator(std::begin(res._lod_map)),
@@ -78,6 +83,12 @@ class ModelRes {
   std::vector<float>&& get_float_by_name_with_rv(const std::string& name) {
     return std::move(_float_value_map[name]);
   }
+  const std::vector<int32_t>& get_int32_by_name(const std::string& name) {
+    return _int32_value_map[name];
+  }
+  std::vector<int32_t>&& get_int32_by_name_with_rv(const std::string& name) {
+    return std::move(_int32_value_map[name]);
+  }
   const std::vector<int>& get_shape_by_name(const std::string& name) {
     return _shape_map[name];
   }
@@ -103,6 +114,9 @@ class ModelRes {
       _float_value_map.insert(
           std::make_move_iterator(std::begin(res._float_value_map)),
           std::make_move_iterator(std::end(res._float_value_map)));
+      _int32_value_map.insert(
+          std::make_move_iterator(std::begin(res._int32_value_map)),
+          std::make_move_iterator(std::end(res._int32_value_map)));
       _shape_map.insert(std::make_move_iterator(std::begin(res._shape_map)),
                         std::make_move_iterator(std::end(res._shape_map)));
       _lod_map.insert(std::make_move_iterator(std::begin(res._lod_map)),
@@ -115,6 +129,7 @@ class ModelRes {
   std::string _engine_name;
   std::map<std::string, std::vector<int64_t>> _int64_value_map;
   std::map<std::string, std::vector<float>> _float_value_map;
+  std::map<std::string, std::vector<int32_t>> _int32_value_map;
   std::map<std::string, std::vector<int>> _shape_map;
   std::map<std::string, std::vector<int>> _lod_map;
 };
@@ -145,6 +160,14 @@ class PredictorRes {
                                                  const std::string& name) {
     return std::move(_models[model_idx].get_float_by_name_with_rv(name));
   }
+  const std::vector<int32_t>& get_int32_by_name(const int model_idx,
+                                                const std::string& name) {
+    return _models[model_idx].get_int32_by_name(name);
+  }
+  std::vector<int32_t>&& get_int32_by_name_with_rv(const int model_idx,
+                                                   const std::string& name) {
+    return std::move(_models[model_idx].get_int32_by_name_with_rv(name));
+  }
   const std::vector<int>& get_shape_by_name(const int model_idx,
                                             const std::string& name) {
     return _models[model_idx].get_shape_by_name(name);

core/general-client/src/general_model.cpp

@@ -207,17 +207,28 @@ int PredictorClient::batch_predict(
     for (auto &name : int_feed_name) {
       int idx = _feed_name_to_idx[name];
       Tensor *tensor = tensor_vec[idx];
-      VLOG(2) << "prepare int feed " << name << " shape size "
-              << int_shape[vec_idx].size();
+      if (_type[idx] == 0) {
+        VLOG(2) << "prepare int64 feed " << name << " shape size "
+                << int_shape[vec_idx].size();
+        VLOG(3) << "feed var name " << name << " index " << vec_idx
+                << "first data " << int_feed[vec_idx][0];
+        for (uint32_t j = 0; j < int_feed[vec_idx].size(); ++j) {
+          tensor->add_int64_data(int_feed[vec_idx][j]);
+        }
+      } else if (_type[idx] == 2) {
+        VLOG(2) << "prepare int32 feed " << name << " shape size "
+                << int_shape[vec_idx].size();
+        VLOG(3) << "feed var name " << name << " index " << vec_idx
+                << "first data " << int32_t(int_feed[vec_idx][0]);
+        for (uint32_t j = 0; j < int_feed[vec_idx].size(); ++j) {
+          tensor->add_int_data(int32_t(int_feed[vec_idx][j]));
+        }
+      }
+
       for (uint32_t j = 0; j < int_shape[vec_idx].size(); ++j) {
         tensor->add_shape(int_shape[vec_idx][j]);
       }
-      tensor->set_elem_type(0);
-      VLOG(3) << "feed var name " << name << " index " << vec_idx
-              << "first data " << int_feed[vec_idx][0];
-      for (uint32_t j = 0; j < int_feed[vec_idx].size(); ++j) {
-        tensor->add_int64_data(int_feed[vec_idx][j]);
-      }
+      tensor->set_elem_type(_type[idx]);
       vec_idx++;
     }
 
@@ -284,7 +295,7 @@ int PredictorClient::batch_predict(
       for (auto &name : fetch_name) {
         // int idx = _fetch_name_to_idx[name];
         if (_fetch_name_to_type[name] == 0) {
-          VLOG(2) << "ferch var " << name << "type int";
+          VLOG(2) << "fetch var " << name << " type int64";
           model._int64_value_map[name].resize(
               output.insts(0).tensor_array(idx).int64_data_size());
           int size = output.insts(0).tensor_array(idx).int64_data_size();
@@ -292,8 +303,8 @@ int PredictorClient::batch_predict(
             model._int64_value_map[name][i] =
                 output.insts(0).tensor_array(idx).int64_data(i);
           }
-        } else {
-          VLOG(2) << "fetch var " << name << "type float";
+        } else if (_fetch_name_to_type[name] == 1) {
+          VLOG(2) << "fetch var " << name << " type float";
           model._float_value_map[name].resize(
               output.insts(0).tensor_array(idx).float_data_size());
           int size = output.insts(0).tensor_array(idx).float_data_size();
@@ -301,7 +312,10 @@ int PredictorClient::batch_predict(
             model._float_value_map[name][i] =
                 output.insts(0).tensor_array(idx).float_data(i);
           }
+        } else if (_fetch_name_to_type[name] == 2) {
+          VLOG(2) << "fetch var " << name << " type int32";
         }
+
         idx += 1;
       }
       predict_res_batch.add_model_res(std::move(model));
@@ -448,12 +462,19 @@ int PredictorClient::numpy_predict(
     for (auto &name : int_feed_name) {
       int idx = _feed_name_to_idx[name];
       Tensor *tensor = tensor_vec[idx];
-      VLOG(2) << "prepare int feed " << name << " shape size "
-              << int_shape[vec_idx].size();
+
       for (uint32_t j = 0; j < int_shape[vec_idx].size(); ++j) {
         tensor->add_shape(int_shape[vec_idx][j]);
       }
-      tensor->set_elem_type(0);
+      tensor->set_elem_type(_type[idx]);
+
+      if (_type[idx] == 0) {
+        VLOG(2) << "prepare int feed " << name << " shape size "
+                << int_shape[vec_idx].size();
+      } else {
+        VLOG(2) << "prepare int32 feed " << name << " shape size "
+                << int_shape[vec_idx].size();
+      }
 
       const int int_shape_size = int_shape[vec_idx].size();
       switch (int_shape_size) {
@@ -463,7 +484,11 @@ int PredictorClient::numpy_predict(
             for (ssize_t j = 0; j < int_array.shape(1); j++) {
               for (ssize_t k = 0; k < int_array.shape(2); k++) {
                 for (ssize_t l = 0; k < int_array.shape(3); l++) {
-                  tensor->add_int64_data(int_array(i, j, k, l));
+                  if (_type[idx] == 0) {
+                    tensor->add_int64_data(int_array(i, j, k, l));
+                  } else {
+                    tensor->add_int_data(int_array(i, j, k, l));
+                  }
                 }
               }
             }
@@ -475,7 +500,11 @@ int PredictorClient::numpy_predict(
           for (ssize_t i = 0; i < int_array.shape(0); i++) {
             for (ssize_t j = 0; j < int_array.shape(1); j++) {
               for (ssize_t k = 0; k < int_array.shape(2); k++) {
-                tensor->add_int64_data(int_array(i, j, k));
+                if (_type[idx] == 0) {
+                  tensor->add_int64_data(int_array(i, j, k));
+                } else {
+                  tensor->add_int_data(int_array(i, j, k));
+                }
               }
             }
           }
@@ -485,7 +514,11 @@ int PredictorClient::numpy_predict(
           auto int_array = int_feed[vec_idx].unchecked<2>();
           for (ssize_t i = 0; i < int_array.shape(0); i++) {
             for (ssize_t j = 0; j < int_array.shape(1); j++) {
-              tensor->add_int64_data(int_array(i, j));
+              if (_type[idx] == 0) {
+                tensor->add_int64_data(int_array(i, j));
+              } else {
+                tensor->add_int_data(int_array(i, j));
+              }
             }
           }
           break;
@@ -493,7 +526,11 @@ int PredictorClient::numpy_predict(
         case 1: {
           auto int_array = int_feed[vec_idx].unchecked<1>();
           for (ssize_t i = 0; i < int_array.shape(0); i++) {
-            tensor->add_int64_data(int_array(i));
+            if (_type[idx] == 0) {
+              tensor->add_int64_data(int_array(i));
+            } else {
+              tensor->add_int_data(int_array(i));
+            }
           }
           break;
         }
@@ -563,7 +600,7 @@ int PredictorClient::numpy_predict(
       for (auto &name : fetch_name) {
         // int idx = _fetch_name_to_idx[name];
         if (_fetch_name_to_type[name] == 0) {
-          VLOG(2) << "ferch var " << name << "type int";
+          VLOG(2) << "ferch var " << name << "type int64";
           model._int64_value_map[name].resize(
               output.insts(0).tensor_array(idx).int64_data_size());
           int size = output.insts(0).tensor_array(idx).int64_data_size();
@@ -571,7 +608,7 @@ int PredictorClient::numpy_predict(
             model._int64_value_map[name][i] =
                 output.insts(0).tensor_array(idx).int64_data(i);
           }
-        } else {
+        } else if (_fetch_name_to_type[name] == 1) {
           VLOG(2) << "fetch var " << name << "type float";
           model._float_value_map[name].resize(
               output.insts(0).tensor_array(idx).float_data_size());
@@ -580,6 +617,15 @@ int PredictorClient::numpy_predict(
             model._float_value_map[name][i] =
                 output.insts(0).tensor_array(idx).float_data(i);
           }
+        } else if (_fetch_name_to_type[name] == 2) {
+          VLOG(2) << "fetch var " << name << "type int32";
+          model._int32_value_map[name].resize(
+              output.insts(0).tensor_array(idx).int_data_size());
+          int size = output.insts(0).tensor_array(idx).int_data_size();
+          for (int i = 0; i < size; ++i) {
+            model._int64_value_map[name][i] =
+                output.insts(0).tensor_array(idx).int_data(i);
+          }
         }
         idx += 1;
       }
@@ -613,7 +659,6 @@ int PredictorClient::numpy_predict(
   _api.thrd_clear();
   return 0;
 }
-
 }  // namespace general_model
 }  // namespace paddle_serving
 }  // namespace baidu

core/general-server/op/general_reader_op.cpp

@@ -126,9 +126,12 @@ int GeneralReaderOp::inference() {
     if (elem_type[i] == 0) {  // int64
       elem_size[i] = sizeof(int64_t);
       lod_tensor.dtype = paddle::PaddleDType::INT64;
-    } else {
+    } else if (elem_type[i] == 1) {
       elem_size[i] = sizeof(float);
       lod_tensor.dtype = paddle::PaddleDType::FLOAT32;
+    } else if (elem_type[i] == 2) {
+      elem_size[i] = sizeof(int32_t);
+      lod_tensor.dtype = paddle::PaddleDType::INT32;
     }
 
     if (model_config->_is_lod_feed[i]) {
@@ -159,8 +162,10 @@ int GeneralReaderOp::inference() {
         int data_len = 0;
         if (tensor.int64_data_size() > 0) {
           data_len = tensor.int64_data_size();
-        } else {
+        } else if (tensor.float_data_size() > 0) {
           data_len = tensor.float_data_size();
+        } else if (tensor.int_data_size() > 0) {
+          data_len = tensor.int_data_size();
         }
         VLOG(2) << "tensor size for var[" << i << "]: " << data_len;
         tensor_size += data_len;
@@ -210,7 +215,7 @@ int GeneralReaderOp::inference() {
           offset += capacity[i];
         }
       }
-    } else {
+    } else if (elem_type[i] == 1) {
       float *dst_ptr = static_cast<float *>(out->at(i).data.data());
       int offset = 0;
       for (int j = 0; j < batch_size; ++j) {
@@ -224,6 +229,20 @@ int GeneralReaderOp::inference() {
           offset += capacity[i];
         }
       }
+    } else if (elem_type[i] == 2) {
+      int32_t *dst_ptr = static_cast<int32_t *>(out->at(i).data.data());
+      int offset = 0;
+      for (int j = 0; j < batch_size; ++j) {
+        int elem_num = req->insts(j).tensor_array(i).int_data_size();
+        for (int k = 0; k < elem_num; ++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];
+        } else {
+          offset += capacity[i];
+        }
+      }
     }
   }
 

core/general-server/op/general_response_op.cpp

@@ -157,6 +157,27 @@ int GeneralResponseOp::inference() {
         }
         VLOG(2) << "fetch var [" << model_config->_fetch_name[idx] << "] ready";
         var_idx++;
+      } else if (in->at(idx).dtype == paddle::PaddleDType::INT32) {
+        VLOG(2) << "Prepare float var [" << model_config->_fetch_name[idx]
+                << "].";
+        int32_t *data_ptr = static_cast<int32_t *>(in->at(idx).data.data());
+        if (model_config->_is_lod_fetch[idx]) {
+          FetchInst *fetch_p = output->mutable_insts(0);
+          for (int j = 0; j < in->at(idx).lod[0].size(); ++j) {
+            fetch_p->mutable_tensor_array(var_idx)->add_lod(
+                in->at(idx).lod[0][j]);
+          }
+          for (int j = 0; j < cap; ++j) {
+            fetch_p->mutable_tensor_array(var_idx)->add_int_data(data_ptr[j]);
+          }
+        } else {
+          FetchInst *fetch_p = output->mutable_insts(0);
+          for (int j = 0; j < cap; ++j) {
+            fetch_p->mutable_tensor_array(var_idx)->add_int_data(data_ptr[j]);
+          }
+        }
+        VLOG(2) << "fetch var [" << model_config->_fetch_name[idx] << "] ready";
+        var_idx++;
       }
     }
   }

python/paddle_serving_client/__init__.py

@@ -28,8 +28,11 @@ sys.path.append(
     os.path.join(os.path.abspath(os.path.dirname(__file__)), 'proto'))
 from .proto import multi_lang_general_model_service_pb2_grpc
 
-int_type = 0
-float_type = 1
+int64_type = 0
+float32_type = 1
+int32_type = 2
+int_type = set([int64_type, int32_type])
+float_type = set([float32_type])
 
 
 class _NOPProfiler(object):
@@ -279,7 +282,7 @@ class Client(object):
                     raise ValueError("Wrong feed name: {}.".format(key))
                 #if not isinstance(feed_i[key], np.ndarray):
                 self.shape_check(feed_i, key)
-                if self.feed_types_[key] == int_type:
+                if self.feed_types_[key] in int_type:
                     if i == 0:
                         int_feed_names.append(key)
                         if isinstance(feed_i[key], np.ndarray):
@@ -292,7 +295,7 @@ class Client(object):
                     else:
                         int_slot.append(feed_i[key])
                         self.all_numpy_input = False
-                elif self.feed_types_[key] == float_type:
+                elif self.feed_types_[key] in float_type:
                     if i == 0:
                         float_feed_names.append(key)
                         if isinstance(feed_i[key], np.ndarray):
@@ -339,7 +342,7 @@ class Client(object):
             result_map = {}
             # result map needs to be a numpy array
             for i, name in enumerate(fetch_names):
-                if self.fetch_names_to_type_[name] == int_type:
+                if self.fetch_names_to_type_[name] == int64_type:
                     # result_map[name] will be py::array(numpy array)
                     result_map[name] = result_batch_handle.get_int64_by_name(
                         mi, name)
@@ -348,7 +351,7 @@ class Client(object):
                     if name in self.lod_tensor_set:
                         result_map["{}.lod".format(
                             name)] = result_batch_handle.get_lod(mi, name)
-                elif self.fetch_names_to_type_[name] == float_type:
+                elif self.fetch_names_to_type_[name] == float32_type:
                     result_map[name] = result_batch_handle.get_float_by_name(
                         mi, name)
                     shape = result_batch_handle.get_shape(mi, name)
@@ -356,6 +359,16 @@ class Client(object):
                     if name in self.lod_tensor_set:
                         result_map["{}.lod".format(
                             name)] = result_batch_handle.get_lod(mi, name)
+
+                elif self.fetch_names_to_type_[name] == int32_type:
+                    # result_map[name] will be py::array(numpy array)
+                    result_map[name] = result_batch_handle.get_int32_by_name(
+                        mi, name)
+                    shape = result_batch_handle.get_shape(mi, name)
+                    result_map[name].shape = shape
+                    if name in self.lod_tensor_set:
+                        result_map["{}.lod".format(
+                            name)] = result_batch_handle.get_lod(mi, name)
             multi_result_map.append(result_map)
         ret = None
         if len(model_engine_names) == 1:
@@ -454,6 +467,8 @@ class MultiLangClient(object):
                             data = np.array(var, dtype="int64")
                         elif v_type == 1:  # float32
                             data = np.array(var, dtype="float32")
+                        elif v_type == 2:  #int32
+                            data = np.array(var, dtype="int32")
                         else:
                             raise Exception("error type.")
                     else:
@@ -472,6 +487,11 @@ class MultiLangClient(object):
                             tensor.float_data.extend(var.reshape(-1).tolist())
                         else:
                             tensor.float_data.extend(self._flatten_list(var))
+                    elif v_type == 2:  #int32
+                        if isinstance(car, np.array):
+                            tensor.int_data.extend(var.reshape(-1).tolist())
+                        else:
+                            tensor.int_data.extend(self._flatten_list(var))
                     else:
                         raise Exception("error type.")
                 if isinstance(var, np.ndarray):
@@ -503,6 +523,9 @@ class MultiLangClient(object):
                 elif v_type == 1:  # float32
                     result_map[name] = np.array(
                         list(var.float_data), dtype="float32")
+                elif v_type == 2:  # int32
+                    result_map[name] = np.array(
+                        list(var.int_data), dtype="int32")
                 else:
                     raise Exception("error type.")
             result_map[name].shape = list(var.shape)

python/paddle_serving_client/io/__init__.py

@@ -48,16 +48,18 @@ def save_model(server_model_folder,
 
     config = model_conf.GeneralModelConfig()
 
+    #int64 = 0; float32 = 1; int32 = 2;
     for key in feed_var_dict:
         feed_var = model_conf.FeedVar()
         feed_var.alias_name = key
         feed_var.name = feed_var_dict[key].name
         feed_var.is_lod_tensor = feed_var_dict[key].lod_level >= 1
-        if feed_var_dict[key].dtype == core.VarDesc.VarType.INT32 or \
-           feed_var_dict[key].dtype == core.VarDesc.VarType.INT64:
+        if feed_var_dict[key].dtype == core.VarDesc.VarType.INT64:
             feed_var.feed_type = 0
         if feed_var_dict[key].dtype == core.VarDesc.VarType.FP32:
             feed_var.feed_type = 1
+        if feed_var_dict[key].dtype == core.VarDesc.VarType.INT32:
+            feed_var.feed_type = 2
         if feed_var.is_lod_tensor:
             feed_var.shape.extend([-1])
         else:
@@ -73,13 +75,12 @@ def save_model(server_model_folder,
         fetch_var.alias_name = key
         fetch_var.name = fetch_var_dict[key].name
         fetch_var.is_lod_tensor = fetch_var_dict[key].lod_level >= 1
-        if fetch_var_dict[key].dtype == core.VarDesc.VarType.INT32 or \
-           fetch_var_dict[key].dtype == core.VarDesc.VarType.INT64:
+        if fetch_var_dict[key].dtype == core.VarDesc.VarType.INT64:
             fetch_var.fetch_type = 0
-
         if fetch_var_dict[key].dtype == core.VarDesc.VarType.FP32:
             fetch_var.fetch_type = 1
-
+        if fetch_var_dict[key].dtype == core.VarDesc.VarType.INT32:
+            fetch_var.fetch_type = 2
         if fetch_var.is_lod_tensor:
             fetch_var.shape.extend([-1])
         else: