modules/dnn/src/cuda4dnn/primitives/activation.hpp

   1 // This file is part of OpenCV project.
   2 // It is subject to the license terms in the LICENSE file found in the top-level directory
   3 // of this distribution and at http://opencv.org/license.html.
   4
   5 #ifndef OPENCV_DNN_SRC_CUDA4DNN_PRIMITIVES_ACTIVATION_HPP
   6 #define OPENCV_DNN_SRC_CUDA4DNN_PRIMITIVES_ACTIVATION_HPP
   7
   8 #include "../../op_cuda.hpp"
   9
  10 #include "../csl/stream.hpp"
  11 #include "../csl/tensor.hpp"
  12
  13 #include "../kernels/activations.hpp"
  14
  15 #include <opencv2/core.hpp>
  16
  17 #include <utility>
  18
  19 namespace cv { namespace dnn { namespace cuda4dnn {
  20
  21     template <class T>
  22     class ReLUOp final : public CUDABackendNode {
  23     public:
  24         using wrapper_type = GetCUDABackendWrapperType<T>;
  25
  26         ReLUOp(csl::Stream stream_, T slope_)
  27             : stream(std::move(stream_)), slope{ slope_ } { }
  28
  29         void forward(
  30             const std::vector<cv::Ptr<BackendWrapper>>& inputs,
  31             const std::vector<cv::Ptr<BackendWrapper>>& outputs,
  32             csl::Workspace& workspace) override
  33         {
  34             for (int i = 0; i < inputs.size(); i++)
  35             {
  36                 auto input_wrapper = inputs[i].dynamicCast<wrapper_type>();
  37                 auto input = input_wrapper->getView();
  38
  39                 auto output_wrapper = outputs[i].dynamicCast<wrapper_type>();
  40                 auto output = output_wrapper->getSpan();
  41
  42                 kernels::relu<T>(stream, output, input, slope);
  43             }
  44         }
  45
  46     private:
  47         csl::Stream stream;
  48         const T slope;
  49     };
  50
  51     template <class T>
  52     class ClippedReLUOp final : public CUDABackendNode {
  53     public:
  54         using wrapper_type = GetCUDABackendWrapperType<T>;
  55
  56         ClippedReLUOp(csl::Stream stream_, T min_, T max_)
  57             : stream(std::move(stream_)), min{ min_ }, max{ max_ } { }
  58
  59         void forward(
  60             const std::vector<cv::Ptr<BackendWrapper>>& inputs,
  61             const std::vector<cv::Ptr<BackendWrapper>>& outputs,
  62             csl::Workspace& workspace) override
  63         {
  64             for (int i = 0; i < inputs.size(); i++)
  65             {
  66                 auto input_wrapper = inputs[i].dynamicCast<wrapper_type>();
  67                 auto input = input_wrapper->getView();
  68
  69                 auto output_wrapper = outputs[i].dynamicCast<wrapper_type>();
  70                 auto output = output_wrapper->getSpan();
  71
  72                 kernels::clipped_relu<T>(stream, output, input, min, max);
  73             }
  74         }
  75
  76     private:
  77         csl::Stream stream;
  78         const T min, max;
  79     };
  80
  81     template <class T>
  82     class ChannelwiseReLUOp final : public CUDABackendNode {
  83     public:
  84         using wrapper_type = GetCUDABackendWrapperType<T>;
  85
  86         ChannelwiseReLUOp(csl::Stream stream_, const Mat& slope)
  87             : stream(std::move(stream_))
  88         {
  89             CV_Assert(!slope.empty());
  90             slopeTensor = csl::makeTensorHeader<T>(slope);
  91             csl::copyMatToTensor<T>(slope, slopeTensor, stream);
  92         }
  93
  94         void forward(
  95             const std::vector<cv::Ptr<BackendWrapper>>& inputs,
  96             const std::vector<cv::Ptr<BackendWrapper>>& outputs,
  97             csl::Workspace& workspace) override
  98         {
  99             for (int i = 0; i < inputs.size(); i++)
 100             {
 101                 auto input_wrapper = inputs[i].dynamicCast<wrapper_type>();
 102                 auto input = input_wrapper->getView();
 103
 104                 auto output_wrapper = outputs[i].dynamicCast<wrapper_type>();
 105                 auto output = output_wrapper->getSpan();
 106
 107                 CV_Assert(input.get_axis_size(1) == slopeTensor.size());
 108                 std::size_t inner_size = input.size_range(2, input.rank());
 109                 kernels::axiswise_relu<T>(stream, output, input, inner_size, slopeTensor);
 110             }
 111         }
 112
 113     private:
 114         csl::Stream stream;
 115         csl::Tensor<T> slopeTensor;
 116     };
 117
 118     template <class T>
 119     class TanHOp final : public CUDABackendNode {
 120     public:
 121         using wrapper_type = GetCUDABackendWrapperType<T>;
 122
 123         TanHOp(csl::Stream stream_) : stream(std::move(stream_)) { }
 124
 125         void forward(
 126             const std::vector<cv::Ptr<BackendWrapper>>& inputs,
 127             const std::vector<cv::Ptr<BackendWrapper>>& outputs,
 128             csl::Workspace& workspace) override
 129         {
 130             for (int i = 0; i < inputs.size(); i++)
 131             {
 132                 auto input_wrapper = inputs[i].dynamicCast<wrapper_type>();
 133                 auto input = input_wrapper->getView();
 134
 135                 auto output_wrapper = outputs[i].dynamicCast<wrapper_type>();
 136                 auto output = output_wrapper->getSpan();
 137
 138                 kernels::tanh<T>(stream, output, input);
 139             }
 140         }
 141
 142     private:
 143         csl::Stream stream;
 144     };
 145
 146     template <class T>
 147     class SigmoidOp final : public CUDABackendNode {
 148     public:
 149         using wrapper_type = GetCUDABackendWrapperType<T>;
 150
 151         SigmoidOp(csl::Stream stream_) : stream(std::move(stream_)) { }
 152
 153         void forward(
 154             const std::vector<cv::Ptr<BackendWrapper>>& inputs,
 155             const std::vector<cv::Ptr<BackendWrapper>>& outputs,
 156             csl::Workspace& workspace) override
 157         {
 158             for (int i = 0; i < inputs.size(); i++)
 159             {
 160                 auto input_wrapper = inputs[i].dynamicCast<wrapper_type>();
 161                 auto input = input_wrapper->getView();
 162
 163                 auto output_wrapper = outputs[i].dynamicCast<wrapper_type>();
 164                 auto output = output_wrapper->getSpan();
 165
 166                 kernels::sigmoid<T>(stream, output, input);
 167             }
 168         }
 169
 170     private:
 171         csl::Stream stream;
 172     };
 173
 174     template <class T>
 175     class ELUOp final : public CUDABackendNode {
 176     public:
 177         using wrapper_type = GetCUDABackendWrapperType<T>;
 178
 179         ELUOp(csl::Stream stream_) : stream(std::move(stream_)) { }
 180
 181         void forward(
 182             const std::vector<cv::Ptr<BackendWrapper>>& inputs,
 183             const std::vector<cv::Ptr<BackendWrapper>>& outputs,
 184             csl::Workspace& workspace) override
 185         {
 186             for (int i = 0; i < inputs.size(); i++)
 187             {
 188                 auto input_wrapper = inputs[i].dynamicCast<wrapper_type>();
 189                 auto input = input_wrapper->getView();
 190
 191                 auto output_wrapper = outputs[i].dynamicCast<wrapper_type>();
 192                 auto output = output_wrapper->getSpan();
 193
 194                 kernels::elu<T>(stream, output, input);
 195             }
 196         }
 197
 198     private:
 199         csl::Stream stream;
 200     };
 201
 202     template <class T>
 203     class AbsValOp final : public CUDABackendNode {
 204     public:
 205         using wrapper_type = GetCUDABackendWrapperType<T>;
 206
 207         AbsValOp(csl::Stream stream_) : stream(std::move(stream_)) { }
 208
 209         void forward(
 210             const std::vector<cv::Ptr<BackendWrapper>>& inputs,
 211             const std::vector<cv::Ptr<BackendWrapper>>& outputs,
 212             csl::Workspace& workspace) override
 213         {
 214             for (int i = 0; i < inputs.size(); i++)
 215             {
 216                 auto input_wrapper = inputs[i].dynamicCast<wrapper_type>();
 217                 auto input = input_wrapper->getView();
 218
 219                 auto output_wrapper = outputs[i].dynamicCast<wrapper_type>();
 220                 auto output = output_wrapper->getSpan();
 221
 222                 kernels::abs<T>(stream, output, input);
 223             }
 224         }
 225
 226     private:
 227         csl::Stream stream;
 228     };
 229
 230     template <class T>
 231     class BNLLOp final : public CUDABackendNode {
 232     public:
 233         using wrapper_type = GetCUDABackendWrapperType<T>;
 234
 235         BNLLOp(csl::Stream stream_) : stream(std::move(stream_)) { }
 236
 237         void forward(
 238             const std::vector<cv::Ptr<BackendWrapper>>& inputs,
 239             const std::vector<cv::Ptr<BackendWrapper>>& outputs,
 240             csl::Workspace& workspace) override
 241         {
 242             for (int i = 0; i < inputs.size(); i++)
 243             {
 244                 auto input_wrapper = inputs[i].dynamicCast<wrapper_type>();
 245                 auto input = input_wrapper->getView();
 246
 247                 auto output_wrapper = outputs[i].dynamicCast<wrapper_type>();
 248                 auto output = output_wrapper->getSpan();
 249
 250                 kernels::bnll<T>(stream, output, input);
 251             }
 252         }
 253
 254     private:
 255         csl::Stream stream;
 256     };
 257
 258     template <class T>
 259     class PowerOp final : public CUDABackendNode {
 260     public:
 261         using wrapper_type = GetCUDABackendWrapperType<T>;
 262
 263         PowerOp(csl::Stream stream_, T exp_, T scale_, T shift_)
 264             : stream(std::move(stream_)), exp{ exp_ }, scale{ scale_ }, shift{ shift_ } { }
 265
 266         void forward(
 267             const std::vector<cv::Ptr<BackendWrapper>>& inputs,
 268             const std::vector<cv::Ptr<BackendWrapper>>& outputs,
 269             csl::Workspace& workspace) override
 270         {
 271             for (int i = 0; i < inputs.size(); i++)
 272             {
 273                 auto input_wrapper = inputs[i].dynamicCast<wrapper_type>();
 274                 auto input = input_wrapper->getView();
 275
 276                 auto output_wrapper = outputs[i].dynamicCast<wrapper_type>();
 277                 auto output = output_wrapper->getSpan();
 278
 279                 kernels::power<T>(stream, output, input, exp, scale, shift);
 280             }
 281         }
 282
 283     private:
 284         csl::Stream stream;
 285         const T exp, scale, shift;
 286     };
 287
 288 }}} /* namespace cv::dnn::cuda4dnn */
 289
 290 #endif /* OPENCV_DNN_SRC_CUDA4DNN_PRIMITIVES_ACTIVATION_HPP */