circlechef Namespace Reference

Data Structures
class	CircleImport
	Loads TF lite file and provides helpers to access attributes. More...
class	CircleOpBatchMatMul
	circlechef operator builder for batchmatmul More...
class	CircleOpBCQFullyConnected
	circlechef operator builder for BCQFullyConnected More...
class	CircleOpBCQGather
	circlechef operator builder for BCQGather More...
class	CircleOpChef
	Interface for each operators to build circlechef. More...
class	CircleOpGRU
	circlechef operator builder for GRU More...
class	CircleOpInstanceNorm
	circlechef operator builder for INSTANCE_NORM More...
class	CircleOpRegistry
	circlechef operator registry More...
class	CircleOpRmsNorm
	circlechef operator builder for RMS_NORM More...
class	CircleOpRoPE
	circlechef operator builder for RoPE More...
class	GeneratedModel
class	Logger
	Logger Implementation. More...
class	LoggerConfig
	Logger Configuration. More...
struct	LoggingContext
	Global logging context. More...

Typedefs
using	CircleSubGraphs_t = flatbuffers::Vector< flatbuffers::Offset< circle::SubGraph > >
using	CircleTensors_t = flatbuffers::Vector< flatbuffers::Offset< circle::Tensor > >
using	CircleBuffers_t = flatbuffers::Vector< flatbuffers::Offset< circle::Buffer > >
using	CircleOperators_t = flatbuffers::Vector< flatbuffers::Offset< circle::Operator > >

Functions
std::unique_ptr< ModelRecipe >	generate_recipe (const circle::Model *model)
	Create ModelRecipe from circle::Model.
bool	write_recipe (const std::string &filename, std::unique_ptr< ModelRecipe > &recipe)
	Write ModelRecipe to file with given name.
circlechef::TensorType	as_circlechef_type (const circle::TensorType type)
circlechef::Activation	as_circlechef_activation (const circle::ActivationFunctionType type)
circlechef::Padding	as_circlechef_padding (const circle::Padding padding)
template<typename DT >
std::vector< DT >	extract_buffer (const circle::Buffer *buffer)
	extract buffer data to std::vector<DT>
template<typename T >
std::vector< T >	as_index_vector (const flatbuffers::Vector< T > *flat_array)
void	set_inputs (CircleImport *import, circlechef::Operation *operation, const circle::Operator *op)
void	set_outputs (CircleImport *import, circlechef::Operation *operation, const circle::Operator *op)
GeneratedModel	cook (const ModelRecipe &model_recipe)
GeneratedModel	cook (const ::circlechef::ModelRecipe &model_recipe)
	Generate a (in-memory) TensorFlow Lite model from a given model recipe.

Typedef Documentation

CircleBuffers_t

using circlechef::CircleBuffers_t = typedef flatbuffers::Vector<flatbuffers::Offset<circle::Buffer> >

Definition at line 34 of file CircleImport.h.

CircleOperators_t

using circlechef::CircleOperators_t = typedef flatbuffers::Vector<flatbuffers::Offset<circle::Operator> >

Definition at line 35 of file CircleImport.h.

CircleSubGraphs_t

using circlechef::CircleSubGraphs_t = typedef flatbuffers::Vector<flatbuffers::Offset<circle::SubGraph> >

Definition at line 32 of file CircleImport.h.

CircleTensors_t

using circlechef::CircleTensors_t = typedef flatbuffers::Vector<flatbuffers::Offset<circle::Tensor> >

Definition at line 33 of file CircleImport.h.

Function Documentation

as_circlechef_activation()

circlechef::Activation circlechef::as_circlechef_activation

(

const circle::ActivationFunctionType

type

)

Definition at line 55 of file Convert.cpp.

{
  switch (type)
  {
    case circle::ActivationFunctionType_NONE:
      return circlechef::NONE;
    case circle::ActivationFunctionType_RELU:
      return circlechef::RELU;
    case circle::ActivationFunctionType_RELU6:
      return circlechef::RELU6;
    // TODO handle other types
    // ActivationFunctionType_RELU_N1_TO_1
    // ActivationFunctionType_TANH
    // ActivationFunctionType_SIGN_BIT
    default:
      throw std::runtime_error{"unsupported activation type"};
  }
}

Referenced by circlechef::CircleOpBCQFullyConnected::build(), circlechef::CircleOpGRU::build(), and circlechef::CircleOpInstanceNorm::build().

