training_configure_tool Namespace Reference

Data Structures
struct	TrainConfigFileData
struct	TrainData
struct	TrainResult

Typedefs
using	DataBuffer = std::vector< char >

Enumerations
enum	OpTrainableRank {   ALL = 0 , ONLY_BIAS = 1 , UP_1_2_PART = 2 , LOWER_1_2_PART = 3 ,   MAX_VALUE = 4 }

Functions
onert_micro::OMStatus	findBestTrainableOpIndexes (onert_micro::OMConfig &config, TrainData &train_data, std::unordered_set< uint16_t > &best_trainable_op_indexes)
bool	cmpTrainResults (const training_configure_tool::TrainResult &left, const training_configure_tool::TrainResult &right, const float acceptable_diff)
std::unordered_set< uint16_t >	findAllTrainableOps (const char *circle_model_path)
std::vector< std::unordered_set< uint16_t > >	generateAllPossibleOpIndexesSets (const std::unordered_set< uint16_t > &initial_train_op_indexes)
std::vector< std::unordered_set< uint16_t > >	selectOpIndexesSetsAccordingToMemoryRestriction (const std::vector< std::unordered_set< uint16_t > > &op_indexes_sets, onert_micro::OMConfig config, training_configure_tool::TrainData train_data)
std::vector< std::unordered_map< uint16_t, OpTrainableRank > >	findAllTensorsRanksCombinations (const std::unordered_set< uint16_t > &selected_op_indexes, onert_micro::OMConfig config, training_configure_tool::TrainData train_data)
onert_micro::OMStatus	findBestSparseBackpropagationTensorsRanks (onert_micro::OMConfig &config, TrainData &train_data, const std::unordered_set< uint16_t > &selected_op_indexes, std::unordered_map< uint16_t, OpTrainableRank > &best_train_ranks)
void	readDataFromFile (const std::string &filename, char *data, size_t data_size, size_t start_position=0)
void	writeDataToFile (const std::string &filename, const char *data, size_t data_size)
DataBuffer	readFile (const char *path)
onert_micro::OMStatus	createResultFile (const TrainConfigFileData &train_data, const char *save_path)
onert_micro::OMStatus	createResultData (const TrainConfigFileData &train_data, std::vector< char > &result_buffer)
onert_micro::OMStatus	runTrainProcessWithCurConfig (onert_micro::OMConfig &config, const training_configure_tool::TrainData &train_data, TrainResult &train_result)

Typedef Documentation

DataBuffer

using training_configure_tool::DataBuffer = typedef std::vector<char>

Definition at line 30 of file TrainingConfigureFileHandler.h.

Enumeration Type Documentation

OpTrainableRank

enum training_configure_tool::OpTrainableRank

Enumerator
ALL
ONLY_BIAS
UP_1_2_PART
LOWER_1_2_PART
MAX_VALUE

Definition at line 34 of file TrainConfigData.h.

{
  ALL = 0,            // 0 - Train all weights in the operation
  ONLY_BIAS = 1,      // 1 - Train bias only in the operation
  UP_1_2_PART = 2,    // 2 - Train the upper 1/2 part of the operation
  LOWER_1_2_PART = 3, // 3 - Train the lower 1/2 part of the operation
  MAX_VALUE = 4,
  // TODO add more
};

Function Documentation

cmpTrainResults()

bool training_configure_tool::cmpTrainResults	(	const training_configure_tool::TrainResult &	left,
		const training_configure_tool::TrainResult &	right,
		const float	acceptable_diff
	)

Definition at line 155 of file SparseBackpropagationHelper.cpp.

{
  // Metrics should be the same
  assert(left.best_metrics_results.first == right.best_metrics_results.first);
  OMMetrics metric = left.best_metrics_results.first;
  float left_metric_res = left.best_metrics_results.second;
  float right_metric_res = right.best_metrics_results.second;
 
  bool is_in_acceptable_diff = std::abs(left_metric_res - right_metric_res) <= acceptable_diff;
  if (is_in_acceptable_diff)
  {
    return left.peak_memory_footprint < right.peak_memory_footprint;
  }
 
  switch (metric)
  {
    case onert_micro::ACCURACY:
    {
      return left.best_metrics_results.second > right.best_metrics_results.second;
    }
    break;
    case onert_micro::CROSS_ENTROPY_METRICS:
    case onert_micro::MSE_METRICS:
    case onert_micro::MAE_METRICS:
    {
 
      return left.best_metrics_results.second < right.best_metrics_results.second;
    }
    break;
    default:
      assert(false && "Unsupported type");
      break;
  }
  return true;
}

