luci_interpreter_pal::lstm_internal Namespace Reference

Data Structures
struct	LstmSizeInfo
class	LstmStepManager

Functions
template<typename InputType , typename OutputType >
void	mulElementwise (int size, const ArithmeticParams *params, const InputType *input1_data, const InputType *input2_data, OutputType *output_data)
void	mul (const luci_interpreter::RuntimeShape &shape, const ArithmeticParams *params, const int16_t *input1_data, const int16_t *input2_data, int8_t *output_data)
void	mul (const luci_interpreter::RuntimeShape &shape, const ArithmeticParams *params, const int16_t *input1_data, const int16_t *input2_data, int16_t *output_data)
void	addElementWise (const int16_t *input_1, const int16_t *input_2, int n_batch, int n_input, int16_t *output)
void	tanh (int32_t cell_state_scale_power, const luci_interpreter::RuntimeShape &input_data_shape, int16_t *input_data, const luci_interpreter::RuntimeShape &output_data_shape, int16_t *output_data)
void	sigmoid (const luci_interpreter::RuntimeShape &data_shape, int16_t *data)
void	clipping (const int v_size, const luci_interpreter::lstm::CellStateInfo *cell_state_info, int16_t *vector)
void	mul (const luci_interpreter::RuntimeShape &shape, const ArithmeticParams *params, const float *input1_data, const float *input2_data, float *output_data)
void	addElementWise (const float *input_1, const float *input_2, int n_batch, int n_input, float *output)
void	tanh (int32_t, const luci_interpreter::RuntimeShape &input_data_shape, float *input_data, const luci_interpreter::RuntimeShape &output_data_shape, float *output_data)
void	sigmoid (const luci_interpreter::RuntimeShape &data_shape, float *data)
void	clipping (const int v_size, const luci_interpreter::lstm::CellStateInfo *cell_state_info, float *vector)
template<typename ActivationType , typename WeightType , typename CellType , typename BiasType >
void	calculateLstmGate (const LstmStepManager *step_info, const luci_interpreter::lstm::GateParameters *gate_params, ActivationType *input_data, const circle::Tensor *input_weight, const circle::Tensor *input_bias, ActivationType *recurrent_data, const circle::Tensor *recurrent_weight, const circle::Tensor *recurrent_bias, CellType *gate_output, CellType *fc_output_buffer, const FusedActivation activation, luci_interpreter::BaseRuntimeGraph *runtime_graph)
template<typename CellType , typename ActivationType >
void	updateLstmHidden (const LstmStepManager *step_info, CellType *cell_state_data_base, ActivationType *hidden_state_data, const CellType *output_gate_output, const ArithmeticParams *mul_params, int32_t cell_state_scale_power, CellType *buffer)
template<typename CellType >
void	updateLstmCell (const LstmStepManager *step_info, CellType *cell_state_data, CellType *forget_gate_output, const CellType *input_gate_output, const CellType *cell_gate_output, const ArithmeticParams &forget_cell_mul_params, const ArithmeticParams &input_mul_params, const luci_interpreter::lstm::CellStateInfo *cell_state_info, CellType *buffer)
template<typename ActivationType , typename WeightType , typename CellType , typename BiasType >
void	lstmStep (luci_interpreter::lstm::LSTMStruct *lstm_struct, luci_interpreter::lstm::LSTMParameters *lstm_params, LstmStepManager *step_info, luci_interpreter::lstm::CellStateInfo *cell_state_info, ActivationType *output_state_data, CellType *cell_state_data, CellType *scratch0, CellType *scratch1, CellType *scratch2, CellType *scratch3, luci_interpreter::BaseRuntimeGraph *runtime_graph)

Function Documentation

addElementWise() [1/2]

void luci_interpreter_pal::lstm_internal::addElementWise	(	const float *	input_1,
		const float *	input_2,
		int	n_batch,
		int	n_input,
		float *	output
	)

Definition at line 142 of file PALUnidirectionalSequenceLSTMCommon.h.

