Namespaces
namespace	functor

Data Structures
struct	LaunchConv2DBackpropFilterOp

struct	LaunchConv2DBackpropInputOp

struct	LaunchConv2DBackpropInputOpImpl

Enumerations
enum class	ArithmeticType { kAdd , kSub , kMul , kDiv }

enum class	LossReductionType { SUM_OVER_BATCH_SIZE , SUM }

Functions
void	AveragePool2DGrad (const PoolParams &params, const Shape &incoming_shape, const float incoming_data, const Shape &grad_shape, float grad_data)

template<typename T >
void	BinaryArithmeticGrad (const Shape &lhs_shape, const T lhs_data, const Shape &rhs_shape, const T rhs_data, const Shape &incoming_shape, const T incoming_data, const Shape &lhs_grad_shape, T lhs_grad_data, const Shape &rhs_grad_shape, T *rhs_grad_data, ArithmeticType arithmetic_type)

void	ConvInputGrad (const ConvParams &params, const Shape &incoming_shape, const float incoming_data, const Shape &filter_shape, const float filter_data, const int padding_bottom, const int padding_right, const Shape &grad_shape, float *grad_data)

void	ConvFilterGrad (const ConvParams &params, const Shape &incoming_shape, const float incoming_data, const Shape &input_shape, const float input_data, const int padding_bottom, const int padding_right, const Shape &filter_backprop_shape, float *filter_backprop_data)

template<typename T >
void	backpropInput (const DepthwiseConvParams &params, const Shape &incoming_shape, const T incoming_data, const Shape &filter_shape, const T filter_data, T padded_filter_data, const Shape &grad_shape, T grad_data, bool pad_filter, T filter_buffers_data, T filter_dim_buffers_data)

template<typename T >
void	backpropFilter (const DepthwiseConvParams &params, const Shape &incoming_shape, const T incoming_data, const Shape &input_shape, const T input_data, const Shape &filter_grad_shape, T filter_grad_data, T padded_filter_data, T *filter_buffers_data)

template<typename T >
void	FullyConnectedBiasGrad (const Shape &incomming_shape, const T incomming_data, const Shape &grad_shape, T grad_data)

template<typename T >
T	square (T value)

template<typename T >
T	log_threshold ()

template<typename T >
void	MSE (const Shape &y_pred_shape, const T y_pred_data, const Shape &y_true_shape, const T y_true_data, const Shape &output_shape, T *output_data)

template<typename T >
void	MSEGrad (const Shape &y_pred_shape, const T y_pred_data, const Shape &y_true_shape, const T y_true_data, const Shape &grad_shape, T *grad_data, LossReductionType reduction_type)

template<typename T >
void	CategoricalCrossEntropy (const Shape &y_pred_shape, const T y_pred_data, const Shape &y_true_shape, const T y_true_data, const Shape &output_shape, T *output_data)

template<typename T >
void	CategoricalCrossEntropyGrad (const Shape &y_pred_shape, const T y_pred_data, const Shape &y_true_shape, const T y_true_data, const Shape &grad_shape, T *grad_data, LossReductionType reduction_type)

template<typename T >
void	CategoricalCrossEntropyWithLogits (const Shape &logits_shape, const T logits_data, const Shape &y_true_shape, const T y_true_data, const Shape &loss_out_shape, T loss_out_data, const Shape &grad_shape, T grad_data, LossReductionType reduction_type)

void	MaxPool2D (const PoolParams &params, const Shape &input_shape, const float input_data, const Shape &output_shape, float output_data, int *arg_max_index)

void	MaxPool2DGrad (const Shape &incoming_shape, const float incoming_data, const int arg_max_index, const Shape &grad_shape, float *grad_data)

template<typename T >
void	Depad (const int32_t padding_data, int32_t pad_rank, const Shape &input_shape, const T input_data, const Shape &output_shape, T *output_data)

template<typename T >
void	MeanGrad (const Shape &incoming_shape, const T incoming_data, const Shape &grad_shape, T grad_data)

void	ReLUGrad (const Shape &output_shape, const float output_data, const Shape &incoming_shape, const float incoming_data, const Shape &grad_shape, float *grad_data)

void	ReLU6Grad (const Shape &output_shape, const float output_data, const Shape &incoming_shape, const float incoming_data, const Shape &grad_shape, float *grad_data)

void	SoftMaxGrad (const Shape &output_shape, const float output_data, const Shape &incoming_shape, const float incoming_data, const Shape &grad_shape, float *grad_data)

void	Adam (const Shape &trainable_shape, float trainable_data, const Shape &grad_shape, const float grad_data, const Shape &m_shape, float m_data, const Shape &v_shape, float v_data, float beta1_power, float beta2_power, float learning_rate, float beta1, float beta2, float epsilon, bool use_nesterov)

void	GradientDescent (const Shape &output_shape, float output_data, const Shape &grad_shape, const float grad_data, float learning_rate)

Enumeration Type Documentation

◆ ArithmeticType

enum class nnfw::cker::train::ArithmeticType

strong

Enumerator
kAdd
kSub
kMul
kDiv

Definition at line 30 of file BinaryArithmetic.h.

{
  kAdd,
  kSub,
  kMul,
  kDiv,
};

◆ LossReductionType

enum class nnfw::cker::train::LossReductionType

strong

Enumerator
SUM_OVER_BATCH_SIZE
SUM

Definition at line 27 of file Types.h.

{
  SUM_OVER_BATCH_SIZE,
  SUM,
};

Function Documentation

◆ Adam()

void nnfw::cker::train::Adam	(	const Shape &	trainable_shape,
		float *	trainable_data,
		const Shape &	grad_shape,
		const float *	grad_data,
		const Shape &	m_shape,
		float *	m_data,
		const Shape &	v_shape,
		float *	v_data,
		float	beta1_power,
		float	beta2_power,
		float	learning_rate,
		float	beta1,
		float	beta2,
		float	epsilon,
		bool	use_nesterov
	)

inline

Definition at line 33 of file Adam.h.

