onert_micro::train::pal Namespace Reference

Functions
void	Conv2DInputGrad (const core::FloatConv2D &params, const core::OMRuntimeShape &weight_shape, const float *weight_data, const core::OMRuntimeShape &dloss_doutput_shape, const float *dloss_doutput_data, const core::OMRuntimeShape &dloss_dinput_shape, float *dloss_dinput_data)
void	Conv2DBiasGrad (const core::OMRuntimeShape &dloss_doutput_shape, const float *dloss_doutput_data, float *dloss_dbias_data)
void	Conv2DWeightGrad (const core::FloatConv2D &params, const core::OMRuntimeShape &input_shape, const float *input_data, const core::OMRuntimeShape &dloss_doutput_shape, const float *dloss_doutput_data, const core::OMRuntimeShape &dloss_dweight_shape, float *dloss_dweight_data, core::OpTrainableRankType rank)
void	FullyConnectedInputGrad (const float *dloss_doutput_data, const core::OMRuntimeShape &dloss_doutput_shape, const float *weight_data, const core::OMRuntimeShape &weight_shape, float *dloss_dinput_data)
void	FullyConnectedWeightGrad (const float *dloss_doutput_data, const core::OMRuntimeShape &dloss_doutput_shape, const float *input_data, const core::OMRuntimeShape &input_shape, float *dloss_dweight_data, const core::OMRuntimeShape &weight_shape, core::OpTrainableRankType rank)
OMStatus	GRUWeightGrads (const float *output_grad_data, const float *weight_input_data, float *weight_input_grad_data, const float *weight_hidden_data, float *weight_hidden_grad_data, const float *bias_input_data, float *bias_input_grad_data, const float *bias_hidden_data, float *bias_hidden_grad_data, const float *input_data, float *input_grad_data, float *state_grad_data, const core::OMRuntimeShape &input_shape, const core::OMRuntimeShape &output_shape, const core::OMRuntimeShape &weight_input_shape, const core::OMRuntimeShape &weight_hidden_shape, const core::OMRuntimeShape &output_shape_fc, float *intermediate_buffer, float *left_fc_output_grad_buffer, float *right_fc_output_grad_buffer)
void	MaxPool2D (const core::Pool2DParams &params, const core::OMRuntimeShape &input_shape, const float *input_data, const core::OMRuntimeShape &dloss_doutput_shape, const float *dloss_doutput_data, float *dloss_dinput_data)
void	ReluInputGrad (const float *input_relu_data, float *dloss_doutput_data, const core::OMRuntimeShape &dloss_doutput_shape)
void	SoftmaxInputGrad (const float *dloss_doutput_data, const core::OMRuntimeShape &dloss_doutput_shape, const float *calculated_data, float *jacobian_row_data, float *dloss_dinput_data)

Function Documentation

Conv2DBiasGrad()

void onert_micro::train::pal::Conv2DBiasGrad	(	const core::OMRuntimeShape &	dloss_doutput_shape,
		const float *	dloss_doutput_data,
		float *	dloss_dbias_data
	)

Definition at line 31 of file PALConv2DWeightGrad.h.

{
  assert(dloss_doutput_shape.dimensionsCount() == 4);
  assert(dloss_doutput_shape.dims(0) == 1);
  const int dloss_doutput_h = dloss_doutput_shape.dims(1);
  const int dloss_doutput_w = dloss_doutput_shape.dims(2);
  const int dloss_doutput_d = dloss_doutput_shape.dims(3);
 
  // Reduce sum over last dim
  for (uint32_t oc = 0; oc < dloss_doutput_d; ++oc)
  {
    float total = 0.f;
    for (uint32_t h = 0; h < dloss_doutput_h; ++h)
    {
      for (uint32_t w = 0; w < dloss_doutput_w; ++w)
      {
        uint32_t offset = oc + w * dloss_doutput_d + h * dloss_doutput_w * dloss_doutput_d;
        assert(offset < dloss_doutput_shape.flatSize());
        total +=
          dloss_doutput_data[oc + w * dloss_doutput_d + h * dloss_doutput_w * dloss_doutput_d];
      }
    }
    dloss_dbias_data[oc] = total;
  }
}