{
  for (int batch = 0; batch < n_batch; ++batch)
  {
    for (int i = 0; i < n_input; ++i)
    {
      const int index = batch * n_input + i;
      output[index] = input_1[index] + input_2[index];
    }
  }
}

addElementWise() [2/2]

void luci_interpreter_pal::lstm_internal::addElementWise	(	const int16_t *	input_1,
		const int16_t *	input_2,
		int	n_batch,
		int	n_input,
		int16_t *	output
	)

Definition at line 84 of file PALUnidirectionalSequenceLSTMCommon.h.

{
  for (int batch = 0; batch < n_batch; ++batch)
  {
    for (int i = 0; i < n_input; ++i)
    {
      const int index = batch * n_input + i;
      int32_t sum = input_1[index] + input_2[index];
      const int32_t sum_clamped =
        std::min(static_cast<int32_t>(std::numeric_limits<int16_t>::max()),
                 std::max(static_cast<int32_t>(std::numeric_limits<int16_t>::min()), sum));
      output[index] = static_cast<int16_t>(sum_clamped);
    }
  }
}

Referenced by calculateLstmGate(), and updateLstmCell().

calculateLstmGate()

template<typename ActivationType , typename WeightType , typename CellType , typename BiasType >

void luci_interpreter_pal::lstm_internal::calculateLstmGate	(	const LstmStepManager *	step_info,
		const luci_interpreter::lstm::GateParameters *	gate_params,
		ActivationType *	input_data,
		const circle::Tensor *	input_weight,
		const circle::Tensor *	input_bias,
		ActivationType *	recurrent_data,
		const circle::Tensor *	recurrent_weight,
		const circle::Tensor *	recurrent_bias,
		CellType *	gate_output,
		CellType *	fc_output_buffer,
		const FusedActivation	activation,
		luci_interpreter::BaseRuntimeGraph *	runtime_graph
	)

Definition at line 278 of file PALUnidirectionalSequenceLSTMCommon.h.

{
  // Input FC
  const auto gate_output_shape = step_info->stateShape();
  {
    FullyConnectedParams op_params{};
    op_params.input_offset = gate_params->input_fc_params.input_offset;
    op_params.weights_offset = gate_params->input_fc_params.weights_offset;
    op_params.output_offset = gate_params->input_fc_params.output_offset;
    op_params.output_multiplier = gate_params->input_fc_params.output_multiplier;
    op_params.output_shift = gate_params->input_fc_params.output_shift;
    op_params.quantized_activation_min = gate_params->input_fc_params.quantized_activation_min;
    op_params.quantized_activation_max = gate_params->input_fc_params.quantized_activation_max;
    op_params.float_activation_max = gate_params->input_fc_params.float_activation_max;
    op_params.float_activation_min = gate_params->input_fc_params.float_activation_min;
 
    int32_t input_weight_shape[luci_interpreter::kMaxSmallSize];
    luci_interpreter::kernels::getTensorDims(input_weight, runtime_graph, input_weight_shape);
 
    FullyConnected(op_params, step_info->inputShape().dimsData(),
                   input_data + step_info->inputOffset(), input_weight_shape,
                   luci_interpreter::kernels::getTensorData<WeightType>(
                     runtime_graph->getConstDataByTensor(input_weight)),
                   luci_interpreter::kernels::getTensorData<BiasType>(
                     runtime_graph->getConstDataByTensor(input_bias)),
                   gate_output_shape.dimsData(), gate_output, gate_output_shape.dimensionsCount(),
                   luci_interpreter::Tensor::num_dims(input_weight));
  }
 
  // Recurrent FC
  {
    FullyConnectedParams op_params{};
    op_params.input_offset = gate_params->recurrent_fc_params.input_offset;
    op_params.weights_offset = gate_params->recurrent_fc_params.weights_offset;
    op_params.output_offset = gate_params->recurrent_fc_params.output_offset;
    op_params.output_multiplier = gate_params->recurrent_fc_params.output_multiplier;
    op_params.output_shift = gate_params->recurrent_fc_params.output_shift;
    op_params.quantized_activation_min = gate_params->recurrent_fc_params.quantized_activation_min;
    op_params.quantized_activation_max = gate_params->recurrent_fc_params.quantized_activation_max;
    op_params.float_activation_max = gate_params->recurrent_fc_params.float_activation_max;
    op_params.float_activation_min = gate_params->recurrent_fc_params.float_activation_min;
 
    int32_t recurrent_weight_shape[luci_interpreter::kMaxSmallSize];
    luci_interpreter::kernels::getTensorDims(recurrent_weight, runtime_graph,
                                             recurrent_weight_shape);
 
    FullyConnected(op_params, step_info->stateShape().dimsData(),
                   recurrent_data + step_info->hiddenStateOffset(), recurrent_weight_shape,
                   luci_interpreter::kernels::getTensorData<WeightType>(
                     runtime_graph->getConstDataByTensor(recurrent_weight)),
                   luci_interpreter::kernels::getTensorData<BiasType>(
                     runtime_graph->getConstDataByTensor(recurrent_bias)),
                   gate_output_shape.dimsData(), fc_output_buffer,
                   gate_output_shape.dimensionsCount(),
                   luci_interpreter::Tensor::num_dims(recurrent_weight));
 
    addElementWise(gate_output, fc_output_buffer, /*n_batch=*/gate_output_shape.dimsData()[0],
                   /*n_state=*/gate_output_shape.dimsData()[1], gate_output);
 
    switch (activation)
    {
      case FusedActivation::kTfLiteActSigmoid:
        sigmoid(gate_output_shape, gate_output);
        break;
      case FusedActivation::kTfLiteActTanh:
      {
        // Set the scale power to -12 to avoid shift
        tanh(/*cell_state_scale_power=*/-12, gate_output_shape, gate_output, gate_output_shape,
             gate_output);
      }
      break;
      default:
        // Only Sigmoid or Tanh is used.
        assert(false && "Only Sigmoid or Tanh is used");
    }
  }
}

