def run(self, numHidden1, numHidden2=0, numEpochs=20, batchSize=512, codeSuffix=''): x_train, y_train = self.loadData() x_train = np.array(x_train, np.float32) numClasses = max(y_train) + 1 train_data = tf.data.Dataset.from_tensor_slices((x_train, y_train)) train_data = train_data.repeat().shuffle(5000).batch( batchSize).prefetch(1) layers = [] if (numHidden1 > 0): layers += [tf.keras.layers.Dense(numHidden1, activation='relu')] if (numHidden2 > 0): layers += [tf.keras.layers.Dense(numHidden2, activation='relu')] layers += [tf.keras.layers.Dense(numClasses)] model = tf.keras.Sequential(layers) model.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy( from_logits=True), metrics=['accuracy']) model.fit(train_data, epochs=numEpochs, steps_per_epoch=100, verbose=0, callbacks=[TqdmCallback(verbose=2)]) self.writeCodeFile(model, codeSuffix)
def main(): df = pd.read_csv(args.input) df = df[['ID', 'FORM', 'XPOSTAG']] print(df.head()) sentences = Preparing_tagged_data(df) print('Maximum sequence length:', MAX) word2idx, idx2word, tag2idx, idx2tag = preparedicts(df) X, y = prepareData(sentences, word2idx, tag2idx) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.05, random_state=7) print("Dataset dimentions \n") print(X_train.shape, y_train.shape) print(X_test.shape, y_test.shape) embedding_matrix = embeddings(word2idx) model = BUILD_MODEL(X, MAX, len(word2idx), len(tag2idx), embedding_matrix) history = model.fit(X_train, y_train, epochs=10, batch_size=32, validation_split=0.1, verbose=0, callbacks=[TqdmCallback(verbose=2)]) #evaluate_model(history) print("Saving model at ", args.output) model.save(args.output) TestData(model, X_test, y_test, idx2tag)
def train_model(model, train_data, train_labels, regenerate=True): # Build tensorflow dataset dataset = tf.data.Dataset.from_tensor_slices((train_data, train_labels)).batch(128) if regenerate: # Train Model early_stopping_callback = keras.callbacks.EarlyStopping(monitor='loss', min_delta=10e-8, patience=50, verbose=0, mode='auto', baseline=None) model.fit(dataset, shuffle=True, epochs=5000, # war 10000 verbose=0, callbacks=[TqdmCallback(verbose=1), early_stopping_callback]) # Save model model.save('model.h5') else: model = tf.keras.models.load_model('model.h5') print(model.summary()) return model
def train_model(model, train_id, x_train, y_train, dydx_train=None, scaled_MSE=None, epochs = EPOCHS, x_true = None, y_true = None, dydx_true = None): x_norm, y_norm, dydx_norm = get_norm_layers(x_train, y_train, dydx_train) if scaled_MSE is not None: scaled_MSE.adapt(dydx_train) history = model.fit( x_norm(x_train), [y_norm(y_train), dydx_norm(dydx_train)], steps_per_epoch = STEPS_PER_EPOCH, epochs=epochs, callbacks=[ # tf.keras.callbacks.TensorBoard(log_dir = log_dir+train_id, histogram_freq=1), tf.keras.callbacks.EarlyStopping(monitor='loss',patience=100), TqdmCallback(verbose=1) ], validation_data = (x_norm(x_true), [y_norm(y_true), dydx_norm(dydx_true)]), verbose=0 ) return history, x_norm, y_norm
def train_top_model(): train_data = np.load(open('bottleneck_features_train.npy', 'rb')) train_labels = np.array( [0] * (int(nb_train_samples / 2)) + [1] * (int(nb_train_samples / 2))) validation_data = np.load(open('bottleneck_features_validation.npy', 'rb')) validation_labels = np.array( [0] * (int(nb_validation_samples / 2)) + [1] * (int(nb_validation_samples / 2))) model = Sequential() model.add(Flatten(input_shape=train_data.shape[1:])) model.add(Dense(256, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(1, activation='sigmoid')) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy']) model.fit(train_data, train_labels, epochs=epochs, batch_size=batch_size, validation_data=(validation_data, validation_labels), verbose=0, callbacks=[TqdmCallback(), CSVLogger("metrics.csv")]) model.save_weights(top_model_weights_path)
def build_model(self, input_shape, nb_classes): input_layer = keras.layers.Input(input_shape) x = input_layer input_res = input_layer for d in range(self.depth): x = self._inception_module(x) if self.use_residual and d % 3 == 2: x = self._shortcut_layer(input_res, x) input_res = x gap_layer = keras.layers.GlobalAveragePooling1D()(x) output_layer = keras.layers.Dense(nb_classes, activation='softmax')(gap_layer) model = keras.models.Model(inputs=input_layer, outputs=output_layer) model.compile(loss='categorical_crossentropy', optimizer=keras.optimizers.Adam(self.lr), metrics=['accuracy']) reduce_lr = keras.callbacks.ReduceLROnPlateau(monitor='loss', factor=0.5, patience=50, min_lr=0.0001) file_path = self.output_directory + 'best_model.hdf5' model_checkpoint = keras.callbacks.ModelCheckpoint(filepath=file_path, monitor='loss', save_best_only=True) self.callbacks = [reduce_lr, model_checkpoint, TqdmCallback(verbose=0)] return model
def get_callbacks(): filepath1 = "./weights/weights-race-{epoch:02d}-{val_dense_5_accuracy:.2f}.h5" checkpoint1 = ModelCheckpoint(filepath1, monitor='val_dense_5_accuracy', verbose=1, mode='auto', save_best_only=True) filepath2 = "./weights/weights-age-{epoch:02d}-{val_dense_3_accuracy:.2f}.h5" checkpoint2 = ModelCheckpoint(filepath2, monitor='val_dense_3_accuracy', verbose=1, mode='auto', save_best_only=True) def lr_scheduler(epoch, lr): decay_rate = 0.1 decay_step = 50 if epoch % decay_step == 0 and epoch > 10: lr = decay_rate * lr return lr scheduler = LearningRateScheduler(lr_scheduler, verbose=1) es = EarlyStopping(monitor='val_loss', patience=40, verbose=1, min_delta=1e-2) callbacks_list = [checkpoint1, checkpoint2, scheduler, TqdmCallback()] return callbacks_list
def __poison__tensorflow(self, x_poison: np.ndarray, y_poison: np.ndarray) -> Tuple[Any, Any]: """ Optimize the poison by matching the gradient within the perturbation budget. :param x_poison: List of samples to poison. :param y_poison: List of the labels for x_poison. :return: A pair of poisoned samples, B-score (cosine similarity of the gradients). """ self.backdoor_model.compile(loss=None, optimizer=self.optimizer) callbacks = [self.lr_schedule] if self.verbose > 0: from tqdm.keras import TqdmCallback callbacks.append(TqdmCallback(verbose=self.verbose - 1)) # Train the noise. self.backdoor_model.fit( [x_poison, y_poison, np.arange(len(y_poison))], callbacks=callbacks, batch_size=self.batch_size, epochs=self.max_epochs, verbose=0, ) [input_noised_, B_] = self.backdoor_model.predict( # pylint: disable=C0103 [x_poison, y_poison, np.arange(len(y_poison))], batch_size=self.batch_size) return input_noised_, B_
def train_top_model(): train_data = np.load(train_feature_path) train_labels = np.array([0] * (nb_train_samples // 2) + [1] * (nb_train_samples // 2)) validation_data = np.load(valid_feature_path) validation_labels = np.array([0] * (nb_validation_samples // 2) + [1] * (nb_validation_samples // 2)) model = Sequential() model.add(Flatten(input_shape=train_data.shape[1:])) model.add(Dense(256, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(1, activation='sigmoid')) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy']) model.fit(train_data, train_labels, epochs=epochs, batch_size=batch_size, validation_data=(validation_data, validation_labels), verbose=0, callbacks=[TqdmCallback(), CSVLogger(metrics_file)]) model.save_weights(top_model_weights_path) model_json = model.to_json() with open(top_model_json_path, "w") as json_file: json_file.write(model_json)
def _fit_transform(self, graph: Graph, return_dataframe: bool = True, verbose: bool = True) -> EmbeddingResult: """Return node embedding""" try: from tqdm.keras import TqdmCallback traditional_verbose = False except AttributeError: traditional_verbose = True if has_gpus() and self._use_mirrored_strategy: strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy() else: strategy = tf.distribute.get_strategy() # # Build the model with strategy.scope(): model = self._build_model(graph) # Get the model input training_input = self._build_input(graph, verbose=verbose) if not isinstance(training_input, tuple): raise ValueError("The provided input data is not a tuple.") # Fit the model model.fit( *training_input, epochs=self._epochs, verbose=traditional_verbose and verbose > 0, batch_size=(self._batch_size if issubclass( training_input[0].__class__, Sequence) else None), steps_per_epoch=self._get_steps_per_epoch(graph), callbacks=[ EarlyStopping( monitor="loss", min_delta=self._early_stopping_min_delta, patience=self._early_stopping_patience, mode="min", ), ReduceLROnPlateau( monitor="loss", min_delta=self._learning_rate_plateau_min_delta, patience=self._learning_rate_plateau_patience, factor=0.5, mode="min", ), *((TqdmCallback(verbose=1, leave=False), ) if not traditional_verbose and verbose > 0 else ()), ], ) # Extract and return the embedding return self._extract_embeddings(graph, model, return_dataframe=return_dataframe)
def DNN_Classify( train_data, train_size, #model_load, #learning_period, hist, # time length of input data iterations #update_period, # gradient will be updated for every 10 iterations #save_direct # location of saving weights ): variables = train_data.iloc[:train_size].copy() labels = torch.as_tensor(variables.Label.iloc[hist:].copy().values) labels = torch.nn.functional.one_hot(labels.long()) variables = variables.drop('Label', axis=1).copy() scaler.fit(variables) _, features = preprocFeatures(variables) #gainArr = gainArr.values.tolist()[hist:] features = flattenSeries(features, hist) inputdim = len(features[-1]) #model_load = False model = tf.keras.Sequential() model.add(tf.keras.layers.Dense(128, input_dim=inputdim, activation='relu')) model.add(tf.keras.layers.Dense(52, activation='relu')) model.add(tf.keras.layers.Dense(2, activation='softmax')) optimizer = tf.keras.optimizers.Adam(learning_rate=0.001) model.compile(optimizer=optimizer, loss='categorical_crossentropy') early_stopping = EarlyStopping(monitor='loss', mode='min', verbose=0, patience=50) mc = ModelCheckpoint(save_direct + '/test_historic_' + str(train_size) + '.h5', monitor='loss', mode='min', save_best_only=True) if model_load == False: pass else: model.load_weights(save_direct + '/test_historic_' + str(train_size - learning_period) + '.h5') model.fit(np.array(features), np.array(labels), epochs=iterations, verbose=0, callbacks=[TqdmCallback(verbose=0), early_stopping, mc]) model.save_weights(save_direct + '/test_historic_' + str(train_size) + '.h5')
def train_model(model, train_data, train_labels, parameters, silent, regenerate=True): # Build tensorflow dataset dataset = tf.data.Dataset.from_tensor_slices( (train_data, train_labels)).batch(parameters['batch_size']) if regenerate: # Train Model # Early stopping callback early_stopping_callback = keras.callbacks.EarlyStopping( monitor='loss', min_delta=10e-8, patience=50, verbose=0, mode='auto', baseline=None) # History to csv callback path = os.path.dirname(os.path.abspath(__file__)) param_str = parameters['filename'] file_name = os.path.join(path, '..', 'models', 'history', 'history' + param_str + '.csv') csv_logger = tf.keras.callbacks.CSVLogger(file_name, separator=',', append=False) # Train model model.fit( dataset, shuffle=True, epochs=parameters['epochs'], # war 10000 verbose=0, callbacks=[ TqdmCallback(verbose=(0 if silent else 1)), early_stopping_callback, csv_logger ]) # Save model path = os.path.dirname(os.path.abspath(__file__)) param_str = parameters['filename'] file_name = os.path.join(path, '..', 'models', 'models', 'model' + param_str + '.h5') model.save(file_name) else: path = os.path.dirname(os.path.abspath(__file__)) param_str = parameters['filename'] file_name = os.path.join(path, '..', 'models', 'models', 'model' + param_str + '.h5') model = tf.keras.models.load_model(file_name) print(model.summary()) return model
def train(DATA_URL, SAVE_URL): x_train, y_train, x_test = data_loader(DATA_URL) model = create_cnn_model(x_train) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) # 파일 이름에 에포크 번호를 포함시킵니다(`str.format` 포맷) checkpoint_path = os.path.join(SAVE_URL,"my_model.h5") # checkpoint_dir = SAVE_URL model.fit(x_train, y_train, epochs=20, verbose=0, callbacks=[TqdmCallback(verbose=2)]) model.save(checkpoint_path) return model
def build_model(self, input_shape, nb_classes, len_series): nb_rows = [ np.int(self.ratio[0] * len_series), np.int(self.ratio[1] * len_series) ] nb_cols = input_shape[2] input_layer = keras.layers.Input(input_shape) x_layer_1 = keras.layers.Conv2D( self.num_filter, (nb_rows[0], nb_cols), kernel_initializer='lecun_uniform', activation='relu', padding='valid', strides=(1, 1), data_format='channels_first')(input_layer) x_layer_1 = keras.layers.GlobalMaxPooling2D( data_format='channels_first')(x_layer_1) y_layer_1 = keras.layers.Conv2D( self.num_filter, (nb_rows[1], nb_cols), kernel_initializer='lecun_uniform', activation='relu', padding='valid', strides=(1, 1), data_format='channels_first')(input_layer) y_layer_1 = keras.layers.GlobalMaxPooling2D( data_format='channels_first')(y_layer_1) concat_layer = keras.layers.concatenate([x_layer_1, y_layer_1]) #concat_layer = keras.layers.Dense(128, kernel_initializer = 'lecun_uniform', activation = 'relu')(concat_layer) #concat_layer = keras.layers.Dense(128, kernel_initializer = 'lecun_uniform', activation = 'relu')(concat_layer) concat_layer = keras.layers.Dropout(0.25)(concat_layer) output_layer = keras.layers.Dense(nb_classes, kernel_initializer='lecun_uniform', activation='softmax')(concat_layer) model = keras.models.Model(input_layer, output_layer) model.compile(loss='categorical_crossentropy', optimizer=tf.keras.optimizers.Adam(learning_rate=0.001), metrics=['accuracy']) self.callbacks_ = [] if self.verbose: self.callbacks_.append(TqdmCallback(verbose=0)) return model
def train_2(model_fn, data_microbioma, data_domain, latent_space=10, folds=5, epochs=20, batch_size=128, learning_rate_scheduler=ExpDecayScheluder(), random_seed=347, verbose=0): data_zeros_latent = np.zeros((data_microbioma.shape[0], latent_space), dtype=data_microbioma.dtype) results = [] models = [] train_callbacks = [ callbacks.EarlyStopping(monitor='val_loss', patience=epochs + 1, restore_best_weights=True) ] if verbose >= 0: train_callbacks += [TqdmCallback(verbose=verbose)] if learning_rate_scheduler is not None: train_callbacks += [learning_rate_scheduler.make()] if folds <= 1: m_train, m_test = data_microbioma, data_microbioma d_train, d_test = data_domain, data_domain z_train, z_test = data_zeros_latent, data_zeros_latent tf.random.set_seed(random_seed) r, m = train_kfold(model_fn, m_train, d_train, z_train, m_test, d_test, z_test, batch_size, epochs, train_callbacks) results.append(r) models.append(m) else: kf = KFold(n_splits=folds, random_state=random_seed, shuffle=True) tf.random.set_seed(random_seed) for train_index, test_index in kf.split(data_microbioma): m_train, m_test = data_microbioma[train_index], data_microbioma[ test_index] d_train, d_test = data_domain[train_index], data_domain[test_index] z_train, z_test = data_zeros_latent[ train_index], data_zeros_latent[test_index] r, m = train_kfold(model_fn, m_train, d_train, z_train, m_test, d_test, z_test, batch_size, epochs, train_callbacks) results.append(r) models.append(m) return results, models
def train(training_samples, samples_labels, num_of_epochs=100, batch_size=1024, validation_split=0.0): model = prepare_network_model(samples_labels.shape[-1]) conv_weights = [] get_weights = LambdaCallback(on_epoch_end=lambda batch, logs: conv_weights.append(np.array([np.rot90(x, 3) for x in model.layers[0].get_weights()[0].squeeze()[::-1].T]))) history_temp = model.fit(training_samples, samples_labels, batch_size=batch_size, epochs=num_of_epochs, validation_split=validation_split, callbacks=[get_weights, TqdmCallback(verbose=1)], verbose=0) return np.array(conv_weights)
def train( self, X_train=None, y_train=None, validation_data=None, early_stopping: int = None, tqdm=True, **params, ): """Base method to train input model. Based on Keras hyperparameters Args: X_train ([pd.DataFrame, np.array], optional): the Keras `x` input. Defaults to None. If None, the learner will take the attribute `X_train` fitted in the class. y_train ([pd.DataFrame, np.array], optional): the Keras `y` input. Defaults to None. If None, the learner will take the attribute `y_train` fitted in the class. validation_data ([pd.DataFrame, np.array], optional): the Keras `validation_data` input. Defaults to None. If None, the learner will take the attribute `validation_data` fitted in the class. early_stopping (int, optional): Number of epochs before Early Stopping. Defaults to None. If None, the training will last `epochs`. tqdm (bool, optional): To create `tqdm` progress bar during training or not. Defaults to True. """ if X_train is not None: self.X_train = X_train if y_train is not None: self.y_train = y_train if validation_data is not None: self.validation_data = validation_data if early_stopping: self.early_stopping_ = early_stopping es = keras.callbacks.EarlyStopping(monitor="val_loss", patience=self.early_stopping) self.callbacks.append(es) if tqdm: tqdm_nb = TqdmCallback() self.callbacks.append(tqdm_nb) self.set_params(params) logging.info("Start training") history = self.model.model.fit( x=self.X_train.values, y=self.y_train, batch_size=self.batch_size, shuffle=self.shuffle, epochs=self.epochs, verbose=self.verbose, validation_data=self.validation_data, class_weight=self.class_weight_dict, callbacks=self.callbacks, ) self.history = history.history
def fit(self, X, y, subpolicies=None): if subpolicies is not None: which = np.random.randint(len(subpolicies), size=len(X)) for i, subpolicy in enumerate(subpolicies): X[which == i] = subpolicy(X[which == i]) X = X.astype(np.float32) / 255 callback = TqdmCallback(leave=False, file=sys.stdout, verbose=0) callback.on_train_batch_begin = callback.on_batch_begin callback.on_train_batch_end = callback.on_batch_end self.model.fit(X, y, CHILD_BATCH_SIZE, CHILD_EPOCHS, verbose=0, callbacks=[callback]) return self
def train_model(model, train_data, train_labels, val_data, val_labels, parameters, silent): # Build tensorflow dataset train_dataset = tf.data.Dataset.from_tensor_slices((train_data, train_labels))\ .batch(parameters['batch_size'])\ .prefetch(parameters['batch_size']*4) val_dataset = tf.data.Dataset.from_tensor_slices((val_data, val_labels))\ .batch(parameters['batch_size'])\ .prefetch(parameters['batch_size']*4) # Train Model # Early stopping callback early_stopping_callback = keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=10e-8, patience=5, verbose=0, mode='auto', baseline=None) # History to csv callback path = os.path.dirname(os.path.abspath(sys.argv[0])) param_str = parameters['filename'] file_name = os.path.join(path, 'models', 'history', 'history' + param_str + '.csv') csv_logger = tf.keras.callbacks.CSVLogger(file_name, separator=',', append=False) # Train model model.fit( train_dataset, validation_data=val_dataset, shuffle=True, epochs=parameters['epochs'], # war 10000 verbose=0, callbacks=[ TqdmCallback(verbose=(0 if silent else 1)), early_stopping_callback, csv_logger ]) # validation_steps=2, # Save model path = os.path.dirname(os.path.abspath(sys.argv[0])) param_str = parameters['filename'] file_name = os.path.join(path, 'models', 'models', 'model' + param_str + '.h5') model.save(file_name) return model
def fit(): train_ds, val_ds, test_ds, feature_columns = read_data() all_inputs, encoded_features = prepare_data( columns=["mileage", "year", "power", "model_number", "consumption"], train_ds=train_ds) all_features = tf.keras.layers.concatenate(encoded_features) x = tf.keras.layers.Dense(12, activation="relu")(all_features) x = tf.keras.layers.Dropout(0.05)(x) x = tf.keras.layers.Dense(7, activation="relu")(x) output = tf.keras.layers.Dense(1)(x) model = tf.keras.Model(all_inputs, output) model.compile(optimizer=tf.optimizers.Adam(learning_rate=0.1), loss=tf.keras.losses.MeanSquaredError(), metrics=[ tfa.metrics.r_square.RSquare(y_shape=(1, )), tf.metrics.MeanAbsolutePercentageError() ]) epochs = 100 history = model.fit(train_ds, validation_data=val_ds, epochs=epochs, verbose=0, callbacks=[TqdmCallback(verbose=0, position=0)]) plot_loss(history, epochs=range(epochs)) plt.show() logger.info(model.summary()) accuracy = model.evaluate(test_ds) logger.info(f"Accuracy : {accuracy}") y = tf.concat([y for x, y in test_ds], axis=0) logger.info( tf.concat([model.predict(test_ds), tf.expand_dims(y, -1)], axis=1)) model.save('neural_net_classifier', save_format='h5') tf.keras.utils.plot_model(model, show_shapes=True, rankdir="LR")
def build_and_train_keras_sequential(): train_ds, val_ds, test_ds, feature_columns = read_data() feature_layer = tf.keras.layers.DenseFeatures(feature_columns) model = tf.keras.Sequential([ feature_layer, layers.Dense(24, activation='relu'), layers.Dropout(.1), layers.Dense(10, activation='relu'), layers.Dropout(.1), layers.Dense(1) ]) model.compile(optimizer='adam', loss=tf.keras.losses.MeanSquaredError(), metrics=[ tfa.metrics.r_square.RSquare(y_shape=(1, )), tf.metrics.MeanAbsolutePercentageError() ]) epochs = 100 history = model.fit(train_ds, validation_data=val_ds, epochs=epochs, verbose=0, callbacks=[TqdmCallback(verbose=0, position=0)]) plot_loss(history, epochs=range(epochs)) plt.show() logger.info(model.summary()) accuracy = model.evaluate(test_ds) logger.info(f"Accuracy : {accuracy}") y = tf.concat([y for x, y in test_ds], axis=0) logger.info( tf.concat([model.predict(test_ds), tf.expand_dims(y, -1)], axis=1)) model.save('neural_net_classifier', save_format='tf')
def build_model(self, input_shape, nb_classes, len_series, ratio, num_filter): #ratio = self.conv_config['ratio'] nb_rows = [np.int(ratio[0]*len_series), np.int(ratio[1]*len_series)] nb_cols = input_shape[2] input_layer = keras.layers.Input(input_shape) x_layer_1 = keras.layers.Conv2D(num_filter, (nb_rows[0], nb_cols), kernel_initializer='lecun_uniform', activation='relu', padding='valid', strides=(1, 1), data_format='channels_last')(input_layer) x_layer_1 = keras.layers.GlobalMaxPooling2D( data_format='channels_first')(x_layer_1) y_layer_1 = keras.layers.Conv2D(num_filter, (nb_rows[1], nb_cols), kernel_initializer='lecun_uniform', activation='relu', padding='valid', strides=(1, 1), data_format='channels_last')(input_layer) y_layer_1 = keras.layers.GlobalMaxPooling2D( data_format='channels_last')(y_layer_1) concat_layer = keras.layers.concatenate([x_layer_1, y_layer_1]) layer_2 = keras.layers.Dense( 64, kernel_initializer='lecun_uniform', activation='relu')(concat_layer) layer_3 = keras.layers.Dense( 128, kernel_initializer='lecun_uniform', activation='relu')(layer_2) layer_3 = keras.layers.Dropout(0.25)(layer_3) output_layer = keras.layers.Dense( nb_classes, kernel_initializer='lecun_uniform', activation='softmax')(layer_3) model = keras.models.Model(input_layer, output_layer) model.compile(loss='categorical_crossentropy', optimizer=tf.keras.optimizers.Adam( learning_rate=0.001), metrics=['accuracy']) #factor = 1. / np.cbrt(2) #reduce_lr = keras.callbacks.ReduceLROnPlateau(monitor='loss', factor=factor, patience=100, min_lr=1e-4, cooldown=0, mode='auto') self.callbacks = [TqdmCallback(verbose=0)] return model
def build_model(self, input_shape, nb_classes): input_layer = keras.layers.Input(input_shape) # flatten/reshape because when multivariate all should be on the same axis input_layer_flattened = keras.layers.Flatten()(input_layer) layer_1 = keras.layers.Dropout(0.1)(input_layer_flattened) layer_1 = keras.layers.Dense(500, activation='relu')(layer_1) layer_2 = keras.layers.Dropout(0.2)(layer_1) layer_2 = keras.layers.Dense(500, activation='relu')(layer_2) layer_3 = keras.layers.Dropout(0.2)(layer_2) layer_3 = keras.layers.Dense(500, activation='relu')(layer_3) output_layer = keras.layers.Dropout(0.3)(layer_3) output_layer = keras.layers.Dense(nb_classes, activation='softmax')(output_layer) model = keras.models.Model(inputs=input_layer, outputs=output_layer) model.compile(loss='categorical_crossentropy', optimizer=keras.optimizers.Adadelta(), metrics=['accuracy']) reduce_lr = keras.callbacks.ReduceLROnPlateau(monitor='loss', factor=0.5, patience=200, min_lr=0.0001) file_path = self.output_dir + 'best_model.hdf5' model_checkpoint = keras.callbacks.ModelCheckpoint(filepath=file_path, monitor='loss', save_best_only=True) self.callbacks = [reduce_lr, model_checkpoint, TqdmCallback(verbose=0)] return model
def callback(self, model): call = [] if os.path.exists(checkpoint_path): if os.listdir(checkpoint_path): logger.debug('load the model') model.load_weights( os.path.join(checkpoint_path, self.calculate_the_best_weight())) logger.debug( f'读取的权重为{os.path.join(checkpoint_path, self.calculate_the_best_weight())}' ) cp_callback = tf.keras.callbacks.ModelCheckpoint( filepath=checkpoint_file_path, verbose=1, save_weights_only=True, save_best_only=True, period=1) call.append(cp_callback) tensorboard_callback = tf.keras.callbacks.TensorBoard( log_dir=log_dir, histogram_freq=1, write_images=True, update_freq=UPDATE_FREQ) call.append(tensorboard_callback) lr_callback = tf.keras.callbacks.ReduceLROnPlateau( factor=0.01, patience=LR_PATIENCE) call.append(lr_callback) csv_callback = tf.keras.callbacks.CSVLogger(filename=csv_path, append=True) call.append(csv_callback) early_callback = tf.keras.callbacks.EarlyStopping( min_delta=0, verbose=1, patience=EARLY_PATIENCE) call.append(early_callback) call.append(TqdmCallback()) return (model, call)
def main(): df = pd.read_csv(args.input) print(df.head()) sentences = Preparing_tagged_data(df) print('Maximum sequence length:', MAX) word2idx, idx2word, tag2idx, idx2tag = preparedicts(df) X, y = prepareData(sentences, word2idx, tag2idx) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.05, random_state=7) print("Dataset dimentions \n") print(X_train.shape, y_train.shape) print(X_test.shape, y_test.shape) embedding_matrix = embeddings(word2idx) print(MAX) model = BUILD_MODEL(X, MAX, len(word2idx), len(tag2idx), embedding_matrix) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) history = model.fit(X_train, y_train, epochs=10, batch_size=64, validation_split=0.1, verbose=0, callbacks=[TqdmCallback(verbose=1)]) evaluate_model(history) TestData(model, X_test, y_test, idx2tag) print("Saving model at ", args.output) model.save(args.output)
input_noise = np.expand_dims(input_noise,0) * NOISE_REDUCTION target = np.expand_dims(ct_small,0) # initialize results_all = [] predicted_all = [] epochs_saved = [0] previous_epochs = 0 model = get_architecture(target[0], archi, ch_init, g_noise, act_max_value, act_out_max_value) opt = tf.keras.optimizers.Adam(lr_value) loss_masked, mask_used = choose_loss(mask_target, mask_target2, mask_target3, LOSS_USED=0) model.compile(optimizer=opt, loss=loss_masked) # Train model for i in tqdm(range(LOOP_MASKS)): results = model.fit(input_noise, target, epochs=EPOCHS, verbose=0, callbacks=[TqdmCallback(verbose=0)]); results_all.extend(results.history['loss']) predicted_all.append(model.predict(input_noise)[0,...]) epochs_saved.append(epochs_saved[-1] + EPOCHS) # sneak peek loss_masked, mask_used = choose_loss(mask_target, mask_target2, mask_target3, LOSS_USED=2) results = model.fit(input_noise, target, epochs=EPOCHS_sneak_peek, verbose=0, callbacks=[TqdmCallback(verbose=0)]); loss_masked, mask_used = choose_loss(mask_target, mask_target2, mask_target3, LOSS_USED=0) results_all.extend(results.history['loss']) predicted_all.append(model.predict(input_noise)[0,...]) epochs_sneak_peak = epochs_saved[-1] + EPOCHS_sneak_peek epochs_saved.append(epochs_sneak_peak) lr_value = lr_value * LR_REDUCE K.set_value(model.optimizer.learning_rate, lr_value)
def fit(self, X, Y, output_slices=None, **kwargs): with get_device(self.config): checkpoint = self.model_path.joinpath('checkpoint') if checkpoint.exists() and not self.no_load: if self.verbose: print(f'Restoring model weights from {checkpoint}') self.load() elif self.no_load and X is None: raise Exception( 'Model exists, but no_load is set and no training data was given.' ) elif X is not None and Y is not None: self.scalerx.fit(ensure_format(X), ensure_format(Y)) self.scalery.fit(ensure_format(Y)) # Gather all data (train, validation, test, ...) into singular object datasets = kwargs['datasets'] = kwargs.get('datasets', {}) datasets.update({'train': {'x': X, 'y': Y}}) for key, data in datasets.items(): if data['x'] is not None: datasets[key].update({ 'x_t': self.scalerx.transform(ensure_format(data['x'])), 'y_t': self.scalery.transform(ensure_format(data['y'])), }) assert (np.isfinite(datasets['train']['x_t']).all() ), 'NaN values found in X training data' self.update_config({ 'output_slices': output_slices or { '': slice(None) }, 'n_inputs': datasets['train']['x_t'].shape[1], 'n_targets': datasets['train']['y_t'].shape[1], }) self.build() callbacks = [] model_kws = { 'batch_size': self.batch, 'epochs': max(1, int(self.n_iter / max(1, len(X) / self.batch))), 'verbose': 0, 'callbacks': callbacks, } if self.verbose: callbacks.append( TqdmCallback(model_kws['epochs'], data_size=len(X), batch_size=self.batch)) if self.debug: callbacks.append( tf.keras.callbacks.TensorBoard(histogram_freq=1, profile_batch=(2, 60))) if 'args' in kwargs: if getattr(kwargs['args'], 'plot_loss', False): callbacks.append( PlottingCallback(kwargs['args'], datasets, self)) if getattr(kwargs['args'], 'save_stats', False): callbacks.append( StatsCallback(kwargs['args'], datasets, self)) if getattr(kwargs['args'], 'best_epoch', False): if 'valid' in datasets and 'x_t' in datasets['valid']: model_kws['validation_data'] = ( datasets['valid']['x_t'], datasets['valid']['y_t']) callbacks.append(ModelCheckpoint(self.model_path)) self.model.fit(datasets['train']['x_t'], datasets['train']['y_t'], **model_kws) if not self.no_save: self.save() else: raise Exception( f"No trained model exists at: \n{self.model_path}") return self
def train_unet(config, train_dataloader=None, val_dataloader=None, loss=None, metrics=None, checkpoint_dir=None): epochs = 15 batch_size = 1 model = get_model(backbone='vvg16', encoder_freeze=config["encoder_freeze"], n_classes=1, activation='sigmoid', dropout=config["dropout"]) model.compile(optimizer=config["optimizer"](config["learning_rate"]), loss=loss, metrics=metrics) history = model.fit(train_dataloader, steps_per_epoch=len(train_dataloader), epochs=epochs, verbose=0, batch_size=batch_size, validation_data=val_dataloader, validation_steps=len(val_dataloader), callbacks=[ TuneReportCallback( { "loss": "loss", "iou_score": "iou_score", "val_loss": "val_loss", "val_iou_score": "val_iou_score", }, on="epoch_end"), TqdmCallback(verbose=2), ]) # save best model of the trial with tune.checkpoint_dir(step=1) as checkpoint_dir: checkpoint_dir = os.path.dirname( os.path.dirname(checkpoint_dir)) # go up two directories score_file_path = os.path.join(checkpoint_dir, 'score') score_file_exists = os.path.isfile(score_file_path) new_val_iou_score = history.history['val_iou_score'][0] best_model_file_path = os.path.join(checkpoint_dir, 'best_model.h5') if score_file_exists: old_val_iou_score = 0 with open(score_file_path) as f: old_val_iou_score = float(f.read()) if new_val_iou_score > old_val_iou_score: # we have a new best model with open(score_file_path, 'w') as f: f.write(str(new_val_iou_score)) model.save(best_model_file_path) else: # first model of the trial with open(score_file_path, 'w') as f: f.write(str(new_val_iou_score)) model.save(best_model_file_path) print(history.history.keys())
def run_training( model_f, lr_f, name, epochs, batch_size, train_data, val_data, img, img_size, mixed_float=True, notebook=True, ): """ val_data : (X_val, Y_val) tuple """ if mixed_float: policy = mixed_precision.Policy('mixed_float16') mixed_precision.set_policy(policy) st = time.time() inputs = keras.Input((200, 200, 3)) mymodel = AdiposeModel(inputs, model_f) loss = keras.losses.BinaryCrossentropy(from_logits=True) mymodel.compile(optimizer='adam', loss=loss, metrics=[ keras.metrics.BinaryAccuracy(threshold=0.5), ]) logdir = 'logs/fit/' + name tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=logdir, histogram_freq=1, profile_batch='3,5', update_freq='epoch') lr_callback = keras.callbacks.LearningRateScheduler(lr_f, verbose=1) savedir = 'savedmodels/' + name + '/{epoch}' save_callback = keras.callbacks.ModelCheckpoint(savedir, save_weights_only=True, verbose=1) if notebook: tqdm_callback = TqdmNotebookCallback( metrics=['loss', 'binary_accuracy'], leave_inner=False) else: tqdm_callback = TqdmCallback() train_ds = create_train_dataset(img, train_data, img_size, batch_size) val_ds = create_train_dataset(img, val_data, img_size, batch_size, True) image_callback = ValFigCallback(val_ds, logdir) mymodel.fit( x=train_ds, epochs=epochs, steps_per_epoch=len(train_data) // batch_size, callbacks=[ tensorboard_callback, lr_callback, save_callback, tqdm_callback, image_callback, ], verbose=0, validation_data=val_ds, validation_steps=10, ) print('Took {} seconds'.format(time.time() - st)) mymodel.evaluate(val_ds, steps=1000)
training_data = data_gen.flow(*list(zip(*training_data))) if validation_data is not None: validation_data = data_gen.flow(*list(zip(*validation_data))) checkpoint_filepath = 'weights_{epoch:03d}_{val_loss:.8f}.hdf5' else: checkpoint_filepath = 'weights_{epoch:03d}_{loss:.8f}.hdf5' output_dir = pathlib.Path(args.output_dir) output_dir.mkdir(parents=True, exist_ok=True) print('Training RCAN model') model.fit_generator( training_data, epochs=config['epochs'], steps_per_epoch=config['steps_per_epoch'], validation_data=validation_data, validation_steps=config['steps_per_epoch'], verbose=0, callbacks=[ keras.callbacks.LearningRateScheduler( staircase_exponential_decay(config['epochs'] // 4)), keras.callbacks.ModelCheckpoint( str(output_dir / checkpoint_filepath), monitor='loss' if validation_data is None else 'val_loss', save_best_only=True), keras.callbacks.TensorBoard(log_dir=str(output_dir), write_graph=False), TqdmCallback(tqdm_class=tqdm) ])