References onert_micro::core::OMRuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::dims(), onert_micro::core::OMRuntimeShape::flatSize(), and offset().

Conv2DInputGrad()

void onert_micro::train::pal::Conv2DInputGrad	(	const core::FloatConv2D &	params,
		const core::OMRuntimeShape &	weight_shape,
		const float *	weight_data,
		const core::OMRuntimeShape &	dloss_doutput_shape,
		const float *	dloss_doutput_data,
		const core::OMRuntimeShape &	dloss_dinput_shape,
		float *	dloss_dinput_data
	)

Definition at line 60 of file PALConv2DInputGrad.h.

{
  const int stride_width = params.stride_w;
  const int stride_height = params.stride_h;
  const int dilation_width_factor = params.dilation_width_factor;
  const int dilation_height_factor = params.dilation_height_factor;
  const int pad_width = 0;
  const int pad_height = 0;
 
  const int weight_h = weight_shape.dims(1);
  const int weight_w = weight_shape.dims(2);
  const int weight_d = weight_shape.dims(3);
  const int dloss_doutput_h = dloss_doutput_shape.dims(1);
  const int dloss_doutput_w = dloss_doutput_shape.dims(2);
  const int dloss_doutput_d = dloss_doutput_shape.dims(3);
  const int dloss_dinput_h = dloss_dinput_shape.dims(1);
  const int dloss_dinput_w = dloss_dinput_shape.dims(2);
  const int dloss_dinput_d = dloss_dinput_shape.dims(3);
 
  auto *n_c_weight_data = const_cast<float *>(weight_data);
 
  for (uint32_t oc = 0; oc < dloss_dinput_d; ++oc)
  {
    for (uint32_t ic = 0; ic < dloss_doutput_d; ++ic)
    {
      rotate_180(n_c_weight_data, weight_h, weight_w, ic, oc, dloss_dinput_d);
      for (int out_y = 0; out_y < dloss_dinput_h; ++out_y)
      {
        for (int out_x = 0; out_x < dloss_dinput_w; ++out_x)
        {
          const int in_x_origin = (out_x * stride_width) - pad_width;
          const int in_y_origin = (out_y * stride_height) - pad_height;
          float total = 0.f;
 
          for (int filter_y = 0; filter_y < weight_h; ++filter_y)
          {
            for (int filter_x = 0; filter_x < weight_w; ++filter_x)
            {
              const int in_x = in_x_origin + dilation_width_factor * filter_x;
              const int in_y = in_y_origin + dilation_height_factor * filter_y;
              // If the location is outside the bounds of the input image,
              // use zero as a default value.
              if ((in_x >= 0) && (in_x < dloss_doutput_w) && (in_y >= 0) &&
                  (in_y < dloss_doutput_h))
              {
                uint32_t input_offset =
                  in_x * dloss_doutput_d + in_y * dloss_doutput_w * dloss_doutput_d + ic;
                uint32_t filter_offset = oc + filter_x * dloss_dinput_d +
                                         filter_y * weight_w * dloss_dinput_d +
                                         ic * weight_w * dloss_dinput_d * weight_h;
                assert(input_offset < dloss_doutput_shape.flatSize());
                float input_value = dloss_doutput_data[input_offset];
                float filter_value = n_c_weight_data[filter_offset];
                total += (input_value * filter_value);
              }
            }
          }
          uint32_t output_offset =
            oc + dloss_dinput_d * out_x + out_y * dloss_dinput_d * dloss_dinput_w;
          assert(output_offset < dloss_dinput_shape.flatSize());
          dloss_dinput_data[output_offset] = total;
        }
      }
      // Rotate back
      rotate_180(n_c_weight_data, weight_h, weight_w, ic, oc, dloss_dinput_d);
    }
  }
}

