mir_caffe::CaffeOpCreator Class Reference

#include <caffe_op_creator.h>

Public Member Functions
	CaffeOpCreator (mir::Graph *g)
std::vector< mir::Operation::Output * >	convertInput (const caffe::LayerParameter &layer)
std::vector< mir::Operation::Output * >	convertConvolution (const caffe::LayerParameter &layer, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertInnerProduct (const caffe::LayerParameter &layer, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertConcat (const caffe::LayerParameter &layer, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertPooling (const caffe::LayerParameter &layer, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertSoftmax (const caffe::LayerParameter &layer, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertReshape (const caffe::LayerParameter &layer, const std::vector< mir::Operation::Output * > &inputs)
	Converts Caffe Reshape layer to Model IR Reshape operation.
std::vector< mir::Operation::Output * >	convertReLU (const caffe::LayerParameter &layer, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertScale (const caffe::LayerParameter &layer, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertBatchNorm (const caffe::LayerParameter &layer, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertDropout (const caffe::LayerParameter &layer, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertDeconvolution (const caffe::LayerParameter &layer, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertELU (const caffe::LayerParameter &layer, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertEmbed (const caffe::LayerParameter &layer, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertSigmoid (const caffe::LayerParameter &layer, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertTanH (const caffe::LayerParameter &layer, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertEltwise (const caffe::LayerParameter &layer, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertSplit (const caffe::LayerParameter &layer, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertLSTM (const caffe::LayerParameter &layer, const std::vector< mir::Operation::Output * > &inputs)
void	checkConvolution (const caffe::LayerParameter &layer, std::set< std::string > &problems_ops_set)
void	checkPooling (const caffe::LayerParameter &layer, std::set< std::string > &problems_ops_set)
void	checkReshape (const caffe::LayerParameter &layer, std::set< std::string > &problems_ops_set)
void	checkBatchNorm (const caffe::LayerParameter &layer, std::set< std::string > &problems_ops_set)
void	checkLSTM (const caffe::LayerParameter &layer, std::set< std::string > &problems_ops_set)

Detailed Description

Definition at line 34 of file caffe_op_creator.h.

Constructor & Destructor Documentation

CaffeOpCreator()

mir_caffe::CaffeOpCreator::CaffeOpCreator ( mir::Graph *  g )

inlineexplicit

Definition at line 37 of file caffe_op_creator.h.

: _graph(g){};

Member Function Documentation

checkBatchNorm()

void mir_caffe::CaffeOpCreator::checkBatchNorm	(	const caffe::LayerParameter &	layer,
		std::set< std::string > &	problems_ops_set
	)

Definition at line 533 of file caffe_op_creator.cpp.

{
  const auto &scale_shape = layer.blobs(2).shape();
 
  // Check that last blob(with scaleFactor) containing only one number
  if (scale_shape.dim_size() != 1 || scale_shape.dim(0) != 1)
    problems_ops_set.insert("Unexpected shape of scale parameter in batch norm");
}

checkConvolution()

void mir_caffe::CaffeOpCreator::checkConvolution	(	const caffe::LayerParameter &	layer,
		std::set< std::string > &	problems_ops_set
	)

Definition at line 221 of file caffe_op_creator.cpp.

{
  const caffe::ConvolutionParameter &params = layer.convolution_param();
 
  assert(params.stride_size() <= 2);
 
  if (params.axis() != 1)
    problems_ops_set.insert("Conv2D: Unsupported axis");
 
  if (params.pad_size() != 0 && (params.has_pad_h() || params.has_pad_w()))
    problems_ops_set.insert("Conv2D: Conflicting padding properties");
 
  if (params.pad_size() > 2)
    problems_ops_set.insert("Conv2D: Unsupported number of pads");
}

checkLSTM()

void mir_caffe::CaffeOpCreator::checkLSTM	(	const caffe::LayerParameter &	layer,
		std::set< std::string > &	problems_ops_set
	)

Definition at line 702 of file caffe_op_creator.cpp.

{
  const auto &params = layer.recurrent_param();
  if (params.expose_hidden())
    problems_ops_set.insert("LSTM: parameter 'expose_hidden' has unsupported value: " +
                            std::to_string(params.expose_hidden()));
}

checkPooling()

void mir_caffe::CaffeOpCreator::checkPooling	(	const caffe::LayerParameter &	layer,
		std::set< std::string > &	problems_ops_set
	)

Definition at line 383 of file caffe_op_creator.cpp.

{
  const caffe::PoolingParameter &params = layer.pooling_param();
 
  if (params.has_global_pooling() && params.global_pooling())
    problems_ops_set.insert("Pooling: pooling layer global_pooling param is not supported yet");
 
  if (params.pool() != caffe::PoolingParameter::AVE &&
      params.pool() != caffe::PoolingParameter::MAX)
    problems_ops_set.insert("Pooling: unsupported pooling type");
 
  if (params.has_pad() && (params.has_pad_h() || params.has_pad_w()))
    problems_ops_set.insert("Pooling: conflicting padding properties in pooling");
}

checkReshape()

void mir_caffe::CaffeOpCreator::checkReshape	(	const caffe::LayerParameter &	layer,
		std::set< std::string > &	problems_ops_set
	)

Definition at line 460 of file caffe_op_creator.cpp.

{
  const caffe::ReshapeParameter &params = layer.reshape_param();
 
  if (params.has_axis() || params.has_num_axes())
    problems_ops_set.insert("Reshape layer axis and num_axes params are not supported yet");
 
  if (!params.has_shape())
    problems_ops_set.insert("Reshape layer doesn't have shape parameter");
 
  const mir::Shape newShape = convertBlobShape(params.shape());
 
  for (int32_t i = 0; i < newShape.rank(); ++i)
    if (newShape.dim(i) == 0)
      problems_ops_set.insert("Reshape layer zero shape values are not supported yet");
}

References mir::Shape::dim(), and mir::Shape::rank().

convertBatchNorm()

std::vector< mir::Operation::Output * > mir_caffe::CaffeOpCreator::convertBatchNorm	(	const caffe::LayerParameter &	layer,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 544 of file caffe_op_creator.cpp.

{
  const caffe::BatchNormParameter &params = layer.batch_norm_param();
 
  auto input = inputs[0];
  auto mean_tensor = convertBlob(layer.blobs(0));
  auto var_tensor = convertBlob(layer.blobs(1));
  auto scale_tensor = convertBlob(layer.blobs(2));
  const float eps = params.eps();
 
  float scale_factor = *reinterpret_cast<float *>(scale_tensor.at(mir::Index{0}));
 
  // See https://github.com/BVLC/caffe/blob/master/src/caffe/layers/batch_norm_layer.cpp#L100
  // Y = (X - mean / scale_factor) / sqrt(var / scale_factor + epsilon) =
  //   = (X + C1) * C2
  if (scale_factor != 0.0f)
    scale_factor = 1.0f / scale_factor;
 
  // C1 = -mean / scale_factor
  Tensor<float> mean_accessor(mean_tensor);
  for (const auto &idx : ShapeRange(mean_accessor.getShape()))
    mean_accessor.at(idx) *= -scale_factor;
  auto c1 = createOp<ops::ConstantOp>(mean_tensor)->getOutput(0);
 
  // C2 = 1 / sqrt(var / scale_factor + epsilon)
  Tensor<float> var_accessor(var_tensor);
  for (const auto &idx : ShapeRange(var_accessor.getShape()))
    var_accessor.at(idx) = 1.0f / std::sqrt(var_accessor.at(idx) * scale_factor + eps);
  auto c2 = createOp<ops::ConstantOp>(var_tensor)->getOutput(0);
 
  c1 = createOp<ops::ReshapeOp>(c1, Shape{1, c1->getShape().dim(0), 1, 1})->getOutput(0);
  c2 = createOp<ops::ReshapeOp>(c2, Shape{1, c2->getShape().dim(0), 1, 1})->getOutput(0);
 
  // Y = (X + C1) * C2
  auto result = createOp<ops::AddOp>(input, c1)->getOutput(0);
  result = createOp<ops::MulOp>(result, c2)->getOutput(0);
 
  return {result};
}

References mir::Tensor< T >::at(), mir::Tensor< T >::getShape(), and mir_caffe::input.

convertConcat()

std::vector< mir::Operation::Output * > mir_caffe::CaffeOpCreator::convertConcat	(	const caffe::LayerParameter &	layer,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 320 of file caffe_op_creator.cpp.

{
  const auto &params = layer.concat_param();
  auto concat = createOp<ops::ConcatOp>(inputs, params.axis());
  return {concat->getOutput(0)};
}

References mir_caffe::concat.

convertConvolution()

std::vector< mir::Operation::Output * > mir_caffe::CaffeOpCreator::convertConvolution	(	const caffe::LayerParameter &	layer,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 239 of file caffe_op_creator.cpp.

{
  const auto &params = layer.convolution_param();
  Conv2DOpAttributes attributes;
 
  convertConvolutionParam(params, attributes);
  attributes.num_groups = params.group();
  attributes.data_format = DataFormat::NCHW;
 
  assert(layer.blobs(0).shape().dim_size() == 4);
  auto kernel = createOp<ops::ConstantOp>(convertBlob(layer.blobs(0)))->getOutput(0);
  std::vector<std::size_t> perm{0, 2, 3, 1}; // OIHW -> OHWI
  kernel = createOp<ops::TransposeOp>(kernel, perm)->getOutput(0);
  auto result = createOp<ops::Conv2DOp>(inputs[0], kernel, attributes)->getOutput(0);
 
  // Add the bias, if any.
  if (params.bias_term())
  {
    auto bias = createOp<ops::ConstantOp>(convertBlob(layer.blobs(1)))->getOutput(0);
    bias = createOp<ops::ReshapeOp>(bias, Shape{1, bias->getShape().dim(0), 1, 1})->getOutput(0);
    result = createOp<ops::AddOp>(result, bias)->getOutput(0);
  }
 
  return {result};
}

References mir_caffe::bias, mir::Conv2DOpAttributes::data_format, and mir::Conv2DOpAttributes::num_groups.

convertDeconvolution()

std::vector< mir::Operation::Output * > mir_caffe::CaffeOpCreator::convertDeconvolution	(	const caffe::LayerParameter &	layer,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 267 of file caffe_op_creator.cpp.

{
  const caffe::ConvolutionParameter &params = layer.convolution_param();
  Deconv2DOpAttributes attributes;
 
  convertConvolutionParam(params, attributes);
  attributes.data_format = DataFormat::NCHW;
 
  if (params.group() != 1)
  {
    throw std::runtime_error("Deconvolution: 'group' != 1 is not supported.");
  }
 
  auto kernel = createOp<ops::ConstantOp>(convertBlob(layer.blobs(0)))->getOutput(0);
  std::vector<std::size_t> perm{2, 3, 1, 0}; // IOHW -> HWOI
  kernel = createOp<ops::TransposeOp>(kernel, perm)->getOutput(0);
  auto result = createOp<ops::DeConv2DOp>(inputs[0], kernel, attributes)->getOutput(0);
 
  // bias_term is optional (so might not be present) and defaults to true
  if (params.bias_term())
  {
    auto bias = createOp<ops::ConstantOp>(convertBlob(layer.blobs(1)))->getOutput(0);
    bias = createOp<ops::ReshapeOp>(bias, Shape{1, bias->getShape().dim(0), 1, 1})->getOutput(0);
    result = createOp<ops::AddOp>(result, bias)->getOutput(0);
  }
 
  return {result};
}

References mir_caffe::bias, and mir::Deconv2DOpAttributes::data_format.

convertDropout()

std::vector< mir::Operation::Output * > mir_caffe::CaffeOpCreator::convertDropout	(	const caffe::LayerParameter &	layer,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 586 of file caffe_op_creator.cpp.

{
  // This is a no-op in inference mode.
  return {inputs[0]};
}

convertEltwise()

std::vector< mir::Operation::Output * > mir_caffe::CaffeOpCreator::convertEltwise	(	const caffe::LayerParameter &	layer,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 638 of file caffe_op_creator.cpp.

{
  auto &params = layer.eltwise_param();
 
  mir::Operation::Output *result;
  switch (params.operation())
  {
    case caffe::EltwiseParameter::PROD:
    {
      result = createOp<ops::MulOp>(inputs[0], inputs[1])->getOutput(0);
      for (int i = 2; i < layer.bottom_size(); ++i)
      {
        result = createOp<ops::MulOp>(result, inputs[i])->getOutput(0);
      }
      break;
    }
    case caffe::EltwiseParameter::SUM:
    {
      std::vector<mir::Operation::Output *> scaled_inputs = inputs;
      if (params.coeff_size() > 0)
      {
        assert(params.coeff_size() == layer.bottom_size());
        for (int i = 0; i < layer.bottom_size(); i++)
        {
          if (params.coeff(i) != 1.0f)
          {
            const float coeff_val = params.coeff(i);
            TensorVariant coeff_tensor({DataType::FLOAT32, {}}, &coeff_val);
            auto coeff_const = createOp<ops::ConstantOp>(coeff_tensor)->getOutput(0);
            scaled_inputs[i] = createOp<ops::MulOp>(coeff_const, inputs[i])->getOutput(0);
          }
        }
      }
      result = createOp<ops::AddOp>(scaled_inputs[0], scaled_inputs[1])->getOutput(0);
      for (int i = 2; i < layer.bottom_size(); ++i)
      {
        result = createOp<ops::AddOp>(result, scaled_inputs[i])->getOutput(0);
      }
      break;
    }
    case caffe::EltwiseParameter::MAX:
    {
      result = createOp<ops::MaxOp>(inputs[0], inputs[1])->getOutput(0);
      for (int i = 2; i < layer.bottom_size(); ++i)
      {
        result = createOp<ops::MaxOp>(result, inputs[i])->getOutput(0);
      }
      break;
    }
    default:
      throw std::runtime_error("Unknown element-wise operation.");
  }
  return {result};
}

convertELU()

std::vector< mir::Operation::Output * > mir_caffe::CaffeOpCreator::convertELU	(	const caffe::LayerParameter &	layer,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 594 of file caffe_op_creator.cpp.

{
  const caffe::ELUParameter &params = layer.elu_param();
 
  auto elu = createOp<ops::EluOp>(inputs[0], params.alpha());
  return {elu->getOutput(0)};
}

convertEmbed()

std::vector< mir::Operation::Output * > mir_caffe::CaffeOpCreator::convertEmbed	(	const caffe::LayerParameter &	layer,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 604 of file caffe_op_creator.cpp.

{
  const auto &params = layer.embed_param();
  auto data = createOp<ops::ConstantOp>(convertBlob(layer.blobs(0)));
  auto result = createOp<ops::GatherOp>(data->getOutput(0), inputs[0], 0)->getOutput(0);
 
  // Add the bias, if any.
  if (params.bias_term())
  {
    auto bias = createOp<ops::ConstantOp>(convertBlob(layer.blobs(1)))->getOutput(0);
    result = createOp<ops::AddOp>(result, bias)->getOutput(0);
  }
 
  return {result};
}

References mir_caffe::bias, and mir_caffe::data.

convertInnerProduct()

std::vector< mir::Operation::Output * > mir_caffe::CaffeOpCreator::convertInnerProduct	(	const caffe::LayerParameter &	layer,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 298 of file caffe_op_creator.cpp.

{
  const auto &params = layer.inner_product_param();
  auto weights = createOp<ops::ConstantOp>(convertBlob(layer.blobs(0)))->getOutput(0);
 
  if (!params.transpose())
    weights = createOp<ops::TransposeOp>(weights, std::vector<std::size_t>{1, 0})->getOutput(0);
 
  auto result = createFullyConnected(inputs[0], weights, params.axis());
 
  // Add the bias, if any.
  if (params.bias_term())
  {
    auto bias = createOp<ops::ConstantOp>(convertBlob(layer.blobs(1)))->getOutput(0);
    result = createOp<ops::AddOp>(result, bias)->getOutput(0);
  }
 
  return {result};
}

References mir_caffe::bias.

convertInput()

std::vector< mir::Operation::Output * > mir_caffe::CaffeOpCreator::convertInput

(

const caffe::LayerParameter &

layer

)

Definition at line 144 of file caffe_op_creator.cpp.

{
  const auto &params = layer.input_param();
  const auto num_inputs = layer.top_size();
  const auto num_shapes = params.shape_size();
  std::vector<mir::Operation::Output *> outputs;
 
  assert((num_shapes == 1 || num_shapes == num_inputs) && "Unsupported number of shapes.");
 
  for (int i = 0; i < num_inputs; ++i)
  {
    const auto &blob_shape = params.shape(num_shapes == 1 ? 0 : i);
    mir::TensorType input_type(DataType::FLOAT32, convertBlobShape(blob_shape));
    auto input = createOp<ops::InputOp>(input_type)->getOutput(0);
    outputs.push_back(input);
  }
 
  return outputs;
}

References mir_caffe::input.

convertLSTM()

std::vector< mir::Operation::Output * > mir_caffe::CaffeOpCreator::convertLSTM	(	const caffe::LayerParameter &	layer,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 771 of file caffe_op_creator.cpp.

{
  const auto &params = layer.recurrent_param();
 
  // Inputs to the layer.
  auto x = inputs[0];
  auto cont = inputs[1];
  assert(inputs.size() == 2);
 
  const auto &x_shape = x->getShape();
  const int32_t seq_length = x_shape.dim(0);
  const int32_t batch_size = x_shape.dim(1);
  const int32_t hidden_size = params.num_output();
 
  // Learned parameters of the layer. Tensors are transposed to match the ModelIR.
  auto xw = createOp<ops::ConstantOp>(convertBlob(layer.blobs(0)))->getOutput(0);
  auto xb = createOp<ops::ConstantOp>(convertBlob(layer.blobs(1)))->getOutput(0);
  auto hw = createOp<ops::ConstantOp>(convertBlob(layer.blobs(2)))->getOutput(0);
  xw = createOp<ops::TransposeOp>(xw, std::vector<std::size_t>{1, 0})->getOutput(0);
  hw = createOp<ops::TransposeOp>(hw, std::vector<std::size_t>{1, 0})->getOutput(0);
 
  // Add a dummy dimension so that element-wise operations perform properly.
  cont = createOp<ops::ReshapeOp>(cont, Shape{seq_length, batch_size, 1})->getOutput(0);
 
  // Initialize cell and hidden states with zeros.
  auto zero_tensor = createZeroedTensor(Shape{1, batch_size, hidden_size});
  auto c_t = createOp<ops::ConstantOp>(zero_tensor)->getOutput(0);
  auto h_t = createOp<ops::ConstantOp>(zero_tensor)->getOutput(0);
 
  auto x_xw = createFullyConnected(x, xw, 2);
  auto x_xw_b = createOp<ops::AddOp>(x_xw, xb)->getOutput(0);
 
  // Split input and continuation tensors into seq_length slices.
  std::vector<mir::Operation::Output *> x_xw_b_slices = createSplit(x_xw_b, seq_length, 0);
  std::vector<mir::Operation::Output *> cont_slices = createSplit(cont, seq_length, 0);
  std::vector<mir::Operation::Output *> h_slices(seq_length);
 
  for (int32_t t = 0; t < seq_length; t++)
  {
    auto c_cont_t = createOp<ops::MulOp>(c_t, cont_slices[t])->getOutput(0);
    auto h_cont_t = createOp<ops::MulOp>(h_t, cont_slices[t])->getOutput(0);
 
    auto x_xw_b_t = x_xw_b_slices[t];
    auto h_hw_t = createFullyConnected(h_cont_t, hw, 2);
    auto activation_inputs_concat = createOp<ops::AddOp>(x_xw_b_t, h_hw_t)->getOutput(0);
    auto activation_inputs = createSplit(activation_inputs_concat, 4, 2);
 
    auto i_t = createOp<ops::SigmoidOp>(activation_inputs[0])->getOutput(0);
    auto f_t = createOp<ops::SigmoidOp>(activation_inputs[1])->getOutput(0);
    auto o_t = createOp<ops::SigmoidOp>(activation_inputs[2])->getOutput(0);
    auto g_t = createOp<ops::TanhOp>(activation_inputs[3])->getOutput(0);
 
    c_t = createOp<ops::AddOp>(createOp<ops::MulOp>(c_cont_t, f_t)->getOutput(0),
                               createOp<ops::MulOp>(i_t, g_t)->getOutput(0))
            ->getOutput(0);
    h_t = createOp<ops::MulOp>(createOp<ops::TanhOp>(c_t)->getOutput(0), o_t)->getOutput(0);
 
    h_slices[t] = h_t;
  }
 
  return {createOp<ops::ConcatOp>(h_slices, 0)->getOutput(0)};
}

convertPooling()

std::vector< mir::Operation::Output * > mir_caffe::CaffeOpCreator::convertPooling	(	const caffe::LayerParameter &	layer,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 400 of file caffe_op_creator.cpp.

{
  const auto &params = layer.pooling_param();
 
  assert(inputs.size() == 1);
  auto input = inputs[0];
 
  mir::Operation::Output *result;
 
  switch (params.pool())
  {
    case caffe::PoolingParameter::AVE:
    {
      AvgPool2DOpAttributes attributes_avg;
      attributes_avg.data_format = DataFormat::NCHW;
      convertPoolingParam(params, input->getShape(), attributes_avg);
      result = createOp<ops::AvgPool2DOp>(input, attributes_avg)->getOutput(0);
      break;
    }
    case caffe::PoolingParameter::MAX:
    {
      MaxPool2DOpAttributes attributes_max;
      attributes_max.data_format = DataFormat::NCHW;
      convertPoolingParam(params, input->getShape(), attributes_max);
      result = createOp<ops::MaxPool2DOp>(input, attributes_max)->getOutput(0);
      break;
    }
    default:
      throw std::runtime_error("Unsupported PoolMethod: " + std::to_string(params.pool()));
  }
 
  return {result};
}

References mir::AvgPool2DOpAttributes::data_format, mir::MaxPool2DOpAttributes::data_format, and mir_caffe::input.

convertReLU()

std::vector< mir::Operation::Output * > mir_caffe::CaffeOpCreator::convertReLU	(	const caffe::LayerParameter &	layer,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 496 of file caffe_op_creator.cpp.

{
  mir::Operation *relu;
  if (layer.relu_param().has_negative_slope())
  {
    float alpha = layer.relu_param().negative_slope();
    relu = createOp<ops::LeakyReluOp>(inputs[0], alpha);
  }
  else
  {
    relu = createOp<ops::ReluOp>(inputs[0]);
  }
 
  return {relu->getOutput(0)};
}

convertReshape()

std::vector< mir::Operation::Output * > mir_caffe::CaffeOpCreator::convertReshape	(	const caffe::LayerParameter &	layer,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Converts Caffe Reshape layer to Model IR Reshape operation.

Definition at line 485 of file caffe_op_creator.cpp.

{
  const caffe::ReshapeParameter &params = layer.reshape_param();
 
  const mir::Shape new_shape = convertBlobShape(params.shape());
  auto reshape = createOp<ops::ReshapeOp>(inputs[0], new_shape);
  return {reshape->getOutput(0)};
}

References mir_caffe::reshape.

convertScale()

std::vector< mir::Operation::Output * > mir_caffe::CaffeOpCreator::convertScale	(	const caffe::LayerParameter &	layer,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 514 of file caffe_op_creator.cpp.

{
  const auto &params = layer.scale_param();
  auto scale = createOp<ops::ConstantOp>(convertBlob(layer.blobs(0)))->getOutput(0);
  scale = createOp<ops::ReshapeOp>(scale, Shape{1, scale->getShape().dim(0), 1, 1})->getOutput(0);
  auto result = createOp<ops::MulOp>(inputs[0], scale)->getOutput(0);
 
  // Add the bias, if any.
  if (params.bias_term())
  {
    auto bias = createOp<ops::ConstantOp>(convertBlob(layer.blobs(1)))->getOutput(0);
    bias = createOp<ops::ReshapeOp>(bias, Shape{1, bias->getShape().dim(0), 1, 1})->getOutput(0);
    result = createOp<ops::AddOp>(result, bias)->getOutput(0);
  }
 
  return {result};
}

References mir_caffe::bias, and mir_caffe::scale.

convertSigmoid()

std::vector< mir::Operation::Output * > mir_caffe::CaffeOpCreator::convertSigmoid	(	const caffe::LayerParameter &	layer,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 622 of file caffe_op_creator.cpp.

{
  auto result = createOp<ops::SigmoidOp>(inputs[0]);
  return {result->getOutput(0)};
}

convertSoftmax()

std::vector< mir::Operation::Output * > mir_caffe::CaffeOpCreator::convertSoftmax	(	const caffe::LayerParameter &	layer,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 436 of file caffe_op_creator.cpp.

{
  const auto &params = layer.softmax_param();
 
  // CPP and ACL backends are able to perform Softmax only along the last axis.
  // FIXME Do it in backends.
  if (inputs[0]->getShape().rank() == 4)
  {
    // For now, we only account for the most common case.
    if (params.axis() != 1)
      throw std::runtime_error("Softmax: unsupported axis");
    int32_t axis = 3;
    auto input = createOp<ops::TransposeOp>(inputs[0], std::vector<std::size_t>{0, 2, 3, 1});
    auto softmax = createOp<ops::SoftmaxOp>(input->getOutput(0), axis);
    auto result =
      createOp<ops::TransposeOp>(softmax->getOutput(0), std::vector<std::size_t>{0, 3, 1, 2});
    return {result->getOutput(0)};
  }
 
  auto softmax = createOp<ops::SoftmaxOp>(inputs[0], params.axis());
  return {softmax->getOutput(0)};
}

References mir_caffe::input, and mir_caffe::softmax.

convertSplit()

std::vector< mir::Operation::Output * > mir_caffe::CaffeOpCreator::convertSplit	(	const caffe::LayerParameter &	layer,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 695 of file caffe_op_creator.cpp.

{
  std::vector<mir::Operation::Output *> outputs(layer.top_size(), inputs.at(0));
  return outputs;
}

convertTanH()

std::vector< mir::Operation::Output * > mir_caffe::CaffeOpCreator::convertTanH	(	const caffe::LayerParameter &	layer,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 630 of file caffe_op_creator.cpp.

{
  auto tanh = createOp<ops::TanhOp>(inputs[0]);
  return {tanh->getOutput(0)};
}

References mir_caffe::tanh.

---

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

• compiler/mir/src/mir_caffe_importer/caffe_op_creator.h
• compiler/mir/src/mir_caffe_importer/caffe_op_creator.cpp