{
  Tensor trainable_tensor;
  Tensor grad_tensor;
  Tensor m_tensor;
  Tensor v_tensor;
  Tensor beta1_power_tensor;
  Tensor beta2_power_tensor;
  Tensor lr_tensor;
  Tensor beta1_tensor;
  Tensor beta2_tensor;
  Tensor epsilon_tensor;
 
  trainable_tensor.shape.ReplaceWith(trainable_shape.DimensionsCount(), trainable_shape.DimsData());
  trainable_tensor.buffer = trainable_data;
 
  grad_tensor.shape.ReplaceWith(grad_shape.DimensionsCount(), grad_shape.DimsData());
  grad_tensor.buffer = const_cast<float *>(grad_data);
 
  m_tensor.shape.ReplaceWith(m_shape.DimensionsCount(), m_shape.DimsData());
  m_tensor.buffer = m_data;
 
  v_tensor.shape.ReplaceWith(v_shape.DimensionsCount(), v_shape.DimsData());
  v_tensor.buffer = v_data;
 
  std::vector<float> beta1_power_vec{beta1_power};
  beta1_power_tensor.buffer = beta1_power_vec.data();
 
  std::vector<float> beta2_power_vec{beta2_power};
  beta2_power_tensor.buffer = beta2_power_vec.data();
 
  std::vector<float> lr_vec{learning_rate};
  lr_tensor.buffer = lr_vec.data();
 
  std::vector<float> beta1_vec{beta1};
  beta1_tensor.buffer = beta1_vec.data();
 
  std::vector<float> beta2_vec{beta2};
  beta2_tensor.buffer = beta2_vec.data();
 
  std::vector<float> epsilon_vec{epsilon};
  epsilon_tensor.buffer = epsilon_vec.data();
 
  if (trainable_shape != m_shape)
    throw std::runtime_error("cker::Adam: output and m do not have the same shape");
 
  if (trainable_shape != v_shape)
    throw std::runtime_error("cker::Adam: output and v do not have the same shape");
 
  if (trainable_shape != grad_shape)
    throw std::runtime_error("cker::Adam: output and gradient do not have the same shape");
 
  const training_ops::CPUDevice &device = *eigen_support::GetThreadPoolDevice();
  training_ops::functor::ApplyAdam<training_ops::CPUDevice, float>()(
    device, trainable_tensor.flat<float>(), m_tensor.flat<float>(), v_tensor.flat<float>(),
    beta1_power_tensor.scalar<float>(), beta2_power_tensor.scalar<float>(),
    lr_tensor.scalar<float>(), beta1_tensor.scalar<float>(), beta2_tensor.scalar<float>(),
    epsilon_tensor.scalar<float>(), static_cast<const Tensor &>(grad_tensor).flat<float>(),
    use_nesterov);
}

References nnfw::cker::Tensor::buffer, nnfw::cker::Shape::DimensionsCount(), nnfw::cker::Shape::DimsData(), nnfw::cker::Tensor::flat(), nnfw::cker::eigen_support::GetThreadPoolDevice(), nnfw::cker::Shape::ReplaceWith(), nnfw::cker::Tensor::scalar(), and nnfw::cker::Tensor::shape.

Referenced by onert::backend::train::optimizer::Adam::applyGradient().

◆ AveragePool2DGrad()

void nnfw::cker::train::AveragePool2DGrad	(	const PoolParams &	params,
		const Shape &	incoming_shape,
		const float *	incoming_data,
		const Shape &	grad_shape,
		float *	grad_data
	)

inline

Definition at line 33 of file AveragePool.h.

{
  assert(grad_shape.DimensionsCount() == 4);
  assert(incoming_shape.DimensionsCount() == 4);
 
  const int batches = MatchingDim(incoming_shape, 0, grad_shape, 0);
  const int grad_height = grad_shape.Dims(1);
  const int grad_width = grad_shape.Dims(2);
  const int incoming_height = incoming_shape.Dims(1);
  const int incoming_width = incoming_shape.Dims(2);
  const int stride_height = params.stride_height;
  const int stride_width = params.stride_width;
 
  // initialize grad_data
  std::fill(grad_data, grad_data + grad_shape.FlatSize(), 0.0);
 
  const auto incoming_mat = MapAsMatrixWithLastDimAsRows(incoming_data, incoming_shape);
  auto grad_mat = MapAsMatrixWithLastDimAsRows(grad_data, grad_shape);
 
  for (int b = 0; b < batches; ++b)
  {
    for (int h = 0; h < incoming_height; ++h)
    {
      for (int w = 0; w < incoming_width; ++w)
      {
        // (h_start, h_end) * (w_start, w_end) is input range
        // that output is projected from.
        int h_start = h * stride_height - params.padding_values.height;
        int h_end = std::min(h_start + params.filter_height, grad_height);
        h_start = h_start < 0 ? 0 : h_start;
 
        int w_start = w * stride_width - params.padding_values.width;
        int w_end = std::min(w_start + params.filter_width, grad_width);
        w_start = w_start < 0 ? 0 : w_start;
 
        int count = (h_end - h_start) * (w_end - w_start);
 
        if (h_end <= 0 || w_end <= 0 || count <= 0 || h_start >= grad_height ||
            w_start >= grad_width)
          continue;
 
        int incoming_offset = NodeOffset(b, h, w, incoming_height, incoming_width);
        for (int ph = h_start; ph < h_end; ++ph)
        {
          for (int pw = w_start; pw < w_end; ++pw)
          {
            int grad_offset = NodeOffset(b, ph, pw, grad_height, grad_width);
            grad_mat.col(grad_offset) += incoming_mat.col(incoming_offset) / count;
          }
        }
      }
    }
  }
}

References nnfw::cker::Shape::DimensionsCount(), nnfw::cker::Shape::Dims(), nnfw::cker::PoolParams::filter_height, nnfw::cker::PoolParams::filter_width, nnfw::cker::Shape::FlatSize(), nnfw::cker::PaddingValues::height, nnfw::cker::MapAsMatrixWithLastDimAsRows(), nnfw::cker::MatchingDim(), nnfw::cker::NodeOffset(), nnfw::cker::PoolParams::padding_values, nnfw::cker::PoolParams::stride_height, nnfw::cker::PoolParams::stride_width, and nnfw::cker::PaddingValues::width.

◆ backpropFilter()

template<typename T >

void nnfw::cker::train::backpropFilter	(	const DepthwiseConvParams &	params,
		const Shape &	incoming_shape,
		const T *	incoming_data,
		const Shape &	input_shape,
		const T *	input_data,
		const Shape &	filter_grad_shape,
		T *	filter_grad_data,
		T *	padded_filter_data,
		T *	filter_buffers_data
	)

Definition at line 65 of file DepthwiseConv.h.

{
  if (params.stride_height != params.stride_width)
    throw std::runtime_error("Not support different length strides");
 
  if (params.dilation_height_factor != 1 || params.dilation_width_factor != 1)
    throw std::runtime_error{"Not support dilation other than 1."};
 
  const int batch = MatchingDim(incoming_shape, 0, input_shape, 0);
  const int input_depth = input_shape.Dims(3);
  const int output_depth = incoming_shape.Dims(3);
  const int incoming_height = incoming_shape.Dims(1);
  const int incoming_width = incoming_shape.Dims(2);
  const int input_height = input_shape.Dims(1);
  const int input_width = input_shape.Dims(2);
  const int stride = params.stride_height;
  const int depth_multiplier = params.depth_multiplier;
  const int filter_height = filter_grad_shape.Dims(1);
  const int filter_width = filter_grad_shape.Dims(2);
  const int pad_height = params.padding_values.height;
  const int pad_width = params.padding_values.width;
 
  depthwise_conv_op::LaunchDepthwiseConvBackpropFilterOp<Eigen::ThreadPoolDevice, T>()(
    batch, input_height, input_width, input_depth, filter_height, filter_width, depth_multiplier,
    stride, pad_height, pad_width, incoming_height, incoming_width, output_depth, incoming_data,
    input_data, filter_grad_data, padded_filter_data, filter_buffers_data);
}

