              retval[name] = inbound
          logger.debug("Model structure: %s", retval)
          return retval
  
      @classmethod
      def _get_required_layers(cls, filtered_structure):
          """ Parse through the filtered model structure in reverse order to get the required layers
          from the faceswap model for creating an inference model.
  
          Parameters
          ----------
          filtered_structure: :class:`OrderedDict`
              The full model structure with unused inbound nodes and layers removed
 
</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 </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         set
            The layers from the saved model that are required to build the inference model
 </s> add         list
            List of input tensors to feed the model for the requested swap direction </s> remove         """ Obtain the structure of the full model, filtering out inbound nodes and
        layers that are not required for the requested swap destination.
 </s> add         """ Obtain the structure of the inference model. </s> remove         Input layers to the full model are not returned in the structure.
 </s> add         This parses the model config (in reverse) to obtain the required layers for an inference
        model.
            if not inbound:
                break

            inbound_info = self._get_nodes(inbound)

            if any(inb[0] == drop_input for inb in inbound_info):  # Switch inputs
                inbound_info = [(switch_input if inb[0] == drop_input else inb[0], inb[1])
                                for inb in inbound_info]
            struct[layer_info[0]] = inbound_info
            next_layers.extend(inbound_info)

            if not current_layers:
                current_layers = next_layers
                next_layers = []

        struct[switch_input] = []  # Add the input layer
        logger.debug("Model structure: %s", struct)
        return struct

    def _get_inputs(self, inputs):
        """ Obtain the inputs for the requested swap direction.
              retval[name] = inbound
          logger.debug("Model structure: %s", retval)
          return retval
  
            if not inbound:
                break

            inbound_info = self._get_nodes(inbound)

            if any(inb[0] == drop_input for inb in inbound_info):  # Switch inputs
                inbound_info = [(switch_input if inb[0] == drop_input else inb[0], inb[1])
                                for inb in inbound_info]
            struct[layer_info[0]] = inbound_info
            next_layers.extend(inbound_info)

            if not current_layers:
                current_layers = next_layers
                next_layers = []

        struct[switch_input] = []  # Add the input layer
        logger.debug("Model structure: %s", struct)
        return struct

    def _get_inputs(self, inputs):
        """ Obtain the inputs for the requested swap direction.
            if not inbound:
                break

            inbound_info = self._get_nodes(inbound)

            if any(inb[0] == drop_input for inb in inbound_info):  # Switch inputs
                inbound_info = [(switch_input if inb[0] == drop_input else inb[0], inb[1])
                                for inb in inbound_info]
            struct[layer_info[0]] = inbound_info
            next_layers.extend(inbound_info)

            if not current_layers:
                current_layers = next_layers
                next_layers = []

        struct[switch_input] = []  # Add the input layer
        logger.debug("Model structure: %s", struct)
        return struct

    def _get_inputs(self, inputs):
        """ Obtain the inputs for the requested swap direction.
            if not inbound:
                break

            inbound_info = self._get_nodes(inbound)

            if any(inb[0] == drop_input for inb in inbound_info):  # Switch inputs
                inbound_info = [(switch_input if inb[0] == drop_input else inb[0], inb[1])
                                for inb in inbound_info]
            struct[layer_info[0]] = inbound_info
            next_layers.extend(inbound_info)

            if not current_layers:
                current_layers = next_layers
                next_layers = []

        struct[switch_input] = []  # Add the input layer
        logger.debug("Model structure: %s", struct)
        return struct

    def _get_inputs(self, inputs):
        """ Obtain the inputs for the requested swap direction.
            if not inbound:
                break

            inbound_info = self._get_nodes(inbound)

            if any(inb[0] == drop_input for inb in inbound_info):  # Switch inputs
                inbound_info = [(switch_input if inb[0] == drop_input else inb[0], inb[1])
                                for inb in inbound_info]
            struct[layer_info[0]] = inbound_info
            next_layers.extend(inbound_info)

            if not current_layers:
                current_layers = next_layers
                next_layers = []

        struct[switch_input] = []  # Add the input layer
        logger.debug("Model structure: %s", struct)
        return struct

    def _get_inputs(self, inputs):
        """ Obtain the inputs for the requested swap direction.
  
          Parameters
          ----------
          filtered_structure: :class:`OrderedDict`
              The full model structure with unused inbound nodes and layers removed
keep keep keep keep replace replace replace replace keep keep keep keep keep
 plugins.train.model.base - More robust inference model generation 
plugins/train/model/_base.py