References onert_micro::core::FloatConv2D::dilation_height_factor, onert_micro::core::FloatConv2D::dilation_width_factor, onert_micro::core::OMRuntimeShape::dims(), onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::core::FloatConv2D::stride_h, and onert_micro::core::FloatConv2D::stride_w.

Conv2DWeightGrad()

void onert_micro::train::pal::Conv2DWeightGrad	(	const core::FloatConv2D &	params,
		const core::OMRuntimeShape &	input_shape,
		const float *	input_data,
		const core::OMRuntimeShape &	dloss_doutput_shape,
		const float *	dloss_doutput_data,
		const core::OMRuntimeShape &	dloss_dweight_shape,
		float *	dloss_dweight_data,
		core::OpTrainableRankType	rank
	)

Definition at line 58 of file PALConv2DWeightGrad.h.

{
  const int stride_width = params.stride_w;
  const int stride_height = params.stride_h;
  const int dilation_width_factor = params.dilation_width_factor;
  const int dilation_height_factor = params.dilation_height_factor;
  const int pad_width = 0;
  const int pad_height = 0;
 
  const int batches = dloss_doutput_shape.dims(0);
  const int input_h = input_shape.dims(1);
  const int input_w = input_shape.dims(2);
  const int input_d = input_shape.dims(3);
  const int dloss_doutput_h = dloss_doutput_shape.dims(1);
  const int dloss_doutput_w = dloss_doutput_shape.dims(2);
  const int dloss_doutput_d = dloss_doutput_shape.dims(3);
  const int dloss_dweight_h = dloss_dweight_shape.dims(1);
  const int dloss_dweight_w = dloss_dweight_shape.dims(2);
  const int dloss_dweight_d = dloss_dweight_shape.dims(3);
  const int dloss_dweight_o = dloss_dweight_shape.dims(0);
 
  auto depth_bounds = execute::pal::getUpLowerWeightTensorDepth(rank, dloss_doutput_d);
 
  for (uint32_t oc = 0; oc < dloss_dweight_o; ++oc)
  {
    for (uint32_t ic = 0; ic < input_d; ++ic)
    {
      for (int out_y = 0; out_y < dloss_dweight_h; ++out_y)
      {
        for (int out_x = 0; out_x < dloss_dweight_w; ++out_x)
        {
          const int in_x_origin = (out_x * stride_width) - pad_width;
          const int in_y_origin = (out_y * stride_height) - pad_height;
          float total = 0.f;
 
          for (int filter_y = 0; filter_y < dloss_doutput_h; ++filter_y)
          {
            for (int filter_x = 0; filter_x < dloss_doutput_w; ++filter_x)
            {
              const int in_x = in_x_origin + dilation_width_factor * filter_x;
              const int in_y = in_y_origin + dilation_height_factor * filter_y;
              // If the location is outside the bounds of the input image,
              // use zero as a default value.
              if ((in_x >= 0) && (in_x < input_w) && (in_y >= 0) && (in_y < input_h))
              {
                uint32_t input_offset = in_x * input_d + in_y * input_w * input_d + ic;
                uint32_t filter_offset =
                  oc + filter_x * dloss_doutput_d + filter_y * dloss_doutput_w * dloss_doutput_d;
                assert(input_offset < input_shape.flatSize());
                assert(filter_offset < dloss_doutput_shape.flatSize());
                float input_value = input_data[input_offset];
                float filter_value = dloss_doutput_data[filter_offset];
                total += (input_value * filter_value);
              }
            }
          }
          uint32_t output_offset = ic + input_d * out_x + input_d * dloss_dweight_w * out_y +
                                   input_d * dloss_dweight_w * dloss_dweight_h * oc;
          assert(output_offset < dloss_dweight_shape.flatSize());
          dloss_dweight_data[output_offset] = total;
        }
      }
    }
  }
}

References onert_micro::core::FloatConv2D::dilation_height_factor, onert_micro::core::FloatConv2D::dilation_width_factor, onert_micro::core::OMRuntimeShape::dims(), onert_micro::core::OMRuntimeShape::flatSize(), onert_micro::execute::pal::getUpLowerWeightTensorDepth(), onert_micro::core::FloatConv2D::stride_h, and onert_micro::core::FloatConv2D::stride_w.

