@@ -18,76 +18,102 @@ void BindPaddleClas(pybind11::module& m) {
1818 pybind11::class_<vision::classification::PaddleClasPreprocessor>(
1919 m, " PaddleClasPreprocessor"
2020 .def (pybind11::init<std::string>())
21- .
def (
" run" , [](vision::classification::PaddleClasPreprocessor& self, std::vector<pybind11::array>& im_list) {
22- std::vector<vision::FDMat> images;
23- for (size_t i = 0 ; i < im_list.size (); ++i) {
24- images.push_back (vision::WrapMat (PyArrayToCvMat (im_list[i])));
25- }
26- std::vector<FDTensor> outputs;
27- if (!self.Run (&images, &outputs)) {
28- throw std::runtime_error (" Failed to preprocess the input data in PaddleClasPreprocessor."
29- }
30- if (!self.WithGpu ()) {
31- for (size_t i = 0 ; i < outputs.size (); ++i) {
32- outputs[i].StopSharing ();
33- }
34- }
35- return outputs;
36- })
37- .def (" use_gpu" int gpu_id = -1 ) {
38- self.UseGpu (gpu_id);
39- })
40- .def (" disable_normalize"
41- self.DisableNormalize ();
42- })
43- .def (" disable_permute"
44- self.DisablePermute ();
45- });
21+ .def (" run"
22+ [](vision::classification::PaddleClasPreprocessor& self,
23+ std::vector<pybind11::array>& im_list) {
24+ std::vector<vision::FDMat> images;
25+ for (size_t i = 0 ; i < im_list.size (); ++i) {
26+ images.push_back (vision::WrapMat (PyArrayToCvMat (im_list[i])));
27+ }
28+ std::vector<FDTensor> outputs;
29+ if (!self.Run (&images, &outputs)) {
30+ throw std::runtime_error (
31+ " Failed to preprocess the input data in "
32+ " PaddleClasPreprocessor."
33+ }
34+ if (!self.CudaUsed ()) {
35+ for (size_t i = 0 ; i < outputs.size (); ++i) {
36+ outputs[i].StopSharing ();
37+ }
38+ }
39+ return outputs;
40+ })
41+ .def (" use_cuda"
42+ [](vision::classification::PaddleClasPreprocessor& self,
43+ bool enable_cv_cuda = false ,
44+ int gpu_id = -1 ) { self.UseCuda (enable_cv_cuda, gpu_id); })
45+ .def (" disable_normalize"
46+ [](vision::classification::PaddleClasPreprocessor& self) {
47+ self.DisableNormalize ();
48+ })
49+ .def (" disable_permute"
50+ [](vision::classification::PaddleClasPreprocessor& self) {
51+ self.DisablePermute ();
52+ });
4653
4754 pybind11::class_<vision::classification::PaddleClasPostprocessor>(
4855 m, " PaddleClasPostprocessor"
4956 .def (pybind11::init<int >())
50- .def (" run"
51- std::vector<vision::ClassifyResult> results;
52- if (!self.Run (inputs, &results)) {
53- throw std::runtime_error (" Failed to postprocess the runtime result in PaddleClasPostprocessor."
54- }
55- return results;
56- })
57- .
def (
" run" , [](vision::classification::PaddleClasPostprocessor& self, std::vector<pybind11::array>& input_array) {
58- std::vector<vision::ClassifyResult> results;
59- std::vector<FDTensor> inputs;
60- PyArrayToTensorList (input_array, &inputs, /* share_buffer=*/ true );
61- if (!self.Run (inputs, &results)) {
62- throw std::runtime_error (" Failed to postprocess the runtime result in PaddleClasPostprocessor."
63- }
64- return results;
65- })
66- .def_property (" topk"
57+ .def (" run"
58+ [](vision::classification::PaddleClasPostprocessor& self,
59+ std::vector<FDTensor>& inputs) {
60+ std::vector<vision::ClassifyResult> results;
61+ if (!self.Run (inputs, &results)) {
62+ throw std::runtime_error (
63+ " Failed to postprocess the runtime result in "
64+ " PaddleClasPostprocessor."
65+ }
66+ return results;
67+ })
68+ .def (" run"
69+ [](vision::classification::PaddleClasPostprocessor& self,
70+ std::vector<pybind11::array>& input_array) {
71+ std::vector<vision::ClassifyResult> results;
72+ std::vector<FDTensor> inputs;
73+ PyArrayToTensorList (input_array, &inputs, /* share_buffer=*/ true );
74+ if (!self.Run (inputs, &results)) {
75+ throw std::runtime_error (
76+ " Failed to postprocess the runtime result in "
77+ " PaddleClasPostprocessor."
78+ }
79+ return results;
80+ })
81+ .def_property (" topk"
82+ &vision::classification::PaddleClasPostprocessor::GetTopk,
83+ &vision::classification::PaddleClasPostprocessor::SetTopk);
6784
6885 pybind11::class_<vision::classification::PaddleClasModel, FastDeployModel>(
6986 m, " PaddleClasModel"
7087 .def (pybind11::init<std::string, std::string, std::string, RuntimeOption,
7188 ModelFormat>())
72- .def (" clone"
73- return self.Clone ();
74- })
75- .def (" predict"
76- cv::Mat im = PyArrayToCvMat (data);
77- vision::ClassifyResult result;
78- self.Predict (im, &result);
79- return result;
80- })
81- .
def (
" batch_predict" , [](vision::classification::PaddleClasModel& self, std::vector<pybind11::array>& data) {
82- std::vector<cv::Mat> images;
83- for (size_t i = 0 ; i < data.size (); ++i) {
84- images.push_back (PyArrayToCvMat (data[i]));
85- }
86- std::vector<vision::ClassifyResult> results;
87- self.BatchPredict (images, &results);
88- return results;
89- })
90- .def_property_readonly (" preprocessor"
91- .def_property_readonly (" postprocessor"
89+ .def (" clone"
90+ [](vision::classification::PaddleClasModel& self) {
91+ return self.Clone ();
92+ })
93+ .def (" predict"
94+ [](vision::classification::PaddleClasModel& self,
95+ pybind11::array& data) {
96+ cv::Mat im = PyArrayToCvMat (data);
97+ vision::ClassifyResult result;
98+ self.Predict (im, &result);
99+ return result;
100+ })
101+ .def (" batch_predict"
102+ [](vision::classification::PaddleClasModel& self,
103+ std::vector<pybind11::array>& data) {
104+ std::vector<cv::Mat> images;
105+ for (size_t i = 0 ; i < data.size (); ++i) {
106+ images.push_back (PyArrayToCvMat (data[i]));
107+ }
108+ std::vector<vision::ClassifyResult> results;
109+ self.BatchPredict (images, &results);
110+ return results;
111+ })
112+ .def_property_readonly (
113+ " preprocessor"
114+ &vision::classification::PaddleClasModel::GetPreprocessor)
115+ .def_property_readonly (
116+ " postprocessor"
117+ &vision::classification::PaddleClasModel::GetPostprocessor);
92118}
93119} // namespace fastdeploy
0 commit comments