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_wrap(self, layer, pre_name, state, depth):
      for name, module in layer.named_children():
          nname = pre_name + "_" + name if pre_name != "" else name
  
          def new_forward(old_forward):
              def new_forward_1(self, *args, **kwargs):
                  o = old_forward(*args, **kwargs)
  
                  if self.do_mixup and self.training:
                      o = _mixup_inputs(o, state)
  
                  self.do_mixup = False
                  return o
  
              return new_forward_1
  
          if depth == self.depth or self.depth is None:
              self.layer_names.append(nname)
  
              if self._wrap_layer_check(module, name, nname):
                  self._layers.append(module)
                  nf = new_forward(module.forward)
  
                  bound_forward = types.MethodType(nf, module)
                  bound_mixup = types.MethodType(_mixup, module)
  
                  module.__setattr__("forward", bound_forward)
                  module.__setattr__("mixup", bound_mixup)
                  module.__setattr__("state", state)
                  module.__setattr__("do_mixup", False)
  
          if self.depth is None or depth <= self.depth:
              if len(list(layer.named_children())) > 0:
                  self._recursive_wrap(module, nname, state, depth + 1)
  
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 14 for calling the ManifoldMixup obj's underlying member method code with example usage: obj._recursive_wrap(layer, pre_name, state, depth) and returns: new_forward_1, o