class_docstr: Single `BatchNormalization -> Convolution` pass is folded into one `Convolution`.
  
  If there is a `BatchNormalization -> Convolution` pass,
  fold the batch normalization parameters to the kernel
  and bias (if it exists) of the preceding convolution,
  then skip the batch normalization following the convolution.
  
  Supported folding functions: `Convolution`, `Deconvolution`, `Affine`.
class_docstr_tok: ["Single","`","BatchNormalization","-",">","Convolution","`","pass","is","folded","into","one","`","Convolution","`",".","If","there","is","a","`","BatchNormalization","-",">","Convolution","`","pass",",","fold","the","batch","normalization","parameters","to","the","kernel","and","bias","(","if","it","exists",")","of","the","preceding","convolution",",","then","skip","the","batch","normalization","following","the","convolution",".","Supported","folding","functions",":","`","Convolution","`",",","`","Deconvolution","`",",","`","Affine","`","."]
code: def _compute_folded_parameters(self, ip_func, bn_func):
      beta_data = bn_func.inputs[1].d.copy()
      gamma_data = bn_func.inputs[2].d.copy()
      mean_data = bn_func.inputs[3].d.copy()
      var_data = bn_func.inputs[4].d.copy()
      eps_data = bn_func.info.args["eps"]
  
      # Reshape BN parameters to make it match with the weight of Conv/Deconv/Affine
      (
          beta_data,
          gamma_data,
          mean_data,
          var_data,
      ) = self.reshape_bn_parameters(
          ip_func,
          [beta_data, gamma_data, mean_data, var_data],
          self._channel_last,
      )
      std_data = np.sqrt(var_data + eps_data)
  
      c0 = gamma_data / std_data
      c1 = beta_data - (gamma_data * mean_data) / std_data
      w = ip_func.inputs[1]
      w_data = w.d
  
      # Reshape the weight of Affine
      if ip_func.info.type_name == "Affine":
          d_0, d_1, d_2 = bn_func.inputs[0].shape[1:]
          d_3 = w_data.shape[1:]
          w_data = np.reshape(w_data, (d_0, d_1, d_2, d_3))
  
      # Fold
      w_data = c0 * w_data
      b_data = w_data * c1
  
      w_data = (
          np.reshape(w_data, (-1, d_3))
          if ip_func.info.type_name == "Affine"
          else w_data
      )
  
      # Reduce the dimension of bias
      # Default setting for Conv
      axes_to_reduce = tuple(range(1, w_data.ndim))
      if ip_func.info.type_name == "Deconvolution":
          axes_to_reduce = (
              tuple(range(w_data.ndim - 1))
              if self._channel_last
              else (0,) + tuple(range(2, w_data.ndim))
          )
      axes_to_reduce = (
          (0, 1, 2)
          if ip_func.info.type_name == "Affine"
          else axes_to_reduce
      )
      b_data = np.sum(b_data, axes_to_reduce)
  
      if len(ip_func.inputs) == 3:
          b = ip_func.inputs[2]
          b_data += b.d
      return w_data, b_data
  
imports: import nnabla
  import nnabla.functions
  import numpy
  from nnabla.initializer import ConstantInitializer
  from nnabla.parameter import get_parameter_or_create
  from .graph_converter import FunctionModifier
label_desc: Use image node_id 4 for calling the BatchNormalizationFoldingOppositeModifierInner obj's underlying member method code with example usage: obj._compute_folded_parameters(ip_func, bn_func) and returns: w_data,  b_data