          required_layers = self._get_required_layers(struct)
          logger.debug("Compiling model")
          layer_dict = {layer.name: layer for layer in saved_model.layers}
          compiled_layers = dict()
          for name, inbound in struct.items():
              if name not in required_layers:
                  logger.debug("Skipping unused layer: '%s'", name)
                  continue
              layer = layer_dict[name]
              logger.debug("Processing layer '%s': (layer: %s, inbound_nodes: %s)",
                           name, layer, inbound)
              if not inbound:
 
</s> remove         required_layers = self._get_required_layers(struct)
        logger.debug("Compiling model")
        layer_dict = {layer.name: layer for layer in saved_model.layers}
 </s> add         model_inputs = self._get_inputs(saved_model.inputs) </s> remove             layer = layer_dict[name]
 </s> add             inbound = struct[layer.name] </s> remove                          name, layer, inbound)
 </s> add                          layer.name, layer, inbound) </s> remove                 logger.debug("Adding model inputs %s: %s", self._input_names, self._inputs)
                model = layer(self._inputs)
 </s> add                 model = model_inputs
                logger.debug("Adding model inputs %s: %s", layer.name, 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"]
        for layer in saved_model.layers:
            if layer.name not in struct:
                logger.debug("Skipping unused layer: '%s'", layer.name)
          required_layers = self._get_required_layers(struct)
          logger.debug("Compiling model")
          layer_dict = {layer.name: layer for layer in saved_model.layers}
          compiled_layers = dict()
        for layer in saved_model.layers:
            if layer.name not in struct:
                logger.debug("Skipping unused layer: '%s'", layer.name)
        for layer in saved_model.layers:
            if layer.name not in struct:
                logger.debug("Skipping unused layer: '%s'", layer.name)
        for layer in saved_model.layers:
            if layer.name not in struct:
                logger.debug("Skipping unused layer: '%s'", layer.name)
                  continue
              layer = layer_dict[name]
              logger.debug("Processing layer '%s': (layer: %s, inbound_nodes: %s)",
                           name, layer, inbound)
              if not inbound:
keep keep keep keep replace replace replace keep keep keep keep keep
 plugins.train.model.base - More robust inference model generation 
plugins/train/model/_base.py