def init_model(self): input_dim = self.model_data.feature_dimension output_dim = self.model_data.output if not isinstance(input_dim, list): input_dim = list(input_dim) print("\nInitiating model with {:d}x{:d} inputs" " and {:d} outputs".format(*input_dim, output_dim)) layer_list = self.model_data.layer_list if layer_list is None: return {"loaded": False, "model_message": "Noe Layers defined"} nr_layers = len(layer_list) layer_callbacks = layer_definitions.get_layers() lstm_mode = False time_series = False steps = self.model_data.time_distributed print("Building model with {} layers...".format(nr_layers)) if steps > 1: input_dim[-1] = input_dim[-1] - steps + 1 input_dim = [steps] + input_dim lstm_mode = True time_series = True print( "Building TimeDistributed model with {} steps!".format(steps)) # Add single channel dimension if input_dim[-1] != 1: input_dim = input_dim + [1] self.model_data.input = input_dim inputs = Input(shape=input_dim) x = None nr_layers = len(layer_list) for idx, layer in enumerate(layer_list): if not layer.get("is_active", True): continue try: cb = layer_callbacks[layer['name']]['class'] except KeyError: print("Layer {} not found in layer_definitions.py!".format( layer['name'])) # Wrap layers in TimeDistributed until first LSTM layer if layer['name'] == "lstm": lstm_mode = False time_series = False layer["params"].pop("steps") if lstm_mode: if layer['class'] not in not_time_distributed: time_series = True else: time_series = False try: options = {} if layer["params"] is not None: for entry in layer["params"]: opt = layer["params"][entry] if isinstance(opt, list): options[entry] = tuple(opt) else: options[entry] = opt print("{}: Adding {} with\n{}".format(idx + 1, layer['name'], options)) if idx == 0 and nr_layers > 1: if time_series: x = TimeDistributed(cb(**options))(inputs) else: x = cb(**options)(inputs) elif idx > 0 and idx < nr_layers - 1: if time_series: x = TimeDistributed(cb(**options))(x) else: x = cb(**options)(x) else: options.pop("units", None) predictions = cb(output_dim, **options)(x) except Exception as e: traceback.print_exc() return { "loaded": False, "model_message": "\nLayer nr. {} failed." " Error adding {}\n{}".format(idx + 1, layer['name'], e) } if layer["name"] == "lstm": layer["params"]["steps"] = steps self.model = Model(inputs=inputs, outputs=predictions) self.set_optimizer("Adam") return {"loaded": True, "model_message": ""}
def load_model(self, file): try: self.clear_model() info = np.load(file, allow_pickle=True) self.model = info.item()["model"] self.labels_dict = info.item()["labels_dict"] model_dimensions = info.item()["model_dimensions"] self.label_num = model_dimensions["output"] feature_list = info.item()["feature_list"] sensor_config = configs.load(info.item()["sensor_config"]) frame_settings = info.item()["frame_settings"] time_distributed = model_dimensions.get("time_distributed", 1) feature_dimension = model_dimensions.get( "feature_dimension", model_dimensions["input"][:-1]) self.tf_session = K.get_session() self.tf_graph = tf.compat.v1.get_default_graph() with self.tf_session.as_default(): with self.tf_graph.as_default(): self.model._make_predict_function() except Exception as e: error_text = self.error_to_text(e) message = "Error in load model:\n{}".format(error_text) return {"loaded": False}, message else: try: self.model_data.nr_of_training_maps = info.item( )["nr_of_training_maps"] except KeyError: self.model_data.nr_of_training_maps = 0 gui_layer_conf = layer_definitions.get_layers() layer_list = [] for l in self.model.layers: l_conf = l.get_config() l_name = l_conf["name"].rsplit("_", 1)[0] if "time_distributed" in l_name: l_conf = l_conf["layer"]["config"] l_name = l_name = l_conf["name"].rsplit("_", 1)[0] if l_name in gui_layer_conf: g_conf = gui_layer_conf[l_name]["params"] layer = { "name": l_name, "class": gui_layer_conf[l_name]["class_str"], "params": {}, } if g_conf is None: layer["params"] = None else: for p in l_conf: if p in g_conf: if isinstance(l_conf[p], tuple): layer["params"][p] = list(l_conf[p]) else: layer["params"][p] = l_conf[p] layer_list.append(layer) else: if l_name != "input": print( "Keras layer {} not found in layer_definitions.py!" .format(l_name)) counted = self.count_variables() labels = self.get_label_list() label_categories = None if self.training_data["loaded"]: try: data_labels = self.label_assignment( self.training_data["raw_labels"], self.labels_dict) label_categories = to_categorical(data_labels, self.label_num) except Exception as e: print("Loaded data incompatible with model data!\n", e) self.trainning = {"loaded": False} label_categories = None model_data = { "loaded": True, "y_labels": label_categories, "label_list": labels, "feature_list": feature_list, "sensor_config": sensor_config, "frame_settings": frame_settings, "layer_list": layer_list, # GUI format layer list "keras_layer_info": self.model.layers, # Keras format layer list "trainable": counted["trainable"], "non_trainable": counted["non_trainable"], "input": model_dimensions["input"], "output": model_dimensions["output"], "time_distributed": time_distributed, "feature_dimension": feature_dimension, } self.set_model_data(model_data) message = "Loaded model with:\n" message += "input shape :{}\n".format(self.model_data.input) if self.model_data.time_distributed > 1: message += "time steps :{}\n".format( self.model_data.time_distributed) message += "output shape :{}\n".format(self.model_data.output) message += "nr of features :{}\n".format(len(feature_list)) message += "labels :{}\n".format(labels) message += "Trained with {} features".format( self.model_data.get("nr_of_training_maps", "N/A")) return self.model_data, message
def init_model(self): input_dim = self.model_data.input output_dim = self.model_data.output model_dim = len(input_dim) - 1 if model_dim == 1: print("\nInitiating 1D model with {:d} inputs" " and {:d} outputs".format(input_dim[0], output_dim)) elif model_dim == 2: print("\nInitiating 2d model with {:d}x{:d} inputs" " and {:d} outputs".format(*input_dim, output_dim)) layer_list = self.model_data.layer_list if layer_list is None: if model_dim == 1: self.init_default_model_1D() elif model_dim == 2: self.init_default_model_2D() return {"loaded": True, "model_message": ""} inputs = Input(shape=input_dim) nr_layers = len(layer_list) layer_callbacks = layer_definitions.get_layers() print("Building model with {} layers...".format(nr_layers)) x = None nr_layers = len(layer_list) for idx, layer in enumerate(layer_list): try: cb = layer_callbacks[layer['name']]['class'] except KeyError: print("Layer {} not found in layer_definitions.py!".format( layer['name'])) try: options = {} if layer["params"] is not None: for entry in layer["params"]: opt = layer["params"][entry] if isinstance(opt, list): options[entry] = tuple(opt) else: options[entry] = opt print("{}: Adding {} with\n{}".format(idx + 1, layer['name'], options)) if idx == 0 and nr_layers > 1: x = cb(**options)(inputs) elif idx > 0 and idx < nr_layers - 1: x = cb(**options)(x) else: options.pop("units", None) predictions = cb(output_dim, **options)(x) except Exception as e: return { "loaded": False, "model_message": "\nLayer nr. {} failed." " Error adding {}\n{}".format(idx + 1, layer['name'], e) } self.model = Model(inputs=inputs, outputs=predictions) self.set_optimizer("Adam") return {"loaded": True, "model_message": ""}