circle_eval_diff Namespace Reference

Data Structures
class	CircleEvalDiff
class	DirectoryLoader
class	HDF5Loader
class	InputDataLoader
class	MAEPrinter
class	MAPEPrinter
class	MetricPrinter
class	MPEIRPrinter
class	MSEPrinter
struct	Tensor
struct	TensorDataType
struct	TensorShape
class	TopKMatchPrinter

Enumerations
enum class	Metric {   Undefined , MAE , MAPE , MPEIR ,   MTOP1 , MTOP5 , MSE }
enum class	InputFormat { Undefined , H5 , DIR }

Functions
std::vector< std::shared_ptr< Tensor > >	interpret (const luci::Module *module, const InputDataLoader::Data &data)
void	verifyTypeShape (const luci::CircleInput *input_node, const DataType &dtype, const Shape &shape)
std::vector< size_t >	getEachByteSizeOf (const std::vector< loco::Node * > &nodes)
size_t	getTotalByteSizeOf (const std::vector< loco::Node * > &nodes)
std::unique_ptr< InputDataLoader >	makeDataLoader (const std::string &file_path, const InputFormat &format, const std::vector< loco::Node * > &input_nodes)
void	verifyTypeShape (const luci::CircleInput *input_node, const loco::DataType &dtype, const std::vector< loco::Dimension > &shape)
	INSTANTIATE (loco::DataType::S64)
	INSTANTIATE (loco::DataType::S32)
	INSTANTIATE (loco::DataType::S16)
	INSTANTIATE (loco::DataType::U8)
	INSTANTIATE (loco::DataType::FLOAT32)
std::shared_ptr< Tensor >	createEmptyTensor (const luci::CircleNode *node)

Enumeration Type Documentation

InputFormat

enum class circle_eval_diff::InputFormat

strong

Enumerator
Undefined
H5
DIR

Definition at line 40 of file InputDataLoader.h.

{
  Undefined, // For debugging
  H5,
  DIR, // directory
  // TODO Implement Random, Directory
};

Metric

enum class circle_eval_diff::Metric

strong

Enumerator
Undefined
MAE
MAPE
MPEIR
MTOP1
MTOP5
MSE

Definition at line 36 of file CircleEvalDiff.h.

{
  Undefined, // For debugging
  MAE,       // Mean Absolute Error
  MAPE,      // Mean Percentage Absolute Error
  MPEIR,     // Mean Peak Error to Interval Ratio
  MTOP1,     // Mean Top-1 Match Ratio
  MTOP5,     // Mean Top-5 Match Ratio
  MSE,       // Mean Squared Error
};

Function Documentation

createEmptyTensor()

std::shared_ptr< Tensor > circle_eval_diff::createEmptyTensor

(

const luci::CircleNode *

node

)

Definition at line 90 of file Tensor.cpp.

{
  auto tensor = std::make_shared<Tensor>();
  {
    tensor->dtype(node->dtype());
    tensor->rank(node->rank());
    for (uint32_t i = 0; i < node->rank(); i++)
      tensor->dim(i) = node->dim(i);
 
    switch (node->dtype())
    {
      case loco::DataType::FLOAT32:
        tensor->size<loco::DataType::FLOAT32>(numElements(node));
        break;
      case loco::DataType::U8:
        tensor->size<loco::DataType::U8>(numElements(node));
        break;
      case loco::DataType::S16:
        tensor->size<loco::DataType::S16>(numElements(node));
        break;
      case loco::DataType::S32:
        tensor->size<loco::DataType::S32>(numElements(node));
        break;
      case loco::DataType::S64:
        tensor->size<loco::DataType::S64>(numElements(node));
        break;
      default:
        throw std::runtime_error("Unsupported input tensor dtype for " + node->name());
    }
  }
 
  return tensor;
}

References luci::CircleNode::name().

Referenced by circle_eval_diff::HDF5Loader::get(), circle_eval_diff::DirectoryLoader::get(), and interpret().

getEachByteSizeOf()

std::vector< size_t > circle_eval_diff::getEachByteSizeOf

(

const std::vector< loco::Node * > &

nodes

)

Definition at line 52 of file InputDataLoader.cpp.

{
  std::vector<size_t> vec;
 
  for (const auto node : nodes)
  {
    const auto input_node = loco::must_cast<const luci::CircleInput *>(node);
    const auto dtype_size = luci::size(input_node->dtype());
    size_t element_size = 1;
 
    for (uint32_t index = 0; index < input_node->rank(); index++)
    {
      element_size *= input_node->dim(index).value();
    }
 
    vec.push_back(element_size * dtype_size);
  }
 
  return vec;
}

References loco::must_cast(), and luci::size().

Referenced by circle_eval_diff::DirectoryLoader::get().