References onert_micro::ACCURACY, training_configure_tool::TrainResult::best_metrics_results, onert_micro::CROSS_ENTROPY_METRICS, onert_micro::MAE_METRICS, onert_micro::MSE_METRICS, and training_configure_tool::TrainResult::peak_memory_footprint.

Referenced by findBestSparseBackpropagationTensorsRanks(), and findBestTrainableOpIndexes().

createResultData()

onert_micro::OMStatus training_configure_tool::createResultData	(	const TrainConfigFileData &	train_data,
		std::vector< char > &	result_buffer
	)

Definition at line 155 of file TrainingConfigureFileHandler.cpp.

{
  writeTrainConfigFileDataIntoBuffer(train_data, result_buffer);
 
  return onert_micro::Ok;
}

References onert_micro::Ok.

Referenced by findBestSparseBackpropagationTensorsRanks(), findBestTrainableOpIndexes(), and selectOpIndexesSetsAccordingToMemoryRestriction().

createResultFile()

onert_micro::OMStatus training_configure_tool::createResultFile	(	const TrainConfigFileData &	train_data,
		const char *	save_path
	)

Definition at line 132 of file TrainingConfigureFileHandler.cpp.

{
  std::vector<char> buffer;
 
  writeTrainConfigFileDataIntoBuffer(train_data, buffer);
 
  // Open or create file
  // Note: if the file existed, it will be overwritten
  std::ofstream out_file(save_path, std::ios::binary | std::ios::trunc);
  if (not out_file.is_open())
    return onert_micro::UnknownError;
 
  // Write data
  out_file.write(buffer.data(), static_cast<long>(buffer.size()));
 
  // Close file
  out_file.close();
 
  return onert_micro::Ok;
}

References onert_micro::Ok, and onert_micro::UnknownError.

Referenced by entry().

findAllTensorsRanksCombinations()

std::vector< std::unordered_map< uint16_t, training_configure_tool::OpTrainableRank > > training_configure_tool::findAllTensorsRanksCombinations	(	const std::unordered_set< uint16_t > &	selected_op_indexes,
		onert_micro::OMConfig	config,
		training_configure_tool::TrainData	train_data
	)

Definition at line 327 of file SparseBackpropagationHelper.cpp.

{
  // 1 - Find pairs: selected ops indexes - divided dim max rank value
  // 2 - Find for every tensor index every possible rank according to its opcode and size
  // 3 - Get result
  std::vector<std::unordered_map<uint16_t, training_configure_tool::OpTrainableRank>> result;
 
  training_configure_tool::DataBuffer model_ptr =
    training_configure_tool::readFile(train_data.circle_model_path);
 
  // Init reader
  OMStatus status = Ok;
  core::reader::OMCircleReader reader;
  assert(model_ptr.data() != nullptr);
  status = reader.parse(model_ptr.data());
  assert(status == Ok);
  // return empty set
  if (status != Ok)
    return result;
  // TODO: support multi subgraph models
  status = reader.select_subgraph(0);
  // return empty set
  if (status != Ok)
    return result;
 
  // 1 - Find pairs: selected ops indexes - divided dim max rank value
  std::unordered_map<uint16_t, uint32_t> operator_index_to_tensor_index =
    findTrainableTensorsMaxDivideRankAccordingToOperatorIndex(selected_op_indexes, reader);
  assert(operator_index_to_tensor_index.size() == selected_op_indexes.size());
  // 2 - Find for every tensor index every possible rank according to its opcode and size
  std::unordered_map<uint16_t, std::unordered_set<uint16_t>> op_index_to_all_possible_ranks;
  for (auto &p : operator_index_to_tensor_index)
  {
    const auto op_index = p.first;
    const auto max_value = p.second;
 
    uint16_t cur_value = 2;
    op_index_to_all_possible_ranks[op_index] = {ALL, ONLY_BIAS};
    while (cur_value < uint32_t(OpTrainableRank::MAX_VALUE) and cur_value <= max_value)
    {
      auto new_value = cur_value * 2;
      while (cur_value < uint16_t(OpTrainableRank::MAX_VALUE) and cur_value < new_value)
      {
        op_index_to_all_possible_ranks[op_index].insert(cur_value);
        cur_value++;
      }
    }
  }
  // Get all op indices
  std::vector<uint16_t> indices(selected_op_indexes.begin(), selected_op_indexes.end());
  std::vector<std::vector<uint16_t>> rank_combinations;
  std::vector<uint16_t> cur_v;
  generateRankCombinations(op_index_to_all_possible_ranks, indices, 0, cur_v, rank_combinations);
 
  for (const auto &ranks : rank_combinations)
  {
    std::unordered_map<uint16_t, OpTrainableRank> combination;
    for (size_t i = 0; i < indices.size(); ++i)
    {
      combination[indices[i]] = OpTrainableRank(ranks[i]);
    }
    result.push_back(std::move(combination));
  }
 
  return result;
}