References nnfw::cker::DepthwiseConvParams::depth_multiplier, nnfw::cker::DepthwiseConvParams::dilation_height_factor, nnfw::cker::DepthwiseConvParams::dilation_width_factor, nnfw::cker::Shape::Dims(), nnfw::cker::PaddingValues::height, nnfw::cker::MatchingDim(), nnfw::cker::DepthwiseConvParams::padding_values, nnfw::cker::DepthwiseConvParams::stride_height, nnfw::cker::DepthwiseConvParams::stride_width, and nnfw::cker::PaddingValues::width.

◆ backpropInput()

template<typename T >

void nnfw::cker::train::backpropInput	(	const DepthwiseConvParams &	params,
		const Shape &	incoming_shape,
		const T *	incoming_data,
		const Shape &	filter_shape,
		const T *	filter_data,
		T *	padded_filter_data,
		const Shape &	grad_shape,
		T *	grad_data,
		bool	pad_filter,
		T *	filter_buffers_data,
		T *	filter_dim_buffers_data
	)

Definition at line 32 of file DepthwiseConv.h.

{
  if (params.stride_height != params.stride_width)
    throw std::runtime_error("Not support different length strides");
 
  if (params.dilation_height_factor != 1 || params.dilation_width_factor != 1)
    throw std::runtime_error{"Not support dilation other than 1."};
 
  const int batch = MatchingDim(incoming_shape, 0, grad_shape, 0);
  const int input_depth = grad_shape.Dims(3);
  const int output_depth = incoming_shape.Dims(3);
  const int incoming_height = incoming_shape.Dims(1);
  const int incoming_width = incoming_shape.Dims(2);
  const int grad_height = grad_shape.Dims(1);
  const int grad_width = grad_shape.Dims(2);
  const int stride = params.stride_height;
  const int depth_multiplier = params.depth_multiplier;
  const int filter_height = filter_shape.Dims(1);
  const int filter_width = filter_shape.Dims(2);
  const int pad_height = params.padding_values.height;
  const int pad_width = params.padding_values.width;
 
  depthwise_conv_op::LaunchDepthwiseConvBackpropInputOp<Eigen::ThreadPoolDevice, T>()(
    batch, grad_height, grad_width, input_depth, filter_height, filter_width, depth_multiplier,
    stride, pad_height, pad_width, incoming_height, incoming_width, output_depth, incoming_data,
    filter_data, padded_filter_data, grad_data, pad_filter, filter_buffers_data,
    filter_dim_buffers_data);
}

References nnfw::cker::DepthwiseConvParams::depth_multiplier, nnfw::cker::DepthwiseConvParams::dilation_height_factor, nnfw::cker::DepthwiseConvParams::dilation_width_factor, nnfw::cker::Shape::Dims(), nnfw::cker::PaddingValues::height, nnfw::cker::MatchingDim(), nnfw::cker::DepthwiseConvParams::padding_values, nnfw::cker::DepthwiseConvParams::stride_height, nnfw::cker::DepthwiseConvParams::stride_width, and nnfw::cker::PaddingValues::width.

◆ BinaryArithmeticGrad()

template<typename T >

void nnfw::cker::train::BinaryArithmeticGrad	(	const Shape &	lhs_shape,
		const T *	lhs_data,
		const Shape &	rhs_shape,
		const T *	rhs_data,
		const Shape &	incoming_shape,
		const T *	incoming_data,
		const Shape &	lhs_grad_shape,
		T *	lhs_grad_data,
		const Shape &	rhs_grad_shape,
		T *	rhs_grad_data,
		ArithmeticType	arithmetic_type
	)

Definition at line 39 of file BinaryArithmetic.h.

{
  if (!(lhs_shape == rhs_shape && rhs_shape == incoming_shape && incoming_shape == lhs_grad_shape &&
        lhs_grad_shape == rhs_grad_shape))
    throw std::runtime_error{"Shape of lhs, rhs, incoming, lhs_grad, and rhs_grad must match"};
 
  switch (arithmetic_type)
  {
    case ArithmeticType::kAdd:
    {
      BroadcastTo(incoming_shape, const_cast<T *>(incoming_data), lhs_grad_shape, lhs_grad_data);
      BroadcastTo(incoming_shape, const_cast<T *>(incoming_data), rhs_grad_shape, rhs_grad_data);
    }
    break;
 
    case ArithmeticType::kSub:
    {
      BroadcastTo(incoming_shape, const_cast<T *>(incoming_data), lhs_grad_shape, lhs_grad_data);
 
      auto const in_map = MapAsVector(incoming_data, incoming_shape);
      auto rhs_grad_map = MapAsVector(rhs_grad_data, rhs_grad_shape);
      rhs_grad_map = -in_map;
    }
    break;
 
    case ArithmeticType::kMul:
    {
      auto const in_map = MapAsVector(incoming_data, incoming_shape);
      auto const lhs_map = MapAsVector(lhs_data, lhs_shape);
      auto const rhs_map = MapAsVector(rhs_data, rhs_shape);
      auto lhs_grad_map = MapAsVector(lhs_grad_data, lhs_grad_shape);
      auto rhs_grad_map = MapAsVector(rhs_grad_data, rhs_grad_shape);
 
      lhs_grad_map = in_map.array() * rhs_map.array();
      rhs_grad_map = in_map.array() * lhs_map.array();
    }
    break;
 
    case ArithmeticType::kDiv:
    default:
      throw std::runtime_error{"Unsupported Binary Arithmetic Operation"};
  }
}

References nnfw::cker::BroadcastTo(), kAdd, kDiv, kMul, kSub, and nnfw::cker::MapAsVector().

Referenced by onert::backend::train::ops::BinaryArithmeticLayer::backward().

◆ CategoricalCrossEntropy()

template<typename T >

void nnfw::cker::train::CategoricalCrossEntropy	(	const Shape &	y_pred_shape,
		const T *	y_pred_data,
		const Shape &	y_true_shape,
		const T *	y_true_data,
		const Shape &	output_shape,
		T *	output_data
	)

inline

Definition at line 103 of file Loss.h.

{
  if (output_shape.DimensionsCount() != 1)
    throw std::runtime_error("cker::CategoricalCrossEntropy: output dimension count should be 1");
  if (y_pred_shape != y_true_shape)
    throw std::runtime_error(
      "cker::CategoricalCrossEntropy: y_pred and y_true do not have the same shape");
  if (output_shape.Dims(0) != y_pred_shape.Dims(0))
    throw std::runtime_error(
      "cker::CategoricalCrossEntropy: output and y_pred do not have the same batch");
 
  const auto y_pred = MapAsMatrixWithLastDimAsRows(y_pred_data, y_pred_shape);
  const auto y_true = MapAsMatrixWithLastDimAsRows(y_true_data, y_true_shape);
  auto output = MapAsVector(output_data, output_shape);
 
  output = -(y_true.array() * y_pred.array().cwiseMax(log_threshold<T>()).log()).colwise().sum();
}

