code: def _spectral_norm_backward(dw_sn, w, u, dim=0, itr=1, eps=1e-12):
      # Forward recomputation
  
      w_shape = w.shape
      # Transpose if the output dimension is not the most-left dimension.
      if dim != 0:
          dims_transpose = [dim] + [
              i for i in range(len(w_shape)) if i != dim
          ]
          w = F.transpose(w, dims_transpose)
          w_shape = w.shape
      d0 = w.shape[0]  # Out
      d1 = np.prod(w.shape[1:])  # In
      w = F.reshape(w, [d0, d1])
      u = F.reshape(u, [1, d0])
      # Power method
      for _ in range(itr):
          # v
          v = F.affine(u, w)
          v = v / ((F.sum(v**2.0, keepdims=True) + eps) ** 0.5)
          v = F.reshape(v, [d1, 1])
          # u
          u = F.affine(w, v)
          u = u / ((F.sum(u**2.0, keepdims=True) + eps) ** 0.5)
          u = F.reshape(u, [1, d0])
      # No grad
      u = no_grad(u)
      v = no_grad(v)
      # Spectral normalization
      wv = F.affine(w, v)
      sigma = F.affine(u, wv)
      w_sn = w / sigma
      # The following process is not necessary for gradient calculation
      # w_sn = F.reshape(w_sn, w_shape)
      # # Transpose again if the output dimension is not the most-left dimension.
      # if dim != 0:
      #     dims_transpose = [i for i in range(1, dim + 1)] \
      #                      + [0] + [i for i in range(dim + 1, len(w_shape))]
      #     w_sn = F.transpose(w_sn, dims_transpose)
  
      # Backward
  
      # Backward for post-transpose
      if dim != 0:
          dims_transpose = [dim] + [
              i for i in range(len(w_shape)) if i != dim
          ]
          dw_sn = F.transpose(dw_sn, dims_transpose)
      dw_sn = dw_sn.reshape(w.shape)
  
      # Backward for spectral norm
      # Sum for broadcast backward
      S = sum_for_arithmetics(dw_sn * w_sn, sigma)
      # Add batch axis
      S = S.reshape((1,) + S.shape)
      u = u.reshape((1,) + u.shape)
      v = v.reshape((1,) + v.shape)
      m = F.batch_matmul(u, S, transpose_a=True)
      m = F.batch_matmul(m, v, transpose_b=True)
      # Remove batch axis
      m = m.reshape((m.shape[1], m.shape[2]))
      dw = (dw_sn - m) / sigma
  
      # Backward for pre-transpose
      dw = dw.reshape(w_shape)
      if dim != 0:
          dims_transpose = (
              [i for i in range(1, dim + 1)]
              + [0]
              + [i for i in range(dim + 1, len(w_shape))]
          )
          dw = F.transpose(dw, dims_transpose)
  
      return dw, None
  
imports: import numpy
  import nnabla
  import nnabla.functions
  from .utils import no_grad, sum_for_arithmetics
label_desc: Use image node_id 1 for calling a global function with example usage: _spectral_norm_backward(dw_sn, w, u, dim, itr, eps) and returns: dw,  None