nnkit::support::moco::tf::Backend Class Reference

#include <Backend.h>

Collaboration diagram for nnkit::support::moco::tf::Backend:

Public Member Functions
	Backend (const char *pb_path, const char *info_path)
void	setInputOutputFromGraph (const std::unique_ptr< loco::Graph > &loco_graph, ParsedTensors &parsed_tensors)
void	prepare (const std::function< void(nnkit::TensorContext &)> &f) override
void	run (void) override
void	teardown (const std::function< void(nnkit::TensorContext &)> &f)
Public Member Functions inherited from nnkit::Backend
virtual	~Backend ()=default
virtual void	prepare (const std::function< void(TensorContext &)> &f)=0
virtual void	teardown (const std::function< void(TensorContext &)> &f)=0

Detailed Description

Definition at line 39 of file Backend.h.

Constructor & Destructor Documentation

Backend()

nnkit::support::moco::tf::Backend::Backend	(	const char *	pb_path,
		const char *	info_path
	)

Definition at line 87 of file Backend.cpp.

{
  // read test.info
  ::moco::ModelSignature sig;
 
  auto parsed_tensors = nnkit::support::tftestinfo::parse(info_path);
 
  for (auto &parsed_tensor : parsed_tensors)
  {
    if (parsed_tensor->kind() == ParsedTensor::Kind::Input)
    {
      sig.add_input(::moco::TensorName(parsed_tensor->name()));
    }
    else
    {
      sig.add_output(::moco::TensorName(parsed_tensor->name()));
    }
    if (parsed_tensor->hasShape())
      sig.shape(parsed_tensor->name(), parsed_tensor->shape());
  }
 
  // get loco::Graph
  ::moco::tf::Frontend moco;
 
  // After converting, all shapes will be determined.
  auto loco_graph = moco.load(sig, pb_path, ::moco::tf::Frontend::FileType::Binary);
 
  // Set input and output from loco graph.
  setInputOutputFromGraph(loco_graph, parsed_tensors);
 
  // set member vars
  _loco_graph = std::move(loco_graph);
  _sess = std::make_unique<locomotiv::Session>(_loco_graph.get());
}

References moco::ModelSignature::add_input(), moco::ModelSignature::add_output(), moco::tf::Frontend::Binary, nnkit::support::tftestinfo::ParsedTensor::Input, nnkit::support::tftestinfo::parse(), setInputOutputFromGraph(), and moco::ModelSignature::shape().

Member Function Documentation

prepare()

void nnkit::support::moco::tf::Backend::prepare ( const std::function< void(nnkit::TensorContext &)> &  f )

override

Definition at line 122 of file Backend.cpp.

{
  using nncc::core::ADT::tensor::Buffer;
  using nncc::core::ADT::tensor::make_buffer;
  using nncc::core::ADT::tensor::LexicalLayout;
 
  // allocate memory for inputs of loco interpreter
  std::vector<std::unique_ptr<Buffer<float>>> buf_list; // TODO Support more types other than float
 
  for (int n = 0; n < _inputs.size(); n++)
  {
    auto buf = make_buffer<float, LexicalLayout>(_inputs.at(n)->shape());
    buf_list.emplace_back(std::make_unique<nncc::core::ADT::tensor::Buffer<float>>(buf));
  }
 
  // fill test input values
  InputTensorContext ctx(_inputs, buf_list);
  f(ctx);
 
  // set input of locomotiv
  for (int n = 0; n < buf_list.size(); n++)
  {
    auto buf = buf_list.at(n).get();
    auto node_data = locomotiv::make_data(*buf);
    _sess->set_input(n, std::move(node_data));
  }
}

References nncc::core::ADT::tensor::make_buffer(), and locomotiv::make_data().

run()

void nnkit::support::moco::tf::Backend::run ( void  )

overridevirtual

Implements nnkit::Backend.

Definition at line 150 of file Backend.cpp.

{ _sess->infer(); }

Referenced by package.infer.session::inference().

setInputOutputFromGraph()

void nnkit::support::moco::tf::Backend::setInputOutputFromGraph	(	const std::unique_ptr< loco::Graph > &	loco_graph,
		ParsedTensors &	parsed_tensors
	)

Definition at line 45 of file Backend.cpp.

{
  auto inputs = loco_graph.get()->inputs();
  auto outputs = loco_graph.get()->outputs();
  uint32_t input_idx = 0;
  uint32_t output_idx = 0;
  for (auto &parsed_tensor : parsed_tensors)
  {
    if (parsed_tensor->kind() == ParsedTensor::Kind::Input)
    {
      if (!parsed_tensor->hasShape())
      {
        auto input_shape = inputs->at(input_idx++)->shape();
 
        uint32_t size = input_shape->rank();
        parsed_tensor->mutable_shape().resize(size);
        for (uint32_t d = 0; d < size; d++)
        {
          parsed_tensor->mutable_shape().dim(d) = input_shape->dim(d).value();
        }
      }
      _inputs.emplace_back(std::move(parsed_tensor));
    }
    else // Output
    {
      if (!parsed_tensor->hasShape())
      {
        auto output_shape = outputs->at(output_idx++)->shape();
 
        uint32_t size = output_shape->rank();
        parsed_tensor->mutable_shape().resize(size);
        for (uint32_t d = 0; d < size; d++)
        {
          parsed_tensor->mutable_shape().dim(d) = output_shape->dim(d).value();
        }
      }
      _outputs.emplace_back(std::move(parsed_tensor));
    }
  }
}

References nnkit::support::tftestinfo::ParsedTensor::Input, output_shape, luci_interpreter::RuntimeShape::resize(), and size.

Referenced by Backend().

teardown()

void nnkit::support::moco::tf::Backend::teardown

(

const std::function< void(nnkit::TensorContext &)> &

f

)

Definition at line 152 of file Backend.cpp.

{
  // get output
  OutputTensorContext ctx(_outputs, _sess.get());
  f(ctx);
}

---

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

• compiler/nnkit-mocotf/support/include/nnkit/support/moco/tf/Backend.h
• compiler/nnkit-mocotf/support/src/Backend.cpp