References nnfw::cker::Shape::Dims(), nnfw::cker::MapAsMatrixWithLastDimAsRows(), nnfw::cker::MapAsVector(), and output_shape.

Referenced by onert::backend::train::ops::LossCategoricalCrossentropyLayer::forward().

◆ CategoricalCrossEntropyGrad()

template<typename T >

void nnfw::cker::train::CategoricalCrossEntropyGrad	(	const Shape &	y_pred_shape,
		const T *	y_pred_data,
		const Shape &	y_true_shape,
		const T *	y_true_data,
		const Shape &	grad_shape,
		T *	grad_data,
		LossReductionType	reduction_type
	)

inline

Definition at line 124 of file Loss.h.

{
  if (y_pred_shape != y_true_shape)
    throw std::runtime_error(
      "cker::CategoricalCrossEntropyGrad: y_pred and y_true do not have the same shape");
  if (y_pred_shape != grad_shape)
    throw std::runtime_error(
      "cker::CategoricalCrossEntropyGrad: y_pred and grad do not have the same shape");
 
  const auto y_pred = MapAsMatrixWithLastDimAsRows(y_pred_data, y_pred_shape);
  const auto y_true = MapAsMatrixWithLastDimAsRows(y_true_data, y_true_shape);
  auto grad = MapAsMatrixWithLastDimAsRows(grad_data, grad_shape);
 
  const int32_t batch_size = grad_shape.Dims(0);
  int32_t reduction_size = 1;
  switch (reduction_type)
  {
    case LossReductionType::SUM_OVER_BATCH_SIZE:
      reduction_size = batch_size;
      break;
    case LossReductionType::SUM:
      reduction_size = 1;
      break;
    default:
      throw std::runtime_error("Unsupported reduction type");
  }
  assert(reduction_size > 0);
 
  grad = -(y_true.array() / y_pred.array().cwiseMax(log_threshold<T>())) /
         static_cast<T>(reduction_size);
}

References nnfw::cker::Shape::Dims(), nnfw::cker::MapAsMatrixWithLastDimAsRows(), SUM, and SUM_OVER_BATCH_SIZE.

Referenced by onert::backend::train::ops::LossCategoricalCrossentropyLayer::backward().

◆ CategoricalCrossEntropyWithLogits()

template<typename T >

void nnfw::cker::train::CategoricalCrossEntropyWithLogits	(	const Shape &	logits_shape,
		const T *	logits_data,
		const Shape &	y_true_shape,
		const T *	y_true_data,
		const Shape &	loss_out_shape,
		T *	loss_out_data,
		const Shape &	grad_shape,
		T *	grad_data,
		LossReductionType	reduction_type
	)

Definition at line 160 of file Loss.h.

{
  // TODO Enable broadcast shapes
  if (loss_out_shape.DimensionsCount() != 1)
    throw std::runtime_error(
      "cker::CategoricalCrossEntropyWithLogits: loss output dimension count should be 1");
  if (logits_shape != y_true_shape)
    throw std::runtime_error(
      "cker::CategoricalCrossEntropyWithLogits: logits and y_true do not have the same shape");
  if (loss_out_shape.Dims(0) != logits_shape.Dims(0))
    throw std::runtime_error(
      "cker::CategoricalCrossEntropyWithLogits: loss_out and logits do not have the same batch");
  if (logits_shape != grad_shape)
    throw std::runtime_error(
      "cker::CategoricalCrossEntropyWithLogits: logits and grad do not have the same shape");
 
  auto shape_in = logits_shape;
 
  BCast bcast(BCast::FromShape(shape_in), BCast::FromShape(y_true_shape),
              /*fewer_dims_optimization=*/false);
 
  // loss is 1-D (one per example), and size is batch_size.
 
  Tensor logits_in;
  Tensor labels_in;
  Tensor scratch;
  Tensor loss_out;
  Tensor back_out;
 
  logits_in.shape.ReplaceWith(shape_in.DimensionsCount(), shape_in.DimsData());
  logits_in.buffer = const_cast<T *>(logits_data);
 
  labels_in.shape.ReplaceWith(y_true_shape.DimensionsCount(), y_true_shape.DimsData());
  labels_in.buffer = const_cast<T *>(y_true_data);
 
  scratch.shape.ReplaceWith(shape_in.DimensionsCount(), shape_in.DimsData());
  std::vector<T> scratch_vec(shape_in.Dims(0) * shape_in.Dims(1), static_cast<T>(0));
  scratch.buffer = scratch_vec.data();
 
  Shape shape_loss_out{shape_in.Dims(0)};
  loss_out.shape.ReplaceWith(shape_loss_out.DimensionsCount(), shape_loss_out.DimsData());
  loss_out.buffer = loss_out_data;
 
  back_out.shape.ReplaceWith(shape_in.DimensionsCount(), shape_in.DimsData());
  back_out.buffer = grad_data;
 
  if (shape_in.Dims(0) > 0)
  {
    const int32_t batch_size = grad_shape.Dims(0);
    int32_t reduction_size = 1;
    switch (reduction_type)
    {
      case LossReductionType::SUM_OVER_BATCH_SIZE:
        reduction_size = batch_size;
        break;
      case LossReductionType::SUM:
        reduction_size = 1;
        break;
      default:
        throw std::runtime_error("Unsupported reduction type");
    }
    assert(reduction_size > 0);
 
    const xent_ops::CPUDevice &device = *eigen_support::GetThreadPoolDevice();
    xent_ops::functor::XentFunctor<xent_ops::CPUDevice, T> functor;
    const Eigen::DSizes<Eigen::DenseIndex, 2> shape{shape_in.Dims(0), shape_in.Dims(1)};
 
    functor(device, shape, BCast::ToIndexArray<2>(bcast.x_bcast()),
            BCast::ToIndexArray<2>(bcast.y_bcast()),
            logits_in.template shaped<const T, 2>(bcast.x_reshape()),
            labels_in.template shaped<const T, 2>(bcast.y_reshape()), scratch.matrix<T>(),
            loss_out.vec<T>(), back_out.matrix<T>(), static_cast<T>(reduction_size));
  }
}

References nnfw::cker::Tensor::buffer, nnfw::cker::Shape::DimensionsCount(), nnfw::cker::Shape::Dims(), nnfw::cker::Shape::DimsData(), nnfw::cker::BCast::FromShape(), nnfw::cker::eigen_support::GetThreadPoolDevice(), nnfw::cker::Tensor::matrix(), nnfw::cker::Shape::ReplaceWith(), nnfw::cker::Tensor::shape, SUM, SUM_OVER_BATCH_SIZE, nnfw::cker::Tensor::vec(), nnfw::cker::BCast::x_bcast(), nnfw::cker::BCast::x_reshape(), nnfw::cker::BCast::y_bcast(), and nnfw::cker::BCast::y_reshape().

Referenced by onert::backend::train::ops::LossCategoricalCrossentropyLayer::backward().

◆ ConvFilterGrad()