FullyConnectedInputGrad()

void onert_micro::train::pal::FullyConnectedInputGrad ( const float *  dloss_doutput_data, const core::OMRuntimeShape &  dloss_doutput_shape, const float *  weight_data, const core::OMRuntimeShape &  weight_shape, float *  dloss_dinput_data  )

inline

Definition at line 33 of file PALFullyConnectedInputGrad.h.

{
  const uint32_t input_rows = dloss_doutput_shape.dims(0);
  const uint32_t input_col = weight_shape.dims(1);
  const uint32_t output_cols = dloss_doutput_shape.dims(1);
 
  for (uint32_t i = 0; i < input_rows; ++i)
  {
    for (uint32_t j = 0; j < input_col; ++j)
    {
      float total = 0.f;
      for (uint32_t o = 0; o < output_cols; ++o)
      {
        total += weight_data[o * input_col + j] * dloss_doutput_data[o + i * output_cols];
      }
      dloss_dinput_data[j + i * input_col] = total;
    }
  }
}

References onert_micro::core::OMRuntimeShape::dims().

FullyConnectedWeightGrad()

void onert_micro::train::pal::FullyConnectedWeightGrad ( const float *  dloss_doutput_data, const core::OMRuntimeShape &  dloss_doutput_shape, const float *  input_data, const core::OMRuntimeShape &  input_shape, float *  dloss_dweight_data, const core::OMRuntimeShape &  weight_shape, core::OpTrainableRankType  rank  )

inline

Definition at line 34 of file PALFullyConnectedWeightGrad.h.

{
  const uint32_t batches = input_shape.dims(0);
  const uint32_t output_depth = dloss_doutput_shape.dims(1);
  const uint32_t accum_depth = input_shape.dims(1);
 
  auto depth_bounds = execute::pal::getUpLowerWeightTensorDepth(rank, output_depth);
 
  auto weight_depth = weight_shape.dims(0);
 
  for (uint32_t o = 0; o < weight_depth; ++o)
  {
    float cur_dloss_doutput = dloss_doutput_data[o + depth_bounds.first];
    for (uint32_t i = 0; i < accum_depth; ++i)
    {
      dloss_dweight_data[i + o * accum_depth] += cur_dloss_doutput * input_data[i];
    }
  }
 
  for (int b = 1; b < batches; ++b)
  {
    for (uint32_t o = depth_bounds.first; o < depth_bounds.second; ++o)
    {
      float cur_dloss_doutput = dloss_doutput_data[o + b * output_depth];
      for (uint32_t i = 0; i < accum_depth; ++i)
      {
        dloss_dweight_data[i + o * accum_depth] +=
          cur_dloss_doutput * input_data[i + b * accum_depth];
      }
    }
  }
}

References onert_micro::core::OMRuntimeShape::dims(), and onert_micro::execute::pal::getUpLowerWeightTensorDepth().

GRUWeightGrads()

OMStatus onert_micro::train::pal::GRUWeightGrads	(	const float *	output_grad_data,
		const float *	weight_input_data,
		float *	weight_input_grad_data,
		const float *	weight_hidden_data,
		float *	weight_hidden_grad_data,
		const float *	bias_input_data,
		float *	bias_input_grad_data,
		const float *	bias_hidden_data,
		float *	bias_hidden_grad_data,
		const float *	input_data,
		float *	input_grad_data,
		float *	state_grad_data,
		const core::OMRuntimeShape &	input_shape,
		const core::OMRuntimeShape &	output_shape,
		const core::OMRuntimeShape &	weight_input_shape,
		const core::OMRuntimeShape &	weight_hidden_shape,
		const core::OMRuntimeShape &	output_shape_fc,
		float *	intermediate_buffer,
		float *	left_fc_output_grad_buffer,
		float *	right_fc_output_grad_buffer
	)

