/*M/////////////////////////////////////////////////////////////////////////////////////// // // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. // // By downloading, copying, installing or using the software you agree to this license. // If you do not agree to this license, do not download, install, // copy or use the software. // // // License Agreement // For Open Source Computer Vision Library // // Copyright (C) 2013, OpenCV Foundation, all rights reserved. // Copyright (C) 2017, Intel Corporation, all rights reserved. // Third party copyrights are property of their respective owners. // // Redistribution and use in source and binary forms, with or without modification, // are permitted provided that the following conditions are met: // // * Redistribution's of source code must retain the above copyright notice, // this list of conditions and the following disclaimer. // // * Redistribution's in binary form must reproduce the above copyright notice, // this list of conditions and the following disclaimer in the documentation // and/or other materials provided with the distribution. // // * The name of the copyright holders may not be used to endorse or promote products // derived from this software without specific prior written permission. // // This software is provided by the copyright holders and contributors "as is" and // any express or implied warranties, including, but not limited to, the implied // warranties of merchantability and fitness for a particular purpose are disclaimed. // In no event shall the Intel Corporation or contributors be liable for any direct, // indirect, incidental, special, exemplary, or consequential damages // (including, but not limited to, procurement of substitute goods or services; // loss of use, data, or profits; or business interruption) however caused // and on any theory of liability, whether in contract, strict liability, // or tort (including negligence or otherwise) arising in any way out of // the use of this software, even if advised of the possibility of such damage. // //M*/ #include "../precomp.hpp" #include "layers_common.hpp" #include "../op_cuda.hpp" #include "../op_inf_engine.hpp" #include "../ie_ngraph.hpp" #include "../op_cann.hpp" #include #include #include #ifdef HAVE_CUDA #include "../cuda4dnn/primitives/reshape.hpp" using namespace cv::dnn::cuda4dnn; #endif namespace cv { namespace dnn { class FlattenLayerImpl CV_FINAL : public FlattenLayer { public: bool _onnxMode; FlattenLayerImpl(const LayerParams ¶ms) { _startAxis = params.get("axis", 1); _endAxis = params.get("end_axis", -1); _onnxMode = params.get("onnx", false); setParamsFrom(params); } virtual bool supportBackend(int backendId) CV_OVERRIDE { #ifdef HAVE_INF_ENGINE if (backendId == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) return true; #endif return backendId == DNN_BACKEND_OPENCV || backendId == DNN_BACKEND_CUDA || backendId == DNN_BACKEND_CANN; } bool isDataShuffling() const CV_OVERRIDE { return true; } virtual bool alwaysSupportInplace() const CV_OVERRIDE { return true; } bool getMemoryShapes(const std::vector &inputs, const int requiredOutputs, std::vector &outputs, std::vector &internals) const CV_OVERRIDE { CV_Assert(inputs.size() > 0); for (size_t i = 1; i < inputs.size(); i++) { CV_Assert(inputs[i] == inputs[0]); } MatShape outputShapeVec; int numAxes = (int)inputs[0].size(); /* Ticket: https://github.com/opencv/opencv/issues/26197 [TODO] this is not quite correct, in ONNX Flatten valid range is [0, numAxes], not [0, numAxes-1] which normalize_axis() produces. But if we fix it, flatten_const.onnx from opencv_extra is not processed correctly. libprotobuf-c reads it correctly, but the current version of libprotobuf does not */ int startAxis = normalize_axis(_startAxis, numAxes); int endAxis = normalize_axis(_endAxis, numAxes); CV_Assert(startAxis >= 0 && startAxis <= numAxes); if (_onnxMode) { int onnxAxis = _startAxis; if (onnxAxis < 0) onnxAxis += numAxes; onnxAxis = std::max(0, std::min(onnxAxis, numAxes)); size_t outer = 1, inner = 1; int i = 0; for (; i < onnxAxis; i++) outer *= inputs[0][i]; for (; i < numAxes; i++) inner *= inputs[0][i]; CV_Assert_N(inner <= (size_t)INT_MAX, outer < (size_t)INT_MAX); outputShapeVec.push_back((int)outer); outputShapeVec.push_back((int)inner); } else { outputShapeVec = inputs[0].flatten(startAxis, endAxis); } outputs.resize(inputs.size(), outputShapeVec); return true; } void getTypes(const std::vector& inputs, const int requiredOutputs, const int requiredInternals, std::vector& outputs, std::vector& internals) const CV_OVERRIDE { CV_Assert(inputs.size()); outputs.assign(requiredOutputs, inputs[0]); } void finalize(InputArrayOfArrays inputs_arr, OutputArrayOfArrays) CV_OVERRIDE { std::vector inputs; inputs_arr.getMatVector(inputs); int numAxes = inputs[0].dims; if (!_onnxMode) { _startAxis = normalize_axis(_startAxis, numAxes); _endAxis = normalize_axis(_endAxis, numAxes); } } #ifdef HAVE_OPENCL bool forward_ocl(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr, OutputArrayOfArrays internals_arr) { std::vector inpvec; std::vector outputs; inputs_arr.getUMatVector(inpvec); outputs_arr.getUMatVector(outputs); std::vector inputs(inpvec.size()); for (int i = 0; i < inpvec.size(); i++) inputs[i] = &inpvec[i]; for (size_t i = 0; i < inputs.size(); i++) { MatShape outShape = shape(outputs[i]); UMat& output = outputs_arr.getUMatRef(i); inputs[i]->reshape(1, (int)outShape.size(), &outShape[0]).copyTo(output); } return true; } #endif void forward(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr, OutputArrayOfArrays internals_arr) CV_OVERRIDE { CV_TRACE_FUNCTION(); CV_TRACE_ARG_VALUE(name, "name", name.c_str()); CV_OCL_RUN(IS_DNN_OPENCL_TARGET(preferableTarget) && outputs_arr.isUMatVector(), forward_ocl(inputs_arr, outputs_arr, internals_arr)) std::vector outs; outputs_arr.getMatVector(outs); CV_Assert(!outs.empty()); const MatShape outShape = outs[0].shape(); reshapeAndCopyFirst(inputs_arr, outputs_arr, outShape); } #ifdef HAVE_CANN virtual Ptr initCann(const std::vector > &inputs, const std::vector > &outputs, const std::vector >& nodes) CV_OVERRIDE { auto x = inputs[0].dynamicCast(); auto x_desc = x->getTensorDesc(); auto op_x = nodes[0].dynamicCast()->getOp(); auto output_desc = std::make_shared(ge::Shape(), ge::FORMAT_NCHW, ge::DT_FLOAT); auto op = std::make_shared(name); // set attributes int num_axes = x->host->dims; int start_axis = normalize_axis(_startAxis, num_axes); int end_axis = normalize_axis(_endAxis, num_axes); op->set_attr_axis(start_axis); op->set_attr_end_axis(end_axis); // set inputs op->set_input_x_by_name(*op_x, x->name.c_str()); op->update_input_desc_x(*x_desc); // set outputs op->update_output_desc_y(*output_desc); return Ptr(new CannBackendNode(op)); } #endif #ifdef HAVE_DNN_NGRAPH virtual Ptr initNgraph(const std::vector >& inputs, const std::vector >& nodes) CV_OVERRIDE { auto& ieInpNode = nodes[0].dynamicCast()->node; std::vector dims = ieInpNode.get_shape(); int numAxes = dims.size(); int startAxis = _startAxis; if (startAxis < 0) startAxis += numAxes; startAxis = std::max(0, std::min(startAxis, numAxes)); int endAxis = _endAxis; if (endAxis < 0) endAxis += numAxes; endAxis = std::max(0, std::min(endAxis, numAxes - 1)); CV_Assert(startAxis >= 0); int64_t flattenedDimensionSize = std::accumulate(dims.begin() + startAxis, dims.begin() + endAxis + 1, 1, std::multiplies()); std::vector outputShapeVec(dims.begin(), dims.begin() + startAxis); outputShapeVec.push_back(flattenedDimensionSize); outputShapeVec.insert(outputShapeVec.end(), dims.begin() + endAxis + 1, dims.end()); auto shape = std::make_shared(ov::element::i64, ov::Shape({outputShapeVec.size()}), outputShapeVec.data()); auto reshape = std::make_shared(ieInpNode, shape, true); return Ptr(new InfEngineNgraphNode(reshape)); } #endif // HAVE_DNN_NGRAPH #ifdef HAVE_CUDA Ptr initCUDA( void *context_, InputArrayOfArrays inputs_, InputArrayOfArrays outputs ) override { auto context = reinterpret_cast(context_); std::vector inputs; inputs_.getUMatVector(inputs); int depth = CV_MAT_DEPTH(inputs[0].type()); if (depth == CV_Bool) return make_cuda_node_bool(std::move(context->stream)); else return make_cuda_node_with_type(preferableTarget, depth, std::move(context->stream)); } #endif int _startAxis; int _endAxis; }; Ptr FlattenLayer::create(const LayerParams& params) { return Ptr(new FlattenLayerImpl(params)); } } }