#include <Frontend.h>

Collaboration diagram for Frontend:

[legend]

Public Member Functions
	Frontend ()

::caffe::NetParameter *	prototxt (void)

::caffe::NetParameter *	caffemodel (void)

enco::Bundle	load (void) const override

	Frontend (std::unique_ptr< RawModel > &&raw)

enco::Bundle	load (void) const override

Public Member Functions inherited from enco::Frontend
virtual	~Frontend ()=default

Detailed Description

Definition at line 26 of file Frontend.h.

Constructor & Destructor Documentation

◆ Frontend() [1/2]

Frontend::Frontend ( )

Definition at line 35 of file Frontend.cpp.

                   : _prototxt{new ::caffe::NetParameter}, _caffemodel{new ::caffe::NetParameter}
{
  // DO NOTHING
}

◆ Frontend() [2/2]

Frontend::Frontend ( std::unique_ptr< RawModel > && raw )

Definition at line 125 of file Frontend.cpp.

                                                : _raw{std::move(raw)}
{
  // DO NOTHING
}

Member Function Documentation

◆ caffemodel()

::caffe::NetParameter * Frontend::caffemodel ( void )

inline

Definition at line 33 of file Frontend.h.

33{ return _caffemodel.get(); }

◆ load() [1/2]

enco::Bundle Frontend::load ( void ) const

overridevirtual

Implements enco::Frontend.

Definition at line 40 of file Frontend.cpp.

{
  auto module = coco::Module::create();
  auto blk = module->entity()->block()->create();
  module->block()->append(blk);
 
  auto data = coco::Data::create();
 
  // For weight access
  caffeimport::WeightContext weight_ctx(_caffemodel.get());
 
  // For inter-layer communication
  std::map<std::string, tensor::Shape> shape_ctx;
  std::map<std::string, coco::Bag *> bag_ctx;
 
  std::set<std::string> bags;
  std::map<std::string, uint32_t> def_count;
  std::map<std::string, uint32_t> use_count;
 
  auto def = [&bags, &def_count, &use_count](const std::string &name) {
    if (bags.find(name) == bags.end())
    {
      bags.insert(name);
      def_count[name] = 0;
      use_count[name] = 0;
    }
 
    def_count.at(name) += 1;
  };
 
  auto use = [&use_count](const std::string &name) { use_count.at(name) += 1; };
 
  auto outputs = [&bags, &def_count, &use_count](void) {
    std::set<std::string> res;
 
    for (const auto &bag : bags)
    {
      if (def_count.at(bag) > use_count.at(bag))
      {
        res.insert(bag);
      }
    }
 
    return res;
  };
 
  caffeimport::GraphBuilderContext opbuilder_context(module.get(), data.get(), blk, shape_ctx,
                                                     bag_ctx, weight_ctx);
 
  for (const auto &layer : _prototxt->layer())
  {
    assert(layer.has_name());
    assert(layer.has_type());
 
    for (uint32_t n = 0; n < layer.top().size(); ++n)
    {
      def(layer.top(n));
    }
 
    for (uint32_t n = 0; n < layer.bottom().size(); ++n)
    {
      use(layer.bottom(n));
    }
 
    if (const auto *graph_builder = caffeimport::GraphBuilderRegistry::get().lookup(layer.type()))
    {
      graph_builder->build(layer, &opbuilder_context);
    }
    else
    {
      throw std::runtime_error{"Not supported: " + layer.type()};
    }
  }
 
  // Finalize: Create output for each top blob
  for (const auto &name : outputs())
  {
    const auto &shape = shape_ctx.at(name);
    auto bag = bag_ctx.at(name);
 
    auto output = module->entity()->output()->create(shape);
 
    output->bag(bag);
    output->name(name);
    output->reorder<LexicalLayout>();
 
    module->output()->insert(output);
  }
 
  enco::Bundle bundle;
 
  bundle.module(std::move(module));
  bundle.data(std::move(data));
 
  return std::move(bundle);
}

References coco::Data::create(), enco::Bundle::data(), caffeimport::GraphBuilderRegistry::get(), enco::Bundle::module(), and size.

◆ load() [2/2]

enco::Bundle Frontend::load ( void ) const

overridevirtual

Implements enco::Frontend.

◆ prototxt()

::caffe::NetParameter * Frontend::prototxt ( void )