mir_onnx Namespace Reference

Data Structures
class	ConverterContext
class	ModelContext
class	NodeConverterRegistry

Functions
std::unique_ptr< mir::Graph >	importModelFromBinaryFile (const std::string &filename)
std::unique_ptr< mir::Graph >	importModelFromTextFile (const std::string &filename)
std::unique_ptr< mir::Graph >	loadModel (const std::string &filename)
template<typename T >
T	getAttributeValue (const onnx::AttributeProto &attribute)=delete
template<>
float	getAttributeValue (const onnx::AttributeProto &attribute)
template<>
std::int64_t	getAttributeValue (const onnx::AttributeProto &attribute)
template<>
std::string	getAttributeValue (const onnx::AttributeProto &attribute)
template<>
onnx::TensorProto	getAttributeValue (const onnx::AttributeProto &attribute)
template<>
std::vector< std::int32_t >	getAttributeValue (const onnx::AttributeProto &attribute)
template<>
std::vector< std::int64_t >	getAttributeValue (const onnx::AttributeProto &attribute)
const onnx::AttributeProto *	findAttribute (const onnx::NodeProto &node, const std::string &name)
template<typename T >
T	getAttributeValue (const onnx::NodeProto &node, const std::string &name)
template<typename T >
T	getAttributeValue (const onnx::NodeProto &node, const std::string &name, T default_value)
void	inferAutoPadding (const std::string &pad_type, const mir::Shape &input_shape, const std::vector< std::int32_t > &dilations, const std::vector< std::int32_t > &strides, const std::vector< std::int32_t > &window_size, std::vector< std::int32_t > &padding_before, std::vector< std::int32_t > &padding_after)
std::vector< std::int32_t >	fixPads (const mir::Shape &input_shape, const std::vector< std::int32_t > &pads, const std::vector< std::int32_t > &strides, const std::vector< std::int32_t > &dilation, const std::vector< std::int32_t > &kernel_shape)
mir::Shape	constantToShape (const mir::ops::ConstantOp *op)
mir::DataType	onnxDataTypeToMirDataType (onnx::TensorProto::DataType type)
mir::TensorVariant	createTensor (const onnx::TensorProto *tensor)
mir::Operation *	foldConstants (mir::Graph *graph, mir::Operation *op)
template<typename OpType , typename... Types>
mir::Operation *	createOp (mir::Graph *graph, Types &&...args)
void	registerSupportedOps ()
void	convertAbsV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertAbsV6 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertAddV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertAddV6 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertAddV7 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertAveragePoolV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertAveragePoolV7 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertAveragePoolV10 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertBatchNormalizationV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertBatchNormalizationV6 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertBatchNormalizationV7 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertBatchNormalizationV9 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertConcatV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertConcatV4 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertConstantV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertConstantV9 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertConstantV11 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertConvV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertConvTransposeV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertDivV7 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertDropoutV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertDropoutV6 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertDropoutV7 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertDropoutV10 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertEqualV11 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertEqualV7 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertExpandV8 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertFlattenV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertFlattenV9 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertGatherV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertGemmV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertGemmV6 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertGemmV7 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertGemmV9 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertGemmV11 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertGlobalAveragePoolV2 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertGreaterV7 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertGreaterV9 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertIdentityV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertLessV7 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertLessV9 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertMatMulV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertMatMulV9 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertMaxV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertMaxV6 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertMaxV8 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertMaxPoolV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertMaxPoolV8 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertMaxPoolV10 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertMulV7 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertPadAttrName (const std::string &pad_attr_name, const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertPadV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertPadV2 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertReciprocalV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertReciprocalV6 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertReduceMeanV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertReluV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertReluV6 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertReshapeV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertReshapeV5 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertShapeV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertSigmoidV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertSigmoidV6 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertSoftmaxV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertSqrtV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertSqrtV6 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertSubV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertSubV6 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertSubV7 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertSumV8 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertTanhV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertTanhV6 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertTransposeV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertUnsqueezeV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertUpsampleV1 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertUpsampleV7 (const onnx::NodeProto &onnx_node, ConverterContext *context)
void	convertUpsampleV9 (const onnx::NodeProto &onnx_node, ConverterContext *context)

Variables
const int64_t	firstUnknownOpset = 13

Function Documentation

constantToShape()

mir::Shape mir_onnx::constantToShape

(

const mir::ops::ConstantOp *

op

)

Definition at line 48 of file ONNXHelpers.cpp.

{
  const auto &t = op->getValue();
  mir::DataType d_type = t.getElementType();
 
  if (t.getType().isQuantized())
    throw std::runtime_error("unsupported data type of shape operator");
 
  switch (d_type)
  {
    case mir::DataType::FLOAT32:
      return constantToShapeT<float>(t);
      break;
    case mir::DataType::FLOAT64:
      return constantToShapeT<double>(t);
      break;
    case mir::DataType::INT32:
      return constantToShapeT<int32_t>(t);
      break;
    case mir::DataType::INT64:
      return constantToShapeT<int64_t>(t);
      break;
    case mir::DataType::UINT8:
      return constantToShapeT<uint8_t>(t);
      break;
    default:
      throw std::runtime_error{"Unknown datatype in constant"};
      break;
  }
}

References mir::TensorVariant::getElementType(), and mir::ops::ConstantOp::getValue().

Referenced by convertExpandV8().

convertAbsV1()

void mir_onnx::convertAbsV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 37 of file Abs.cpp.

{
  convertAbsGeneric(onnx_node, context);
}

convertAbsV6()

void mir_onnx::convertAbsV6	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 42 of file Abs.cpp.

{
  convertAbsGeneric(onnx_node, context);
}

convertAddV1()

void mir_onnx::convertAddV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 27 of file Add.cpp.

{
  // consumed_inputs attribute not used
  convertAddV6(onnx_node, context);
}

References convertAddV6().

convertAddV6()

void mir_onnx::convertAddV6	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 33 of file Add.cpp.

{
  // broadcast attribute not used
  const auto *axis = findAttribute(onnx_node, "axis");
  if (axis != nullptr)
    throw std::runtime_error("Not supported axis attribute in Add operation!");
 
  convertAddV7(onnx_node, context);
}

References convertAddV7(), and findAttribute().

Referenced by convertAddV1().

convertAddV7()

void mir_onnx::convertAddV7	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 43 of file Add.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
 
  auto result = createOp<mir::ops::AddOp>(graph, inputs[0], inputs[1])->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), and mir_onnx::ConverterContext::setNodeOutputs().

Referenced by convertAddV6().

convertAveragePoolV1()

void mir_onnx::convertAveragePoolV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 28 of file AveragePool.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
 
  assert(inputs.size() == 1);
  auto input = inputs[0];
 
  const auto &input_shape = input->getShape();
  if (input_shape.rank() != 4)
    throw std::runtime_error("AveragePool: only 2-D input is supported.");
 
  constexpr int num_spatial_dims = 2;
 
  const auto strides =
    getAttributeValue(onnx_node, "strides", std::vector<std::int32_t>(num_spatial_dims, 1));
  if (strides.size() != num_spatial_dims)
    throw std::runtime_error("AveragePool: attribute 'strides' has incorrect size.");
 
  const auto kernel_shape = getAttributeValue<std::vector<std::int32_t>>(onnx_node, "kernel_shape");
  if (kernel_shape.size() != num_spatial_dims)
    throw std::runtime_error("AveragePool: attribute 'kernel_shape' has incorrect size.");
 
  std::vector<std::int32_t> padding_before(num_spatial_dims, 0);
  std::vector<std::int32_t> padding_after(num_spatial_dims, 0);
  if (const auto *pads_attr = findAttribute(onnx_node, "pads"))
  {
    const auto pads = getAttributeValue<std::vector<std::int32_t>>(*pads_attr);
    if (pads.size() != num_spatial_dims * 2)
      throw std::runtime_error("AveragePool: attribute 'pads' has incorrect size.");
    padding_before.assign(pads.cbegin(), std::next(pads.cbegin(), num_spatial_dims));
    padding_after.assign(std::next(pads.cbegin(), num_spatial_dims), pads.cend());
  }
  else
  {
    const auto auto_pad = getAttributeValue<std::string>(onnx_node, "auto_pad", "NOTSET");
    const std::vector<std::int32_t> dilations(num_spatial_dims, 1);
    inferAutoPadding(auto_pad, input_shape, dilations, strides, kernel_shape, padding_before,
                     padding_after);
  }
 
  mir::AvgPool2DOpAttributes attributes;
  attributes.window = kernel_shape;
  attributes.strides = strides;
  attributes.padding_before = padding_before;
  attributes.padding_after = padding_after;
  attributes.include_pad = false;
  attributes.data_format = mir::DataFormat::NCHW;
  auto result = createOp<mir::ops::AvgPool2DOp>(graph, input, attributes)->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References mir::AvgPool2DOpAttributes::data_format, findAttribute(), getAttributeValue(), mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), mir::AvgPool2DOpAttributes::include_pad, inferAutoPadding(), mir::NCHW, mir::AvgPool2DOpAttributes::padding_after, mir::AvgPool2DOpAttributes::padding_before, mir_onnx::ConverterContext::setNodeOutputs(), mir::AvgPool2DOpAttributes::strides, and mir::AvgPool2DOpAttributes::window.

Referenced by convertAveragePoolV7().

convertAveragePoolV10()

void mir_onnx::convertAveragePoolV10	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 90 of file AveragePool.cpp.

{
  const auto ceil_mode = getAttributeValue<int64_t>(onnx_node, "ceil_mode", 0);
  if (ceil_mode != 0)
    throw std::runtime_error("Not supported ceil_mode attribute!");
 
  convertAveragePoolV7(onnx_node, context);
}

