api_paddle_mobile.cc 7.3 KB
Newer Older
N
nhzlx 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
// Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "io/api_paddle_mobile.h"
H
hjchen2 已提交
16
#include <string>
N
nhzlx 已提交
17
#include <vector>
18
#include "common/enforce.h"
N
nhzlx 已提交
19 20 21 22
#include "framework/tensor.h"

namespace paddle_mobile {

23 24
template <typename Device, typename T>
PaddleMobilePredictor<Device, T>::PaddleMobilePredictor(
N
nhzlx 已提交
25 26 27 28 29 30
    const PaddleMobileConfig &config) {
  PADDLE_MOBILE_ENFORCE(Init(config) == true,
                        "paddle mobile predictor init failed!");
  config_ = config;
}

31 32 33
template <typename Device, typename T>
bool PaddleMobilePredictor<Device, T>::Init(const PaddleMobileConfig &config) {
  paddle_mobile_.reset(new PaddleMobile<Device, T>());
Y
yangfei 已提交
34 35 36
#ifdef PADDLE_MOBILE_CL
  paddle_mobile_->SetCLPath(config.cl_path);
#endif
xiebaiyuan's avatar
xiebaiyuan 已提交
37 38 39 40 41 42 43
  if (config.memory_pack.from_memory) {
    DLOG << "load from memory!";
    paddle_mobile_->LoadCombinedMemory(config.memory_pack.model_size,
                                       config.memory_pack.model_buf,
                                       config.memory_pack.combined_params_size,
                                       config.memory_pack.combined_params_buf);
  } else if (!config.model_dir.empty()) {
N
nhzlx 已提交
44
    paddle_mobile_->Load(config.model_dir, config.optimize,
Z
zhangyang0701 已提交
45 46
                         config.quantification, config.batch_size,
                         config.lod_mode);
N
nhzlx 已提交
47 48
  } else if (!config.prog_file.empty() && !config.param_file.empty()) {
    paddle_mobile_->Load(config.prog_file, config.param_file, config.optimize,
Z
zhangyang0701 已提交
49 50
                         config.quantification, config.batch_size,
                         config.lod_mode);
N
nhzlx 已提交
51 52 53 54 55 56 57 58
  } else {
    LOG(kLOG_ERROR) << "fail to load inference model!";
    return false;
  }
  // If the openmp is open, set the thread num
  paddle_mobile_->SetThreadNum(config.thread_num);
  return true;
}
59 60
template <typename Device, typename T>
bool PaddleMobilePredictor<Device, T>::Run(
N
nhzlx 已提交
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
    const std::vector<PaddleTensor> &inputs,
    std::vector<PaddleTensor> *output_data, int batch_size) {
  if (inputs.empty()) {
    LOG(kLOG_ERROR) << "At least one output should be set with tensors' names.";
    return false;
  }
  auto input = inputs[0];

  if (input.shape.size() != 4) {
    LOG(kLOG_ERROR) << "input shape not equal to 4!";
    return false;
  }
  std::vector<int64_t> dims;
  for (auto d : input.shape) {
    dims.push_back(static_cast<int64_t>(d));
  }

  // use tensor
  framework::DDim ddim =
      framework::make_ddim({dims[0], dims[1], dims[2], dims[3]});

  framework::Tensor input_tensor;
  input_tensor.Resize(ddim);
  int input_length = framework::product(ddim);
85
  auto input_ptr = input_tensor.mutable_data<T>();
N
nhzlx 已提交
86

87 88 89 90
  memcpy(input_ptr, static_cast<T *>(input.data.data()),
         input_length * sizeof(T));
  paddle_mobile_->Predict(input_tensor);
  auto output_tensor = paddle_mobile_->Fetch();
N
nhzlx 已提交
91 92 93 94 95 96 97 98 99 100 101 102 103 104 105

  if (output_data->empty()) {
    LOG(kLOG_ERROR) << "At least one output should be set with tensors' names.";
    return false;
  }

  auto &output = (*output_data)[0];
  int output_length = output_tensor->numel();
  std::vector<int64_t> tensor_shape =
      framework::vectorize(output_tensor->dims());

  for (auto d : tensor_shape) {
    output.shape.push_back(static_cast<int>(d));
  }

106 107
  if (output.data.length() < output_length * sizeof(T)) {
    output.data.Resize(output_length * sizeof(T));
N
nhzlx 已提交
108 109
  }

110 111
  memcpy(output.data.data(), output_tensor->template data<T>(),
         output_length * sizeof(T));
N
nhzlx 已提交
112 113 114 115

  return true;
}

Z
zhangyang0701 已提交
116
#ifdef PADDLE_MOBILE_FPGA
117 118 119 120 121 122 123
void ConvertPaddleTensors(const PaddleTensor &src, framework::Tensor *des) {
  des->Resize(framework::make_ddim(src.shape));
  des->external_data = src.data.data();
  des->set_type(src.dtypeid);
  des->layout =
      src.layout == LAYOUT_HWC ? framework::LAYOUT_HWC : framework::LAYOUT_CHW;
}
Z
zhangyang0701 已提交
124

125 126 127 128
void ConvertTensors(const framework::Tensor &src, PaddleTensor *des) {
  des->shape = framework::vectorize2int(src.dims());
  des->dtypeid = src.type();
  des->layout = src.layout == framework::LAYOUT_HWC ? LAYOUT_HWC : LAYOUT_CHW;
Z
zhangyang0701 已提交
129

130
  auto num = src.numel();
131
  if (src.type() == type_id<float>()) {
132 133 134 135 136
    des->data.Reset(const_cast<float *>(src.data<float>()),
                    num * sizeof(float));
  } else {
    des->data.Reset(const_cast<int16_t *>(src.data<int16_t>()),
                    num * sizeof(int16_t));
Z
zhangyang0701 已提交
137
  }
138
}
Z
zhangyang0701 已提交
139

140 141 142 143 144 145
template <typename Device, typename T>
void PaddleMobilePredictor<Device, T>::FeedPaddleTensors(
    const std::vector<PaddleTensor> &inputs) {
  auto num = inputs.size();
  std::vector<framework::Tensor> tensors(num, framework::Tensor());
  for (int i = 0; i < num; i++) {
146
    tensors[i].init(type_id<float>());
147
    ConvertPaddleTensors(inputs[i], &tensors[i]);
Z
zhangyang0701 已提交
148
  }
149
  paddle_mobile_->FeedTensorData(tensors);
150
}
Z
zhangyang0701 已提交
151

152 153 154
template <typename Device, typename T>
void PaddleMobilePredictor<Device, T>::FetchPaddleTensors(
    std::vector<PaddleTensor> *outputs) {
155 156 157 158 159
  //  auto num = outputs->size();
  //  PADDLE_MOBILE_ENFORCE(num > 0, "0 output pointers is not permitted");
  //  std::vector<framework::Tensor *> tensors(num, nullptr);
  outputs->clear();
  std::vector<framework::Tensor *> tensors;
160
  paddle_mobile_->GetTensorResults(&tensors);
161 162
  auto num = tensors.size();
  outputs->resize(num, PaddleTensor());
163 164
  for (int i = 0; i < num; i++) {
    ConvertTensors(*tensors[i], &(*outputs)[i]);
Z
zhangyang0701 已提交
165 166 167
  }
}

168 169 170 171 172
template <typename Device, typename T>
void PaddleMobilePredictor<Device, T>::GetPaddleTensor(const std::string &name,
                                                       PaddleTensor *output) {
  framework::Tensor *t = paddle_mobile_->GetTensorByName(name);
  ConvertTensors(*t, output);
Z
zhangyang0701 已提交
173
}
174

175 176 177 178 179
template <typename Device, typename T>
void PaddleMobilePredictor<Device, T>::Predict_From_To(int start, int end) {
  paddle_mobile_->Predict_From_To(start, end);
}

Z
zhangyang0701 已提交
180
#endif
181 182
template <typename Device, typename T>
PaddleMobilePredictor<Device, T>::~PaddleMobilePredictor() {
L
liuruilong 已提交
183 184 185
  paddle_mobile_->Clear();
}

N
nhzlx 已提交
186 187 188 189 190 191 192 193
// A factory to help create difference predictor.
template <>
std::unique_ptr<PaddlePredictor>
CreatePaddlePredictor<PaddleMobileConfig, PaddleEngineKind::kPaddleMobile>(
    const PaddleMobileConfig &config) {
  std::unique_ptr<PaddlePredictor> x;
  if (config.precision == PaddleMobileConfig::FP32) {
    if (config.device == PaddleMobileConfig::kCPU) {
194
      x.reset(new PaddleMobilePredictor<CPU, float>(config));
N
nhzlx 已提交
195
    } else if (config.device == PaddleMobileConfig::kFPGA) {
196
      x.reset(new PaddleMobilePredictor<FPGA, float>(config));
N
nhzlx 已提交
197
    } else if (config.device == PaddleMobileConfig::kGPU_MALI) {
198
      x.reset(new PaddleMobilePredictor<GPU_MALI, float>(config));
L
liuruilong 已提交
199
    } else if (config.device == PaddleMobileConfig::kGPU_CL) {
200
      x.reset(new PaddleMobilePredictor<GPU_CL, float>(config));
N
nhzlx 已提交
201 202 203 204 205 206 207 208 209 210 211 212
    } else {
      LOG(kLOG_ERROR) << "unsupport device type!";
      return nullptr;
    }
  } else {
    LOG(kLOG_ERROR) << "unsupport precision type!";
    return nullptr;
  }
  return std::move(x);
}

}  // namespace paddle_mobile