void nnfw::cker::train::ConvFilterGrad	(	const ConvParams &	params,
		const Shape &	incoming_shape,
		const float *	incoming_data,
		const Shape &	input_shape,
		const float *	input_data,
		const int	padding_bottom,
		const int	padding_right,
		const Shape &	filter_backprop_shape,
		float *	filter_backprop_data
	)

inline

Definition at line 225 of file Conv.h.

{
  const int stride_rows = params.stride_height;
  const int stride_cols = params.stride_width;
  const PaddingType padding = params.padding_type;
  const int padding_top = params.padding_values.height;
  const int padding_left = params.padding_values.width;
  assert(padding_top >= 0);
  assert(padding_bottom >= 0);
  assert(padding_left >= 0);
  assert(padding_right >= 0);
  const int dilation_rows = params.dilation_height_factor;
  const int dilation_cols = params.dilation_width_factor;
 
  const int batches = MatchingDim(input_shape, 0, incoming_shape, 0);
  const int input_depth = MatchingDim(filter_backprop_shape, 2, input_shape, 3);
  const int output_depth = MatchingDim(filter_backprop_shape, 3, incoming_shape, 3);
  const int input_height = input_shape.Dims(1);
  const int input_width = input_shape.Dims(2);
  const int filter_backprop_height = filter_backprop_shape.Dims(0);
  const int filter_backprop_width = filter_backprop_shape.Dims(1);
  const int incoming_height = incoming_shape.Dims(1);
  const int incoming_width = incoming_shape.Dims(2);
 
  if (dilation_rows != 1 || dilation_cols != 1)
    throw std::runtime_error("cker::ConvFilterGrad: not yet support dilation rates larger than 1.");
 
  LaunchConv2DBackpropFilterOp<float>()(
    incoming_data, batches, incoming_height, incoming_width, output_depth, input_data, input_height,
    input_width, input_depth, dilation_rows, dilation_cols, stride_rows, stride_cols, padding,
    padding_top, padding_bottom, padding_left, padding_right, filter_backprop_data,
    filter_backprop_height, filter_backprop_width);
}

References nnfw::cker::ConvParams::dilation_height_factor, nnfw::cker::ConvParams::dilation_width_factor, nnfw::cker::Shape::Dims(), nnfw::cker::PaddingValues::height, nnfw::cker::MatchingDim(), nnfw::cker::ConvParams::padding_type, nnfw::cker::ConvParams::padding_values, nnfw::cker::ConvParams::stride_height, nnfw::cker::ConvParams::stride_width, and nnfw::cker::PaddingValues::width.

◆ ConvInputGrad()

void nnfw::cker::train::ConvInputGrad	(	const ConvParams &	params,
		const Shape &	incoming_shape,
		const float *	incoming_data,
		const Shape &	filter_shape,
		const float *	filter_data,
		const int	padding_bottom,
		const int	padding_right,
		const Shape &	grad_shape,
		float *	grad_data
	)

inline

Definition at line 188 of file Conv.h.

{
  const int stride_rows = params.stride_height;
  const int stride_cols = params.stride_width;
  const PaddingType padding = params.padding_type;
  const int padding_top = params.padding_values.height;
  const int padding_left = params.padding_values.width;
  assert(padding_top >= 0);
  assert(padding_bottom >= 0);
  assert(padding_left >= 0);
  assert(padding_right >= 0);
  const int dilation_rows = params.dilation_height_factor;
  const int dilation_cols = params.dilation_width_factor;
 
  const int batches = MatchingDim(grad_shape, 0, incoming_shape, 0);
  const int input_depth = MatchingDim(filter_shape, 2, grad_shape, 3);
  const int output_depth = MatchingDim(filter_shape, 3, incoming_shape, 3);
  const int grad_height = grad_shape.Dims(1);
  const int grad_width = grad_shape.Dims(2);
  const int filter_height = filter_shape.Dims(0);
  const int filter_width = filter_shape.Dims(1);
  const int incoming_height = incoming_shape.Dims(1);
  const int incoming_width = incoming_shape.Dims(2);
 
  if (dilation_rows != 1 || dilation_cols != 1)
    throw std::runtime_error("cker::ConvFilterGrad: not yet support dilation rates larger than 1.");
 
  LaunchConv2DBackpropInputOp<float>()(
    incoming_data, batches, incoming_height, incoming_width, output_depth, filter_data,
    filter_height, filter_width, dilation_rows, dilation_cols, stride_rows, stride_cols, padding,
    padding_top, padding_bottom, padding_left, padding_right, grad_data, grad_height, grad_width,
    input_depth);
}

References nnfw::cker::ConvParams::dilation_height_factor, nnfw::cker::ConvParams::dilation_width_factor, nnfw::cker::Shape::Dims(), nnfw::cker::PaddingValues::height, nnfw::cker::MatchingDim(), nnfw::cker::ConvParams::padding_type, nnfw::cker::ConvParams::padding_values, nnfw::cker::ConvParams::stride_height, nnfw::cker::ConvParams::stride_width, and nnfw::cker::PaddingValues::width.

◆ Depad()

template<typename T >

void nnfw::cker::train::Depad	(	const int32_t *	padding_data,
		int32_t	pad_rank,
		const Shape &	input_shape,
		const T *	input_data,
		const Shape &	output_shape,
		T *	output_data
	)

inline

Definition at line 50 of file Pad.h.

