mirror of
https://github.com/PaddlePaddle/FastDeploy.git
synced 2025-10-31 20:02:53 +08:00
c8d6c8244e
* add yolo cuda preprocessing * cmake build cuda src * yolov5 support cuda preprocessing * yolov5 cuda preprocessing configurable * yolov5 update get mat data api * yolov5 check cuda preprocess args * refactor cuda function name * yolo cuda preprocess padding value configurable * yolov5 release cuda memory * cuda preprocess pybind api update * move use_cuda_preprocessing option to yolov5 model * yolov5lite cuda preprocessing * yolov6 cuda preprocessing * yolov7 cuda preprocessing * yolov7_e2e cuda preprocessing * remove cuda preprocessing in runtime option * refine log and cmake variable name * fix model runtime ptr type Co-authored-by: Jason <jiangjiajun@baidu.com>
112 lines
4.1 KiB
C++
112 lines
4.1 KiB
C++
// Copyright (c) 2022 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 "fastdeploy/runtime.h"
|
|
|
|
namespace fastdeploy {
|
|
|
|
/*! @brief Base model object for all the vision models
|
|
*/
|
|
class FASTDEPLOY_DECL FastDeployModel {
|
|
public:
|
|
/// Get model's name
|
|
virtual std::string ModelName() const { return "NameUndefined"; }
|
|
|
|
/** \brief Inference the model by the runtime. This interface is included in the `Predict()` function, so we don't call `Infer()` directly in most common situation
|
|
*/
|
|
virtual bool Infer(std::vector<FDTensor>& input_tensors,
|
|
std::vector<FDTensor>* output_tensors);
|
|
|
|
RuntimeOption runtime_option;
|
|
/** \brief Model's valid cpu backends. This member defined all the cpu backends have successfully tested for the model
|
|
*/
|
|
std::vector<Backend> valid_cpu_backends = {Backend::ORT};
|
|
/** Model's valid gpu backends. This member defined all the gpu backends have successfully tested for the model
|
|
*/
|
|
std::vector<Backend> valid_gpu_backends = {Backend::ORT};
|
|
/// Get number of inputs for this model
|
|
virtual int NumInputsOfRuntime() { return runtime_->NumInputs(); }
|
|
/// Get number of outputs for this model
|
|
virtual int NumOutputsOfRuntime() { return runtime_->NumOutputs(); }
|
|
/// Get input information for this model
|
|
virtual TensorInfo InputInfoOfRuntime(int index) {
|
|
return runtime_->GetInputInfo(index);
|
|
}
|
|
/// Get output information for this model
|
|
virtual TensorInfo OutputInfoOfRuntime(int index) {
|
|
return runtime_->GetOutputInfo(index);
|
|
}
|
|
/// Check if the model is initialized successfully
|
|
virtual bool Initialized() const {
|
|
return runtime_initialized_ && initialized;
|
|
}
|
|
|
|
/** \brief This is a debug interface, used to record the time of backend runtime
|
|
*
|
|
* example code @code
|
|
* auto model = fastdeploy::vision::PPYOLOE("model.pdmodel", "model.pdiparams", "infer_cfg.yml");
|
|
* if (!model.Initialized()) {
|
|
* std::cerr << "Failed to initialize." << std::endl;
|
|
* return -1;
|
|
* }
|
|
* model.EnableRecordTimeOfRuntime();
|
|
* cv::Mat im = cv::imread("test.jpg");
|
|
* for (auto i = 0; i < 1000; ++i) {
|
|
* fastdeploy::vision::DetectionResult result;
|
|
* model.Predict(&im, &result);
|
|
* }
|
|
* model.PrintStatisInfoOfRuntime();
|
|
* @endcode After called the `PrintStatisInfoOfRuntime()`, the statistical information of runtime will be printed in the console
|
|
*/
|
|
virtual void EnableRecordTimeOfRuntime() {
|
|
time_of_runtime_.clear();
|
|
std::vector<double>().swap(time_of_runtime_);
|
|
enable_record_time_of_runtime_ = true;
|
|
}
|
|
|
|
/** \brief Disable to record the time of backend runtime, see `EnableRecordTimeOfRuntime()` for more detail
|
|
*/
|
|
virtual void DisableRecordTimeOfRuntime() {
|
|
enable_record_time_of_runtime_ = false;
|
|
}
|
|
|
|
/** \brief Print the statistic information of runtime in the console, see function `EnableRecordTimeOfRuntime()` for more detail
|
|
*/
|
|
virtual std::map<std::string, float> PrintStatisInfoOfRuntime();
|
|
|
|
/** \brief Check if the `EnableRecordTimeOfRuntime()` method is enabled.
|
|
*/
|
|
virtual bool EnabledRecordTimeOfRuntime() {
|
|
return enable_record_time_of_runtime_;
|
|
}
|
|
|
|
protected:
|
|
virtual bool InitRuntime();
|
|
virtual bool CreateCpuBackend();
|
|
virtual bool CreateGpuBackend();
|
|
bool initialized = false;
|
|
std::vector<Backend> valid_external_backends;
|
|
|
|
private:
|
|
std::shared_ptr<Runtime> runtime_;
|
|
bool runtime_initialized_ = false;
|
|
// whether to record inference time
|
|
bool enable_record_time_of_runtime_ = false;
|
|
|
|
// record inference time for backend
|
|
std::vector<double> time_of_runtime_;
|
|
};
|
|
|
|
} // namespace fastdeploy
|