References convertAveragePoolV7().

convertAveragePoolV7()

void mir_onnx::convertAveragePoolV7	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 81 of file AveragePool.cpp.

{
  const auto count_include_pad = getAttributeValue<int64_t>(onnx_node, "count_include_pad", 0);
  if (count_include_pad != 0)
    throw std::runtime_error("Not supported count_include_pad attribute!");
 
  convertAveragePoolV1(onnx_node, context);
}

References convertAveragePoolV1().

Referenced by convertAveragePoolV10().

convertBatchNormalizationV1()

void mir_onnx::convertBatchNormalizationV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 35 of file BatchNormalization.cpp.

{
  // consumed_inputs attribute not used
  convertBatchNormalizationV6(onnx_node, context);
}

References convertBatchNormalizationV6().

convertBatchNormalizationV6()

void mir_onnx::convertBatchNormalizationV6	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 41 of file BatchNormalization.cpp.

{
  const auto is_test = getAttributeValue<std::int64_t>(onnx_node, "is_test", 0);
  if (is_test == 0)
    throw std::runtime_error("Not supported is_test attribute!");
 
  convertBatchNormalizationV7(onnx_node, context);
}

References convertBatchNormalizationV7().

Referenced by convertBatchNormalizationV1().

convertBatchNormalizationV7()

void mir_onnx::convertBatchNormalizationV7	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 50 of file BatchNormalization.cpp.

{
  // spatial attribute used only for learning
 
  convertBatchNormalizationV9(onnx_node, context);
}

References convertBatchNormalizationV9().

Referenced by convertBatchNormalizationV6().

convertBatchNormalizationV9()

void mir_onnx::convertBatchNormalizationV9	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 57 of file BatchNormalization.cpp.

{
  // momentum attrribute used only for learning
 
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
 
  assert(inputs.size() == 5);
  auto input = inputs[0];
  auto scale = inputs[1];
  auto bias = inputs[2];
  auto mean = inputs[3];
  auto var = inputs[4];
 
  // 1e-05f is the default epsilon.
  const auto epsilon = getAttributeValue<float>(onnx_node, "epsilon", 1e-05f);
 
  // Y = (X - mean) * scale / sqrt(var + epsilon) + bias =
  //   = (X + C1) * C2 + bias
  // We need these to be constants since we are going to change them.
  // TODO Implement the formula using ops and let the optimizer constant-fold them.
  auto scale_op = dynamic_cast<mir::ops::ConstantOp *>(scale->getNode());
  auto mean_op = dynamic_cast<mir::ops::ConstantOp *>(mean->getNode());
  auto var_op = dynamic_cast<mir::ops::ConstantOp *>(var->getNode());
 
  if (scale_op == nullptr || mean_op == nullptr || var_op == nullptr)
    throw std::runtime_error(
      "BatchNormalization: only constant 'scale', 'mean' and 'variance' inputs are supported.");
 
  mir::Tensor<float> scale_accessor(scale_op->getValue());
  mir::Tensor<float> mean_accessor(mean_op->getValue());
  mir::Tensor<float> var_accessor(var_op->getValue());
 
  // C1 = -mean
  for (const auto &idx : mir::ShapeRange(mean_accessor.getShape()))
    mean_accessor.at(idx) *= -1;
 
  // C2 = scale / sqrt(var + epsilon)
  for (const auto &idx : mir::ShapeRange(scale_accessor.getShape()))
    scale_accessor.at(idx) /= std::sqrt(var_accessor.at(idx) + epsilon);
 
  assert(mean_accessor.getShape().rank() == 1);
  auto input_rank = input->getShape().rank();
  if (input_rank < 2)
    throw std::runtime_error("Inputs with shape rank < 2 are not supported for batchnorm");
 
  mir::Shape new_shape(std::vector<std::int32_t>(input_rank, 1));
 
  new_shape.dim(1) = mean_accessor.getShape().dim(0); // set channel dim
 
  auto reshaped_mean = createOp<mir::ops::ReshapeOp>(graph, mean, new_shape)->getOutput(0);
  auto reshaped_scale = createOp<mir::ops::ReshapeOp>(graph, scale, new_shape)->getOutput(0);
  auto reshaped_bias = createOp<mir::ops::ReshapeOp>(graph, bias, new_shape)->getOutput(0);
 
  // Y = (X + C1) * C2 + bias
  auto result = createOp<mir::ops::AddOp>(graph, input, reshaped_mean)->getOutput(0);
  result = createOp<mir::ops::MulOp>(graph, result, reshaped_scale)->getOutput(0);
  result = createOp<mir::ops::AddOp>(graph, result, reshaped_bias)->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References mir::Tensor< T >::at(), mir::Shape::dim(), mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), mir::Tensor< T >::getShape(), mir::Shape::rank(), and mir_onnx::ConverterContext::setNodeOutputs().

Referenced by convertBatchNormalizationV7().

convertConcatV1()

void mir_onnx::convertConcatV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 27 of file Concat.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
 
  const auto axis = getAttributeValue<int64_t>(onnx_node, "axis", 1);
 
  auto result = createOp<mir::ops::ConcatOp>(graph, inputs, axis)->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), and mir_onnx::ConverterContext::setNodeOutputs().

convertConcatV4()

void mir_onnx::convertConcatV4	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 39 of file Concat.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
  // From version 4 axis attribute is required
  auto attr = findAttribute(onnx_node, "axis");
  if (!attr)
    throw std::runtime_error("Attribute axis is required!");
  int32_t axis = attr->i();
 
  auto result = createOp<mir::ops::ConcatOp>(graph, inputs, axis)->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References findAttribute(), mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), and mir_onnx::ConverterContext::setNodeOutputs().

convertConstantV1()

void mir_onnx::convertConstantV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 28 of file Constant.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
 
  const auto onnx_tensor = getAttributeValue<onnx::TensorProto>(onnx_node, "value");
  auto mir_tensor = createTensor(&onnx_tensor);
 
  auto result = graph->create<mir::ops::ConstantOp>(mir_tensor)->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References createTensor(), mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), and mir_onnx::ConverterContext::setNodeOutputs().

Referenced by convertConstantV9().

convertConstantV11()

void mir_onnx::convertConstantV11	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 47 of file Constant.cpp.

{
  const auto *value_attr = findAttribute(onnx_node, "value");
  const auto *sparse_value_attr = findAttribute(onnx_node, "sparse_value");
  if (value_attr == nullptr && sparse_value_attr == nullptr)
    throw std::runtime_error("Not enough attributes in Constant operation!");
 
  if (value_attr != nullptr)
    return convertConstantV9(onnx_node, context);
 
  if (sparse_value_attr != nullptr)
    throw std::runtime_error("Not supported sparse_tensor in Constant operation!");
}

References convertConstantV9(), and findAttribute().

convertConstantV9()

void mir_onnx::convertConstantV9	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 41 of file Constant.cpp.

{
  // Since version 9 Constant operation support other types contained in tensor
  convertConstantV1(onnx_node, context);
}

References convertConstantV1().

Referenced by convertConstantV11().

convertConvTransposeV1()

