class_docstr: Performs manifold mixup on desired layers. Requires use of :meth:`MixupInputs.loss`, otherwise lambdas can be found in
  state under :attr:`.MIXUP_LAMBDA`. Model targets will be a tuple containing the original target and permuted target.
  
  Args:
      lam: Mixup lambda. If RANDOM, choose lambda from Beta(alpha, alpha). Else, lambda=lam
      alpha: Mixup alpha. Alpha used to sample lambda from Beta(alpha, alpha)
code: def _recursive_name_seach(self, layer_names, layer, pre_name, depth):
      for name, module in layer.named_children():
          nname = pre_name + "_" + name if pre_name != "" else name
          if depth == self.depth or self.depth is None:
              if self._wrap_layer_check(module, name, nname):
                  layer_names.append(nname)
  
          if self.depth is None or depth <= self.depth:
              if len(list(layer.named_children())) > 0:
                  self._recursive_name_seach(
                      layer_names, module, nname, depth + 1
                  )
      return layer_names
  
imports: from torchbearer import Callback
  import torchbearer
  from torch.distributions.beta import Beta
  import random
  import torch
  import types
  from torchbearer import cite
label_desc: Use image node_id 13 for calling the ManifoldMixup obj's underlying member method code with example usage: obj._recursive_name_seach(layer_names, layer, pre_name, depth) and returns: layer_names