inference-engine/thirdparty/clDNN/kernel_selector/core/actual_kernels/scale_grad_weights/scale_grad_weights_kernel_base.cpp

   1 /*
   2 // Copyright (c) 2018 Intel Corporation
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the "License");
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //      http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 */
  16
  17 #include "scale_grad_weights_kernel_base.h"
  18 #include "kernel_selector_utils.h"
  19
  20 namespace kernel_selector
  21 {
  22     JitConstants ScaleGradWeightsKernelBase::GetJitConstants(const scale_grad_weights_params& params) const
  23     {
  24         JitConstants jit = training_kernel_base::GetJitConstants(params);
  25
  26         return jit;
  27     }
  28
  29     ScaleGradWeightsKernelBase::DispatchData ScaleGradWeightsKernelBase::SetDefault(const scale_grad_weights_params& params) const
  30     {
  31         DispatchData kd;
  32
  33         kd.fp16UnitUsed = params.inputs[0].GetDType() == Datatype::F16;
  34
  35         kd.gws0 = params.inputs[0].Batch().v;
  36         kd.gws1 = params.inputs[0].Feature().v;
  37         kd.gws2 = 1;
  38
  39         kd.lws0 = params.inputs[0].Batch().v;
  40         kd.lws1 = 1;
  41         kd.lws2 = 1;
  42         kd.effiency = DONT_USE_IF_HAVE_SOMETHING_ELSE;
  43         return kd;
  44     }
  45
  46     KernelsData ScaleGradWeightsKernelBase::GetKernelsData(const Params& params, const optional_params& options) const
  47     {
  48         assert(params.GetType() == KernelType::SCALE_GRAD_WEIGHTS);
  49
  50         const scale_grad_weights_params& orgParams = static_cast<const scale_grad_weights_params&>(params);
  51
  52         DispatchData runInfo = SetDefault(orgParams);
  53         KernelData kd = KernelData::Default<scale_grad_weights_params>(params);
  54
  55         auto cldnn_jit = GetJitConstants(orgParams);
  56         auto entry_point = GetEntryPoint(kernelName, orgParams.layerID, options);
  57         auto jit = CreateJit(kernelName, cldnn_jit, entry_point);
  58
  59         auto& kernel = kd.kernels[0];
  60         FillCLKernelData(kernel, runInfo, params.engineInfo, kernelName, jit, entry_point, DEFAULT, true, !orgParams.bias.empty(), 2);
  61
  62         if (orgParams.use_momentum)
  63         {
  64             kernel.arguments.push_back({ ArgumentDescriptor::Types::PREV_WEIGHTS_GRADIENT, 0 });
  65             if (!orgParams.bias.empty())
  66                 kernel.arguments.push_back({ ArgumentDescriptor::Types::PREV_BIAS_GRADIENT, 0 });
  67         }
  68         kernel.arguments.push_back({ ArgumentDescriptor::Types::LEARNING_RATE, 0 });
  69
  70         kd.estimatedTime = runInfo.effiency;
  71
  72         return{ kd };
  73     }
  74 }