void mir_onnx::convertConvTransposeV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 32 of file ConvTranspose.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
 
  assert(inputs.size() >= 2);
  auto input = inputs[0];
  auto kernel = inputs[1];
 
  const auto group = getAttributeValue<std::int64_t>(onnx_node, "group", 1);
  if (group != 1)
    throw std::runtime_error("ConvTranspose: attribute 'group' has unsupported value.");
 
  const auto &input_shape = input->getShape();
  if (input_shape.rank() != 4)
    throw std::runtime_error("ConvTranspose: only 2-D input is supported.");
 
  constexpr int num_spatial_dims = 2;
 
  const auto dilations =
    getAttributeValue(onnx_node, "dilations", std::vector<std::int32_t>(num_spatial_dims, 1));
  if (dilations.size() != num_spatial_dims)
    throw std::runtime_error("ConvTranspose: attribute 'dilations' has incorrect size.");
  if (!std::all_of(dilations.cbegin(), dilations.cend(), [](std::int32_t x) { return x == 1; }))
    throw std::runtime_error("ConvTranspose: attribute 'dilations' has unsupported value.");
 
  const auto strides =
    getAttributeValue(onnx_node, "strides", std::vector<std::int32_t>(num_spatial_dims, 1));
  if (strides.size() != num_spatial_dims)
    throw std::runtime_error("ConvTranspose: attribute 'strides' has incorrect size.");
 
  const auto output_padding =
    getAttributeValue(onnx_node, "output_padding", std::vector<std::int32_t>(num_spatial_dims, 0));
  if (output_padding.size() != num_spatial_dims)
    throw std::runtime_error("ConvTranspose: attribute 'output_padding' has incorrect size.");
  if (!std::all_of(output_padding.cbegin(), output_padding.cend(),
                   [](std::int32_t x) { return x == 0; }))
    throw std::runtime_error("ConvTranspose: attribute 'output_padding' has unsupported value.");
 
  // Assuming kernel has IOHW format.
  assert(kernel->getShape().rank() == 4);
  const auto kernel_size = getAttributeValue(
    onnx_node, "kernel_shape",
    std::vector<std::int32_t>{kernel->getShape().dim(2), kernel->getShape().dim(3)});
  if (kernel_size.size() != num_spatial_dims)
    throw std::runtime_error("ConvTranspose: attribute 'kernel_shape' has incorrect size.");
 
  // ONNX IOHW -> MIR HWOI
  std::vector<std::size_t> perm{2, 3, 1, 0}; // OIHW -> OHWI
  kernel = createOp<mir::ops::TransposeOp>(graph, kernel, perm)->getOutput(0);
 
  mir::Operation::Output *result;
  if (const auto *output_shape_attr = findAttribute(onnx_node, "output_shape"))
  {
    const auto output_size = getAttributeValue<std::vector<std::int32_t>>(*output_shape_attr);
    if (output_size.size() != num_spatial_dims)
      throw std::runtime_error("ConvTranspose: attribute 'output_shape' has incorrect size.");
    const mir::Shape output_shape{input_shape.dim(0), kernel->getShape().dim(2), output_size[0],
                                  output_size[1]};
    mir::Deconv2DOpAttributes attributes;
    attributes.strides = strides;
    attributes.data_format = mir::DataFormat::NCHW;
    attributes.padding_type = mir::ops::PaddingType::SameUpper;
    result =
      createOp<mir::ops::DeConv2DOp>(graph, input, kernel, attributes, output_shape)->getOutput(0);
  }
  else
  {
    // TODO This code was not tested.
    throw std::runtime_error(
      "ConvTranspose: absence of attribute 'output_shape' is not supported.");
    std::vector<std::int32_t> padding_before(num_spatial_dims, 0);
    std::vector<std::int32_t> padding_after(num_spatial_dims, 0);
    if (const auto *pads_attr = findAttribute(onnx_node, "pads"))
    {
      const auto pads = getAttributeValue<std::vector<std::int32_t>>(*pads_attr);
      if (pads.size() != num_spatial_dims * 2)
        throw std::runtime_error("ConvTranspose: attribute 'pads' has incorrect size.");
      padding_before.assign(pads.cbegin(), std::next(pads.cbegin(), num_spatial_dims));
      padding_after.assign(std::next(pads.cbegin(), num_spatial_dims), pads.cend());
    }
    else
    {
      const auto auto_pad = getAttributeValue<std::string>(onnx_node, "auto_pad", "NOTSET");
      inferAutoPadding(auto_pad, input_shape, dilations, strides, kernel_size, padding_before,
                       padding_after);
    }
    mir::Deconv2DOpAttributes attributes;
    attributes.strides = strides;
    attributes.padding_before = padding_before;
    attributes.padding_after = padding_after;
    attributes.data_format = mir::DataFormat::NCHW;
    result = createOp<mir::ops::DeConv2DOp>(graph, input, kernel, attributes)->getOutput(0);
  }
 
  if (inputs.size() > 2)
  {
    auto bias = inputs[2];
    bias = createOp<mir::ops::ReshapeOp>(graph, bias, mir::Shape{1, bias->getShape().dim(0), 1, 1})
             ->getOutput(0);
    result = createOp<mir::ops::AddOp>(graph, result, bias)->getOutput(0);
  }
 
  context->setNodeOutputs(onnx_node, {result});
}

References mir::Deconv2DOpAttributes::data_format, findAttribute(), getAttributeValue(), mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), inferAutoPadding(), mir::NCHW, output_shape, mir::Deconv2DOpAttributes::padding_after, mir::Deconv2DOpAttributes::padding_before, mir::Deconv2DOpAttributes::padding_type, mir::ops::SameUpper, mir_onnx::ConverterContext::setNodeOutputs(), and mir::Deconv2DOpAttributes::strides.

convertConvV1()

void mir_onnx::convertConvV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 30 of file Conv.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
 
  assert(inputs.size() >= 2);
  auto input = inputs[0];
  auto kernel = inputs[1];
 
  auto input_shape = input->getShape();
  bool conv1d = false;
  if (input_shape.rank() == 3)
  {
    input_shape = {input_shape.dim(0), input_shape.dim(1), input_shape.dim(2), 1};
    auto reshaped_input = createOp<mir::ops::ReshapeOp>(graph, input, input_shape);
    input = reshaped_input->getOutput(0);
    conv1d = true;
  }
  else
  {
    if (input_shape.rank() != 4)
      throw std::runtime_error{"Conv is unsupported for tensors with more than 4 dimentions"};
  }
 
  constexpr int num_spatial_dims = 2;
 
  std::vector<int32_t> dilations(num_spatial_dims, 1);
  if (const auto *dilations_attr = findAttribute(onnx_node, "dilations"))
  {
    dilations = getAttributeValue<std::vector<int32_t>>(*dilations_attr);
    if (conv1d)
      dilations.emplace_back(1);
  }
 
  if (dilations.size() != num_spatial_dims)
    throw std::runtime_error("Conv: attribute 'dilations' has incorrect size.");
  if (!std::all_of(dilations.cbegin(), dilations.cend(), [](std::int32_t x) { return x == 1; }))
    throw std::runtime_error("Conv: attribute 'dilations' has unsupported value.");
 
  std::vector<int32_t> strides(num_spatial_dims, 1);
  if (const auto *strides_attr = findAttribute(onnx_node, "strides"))
  {
    strides = getAttributeValue<std::vector<int32_t>>(*strides_attr);
    if (conv1d)
      strides.emplace_back(1);
  }
 
  if (strides.size() != num_spatial_dims)
    throw std::runtime_error("Conv: attribute 'strides' has incorrect size.");
 
  // Assuming kernel has OIHW format.
  if (conv1d)
  {
    auto kernel_shape = kernel->getShape();
    assert(kernel_shape.rank() == 3);
    kernel_shape = {kernel_shape.dim(0), kernel_shape.dim(1), kernel_shape.dim(2), 1};
    auto reshaped_kernel = createOp<mir::ops::ReshapeOp>(graph, kernel, kernel_shape);
    kernel = reshaped_kernel->getOutput(0);
  }
 
  std::vector<std::int32_t> kernel_shape{kernel->getShape().dim(2), kernel->getShape().dim(3)};
  if (const auto *k_shape_attr = findAttribute(onnx_node, "kernel_shape"))
  {
    kernel_shape = getAttributeValue<std::vector<std::int32_t>>(*k_shape_attr);
    if (conv1d)
      kernel_shape.emplace_back(1);
  }
 
  if (kernel_shape.size() != num_spatial_dims)
    throw std::runtime_error("Conv: attribute 'kernel_shape' has incorrect size.");
 
  std::vector<std::int32_t> padding_before(num_spatial_dims, 0);
  std::vector<std::int32_t> padding_after(num_spatial_dims, 0);
  if (const auto *pads_attr = findAttribute(onnx_node, "pads"))
  {
    auto pads = getAttributeValue<std::vector<std::int32_t>>(*pads_attr);
    if (conv1d)
    {
      pads.emplace_back(0);
      pads.emplace_back(0);
    }
 
    if (pads.size() != num_spatial_dims * 2)
      throw std::runtime_error("Conv: attribute 'pads' has incorrect size.");
    const auto fixed_pads = fixPads(input_shape, pads, strides, dilations, kernel_shape);
    padding_before.assign(fixed_pads.cbegin(), std::next(fixed_pads.cbegin(), num_spatial_dims));
    padding_after.assign(std::next(fixed_pads.cbegin(), num_spatial_dims), fixed_pads.cend());
  }
  else
  {
    const auto auto_pad = getAttributeValue<std::string>(onnx_node, "auto_pad", "NOTSET");
    inferAutoPadding(auto_pad, input_shape, dilations, strides, kernel_shape, padding_before,
                     padding_after);
  }
 
  const auto group = getAttributeValue<std::int64_t>(onnx_node, "group", 1);
 
  mir::Conv2DOpAttributes attributes;
  attributes.strides = strides;
  attributes.padding_before = padding_before;
  attributes.padding_after = padding_after;
  attributes.num_groups = group;
  attributes.data_format = mir::DataFormat::NCHW;
 
  std::vector<std::size_t> perm{0, 2, 3, 1}; // OIHW -> OHWI
  kernel = createOp<mir::ops::TransposeOp>(graph, kernel, perm)->getOutput(0);
  auto result = createOp<mir::ops::Conv2DOp>(graph, input, kernel, attributes)->getOutput(0);
 
  if (inputs.size() > 2)
  {
    auto bias = inputs[2];
    bias = createOp<mir::ops::ReshapeOp>(graph, bias, mir::Shape{1, bias->getShape().dim(0), 1, 1})
             ->getOutput(0);
    result = createOp<mir::ops::AddOp>(graph, result, bias)->getOutput(0);
  }
 
  if (conv1d)
  {
    auto output_shape = result->getShape();
    output_shape.resize(output_shape.rank() - 1);
    result = createOp<mir::ops::ReshapeOp>(graph, result, output_shape)->getOutput(0);
  }
 
  context->setNodeOutputs(onnx_node, {result});
}

References mir::Conv2DOpAttributes::data_format, findAttribute(), fixPads(), mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), inferAutoPadding(), mir::NCHW, mir::Conv2DOpAttributes::num_groups, output_shape, mir::Conv2DOpAttributes::padding_after, mir::Conv2DOpAttributes::padding_before, luci_interpreter::RuntimeShape::resize(), mir_onnx::ConverterContext::setNodeOutputs(), and mir::Conv2DOpAttributes::strides.

convertDivV7()

void mir_onnx::convertDivV7	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 27 of file Div.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
 
  mir::Graph *graph = context->getGraph();
 
  auto result = createOp<mir::ops::DivOp>(graph, inputs[0], inputs[1])->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), and mir_onnx::ConverterContext::setNodeOutputs().

convertDropoutV1()

void mir_onnx::convertDropoutV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 24 of file Dropout.cpp.

{
  // consumed_inputs attribute not used
  convertDropoutV6(onnx_node, context);
}

References convertDropoutV6().

convertDropoutV10()

void mir_onnx::convertDropoutV10	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 44 of file Dropout.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
 
  // ratio attribute not used
 
  // This is a no-op in inference mode.
  context->setNodeOutputs(onnx_node, {inputs[0]});
}

References mir_onnx::ConverterContext::getNodeInputs(), and mir_onnx::ConverterContext::setNodeOutputs().

Referenced by convertDropoutV6(), and convertDropoutV7().

convertDropoutV6()

void mir_onnx::convertDropoutV6	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 30 of file Dropout.cpp.

{
  const auto is_test = getAttributeValue<std::int64_t>(onnx_node, "is_test", 0);
  if (is_test == 0)
    throw std::runtime_error("Not supported is_test attribute!");
 
  convertDropoutV10(onnx_node, context);
}

References convertDropoutV10().

Referenced by convertDropoutV1().

convertDropoutV7()

void mir_onnx::convertDropoutV7	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 39 of file Dropout.cpp.

{
  convertDropoutV10(onnx_node, context);
}

References convertDropoutV10().

convertEqualV11()

void mir_onnx::convertEqualV11	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 27 of file Equal.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
 
  auto result = createOp<mir::ops::EqualOp>(graph, inputs[0], inputs[1])->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), and mir_onnx::ConverterContext::setNodeOutputs().

Referenced by convertEqualV7().

convertEqualV7()

void mir_onnx::convertEqualV7	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 37 of file Equal.cpp.

{
  // Other type constraints
  convertEqualV11(onnx_node, context);
}

References convertEqualV11().

convertExpandV8()

void mir_onnx::convertExpandV8	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 26 of file Expand.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
 
  if (inputs[1]->getNode()->getType() != mir::Operation::Type::constant)
  {
    throw std::runtime_error{"Expand with non-constant input shape is not supported"};
  }
 
  auto target_shape = constantToShape(static_cast<mir::ops::ConstantOp *>(inputs[1]->getNode()));
 
  auto *result = createOp<mir::ops::BroadcastOp>(graph, inputs[0], target_shape)->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References constantToShape(), mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), getType(), and mir_onnx::ConverterContext::setNodeOutputs().

convertFlattenV1()

void mir_onnx::convertFlattenV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 27 of file Flatten.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
 
  const auto axis = getAttributeValue<int64_t>(onnx_node, "axis", 1);
  assert(inputs.size() == 1);
  const auto &in_shape = inputs[0]->getShape();
  assert(axis <= in_shape.rank()); // A tensor of rank >= axis
  int32_t first_dim = 1, second_dim = 1;
  int32_t dim = 0;
 
  for (; dim < axis; dim++)
    first_dim *= in_shape.dim(dim);
 
  for (; dim < in_shape.rank(); dim++)
    second_dim *= in_shape.dim(dim);
 
  mir::Shape out_shape({first_dim, second_dim}); // Output 2D tensor
 
  auto result = createOp<mir::ops::ReshapeOp>(graph, inputs[0], out_shape)->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), and mir_onnx::ConverterContext::setNodeOutputs().

Referenced by convertFlattenV9().

convertFlattenV9()

void mir_onnx::convertFlattenV9	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 52 of file Flatten.cpp.

{
  // Other type constraints
  convertFlattenV1(onnx_node, context);
}

References convertFlattenV1().

convertGatherV1()

void mir_onnx::convertGatherV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 27 of file Gather.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
 
  // 0 is the default axis number.
  const auto axis = getAttributeValue<std::int64_t>(onnx_node, "axis", 0);
 
  auto result = createOp<mir::ops::GatherOp>(graph, inputs[0], inputs[1], axis)->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), and mir_onnx::ConverterContext::setNodeOutputs().

convertGemmV1()

void mir_onnx::convertGemmV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 91 of file Gemm.cpp.

{
  return convertGemm(onnx_node, context);
}

convertGemmV11()

void mir_onnx::convertGemmV11	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 114 of file Gemm.cpp.

{
  // This operation differs from V11: input C is optional
  return convertGemm(onnx_node, context);
}

convertGemmV6()

void mir_onnx::convertGemmV6	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 96 of file Gemm.cpp.

{
  // This version differs from V1: in description of C input (redundant text "can be inplace.")
  return convertGemm(onnx_node, context);
}

convertGemmV7()

void mir_onnx::convertGemmV7	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 102 of file Gemm.cpp.

{
  // This version differs from V6: removed "broadcast" atribute
  return convertGemm(onnx_node, context);
}

convertGemmV9()

void mir_onnx::convertGemmV9	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 108 of file Gemm.cpp.

{
  // This version differs from V7: added more supported types
  return convertGemm(onnx_node, context);
}

convertGlobalAveragePoolV2()

void mir_onnx::convertGlobalAveragePoolV2	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 26 of file GlobalAveragePool.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
 
  assert(inputs.size() == 1);
  auto input = inputs[0];
 
  const auto &input_shape = input->getShape();
  if (input_shape.rank() != 4)
    throw std::runtime_error("GlobalAveragePool: only 2-D input is supported.");
 
  // GlobalAveragePool is equivalent to AveragePool with kernel size equal
  // to the spatial dimension of input tensor.
  const std::vector<std::int32_t> window_size{input->getShape().dim(2), input->getShape().dim(3)};
  mir::AvgPool2DOpAttributes attributes;
  attributes.window = window_size;
  attributes.data_format = mir::DataFormat::NCHW;
 
  auto result = createOp<mir::ops::AvgPool2DOp>(graph, input, attributes)->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References mir::AvgPool2DOpAttributes::data_format, mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), mir::NCHW, mir_onnx::ConverterContext::setNodeOutputs(), and mir::AvgPool2DOpAttributes::window.

convertGreaterV7()

void mir_onnx::convertGreaterV7	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 37 of file Greater.cpp.

{
  convertGreaterVGeneric(onnx_node, context);
}

convertGreaterV9()

void mir_onnx::convertGreaterV9	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 42 of file Greater.cpp.

{
  convertGreaterVGeneric(onnx_node, context);
}

convertIdentityV1()

void mir_onnx::convertIdentityV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 22 of file Identity.cpp.

{
  const auto inputs = context->getNodeInputs(onnx_node);
  assert(inputs.size() == 1);
 
  context->setNodeOutputs(onnx_node, {inputs[0]});
}

References mir_onnx::ConverterContext::getNodeInputs(), and mir_onnx::ConverterContext::setNodeOutputs().

convertLessV7()

void mir_onnx::convertLessV7	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 37 of file Less.cpp.

{
  convertLessGeneric(onnx_node, context);
}

convertLessV9()

void mir_onnx::convertLessV9	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 42 of file Less.cpp.

{
  convertLessGeneric(onnx_node, context);
}

convertMatMulV1()

void mir_onnx::convertMatMulV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 26 of file MatMul.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
 
  assert(inputs.size() == 2);
  auto A = inputs[0];
  auto B = inputs[1];
  // MatMul multiply N-dimentional matrix
  // FullyConnected layer multiply only 2-dimentional matrix
  if (A->getShape().rank() != 2 || B->getShape().rank() != 2)
    throw std::runtime_error("Supported only 2D matrix multiplying!");
  // Calculate A * B.
  auto result = createOp<mir::ops::FullyConnectedOp>(graph, A, B)->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), and mir_onnx::ConverterContext::setNodeOutputs().

Referenced by convertMatMulV9().

convertMatMulV9()

void mir_onnx::convertMatMulV9	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 44 of file MatMul.cpp.

{
  // Other type constraints
  convertMatMulV1(onnx_node, context);
}

References convertMatMulV1().

convertMaxPoolV1()

void mir_onnx::convertMaxPoolV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 28 of file MaxPool.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
 
  assert(inputs.size() == 1);
  auto input = inputs[0];
 
  const auto &input_shape = input->getShape();
  if (input_shape.rank() != 4)
    throw std::runtime_error("MaxPool: only 2-D input is supported.");
 
  constexpr int num_spatial_dims = 2;
 
  const auto strides =
    getAttributeValue(onnx_node, "strides", std::vector<std::int32_t>(num_spatial_dims, 1));
  if (strides.size() != num_spatial_dims)
    throw std::runtime_error("MaxPool: attribute 'strides' has incorrect size.");
 
  const auto kernel_shape = getAttributeValue<std::vector<std::int32_t>>(onnx_node, "kernel_shape");
  if (kernel_shape.size() != num_spatial_dims)
    throw std::runtime_error("MaxPool: attribute 'kernel_shape' has incorrect size.");
 
  std::vector<std::int32_t> padding_before;
  std::vector<std::int32_t> padding_after;
  if (const auto *pads_attr = findAttribute(onnx_node, "pads"))
  {
    const auto pads = getAttributeValue<std::vector<std::int32_t>>(*pads_attr);
    if (pads.size() != num_spatial_dims * 2)
      throw std::runtime_error("MaxPool: attribute 'pads' has incorrect size.");
    padding_before.assign(pads.cbegin(), std::next(pads.cbegin(), num_spatial_dims));
    padding_after.assign(std::next(pads.cbegin(), num_spatial_dims), pads.cend());
  }
  else
  {
    const auto auto_pad = getAttributeValue<std::string>(onnx_node, "auto_pad", "NOTSET");
    const std::vector<std::int32_t> dilations(num_spatial_dims, 1);
    inferAutoPadding(auto_pad, input_shape, dilations, strides, kernel_shape, padding_before,
                     padding_after);
  }
 
  mir::MaxPool2DOpAttributes attributes;
  attributes.window = kernel_shape;
  attributes.strides = strides;
  attributes.padding_before = padding_before;
  attributes.padding_after = padding_after;
  attributes.data_format = mir::DataFormat::NCHW;
  auto result = createOp<mir::ops::MaxPool2DOp>(graph, input, attributes)->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References mir::MaxPool2DOpAttributes::data_format, findAttribute(), getAttributeValue(), mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), inferAutoPadding(), mir::NCHW, mir::MaxPool2DOpAttributes::padding_after, mir::MaxPool2DOpAttributes::padding_before, mir_onnx::ConverterContext::setNodeOutputs(), mir::MaxPool2DOpAttributes::strides, and mir::MaxPool2DOpAttributes::window.

Referenced by convertMaxPoolV8().

convertMaxPoolV10()

void mir_onnx::convertMaxPoolV10	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 89 of file MaxPool.cpp.

{
  const auto ceil_mode = getAttributeValue<int64_t>(onnx_node, "ceil_mode", 0);
  if (ceil_mode != 0)
    throw std::runtime_error("Not supported ceil_mode attribute!");
 
  const auto *dilations = findAttribute(onnx_node, "dilations");
  if (dilations != nullptr)
  {
    // check default (=1) dilations on each spatial axis
    for (auto index = 0; index < dilations->ints_size(); index++)
      if (dilations->ints(index) != 1)
        throw std::runtime_error("Not supported dilations in MaxPool operation!");
  }
 
  convertMaxPoolV8(onnx_node, context);
}

References convertMaxPoolV8(), and findAttribute().

convertMaxPoolV8()

void mir_onnx::convertMaxPoolV8	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 80 of file MaxPool.cpp.

{
  const auto storage_order = getAttributeValue<int64_t>(onnx_node, "storage_order", 0);
  if (storage_order != 0)
    throw std::runtime_error("Not supported storage order attribute!");
 
  convertMaxPoolV1(onnx_node, context);
}

References convertMaxPoolV1().

Referenced by convertMaxPoolV10().

convertMaxV1()

void mir_onnx::convertMaxV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 39 of file Max.cpp.

{
  convertMaxGeneric(onnx_node, context);
}

convertMaxV6()

void mir_onnx::convertMaxV6	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 44 of file Max.cpp.

{
  convertMaxGeneric(onnx_node, context);
}

convertMaxV8()

void mir_onnx::convertMaxV8	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 49 of file Max.cpp.

{
  convertMaxGeneric(onnx_node, context);
}

convertMulV7()

void mir_onnx::convertMulV7	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 26 of file Mul.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
  auto result = createOp<mir::ops::MulOp>(graph, inputs[0], inputs[1])->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), and mir_onnx::ConverterContext::setNodeOutputs().

convertPadAttrName()

void mir_onnx::convertPadAttrName	(	const std::string &	pad_attr_name,
		const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 27 of file Pad.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
 
  assert(inputs.size() == 1);
  auto input = inputs[0];
 
  // 0.0f is the default value to be filled into padded cells.
  const auto value = getAttributeValue<float>(onnx_node, "value", 0.0f);
  const auto pads = getAttributeValue<std::vector<std::int64_t>>(onnx_node, pad_attr_name);
  // "constant" is the default mode.
  const auto mode = getAttributeValue<std::string>(onnx_node, "mode", "constant");
  if (mode != "constant")
    throw std::runtime_error("Not supported Pad mode attribute!");
 
  const int num_dims = input->getShape().rank();
  assert(static_cast<int>(pads.size()) == num_dims * 2);
  mir::PadOpAttributes attributes(num_dims);
  for (int i = 0; i < num_dims; i++)
  {
    attributes.padding_before[i] = pads[i];
    attributes.padding_after[i] = pads[num_dims + i];
  }
 
  attributes.padding_value = value;
 
  auto result = createOp<mir::ops::PadOp>(graph, input, attributes)->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), mir::PadOpAttributes::padding_after, mir::PadOpAttributes::padding_before, mir::PadOpAttributes::padding_value, and mir_onnx::ConverterContext::setNodeOutputs().

Referenced by convertPadV1(), and convertPadV2().

convertPadV1()

void mir_onnx::convertPadV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 60 of file Pad.cpp.

{
  convertPadAttrName("paddings", onnx_node, context);
}

References convertPadAttrName().

convertPadV2()

void mir_onnx::convertPadV2	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 65 of file Pad.cpp.

{
  convertPadAttrName("pads", onnx_node, context);
}

References convertPadAttrName().

convertReciprocalV1()

void mir_onnx::convertReciprocalV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 43 of file Reciprocal.cpp.

{
  convertReciprocal(onnx_node, context);
}

convertReciprocalV6()

void mir_onnx::convertReciprocalV6	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 48 of file Reciprocal.cpp.

{
  convertReciprocal(onnx_node, context);
}

convertReduceMeanV1()

void mir_onnx::convertReduceMeanV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 29 of file ReduceMean.cpp.

{
  const auto inputs = context->getNodeInputs(onnx_node);
  assert(inputs.size() == 1);
 
  const auto axes = getAttributeValue<std::vector<std::int64_t>>(onnx_node, "axes");
  const auto keepdims = getAttributeValue<int64_t>(onnx_node, "keepdims", 1);
 
  std::vector<int32_t> reduce_dims;
  if (axes.empty())
  { // reduce over all dimensions
    reduce_dims.resize(inputs[0]->getShape().rank());
    std::iota(reduce_dims.begin(), reduce_dims.end(), 0);
  }
  else
  {
    auto rank = inputs[0]->getShape().rank();
 
    std::transform(axes.begin(), axes.end(), std::back_inserter(reduce_dims),
                   [rank](int64_t axis) { return axis < 0 ? axis + rank : axis; });
  }
  // Keep the reduced dimension or not, default 1 mean keep reduced dimension.
  bool keep_dims = static_cast<bool>(keepdims);
 
  mir::Graph *graph = context->getGraph();
  auto result =
    createOp<mir::ops::ReduceMeanOp>(graph, inputs[0], reduce_dims, keep_dims)->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), and mir_onnx::ConverterContext::setNodeOutputs().

convertReluV1()

void mir_onnx::convertReluV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 36 of file Relu.cpp.

{
  convertRelu(onnx_node, context);
}

convertReluV6()

void mir_onnx::convertReluV6	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 41 of file Relu.cpp.

{
  convertRelu(onnx_node, context);
}

convertReshapeV1()

void mir_onnx::convertReshapeV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 31 of file Reshape.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
  // consumed_inputs attribute not used
  const auto *shape_attr = findAttribute(onnx_node, "shape");
  if (shape_attr && shape_attr->ints_size() > 0)
  {
    mir::Shape in_shape = inputs[0]->getShape();
    mir::Shape out_shape(shape_attr->ints_size());
    for (int32_t index = 0; index < out_shape.rank(); index++)
    {
      const auto dim_value = shape_attr->ints(index);
      if (dim_value == 0)
        out_shape.dim(index) = in_shape.dim(index);
      else
        out_shape.dim(index) = dim_value;
    }
 
    auto result = createOp<mir::ops::ReshapeOp>(graph, inputs[0], out_shape)->getOutput(0);
 
    context->setNodeOutputs(onnx_node, {result});
  }
  else // dimension value is unchanged
  {
    context->setNodeOutputs(onnx_node, {inputs[0]});
  }
}

References mir::Shape::dim(), findAttribute(), mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), mir::Shape::rank(), and mir_onnx::ConverterContext::setNodeOutputs().

convertReshapeV5()

void mir_onnx::convertReshapeV5	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 60 of file Reshape.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
  // The original shape
  const auto &in_shape = inputs[0]->getShape();
 
  // Input tensor describing the new shape
  auto *op = dynamic_cast<mir::ops::ConstantOp *>(inputs[1]->getNode());
  assert(op && "We support only constant shape input");
  auto shape_tensor = op->getValue();
  mir::Shape shape_tensor_shape = (shape_tensor).getShape();
  assert(shape_tensor_shape.rank() == 1);
  // The rank of the new shape
  auto cnt = shape_tensor_shape.numElements();
  // The vector to build the new shape from
  std::vector<int32_t> shape_vector(cnt);
  mir::ShapeRange out_range(shape_tensor_shape);
  mir::Tensor<int64_t> tensor_accessor(shape_tensor);
 
  int i = 0;
  for (auto idx : out_range)
  {
    if (tensor_accessor.at(idx) == 0)
      shape_vector[i] = in_shape.dim(i);
    else if (tensor_accessor.at(idx) == -1)
      shape_vector[i] = mir::Shape::autoDim;
    else
      shape_vector[i] = tensor_accessor.at(idx);
    i++;
  }
  auto out_shape = mir::Shape(shape_vector);
  auto result = createOp<mir::ops::ReshapeOp>(graph, inputs[0], out_shape)->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References mir::Tensor< T >::at(), mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), mir::Shape::numElements(), mir::Shape::rank(), and mir_onnx::ConverterContext::setNodeOutputs().

convertShapeV1()

void mir_onnx::convertShapeV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 28 of file Shape.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
  const auto &input_shape = inputs[0]->getShape();
  int size = input_shape.rank();
  mir::Shape output_shape{size};
  std::vector<int64_t> data(static_cast<std::size_t>(size));
  for (int i = 0; i < size; i++)
  {
    data[i] = input_shape.dim(i);
  }
  mir::TensorVariant tensor({mir::DataType::INT64, output_shape}, data.data());
  auto result = createOp<mir::ops::ConstantOp>(graph, tensor)->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), output_shape, mir_onnx::ConverterContext::setNodeOutputs(), and size.

convertSigmoidV1()

void mir_onnx::convertSigmoidV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 36 of file Sigmoid.cpp.

{
  convertSigmoid(onnx_node, context);
}

convertSigmoidV6()

void mir_onnx::convertSigmoidV6	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 41 of file Sigmoid.cpp.

{
  convertSigmoid(onnx_node, context);
}

convertSoftmaxV1()

void mir_onnx::convertSoftmaxV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 27 of file Softmax.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
 
  // 1 is the default axis number.
  const auto axis = getAttributeValue<std::int64_t>(onnx_node, "axis", 1);
 
  auto result = createOp<mir::ops::SoftmaxOp>(graph, inputs[0], axis)->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), and mir_onnx::ConverterContext::setNodeOutputs().

convertSqrtV1()

void mir_onnx::convertSqrtV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 36 of file Sqrt.cpp.

{
  convertSqrt(onnx_node, context);
}

convertSqrtV6()

void mir_onnx::convertSqrtV6	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 41 of file Sqrt.cpp.

{
  convertSqrt(onnx_node, context);
}

convertSubV1()

void mir_onnx::convertSubV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 27 of file Sub.cpp.

{
  // consumed_inputs attribute not used
  convertSubV6(onnx_node, context);
}

References convertSubV6().

convertSubV6()

void mir_onnx::convertSubV6	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 33 of file Sub.cpp.

{
  // broadcast attribute not used
  const auto *axis = findAttribute(onnx_node, "axis");
  if (axis != nullptr)
    throw std::runtime_error("Not supported axis attribute in Sub operation!");
 
  convertSubV7(onnx_node, context);
}

References convertSubV7(), and findAttribute().

Referenced by convertSubV1().

convertSubV7()

void mir_onnx::convertSubV7	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 43 of file Sub.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
 
  auto result = createOp<mir::ops::SubOp>(graph, inputs[0], inputs[1])->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), and mir_onnx::ConverterContext::setNodeOutputs().

Referenced by convertSubV6().

convertSumV8()

void mir_onnx::convertSumV8	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 26 of file Sum.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
  assert(inputs.size() >= 1);
 
  auto result = inputs[0];
  for (int i = 1; i < static_cast<int>(inputs.size()); ++i)
  {
    result = createOp<mir::ops::AddOp>(graph, result, inputs[i])->getOutput(0);
  }
 
  context->setNodeOutputs(onnx_node, {result});
}

References mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), and mir_onnx::ConverterContext::setNodeOutputs().

convertTanhV1()

void mir_onnx::convertTanhV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 36 of file Tanh.cpp.

{
  convertTanh(onnx_node, context);
}

convertTanhV6()

void mir_onnx::convertTanhV6	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 41 of file Tanh.cpp.

{
  convertTanh(onnx_node, context);
}

convertTransposeV1()

void mir_onnx::convertTransposeV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 28 of file Transpose.cpp.

{
  const auto inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
 
  assert(inputs.size() == 1);
  auto input = inputs[0];
 
  const int num_axes = input->getShape().rank();
  std::vector<std::size_t> axis_order(num_axes);
  const auto *perm_attr = findAttribute(onnx_node, "perm");
 
  if (perm_attr == nullptr)
  {
    // Reverse the dimensions.
    std::iota(axis_order.rbegin(), axis_order.rend(), 0);
  }
  else
  {
    const auto perm = getAttributeValue<std::vector<std::int64_t>>(*perm_attr);
    assert(static_cast<int>(perm.size()) == num_axes);
    std::copy(perm.cbegin(), perm.cend(), axis_order.begin());
  }
 
  auto result = createOp<mir::ops::TransposeOp>(graph, input, axis_order)->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References findAttribute(), mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), and mir_onnx::ConverterContext::setNodeOutputs().

convertUnsqueezeV1()

void mir_onnx::convertUnsqueezeV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 27 of file Unsqueeze.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
  const auto axes = getAttributeValue<std::vector<std::int64_t>>(onnx_node, "axes");
  assert(!axes.empty());
  const mir::Shape &input_shape = inputs[0]->getShape();
  const int out_rank = input_shape.rank() + static_cast<int>(axes.size());
  mir::Shape out_shape(out_rank);
  auto ints_iterator = axes.cbegin();
  int j = 0;
  for (int i = 0; i < out_rank; i++)
  {
    if (ints_iterator < axes.cend() && i == *ints_iterator)
    {
      out_shape.dim(i) = 1;
      ints_iterator++;
    }
    else
    {
      out_shape.dim(i) = input_shape.dim(j);
      j++;
    }
  }
  auto result = createOp<mir::ops::ReshapeOp>(graph, inputs[0], out_shape)->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References mir::Shape::dim(), mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), mir::Shape::rank(), and mir_onnx::ConverterContext::setNodeOutputs().

convertUpsampleV1()

void mir_onnx::convertUpsampleV1	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 32 of file Upsample.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
 
  // "nearest" is the default mode.
  std::string mode = getAttributeValue<std::string>(onnx_node, "mode", "nearest");
  assert(mode == "nearest" && "Unsupported upscale mode!");
 
  const float h_scale = getAttributeValue<float>(onnx_node, "height_scale", 0.0f); // required
  const float w_scale = getAttributeValue<float>(onnx_node, "width_scale", 0.0f);  // required
  if (h_scale < 1.0f || w_scale < 1.0f)
    throw std::runtime_error("Wrong scale attributes!");
 
  assert(inputs[0]->getShape().rank() == 4 && "Only rank 4 is supported");
  std::vector<float> scales_vector(4);
  // NCHW
  scales_vector.at(0) = 1.0f;
  scales_vector.at(1) = 1.0f;
  scales_vector.at(2) = h_scale;
  scales_vector.at(3) = w_scale;
 
  auto result =
    createOp<mir::ops::ResizeOp>(graph, inputs[0],
                                 mir::ops::ResizeOp::ResizeMethod::nearestNeighbor, scales_vector)
      ->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), mir::ops::ResizeOp::nearestNeighbor, and mir_onnx::ConverterContext::setNodeOutputs().

convertUpsampleV7()

void mir_onnx::convertUpsampleV7	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 62 of file Upsample.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
 
  // "nearest" is the default mode.
  std::string mode = getAttributeValue<std::string>(onnx_node, "mode", "nearest");
  assert(mode == "nearest" && "Unsupported upscale mode!");
 
  const auto *scales_attr = findAttribute(onnx_node, "scales");
  if (!scales_attr)
    throw std::runtime_error("Not enough required scales attribute!");
 
  if (scales_attr->floats_size() != inputs[0]->getShape().rank())
    throw std::runtime_error(
      "Number of elements of scales should be the same as the rank of input");
 
  assert(inputs[0]->getShape().rank() == 4 && "Only rank 4 is supported");
  std::vector<float> scales_vector(4);
  // NCHW
  scales_vector.at(0) = scales_attr->floats(0);
  scales_vector.at(1) = scales_attr->floats(1);
  scales_vector.at(2) = scales_attr->floats(2);
  scales_vector.at(3) = scales_attr->floats(3);
 
  auto result =
    createOp<mir::ops::ResizeOp>(graph, inputs[0],
                                 mir::ops::ResizeOp::ResizeMethod::nearestNeighbor, scales_vector)
      ->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References findAttribute(), mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), mir::ops::ResizeOp::nearestNeighbor, and mir_onnx::ConverterContext::setNodeOutputs().

convertUpsampleV9()

void mir_onnx::convertUpsampleV9	(	const onnx::NodeProto &	onnx_node,
		ConverterContext *	context
	)

Definition at line 95 of file Upsample.cpp.

{
  std::vector<mir::Operation::Output *> inputs = context->getNodeInputs(onnx_node);
  mir::Graph *graph = context->getGraph();
 
  // "nearest" is the default mode.
  const auto mode = getAttributeValue<std::string>(onnx_node, "mode", "nearest");
  if (mode != "nearest")
    throw std::runtime_error("Upsample: only 'nearest' mode is supported.");
 
  // relies on attributes being lifted to constants (ONNX optimization pass)
  assert(inputs.size() > 1);
  auto *scales = dynamic_cast<mir::ops::ConstantOp *>(inputs[1]->getNode());
  assert(scales && "Weights could be a constant tensor only");
  auto scales_tensor = mir::Tensor<float>(scales->getValue());
  int rank = inputs[0]->getShape().rank();
  if (rank != 4)
    throw std::runtime_error("Upsample: only 4-D input is supported.");
  assert(scales_tensor.getShape().numElements() == rank &&
         "The number of elements of 'scales' should be the same as the rank of input 'X'");
  std::vector<float> scales_vector(rank);
  for (int i = 0; i < scales_tensor.getShape().numElements(); i++)
    scales_vector[i] = scales_tensor.atOffset(i);
 
  auto result =
    createOp<mir::ops::ResizeOp>(graph, inputs[0],
                                 mir::ops::ResizeOp::ResizeMethod::nearestNeighbor, scales_vector)
      ->getOutput(0);
 
  context->setNodeOutputs(onnx_node, {result});
}

References mir_onnx::ConverterContext::getGraph(), mir_onnx::ConverterContext::getNodeInputs(), mir::ops::ResizeOp::nearestNeighbor, and mir_onnx::ConverterContext::setNodeOutputs().

createOp()

template<typename OpType , typename... Types>

mir::Operation * mir_onnx::createOp	(	mir::Graph *	graph,
		Types &&...	args
	)

Definition at line 41 of file ONNXHelpers.h.

{
  auto op = graph->create<OpType>(std::forward<Types>(args)...);
  op = foldConstants(graph, op);
  return op;
}

References foldConstants().

createTensor()

mir::TensorVariant mir_onnx::createTensor

(

const onnx::TensorProto *

tensor

)

Definition at line 106 of file ONNXHelpers.cpp.

{
  mir::DataType type;
  const void *src_data;
  mir::Shape shape(tensor->dims_size());
  for (int i = 0; i < tensor->dims_size(); ++i)
  {
    shape.dim(i) = tensor->dims(i);
  }
 
  if (tensor->float_data_size() != 0)
  {
    assert(tensor->data_type() == onnx::TensorProto::FLOAT);
    type = mir::DataType::FLOAT32;
    src_data = tensor->float_data().data();
  }
  else if (tensor->double_data_size() != 0)
  {
    assert(tensor->data_type() == onnx::TensorProto::DOUBLE);
    type = mir::DataType::FLOAT64;
    src_data = tensor->double_data().data();
  }
  else if (tensor->int32_data_size() != 0)
  {
    assert(tensor->data_type() == onnx::TensorProto::INT32);
    type = mir::DataType::INT32;
    src_data = tensor->int32_data().data();
  }
  else if (tensor->int64_data_size() != 0)
  {
    assert(tensor->data_type() == onnx::TensorProto::INT64);
    type = mir::DataType::INT64;
    src_data = tensor->int64_data().data();
  }
  else if (tensor->has_raw_data())
  {
    type = onnxDataTypeToMirDataType((onnx::TensorProto_DataType)tensor->data_type());
    src_data = tensor->raw_data().data();
  }
  else
  {
    throw std::runtime_error("Invalid data in Proto file, investigate");
  }
 
  return mir::TensorVariant({type, shape}, src_data);
}

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

Referenced by convertConstantV1().

findAttribute()

const onnx::AttributeProto * mir_onnx::findAttribute ( const onnx::NodeProto &  node, const std::string &  name  )

inline

Definition at line 74 of file AttributeHelpers.h.

{
  const auto &attributes = node.attribute();
  const auto it = std::find_if(
    attributes.cbegin(), attributes.cend(),
    [&name](const onnx::AttributeProto &attribute) { return attribute.name() == name; });
  if (it == attributes.cend())
    return nullptr;
  return &*it;
}

Referenced by convertAddV6(), convertAveragePoolV1(), convertConcatV4(), convertConstantV11(), convertConvTransposeV1(), convertConvV1(), convertMaxPoolV1(), convertMaxPoolV10(), convertReshapeV1(), convertSubV6(), convertTransposeV1(), convertUpsampleV7(), getAttributeValue(), and getAttributeValue().

fixPads()

std::vector< std::int32_t > mir_onnx::fixPads	(	const mir::Shape &	input_shape,
		const std::vector< std::int32_t > &	pads,
		const std::vector< std::int32_t > &	strides,
		const std::vector< std::int32_t > &	dilation,
		const std::vector< std::int32_t > &	kernel_shape
	)

Definition at line 74 of file ConvPoolHelpers.cpp.

{
  assert(pads.size() % 2 == 0);
  int spatial_dimensions = pads.size() / 2;
  std::vector<std::int32_t> fixed_pads(pads);
  for (int i = 0; i < spatial_dimensions; ++i)
  {
    auto effective_window_dim = (kernel_shape[i] - 1) * dilation[i] + 1;
    auto effective_input_dim = input_shape.dim(i + 2) + pads[i] + pads[i + spatial_dimensions];
    // Computing number of "redundant" elements at the end of input dimension
    // for example we have effective_input_dim == 8, effective_window)dim == 3 and stride == 2:
    // [1][2][3][4][5][6][7][8]  - input
    //  *  *  *  .  .  .  .      - first kernel application
    //  .  .  *  *  *  .  .      - second kernel application
    //  .  .  .  .  *  *  *      - third kernel application
    // element 8 is unused (remainder should be 1)
    //
    // glossary:
    // i - effective input size
    // w - effective window size
    // s - stride
    // n - number of kernel applications (3 in example)
    //
    // i = s * (n-1) + w + r
    // r = i - w - s * (n-1)
    // n - is the maximum number of windows we can fit into input, so this formula is equal to
    // r = (i - w) % s
    auto remainder = (effective_input_dim - effective_window_dim) % strides[i];
 
    // remove redundant pad, but no more than there are padding
    fixed_pads[i + spatial_dimensions] -= std::min(remainder, pads[i + spatial_dimensions]);
  }
  return fixed_pads;
}

References mir::Shape::dim().

Referenced by convertConvV1().

foldConstants()

mir::Operation * mir_onnx::foldConstants	(	mir::Graph *	graph,
		mir::Operation *	op
	)

Definition at line 153 of file ONNXHelpers.cpp.

{
  if (op->getType() == mir::Operation::Type::constant ||
      op->getType() == mir::Operation::Type::input || op->getType() == mir::Operation::Type::output)
  {
    // don't fold input, output and constant nodes
    return op;
  }
 
  if (op->getNumOutputs() != 1)
  {
    // this operation either have more than 1 output or none at all
    return op;
  }
 
  bool is_foldable =
    std::all_of(op->getInputs().begin(), op->getInputs().end(), [](mir::Operation::Output *out) {
      return out->getNode()->getType() == mir::Operation::Type::constant;
    });
 
  if (!is_foldable)
    return op;
 
  mir_interpreter::MIRInterpreter interpreter;
  for (mir::Operation::Output *out : op->getInputs())
  {
    auto *constant = static_cast<mir::ops::ConstantOp *>(out->getNode());
    interpreter.setTensor(out, constant->getValue());
  }
  op->accept(&interpreter);
  const mir::TensorVariant &output = interpreter.getTensor(op->getOutput(0));
 
  return graph->create<mir::ops::ConstantOp>(output);
}

References mir::Operation::accept(), mir::Operation::getInputs(), mir::Operation::Output::getNode(), mir::Operation::getNumOutputs(), mir::Operation::getOutput(), and mir::Operation::getType().

Referenced by createOp().

getAttributeValue() [1/9]

template<>

float mir_onnx::getAttributeValue ( const onnx::AttributeProto &  attribute )

inline

Definition at line 35 of file AttributeHelpers.h.

{
  assert(attribute.type() == onnx::AttributeProto::FLOAT);
  return attribute.f();
}

getAttributeValue() [2/9]

template<>

std::int64_t mir_onnx::getAttributeValue ( const onnx::AttributeProto &  attribute )

inline

Definition at line 41 of file AttributeHelpers.h.

{
  assert(attribute.type() == onnx::AttributeProto::INT);
  return attribute.i();
}

getAttributeValue() [3/9]

template<>

std::string mir_onnx::getAttributeValue ( const onnx::AttributeProto &  attribute )

inline

Definition at line 47 of file AttributeHelpers.h.

{
  assert(attribute.type() == onnx::AttributeProto::STRING);
  return attribute.s();
}

getAttributeValue() [4/9]

template<>

onnx::TensorProto mir_onnx::getAttributeValue ( const onnx::AttributeProto &  attribute )

inline

Definition at line 53 of file AttributeHelpers.h.

{
  assert(attribute.type() == onnx::AttributeProto::TENSOR);
  return attribute.t();
}

getAttributeValue() [5/9]

template<>

std::vector< std::int32_t > mir_onnx::getAttributeValue ( const onnx::AttributeProto &  attribute )

inline

Definition at line 60 of file AttributeHelpers.h.

{
  assert(attribute.type() == onnx::AttributeProto::INTS);
  // TODO Check that values fit.
  return {attribute.ints().cbegin(), attribute.ints().cend()};
}

getAttributeValue() [6/9]

template<>

std::vector< std::int64_t > mir_onnx::getAttributeValue ( const onnx::AttributeProto &  attribute )

inline

Definition at line 68 of file AttributeHelpers.h.

{
  assert(attribute.type() == onnx::AttributeProto::INTS);
  return {attribute.ints().cbegin(), attribute.ints().cend()};
}

getAttributeValue() [7/9]

template<typename T >

T mir_onnx::getAttributeValue ( const onnx::AttributeProto &  attribute )

delete

Referenced by convertAveragePoolV1(), convertConvTransposeV1(), and convertMaxPoolV1().

getAttributeValue() [8/9]

template<typename T >

T mir_onnx::getAttributeValue	(	const onnx::NodeProto &	node,
		const std::string &	name
	)

Definition at line 86 of file AttributeHelpers.h.

{
  const auto *attribute = findAttribute(node, name);
  if (attribute == nullptr)
    throw std::runtime_error("Cannot find attribute '" + name + "' in node '" + node.name() + "'.");
  return getAttributeValue<T>(*attribute);
}

References findAttribute().

getAttributeValue() [9/9]

template<typename T >

T mir_onnx::getAttributeValue	(	const onnx::NodeProto &	node,
		const std::string &	name,
		T	default_value
	)

Definition at line 95 of file AttributeHelpers.h.

{
  const auto *attribute = findAttribute(node, name);
  if (attribute == nullptr)
    return default_value;
  return getAttributeValue<T>(*attribute);
}

References findAttribute().

importModelFromBinaryFile()

std::unique_ptr< mir::Graph > mir_onnx::importModelFromBinaryFile

(

const std::string &

filename

)

Definition at line 223 of file ONNXImporterImpl.cpp.

{
  ONNXImporterImpl importer;
  return importer.importModelFromBinaryFile(filename);
}

Referenced by loadModel(), and main().

importModelFromTextFile()

std::unique_ptr< mir::Graph > mir_onnx::importModelFromTextFile

(

const std::string &

filename

)

Definition at line 229 of file ONNXImporterImpl.cpp.

{
  ONNXImporterImpl importer;
  return importer.importModelFromTextFile(filename);
}

Referenced by main().

inferAutoPadding()

void mir_onnx::inferAutoPadding	(	const std::string &	pad_type,
		const mir::Shape &	input_shape,
		const std::vector< std::int32_t > &	dilations,
		const std::vector< std::int32_t > &	strides,
		const std::vector< std::int32_t > &	window_size,
		std::vector< std::int32_t > &	padding_before,
		std::vector< std::int32_t > &	padding_after
	)

Definition at line 25 of file ConvPoolHelpers.cpp.