References training_configure_tool::TrainData::circle_model_path, onert_micro::Ok, onert_micro::core::reader::OMCircleReader::parse(), readFile(), and onert_micro::core::reader::OMCircleReader::select_subgraph().

Referenced by findBestSparseBackpropagationTensorsRanks().

findAllTrainableOps()

std::unordered_set< uint16_t > training_configure_tool::findAllTrainableOps

(

const char *

circle_model_path

)

Definition at line 276 of file SparseBackpropagationHelper.cpp.

{
  std::unordered_set<uint16_t> result;
 
  training_configure_tool::DataBuffer model_ptr =
    training_configure_tool::readFile(circle_model_path);
 
  // Init reader
  OMStatus status = Ok;
  core::reader::OMCircleReader reader;
  assert(model_ptr.data() != nullptr);
  status = reader.parse(model_ptr.data());
  assert(status == Ok);
  // return empty set
  if (status != Ok)
    return result;
  // TODO: support multi subgraph models
  status = reader.select_subgraph(0);
  // return empty set
  if (status != Ok)
    return result;
 
  // Read ops
  auto operators = reader.operators();
  assert(operators != nullptr);
 
  auto op_size = operators->size();
 
  // Obtain operation codes
  auto op_codes = reader.opcodes();
 
  // Run through all ops
  for (uint32_t i = 0; i < op_size; ++i)
  {
    auto cur_op = operators->operator[](i);
 
    // Get opcode index
    uint32_t cur_opcode_index = cur_op->opcode_index();
    assert(cur_opcode_index < op_codes->size());
 
    const auto opcode = op_codes->operator[](cur_opcode_index);
 
    // If op is trainable - insert it
    if (isTrainableWeights(opcode))
      result.insert(static_cast<uint16_t>(i));
  }
 
  return result;
}

References onert_micro::Ok, onert_micro::core::reader::OMCircleReader::opcodes(), onert_micro::core::reader::OMCircleReader::operators(), onert_micro::core::reader::OMCircleReader::parse(), readFile(), onert_micro::core::reader::OMCircleReader::select_subgraph(), and size.

Referenced by findBestTrainableOpIndexes().

findBestSparseBackpropagationTensorsRanks()

OMStatus training_configure_tool::findBestSparseBackpropagationTensorsRanks	(	onert_micro::OMConfig &	config,
		TrainData &	train_data,
		const std::unordered_set< uint16_t > &	selected_op_indexes,
		std::unordered_map< uint16_t, OpTrainableRank > &	best_train_ranks
	)

Definition at line 35 of file TensorRankSparseBackpropagationHandler.cpp.

{
  // Clear to find best values
  best_train_ranks.clear();
 
  // 1 - Find All combinations with ranks for current selected op indexes
  // 2 - Run all of them to find best variant
 
  // 1 - Find All combinations with ranks for current selected op indexes
  std::vector<std::unordered_map<uint16_t, OpTrainableRank>> all_combinations =
    findAllTensorsRanksCombinations(selected_op_indexes, config, train_data);
 
#if PRINT
  printf("All combinations: op_index : rank_value; { \n");
  for (const auto &combination : all_combinations)
  {
    for (auto &p : combination)
    {
      printf("(%d : %d); ", p.first, p.second);
    }
    printf("\n");
  }
  printf("}\n");
 
#endif // PRINT
 
  // 2 - Run all of them to find best variant
  TrainResult best_train_result(train_data);
  for (const auto &combination : all_combinations)
  {
#if PRINT
    printf("Current checked combination: op_index : rank_value; { ");
    for (auto &p : combination)
    {
      printf("(%d : %d); ", p.first, p.second);
    }
    printf("}\n");
#endif
 
    std::vector<char> tmp_buffer;
    // Create data with current buffer information
    createResultData({combination}, tmp_buffer);
    config.training_context.training_config_info_data = tmp_buffer.data();
 
    TrainResult train_result(train_data);
    // Run train with this information
    runTrainProcessWithCurConfig(config, train_data, train_result);
 
#if PRINT
    printf("Find the following result:\n");
    if (train_result.best_metrics_results.first == CROSS_ENTROPY_METRICS)
    {
      printf("CROSS_ENTROPY_METRIC = %f\n", train_result.best_metrics_results.second);
      printf("PEAK_MEMORY_RESULT = %zu\n", train_result.peak_memory_footprint);
    }
#endif
 
    // Compare with best result to find best
    bool cmp_result = cmpTrainResults(train_result, best_train_result, train_data.acceptable_diff);
    if (cmp_result)
    {
      // Cur rest is better
#if PRINT
      printf("BETTER RESULT\n");
#endif
      best_train_result = train_result;
      best_train_ranks = combination;
    }
  }
 
#if PRINT
  printf("FINISH\n");
 
  printf("Best rank combination: op_index : rank_value; { ");
  for (auto &p : best_train_ranks)
  {
    printf("(%d : %d); ", p.first, p.second);
  }
  printf("}\n");
 
  printf("Find the following result:\n");
  if (best_train_result.best_metrics_results.first == CROSS_ENTROPY_METRICS)
  {
    printf("CROSS_ENTROPY_METRIC = %f\n", best_train_result.best_metrics_results.second);
    printf("PEAK_MEMORY_RESULT = %zu\n", best_train_result.peak_memory_footprint);
  }
#endif
 
  return Ok;
}