Definition at line 130 of file PALGRUWeightGrad.h.

{
  const int32_t time = input_shape.dims(0);
 
  // Init pointers to intermediate values
  size_t offset = output_shape.flatSize();
 
  size_t data_type_size = sizeof(float);
  const int32_t num_of_intermediate_tensors = 9;
  size_t time_offset = num_of_intermediate_tensors * offset;
 
  core::OMRuntimeShape two_dim_input_shape(2);
  auto dim_count = input_shape.dimensionsCount();
  if (dim_count < 2)
    return UnsupportedType;
  two_dim_input_shape.setDim(0, input_shape.dims(dim_count - 2));
  two_dim_input_shape.setDim(1, input_shape.dims(dim_count - 1));
 
  core::OMRuntimeShape two_dim_output_shape(2);
  dim_count = output_shape.dimensionsCount();
  if (dim_count < 2)
    return UnsupportedType;
  two_dim_output_shape.setDim(0, output_shape.dims(dim_count - 2));
  two_dim_output_shape.setDim(1, output_shape.dims(dim_count - 1));
 
  std::memset(weight_input_grad_data, 0, weight_input_shape.flatSize() * sizeof(float));
  std::memset(weight_hidden_grad_data, 0, weight_hidden_shape.flatSize() * sizeof(float));
 
  for (int i = 0; i < time; ++i)
  {
    float *output_data = intermediate_buffer;
    float *left_logistic_data = output_data + offset;
    float *left_mul_data = left_logistic_data + offset;
    float *right_logistic_data = left_mul_data + offset;
    float *right_mul_left_input_data = right_logistic_data + offset;
    float *right_mul_right_input_data = right_mul_left_input_data + offset;
    float *tanh_data = right_mul_right_input_data + offset;
    float *middle_mul_left_input = tanh_data + offset;
    float *middle_mul_right_input = middle_mul_left_input + offset;
 
    calculateGRUWeightGrads(
      output_grad_data, weight_input_data, weight_input_grad_data, weight_hidden_data,
      weight_hidden_grad_data, bias_input_data, bias_input_grad_data, bias_hidden_data,
      bias_hidden_grad_data, input_data, input_grad_data, state_grad_data, two_dim_input_shape,
      output_shape_fc, two_dim_output_shape, weight_input_shape, weight_hidden_shape, output_data,
      left_logistic_data, left_mul_data, right_logistic_data, right_mul_left_input_data,
      right_mul_right_input_data, tanh_data, middle_mul_left_input, middle_mul_right_input,
      left_fc_output_grad_buffer, right_fc_output_grad_buffer);
    input_data += input_shape.dims(2);
    intermediate_buffer += time_offset;
  }
  return Ok;
}

References luci_interpreter::RuntimeShape::dimensionsCount(), onert_micro::core::OMRuntimeShape::dimensionsCount(), luci_interpreter::RuntimeShape::dims(), onert_micro::core::OMRuntimeShape::dims(), luci_interpreter::RuntimeShape::flatSize(), onert_micro::core::OMRuntimeShape::flatSize(), offset(), onert_micro::Ok, output_shape, onert_micro::core::OMRuntimeShape::setDim(), and onert_micro::UnsupportedType.

MaxPool2D()

void onert_micro::train::pal::MaxPool2D ( const core::Pool2DParams &  params, const core::OMRuntimeShape &  input_shape, const float *  input_data, const core::OMRuntimeShape &  dloss_doutput_shape, const float *  dloss_doutput_data, float *  dloss_dinput_data  )

inline

Definition at line 33 of file PALMaxPool2DInputGrad.h.

