code: def build_loss(self):
          r
          image_dims = K.ndim(self.img) - 2
  
          # Constructing slice [1:] + [:-1] * (image_dims - 1) and [:-1] * (image_dims)
          start_slice = [slice(1, None, None)] + [slice(None, -1, None) for _ in range(image_dims - 1)]
          end_slice = [slice(None, -1, None) for _ in range(image_dims)]
          samples_channels_slice = [slice(None, None, None), slice(None, None, None)]
  
          # Compute pixel diffs by rolling slices to the right per image dim.
          tv = None
          for i in range(image_dims):
              ss = tuple(samples_channels_slice + start_slice)
              es = tuple(samples_channels_slice + end_slice)
              diff_square = K.square(self.img[utils.slicer[ss]] - self.img[utils.slicer[es]])
              tv = diff_square if tv is None else tv + diff_square
  
              # Roll over to next image dim
              start_slice = np.roll(start_slice, 1).tolist()
              end_slice = np.roll(end_slice, 1).tolist()
  
          tv = K.sum(K.pow(tv, self.beta / 2.))
          return normalize(self.img, tv)
docs: r"""Implements the N-dim version of function
          $$TV^{\beta}(x) = \sum_{whc} \left ( \left ( x(h, w+1, c) - x(h, w, c) \right )^{2} +
          \left ( x(h+1, w, c) - x(h, w, c) \right )^{2} \right )^{\frac{\beta}{2}}$$
          to return total variation for all images in the batch.