References addElementWise(), luci_interpreter::RuntimeShape::dimsData(), luci_interpreter_pal::FullyConnectedParams::float_activation_max, luci_interpreter_pal::FullyConnectedParams::float_activation_min, luci_interpreter::RuntimeGraph::getConstDataByTensor(), luci_interpreter::kernels::getTensorDims(), luci_interpreter_pal::lstm_internal::LstmStepManager::hiddenStateOffset(), luci_interpreter::lstm::GateParameters::input_fc_params, luci_interpreter_pal::FullyConnectedParams::input_offset, luci_interpreter_pal::lstm_internal::LstmStepManager::inputOffset(), luci_interpreter_pal::lstm_internal::LstmStepManager::inputShape(), luci_interpreter_pal::FullyConnectedParams::output_multiplier, luci_interpreter_pal::FullyConnectedParams::output_offset, luci_interpreter_pal::FullyConnectedParams::output_shift, luci_interpreter_pal::FullyConnectedParams::quantized_activation_max, luci_interpreter_pal::FullyConnectedParams::quantized_activation_min, luci_interpreter::lstm::GateParameters::recurrent_fc_params, sigmoid(), luci_interpreter_pal::lstm_internal::LstmStepManager::stateShape(), tanh(), and luci_interpreter_pal::FullyConnectedParams::weights_offset.

clipping() [1/2]

void luci_interpreter_pal::lstm_internal::clipping	(	const int	v_size,
		const luci_interpreter::lstm::CellStateInfo *	cell_state_info,
		float *	vector
	)

Definition at line 168 of file PALUnidirectionalSequenceLSTMCommon.h.

{
  for (int i = 0; i < v_size; i++)
  {
    vector[i] =
      std::max(std::min(cell_state_info->cell_clip, vector[i]), -cell_state_info->cell_clip);
  }
}

References luci_interpreter::lstm::CellStateInfo::cell_clip.

clipping() [2/2]

void luci_interpreter_pal::lstm_internal::clipping	(	const int	v_size,
		const luci_interpreter::lstm::CellStateInfo *	cell_state_info,
		int16_t *	vector
	)

Definition at line 122 of file PALUnidirectionalSequenceLSTMCommon.h.