References training_configure_tool::TrainData::acceptable_diff, training_configure_tool::TrainResult::best_metrics_results, cmpTrainResults(), createResultData(), onert_micro::CROSS_ENTROPY_METRICS, findAllTensorsRanksCombinations(), onert_micro::Ok, training_configure_tool::TrainResult::peak_memory_footprint, and runTrainProcessWithCurConfig().

Referenced by entry().

findBestTrainableOpIndexes()

OMStatus training_configure_tool::findBestTrainableOpIndexes	(	onert_micro::OMConfig &	config,
		training_configure_tool::TrainData &	train_data,
		std::unordered_set< uint16_t > &	best_trainable_op_indexes
	)

Definition at line 30 of file SparseBackpropagationHandler.cpp.

{
  // Clear to find best values
  best_trainable_op_indexes.clear();
  // 1 - Find all trainable ops indexes in the model - initial_train_op_indexes
  // 2 - Generate all possible sets from initial_train_op_indexes
  // 3 - If above memory restriction is defined - then remove operations indexes sets with peak
  // memory footprint greater then given restriction 4 - Try all found sets to find best metrics
  // results
 
  // 1 - Find all trainable ops indexes in the model - initial_train_op_indexes
  std::unordered_set<uint16_t> initial_train_op_indexes =
    training_configure_tool::findAllTrainableOps(train_data.circle_model_path);
  assert(!initial_train_op_indexes.empty());
  if (initial_train_op_indexes.empty())
    return UnknownError;
#if PRINT
  printf("Found next trainable indexes in the model: ");
  for (auto i : initial_train_op_indexes)
  {
    printf("%d ", i);
  }
  printf("\n");
#endif
 
  // 2 - Generate all possible sets from initial_train_op_indexes
  std::vector<std::unordered_set<uint16_t>> all_possible_train_op_indexes_sets =
    training_configure_tool::generateAllPossibleOpIndexesSets(initial_train_op_indexes);
  assert(all_possible_train_op_indexes_sets.empty() == false);
  if (all_possible_train_op_indexes_sets.empty() == true)
    return UnknownError;
#if PRINT
  printf("Found %zu unique trainable ops indexes in the model:\n",
         all_possible_train_op_indexes_sets.size());
  for (const auto &s : all_possible_train_op_indexes_sets)
  {
    printf("Op indexes set = { ");
    for (auto i : s)
    {
      printf("%d ", i);
    }
    printf("}\n");
  }
#endif
  // Clear initial due to is not needed
  initial_train_op_indexes.clear();
 
  // 3 - If above memory restriction is defined, then save only sets with peak memory less then
  // restriction
  std::vector<std::unordered_set<uint16_t>> selected_op_indexes_sets =
    training_configure_tool::selectOpIndexesSetsAccordingToMemoryRestriction(
      all_possible_train_op_indexes_sets, config, train_data);
#if PRINT
  printf("Found %zu selected op indexes sets:\n", selected_op_indexes_sets.size());
  for (const auto &s : selected_op_indexes_sets)
  {
    printf("Op indexes set = { ");
    for (auto i : s)
    {
      printf("%d ", i);
    }
    printf("}\n");
  }
#endif
  // Clear not needed object
  all_possible_train_op_indexes_sets.clear();
 
  // 4 - Try all found sets to find best metrics results
  // To save best values
  TrainResult best_train_result(train_data);
  for (const auto &index_set : selected_op_indexes_sets)
  {
#if PRINT
    printf("Current checked op indexes set = { ");
    for (auto i : index_set)
    {
      printf("%d ", i);
    }
    printf("}\n");
#endif
 
    // Construct mapping with current indexes - use default train ALL parts
    std::unordered_map<uint16_t, OpTrainableRank> train_op_ranks;
    for (auto index : index_set)
    {
      train_op_ranks[index] = ALL;
    }
 
    std::vector<char> tmp_buffer;
    // Create data with current buffer information
    createResultData({train_op_ranks}, tmp_buffer);
    config.training_context.training_config_info_data = tmp_buffer.data();
 
    TrainResult train_result(train_data);
    // Run train with this information
    runTrainProcessWithCurConfig(config, train_data, train_result);
 
#if PRINT
    printf("Find the following result:\n");
    if (train_result.best_metrics_results.first == CROSS_ENTROPY_METRICS)
    {
      printf("CROSS_ENTROPY_METRIC = %f\n", train_result.best_metrics_results.second);
      printf("PEAK_MEMORY_RESULT = %zu\n", train_result.peak_memory_footprint);
    }
#endif
 
    // Compare with best result to find best
    bool cmp_result = cmpTrainResults(train_result, best_train_result, train_data.acceptable_diff);
    if (cmp_result)
    {
      // Cur rest is better
#if PRINT
      printf("BETTER RESULT\n");
#endif
      best_train_result = train_result;
      best_trainable_op_indexes = index_set;
    }
  }
 
#if PRINT
  printf("FINISH\n");
 
  printf("Best op indexes set = { ");
  for (auto i : best_trainable_op_indexes)
  {
    printf("%d ", i);
  }
  printf("}\n");
 
  printf("Find the following result:\n");
  if (best_train_result.best_metrics_results.first == CROSS_ENTROPY_METRICS)
  {
    printf("CROSS_ENTROPY_METRIC = %f\n", best_train_result.best_metrics_results.second);
    printf("PEAK_MEMORY_RESULT = %zu\n", best_train_result.peak_memory_footprint);
  }
#endif
 
  return Ok;
}

