#include <TrainInfoBuilder.h>

Public Member Functions
	TrainInfoBuilder (const std::unique_ptr< ir::train::TrainingInfo > &training_info)

uint8_t *	get () const

uint32_t	size () const

Detailed Description

Definition at line 27 of file TrainInfoBuilder.h.

Constructor & Destructor Documentation

◆ TrainInfoBuilder()

onert::exporter::TrainInfoBuilder::TrainInfoBuilder ( const std::unique_ptr< ir::train::TrainingInfo > & training_info )

inline

Definition at line 30 of file TrainInfoBuilder.h.

                                                                            : _builder(1024)
  {
    const auto &optimizerInfo = training_info->optimizerInfo();
    const auto &lossInfo = training_info->lossInfo();
 
    ::circle::Optimizer optimizer;
    ::circle::OptimizerOptions optimizer_opt_type;
    ::flatbuffers::Offset<void> optimizer_opt;
    switch (optimizerInfo.optim_code)
    {
      case ir::train::OptimizerCode::SGD:
        optimizer = ::circle::Optimizer_SGD;
        optimizer_opt_type = ::circle::OptimizerOptions_SGDOptions;
        optimizer_opt = ::circle::CreateSGDOptions(_builder, optimizerInfo.learning_rate).Union();
        break;
      case ir::train::OptimizerCode::Adam:
        optimizer = ::circle::Optimizer_ADAM;
        optimizer_opt_type = ::circle::OptimizerOptions_AdamOptions;
        optimizer_opt = ::circle::CreateAdamOptions(_builder, optimizerInfo.learning_rate).Union();
        break;
      default:
        throw std::runtime_error("Not supported optimizer code");
    }
 
    ::circle::LossFn lossfn;
    ::circle::LossFnOptions lossfn_opt_type;
    ::flatbuffers::Offset<void> lossfn_opt;
    switch (lossInfo.loss_code)
    {
      case ir::train::LossCode::MeanSquaredError:
        lossfn = ::circle::LossFn_MEAN_SQUARED_ERROR;
        lossfn_opt_type = ::circle::LossFnOptions_MeanSquaredErrorOptions;
        lossfn_opt = ::circle::CreateMeanSquaredErrorOptions(_builder).Union();
        break;
      case ir::train::LossCode::CategoricalCrossentropy:
        lossfn = ::circle::LossFn_CATEGORICAL_CROSSENTROPY;
        lossfn_opt_type = ::circle::LossFnOptions_CategoricalCrossentropyOptions;
        lossfn_opt = ::circle::CreateCategoricalCrossentropyOptions(_builder).Union();
        break;
      default:
        throw std::runtime_error("Not supported loss code");
    }
 
    ::circle::LossReductionType loss_reduction_type;
    switch (lossInfo.reduction_type)
    {
      case ir::train::LossReductionType::SumOverBatchSize:
        loss_reduction_type = ::circle::LossReductionType_SumOverBatchSize;
        break;
      case ir::train::LossReductionType::Sum:
        loss_reduction_type = ::circle::LossReductionType_Sum;
        break;
      default:
        throw std::runtime_error("Not supported loss reduction type");
    }
 
    std::vector<int32_t> trainable_ops;
    for (const auto &op : training_info->getTrainableOps())
    {
      trainable_ops.push_back(op.value());
    }
 
    const auto end = ::circle::CreateModelTrainingDirect(
      _builder, training_info->version(), optimizer, optimizer_opt_type, optimizer_opt, lossfn,
      lossfn_opt_type, lossfn_opt, 0, training_info->batchSize(), loss_reduction_type,
      &trainable_ops);
    _builder.Finish(end, ::circle::ModelTrainingIdentifier());
 
    ::flatbuffers::Verifier v(_builder.GetBufferPointer(), _builder.GetSize());
    bool verified = ::circle::VerifyModelTrainingBuffer(v);
    if (not verified)
      throw std::runtime_error{"TrainingInfo buffer is not accessible"};
  }