ConvBackend Class Reference

#include <ConvBackend.h>

Collaboration diagram for ConvBackend:

Public Member Functions
	ConvBackend (const nnsuite::conv::Model &model)
::tflite::Interpreter &	interpreter (void) override
Public Member Functions inherited from nnkit::support::tflite::AbstractBackend
virtual	~AbstractBackend ()=default
void	prepare (const std::function< void(TensorContext &)> &f) override
void	run (void) override
void	teardown (const std::function< void(TensorContext &)> &f) override
Public Member Functions inherited from nnkit::Backend
virtual	~Backend ()=default
virtual void	prepare (const std::function< void(TensorContext &)> &f)=0
virtual void	teardown (const std::function< void(TensorContext &)> &f)=0

Static Public Member Functions
static std::unique_ptr< nnkit::Backend >	create (const nnsuite::conv::Model &)

Detailed Description

Definition at line 25 of file ConvBackend.h.

Constructor & Destructor Documentation

ConvBackend()

ConvBackend::ConvBackend ( const nnsuite::conv::Model &  model )

explicit

Definition at line 76 of file ConvBackend.cpp.

  : _ifm_name{model.ifm_name()}, _ofm_name{model.ofm_name()}
{
  using nncc::core::ADT::kernel::Overlay;
  using nncc::core::ADT::kernel::NHWCLayout;
 
  using nncc::core::ADT::kernel::make_overlay;
  using nncc::core::ADT::kernel::num_elements;
 
  // Set kernel data
  const auto &ker_shape = model.ker_shape();
 
  _kernel.resize(num_elements(ker_shape));
 
  auto kernel_overlay = make_overlay<float, NHWCLayout>(ker_shape, _kernel.data());
 
  for (uint32_t n = 0; n < ker_shape.count(); ++n)
  {
    for (uint32_t ch = 0; ch < ker_shape.depth(); ++ch)
    {
      for (uint32_t row = 0; row < ker_shape.height(); ++row)
      {
        for (uint32_t col = 0; col < ker_shape.width(); ++col)
        {
          kernel_overlay.at(n, ch, row, col) = model.ker_data().at(n, ch, row, col);
        }
      }
    }
  }
 
  // Set bias data
  _bias.resize(ker_shape.count(), 0.0f);
 
  // Initialize interpreter
  auto quantization = make_default_quantization();
 
  // Create Tensors
  //  0 -> OFM
  //  1 -> IFM
  //  2 -> Kernel
  //  3 -> Bias
  _interp.AddTensors(4);
 
  _interp.SetTensorParametersReadWrite(0, kTfLiteFloat32 /* type */, _ofm_name.c_str(),
                                       as_dims(model.ofm_shape()), quantization);
 
  _interp.SetTensorParametersReadWrite(1, kTfLiteFloat32 /* type */, _ifm_name.c_str(),
                                       as_dims(model.ifm_shape()), quantization);
 
  _interp.SetTensorParametersReadOnly(
    2, kTfLiteFloat32 /* type */, "kernel" /* name */, as_dims(model.ker_shape()), quantization,
    reinterpret_cast<const char *>(_kernel.data()), _kernel.size() * sizeof(float));
 
  _interp.SetTensorParametersReadOnly(
    3, kTfLiteFloat32 /* type */, "bias" /* name */, {static_cast<int>(_bias.size())}, quantization,
    reinterpret_cast<const char *>(_bias.data()), _bias.size() * sizeof(float));
 
  auto param = typed_malloc<TfLiteConvParams>();
 
  param->padding = kTfLitePaddingValid;
  param->stride_width = 1;
  param->stride_height = 1;
  param->activation = kTfLiteActNone;
 
  _interp.AddNodeWithParameters({1, 2, 3}, {0}, nullptr, 0, reinterpret_cast<void *>(param),
                                BuiltinOpResolver().FindOp(BuiltinOperator_CONV_2D));
 
  _interp.SetInputs({1});
  _interp.SetOutputs({0});
}

References nncc::core::ADT::kernel::make_overlay(), and nncc::core::ADT::kernel::num_elements().

Member Function Documentation

create()

std::unique_ptr< nnkit::Backend > ConvBackend::create ( const nnsuite::conv::Model &  model )

static

Definition at line 30 of file ConvBackend.cpp.

{
  ::caffe::NetParameter param;
 
  param.set_name("conv");
 
  // Create 'Input' layer
  {
    auto input = param.add_layer();
    input->set_name("input");
    input->set_type("Input");
    input->add_top(model.ifm_name());
 
    auto input_param = new ::caffe::InputParameter{};
    auto input_shape = input_param->add_shape();
    input_shape->add_dim(1);
    input_shape->add_dim(model.ifm_shape().depth());
    input_shape->add_dim(model.ifm_shape().height());
    input_shape->add_dim(model.ifm_shape().width());
    input->set_allocated_input_param(input_param);
  }
 
  // Create 'Convolution' layer
  {
    auto conv = param.add_layer();
    conv->set_name("conv");
    conv->set_type("Convolution");
    conv->add_bottom(model.ifm_name());
    conv->add_top(model.ofm_name());
 
    const auto &ker_shape = model.ker_shape();
 
    auto ker_blob_shape = new ::caffe::BlobShape{};
 
    ker_blob_shape->add_dim(ker_shape.count());
    ker_blob_shape->add_dim(ker_shape.depth());
    ker_blob_shape->add_dim(ker_shape.height());
    ker_blob_shape->add_dim(ker_shape.width());
 
    auto ker_blob = conv->add_blobs();
 
    for (uint32_t n = 0; n < ker_shape.count(); ++n)
    {
      for (uint32_t ch = 0; ch < ker_shape.depth(); ++ch)
      {
        for (uint32_t row = 0; row < ker_shape.height(); ++row)
        {
          for (uint32_t col = 0; col < ker_shape.width(); ++col)
          {
            ker_blob->add_data(model.ker_data().at(n, ch, row, col));
          }
        }
      }
    }
 
    ker_blob->set_allocated_shape(ker_blob_shape);
 
    auto conv_param = new ::caffe::ConvolutionParameter{};
    conv_param->set_num_output(model.ker_shape().count());
    conv_param->set_bias_term(false);
    conv_param->add_kernel_size(model.ker_shape().height());
    conv_param->add_kernel_size(model.ker_shape().width());
    conv->set_allocated_convolution_param(conv_param);
  }
 
  auto net = make_unique<::caffe::Net<float>>(param);
  return make_unique<nnkit::support::caffe::Backend<float>>(std::move(net));
}

Referenced by make_backend().

interpreter()

::tflite::Interpreter & ConvBackend::interpreter ( void  )

inlineoverridevirtual

Implements nnkit::support::tflite::AbstractBackend.

Definition at line 31 of file ConvBackend.h.

{ return _interp; }

---

The documentation for this class was generated from the following files:

• compiler/nnsuite/conv/nnkit-caffe/ConvBackend.h
• compiler/nnsuite/conv/nnkit-tflite/ConvBackend.h
• compiler/nnsuite/conv/nnkit-caffe/ConvBackend.cpp
• compiler/nnsuite/conv/nnkit-tflite/ConvBackend.cpp