References training_configure_tool::TrainData::acceptable_diff, training_configure_tool::TrainResult::best_metrics_results, training_configure_tool::TrainData::circle_model_path, cmpTrainResults(), createResultData(), onert_micro::CROSS_ENTROPY_METRICS, findAllTrainableOps(), generateAllPossibleOpIndexesSets(), onert_micro::Ok, training_configure_tool::TrainResult::peak_memory_footprint, runTrainProcessWithCurConfig(), selectOpIndexesSetsAccordingToMemoryRestriction(), and onert_micro::UnknownError.

Referenced by entry().

generateAllPossibleOpIndexesSets()

std::vector< std::unordered_set< uint16_t > > training_configure_tool::generateAllPossibleOpIndexesSets

(

const std::unordered_set< uint16_t > &

initial_train_op_indexes

)

Definition at line 261 of file SparseBackpropagationHelper.cpp.

{
  std::vector<std::unordered_set<uint16_t>> result;
  std::unordered_set<uint16_t> cur_set;
 
  auto begin_it = initial_train_op_indexes.begin();
  auto end_it = initial_train_op_indexes.end();
  recursiveGenerateAllPossibleOpIndexesSetsHelper(result, cur_set, begin_it, end_it);
 
  return result;
}

Referenced by findBestTrainableOpIndexes().

readDataFromFile()

void training_configure_tool::readDataFromFile	(	const std::string &	filename,
		char *	data,
		size_t	data_size,
		size_t	start_position = 0
	)

Definition at line 76 of file TrainingConfigureFileHandler.cpp.

{
  std::streampos start = start_position;
 
  std::ifstream fs(filename, std::ifstream::binary);
  if (fs.fail())
    throw std::runtime_error("Cannot open file \"" + filename + "\".\n");
 
  fs.seekg(start);
 
  if (fs.read(data, data_size).fail())
    throw std::runtime_error("Failed to read data from file \"" + filename + "\".\n");
  fs.close();
}

Referenced by runTrainProcessWithCurConfig().

readFile()

training_configure_tool::DataBuffer training_configure_tool::readFile

(

const char *

path

)

Definition at line 104 of file TrainingConfigureFileHandler.cpp.