{
  using PaddingInfo = std::pair<int32_t, int32_t>;
  using PaddingList = std::vector<PaddingInfo>;
 
  assert(output_shape.DimensionsCount() == input_shape.DimensionsCount());
  assert(output_shape.DimensionsCount() == pad_rank);
 
  PaddingList padding_list(pad_rank);
  for (int32_t n = 0; n < pad_rank; ++n)
  {
    const int32_t *from = padding_data + (n * 2);
    assert(from[0] >= 0 && from[1] >= 0);
    padding_list[n] = {from[0], from[1]};
  }
  for (int32_t i = 0; i < pad_rank; ++i)
  {
    assert(output_shape.Dims(i) ==
           input_shape.Dims(i) - padding_list[i].first - padding_list[i].second);
  }
 
  // logical axis: row -> col -> plain -> cube
  switch (pad_rank)
  {
    case 0:
    case 1:
    {
      const int32_t out_row_len = output_shape.Dims(0);
      const int32_t padding_left = padding_list[0].first;
      std::memcpy(output_data, input_data + padding_left, out_row_len * sizeof(T));
      break;
    }
    case 2: // HW
    {
      const int32_t out_col_len = output_shape.Dims(0);
      const int32_t out_row_len = output_shape.Dims(1);
      const int32_t in_row_len = input_shape.Dims(1);
      const int32_t padding_top = padding_list[0].first;
      const int32_t padding_left = padding_list[1].first;
      for (auto i = 0; i < out_col_len; ++i)
      {
        const auto in_offset = (i + padding_top) * in_row_len + padding_left;
        const auto out_offset = i * out_row_len;
        // copy a row of input data to output data
        std::memcpy(output_data + out_offset, input_data + in_offset, out_row_len * sizeof(T));
      }
      break;
    }
    case 3: // HWC
    {
      const int32_t out_plain_len = output_shape.Dims(0);
      const int32_t out_col_len = output_shape.Dims(1);
      const int32_t out_row_len = output_shape.Dims(2);
      const int32_t out_plain_size = out_col_len * out_row_len;
      const int32_t in_col_len = input_shape.Dims(1);
      const int32_t in_row_len = input_shape.Dims(2);
      const int32_t in_plain_size = in_col_len * in_row_len;
      const int32_t padding_depth = padding_list[0].first;
      const int32_t padding_top = padding_list[1].first;
      const int32_t padding_left = padding_list[2].first;
      for (auto d = 0; d < out_plain_len; ++d)
      {
        for (auto h = 0; h < out_col_len; ++h)
        {
          const auto in_offset =
            (d + padding_depth) * in_plain_size + (h + padding_top) * in_row_len + (padding_left);
          const auto out_offset = (d * out_plain_size) + (h * out_row_len);
          // copy a row of input data to output data
          std::memcpy(output_data + out_offset, input_data + in_offset, out_row_len * sizeof(T));
        }
      }
      break;
    }
    case 4: // NHWC
    {
      const int32_t out_cube_len = output_shape.Dims(0);
      const int32_t out_plain_len = output_shape.Dims(1);
      const int32_t out_col_len = output_shape.Dims(2);
      const int32_t out_row_len = output_shape.Dims(3);
      const int32_t out_plain_size = out_col_len * out_row_len;
      const int32_t out_cube_size = out_plain_len * out_plain_size;
      const int32_t in_plain_len = input_shape.Dims(1);
      const int32_t in_col_len = input_shape.Dims(2);
      const int32_t in_row_len = input_shape.Dims(3);
      const int32_t in_plain_size = in_col_len * in_row_len;
      const int32_t in_cube_size = in_plain_len * in_plain_size;
      const int32_t padding_cube = padding_list[0].first;
      const int32_t padding_depth = padding_list[1].first;
      const int32_t padding_top = padding_list[2].first;
      const int32_t padding_left = padding_list[3].first;
      for (auto c = 0; c < out_cube_len; ++c)
      {
        for (auto d = 0; d < out_plain_len; ++d)
        {
          for (auto h = 0; h < out_col_len; ++h)
          {
            const auto in_offset = (c + padding_cube) * in_cube_size +
                                   (d + padding_depth) * in_plain_size +
                                   (h + padding_top) * in_row_len + (padding_left);
            const auto out_offset = (c * out_cube_size) + (d * out_plain_size) + (h * out_row_len);
            // copy a row of input data to output data
            std::memcpy(output_data + out_offset, input_data + in_offset, out_row_len * sizeof(T));
          }
        }
      }
      break;
    }
    default:
      throw std::runtime_error("Padding for rank > 4 NYI");
      break;
  }
}

References nnfw::cker::Shape::DimensionsCount(), nnfw::cker::Shape::Dims(), and output_shape.

◆ FullyConnectedBiasGrad()

template<typename T >

void nnfw::cker::train::FullyConnectedBiasGrad	(	const Shape &	incomming_shape,
		const T *	incomming_data,
		const Shape &	grad_shape,
		T *	grad_data
	)

inline

Definition at line 31 of file FullyConnected.h.

{
  const auto bias_size = grad_shape.FlatSize();
  if (bias_size != incomming_shape.Dims(incomming_shape.DimensionsCount() - 1) ||
      bias_size != grad_shape.Dims(0))
    throw std::runtime_error("cker::FullyConnectedBiasGrad: Unmatched shape");
 
  const auto in_mat = MapAsMatrixWithLastDimAsRows(incomming_data, incomming_shape);
  auto grad_mat = MapAsMatrixWithLastDimAsRows(grad_data, grad_shape);
 
  grad_mat = in_mat.rowwise().sum();
}

References nnfw::cker::Shape::DimensionsCount(), nnfw::cker::Shape::Dims(), nnfw::cker::Shape::FlatSize(), and nnfw::cker::MapAsMatrixWithLastDimAsRows().

◆ GradientDescent()

void nnfw::cker::train::GradientDescent	(	const Shape &	output_shape,
		float *	output_data,
		const Shape &	grad_shape,
		const float *	grad_data,
		float	learning_rate
	)

inline

Definition at line 33 of file SGD.h.

{
  Tensor output_tensor;
  Tensor grad_tensor;
  Tensor lr_tensor;
 
  output_tensor.shape.ReplaceWith(output_shape.DimensionsCount(), output_shape.DimsData());
  output_tensor.buffer = output_data;
 
  grad_tensor.shape.ReplaceWith(grad_shape.DimensionsCount(), grad_shape.DimsData());
  grad_tensor.buffer = const_cast<float *>(grad_data);
 
  std::vector<float> lr_vec{learning_rate};
  lr_tensor.buffer = lr_vec.data();
 
  if (output_shape != grad_shape)
    throw std::runtime_error(
      "cker::GradientDescent: output and gradient do not have the same shape");
 
  const training_ops::CPUDevice &device = *eigen_support::GetThreadPoolDevice();
  training_ops::functor::ApplyGradientDescent<training_ops::CPUDevice, float>()(
    device, output_tensor.flat<float>(), lr_tensor.scalar<float>(),
    static_cast<const Tensor &>(grad_tensor).flat<float>());
}

References nnfw::cker::Tensor::buffer, nnfw::cker::Shape::DimensionsCount(), nnfw::cker::Shape::DimsData(), nnfw::cker::eigen_support::GetThreadPoolDevice(), output_shape, nnfw::cker::Shape::ReplaceWith(), nnfw::cker::Tensor::scalar(), and nnfw::cker::Tensor::shape.

Referenced by onert::backend::train::optimizer::SGD::applyGradient().

◆ log_threshold()

template<typename T >

T nnfw::cker::train::log_threshold ( )

inline

Definition at line 38 of file Loss.h.

38{ return static_cast<T>(1e-20); }

◆ MaxPool2D()

void nnfw::cker::train::MaxPool2D	(	const PoolParams &	params,
		const Shape &	input_shape,
		const float *	input_data,
		const Shape &	output_shape,
		float *	output_data,
		int *	arg_max_index
	)

inline

Definition at line 36 of file MaxPool.h.

