Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commit2466922

Browse files
alexlyulkovAlexander Lyulkov
authored and
Alexander Lyulkov
committed
Added int64 and int32 support for dnn(Rebased)
1 parenta291ca2 commit2466922

21 files changed

+405
-97
lines changed

‎modules/dnn/src/layer.cpp‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -253,6 +253,18 @@ void Layer::getTypes(const std::vector<MatType>&inputs,
253253
std::vector<MatType>&internals)const
254254
{
255255
CV_Assert(inputs.size());
256+
for (auto input : inputs)
257+
if (preferableTarget == DNN_TARGET_OPENCL_FP16
258+
|| preferableTarget == DNN_TARGET_CPU_FP16
259+
|| preferableTarget == DNN_TARGET_CUDA_FP16)
260+
{
261+
CV_Assert(input == CV_16S || input == CV_8S);
262+
}
263+
else
264+
{
265+
CV_Assert(input == CV_32F || input == CV_8S);
266+
}
267+
256268
outputs.assign(requiredOutputs, inputs[0]);
257269
internals.assign(requiredInternals, inputs[0]);
258270
}

‎modules/dnn/src/layer_internals.hpp‎

Lines changed: 27 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -154,6 +154,12 @@ struct DataLayer : public Layer
154154

155155
for (int i =0; i < inputsData.size(); ++i)
156156
{
157+
if (inputsData[i].type() == CV_32S || inputsData[i].type() == CV_64S) {
158+
CV_Assert(outputs[i].type() == inputsData[i].type());
159+
CV_Assert(means[i] ==Scalar() && scaleFactors[i] ==1.0);
160+
inputsData[i].copyTo(outputs[i]);
161+
continue;
162+
}
157163
double scale = scaleFactors[i];
158164
Scalar& mean = means[i];
159165

@@ -216,6 +222,12 @@ struct DataLayer : public Layer
216222

217223
for (int i =0; i < inputsData.size(); ++i)
218224
{
225+
if (inputsData[i].type() == CV_32S || inputsData[i].type() == CV_64S) {
226+
CV_Assert(outputs[i].type() == inputsData[i].type());
227+
CV_Assert(means[i] ==Scalar() && scaleFactors[i] ==1.0);
228+
inputsData[i].copyTo(outputs[i]);
229+
continue;
230+
}
219231
Mat inputData = inputsData[i];
220232

221233
double scale = scaleFactors[i];
@@ -228,10 +240,11 @@ struct DataLayer : public Layer
228240
CV_CheckTypeEQ(outputs[i].type(), CV_32FC1,"");
229241

230242
bool singleMean =true;
231-
for (int j =1; j <std::min(4, inputData.size[1]) && singleMean; ++j)
232-
{
233-
singleMean = mean[j] == mean[j -1];
234-
}
243+
if (mean !=Scalar())
244+
for (int j =1; j <std::min(4, inputData.size[1]) && singleMean; ++j)
245+
{
246+
singleMean = mean[j] == mean[j -1];
247+
}
235248

236249
if (singleMean)
237250
{
@@ -311,6 +324,16 @@ struct DataLayer : public Layer
311324
returnfalse;
312325
}
313326

327+
voidgetTypes(const std::vector<MatType>& inputs,
328+
constint requiredOutputs,
329+
constint requiredInternals,
330+
std::vector<MatType>& outputs,
331+
std::vector<MatType>& internals)const
332+
{
333+
CV_Assert(inputs.size());
334+
outputs = inputs;
335+
}
336+
314337
virtualvoidfinalize(InputArrayOfArrays, OutputArrayOfArrays outputs_arr) CV_OVERRIDE
315338
{
316339
std::vector<Mat> outputs;

‎modules/dnn/src/layers/arg_layer.cpp‎

Lines changed: 10 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -72,6 +72,15 @@ class ArgLayerImpl CV_FINAL : public ArgLayer
7272
returnfalse;
7373
}
7474

75+
virtualvoidgetTypes(const std::vector<MatType>& inputs,
76+
constint requiredOutputs,
77+
constint requiredInternals,
78+
std::vector<MatType>& outputs,
79+
std::vector<MatType>& internals)const
80+
{
81+
outputs.assign(1, CV_64S);
82+
}
83+
7584
voidforward(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr, OutputArrayOfArrays internals_arr) CV_OVERRIDE
7685
{
7786
CV_TRACE_FUNCTION();
@@ -98,7 +107,7 @@ class ArgLayerImpl CV_FINAL : public ArgLayer
98107
}
99108

100109
output = output.reshape(1, outShape);
101-
output.convertTo(outputs[0],CV_32FC1);
110+
output.convertTo(outputs[0],CV_64SC1);
102111
}
103112

104113
private:

‎modules/dnn/src/layers/blank_layer.cpp‎

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -82,6 +82,17 @@ class BlankLayerImpl CV_FINAL : public BlankLayer
8282
returntrue;
8383
}
8484