{
  const int32_t batches = input_shape.dims(0);
  const int32_t depth = dloss_doutput_shape.dims(3);
  const int32_t input_height = input_shape.dims(1);
  const int32_t input_width = input_shape.dims(2);
  const int32_t output_height = dloss_doutput_shape.dims(1);
  const int32_t output_width = dloss_doutput_shape.dims(2);
  const int32_t stride_height = params.stride_h;
  const int32_t stride_width = params.stride_w;
  for (int batch = 0; batch < batches; ++batch)
  {
    for (int out_y = 0; out_y < output_height; ++out_y)
    {
      for (int out_x = 0; out_x < output_width; ++out_x)
      {
        for (int channel = 0; channel < depth; ++channel)
        {
          const int in_x_origin = (out_x * stride_width) - params.pad_w;
          const int in_y_origin = (out_y * stride_height) - params.pad_h;
          // Compute the boundaries of the filter region clamped so as to
          // ensure that the filter window fits in the input array.
          const int filter_x_start = std::max(0, -in_x_origin);
          const int filter_x_end = std::min(params.filter_w, input_width - in_x_origin);
          const int filter_y_start = std::max(0, -in_y_origin);
          const int filter_y_end = std::min(params.filter_h, input_height - in_y_origin);
 
          const int output_data_offset =
            ((batch * output_height + out_y) * output_width + out_x) * depth + channel;
 
          float max = std::numeric_limits<float>::lowest();
          int max_index = 0;
 
          for (int filter_y = filter_y_start; filter_y < filter_y_end; ++filter_y)
          {
            for (int filter_x = filter_x_start; filter_x < filter_x_end; ++filter_x)
            {
              const int in_x = in_x_origin + filter_x;
              const int in_y = in_y_origin + filter_y;
 
              const int input_data_offset =
                ((batch * input_height + in_y) * input_width + in_x) * depth + channel;
 
              if (input_data[input_data_offset] > max)
              {
                max = input_data[input_data_offset];
                max_index = input_data_offset;
              }
            }
          }
          dloss_dinput_data[max_index] = dloss_doutput_data[output_data_offset];
        }
      }
    }
  }
}

References onert_micro::core::OMRuntimeShape::dims(), onert_micro::core::Pool2DParams::filter_h, onert_micro::core::Pool2DParams::filter_w, onert_micro::core::Pool2DParams::pad_h, onert_micro::core::Pool2DParams::pad_w, onert_micro::core::Pool2DParams::stride_h, and onert_micro::core::Pool2DParams::stride_w.

ReluInputGrad()

void onert_micro::train::pal::ReluInputGrad ( const float *  input_relu_data, float *  dloss_doutput_data, const core::OMRuntimeShape &  dloss_doutput_shape  )

inline

Definition at line 34 of file PALReluInputGrad.h.

{
  const uint32_t flat_size = dloss_doutput_shape.flatSize();
 
  for (uint32_t i = 0; i < flat_size; ++i)
  {
    dloss_doutput_data[i] = input_relu_data[i] > 0 ? dloss_doutput_data[i] : 0.f;
  }
}

References onert_micro::core::OMRuntimeShape::flatSize().

SoftmaxInputGrad()

void onert_micro::train::pal::SoftmaxInputGrad ( const float *  dloss_doutput_data, const core::OMRuntimeShape &  dloss_doutput_shape, const float *  calculated_data, float *  jacobian_row_data, float *  dloss_dinput_data  )

inline

Definition at line 33 of file PALSoftmaxInputGrad.h.

{
  assert(dloss_doutput_shape.dimensionsCount() == 2);
  assert(dloss_doutput_shape.dims(0) == 1);
  const uint32_t width = dloss_doutput_shape.dims(dloss_doutput_shape.dimensionsCount() - 1);
  for (int w1 = 0; w1 < width; ++w1)
  {
    float sum = 0.0f;
    for (int w2 = 0; w2 < width; ++w2)
    {
      float val;
      if (w1 == w2)
      {
        val = calculated_data[w2] * (1.f - calculated_data[w2]);
      }
      else
      {
        val = -calculated_data[w2] * calculated_data[w1];
      }
      val *= dloss_doutput_data[w2];
      sum += val;
    }
    dloss_dinput_data[w1] = sum;
  }
}

References onert_micro::core::OMRuntimeShape::dimensionsCount(), and onert_micro::core::OMRuntimeShape::dims().