{
  for (int i = 0; i < v_size; i++)
  {
    vector[i] = std::max(std::min(cell_state_info->quantized_cell_clip, vector[i]),
                         static_cast<int16_t>(-cell_state_info->quantized_cell_clip));
  }
}

References luci_interpreter::lstm::CellStateInfo::quantized_cell_clip.

Referenced by updateLstmCell().

lstmStep()

template<typename ActivationType , typename WeightType , typename CellType , typename BiasType >

void luci_interpreter_pal::lstm_internal::lstmStep	(	luci_interpreter::lstm::LSTMStruct *	lstm_struct,
		luci_interpreter::lstm::LSTMParameters *	lstm_params,
		LstmStepManager *	step_info,
		luci_interpreter::lstm::CellStateInfo *	cell_state_info,
		ActivationType *	output_state_data,
		CellType *	cell_state_data,
		CellType *	scratch0,
		CellType *	scratch1,
		CellType *	scratch2,
		CellType *	scratch3,
		luci_interpreter::BaseRuntimeGraph *	runtime_graph
	)

Definition at line 422 of file PALUnidirectionalSequenceLSTMCommon.h.

{
  /*Step1: Calculate gate outputs to prepare cell state update*/
  CellType *gate_internal_buffer = scratch3;
  CellType *forget_gate_output = scratch0;
 
  auto input_data = luci_interpreter::kernels::getTensorData<ActivationType>(
    runtime_graph->getDataByTensor(lstm_struct->input()));
 
  calculateLstmGate<ActivationType, WeightType, CellType, BiasType>(
    step_info, &lstm_params->forget_gate_parameters,
    // Input FC
    input_data, lstm_struct->input_to_forget_weights(), lstm_struct->forget_gate_bias(),
    // Recurrent FC
    output_state_data, lstm_struct->recurrent_to_forget_weights(), nullptr,
    // Output
    forget_gate_output, gate_internal_buffer, FusedActivation::kTfLiteActSigmoid, runtime_graph);
 
  // Input Gate calculation;
  CellType *input_gate_output = scratch1;
  calculateLstmGate<ActivationType, WeightType, CellType, BiasType>(
    step_info, &lstm_params->input_gate_parameters,
    // Input FC
    input_data, lstm_struct->input_to_input_weights(), lstm_struct->input_gate_bias(),
    // Recurrent FC
    output_state_data, lstm_struct->recurrent_to_input_weights(),
    /*recurrent_bias*/ nullptr,
    // Output
    input_gate_output,
    // Scratch arrays
    gate_internal_buffer, FusedActivation::kTfLiteActSigmoid, runtime_graph);
 
  // Cell Gate calculation
  CellType *cell_gate_output = scratch2;
  calculateLstmGate<ActivationType, WeightType, CellType, BiasType>(
    step_info, &lstm_params->cell_gate_parameters,
    // Input FC
    input_data, lstm_struct->input_to_cell_weights(), lstm_struct->cell_gate_bias(),
    // Recurrent FC
    output_state_data, lstm_struct->recurrent_to_cell_weights(),
    /*recurrent_bias*/ nullptr,
    // Output
    cell_gate_output,
    // Scratch arrays
    gate_internal_buffer, FusedActivation::kTfLiteActTanh, runtime_graph);
 
  /*Step2: update the cell state */
  {
    // const InterGateParameters& inter_gate_params = op_data.inter_gate_parameters;
    CellType *updated_input_buffer = scratch1; // reuse buffer
 
    updateLstmCell<CellType>(
      step_info, cell_state_data, forget_gate_output, input_gate_output, cell_gate_output,
      lstm_params->inter_gate_parameters.forget_cell_mul_params,
      lstm_params->inter_gate_parameters.input_mul_params, cell_state_info, updated_input_buffer);
  }
 
  {
    /*Step3: update the hidden state */
    CellType *output_gate_output = scratch1; // reuse buffer
    calculateLstmGate<ActivationType, WeightType, CellType, BiasType>(
      step_info, &lstm_params->output_gate_parameters,
      // Input FC
      input_data, lstm_struct->input_to_output_weights(), lstm_struct->output_gate_bias(),
      // Recurrent FC
      output_state_data, lstm_struct->recurrent_to_output_weights(), nullptr,
      // Output
      output_gate_output,
      // Scratch arrays
      gate_internal_buffer, FusedActivation::kTfLiteActSigmoid, runtime_graph);
    CellType *tanh_activated_cell_buffer = scratch0; // reuse buffer
    updateLstmHidden<CellType, ActivationType>(
      step_info, cell_state_data, output_state_data, output_gate_output,
      &lstm_params->inter_gate_parameters.output_mul_params,
      cell_state_info->cell_state_scale_power, tanh_activated_cell_buffer);
 
    ActivationType *output_ptr = luci_interpreter::kernels::getTensorData<ActivationType>(
      runtime_graph->getDataByTensor(lstm_struct->output()));
    std::memcpy(output_ptr + step_info->outputOffset(),
                output_state_data + step_info->hiddenStateOffset(),
                step_info->stateShape().flatSize() * sizeof(ActivationType));
  }
}