85+
voidgetTypes(const std::vector<MatType>& inputs,
86+
constint requiredOutputs,
87+
constint requiredInternals,
88+
std::vector<MatType>& outputs,
89+
std::vector<MatType>& internals)const
90+
{
91+
CV_Assert(inputs.size());
92+
outputs = inputs;
93+
}
94+
95+
8596
#ifdef HAVE_OPENCL
8697
boolforward_ocl(InputArrayOfArrays inputs_, OutputArrayOfArrays outputs_, OutputArrayOfArrays internals_)
8798
{

‎modules/dnn/src/layers/concat_layer.cpp‎

Lines changed: 15 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -115,6 +115,19 @@ class ConcatLayerImpl CV_FINAL : public ConcatLayer
115115
returnfalse;
116116
}
117117

118+
virtualvoidgetTypes(const std::vector<MatType>& inputs,
119+
constint requiredOutputs,
120+
constint requiredInternals,
121+
std::vector<MatType>& outputs,
122+
std::vector<MatType>& internals)const CV_OVERRIDE
123+
{
124+
CV_Assert(inputs.size());
125+
for (int i =1; i < inputs.size(); i++)
126+
CV_Assert(inputs[i] == inputs[0]);
127+
outputs.assign(1, inputs[0]);
128+
}
129+
130+
118131
virtualboolsupportBackend(int backendId) CV_OVERRIDE
119132
{
120133
#ifdef HAVE_TIMVX
@@ -273,7 +286,7 @@ class ConcatLayerImpl CV_FINAL : public ConcatLayer
273286
CV_TRACE_ARG_VALUE(name,"name", name.c_str());
274287

275288
CV_OCL_RUN(IS_DNN_OPENCL_TARGET(preferableTarget) &&
276-
inputs_arr.depth()!= CV_8S,
289+
(inputs_arr.depth()== CV_32F || inputs_arr.depth() == CV_16S),
277290
forward_ocl(inputs_arr, outputs_arr, internals_arr))
278291

279292
std::vector<Mat> inputs, outputs;
@@ -286,7 +299,7 @@ class ConcatLayerImpl CV_FINAL : public ConcatLayer
286299
if (padding)
287300
outMat.setTo(paddingValue);
288301

289-
if(cAxis ==1 && outMat.dims ==4 && !padding)
302+
if(cAxis ==1 && outMat.dims ==4 && !padding && (inputs[0].depth() == CV_32F || inputs[0].depth() == CV_8S))
290303
{
291304
int nstripes =getNumThreads();
292305
if (outMat.type() == CV_8S)

‎modules/dnn/src/layers/gather_layer.cpp‎

Lines changed: 17 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -40,6 +40,19 @@ class GatherLayerImpl CV_FINAL : public GatherLayer
4040
returnfalse;
4141
}
4242

43+
virtualvoidgetTypes(const std::vector<MatType>& inputs,
44+
constint requiredOutputs,
45+
constint requiredInternals,
46+
std::vector<MatType>& outputs,
47+
std::vector<MatType>& internals)const CV_OVERRIDE
48+
{
49+
CV_Assert(inputs.size() ==2);
50+
CV_Assert(inputs[0] == CV_32F || inputs[0] == CV_16S);
51+
CV_Assert(inputs[1] == CV_64S || inputs[1] == CV_32S);
52+
outputs.assign(1, inputs[0]);
53+
}
54+
55+
4356
voidforward(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr, OutputArrayOfArrays internals_arr) CV_OVERRIDE
4457
{
4558
CV_TRACE_FUNCTION();
@@ -57,17 +70,15 @@ class GatherLayerImpl CV_FINAL : public GatherLayer
5770
const Mat& inp = inputs[0];
5871

5972
int indicesType = inputs[1].type();
60-
CV_CheckType(indicesType, indicesType ==CV_32FC1 || indicesType ==CV_16SC1,"");
73+
CV_CheckType(indicesType, indicesType ==CV_32SC1 || indicesType ==CV_64SC1,"");
6174
Mat indices32S;
62-
if (indicesType ==CV_16S/*FP16*/)
75+
if (indicesType ==CV_64SC1)
6376
{
64-
Mat indicesF32;
65-
convertFp16(inputs[1], indicesF32);
66-
indicesF32.convertTo(indices32S, CV_32S);
77+
inputs[1].convertTo(indices32S, CV_32S);
6778
}
6879
else
6980
{
70-
inputs[1].convertTo(indices32S, CV_32S);
81+
indices32S =inputs[1];
7182
}
7283
constsize_t indices_total = indices32S.total();
7384
indices32S = indices32S.reshape(1, indices_total);

‎modules/dnn/src/layers/max_unpooling_layer.cpp‎

Lines changed: 30 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -68,17 +68,24 @@ class MaxUnpoolLayerImpl CV_FINAL : public MaxUnpoolLayer
6868
returnfalse;
6969
}
7070

71+
virtualvoidgetTypes(const std::vector<MatType>& inputs,
72+
constint requiredOutputs,
73+
constint requiredInternals,
74+
std::vector<MatType>& outputs,
75+
std::vector<MatType>& internals)const
76+
{
77+
CV_Assert(inputs.size() >=2);
78+
CV_Assert(inputs[0] == CV_32F || inputs[0] == CV_16S);
79+
CV_Assert(inputs[1] == CV_64S || inputs[1] == CV_32S);
80+
outputs.assign(1, inputs[0]);
81+
}
82+
83+
7184
voidforward(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr, OutputArrayOfArrays internals_arr) CV_OVERRIDE
7285
{
7386
CV_TRACE_FUNCTION();
7487
CV_TRACE_ARG_VALUE(name,"name", name.c_str());
7588

76-
if (inputs_arr.depth() == CV_16S)
77-
{
78-
forward_fallback(inputs_arr, outputs_arr, internals_arr);
79-
return;
80-
}
81-
8289
std::vector<Mat> inputs, outputs;
8390
inputs_arr.getMatVector(inputs);
8491
outputs_arr.getMatVector(outputs);
@@ -87,6 +94,19 @@ class MaxUnpoolLayerImpl CV_FINAL : public MaxUnpoolLayer
8794
Mat& input = inputs[0];
8895
Mat& indices = inputs[1];
8996

97+
if (input.type() == CV_32F && indices.type() == CV_32S)
98+
run<float,int32_t>(input, indices, outputs);
99+
elseif (input.type() == CV_32F && indices.type() == CV_64S)
100+
run<float,int64_t>(input, indices, outputs);
101+
elseif (input.type() == CV_16S && indices.type() == CV_32S)
102+
run<int16_t,int32_t>(input, indices, outputs);
103+
elseif (input.type() == CV_16S && indices.type() == CV_64S)
104+
run<int16_t,int64_t>(input, indices, outputs);
105+
}
106+
107+
template<typename T,typename INDEX_TYPE>
108+
voidrun(cv::Mat& input, cv::Mat& indices, std::vector<cv::Mat>& outputs)
109+
{
90110
CV_Assert(input.total() == indices.total());
91111
CV_Assert(input.size[0] ==1);
92112
CV_Assert(input.isContinuous());
@@ -102,9 +122,9 @@ class MaxUnpoolLayerImpl CV_FINAL : public MaxUnpoolLayer
102122
{
103123
Mat outPlane =getPlane(outBlob,0, i_c);
104124
int wh_area = input.size[2]*input.size[3];
105-
constfloat* inptr = input.ptr<float>(0, i_c);
106-
constfloat* idxptr = indices.ptr<float>(0, i_c);
107-
float* outptr = outPlane.ptr<float>();
125+
constT* inptr = input.ptr<T>(0, i_c);
126+
constINDEX_TYPE* idxptr = indices.ptr<INDEX_TYPE>(0, i_c);
127+
T* outptr = outPlane.ptr<T>();
108128

109129
for(int i_wh =0; i_wh < wh_area; i_wh++)
110130
{
@@ -125,6 +145,7 @@ class MaxUnpoolLayerImpl CV_FINAL : public MaxUnpoolLayer
125145
}
126146
}
127147

148+
128149
#ifdef HAVE_CUDA
129150
Ptr<BackendNode>initCUDA(
130151
void *context_,

‎modules/dnn/src/layers/nary_eltwise_layers.cpp‎

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -246,6 +246,25 @@ class NaryEltwiseLayerImpl CV_FINAL : public NaryEltwiseLayer
246246
returnfalse;
247247
}
248248

249+
voidgetTypes(const std::vector<MatType>& inputs,
250+
constint requiredOutputs,
251+
constint requiredInternals,
252+
std::vector<MatType>& outputs,
253+
std::vector<MatType>& internals)const CV_OVERRIDE
254+
{
255+
CV_Assert(inputs.size());
256+
for (auto input : inputs)
257+
if (preferableTarget == DNN_TARGET_OPENCL_FP16
258+
|| preferableTarget == DNN_TARGET_CPU_FP16
259+
|| preferableTarget == DNN_TARGET_CUDA_FP16)
260+
CV_Assert(input == CV_16S || input == CV_8S || input == CV_32S);
261+
else
262+
CV_Assert(input == CV_32F || input == CV_8S || input == CV_32S);
263+
264+
outputs.assign(requiredOutputs, inputs[0]);
265+
}
266+
267+
249268
template<typename T,typename Functor>
250269
voidbinary_forward_impl(
251270
int ndims,constint* shape,

‎modules/dnn/src/layers/permute_layer.cpp‎

Lines changed: 19 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -178,6 +178,24 @@ class PermuteLayerImpl CV_FINAL : public PermuteLayer
178178
returnfalse;
179179
}
180180

181+
voidgetTypes(const std::vector<MatType>& inputs,
182+
constint requiredOutputs,
183+
constint requiredInternals,
184+
std::vector<MatType>& outputs,
185+
std::vector<MatType>& internals)const CV_OVERRIDE
186+
{
187+
CV_Assert(inputs.size());
188+
for (auto input : inputs)
189+
if (preferableTarget == DNN_TARGET_OPENCL_FP16
190+
|| preferableTarget == DNN_TARGET_CPU_FP16
191+
|| preferableTarget == DNN_TARGET_CUDA_FP16)
192+
CV_Assert(input == CV_16S || input == CV_8S || input == CV_32S);
193+
else
194+
CV_Assert(input == CV_32F || input == CV_8S || input == CV_32S);
195+
196+
outputs.assign(requiredOutputs, inputs[0]);
197+
}
198+
181199
voidcomputeStrides(const MatShape &shapeBefore,const MatShape &shapeAfter)
182200
{
183201
_oldStride.resize(_numAxes);
@@ -347,7 +365,7 @@ class PermuteLayerImpl CV_FINAL : public PermuteLayer
347365
CV_TRACE_ARG_VALUE(name,"name", name.c_str());
348366

349367
CV_OCL_RUN(IS_DNN_OPENCL_TARGET(preferableTarget) &&
350-
inputs_arr.depth() != CV_8S,
368+
inputs_arr.depth() != CV_8S && inputs_arr.depth() != CV_32S,
351369
forward_ocl(inputs_arr, outputs_arr, internals_arr))
352370

353371
if (inputs_arr.depth() == CV_16S)

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp