      def _get_filtered_structure(self):
          """ Obtain the structure of the full model, filtering out inbound nodes and
          layers that are not required for the requested swap destination.
  
          Input layers to the full model are not returned in the structure.
  
          Returns
          -------
          :class:`collections.OrderedDict`
              The layer name as key with the inbound node layer names for each layer as value.
 
</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             The layer name as key with the inbound node layer names for each layer as value.
 </s> add             The layer name as key with the input name and output index as value. </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             compiled_layers[name] = model
        retval = KerasModel(self._inputs, model, name="{}_inference".format(saved_model.name))
 </s> add             compiled_layers[layer.name] = model
            retval = KerasModel(model_inputs, model, name="{}_inference".format(saved_model.name))
        This parses the model config (in reverse) to obtain the required layers for an inference
        model.
      def _get_filtered_structure(self):
          """ Obtain the structure of the full model, filtering out inbound nodes and
          layers that are not required for the requested swap destination.
  
        This parses the model config (in reverse) to obtain the required layers for an inference
        model.
  
          Returns
          -------
          :class:`collections.OrderedDict`
              The layer name as key with the inbound node layer names for each layer as value.
keep keep keep keep replace keep keep keep keep keep
 plugins.train.model.base - More robust inference model generation 
plugins/train/model/_base.py