mir_tflite::TFLiteOpCreator Class Reference

#include <tflite_op_creator.h>

Public Member Functions
	TFLiteOpCreator (mir::Graph *g)
std::vector< mir::Operation::Output * >	convertConv2D (const tflite::Conv2DOptionsT *opts, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertDepthwiseConv2D (const tflite::DepthwiseConv2DOptionsT *opts, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertConcatenation (const tflite::ConcatenationOptionsT *opts, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertMaxPool2D (const tflite::Pool2DOptionsT *opts, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertAveragePool2D (const tflite::Pool2DOptionsT *opts, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertMean (const tflite::ReducerOptionsT *opts, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertSoftmax (const tflite::SoftmaxOptionsT *opts, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertSlice (const tflite::SliceOptionsT *opts, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertReshape (const tflite::ReshapeOptionsT *opts, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertFullyConnected (const tflite::FullyConnectedOptionsT *opts, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertResizeNearestNeighbor (const tflite::ResizeNearestNeighborOptionsT *opts, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertLogistic (const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertRsqrt (const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertSqrt (const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertSqueeze (const tflite::SqueezeOptionsT *opts, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertAdd (const tflite::AddOptionsT *opts, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertSub (const tflite::SubOptionsT *opts, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertMul (const tflite::MulOptionsT *opts, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertDiv (const tflite::DivOptionsT *opts, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertMax (const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertSquaredDifference (const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertTanh (const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertReLU (const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertReLU6 (const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertTransposeConv (const tflite::TransposeConvOptionsT *opts, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertPad (const tflite::PadOptionsT *opts, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertTranspose (const tflite::TransposeOptionsT *opts, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertStridedSlice (const tflite::StridedSliceOptionsT *opts, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertLeakyReLU (const tflite::LeakyReluOptionsT *opts, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertShape (const tflite::ShapeOptionsT *opts, const std::vector< mir::Operation::Output * > &inputs)
std::vector< mir::Operation::Output * >	convertHardSwish (const tflite::HardSwishOptionsT *opts, const std::vector< mir::Operation::Output * > &inputs)

Detailed Description

Definition at line 30 of file tflite_op_creator.h.

Constructor & Destructor Documentation

TFLiteOpCreator()

mir_tflite::TFLiteOpCreator::TFLiteOpCreator ( mir::Graph *  g )

inlineexplicit

Definition at line 33 of file tflite_op_creator.h.

: _graph(g) {}

Member Function Documentation

convertAdd()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertAdd	(	const tflite::AddOptionsT *	opts,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 340 of file tflite_op_creator.cpp.

{
  assert(inputs.size() == 2);
  auto result = createOp<ops::AddOp>(inputs[0], inputs[1])->getOutput(0);
  return {addFusedActivation(result, opts->fused_activation_function)};
}

convertAveragePool2D()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertAveragePool2D	(	const tflite::Pool2DOptionsT *	opts,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 233 of file tflite_op_creator.cpp.

{
  auto input = inputs.at(0);
 
  const auto &input_shape = input->getShape();
 
  mir::AvgPool2DOpAttributes attributes;
  attributes.window = {opts->filter_height, opts->filter_width};
  attributes.strides = {opts->stride_h, opts->stride_w};
  attributes.include_pad = false;
 
  const auto padding_type = convertPadding(opts->padding);
  const auto &window_size = attributes.window;
  const auto &strides = attributes.strides;
  auto &pad_before = attributes.padding_before;
  auto &pad_after = attributes.padding_after;
  calculatePadding(padding_type, input_shape, window_size, strides, pad_before, pad_after);
 
  auto result = createOp<ops::AvgPool2DOp>(input, attributes);
  return {addFusedActivation(result->getOutput(0), opts->fused_activation_function)};
}

References mir::AvgPool2DOpAttributes::include_pad, mir::AvgPool2DOpAttributes::padding_after, mir::AvgPool2DOpAttributes::padding_before, mir::AvgPool2DOpAttributes::strides, and mir::AvgPool2DOpAttributes::window.

convertConcatenation()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertConcatenation	(	const tflite::ConcatenationOptionsT *	opts,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 202 of file tflite_op_creator.cpp.

{
  auto result = createOp<ops::ConcatOp>(inputs, opts->axis);
  return {addFusedActivation(result->getOutput(0), opts->fused_activation_function)};
}

convertConv2D()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertConv2D	(	const tflite::Conv2DOptionsT *	opts,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 132 of file tflite_op_creator.cpp.

{
  auto input = inputs.at(0);
  auto kernel = inputs.at(1);
  auto bias = inputs.at(2);
 
  mir::Conv2DOpAttributes attributes;
  attributes.strides = {opts->stride_h, opts->stride_w};
 
  const auto padding_type = convertPadding(opts->padding);
  const auto &input_shape = input->getShape();
  const auto &kernel_shape = kernel->getShape();
  const auto &strides = attributes.strides;
  auto &pad_before = attributes.padding_before;
  auto &pad_after = attributes.padding_after;
  std::vector<std::int32_t> kernel_size{kernel_shape.dim(1), kernel_shape.dim(2)};
  calculatePadding(padding_type, input_shape, kernel_size, strides, pad_before, pad_after);
 
  mir::Operation::Output *result;
  if (input->getType().isQuantized())
  {
    result = createOp<ops::Conv2DOp>(input, kernel, bias, attributes)->getOutput(0);
  }
  else // TODO Fuse bias to other backends
  {
    result = createOp<ops::Conv2DOp>(input, kernel, attributes)->getOutput(0);
    result = createOp<ops::AddOp>(result, bias)->getOutput(0);
  }
  return {addFusedActivation(result, opts->fused_activation_function)};
}

References mir::Conv2DOpAttributes::padding_after, mir::Conv2DOpAttributes::padding_before, and mir::Conv2DOpAttributes::strides.

convertDepthwiseConv2D()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertDepthwiseConv2D	(	const tflite::DepthwiseConv2DOptionsT *	opts,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 165 of file tflite_op_creator.cpp.

{
  auto input = inputs.at(0);
  auto kernel = inputs.at(1);
  auto bias = inputs.at(2);
 
  // OHWI -> HWIO
  const std::vector<std::size_t> axis_order{1, 2, 3, 0};
  kernel = createOp<ops::TransposeOp>(kernel, axis_order)->getOutput(0);
 
  mir::Conv2DOpAttributes attributes;
  attributes.strides = {opts->stride_h, opts->stride_w};
 
  const auto padding_type = convertPadding(opts->padding);
  const auto &input_shape = input->getShape();
  const auto &kernel_shape = kernel->getShape();
  std::vector<std::int32_t> kernel_size{kernel_shape.dim(0), kernel_shape.dim(1)};
  const auto &strides = attributes.strides;
  auto &pad_before = attributes.padding_before;
  auto &pad_after = attributes.padding_after;
  calculatePadding(padding_type, input_shape, kernel_size, strides, pad_before, pad_after);
 
  mir::Operation::Output *result;
  if (input->getType().isQuantized())
  {
    result = createOp<ops::DepthwiseConv2DOp>(input, kernel, bias, attributes)->getOutput(0);
  }
  else // TODO Fuse bias to other backends
  {
    result = createOp<ops::DepthwiseConv2DOp>(input, kernel, attributes)->getOutput(0);
    result = createOp<ops::AddOp>(result, bias)->getOutput(0);
  }
  return {addFusedActivation(result, opts->fused_activation_function)};
}

References mir::Conv2DOpAttributes::padding_after, mir::Conv2DOpAttributes::padding_before, and mir::Conv2DOpAttributes::strides.

convertDiv()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertDiv	(	const tflite::DivOptionsT *	opts,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 367 of file tflite_op_creator.cpp.

{
  assert(inputs.size() == 2);
  auto result = createOp<ops::DivOp>(inputs[0], inputs[1])->getOutput(0);
  return {addFusedActivation(result, opts->fused_activation_function)};
}

convertFullyConnected()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertFullyConnected	(	const tflite::FullyConnectedOptionsT *	opts,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 405 of file tflite_op_creator.cpp.

{
  auto input = inputs.at(0);
  auto weights = inputs.at(1);
  auto bias = inputs.at(2);
 
  // Flatten input to 2-D shape.
  const auto &input_shape = input->getShape();
  int32_t outer_size = input_shape.dim(0);
  int32_t inner_size = input_shape.numElements() / outer_size;
  auto flatten = createOp<ops::ReshapeOp>(input, Shape{outer_size, inner_size})->getOutput(0);
 
  // Transpose the weights.
  const std::vector<std::size_t> axis_order{1, 0};
  weights = createOp<ops::TransposeOp>(weights, axis_order)->getOutput(0);
 
  mir::Operation::Output *result;
  if (input->getType().isQuantized())
  {
    result = createOp<ops::FullyConnectedOp>(flatten, weights, bias)->getOutput(0);
  }
  else // TODO Fuse bias to other backends
  {
    result = createOp<ops::FullyConnectedOp>(flatten, weights)->getOutput(0);
    result = createOp<ops::AddOp>(result, bias)->getOutput(0);
  }
  return {addFusedActivation(result, opts->fused_activation_function)};
}

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

convertHardSwish()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertHardSwish	(	const tflite::HardSwishOptionsT *	opts,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 645 of file tflite_op_creator.cpp.

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

convertLeakyReLU()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertLeakyReLU	(	const tflite::LeakyReluOptionsT *	opts,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 614 of file tflite_op_creator.cpp.

{
  auto input = inputs.at(0);
 
  auto result = createOp<ops::LeakyReluOp>(input, opts->alpha);
  return {result->getOutput(0)};
}

convertLogistic()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertLogistic

(

const std::vector< mir::Operation::Output * > &

inputs

)

Definition at line 537 of file tflite_op_creator.cpp.

{
  auto input = inputs.at(0);
 
  auto result = createOp<ops::SigmoidOp>(input);
  return {result->getOutput(0)};
}

convertMax()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertMax

(

const std::vector< mir::Operation::Output * > &

inputs

)

Definition at line 376 of file tflite_op_creator.cpp.

{
  assert(inputs.size() == 2);
  auto result = createOp<ops::MaxOp>(inputs[0], inputs[1])->getOutput(0);
  return {result};
}

convertMaxPool2D()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertMaxPool2D	(	const tflite::Pool2DOptionsT *	opts,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 210 of file tflite_op_creator.cpp.

{
  auto input = inputs.at(0);
 
  const auto &input_shape = input->getShape();
 
  mir::MaxPool2DOpAttributes attributes;
  attributes.window = {opts->filter_height, opts->filter_width};
  attributes.strides = {opts->stride_h, opts->stride_w};
 
  const auto padding_type = convertPadding(opts->padding);
  const auto &window_size = attributes.window;
  const auto &strides = attributes.strides;
  auto &pad_before = attributes.padding_before;
  auto &pad_after = attributes.padding_after;
  calculatePadding(padding_type, input_shape, window_size, strides, pad_before, pad_after);
 
  auto result = createOp<ops::MaxPool2DOp>(input, attributes);
  return {addFusedActivation(result->getOutput(0), opts->fused_activation_function)};
}

References mir::MaxPool2DOpAttributes::padding_after, mir::MaxPool2DOpAttributes::padding_before, mir::MaxPool2DOpAttributes::strides, and mir::MaxPool2DOpAttributes::window.

convertMean()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertMean	(	const tflite::ReducerOptionsT *	opts,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 393 of file tflite_op_creator.cpp.

{
  auto input = inputs.at(0);
  mir::Tensor<int32_t> axes_tensor(extractTensor(inputs.at(1)));
 
  std::vector<int32_t> axes = convertIntTensorToVector<int32_t>(axes_tensor);
  auto result = createOp<ops::ReduceMeanOp>(input, axes, opts->keep_dims);
  return {result->getOutput(0)};
}

convertMul()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertMul	(	const tflite::MulOptionsT *	opts,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 358 of file tflite_op_creator.cpp.

{
  assert(inputs.size() == 2);
  auto result = createOp<ops::MulOp>(inputs[0], inputs[1])->getOutput(0);
  return {addFusedActivation(result, opts->fused_activation_function)};
}

convertPad()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertPad	(	const tflite::PadOptionsT *	opts,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 467 of file tflite_op_creator.cpp.

{
  auto input = inputs.at(0);
  mir::Tensor<int32_t> paddings_tensor(extractTensor(inputs.at(1)));
 
  const auto &input_shape = input->getShape();
  const int num_dims = input_shape.rank();
 
  mir::PadOpAttributes attributes(num_dims);
  for (int i = 0; i < num_dims; i++)
  {
    attributes.padding_before[i] = paddings_tensor.at(mir::Index({i, 0}));
    attributes.padding_after[i] = paddings_tensor.at(mir::Index({i, 1}));
  }
 
  auto result = createOp<ops::PadOp>(input, attributes)->getOutput(0);
  return {result};
}

References mir::Tensor< T >::at(), mir::PadOpAttributes::padding_after, mir::PadOpAttributes::padding_before, and mir::Shape::rank().

convertReLU()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertReLU

(

const std::vector< mir::Operation::Output * > &

inputs

)

Definition at line 497 of file tflite_op_creator.cpp.

{
  auto input = inputs.at(0);
 
  auto result = createOp<ops::ReluOp>(input);
  return {result->getOutput(0)};
}

convertReLU6()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertReLU6

(

const std::vector< mir::Operation::Output * > &

inputs

)

Definition at line 506 of file tflite_op_creator.cpp.

{
  auto input = inputs.at(0);
 
  auto result = createOp<ops::CappedReluOp>(input, 6);
  return {result->getOutput(0)};
}

convertReshape()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertReshape	(	const tflite::ReshapeOptionsT *	opts,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 284 of file tflite_op_creator.cpp.

{
  auto input = inputs.at(0);
 
  // TODO: we should also support "-1" values in new_shape, which means that correct
  // shape values must be calculated. Better do it in the shape inference module.
  Shape new_shape(opts->new_shape.size());
  for (int i = 0; i < static_cast<int>(opts->new_shape.size()); ++i)
  {
    new_shape.dim(i) = opts->new_shape[i];
  }
  auto result = createOp<ops::ReshapeOp>(input, new_shape);
  return {result->getOutput(0)};
}

References mir::Shape::dim().

convertResizeNearestNeighbor()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertResizeNearestNeighbor	(	const tflite::ResizeNearestNeighborOptionsT *	opts,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 322 of file tflite_op_creator.cpp.

{
  if (opts->align_corners)
    throw std::runtime_error("'align_corners' is not currently supported");
 
  auto input = inputs.at(0);
  mir::Tensor<int32_t> size_tensor(extractTensor(inputs.at(1)));
 
  const auto &input_shape = input->getShape();
  Shape res_shape{input_shape.dim(0), size_tensor.at(mir::Index{0}), size_tensor.at(mir::Index{1}),
                  input_shape.dim(3)};
  auto result =
    createOp<ops::ResizeOp>(input, ops::ResizeOp::ResizeMethod::nearestNeighbor, res_shape);
  return {result->getOutput(0)};
}

References mir::Tensor< T >::at(), and mir::Shape::dim().

convertRsqrt()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertRsqrt

(

const std::vector< mir::Operation::Output * > &

inputs

)

Definition at line 515 of file tflite_op_creator.cpp.

{
  auto input = inputs.at(0);
 
  const float one_value = 1.0f;
  mir::TensorVariant one_tensor({mir::DataType::FLOAT32, {}}, &one_value);
  auto one = createOp<ops::ConstantOp>(one_tensor)->getOutput(0);
  auto sqrt = createOp<ops::SqrtOp>(input)->getOutput(0);
  auto result = createOp<ops::DivOp>(one, sqrt)->getOutput(0);
  return {result};
}

convertShape()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertShape	(	const tflite::ShapeOptionsT *	opts,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 624 of file tflite_op_creator.cpp.

{
  if (opts->out_type != tflite::TensorType_INT32)
  {
    throw std::runtime_error(std::string("SHAPE: Unsupported tensor type: ") +
                             EnumNameTensorType(opts->out_type));
  }
 
  const auto &input_shape = inputs[0]->getShape();
  int32_t rank = input_shape.rank();
  std::vector<int32_t> data;
  data.reserve(static_cast<uint64_t>(rank));
  for (int32_t i = 0; i < rank; i++)
    data.emplace_back(input_shape.dim(i));
  mir::TensorVariant tensor({mir::DataType::INT32, {rank}}, data.data());
  auto result = createOp<ops::ConstantOp>(tensor);
  return {result->getOutput(0)};
}

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

convertSlice()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertSlice	(	const tflite::SliceOptionsT *	opts,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 270 of file tflite_op_creator.cpp.

{
  auto input = inputs.at(0);
  mir::Tensor<int32_t> begin_tensor(extractTensor(inputs.at(1)));
  mir::Tensor<int32_t> size_tensor(extractTensor(inputs.at(2)));
 
  Shape starts(convertIntTensorToVector<int32_t>(begin_tensor));
  Shape sizes(convertIntTensorToVector<int32_t>(size_tensor));
  auto result = createOp<ops::SliceOp>(input, starts, sizes);
  return {result->getOutput(0)};
}

convertSoftmax()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertSoftmax	(	const tflite::SoftmaxOptionsT *	opts,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 257 of file tflite_op_creator.cpp.

{
  auto input = inputs.at(0);
 
  // Softmax in TFLite is always 2-D.
  assert(input->getShape().rank() == 2);
  const int32_t axis = 1;
  auto result = createOp<ops::SoftmaxOp>(input, axis);
  return {result->getOutput(0)};
}

convertSqrt()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertSqrt

(

const std::vector< mir::Operation::Output * > &

inputs

)

Definition at line 528 of file tflite_op_creator.cpp.

{
  auto input = inputs.at(0);
 
  auto result = createOp<ops::SqrtOp>(input)->getOutput(0);
  return {result};
}

convertSquaredDifference()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertSquaredDifference

(

const std::vector< mir::Operation::Output * > &

inputs

)

Definition at line 384 of file tflite_op_creator.cpp.

{
  assert(inputs.size() == 2);
  auto result = createOp<ops::SubOp>(inputs[0], inputs[1])->getOutput(0);
  result = createOp<ops::MulOp>(result, result)->getOutput(0);
  return {result};
}

convertSqueeze()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertSqueeze	(	const tflite::SqueezeOptionsT *	opts,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 456 of file tflite_op_creator.cpp.

{
  auto input = inputs.at(0);
 
  std::vector<int32_t> squeeze_dims(opts->squeeze_dims.begin(), opts->squeeze_dims.end());
  auto result = createOp<ops::SqueezeOp>(input, squeeze_dims);
  return {result->getOutput(0)};
}

convertStridedSlice()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertStridedSlice	(	const tflite::StridedSliceOptionsT *	opts,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 558 of file tflite_op_creator.cpp.

{
  if (opts->ellipsis_mask != 0)
    throw std::runtime_error("StridedSlice: parameter 'ellipsis_mask' is not supported.");
 
  if (opts->new_axis_mask != 0)
    throw std::runtime_error("StridedSlice: parameter 'new_axis_mask' is not supported.");
 
  auto input = inputs.at(0);
  mir::Tensor<int32_t> begin_tensor(extractTensor(inputs.at(1)));
  mir::Tensor<int32_t> end_tensor(extractTensor(inputs.at(2)));
  mir::Tensor<int32_t> strides_tensor(extractTensor(inputs.at(3)));
 
  std::vector<int32_t> begin = convertIntTensorToVector<int32_t>(begin_tensor);
  std::vector<int32_t> end = convertIntTensorToVector<int32_t>(end_tensor);
  std::vector<int32_t> strides = convertIntTensorToVector<int32_t>(strides_tensor);
 
  int32_t begin_mask = opts->begin_mask;
  int32_t end_mask = opts->end_mask;
  int32_t shrink_axis_mask = opts->shrink_axis_mask;
 
  const auto &input_shape = input->getShape();
  int32_t num_dims = input_shape.rank();
 
  for (int32_t stride : strides)
  {
    if (stride != 1)
      throw std::runtime_error("StridedSlice: parameter 'strides' is not supported");
  }
 
  Shape start(num_dims);
  Shape size(num_dims);
  std::vector<int32_t> squeeze_dims;
  for (int axis = 0; axis < num_dims; axis++)
  {
    if (static_cast<uint32_t>(begin_mask) & (1u << static_cast<uint32_t>(axis)))
      start.dim(axis) = 0;
    else
      start.dim(axis) = begin.at(static_cast<uint64_t>(axis));
 
    if (static_cast<uint32_t>(end_mask) & (1u << static_cast<uint32_t>(axis)))
      size.dim(axis) = input_shape.dim(axis) - start.dim(axis);
    else
      size.dim(axis) = end.at(static_cast<uint64_t>(axis)) - start.dim(axis);
 
    if (static_cast<uint32_t>(shrink_axis_mask) & (1u << static_cast<uint32_t>(axis)))
      squeeze_dims.push_back(axis);
  }
 
  auto result = createOp<ops::SliceOp>(input, start, size);
  result = createOp<ops::SqueezeOp>(result->getOutput(0), squeeze_dims);
  return {result->getOutput(0)};
}

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

convertSub()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertSub	(	const tflite::SubOptionsT *	opts,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 349 of file tflite_op_creator.cpp.

{
  assert(inputs.size() == 2);
  auto result = createOp<ops::SubOp>(inputs[0], inputs[1])->getOutput(0);
  return {addFusedActivation(result, opts->fused_activation_function)};
}

convertTanh()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertTanh

(

const std::vector< mir::Operation::Output * > &

inputs

)

Definition at line 488 of file tflite_op_creator.cpp.

{
  auto input = inputs.at(0);
 
  auto result = createOp<ops::TanhOp>(input);
  return {result->getOutput(0)};
}

convertTranspose()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertTranspose	(	const tflite::TransposeOptionsT *	opts,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 546 of file tflite_op_creator.cpp.

{
  auto input = inputs.at(0);
  mir::Tensor<int32_t> perm_tensor(extractTensor(inputs.at(1)));
 
  std::vector<std::size_t> axis_order = convertIntTensorToVector<std::size_t>(perm_tensor);
  auto result = createOp<ops::TransposeOp>(input, axis_order);
  return {result->getOutput(0)};
}

convertTransposeConv()

std::vector< mir::Operation::Output * > mir_tflite::TFLiteOpCreator::convertTransposeConv	(	const tflite::TransposeConvOptionsT *	opts,
		const std::vector< mir::Operation::Output * > &	inputs
	)

Definition at line 301 of file tflite_op_creator.cpp.

{
  mir::Tensor<int32_t> output_shape_tensor(extractTensor(inputs.at(0)));
  auto kernel = inputs.at(1);
  auto input = inputs.at(2);
 
  mir::Deconv2DOpAttributes attributes;
  attributes.strides = {opts->stride_h, opts->stride_w};
  Shape output_shape(convertIntTensorToVector<int32_t>(output_shape_tensor));
 
  // OHWI -> HWOI
  const std::vector<std::size_t> axis_order{1, 2, 0, 3};
  kernel = createOp<ops::TransposeOp>(kernel, axis_order)->getOutput(0);
 
  attributes.padding_type = convertPadding(opts->padding);
  auto result = createOp<ops::DeConv2DOp>(input, kernel, attributes, output_shape)->getOutput(0);
  return {result};
}

References output_shape, mir::Deconv2DOpAttributes::padding_type, and mir::Deconv2DOpAttributes::strides.

---

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

• compiler/mir/src/mir_tflite_importer/tflite_op_creator.h
• compiler/mir/src/mir_tflite_importer/tflite_op_creator.cpp