{
  std::ifstream file(path, std::ios::binary | std::ios::in);
  if (!file.good())
  {
    std::string errmsg = "Failed to open file";
    throw std::runtime_error(errmsg.c_str());
  }
 
  file.seekg(0, std::ios::end);
  auto fileSize = file.tellg();
  file.seekg(0, std::ios::beg);
 
  // reserve capacity
  DataBuffer model_data(fileSize);
 
  // read the data
  file.read(model_data.data(), fileSize);
  if (file.fail())
  {
    std::string errmsg = "Failed to read file";
    throw std::runtime_error(errmsg.c_str());
  }
 
  return model_data;
}

Referenced by findAllTensorsRanksCombinations(), findAllTrainableOps(), and runTrainProcessWithCurConfig().

runTrainProcessWithCurConfig()

OMStatus training_configure_tool::runTrainProcessWithCurConfig	(	onert_micro::OMConfig &	config,
		const training_configure_tool::TrainData &	train_data,
		TrainResult &	train_result
	)

Definition at line 40 of file TrainingDriverHandler.cpp.

{
  // Clear previous results
  train_result.peak_memory_footprint = 0;
 
  training_configure_tool::DataBuffer circle_model =
    training_configure_tool::readFile(train_data.circle_model_path);
  training_configure_tool::DataBuffer wof_data;
  // If defined wof file
  if (train_data.wof_file_path != nullptr)
    wof_data = training_configure_tool::readFile(train_data.wof_file_path);
 
  // Save model size and model ptr in config
  config.model_size = circle_model.size();
  config.model_ptr = circle_model.data();
 
  // If defined wof file
  if (train_data.wof_file_path != nullptr)
    config.wof_ptr = nullptr;
 
  config.train_mode = true;
 
  // Create training interpreter and import models
  onert_micro::OMTrainingInterpreter train_interpreter;
  train_interpreter.importTrainModel(config.model_ptr, config);
 
  const auto batch_size = config.training_context.batch_size;
  // TODO: support more inputs
  const auto input_size = train_interpreter.getInputSizeAt(0);
  const auto output_size = train_interpreter.getOutputSizeAt(0);
 
  // Temporary buffer to read input data from file using BATCH_SIZE
  float training_input[batch_size * input_size];
  float training_target[batch_size * output_size];
  // Note: here test size used with BATCH_SIZE = 1
  float test_input[input_size];
  float test_target[output_size];
 
  // Best results
  float max_accuracy = std::numeric_limits<float>::min();
  float min_mse = std::numeric_limits<float>::max();
  float min_mae = std::numeric_limits<float>::max();
  float min_entropy = std::numeric_limits<float>::max();
 
  const auto training_epochs = config.training_context.epochs;
  for (uint32_t e = 0; e < training_epochs; ++e)
  {
#if PRINT
    printf("Epoch: %d/%d\n", e + 1, training_epochs);
#endif
    std::vector<float> accuracy_v;
    std::vector<float> cross_entropy_v;
    std::vector<float> mse_v;
    std::vector<float> mae_v;
 
    // Run train for current epoch
    config.training_context.num_epoch = e + 1;
    uint32_t num_steps = train_data.num_train_data_samples / batch_size;
    for (int i = 0; i < num_steps; ++i)
    {
      uint32_t cur_batch_size =
        std::min(batch_size, train_data.num_train_data_samples - batch_size * i - 1);
      cur_batch_size = std::max(1u, cur_batch_size);
 
      config.training_context.batch_size = cur_batch_size;
 
      // Read current input and target data
      training_configure_tool::readDataFromFile(train_data.input_input_train_data_path,
                                                reinterpret_cast<char *>(training_input),
                                                sizeof(float) * input_size * cur_batch_size,
                                                i * sizeof(MODEL_TYPE) * input_size * batch_size);
 
      training_configure_tool::readDataFromFile(train_data.input_target_train_data_path,
                                                reinterpret_cast<char *>(training_target),
                                                sizeof(float) * output_size * cur_batch_size,
                                                i * sizeof(MODEL_TYPE) * output_size * batch_size);
 
      // Set input and target
      train_interpreter.setInput(reinterpret_cast<uint8_t *>(training_input), 0);
      train_interpreter.setTarget(reinterpret_cast<uint8_t *>(training_target), 0);
 
      // Train with current batch size
      train_interpreter.trainSingleStep(config);
    }
 
    train_interpreter.reset();
 
    // Reset num step value
    config.training_context.num_step = 0;
    num_steps = train_data.num_test_data_samples;
 
    accuracy_v.clear();
    cross_entropy_v.clear();
    mae_v.clear();
    mse_v.clear();
 
    if (train_data.metrics_to_check_best_config == NONE)
      continue;
 
    for (int i = 0; i < num_steps; ++i)
    {
      uint32_t cur_batch_size = 1;
      training_configure_tool::readDataFromFile(
        train_data.input_input_test_data_path, reinterpret_cast<char *>(test_input),
        sizeof(float) * input_size * cur_batch_size, i * sizeof(MODEL_TYPE) * input_size);
 
      training_configure_tool::readDataFromFile(
        train_data.input_target_test_data_path, reinterpret_cast<char *>(test_target),
        sizeof(float) * output_size * cur_batch_size, i * sizeof(MODEL_TYPE) * output_size);
 
      train_interpreter.setInput(reinterpret_cast<uint8_t *>(test_input), 0);
      train_interpreter.setTarget(reinterpret_cast<uint8_t *>(test_target), 0);
 
      switch (train_data.metrics_to_check_best_config)
      {
        case onert_micro::CROSS_ENTROPY_METRICS:
        {
          float cross_entropy_metric = 0.f;
          train_interpreter.evaluateMetric(config, onert_micro::CROSS_ENTROPY_METRICS,
                                           reinterpret_cast<void *>(&cross_entropy_metric),
                                           cur_batch_size);
          cross_entropy_v.push_back(cross_entropy_metric);
        }
        break;
        case onert_micro::ACCURACY:
        {
          float accuracy = 0.f;
          train_interpreter.evaluateMetric(config, onert_micro::ACCURACY,
                                           reinterpret_cast<void *>(&accuracy), cur_batch_size);
          accuracy_v.push_back(accuracy);
        }
        break;
        case onert_micro::MSE_METRICS:
        {
          float mse = 0.f;
          train_interpreter.evaluateMetric(config, onert_micro::MSE_METRICS,
                                           reinterpret_cast<void *>(&mse), cur_batch_size);
          mse_v.push_back(mse);
        }
        break;
        case onert_micro::MAE_METRICS:
        {
          float mae = 0.f;
          train_interpreter.evaluateMetric(config, onert_micro::MAE_METRICS,
                                           reinterpret_cast<void *>(&mae), cur_batch_size);
          mae_v.push_back(mae);
        }
        break;
        default:
        {
          assert(false && "Not supported");
          return UnsupportedType;
        }
      }
    }
 
    // Calculate and use average values
    switch (train_data.metrics_to_check_best_config)
    {
      case onert_micro::CROSS_ENTROPY_METRICS:
      {
        auto average_value = findAverage(cross_entropy_v);
        if (average_value < min_entropy)
          min_entropy = average_value;
      }
      break;
      case onert_micro::ACCURACY:
      {
        auto average_value = findAverage(accuracy_v);
        if (average_value > max_accuracy)
          max_accuracy = average_value;
      }
      break;
      case onert_micro::MSE_METRICS:
      {
        auto average_value = findAverage(mse_v);
        if (average_value < min_mse)
          min_mse = average_value;
      }
      break;
      case onert_micro::MAE_METRICS:
      {
        auto average_value = findAverage(mae_v);
        if (average_value < min_mae)
          min_mae = average_value;
      }
      break;
      default:
      {
        assert(false && "Not supported");
        return UnsupportedType;
      }
    }
  }
  train_result.peak_memory_footprint = train_interpreter.getPeakFootprintMemory();
  switch (train_data.metrics_to_check_best_config)
  {
    case onert_micro::CROSS_ENTROPY_METRICS:
    {
      train_result.best_metrics_results = {train_data.metrics_to_check_best_config, min_entropy};
    }
    break;
    case onert_micro::ACCURACY:
    {
      train_result.best_metrics_results = {train_data.metrics_to_check_best_config, max_accuracy};
    }
    break;
    case onert_micro::MSE_METRICS:
    {
      train_result.best_metrics_results = {train_data.metrics_to_check_best_config, min_mse};
    }
    break;
    case onert_micro::MAE_METRICS:
    {
      train_result.best_metrics_results = {train_data.metrics_to_check_best_config, min_mae};
    }
    break;
    case onert_micro::NONE:
    {
      break;
    }
    default:
    {
      assert(false && "Not supported");
      return UnsupportedType;
    }
  }
  return Ok;
}