{
  constexpr int num_spatial_dims = 2;
 
  if (pad_type == "NOTSET")
  {
    // Do nothing.
  }
  else if (pad_type == "VALID")
  {
    padding_before.assign(num_spatial_dims, 0);
    padding_after.assign(num_spatial_dims, 0);
  }
  else
  {
    padding_before.resize(num_spatial_dims);
    padding_after.resize(num_spatial_dims);
 
    assert(dilations.size() == num_spatial_dims);
    assert(strides.size() == num_spatial_dims);
    assert(window_size.size() == num_spatial_dims);
 
    for (int i = 0; i < num_spatial_dims; ++i)
    {
      const std::int32_t eff_window_size = (window_size[i] - 1) * dilations[i] + 1;
      // Assuming input has NCHW format.
      const std::int32_t residual = input_shape.dim(2 + i) % strides[i];
      const std::int32_t total_pad = std::max(
        INT32_C(0), residual == 0 ? eff_window_size - strides[i] : eff_window_size - residual);
      if (pad_type == "SAME_UPPER")
      {
        padding_before[i] = total_pad / 2;
        padding_after[i] = (total_pad + 1) / 2;
      }
      else
      {
        assert(pad_type == "SAME_LOWER");
        padding_before[i] = (total_pad + 1) / 2;
        padding_after[i] = total_pad / 2;
      }
    }
  }
}

References mir::Shape::dim().

Referenced by convertAveragePoolV1(), convertConvTransposeV1(), convertConvV1(), and convertMaxPoolV1().

loadModel()

std::unique_ptr< mir::Graph > mir_onnx::loadModel

(

const std::string &

filename

)

Definition at line 235 of file ONNXImporterImpl.cpp.

{
  return importModelFromBinaryFile(filename);
}

References importModelFromBinaryFile().

Referenced by main().

onnxDataTypeToMirDataType()

mir::DataType mir_onnx::onnxDataTypeToMirDataType

(

onnx::TensorProto::DataType

type

)

Definition at line 79 of file ONNXHelpers.cpp.

{
  switch (type)
  {
    case onnx::TensorProto_DataType_UINT8:
      return mir::DataType::UINT8;
      break;
    case onnx::TensorProto_DataType_INT32:
      return mir::DataType::INT32;
      break;
    case onnx::TensorProto_DataType_INT64:
      return mir::DataType::INT64;
      break;
    case onnx::TensorProto_DataType_DOUBLE:
      return mir::DataType::FLOAT64;
      break;
    case onnx::TensorProto_DataType_FLOAT:
      return mir::DataType::FLOAT32;
      break;
    case onnx::TensorProto_DataType_UNDEFINED:
      throw std::runtime_error{"Undefined input data type not supported"};
      break;
    default:
      throw std::runtime_error{"Unsupported tensor element data type"};
  }
}

Referenced by createTensor().

registerSupportedOps()

void mir_onnx::registerSupportedOps ( )

inline

Definition at line 64 of file ONNXOpRegistration.h.

{
  auto &registry = NodeConverterRegistry::getInstance();
 
#define REG_CONVERTER(name, version, function) registry.registerConverter(name, version, function)
#define REG(name, version) REG_CONVERTER(#name, version, convert##name##V##version)
#define UNSUPPORTED(name, version) REG_CONVERTER(#name, version, nullptr)
 
  REG(Abs, 1);
  REG(Abs, 6);
  UNSUPPORTED(Abs, firstUnknownOpset);
 
  REG(Add, 1);
  REG(Add, 6);
  REG(Add, 7);
  UNSUPPORTED(Add, firstUnknownOpset);
 
  REG(AveragePool, 1);
  REG(AveragePool, 7);
  REG(AveragePool, 10);
  UNSUPPORTED(AveragePool, 11);
  UNSUPPORTED(AveragePool, firstUnknownOpset);
 
  REG(BatchNormalization, 1);
  REG(BatchNormalization, 6);
  REG(BatchNormalization, 7);
  REG(BatchNormalization, 9);
  UNSUPPORTED(BatchNormalization, firstUnknownOpset);
 
  REG(Concat, 1);
  REG(Concat, 4);
  UNSUPPORTED(Concat, 11);
  UNSUPPORTED(Concat, firstUnknownOpset);
 
  REG(Constant, 1);
  REG(Constant, 9);
  REG(Constant, 11);
  UNSUPPORTED(Constant, 12);
  UNSUPPORTED(Constant, firstUnknownOpset);
 
  REG(Conv, 1);
  UNSUPPORTED(Conv, 11);
  UNSUPPORTED(Conv, firstUnknownOpset);
 
  REG(ConvTranspose, 1);
  UNSUPPORTED(ConvTranspose, 11);
  UNSUPPORTED(ConvTranspose, firstUnknownOpset);
 
  UNSUPPORTED(Div, 1);
  UNSUPPORTED(Div, 6);
  REG(Div, 7);
  UNSUPPORTED(Div, firstUnknownOpset);
 
  REG(Dropout, 1);
  REG(Dropout, 6);
  REG(Dropout, 7);
  REG(Dropout, 10);
  UNSUPPORTED(Dropout, 12);
  UNSUPPORTED(Dropout, firstUnknownOpset);
 
  UNSUPPORTED(Equal, 1);
  REG(Equal, 7);
  REG(Equal, 11);
  UNSUPPORTED(Equal, firstUnknownOpset);
 
  REG(Expand, 8);
  UNSUPPORTED(Expand, firstUnknownOpset);
 
  REG(Flatten, 1);
  REG(Flatten, 9);
  UNSUPPORTED(Flatten, 11);
  UNSUPPORTED(Flatten, firstUnknownOpset);
 
  REG(Gather, 1);
  UNSUPPORTED(Gather, 11);
  UNSUPPORTED(Gather, firstUnknownOpset);
 
  REG(Gemm, 1);
  REG(Gemm, 6);
  REG(Gemm, 7);
  REG(Gemm, 9);
  REG(Gemm, 11);
  UNSUPPORTED(Gemm, firstUnknownOpset);
 
  UNSUPPORTED(GlobalAveragePool, 1);
  REG(GlobalAveragePool, 2);
  UNSUPPORTED(GlobalAveragePool, firstUnknownOpset);
 
  UNSUPPORTED(Greater, 1);
  REG(Greater, 7);
  REG(Greater, 9);
  UNSUPPORTED(Greater, firstUnknownOpset);
 
  REG(Identity, 1);
  UNSUPPORTED(Identity, firstUnknownOpset);
 
  UNSUPPORTED(Less, 1);
  REG(Less, 7);
  REG(Less, 9);
  UNSUPPORTED(Less, firstUnknownOpset);
 
  REG(MatMul, 1);
  REG(MatMul, 9);
  UNSUPPORTED(MatMul, firstUnknownOpset);
 
  REG(Max, 1);
  REG(Max, 6);
  REG(Max, 8);
  UNSUPPORTED(Max, firstUnknownOpset);
 
  REG(MaxPool, 1);
  REG(MaxPool, 8);
  REG(MaxPool, 10);
  UNSUPPORTED(MaxPool, 11);
  UNSUPPORTED(MaxPool, 12);
  UNSUPPORTED(MaxPool, firstUnknownOpset);
 
  UNSUPPORTED(Mul, 1);
  UNSUPPORTED(Mul, 6);
  REG(Mul, 7);
  UNSUPPORTED(Mul, firstUnknownOpset);
 
  REG(Pad, 1);
  REG(Pad, 2);
  UNSUPPORTED(Pad, 11);
  UNSUPPORTED(Pad, firstUnknownOpset);
 
  REG(Reciprocal, 1);
  REG(Reciprocal, 6);
  UNSUPPORTED(Reciprocal, firstUnknownOpset);
 
  REG(ReduceMean, 1);
  UNSUPPORTED(ReduceMean, 11);
  UNSUPPORTED(ReduceMean, firstUnknownOpset);
 
  REG(Relu, 1);
  REG(Relu, 6);
  UNSUPPORTED(Relu, firstUnknownOpset);
 
  REG(Reshape, 1);
  REG(Reshape, 5);
  UNSUPPORTED(Reshape, firstUnknownOpset);
 
  REG(Shape, 1);
  UNSUPPORTED(Shape, firstUnknownOpset);
 
  REG(Sigmoid, 1);
  REG(Sigmoid, 6);
  UNSUPPORTED(Sigmoid, firstUnknownOpset);
 
  REG(Softmax, 1);
  // TODO SoftmaxV11 is mostly the same, needs a check though
  UNSUPPORTED(Softmax, firstUnknownOpset);
 
  REG(Sqrt, 1);
  REG(Sqrt, 6);
  UNSUPPORTED(Sqrt, firstUnknownOpset);
 
  REG(Sub, 1);
  REG(Sub, 6);
  REG(Sub, 7);
  UNSUPPORTED(Sub, firstUnknownOpset);
 
  UNSUPPORTED(Sum, 1);
  UNSUPPORTED(Sum, 6);
  REG(Sum, 8);
  UNSUPPORTED(Sum, firstUnknownOpset);
 
  REG(Tanh, 1);
  REG(Tanh, 6);
  UNSUPPORTED(Tanh, firstUnknownOpset);
 
  REG(Transpose, 1);
  UNSUPPORTED(Transpose, firstUnknownOpset);
 
  REG(Unsqueeze, 1);
  UNSUPPORTED(Unsqueeze, 11);
  UNSUPPORTED(Unsqueeze, firstUnknownOpset);
 
  // Upsample-1 is not mentioned in onnx master and was considered experimental at the time
  REG(Upsample, 1);
  REG(Upsample, 7);
  REG(Upsample, 9);
  UNSUPPORTED(Upsample, firstUnknownOpset);
 
#undef REG
#undef REG_CONVERTER
#undef UNSUPPORTED
}

References Add(), AveragePool(), Conv(), Div(), firstUnknownOpset, Gemm(), mir_onnx::NodeConverterRegistry::getInstance(), Identity, Max, MaxPool(), Mul(), REG, Relu, Softmax(), Sub(), and UNSUPPORTED.

Variable Documentation

firstUnknownOpset

const int64_t mir_onnx::firstUnknownOpset = 13

Definition at line 31 of file ONNXHelpers.cpp.

Referenced by registerSupportedOps().