as_circlechef_padding()

circlechef::Padding circlechef::as_circlechef_padding

(

const circle::Padding

padding

)

Definition at line 74 of file Convert.cpp.

{
  switch (padding)
  {
    case circle::Padding_SAME:
      return circlechef::SAME;
    case circle::Padding_VALID:
      return circlechef::VALID;
    default:
      throw std::runtime_error{"unsupported padding"};
  }
}

as_circlechef_type()

circlechef::TensorType circlechef::as_circlechef_type

(

const circle::TensorType

type

)

Definition at line 22 of file Convert.cpp.

{
  switch (type)
  {
    case circle::TensorType_FLOAT32:
      return circlechef::FLOAT32;
    case circle::TensorType_INT32:
      return circlechef::INT32;
    case circle::TensorType_INT64:
      return circlechef::INT64;
    case circle::TensorType_UINT8:
      return circlechef::UINT8;
    case circle::TensorType_UINT4:
      return circlechef::UINT4;
    case circle::TensorType_BOOL:
      return circlechef::BOOL;
    case circle::TensorType_INT16:
      return circlechef::INT16;
    case circle::TensorType_INT4:
      return circlechef::INT4;
    case circle::TensorType_MXFP4:
      return circlechef::MXFP4;
    case circle::TensorType_MXINT8:
      return circlechef::MXINT8;
    // TODO handle other types
    // TensorType_FLOAT16
    // TensorType_STRING
    // TensorType_COMPLEX64
    default:
      throw std::runtime_error{"unsupported tensor type"};
  }
}

Referenced by generate_recipe().

as_index_vector()

template<typename T >

std::vector< T > circlechef::as_index_vector

(

const flatbuffers::Vector< T > *

flat_array

)

Definition at line 43 of file Convert.h.

{
  if (flat_array == nullptr)
    throw std::runtime_error("flat_array is nullptr");
 
  std::vector<T> ret(flat_array->size());
  for (uint32_t i = 0; i < flat_array->size(); i++)
  {
    ret[i] = flat_array->Get(i);
  }
  return ret;
}

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

Referenced by circlechef::CircleOpBCQFullyConnected::filler(), circlechef::CircleOpBCQGather::filler(), circlechef::CircleOpGRU::filler(), circlechef::CircleOpInstanceNorm::filler(), circlechef::CircleOpRmsNorm::filler(), circlechef::CircleOpRoPE::filler(), generate_recipe(), circlechef::CircleImport::select_sub_graph(), set_inputs(), and set_outputs().

cook() [1/2]

GeneratedModel circlechef::cook

(

const ::circlechef::ModelRecipe &

model_recipe

)

Generate a (in-memory) TensorFlow Lite model from a given model recipe.

Definition at line 529 of file ModelChef.cpp.