References luci_interpreter::lstm::LSTMStruct::cell_gate_bias(), luci_interpreter::lstm::LSTMParameters::cell_gate_parameters, luci_interpreter::lstm::CellStateInfo::cell_state_scale_power, luci_interpreter::RuntimeShape::flatSize(), luci_interpreter::lstm::InterGateParameters::forget_cell_mul_params, luci_interpreter::lstm::LSTMStruct::forget_gate_bias(), luci_interpreter::lstm::LSTMParameters::forget_gate_parameters, luci_interpreter::RuntimeGraph::getDataByTensor(), luci_interpreter_pal::lstm_internal::LstmStepManager::hiddenStateOffset(), luci_interpreter::lstm::LSTMStruct::input(), luci_interpreter::lstm::LSTMStruct::input_gate_bias(), luci_interpreter::lstm::LSTMParameters::input_gate_parameters, luci_interpreter::lstm::InterGateParameters::input_mul_params, luci_interpreter::lstm::LSTMStruct::input_to_cell_weights(), luci_interpreter::lstm::LSTMStruct::input_to_forget_weights(), luci_interpreter::lstm::LSTMStruct::input_to_input_weights(), luci_interpreter::lstm::LSTMStruct::input_to_output_weights(), luci_interpreter::lstm::LSTMParameters::inter_gate_parameters, luci_interpreter::lstm::LSTMStruct::output(), luci_interpreter::lstm::LSTMStruct::output_gate_bias(), luci_interpreter::lstm::LSTMParameters::output_gate_parameters, luci_interpreter::lstm::InterGateParameters::output_mul_params, luci_interpreter_pal::lstm_internal::LstmStepManager::outputOffset(), luci_interpreter::lstm::LSTMStruct::recurrent_to_cell_weights(), luci_interpreter::lstm::LSTMStruct::recurrent_to_forget_weights(), luci_interpreter::lstm::LSTMStruct::recurrent_to_input_weights(), luci_interpreter::lstm::LSTMStruct::recurrent_to_output_weights(), and luci_interpreter_pal::lstm_internal::LstmStepManager::stateShape().

mul() [1/3]

void luci_interpreter_pal::lstm_internal::mul	(	const luci_interpreter::RuntimeShape &	shape,
		const ArithmeticParams *	params,
		const float *	input1_data,
		const float *	input2_data,
		float *	output_data
	)

Definition at line 135 of file PALUnidirectionalSequenceLSTMCommon.h.

{
  const int flat_size = shape.flatSize();
  return luci_interpreter_pal::Mul(*params, flat_size, input1_data, input2_data, output_data);
}

References luci_interpreter::RuntimeShape::flatSize().

mul() [2/3]

void luci_interpreter_pal::lstm_internal::mul	(	const luci_interpreter::RuntimeShape &	shape,
		const ArithmeticParams *	params,
		const int16_t *	input1_data,
		const int16_t *	input2_data,
		int16_t *	output_data
	)

Definition at line 78 of file PALUnidirectionalSequenceLSTMCommon.h.

