code: def hierarchical_subsequence(
      sequential, first, last, after, upto, share_weights=False, depth=0
  ):
      """
      Recursive helper for subsequence() to support descent into dotted
      layer names.  In this helper, first, last, after, and upto are
      arrays of names resulting from splitting on dots.  Can only
      descend into nested Sequentials.
      """
      assert (last is None) or (upto is None)
      assert (first is None) or (after is None)
      if first is last is after is upto is None:
          return (
              sequential if share_weights else copy.deepcopy(sequential)
          )
      assert isinstance(sequential, torch.nn.Sequential), (
          ".".join((first or last or after or upto)[:depth] or "arg")
          + " not Sequential"
      )
      including_children = (first is None) and (after is None)
      included_children = OrderedDict()
      # A = current level short name of A.
      # AN = full name for recursive descent if not innermost.
      (F, FN), (L, LN), (A, AN), (U, UN) = [
          (d[depth], (None if len(d) == depth + 1 else d))
          if d is not None
          else (None, None)
          for d in [first, last, after, upto]
      ]
      for name, layer in sequential._modules.items():
          if name == F:
              first = None
              including_children = True
          if name == A and AN is not None:  # just like F if not a leaf.
              after = None
              including_children = True
          if name == U and UN is None:
              upto = None
              including_children = False
          if including_children:
              # AR = full name for recursive descent if name matches.
              FR, LR, AR, UR = [
                  n if n is None or n[depth] == name else None
                  for n in [FN, LN, AN, UN]
              ]
              chosen = hierarchical_subsequence(
                  layer,
                  first=FR,
                  last=LR,
                  after=AR,
                  upto=UR,
                  share_weights=share_weights,
                  depth=depth + 1,
              )
              if chosen is not None:
                  included_children[name] = chosen
          if name == L:
              last = None
              including_children = False
          if name == U and UN is not None:  # just like L if not a leaf.
              upto = None
              including_children = False
          if name == A and AN is None:
              after = None
              including_children = True
      for name in [first, last, after, upto]:
          if name is not None:
              raise ValueError("Layer %s not found" % ".".join(name))
      # Omit empty subsequences except at the outermost level,
      # where we should not return None.
      if not len(included_children) and depth > 0:
          return None
      result = torch.nn.Sequential(included_children)
      result.training = sequential.training
      return result
  
imports: import contextlib
  import copy
  import inspect
  from collections import OrderedDict
  import torch
label_desc: Use image node_id 3 for calling a global function with example usage: hierarchical_subsequence(sequential, first, last, after, upto, share_weights, depth) and returns: result, unknown, None