References onert_micro::ACCURACY, training_configure_tool::TrainResult::best_metrics_results, training_configure_tool::TrainData::circle_model_path, onert_micro::CROSS_ENTROPY_METRICS, onert_micro::OMTrainingInterpreter::evaluateMetric(), onert_micro::OMTrainingInterpreter::getInputSizeAt(), onert_micro::OMTrainingInterpreter::getOutputSizeAt(), onert_micro::OMTrainingInterpreter::importTrainModel(), training_configure_tool::TrainData::input_input_test_data_path, training_configure_tool::TrainData::input_input_train_data_path, training_configure_tool::TrainData::input_target_test_data_path, training_configure_tool::TrainData::input_target_train_data_path, onert_micro::MAE_METRICS, training_configure_tool::TrainData::metrics_to_check_best_config, MODEL_TYPE, onert_micro::MSE_METRICS, onert_micro::NONE, training_configure_tool::TrainData::num_test_data_samples, training_configure_tool::TrainData::num_train_data_samples, onert_micro::Ok, training_configure_tool::TrainResult::peak_memory_footprint, readDataFromFile(), readFile(), onert_micro::OMTrainingInterpreter::reset(), onert_micro::OMTrainingInterpreter::setInput(), onert_micro::OMTrainingInterpreter::setTarget(), onert_micro::OMTrainingInterpreter::trainSingleStep(), onert_micro::UnsupportedType, and training_configure_tool::TrainData::wof_file_path.