{
  return mulElementwise(shape.flatSize(), params, input1_data, input2_data, output_data);
}

References luci_interpreter::RuntimeShape::flatSize(), and mulElementwise().

mul() [3/3]

void luci_interpreter_pal::lstm_internal::mul	(	const luci_interpreter::RuntimeShape &	shape,
		const ArithmeticParams *	params,
		const int16_t *	input1_data,
		const int16_t *	input2_data,
		int8_t *	output_data
	)

Definition at line 70 of file PALUnidirectionalSequenceLSTMCommon.h.

{
  return mulElementwise<int16_t, int8_t>(shape.flatSize(), params, input1_data, input2_data,
                                         output_data);
}

References luci_interpreter::RuntimeShape::flatSize().

Referenced by updateLstmCell(), and updateLstmHidden().

mulElementwise()

template<typename InputType , typename OutputType >

void luci_interpreter_pal::lstm_internal::mulElementwise	(	int	size,
		const ArithmeticParams *	params,
		const InputType *	input1_data,
		const InputType *	input2_data,
		OutputType *	output_data
	)

Definition at line 51 of file PALUnidirectionalSequenceLSTMCommon.h.

{
  for (int i = 0; i < size; ++i)
  {
    const int32_t input1_val = params->input1_offset + input1_data[i];
    const int32_t input2_val = params->input2_offset + input2_data[i];
    const int32_t unclamped_result =
      params->output_offset + multiplyByQuantizedMultiplier(input1_val * input2_val,
                                                            params->output_multiplier,
                                                            params->output_shift);
    const int32_t clamped_output =
      std::min(params->quantized_activation_max,
               std::max(params->quantized_activation_min, unclamped_result));
    output_data[i] = static_cast<OutputType>(clamped_output);
  }
}

References luci_interpreter_pal::ArithmeticParams::input1_offset, luci_interpreter_pal::ArithmeticParams::input2_offset, luci_interpreter_pal::multiplyByQuantizedMultiplier(), luci_interpreter_pal::ArithmeticParams::output_multiplier, luci_interpreter_pal::ArithmeticParams::output_offset, luci_interpreter_pal::ArithmeticParams::output_shift, luci_interpreter_pal::ArithmeticParams::quantized_activation_max, luci_interpreter_pal::ArithmeticParams::quantized_activation_min, and size.

Referenced by mul().

sigmoid() [1/2]

void luci_interpreter_pal::lstm_internal::sigmoid	(	const luci_interpreter::RuntimeShape &	data_shape,
		float *	data
	)

Definition at line 162 of file PALUnidirectionalSequenceLSTMCommon.h.

{
  const int flat_size = data_shape.flatSize();
  luci_interpreter_pal::Logistic(flat_size, data, data);
}

References luci_interpreter::RuntimeShape::flatSize(), and luci_interpreter_pal::Logistic().

sigmoid() [2/2]

void luci_interpreter_pal::lstm_internal::sigmoid	(	const luci_interpreter::RuntimeShape &	data_shape,
		int16_t *	data
	)

Definition at line 117 of file PALUnidirectionalSequenceLSTMCommon.h.

{
  luci_interpreter_pal::Logistic(0, 0, data_shape.flatSize(), data, data);
}

References luci_interpreter::RuntimeShape::flatSize(), and luci_interpreter_pal::Logistic().

Referenced by calculateLstmGate().

tanh() [1/2]

void luci_interpreter_pal::lstm_internal::tanh	(	int32_t	cell_state_scale_power,
		const luci_interpreter::RuntimeShape &	input_data_shape,
		int16_t *	input_data,
		const luci_interpreter::RuntimeShape &	output_data_shape,
		int16_t *	output_data
	)

Definition at line 101 of file PALUnidirectionalSequenceLSTMCommon.h.

{
  int32_t tanh_input_left_shift = (15 + cell_state_scale_power) - 3;
  int32_t input_multiplier = 0;
  if (tanh_input_left_shift < 0) /* handling negative shift value */
  {
    tanh_input_left_shift = -tanh_input_left_shift;
    input_multiplier = 3;
  }
  const int flat_size = input_data_shape.flatSize();
  luci_interpreter_pal::Tanh(input_multiplier, tanh_input_left_shift, flat_size, input_data,
                             output_data);
}