getTotalByteSizeOf()

size_t circle_eval_diff::getTotalByteSizeOf

(

const std::vector< loco::Node * > &

nodes

)

Definition at line 73 of file InputDataLoader.cpp.

{
  size_t total_byte_size = 0;
 
  for (const auto node : nodes)
  {
    const auto input_node = loco::must_cast<const luci::CircleInput *>(node);
    size_t byte_size = luci::size(input_node->dtype());
 
    for (uint32_t index = 0; index < input_node->rank(); index++)
    {
      byte_size *= input_node->dim(index).value();
    }
 
    total_byte_size += byte_size;
  }
 
  return total_byte_size;
}

References loco::must_cast(), and luci::size().

Referenced by circle_eval_diff::DirectoryLoader::DirectoryLoader(), and circle_eval_diff::DirectoryLoader::get().

INSTANTIATE() [1/5]

circle_eval_diff::INSTANTIATE

(

loco::DataType::FLOAT32

)

INSTANTIATE() [2/5]

circle_eval_diff::INSTANTIATE

(

loco::DataType::S16

)

INSTANTIATE() [3/5]

circle_eval_diff::INSTANTIATE

(

loco::DataType::S32

)

INSTANTIATE() [4/5]

circle_eval_diff::INSTANTIATE

(

loco::DataType::S64

)

INSTANTIATE() [5/5]

circle_eval_diff::INSTANTIATE

(

loco::DataType::U8

)

interpret()

std::vector< std::shared_ptr< Tensor > > circle_eval_diff::interpret	(	const luci::Module *	module,
		const InputDataLoader::Data &	data
	)

Definition at line 109 of file CircleEvalDiff.cpp.

{
  auto interpreter = std::make_unique<luci_interpreter::Interpreter>(module);
 
  auto input_nodes = ::inputs_of(module);
  auto output_nodes = ::outputs_of(module);
 
  for (uint32_t input_idx = 0; input_idx < data.size(); input_idx++)
  {
    auto input_node = loco::must_cast<const luci::CircleInput *>(input_nodes[input_idx]);
    assert(input_node->index() == input_idx);
 
    auto input_data = data.at(input_idx);
    interpreter->writeInputTensor(input_node, input_data.buffer(), input_data.byte_size());
  }
 
  interpreter->interpret();
 
  std::vector<std::shared_ptr<Tensor>> outputs;
  for (uint32_t output_idx = 0; output_idx < output_nodes.size(); output_idx++)
  {
    auto output_node = loco::must_cast<const luci::CircleOutput *>(output_nodes[output_idx]);
    assert(output_node->index() == output_idx);
 
    auto tensor = createEmptyTensor(output_node);
    interpreter->readOutputTensor(output_node, tensor->buffer(), tensor->byte_size());
    outputs.emplace_back(tensor);
  }
 
  return outputs;
}

References createEmptyTensor(), luci::CircleInput::index(), luci::CircleOutput::index(), and loco::must_cast().

Referenced by circle_eval_diff::CircleEvalDiff::evalDiff().

makeDataLoader()

std::unique_ptr< InputDataLoader > circle_eval_diff::makeDataLoader	(	const std::string &	file_path,
		const InputFormat &	format,
		const std::vector< loco::Node * > &	input_nodes
	)

Definition at line 220 of file InputDataLoader.cpp.

{
  switch (format)
  {
    case InputFormat::H5:
    {
      return std::make_unique<HDF5Loader>(file_path, input_nodes);
    }
    case InputFormat::DIR:
    {
      return std::make_unique<DirectoryLoader>(file_path, input_nodes);
    }
    default:
      throw std::runtime_error{"Unsupported input format."};
  }
}

References DIR, and H5.

Referenced by circle_eval_diff::CircleEvalDiff::evalDiff().

verifyTypeShape() [1/2]

void circle_eval_diff::verifyTypeShape	(	const luci::CircleInput *	input_node,
		const DataType &	dtype,
		const Shape &	shape
	)

Definition at line 36 of file InputDataLoader.cpp.

{
  // Type check
  if (dtype != input_node->dtype())
    throw std::runtime_error("Wrong input type.");
 
  if (shape.size() != input_node->rank())
    throw std::runtime_error("Input rank mismatch.");
 
  for (uint32_t i = 0; i < shape.size(); i++)
  {
    if (not(shape.at(i) == input_node->dim(i)))
      throw std::runtime_error("Input shape mismatch.");
  }
}

Referenced by circle_eval_diff::HDF5Loader::get().

verifyTypeShape() [2/2]

void circle_eval_diff::verifyTypeShape	(	const luci::CircleInput *	input_node,
		const loco::DataType &	dtype,
		const std::vector< loco::Dimension > &	shape
	)