{
// Initialize Op Chef Registry
#define OP_CHEF(NAME, FACTORY_CLASS) \
  op_chef_registry().add(#NAME, std::unique_ptr<FACTORY_CLASS>(new FACTORY_CLASS()));
#include "OpChef.def"
#undef OP_CHEF
 
// Initialize Data Chef Registry
#define DATA_CHEF(TYPE, NAME, FACTORY_CLASS) \
  data_chef_registry(::circlechef::TYPE)     \
    .add(#NAME, std::unique_ptr<FACTORY_CLASS>(new FACTORY_CLASS()));
#include "DataChef.def"
#undef DATA_CHEF
 
  //
  // Create FlatBufferBuilder
  //
  auto flatbuffer_builder =
    std::unique_ptr<flatbuffers::FlatBufferBuilder>(new flatbuffers::FlatBufferBuilder(1024));
 
  // Operand-related
  std::vector<flatbuffers::Offset<::circle::Buffer>> buffer_vec;
 
  // Operation-related
  std::vector<flatbuffers::Offset<::circle::OperatorCode>> code_vec;
 
  // Graphs-related
  std::vector<flatbuffers::Offset<::circle::SubGraph>> subgraph_vec;
 
  // Create OperatorCode with Builtin Operator
  std::map<circle::BuiltinOperator, int32_t> builtin_code_map =
    gather_builtincode_map(model_recipe);
  for (auto const &opcode : builtin_code_map)
  {
    circle::OperatorCodeBuilder code_builder{*flatbuffer_builder};
    int8_t dep_code = 127; // BuiltinOperator_PLACEHOLDER_FOR_GREATER_OP_CODES
    if (opcode.first < circle::BuiltinOperator_PLACEHOLDER_FOR_GREATER_OP_CODES)
      dep_code = static_cast<int8_t>(opcode.first);
    code_builder.add_deprecated_builtin_code(dep_code);
    code_builder.add_builtin_code(opcode.first);
    code_builder.add_version(opcode.second);
    auto code = code_builder.Finish();
    // Update OperatorCode vector
    code_vec.emplace_back(code);
  }
 
  // Create OperatorCode with Custom Operator
  std::set<std::string> custom_code_set = gather_customcode_set(model_recipe);
  if (custom_code_set.size() &&
      builtin_code_map.find(circle::BuiltinOperator_CUSTOM) == builtin_code_map.end())
    builtin_code_map[circle::BuiltinOperator_CUSTOM] = 1;
 
  for (auto opcode : custom_code_set)
  {
    auto custom_code = flatbuffer_builder->CreateString(opcode);
    circle::OperatorCodeBuilder code_builder{*flatbuffer_builder};
    code_builder.add_builtin_code(circle::BuiltinOperator_CUSTOM);
    code_builder.add_custom_code(custom_code);
    auto code = code_builder.Finish();
    // Update OperatorCode vector
    code_vec.emplace_back(code);
  }
 
  // Create an Empty Buffer
  //
  // Buffer 0 SHOULD be an empty buffer in TensorFlow Lite model file
  // (Please refer to the comment for Tensor.buffer field in schema)
  {
    circle::BufferBuilder buffer_builder{*flatbuffer_builder};
    buffer_vec.emplace_back(buffer_builder.Finish());
  }
 
  //
  // Create Main graph
  //
  CookParams cp{buffer_vec, code_vec, subgraph_vec, flatbuffer_builder, builtin_code_map, "main"};
 
  cook_graph<::circlechef::ModelRecipe>(model_recipe, cp);
 
  //
  // Create subgraphs if exist
  //
  for (int g = 0; g < model_recipe.graph_size(); ++g)
  {
    const auto &graph = model_recipe.graph(g);
 
    std::ostringstream stringStream;
    stringStream << "sub_" << (g + 1);
 
    CookParams cp{buffer_vec,         code_vec,         subgraph_vec,
                  flatbuffer_builder, builtin_code_map, stringStream.str()};
 
    cook_graph<::circlechef::Graph>(graph, cp);
  }
 
  // Create "Model" arguments
  auto buffers = flatbuffer_builder->CreateVector(buffer_vec);
  auto operator_codes = flatbuffer_builder->CreateVector(code_vec);
  auto subgraphs = flatbuffer_builder->CreateVector(subgraph_vec);
  auto description = flatbuffer_builder->CreateString("Generated by circlechef");
 
  // Create "Model"
  circle::ModelBuilder model_builder{*flatbuffer_builder};
 
  model_builder.add_version(3);
  model_builder.add_operator_codes(operator_codes);
  model_builder.add_subgraphs(subgraphs);
  model_builder.add_description(description);
  model_builder.add_buffers(buffers);
 
  auto model = model_builder.Finish();
 
  // Finalize
  ::circle::FinishModelBuffer(*flatbuffer_builder, model);
 
  // Return "GenerateModel"
  return GeneratedModel{
    std::unique_ptr<GeneratedModelImpl>(new GeneratedModelImpl(std::move(flatbuffer_builder)))};
}

cook() [2/2]

GeneratedModel circlechef::cook

(

const ModelRecipe &

model_recipe

)

Referenced by entry(), and entry_stream().

extract_buffer()

template<typename DT >

std::vector< DT > circlechef::extract_buffer

(

const circle::Buffer *

buffer

)

extract buffer data to std::vector<DT>

Definition at line 34 of file Convert.h.

{
  auto buffer_length = buffer->data()->size();
  auto num_elements = buffer_length / sizeof(DT);
  std::vector<DT> result(num_elements);
  std::memcpy(result.data(), buffer->data()->data(), buffer_length);
  return result;
}

generate_recipe()

std::unique_ptr< ModelRecipe > circlechef::generate_recipe

(

const circle::Model *

model

)

Create ModelRecipe from circle::Model.

This will build ModelRecipe from circle::Model First to check operand filler options by scanning all operators, then translate all operands and operators. Last will set network inputs and outputs.

Definition at line 71 of file RecipeChef.cpp.

{
  std::unique_ptr<ModelRecipe> model_recipe{new ModelRecipe()};
 
  CircleImport circle_import(model);
 
  assert(circle_import.num_subgraph() == 1);
  circle_import.select_sub_graph(0);
 
  auto tensors = circle_import.tensors();
  auto buffers = circle_import.buffers();
  auto operators = circle_import.operators();
 
  // operand fillers for adding all operators
  for (uint32_t i = 0; i < operators->size(); ++i)
  {
    const auto *op = operators->Get(i);
    circle::BuiltinOperator builtincode = circle_import.builtin_code(op);
 
    if (const auto *graph_builder = CircleOpRegistry::get().lookup(builtincode))
    {
      graph_builder->filler(op, &circle_import, model_recipe.get());
    }
    else
    {
      std::string opcodename = circle_import.opcode_name(op);
      throw std::runtime_error{"Not supported: " + opcodename};
    }
  }
 
  // add all operands(tensors)
  for (uint32_t i = 0; i < tensors->size(); ++i)
  {
    auto tensor = tensors->Get(i);
 
    // check buffer
    if (tensor->buffer() >= buffers->size())
      throw std::runtime_error{"file load failed"};
 
    ::circlechef::Operand *operand = model_recipe->add_operand();
 
    operand->set_name(mio::circle::tensor_name(tensor));
    operand->set_type(as_circlechef_type(tensor->type()));
 
    std::vector<int32_t> dims = as_index_vector(tensor->shape());
    ::circlechef::TensorShape *shape = operand->mutable_shape();
    for (auto dim : dims)
    {
      shape->add_dim(dim);
    }
 
    // filler for weights, bias and so on
    std::vector<int32_t> expvalues;
    std::vector<float> expfvalues;
    if (circle_import.get_tensor_filler(i))
    {
      circlechef::TensorFiller *filler = operand->mutable_filler();
      // Note: it is OK to use random weights for functionality validation
      filler->set_tag("gaussian");
      filler->add_arg("0.0"); // average
      filler->add_arg("0.1"); // standard deviation
    }
    else if (circle_import.get_tensor_filler(i, expvalues))
    {
      circlechef::TensorFiller *filler = operand->mutable_filler();
      filler->set_tag("explicit");
      for (auto value : expvalues)
      {
        std::ostringstream ss;
        ss << value;
        filler->add_arg(ss.str());
      }
    }
    else if (circle_import.get_tensor_filler(i, expfvalues))
    {
      circlechef::TensorFiller *filler = operand->mutable_filler();
      filler->set_tag("explicit");
      for (auto value : expfvalues)
      {
        std::ostringstream ss;
        ss << value;
        filler->add_arg(ss.str());
      }
    }
 
    auto quant = tensor->quantization();
    if (quant != nullptr)
    {
      // Note: Calling 'operand->mutable_quant()' will create empty 'quant' node
      // in the recipe file. We want this only when valid parameter exist.
      if (quant->min() != nullptr && quant->min()->size() > 0)
      {
        circlechef::TensorQuantization *chef_quant = operand->mutable_quant();
        for (uint32_t idx = 0; idx < quant->min()->size(); ++idx)
          chef_quant->add_min(quant->min()->Get(idx));
      }
      if (quant->max() != nullptr && quant->max()->size() > 0)
      {
        circlechef::TensorQuantization *chef_quant = operand->mutable_quant();
        for (uint32_t idx = 0; idx < quant->max()->size(); idx++)
          chef_quant->add_max(quant->max()->Get(idx));
      }
      if (quant->scale() != nullptr && quant->scale()->size() > 0)
      {
        circlechef::TensorQuantization *chef_quant = operand->mutable_quant();
        for (uint32_t idx = 0; idx < quant->scale()->size(); ++idx)
          chef_quant->add_scale(quant->scale()->Get(idx));
      }
      if (quant->zero_point() != nullptr && quant->zero_point()->size() > 0)
      {
        circlechef::TensorQuantization *chef_quant = operand->mutable_quant();
        for (uint32_t idx = 0; idx < quant->zero_point()->size(); ++idx)
          chef_quant->add_zero_point(quant->zero_point()->Get(idx));
      }
      circlechef::TensorQuantization *chef_quant = operand->mutable_quant();
      chef_quant->set_quantized_dimension(quant->quantized_dimension());
    }
 
    auto shape_signature = tensor->shape_signature();
    if (shape_signature != nullptr)
    {
      circlechef::ShapeSignature *chef_shape_signature = operand->mutable_shape_signature();
      for (uint32_t i = 0; i < shape_signature->size(); ++i)
      {
        chef_shape_signature->add_dim(shape_signature->Get(i));
      }
    }
  }
 
  // add all operators
  for (uint32_t i = 0; i < operators->size(); ++i)
  {
    const auto *op = operators->Get(i);
    circle::BuiltinOperator builtincode = circle_import.builtin_code(op);
 
    if (const auto *graph_builder = CircleOpRegistry::get().lookup(builtincode))
    {
      auto operation = graph_builder->build(op, &circle_import, model_recipe.get());
 
      // common for all operators: inputs, outputs
      set_inputs(&circle_import, operation, op);
      set_outputs(&circle_import, operation, op);
    }
    else
    {
      std::string opcodename = circle_import.opcode_name(op);
      throw std::runtime_error{"Not supported: " + opcodename};
    }
  }
 
  // network inputs/outputs
  const std::vector<int32_t> &inputs = circle_import.inputs();
  const std::vector<int32_t> &outputs = circle_import.outputs();
 
  for (const auto input : inputs)
  {
    auto tensor = tensors->Get(input);
    std::string name = mio::circle::tensor_name(tensor);
 
    model_recipe->add_input(name);
  }
  for (const auto output : outputs)
  {
    auto tensor = tensors->Get(output);
    std::string name = mio::circle::tensor_name(tensor);
 
    model_recipe->add_output(name);
  }
 
  return std::move(model_recipe);
}

References as_circlechef_type(), as_index_vector(), circlechef::CircleImport::buffers(), circlechef::CircleImport::builtin_code(), circlechef::CircleOpRegistry::get(), flatbuffers::Vector< T >::Get(), souschef::TensorFiller::get_tensor_filler(), circlechef::CircleImport::inputs(), circlechef::CircleOpRegistry::lookup(), circlechef::CircleImport::num_subgraph(), circlechef::CircleImport::opcode_name(), circlechef::CircleImport::operators(), circlechef::CircleImport::outputs(), circlechef::CircleImport::select_sub_graph(), set_inputs(), set_outputs(), mio::circle::tensor_name(), and circlechef::CircleImport::tensors().

Referenced by entry().

set_inputs()

void circlechef::set_inputs	(	CircleImport *	import,
		circlechef::Operation *	operation,
		const circle::Operator *	op
	)

Definition at line 32 of file RecipeChef.cpp.

{
  auto tensors = import->tensors();
  const std::vector<int32_t> &inputs = as_index_vector(op->inputs());
 
  for (auto input : inputs)
  {
    if (input == -1)
    {
      operation->add_input("");
    }
    else
    {
      auto tensor = tensors->Get(input);
      std::string name = mio::circle::tensor_name(tensor);
      operation->add_input(name);
    }
  }
}

References as_index_vector(), and mio::circle::tensor_name().

Referenced by generate_recipe().

set_outputs()

void circlechef::set_outputs	(	CircleImport *	import,
		circlechef::Operation *	operation,
		const circle::Operator *	op
	)

Definition at line 52 of file RecipeChef.cpp.

{
  auto tensors = import->tensors();
  const std::vector<int32_t> &outputs = as_index_vector(op->outputs());
 
  for (auto output : outputs)
  {
    auto tensor = tensors->Get(output);
    std::string name = mio::circle::tensor_name(tensor);
    operation->add_output(name);
  }
}

References as_index_vector(), and mio::circle::tensor_name().

Referenced by generate_recipe().

write_recipe()

bool circlechef::write_recipe	(	const std::string &	filename,
		std::unique_ptr< ModelRecipe > &	recipe
	)

Write ModelRecipe to file with given name.

Definition at line 243 of file RecipeChef.cpp.

{
  std::fstream fo(filename, std::ios::binary | std::ios::out);
 
  if (!fo.is_open())
  {
    throw std::runtime_error{"file store failed"};
  }
 
  // Note: SerializeToString() or SerializeToOstream() writes in binary mode
  // DebugString() and Utf8DebugString() will print as a human readable text
  fo << recipe->Utf8DebugString();
 
  fo.close();
 
  return true;
}

Referenced by entry().