{
  assert(input_shape.DimensionsCount() == 4);
  assert(output_shape.DimensionsCount() == 4);
  assert(input_shape.Dims(0) == output_shape.Dims(0)); // MaxPool2D doesn't change batch
  assert(input_shape.Dims(3) == output_shape.Dims(3)); // MaxPool2D doesn't change depth
 
  const int batches = MatchingDim(input_shape, 0, output_shape, 0);
  const int input_height = input_shape.Dims(1);
  const int input_width = input_shape.Dims(2);
  const int output_height = output_shape.Dims(1);
  const int output_width = output_shape.Dims(2);
  const int filter_height = params.filter_height;
  const int filter_width = params.filter_width;
  const int pad_height = params.padding_values.height;
  const int pad_width = params.padding_values.width;
  const int stride_height = params.stride_height;
  const int stride_width = params.stride_width;
 
  const auto in_mat = MapAsMatrixWithLastDimAsRows(input_data, input_shape);
  auto out_mat = MapAsMatrixWithLastDimAsRows(output_data, output_shape);
  auto arg_max_index_mat = MapAsMatrixWithLastDimAsRows(arg_max_index, output_shape);
 
  // initialize output area
  std::fill(output_data, output_data + output_shape.FlatSize(), 0.0);
  std::fill(arg_max_index, arg_max_index + output_shape.FlatSize(), -1);
 
  // initialize projected area with lowest float
  const int h_start =
    (pad_height < filter_height) ? 0 : (pad_height - filter_height) / stride_height + 1;
  const int h_end = std::min((input_height + pad_height - 1) / stride_height + 1, output_height);
 
  const int w_start =
    (pad_width < filter_width) ? 0 : (pad_width - filter_width) / stride_width + 1;
  const int w_end = std::min((input_width + pad_width - 1) / stride_width + 1, output_width);
 
  for (int b = 0; b < batches; ++b)
  {
    for (int h_idx = h_start; h_idx < h_end; h_idx++)
    {
      for (int w_idx = w_start; w_idx < w_end; w_idx++)
      {
        const int offset = NodeOffset(b, h_idx, w_idx, output_height, output_width);
        out_mat.col(offset).setConstant(std::numeric_limits<float>::lowest());
      }
    }
  }
 
  for (int b = 0; b < batches; ++b)
  {
    for (int h = 0; h < input_height; ++h)
    {
      for (int w = 0; w < input_width; ++w)
      {
        // (h_start, h_end) * (w_start, w_end) is the range that the input
        // vector projects to.
        int hpad = h + pad_height;
        int wpad = w + pad_width;
 
        int h_start = (hpad < filter_height) ? 0 : (hpad - filter_height) / stride_height + 1;
        int h_end = std::min(hpad / stride_height + 1, output_height);
 
        int w_start = (wpad < filter_width) ? 0 : (wpad - filter_width) / stride_width + 1;
        int w_end = std::min(wpad / stride_width + 1, output_width);
 
        // compute elementwise sum
        for (int ph = h_start; ph < h_end; ++ph)
        {
          for (int pw = w_start; pw < w_end; ++pw)
          {
            const int out_offset = NodeOffset(b, ph, pw, output_height, output_width);
            const int in_offset = NodeOffset(b, h, w, input_height, input_width);
 
            const auto out_vector = out_mat.col(out_offset);
            const auto in_vector = in_mat.col(in_offset);
 
            // update arg_max_index_mat
            arg_max_index_mat.col(out_offset) =
              (out_vector.array() < in_vector.array())
                .select(in_offset, arg_max_index_mat.col(out_offset));
 
            // update out_mat
            out_mat.col(out_offset) = out_vector.cwiseMax(in_vector);
          }
        }
      }
    }
  }
 
  out_mat = out_mat.cwiseMin(params.float_activation_max).cwiseMax(params.float_activation_min);
}

References nnfw::cker::Shape::DimensionsCount(), nnfw::cker::Shape::Dims(), nnfw::cker::PoolParams::filter_height, nnfw::cker::PoolParams::filter_width, nnfw::cker::PoolParams::float_activation_max, nnfw::cker::PoolParams::float_activation_min, nnfw::cker::PaddingValues::height, nnfw::cker::MapAsMatrixWithLastDimAsRows(), nnfw::cker::MatchingDim(), nnfw::cker::NodeOffset(), offset(), output_shape, nnfw::cker::PoolParams::padding_values, nnfw::cker::PoolParams::stride_height, nnfw::cker::PoolParams::stride_width, and nnfw::cker::PaddingValues::width.

◆ MaxPool2DGrad()

void nnfw::cker::train::MaxPool2DGrad	(	const Shape &	incoming_shape,
		const float *	incoming_data,
		const int *	arg_max_index,
		const Shape &	grad_shape,
		float *	grad_data
	)

inline

Definition at line 129 of file MaxPool.h.

{
  assert(grad_shape.DimensionsCount() == 4);
  assert(incoming_shape.DimensionsCount() == 4);
 
  // initialize grad_data
  std::fill(grad_data, grad_data + grad_shape.FlatSize(), 0.0);
 
  const int depth = MatchingDim(grad_shape, 3, incoming_shape, 3);
  const auto incoming_mat = MapAsMatrixWithLastDimAsRows(incoming_data, incoming_shape);
  auto arg_max_index_mat = MapAsMatrixWithLastDimAsRows(arg_max_index, incoming_shape);
  auto grad_mat = MapAsMatrixWithLastDimAsRows(grad_data, grad_shape);
 
  for (int col_index = 0; col_index < incoming_mat.cols(); col_index++)
  {
    auto arg_indices = arg_max_index_mat.col(col_index);
    for (int d = 0; d < depth; d++)
    {
      // output value is from padding, so nothing to propagate
      if (arg_indices(d) == -1)
        continue;
 
      grad_mat(d, arg_indices(d)) += incoming_mat(d, col_index);
    }
  }
}

References nnfw::cker::Shape::DimensionsCount(), nnfw::cker::Shape::FlatSize(), nnfw::cker::MapAsMatrixWithLastDimAsRows(), and nnfw::cker::MatchingDim().

◆ MeanGrad()

template<typename T >

void nnfw::cker::train::MeanGrad	(	const Shape &	incoming_shape,
		const T *	incoming_data,
		const Shape &	grad_shape,
		T *	grad_data
	)

Definition at line 32 of file ReduceMean.h.

{
  BroadcastTo(incoming_shape, const_cast<T *>(incoming_data), grad_shape, grad_data);
  const auto incoming = MapAsMatrixWithLastDimAsRows(incoming_data, incoming_shape);
  auto grad = MapAsMatrixWithLastDimAsRows(grad_data, grad_shape);
  grad /= (grad.size() / incoming.size());
}

References nnfw::cker::BroadcastTo(), and nnfw::cker::MapAsMatrixWithLastDimAsRows().

Referenced by onert::backend::train::ops::MeanLayer::backward().

◆ MSE()

template<typename T >

void nnfw::cker::train::MSE	(	const Shape &	y_pred_shape,
		const T *	y_pred_data,
		const Shape &	y_true_shape,
		const T *	y_true_data,
		const Shape &	output_shape,
		T *	output_data
	)

inline

Definition at line 41 of file Loss.h.