Referenced by findBestSparseBackpropagationTensorsRanks(), findBestTrainableOpIndexes(), and selectOpIndexesSetsAccordingToMemoryRestriction().

selectOpIndexesSetsAccordingToMemoryRestriction()

std::vector< std::unordered_set< uint16_t > > training_configure_tool::selectOpIndexesSetsAccordingToMemoryRestriction	(	const std::vector< std::unordered_set< uint16_t > > &	op_indexes_sets,
		onert_micro::OMConfig	config,
		training_configure_tool::TrainData	train_data
	)

Definition at line 198 of file SparseBackpropagationHelper.cpp.

{
  // It 0 - then is not set
  if (train_data.memory_above_restriction == 0)
  {
    return op_indexes_sets;
  }
 
  std::vector<std::unordered_set<uint16_t>> result;
 
  // To obtain real estimation we need minimum batch_size = 2 and num_train_data_samples = 4
  // Change config train and test sample values
  train_data.num_test_data_samples = 0;
  train_data.num_train_data_samples = std::min(4, train_data.num_train_data_samples);
  // To disable tests
  train_data.metrics_to_check_best_config = NONE;
  // Set number of the epochs and batch size to one
  config.training_context.epochs = 1;
  config.training_context.batch_size = std::min(2u, config.training_context.batch_size);
 
  for (const auto &op_indexes_set : op_indexes_sets)
  {
#if PRINT
    printf("Start checking: { ");
    for (auto i : op_indexes_set)
    {
      printf("%d ", i);
    }
    printf("}\n");
#endif
    // Construct mapping with current indexes - use default train ALL parts
    std::unordered_map<uint16_t, OpTrainableRank> train_op_ranks;
    for (auto index : op_indexes_set)
    {
      train_op_ranks[index] = ALL;
    }
 
    std::vector<char> tmp_buffer;
    // Create data with current buffer information
    createResultData({train_op_ranks}, tmp_buffer);
    config.training_context.training_config_info_data = tmp_buffer.data();
 
    TrainResult train_result;
    // Run train with this information
    runTrainProcessWithCurConfig(config, train_data, train_result);
#if PRINT
    printf("CURRENT MEMORY PEAK = %zu\n", train_result.peak_memory_footprint);
#endif
    if (train_result.peak_memory_footprint < train_data.memory_above_restriction)
    {
#if PRINT
      printf("Added to the result\n");
#endif
      result.push_back(op_indexes_set);
    }
  }
 
  return result;
}

References createResultData(), training_configure_tool::TrainData::memory_above_restriction, training_configure_tool::TrainData::metrics_to_check_best_config, onert_micro::NONE, training_configure_tool::TrainData::num_test_data_samples, training_configure_tool::TrainData::num_train_data_samples, training_configure_tool::TrainResult::peak_memory_footprint, and runTrainProcessWithCurConfig().

Referenced by findBestTrainableOpIndexes().

writeDataToFile()

void training_configure_tool::writeDataToFile	(	const std::string &	filename,
		const char *	data,
		size_t	data_size
	)

Definition at line 92 of file TrainingConfigureFileHandler.cpp.

{
  std::ofstream fs(filename, std::ofstream::binary);
  if (fs.fail())
    throw std::runtime_error("Cannot open file \"" + filename + "\".\n");
  if (fs.write(data, data_size).fail())
  {
    throw std::runtime_error("Failed to write data to file \"" + filename + "\".\n");
  }
}