onert_micro::train::optimizers::SGD Class Reference

#include <SGD.h>

Public Member Functions
	SGD ()=default
	SGD (const SGD &)=delete
	SGD (SGD &&)=delete
SGD &	operator= (const SGD &)=delete
SGD &&	operator= (const SGD &&)=delete
	~SGD ()
void	reset ()
OMStatus	handle (core::OMRuntimeStorage &backward_storage, core::OMRuntimeContext &context, core::OMRuntimeStorage &storage)
OMStatus	updateWeights (const OMTrainingContext &training_config, core::OMRuntimeContext &context, core::OMRuntimeStorage &storage, std::unordered_map< uint16_t, core::OpTrainableRankType > &tensor_index_to_rank_type_map)

Detailed Description

Definition at line 37 of file SGD.h.

Constructor & Destructor Documentation

SGD() [1/3]

onert_micro::train::optimizers::SGD::SGD ( )

default

SGD() [2/3]

onert_micro::train::optimizers::SGD::SGD ( const SGD &  )

delete

SGD() [3/3]

onert_micro::train::optimizers::SGD::SGD ( SGD &&  )

delete

~SGD()

onert_micro::train::optimizers::SGD::~SGD ( )

inline

Definition at line 49 of file SGD.h.

{ reset(); }

References reset().

Member Function Documentation

handle()

OMStatus SGD::handle	(	core::OMRuntimeStorage &	backward_storage,
		core::OMRuntimeContext &	context,
		core::OMRuntimeStorage &	storage
	)

Definition at line 94 of file SGD.cpp.

{
  auto &backward_tensor_to_data = backward_storage.getTensorIndexToData();
  // Check is allocated or not helper buffers
  if (_tensor_index_to_gradient.empty())
  {
    // If not - let's just move it with calculations
    // Goes over all calculated gradients
    // Warning: assume that backward storage at this moment contains only weigths gradients -
    // This should be done due to execution plan work
    for (auto &tensor_to_data : backward_tensor_to_data)
    {
      // Move data
      _tensor_index_to_gradient[tensor_to_data.first] = tensor_to_data.second;
      tensor_to_data.second = nullptr;
    }
    backward_tensor_to_data.clear();
  }
  else
  {
    // Goes over all calculated gradients
    // Warning: assume that backward storage at this moment contains only weigths gradients -
    // This should be done due to execution plan work
    for (auto &tensor_to_data : backward_tensor_to_data)
    {
      auto tensor = context.getTensorByIndex(tensor_to_data.first);
      auto num_elements = core::OMRuntimeShape(tensor).flatSize();
 
#ifndef DIS_DYN_SHAPES
      int32_t dynamic_tensor_size = storage.getDynamicRuntimeShape(tensor_to_data.first).flatSize();
      if (dynamic_tensor_size != 0)
        num_elements = dynamic_tensor_size;
#endif // DIS_DYN_SHAPES
 
      auto *grad_data = reinterpret_cast<float *>(_tensor_index_to_gradient[tensor_to_data.first]);
      auto *calculated_data = reinterpret_cast<float *>(tensor_to_data.second);
 
      for (uint32_t i = 0; i < num_elements; ++i)
      {
        grad_data[i] += calculated_data[i];
      }
    }
  }
 
  return Ok;
}

References onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::core::OMRuntimeStorage::getDynamicRuntimeShape(), onert_micro::core::OMRuntimeContext::getTensorByIndex(), onert_micro::core::OMRuntimeStorage::getTensorIndexToData(), and onert_micro::Ok.

operator=() [1/2]

SGD && onert_micro::train::optimizers::SGD::operator= ( const SGD &&  )

delete

operator=() [2/2]

SGD & onert_micro::train::optimizers::SGD::operator= ( const SGD &  )

delete

reset()

void SGD::reset

(

)

Definition at line 79 of file SGD.cpp.

{
  for (auto &cur_tensor_index_data : _tensor_index_to_gradient)
  {
    uint8_t *allocated_data = cur_tensor_index_data.second;
 
    core::memory::OMMemoryManager::deallocateMemory(allocated_data);
  }
  _tensor_index_to_gradient.clear();
}

References onert_micro::core::memory::OMMemoryManager::deallocateMemory().

Referenced by ~SGD().

updateWeights()

OMStatus SGD::updateWeights	(	const OMTrainingContext &	training_config,
		core::OMRuntimeContext &	context,
		core::OMRuntimeStorage &	storage,
		std::unordered_map< uint16_t, core::OpTrainableRankType > &	tensor_index_to_rank_type_map
	)

Definition at line 147 of file SGD.cpp.

{
  assert(!_tensor_index_to_gradient.empty());
  if (_tensor_index_to_gradient.empty())
    return UnknownError;
 
  for (auto &tensor_to_data : _tensor_index_to_gradient)
  {
    auto tensor = context.getTensorByIndex(tensor_to_data.first);
    core::OMRuntimeShape shape(tensor);
    auto num_elements = shape.flatSize();
 
    auto original_d = shape.dims(0);
 
#ifndef DIS_DYN_SHAPES
    int32_t dynamic_tensor_size = storage.getDynamicRuntimeShape(tensor_to_data.first).flatSize();
    if (dynamic_tensor_size != 0)
      num_elements = dynamic_tensor_size;
#endif // DIS_DYN_SHAPES
 
    auto *grad_data = reinterpret_cast<float *>(tensor_to_data.second);
    uint8_t *weight_data = nullptr;
    if (context.getConstDataByTensorIndex(&weight_data, tensor_to_data.first) != Ok)
      return UnknownError;
 
    assert(weight_data != nullptr);
    if (weight_data == nullptr)
      return UnknownError;
 
    auto *f_weight_data = reinterpret_cast<float *>(weight_data);
    float lambda = training_config.learning_rate;
    const uint32_t batch_size = training_config.batch_size;
    auto train_it = tensor_index_to_rank_type_map.find(tensor_to_data.first);
    core::OpTrainableRankType rank = train_it == tensor_index_to_rank_type_map.end()
                                       ? core::OpTrainableRankType::ALL
                                       : core::OpTrainableRankType(train_it->second);
    auto depth_bounds = getUpLowerWeightTensorDepth(rank, original_d);
 
    assert(batch_size != 0);
 
    for (uint32_t i = 0; i < num_elements; ++i)
    {
      f_weight_data[i] -= (lambda * grad_data[i]) / (static_cast<float>(batch_size));
    }
  }
  return Ok;
}

References onert_micro::core::ALL, onert_micro::OMTrainingContext::batch_size, onert_micro::core::OMRuntimeShape::dims(), onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::core::OMRuntimeContext::getConstDataByTensorIndex(), onert_micro::core::OMRuntimeStorage::getDynamicRuntimeShape(), onert_micro::core::OMRuntimeContext::getTensorByIndex(), onert_micro::OMTrainingContext::learning_rate, onert_micro::Ok, and onert_micro::UnknownError.

---

The documentation for this class was generated from the following files:

• onert-micro/onert-micro/include/train/train_optimizers/SGD.h
• onert-micro/onert-micro/src/train/train_optimizers/SGD.cpp