tflimport Namespace Reference

Data Structures
class	AvgPool2DGraphBuilder
	GraphBuilder for AvgPool2D operator. More...
class	ConcatenationGraphBuilder
	GraphBuilder for Concatenation operator. More...
class	Conv2DGraphBuilder
	GraphBuilder for Conv2D operator. More...
class	DepthwiseConv2DGraphBuilder
	GraphBuilder for DepthwiseConv2D operator. More...
class	DivGraphBuilder
	GraphBuilder for Div operator. More...
class	GraphBuilder
	Parent class of tflite operation graph builders (e.g., Conv2DGraphBuilder) More...
class	GraphBuilderContext
	Class to store context to build IR from tflite. More...
class	GraphBuilderRegistry
	Class to return graph builder for passed tflite::builtinOperator. More...
class	MaxPool2DGraphBuilder
	GraphBuilder for AvgPool2D operator. More...
class	ReLU6GraphBuilder
	GraphBuilder for ReLU6 operator. More...
class	ReLUGraphBuilder
	GraphBuilder for ReLU operator. More...
class	ReshapeGraphBuilder
	GraphBuilder for Reshape operator. More...
class	SubGraphBuilder
	GraphBuilder for Sub operator. More...
class	TensorBags
	Pre-creates coco:Bags for each operands(tensors) More...
class	TensorContext
	Extracts and holds operand(tensor) information such as name, shape, and type. More...
class	TflBufferContext
	Class to read and provide buffer information of tflite. More...
class	TflOpCodeContext
	Class that holds operator codes and related methods. More...

Typedefs
using	IndexVector = std::vector< int32_t >

Functions
IndexVector	as_index_vector (const flatbuffers::Vector< int32_t > *array)
	Converts flatbuffers::Vector to IndexVector.
tensor::Shape	as_tensor_shape (const flatbuffers::Vector< int32_t > *shape)
	Converts flatbuffers::Vector to nncc::core::ADT::tensor::Shape.
void	set_module_inputs (coco::Module *m, TensorContext &ctx, TensorBags &bags, const IndexVector &inputs)
	Set module input operands and its information.
void	set_module_outputs (coco::Module *m, TensorContext &ctx, TensorBags &bags, const IndexVector &outputs)
	Set module output operands and its information.
void	copy_tensors (GraphBuilderContext *ctx)
	Copy values of tfl tensors into coco::Data if the data was not copied.
coco::FeatureObject *	build_activation (tflite::ActivationFunctionType act, coco::Block *block, coco::FeatureObject *ifm)
	Add coco::Eval for fused activation. This method creates an ofm object, appends Eval(ofm object, RELU(...)) into block, and returns ofm object.
coco::Padding2D	get_padding (const tensor::Shape &ifm_shape, const int kernel_w, const int kernel_h, tflite::Padding padding, int stride_w, int stride_h, int dilation_w_factor, int dilation_h_factor)
coco::Padding2D	pool2D_padding (const tflite::Pool2DOptions *options, const tensor::Shape &ifm_shape, const int filter_w, const int filter_h)
coco::Padding2D	conv2D_padding (const tflite::Conv2DOptions *options, const tensor::Shape &ifm_shape, const tensor::Shape &kernel_shape)
coco::Padding2D	depthwiseConv2D_padding (const tflite::DepthwiseConv2DOptions *options, const tensor::Shape &ifm_shape, const tensor::Shape &kernel_shape)

Typedef Documentation

IndexVector

using tflimport::IndexVector = typedef std::vector<int32_t>

Definition at line 29 of file Convert.h.

Function Documentation

as_index_vector()

IndexVector tflimport::as_index_vector

(

const flatbuffers::Vector< int32_t > *

array

)

Converts flatbuffers::Vector to IndexVector.

Definition at line 28 of file Convert.cpp.

{
  const uint32_t size = array->size();
 
  std::vector<int32_t> res(size);
 
  for (uint32_t i = 0; i < size; i++)
  {
    res[i] = array->Get(i);
  }
 
  return res;
}

References flatbuffers::Vector< T >::Get(), flatbuffers::Vector< T >::size(), and size.

Referenced by tflimport::AvgPool2DGraphBuilder::build(), tflimport::ConcatenationGraphBuilder::build(), tflimport::DivGraphBuilder::build(), tflimport::MaxPool2DGraphBuilder::build(), tflimport::ReLUGraphBuilder::build(), tflimport::ReLU6GraphBuilder::build(), tflimport::ReshapeGraphBuilder::build(), tflimport::SubGraphBuilder::build(), tflimport::Conv2DGraphBuilder::build(), and tflimport::DepthwiseConv2DGraphBuilder::build().

as_tensor_shape()

tensor::Shape tflimport::as_tensor_shape

(

const flatbuffers::Vector< int32_t > *

shape

)

Converts flatbuffers::Vector to nncc::core::ADT::tensor::Shape.

Definition at line 42 of file Convert.cpp.

{
  const uint32_t rank = shape->size();
 
  tensor::Shape res;
 
  res.resize(rank);
  for (uint32_t axis = 0; axis < rank; ++axis)
  {
    res.dim(axis) = shape->Get(axis);
  }
 
  return res;
}

References nncc::core::ADT::tensor::Shape::dim(), flatbuffers::Vector< T >::Get(), nncc::core::ADT::tensor::Shape::resize(), and flatbuffers::Vector< T >::size().

Referenced by tflimport::TensorContext::prepare(), and tflimport::TensorBags::prepare().

build_activation()

coco::FeatureObject * tflimport::build_activation	(	tflite::ActivationFunctionType	act,
		coco::Block *	block,
		coco::FeatureObject *	ifm
	)

Add coco::Eval for fused activation. This method creates an ofm object, appends Eval(ofm object, RELU(...)) into block, and returns ofm object.

Definition at line 34 of file Activation.cpp.

{
  assert(ifm != nullptr && ifm->asFeature() != nullptr); // support feature only in this version
 
  coco::Module *m = block->module();
 
  auto shape = ifm->asFeature()->shape();
 
  // creates output object
  auto output_obj = m->entity()->object()->create<coco::FeatureObject>();
  auto output_bag = m->entity()->bag()->create(num_elements(shape));
  output_obj->bag(output_bag);
  output_obj->layout(coco::FeatureLayouts::BHWC::create(shape));
 
  switch (act)
  {
    case tflite::ActivationFunctionType::ActivationFunctionType_NONE:
    {
      // Create Copy Instr (copying from ifm to output_obj),
      // redundant layer but optimized by backend
      auto copy_ins = instr_builder(m).copy(output_obj, ifm);
 
      // Append the instruction to the block
      block->instr()->append(copy_ins);
      break;
    }
    case tflite::ActivationFunctionType::ActivationFunctionType_RELU:
    {
      // Create Eval(output_obj, ReLU(load(ifm)))
      auto load_op = op_builder(m).load(ifm).pop();
      auto relu_op = m->entity()->op()->create<coco::ReLU>();
      relu_op->arg(load_op);
 
      auto eval_ins = instr_builder(m).eval(output_obj, relu_op);
 
      // Append the instruction to the block
      block->instr()->append(eval_ins);
      break;
    }
    case tflite::ActivationFunctionType::ActivationFunctionType_RELU6:
    {
      // Create Eval(output_obj, ReLU6(load(ifm)))
      auto load_op = op_builder(m).load(ifm).pop();
      auto relu6_op = m->entity()->op()->create<coco::ReLU6>();
      relu6_op->arg(load_op);
 
      auto eval_ins = instr_builder(m).eval(output_obj, relu6_op);
 
      // Append the instruction to the block
      block->instr()->append(eval_ins);
      break;
    }
    default:
      // TODO support other fused activations
      assert(false);
      break;
  }
 
  return output_obj;
}

References coco::DLinkedList< Child, Parent >::Head::append(), coco::UnaryOp::arg(), coco::FeatureObject::asFeature(), coco::Object::bag(), InstrBuilder::copy(), coco::FeatureLayouts::BHWC::create(), InstrBuilder::eval(), coco::Block::instr(), instr_builder(), OpBuilder::load(), m, coco::Entity::module(), op_builder(), OpBuilder::pop(), relu_op, and coco::FeatureObject::shape().

Referenced by tflimport::Conv2DGraphBuilder::build(), and tflimport::DepthwiseConv2DGraphBuilder::build().

conv2D_padding()

coco::Padding2D tflimport::conv2D_padding	(	const tflite::Conv2DOptions *	options,
		const tensor::Shape &	ifm_shape,
		const tensor::Shape &	kernel_shape
	)

Definition at line 88 of file Padding.cpp.

{
  return get_padding(ifm_shape, kernel_shape.dim(2), kernel_shape.dim(1), /* kernel layout: NHWC */
                     options->padding(), options->stride_w(), options->stride_h(),
                     options->dilation_w_factor(), options->dilation_h_factor());
}

References nncc::core::ADT::tensor::Shape::dim(), and get_padding().

Referenced by tflimport::Conv2DGraphBuilder::build().

copy_tensors()

void tflimport::copy_tensors

(

GraphBuilderContext *

ctx

)

Copy values of tfl tensors into coco::Data if the data was not copied.

Definition at line 84 of file Frontend.cpp.

{
  auto d = ctx->d();
 
  // for each bag, check if bag is not allocated but tflite tensor has values
  for (auto &iter : ctx->bags())
  {
    auto tfl_tensor_id = iter.first;
    auto bag = iter.second;
 
    auto tfl_buffer = ctx->buffer().tensor_buffer<float>(ctx->graph(), tfl_tensor_id);
 
    // TODO remove this line when support int32 is ready
    if (ctx->tensor().type(tfl_tensor_id) == tflite::TensorType::TensorType_INT32)
    {
      std::cout << "*** INT32 COPYING IS NOT SUPPORTED ***" << std::endl;
      continue;
    }
 
    assert(ctx->tensor().type(tfl_tensor_id) == tflite::TensorType::TensorType_FLOAT32);
 
    auto span = d->f32()->weight(bag); // TODO support other type
 
    if (!(span.data() == nullptr && span.size() == 0)) // already allocated
      continue;
 
    if (tfl_buffer.ptr == nullptr || tfl_buffer.len == 0) // no data to copy
      continue;
 
    d->f32()->allocate(bag);
 
    auto ifm_span = d->f32()->weight(bag);
    for (uint32_t idx = 0; idx < tfl_buffer.len; ++idx)
    {
      ifm_span[idx] = tfl_buffer.ptr[idx];
    }
  }
}

References tflimport::GraphBuilderContext::bags(), tflimport::GraphBuilderContext::buffer(), tflimport::GraphBuilderContext::d(), tflimport::GraphBuilderContext::graph(), tflimport::GraphBuilderContext::tensor(), tflimport::TflBufferContext::tensor_buffer(), and tflimport::TensorContext::type().

depthwiseConv2D_padding()

coco::Padding2D tflimport::depthwiseConv2D_padding	(	const tflite::DepthwiseConv2DOptions *	options,
		const tensor::Shape &	ifm_shape,
		const tensor::Shape &	kernel_shape
	)

Definition at line 96 of file Padding.cpp.

{
  return get_padding(ifm_shape, kernel_shape.dim(2), kernel_shape.dim(1), /* kernel layout: NHWC */
                     options->padding(), options->stride_w(), options->stride_h(),
                     options->dilation_w_factor(), options->dilation_h_factor());
}

References nncc::core::ADT::tensor::Shape::dim(), and get_padding().

Referenced by tflimport::DepthwiseConv2DGraphBuilder::build().

get_padding()

coco::Padding2D tflimport::get_padding	(	const tensor::Shape &	ifm_shape,
		const int	kernel_w,
		const int	kernel_h,
		tflite::Padding	padding,
		int	stride_w,
		int	stride_h,
		int	dilation_w_factor,
		int	dilation_h_factor
	)

Compute [top padding + bottom padding] (or [left padding + right padding]). If this returns an even number, top = return value / 2 and bottom = return value - top If this returns an odd number, top = return value / 2 and bottom = return value - top (so, bottom = top + 1)

Code based on https://www.tensorflow.org/api_guides/python/nn#Convolution

Definition at line 38 of file Padding.cpp.

{
  assert(stride_w != 0);
  assert(stride_h != 0);
  assert(ifm_shape.rank() == 4);
 
  auto compute_padding = [](tflite::Padding padding, int stride, int dilation_rate, int in_size,
                            int filter_size) {
    int effective_filter_size = (filter_size - 1) * dilation_rate + 1;
    if (padding == tflite::Padding_SAME)
    {
      if (in_size % stride == 0)
        return std::max(effective_filter_size - stride, 0);
      else
        return std::max(effective_filter_size - (in_size % stride), 0);
    }
    else // padding == VALID
    {
      return 0;
    }
  };
 
  // ifm shape is from order of NHWC. ifm W = dim(2), ifm H = dim(1)
  int padding_w = compute_padding(padding, stride_w, dilation_w_factor, ifm_shape.dim(2), kernel_w);
  int padding_h = compute_padding(padding, stride_h, dilation_h_factor, ifm_shape.dim(1), kernel_h);
 
  coco::Padding2D coco_padding;
  coco_padding.top(padding_h / 2).bottom(padding_h - padding_h / 2);
  coco_padding.left(padding_w / 2).right(padding_w - padding_w / 2);
 
  return coco_padding;
}

References nncc::core::ADT::tensor::Shape::dim(), coco::Padding2D::left(), nncc::core::ADT::tensor::Shape::rank(), and coco::Padding2D::top().

Referenced by conv2D_padding(), depthwiseConv2D_padding(), and pool2D_padding().

pool2D_padding()

coco::Padding2D tflimport::pool2D_padding	(	const tflite::Pool2DOptions *	options,
		const tensor::Shape &	ifm_shape,
		const int	filter_w,
		const int	filter_h
	)

Definition at line 81 of file Padding.cpp.

{
  return get_padding(ifm_shape, filter_w, filter_h, options->padding(), options->stride_w(),
                     options->stride_h(), 1, 1);
}

References get_padding().

Referenced by tflimport::AvgPool2DGraphBuilder::build(), and tflimport::MaxPool2DGraphBuilder::build().

set_module_inputs()

void tflimport::set_module_inputs	(	coco::Module *	m,
		TensorContext &	ctx,
		TensorBags &	bags,
		const IndexVector &	inputs
	)

Set module input operands and its information.

Definition at line 36 of file Frontend.cpp.

{
  for (uint32_t n = 0; n < inputs.size(); ++n)
  {
    auto const tensor_id = inputs.at(n);
 
    auto const tensor_name = ctx.name(tensor_id);
    auto const tensor_shape = ctx.shape(tensor_id);
    auto const tensor_bag = bags.bag(tensor_id);
 
    auto input = m->entity()->input()->create(tensor_shape);
 
    input->name(tensor_name);
    input->bag(tensor_bag);
    input->reorder<tensor::LexicalLayout>();
 
    m->input()->insert(input);
  }
}

References tflimport::TensorBags::bag(), m, tflimport::TensorContext::name(), and tflimport::TensorContext::shape().

set_module_outputs()

void tflimport::set_module_outputs	(	coco::Module *	m,
		TensorContext &	ctx,
		TensorBags &	bags,
		const IndexVector &	outputs
	)

Set module output operands and its information.

Definition at line 60 of file Frontend.cpp.

{
  for (uint32_t n = 0; n < outputs.size(); ++n)
  {
    auto const tensor_id = outputs.at(n);
 
    auto const tensor_name = ctx.name(tensor_id);
    auto const tensor_shape = ctx.shape(tensor_id);
    auto const tensor_bag = bags.bag(tensor_id);
 
    auto output = m->entity()->output()->create(tensor_shape);
 
    output->name(tensor_name);
    output->bag(tensor_bag);
    output->reorder<tensor::LexicalLayout>();
 
    m->output()->insert(output);
  }
}

References tflimport::TensorBags::bag(), m, tflimport::TensorContext::name(), and tflimport::TensorContext::shape().