References luci_interpreter::RuntimeShape::flatSize(), and luci_interpreter_pal::Tanh().

Referenced by calculateLstmGate(), and updateLstmHidden().

tanh() [2/2]

void luci_interpreter_pal::lstm_internal::tanh	(	int32_t	,
		const luci_interpreter::RuntimeShape &	input_data_shape,
		float *	input_data,
		const luci_interpreter::RuntimeShape &	output_data_shape,
		float *	output_data
	)

Definition at line 155 of file PALUnidirectionalSequenceLSTMCommon.h.

{
  const int flat_size = input_data_shape.flatSize();
  luci_interpreter_pal::Tanh(flat_size, input_data, output_data);
}

References luci_interpreter::RuntimeShape::flatSize(), and luci_interpreter_pal::Tanh().

updateLstmCell()

template<typename CellType >

void luci_interpreter_pal::lstm_internal::updateLstmCell	(	const LstmStepManager *	step_info,
		CellType *	cell_state_data,
		CellType *	forget_gate_output,
		const CellType *	input_gate_output,
		const CellType *	cell_gate_output,
		const ArithmeticParams &	forget_cell_mul_params,
		const ArithmeticParams &	input_mul_params,
		const luci_interpreter::lstm::CellStateInfo *	cell_state_info,
		CellType *	buffer
	)

Definition at line 391 of file PALUnidirectionalSequenceLSTMCommon.h.

{
  auto cell_state_shape = step_info->stateShape();
  // Forget Gate x Cell State
  mul(cell_state_shape, &forget_cell_mul_params, forget_gate_output,
      cell_state_data + step_info->cellStateOffset(),
      cell_state_data + step_info->cellStateOffset());
  // Input Gate x Cell Gate
  mul(cell_state_shape, &input_mul_params, input_gate_output, cell_gate_output, buffer);
 
  // Update the cell state
  addElementWise(cell_state_data + step_info->cellStateOffset(), buffer,
                 /*n_batch=*/cell_state_shape.dimsData()[0],
                 /*n_state=*/cell_state_shape.dimsData()[1],
                 cell_state_data + step_info->cellStateOffset());
 
  if (cell_state_info->cell_clip > 0)
  {
    clipping(cell_state_shape.flatSize(), cell_state_info,
             cell_state_data + step_info->cellStateOffset());
  }
}

References addElementWise(), luci_interpreter::lstm::CellStateInfo::cell_clip, luci_interpreter_pal::lstm_internal::LstmStepManager::cellStateOffset(), clipping(), mul(), and luci_interpreter_pal::lstm_internal::LstmStepManager::stateShape().

updateLstmHidden()

template<typename CellType , typename ActivationType >

void luci_interpreter_pal::lstm_internal::updateLstmHidden	(	const LstmStepManager *	step_info,
		CellType *	cell_state_data_base,
		ActivationType *	hidden_state_data,
		const CellType *	output_gate_output,
		const ArithmeticParams *	mul_params,
		int32_t	cell_state_scale_power,
		CellType *	buffer
	)

Definition at line 372 of file PALUnidirectionalSequenceLSTMCommon.h.

{
  auto cell_state_shape = step_info->stateShape();
  CellType *cell_state_data = cell_state_data_base + step_info->cellStateOffset();
  // Tanh(cell_state)
  tanh(cell_state_scale_power, cell_state_shape, cell_state_data, cell_state_shape, buffer);
  // Update the hidden state
  mul(cell_state_shape, mul_params, buffer, output_gate_output,
      hidden_state_data + step_info->hiddenStateOffset());
}

References luci_interpreter_pal::lstm_internal::LstmStepManager::cellStateOffset(), luci_interpreter_pal::lstm_internal::LstmStepManager::hiddenStateOffset(), mul(), luci_interpreter_pal::lstm_internal::LstmStepManager::stateShape(), and tanh().