{
  if (output_shape.DimensionsCount() != 1)
    throw std::runtime_error("cker::MSE: output dimension count should be 1");
  if (output_shape.Dims(0) != y_pred_shape.Dims(0))
    throw std::runtime_error("cker::MSE: output and y_pred do not have the same batch");
  if (y_pred_shape != y_true_shape)
    throw std::runtime_error("cker::MSE: y_pred_shape != y_true_shape");
 
  const auto batch = y_pred_shape.Dims(0);
  const auto size = FlatSizeSkipDim(y_pred_shape, 0);
 
  for (int b = 0; b < batch; ++b)
  {
    float sum = 0.f;
    for (int i = 0; i < size; ++i)
    {
      sum += square(y_pred_data[b * size + i] - y_true_data[b * size + i]);
    }
    output_data[b] = static_cast<T>(sum / size);
  }
}

References nnfw::cker::Shape::Dims(), nnfw::cker::FlatSizeSkipDim(), output_shape, size, and square().

Referenced by onert::backend::train::ops::LossMeanSquaredErrorLayer::forward().

◆ MSEGrad()

template<typename T >

void nnfw::cker::train::MSEGrad	(	const Shape &	y_pred_shape,
		const T *	y_pred_data,
		const Shape &	y_true_shape,
		const T *	y_true_data,
		const Shape &	grad_shape,
		T *	grad_data,
		LossReductionType	reduction_type
	)

inline

Definition at line 66 of file Loss.h.

{
  if (y_pred_shape != y_true_shape)
    throw std::runtime_error("cker::MSEGrad: y_pred_shape != y_true_shape");
  if (y_pred_shape != grad_shape)
    throw std::runtime_error("cker::MSEGrad: y_pred_shape != grad_shape");
 
  const int batch_size = grad_shape.Dims(0);
  const auto flat_size = FlatSizeSkipDim(grad_shape, 0);
  auto reduction_size = 1;
  switch (reduction_type)
  {
    case LossReductionType::SUM_OVER_BATCH_SIZE:
      reduction_size = batch_size * flat_size;
      break;
    case LossReductionType::SUM:
      reduction_size = flat_size;
      break;
    default:
      throw std::runtime_error("Unsupported reduction type");
  }
 
  for (int b = 0; b < batch_size; ++b)
  {
    for (int i = 0; i < flat_size; ++i)
    {
      const int offset = b * flat_size + i;
      assert(offset >= 0);
      grad_data[offset] =
        static_cast<T>(-2 * (y_true_data[offset] - y_pred_data[offset]) / reduction_size);
    }
  }
}

References nnfw::cker::Shape::Dims(), nnfw::cker::FlatSizeSkipDim(), offset(), SUM, and SUM_OVER_BATCH_SIZE.

Referenced by onert::backend::train::ops::LossMeanSquaredErrorLayer::backward().

◆ ReLU6Grad()

void nnfw::cker::train::ReLU6Grad	(	const Shape &	output_shape,
		const float *	output_data,
		const Shape &	incoming_shape,
		const float *	incoming_data,
		const Shape &	grad_shape,
		float *	grad_data
	)

inline

Definition at line 31 of file ReLU6.h.

{
  const auto output_map = MapAsVector(output_data, output_shape);
  const auto incoming_map = MapAsVector(incoming_data, incoming_shape);
  auto grad_map = MapAsVector(grad_data, grad_shape);
 
  if (output_shape != incoming_shape || output_shape != grad_shape)
    throw std::runtime_error{"cker::ReLU6Grad: Unsupported shape"};
 
  grad_map.array() =
    incoming_map.array() *
    (0.0f < output_map.array() && output_map.array() < 6.0f).template cast<float>();
}

References nnfw::cker::MapAsVector(), and output_shape.

Referenced by onert::backend::train::ops::backpropActivation(), and onert::backend::train::ops::ElementwiseActivationLayer::configureBackward().

◆ ReLUGrad()

void nnfw::cker::train::ReLUGrad	(	const Shape &	output_shape,
		const float *	output_data,
		const Shape &	incoming_shape,
		const float *	incoming_data,
		const Shape &	grad_shape,
		float *	grad_data
	)

inline

Definition at line 32 of file ReLU.h.

{
  const auto output_map = MapAsVector(output_data, output_shape);
  const auto incoming_map = MapAsVector(incoming_data, incoming_shape);
  auto grad_map = MapAsVector(grad_data, grad_shape);
 
  if (output_shape == incoming_shape && output_shape == grad_shape)
    grad_map.array() = incoming_map.array() * (output_map.array() > 0.0f).template cast<float>();
  else
    throw std::runtime_error("cker::ReLUGrad: Unsupported shape");
}

References nnfw::cker::MapAsVector(), and output_shape.

Referenced by onert::backend::train::ops::backpropActivation(), and onert::backend::train::ops::ElementwiseActivationLayer::configureBackward().

◆ SoftMaxGrad()

void nnfw::cker::train::SoftMaxGrad	(	const Shape &	output_shape,
		const float *	output_data,
		const Shape &	incoming_shape,
		const float *	incoming_data,
		const Shape &	grad_shape,
		float *	grad_data
	)

inline

Definition at line 30 of file SoftMax.h.

{
  // TODO Support 4dim softmax gradient
  assert(incoming_shape.DimensionsCount() == 2);
  MatchingFlatSize(output_shape, incoming_shape, grad_shape);
 
  const int batches = incoming_shape.Dims(0);
  const int width = incoming_shape.Dims(1);
 
  for (int b = 0; b < batches; ++b)
  {
    int b_offset = b * width;
    for (int w1 = 0; w1 < width; ++w1)
    {
      float sum = 0.0f;
      for (int w2 = 0; w2 < width; ++w2)
      {
        float val;
        if (w1 == w2)
        {
          val = output_data[b_offset + w2] * (1.f - output_data[b_offset + w2]);
        }
        else
        {
          val = -output_data[b_offset + w2] * output_data[b_offset + w1];
        }
        val *= incoming_data[b_offset + w2];
        sum += val;
      }
      grad_data[b_offset + w1] = sum;
    }
  }
}

References nnfw::cker::Shape::DimensionsCount(), nnfw::cker::Shape::Dims(), nnfw::cker::MatchingFlatSize(), and output_shape.

Referenced by onert::backend::train::ops::SoftMaxLayer::backward().

◆ square()

template<typename T >

T nnfw::cker::train::square ( T value )

inline

Definition at line 37 of file Loss.h.

37{ return value * value; }

Referenced by MSE().

Namespaces

Data Structures

Enumerations

Functions

Enumeration Type Documentation

◆ ArithmeticType

◆ LossReductionType

Function Documentation

◆ Adam()

◆ AveragePool2DGrad()

◆ backpropFilter()

◆ backpropInput()

◆ BinaryArithmeticGrad()

◆ CategoricalCrossEntropy()

◆ CategoricalCrossEntropyGrad()

◆ CategoricalCrossEntropyWithLogits()

◆ ConvFilterGrad()

◆ ConvInputGrad()

◆ Depad()

◆ FullyConnectedBiasGrad()

◆ GradientDescent()

◆ log_threshold()

◆ MaxPool2D()

◆ MaxPool2DGrad()

◆ MeanGrad()

◆ MSE()

◆ MSEGrad()

◆ ReLU6Grad()

◆ ReLUGrad()

◆ SoftMaxGrad()

◆ square()