  
      @classmethod
      def _filter_node(cls, node):
          """ Given in input list of nodes from a :attr:`keras.models.Model.get_config` dictionary,
          filters the information out and unravels the dictionary into a more usable format
  
          Parameters
          ----------
          node: list
              A node entry from the :attr:`keras.models.Model.get_config` dictionary
 
</s> remove         node: list
 </s> add         nodes: list </s> remove     @classmethod
    def _filter_node(cls, node):
 </s> add     def _get_nodes(self, nodes): </s> remove             A squeezed list with only the layer name entries remaining
        """
        retval = np.array(node)[..., 0].squeeze().tolist()
        return retval if isinstance(retval, list) else [retval]

    @classmethod
    def _get_inputs(cls, inputs, input_index):
        """ Obtain the inputs for the requested swap direction.

        Parameters
        ----------
        inputs: list
            The full list of input tensors to the saved faceswap training model
        input_index: int
            The input index for the requested swap direction

        Returns
        -------
        list
            List of input tensors to feed the model for the requested swap direction
 </s> add             The (node name, output index) for each node passed in </s> remove         retval = OrderedDict()
        for layer in self._config["layers"]:
            name = layer["name"]
            if not layer["inbound_nodes"]:
                logger.debug("Skipping input layer: '%s'", name)
                continue
            inbound = self._filter_node(layer["inbound_nodes"])

            # TODO Currently any models which have a list input will not contain the main model
            # input. This may not be true in future (if the main input is injected into a layer
            # further down the model chain) so this should be made more robust
            if (not any(isinstance(inb, list) for inb in inbound)
                    and self._input_names.intersection(inbound)):
                # Strip the input inbound nodes for applying the correct input layer at compile
                # time
                logger.debug("Stripping inbound nodes for input '%s': %s", name, inbound)
                inbound = ""

            if inbound and np.array(layer["inbound_nodes"]).shape[0] == 2:
                # if inbound is not populated, then layer is already split at input
                logger.debug("Filtering layer with split inbound nodes: '%s': %s", name, inbound)
                inbound = inbound[self._output_idx]
                inbound = inbound if isinstance(inbound, list) else [inbound]
                logger.debug("Filtered inbound nodes for layer '%s': %s", name, inbound)
            if name in self._outputs_dropout:
                logger.debug("Dropping output layer '%s'", name)
                continue
            retval[name] = inbound
        logger.debug("Model structure: %s", retval)
        return retval
 </s> add         # Filter output layer
        out = np.array(self._config["output_layers"], dtype="object")
        if out.ndim == 2:
            out = np.expand_dims(out, axis=1)  # Needs to be expanded for _get_nodes
        outputs = self._get_nodes(out)

        # Iterate backwards from the required output to get the reversed model structure
        current_layers = [outputs[0]]
        next_layers = []
        struct = OrderedDict()
        drop_input = self._input_names[abs(self._input_idx - 1)]
        switch_input = self._input_names[self._input_idx]
        while True:
            layer_info = current_layers.pop(0)
            current_layer = next(lyr for lyr in self._config["layers"]
                                 if lyr["name"] == layer_info[0])
            inbound = current_layer["inbound_nodes"] </s> remove         filtered_structure: :class:`OrderedDict`
            The full model structure with unused inbound nodes and layers removed
 </s> add         inputs: list
            The full list of input tensors to the saved faceswap training model
        filters the layer name(s) and output index of the node, splitting to the correct output
        index in the event of multiple inputs.
  
      @classmethod
      def _filter_node(cls, node):
          """ Given in input list of nodes from a :attr:`keras.models.Model.get_config` dictionary,
        filters the layer name(s) and output index of the node, splitting to the correct output
        index in the event of multiple inputs.
  
          Parameters
          ----------
          node: list
              A node entry from the :attr:`keras.models.Model.get_config` dictionary
keep keep keep keep replace keep keep keep keep keep
 plugins.train.model.base - More robust inference model generation 
plugins/train/model/_base.py