def setup_callbacks(self, mode, callbacks, env, steps, visualize, verbose=True, log_interval=10000, episodes=10): if mode == 'train': callbacks = [] if not callbacks else callbacks[:] if verbose: callbacks += [TrainIntervalLogger(interval=log_interval)] if visualize: callbacks += [Visualizer()] history = History() callbacks += [history] callbacks = CallbackList(callbacks) if hasattr(callbacks, 'set_model'): callbacks.set_model(self) else: callbacks._set_model(self) callbacks._set_env(env) params = { 'steps': steps, } if hasattr(callbacks, 'set_params'): callbacks.set_params(params) else: callbacks._set_params(params) elif mode == 'test': callbacks = [] if not callbacks else callbacks[:] if verbose: callbacks += [TestLogger()] if visualize: callbacks += [Visualizer()] history = History() callbacks += [history] callbacks = CallbackList(callbacks) if hasattr(callbacks, 'set_model'): callbacks.set_model(self) else: callbacks._set_model(self) callbacks._set_env(env) params = { 'episodes': episodes, } if hasattr(callbacks, 'set_params'): callbacks.set_params(params) else: callbacks._set_params(params) return callbacks, history
def train_model(model, epoch, data, loss='mse', optimizer='rmsprop', save_best_only=True, metrics=None, show=False): # evaluation matrix metrics = ['mse'] if metrics is None else metrics model_name = model.name model_path = os.path.join(os.path.abspath(os.curdir), "saved_models", model_name, get_time_stamp()) if not os.path.exists(model_path): os.makedirs(model_path) os.makedirs(os.path.join(model_path, "saved_checkpoints")) # save the original dataset x_train, x_test, y_train, y_test = data with open(os.path.join(model_path, "data.pickle"), 'wb') as f: pickle.dump((x_train, x_test, y_train, y_test), f) # keras build in model structure visualization plot_model(model, to_file=os.path.join(model_path, f"{model_name}.png")) model.compile(loss=loss, optimizer=optimizer, metrics=metrics) # add keras callbacks save history, tensorboard record and checkpoints history = History() tensorboard = TensorBoard(log_dir=os.path.join(model_path, "logs"), update_freq="epoch") checkpoints = ModelCheckpoint(os.path.join(model_path, "saved_checkpoints", f"weights-{epoch:02d}.hdf5"), monitor='val_loss', mode='auto', save_freq='epoch', save_best_only=save_best_only) model.fit(x_train, y_train, validation_data=(x_test, y_test), callbacks=[history, tensorboard, checkpoints], epochs=epoch) # plot the history history_plot = plot_history(history.history, show=show) history_plot.savefig(os.path.join(model_path, f"{model_name}_loss.png")) history_plot.close() # select the last model selected_file = os.listdir(os.path.join(model_path, "saved_checkpoints"))[-1] selected_model = load_check_point( os.path.join(model_path, "saved_checkpoints", selected_file)) # plot the predicted value with the actual value x_origin, y_origin = concatenate_data(x_train, y_train, x_test, y_test) test_size = len(y_test) predict_plot = predict_and_plot(selected_model, x_origin, y_origin, test_size=test_size, show=show) predict_plot.savefig(os.path.join(model_path, f"{model_name}_value.png")) predict_plot.close() with open(os.path.join(model_path, "history.pickle"), 'wb') as f: pickle.dump(history.history, f)
def train_gate(model, weights_file): history = History() highest_acc = 0 iterationsWithoutImprovement = 0 lr = .001 for i in range(1): # load_weights() model.fit_generator(datagen.flow(x_train, y_train, batch_size=50), epochs=1, steps_per_epoch=len(x_train) / 50, validation_data=(x_test, y_test), callbacks=[history], workers=4, verbose=1) val_acc = history.history['val_acc'][-1] if (val_acc > highest_acc): model.save_weights(weights_file + '.hdf5') print("Saving weights, new highest accuracy: " + str(val_acc)) highest_acc = val_acc iterationsWithoutImprovement = 0 else: iterationsWithoutImprovement += 1 if (iterationsWithoutImprovement > 3): lr *= .5 K.set_value(model.optimizer.lr, lr) print("Learning rate reduced to: " + str(lr)) iterationsWithoutImprovement = 0
def train(): (X_train, _), (_, _) = mnist.load_data() X_train = X_train / 255.0 model = create_model() model.compile(tf.train.AdamOptimizer(), loss_function) model.summary() tpu_grpc_url = "grpc://" + os.environ["COLAB_TPU_ADDR"] tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver( tpu_grpc_url) strategy = keras_support.TPUDistributionStrategy(tpu_cluster_resolver) model = tf.contrib.tpu.keras_to_tpu_model(model, strategy=strategy) cb = Sampling(model) hist = History() dummy_rand = np.zeros((X_train.shape[0], 64)) y_train = np.concatenate( (X_train.reshape(-1, 784), np.zeros((X_train.shape[0], 1))), axis=-1) model.fit([X_train, dummy_rand], y_train, batch_size=1024, callbacks=[cb, hist], epochs=20) history = hist.history with open("vae_history.json", "w") as fp: json.dump(history, fp)
def train(self, epochs): train_data, valid_data = self.dataset.load_dataset(self.batch_size) history = History() callbacks = [ ModelCheckpoint(filepath=f"{self.basedir}/models/checkpoint", save_weights_only=True, monitor='val_mIOU', mode='max', save_best_only=True), history, ] if self.enable_tensorboards: callbacks.append( TensorBoard( log_dir=self.tensorboard_log, histogram_freq=1, write_images=True, update_freq='epoch', profile_batch='500,510', embeddings_freq=1, )) self.model_backend.fit(train_data, validation_data=valid_data, epochs=epochs, callbacks=callbacks) self.plot_segm_history(history) with open(f"{self.basedir}/train_history.json", 'w') as outfile: json.dump(history.history, outfile)
def lstm_model(train_x, train_y, config): model = Sequential() model.add( LSTM(config.lstm_layers[0], input_shape=(train_x.shape[1], train_x.shape[2]), return_sequences=True)) model.add(Dropout(config.dropout)) model.add(LSTM(config.lstm_layers[1], return_sequences=False)) model.add(Dropout(config.dropout)) model.add(Dense(train_y.shape[1])) model.add(Activation("relu")) model.summary() cbs = [ History(), EarlyStopping(monitor='val_loss', patience=config.patience, min_delta=config.min_delta, verbose=0) ] model.compile(loss=config.loss_metric, optimizer=config.optimizer) model.fit(train_x, train_y, batch_size=config.lstm_batch_size, epochs=config.epochs, validation_split=config.validation_split, callbacks=cbs, verbose=True) return model
def train(batch_size, use_tpu, load_existing_weights): model = create_resnet() gen = CatGenerator() if load_existing_weights: model.load_weights("weights.hdf5") model.compile(tf.train.MomentumOptimizer(1e-3, 0.9), loss=loss_function_multiple_distance_and_area, metrics=[loss_function_simple]) if use_tpu: tpu_grpc_url = "grpc://"+os.environ["COLAB_TPU_ADDR"] tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(tpu_grpc_url) strategy = keras_support.TPUDistributionStrategy(tpu_cluster_resolver) model = tf.contrib.tpu.keras_to_tpu_model(model, strategy=strategy) cb = CatsCallback(model) history = History() model.fit_generator(gen.flow_from_directory(batch_size, True), steps_per_epoch=6996//batch_size, validation_data=gen.flow_from_directory(batch_size, False), validation_steps=2999//batch_size, callbacks=[cb, history], epochs=200) with open("history.dat", "wb") as fp: pickle.dump(history.history, fp) with zipfile.ZipFile("cats_result.zip", "w") as zip: zip.write("history.dat") zip.write("cats_weights.hdf5")
def train(input_data): OUTPUT_SHAPE = (10, 32, 32, 1) NUM_POINTS = 2000 BATCH_SIZE = 16 PRE_FETCH = 2 EPOCHS = 10 ignoreself = 1 model = ModelConvLSTM.create_Model(ignoreself) model.compile(loss='mse', optimizer='adam') history = History() #filepath=str(os.getcwd())+"SavedModels/HPC2-{epoch:02d}.h5" #cp=ModelCheckpoint(filepath,verbose=1,save_best_only=False,mode='max',period=10) trainData = db.generatorParametersTrain(input_data, OUTPUT_SHAPE, NUM_POINTS, BATCH_SIZE, PRE_FETCH) valData = db.generatorParametersValidation(input_data, OUTPUT_SHAPE, NUM_POINTS, BATCH_SIZE, PRE_FETCH) history = model.fit(trainData, epochs=EPOCHS, verbose=1, validation_data=valData) # ,callbacks=[cp]) return history
def __init__(self, input_size, hyperparameters, categorical_sizes): self.hyperparameters = hyperparameters self.categorical_sizes = categorical_sizes self.history = History() inputs = Input(shape=(input_size,)) embedding_layers = list() for i, col_name in enumerate(sorted(list(categorical_sizes.keys()))): categorical_size = categorical_sizes[col_name] embedding_size = int(categorical_size ** (hyperparameters['embedding_factor'])) ith_input_slice = Lambda(lambda x: x[:, i])(inputs) embedding = Embedding(categorical_size, embedding_size, input_length=1)(ith_input_slice) embedding_layers.append(embedding) numeric_inputs_slice = Lambda(lambda x: x[:, len(categorical_sizes):])(inputs) to_concat = embedding_layers + [numeric_inputs_slice] all_inputs = Concatenate(axis=1)(to_concat) hidden_input = all_inputs for block_params in self.hyperparameters['dense_blocks']: hidden_output = Dense(block_params['size'], activation='relu')(hidden_input) hidden_output = Dropout(block_params['dropout_rate'])(hidden_output) hidden_input = hidden_output outputs = Dense(1, activation='linear')(hidden_output) self.model = Model(inputs, outputs) # define optimization procedure self.lr_annealer = ReduceLROnPlateau(monitor='val_mean_squared_error', factor=hyperparameters['lr_plateau_factor'], patience=hyperparameters['lr_plateau_patience'], verbose=1) self.early_stopper = EarlyStopping(monitor='val_mean_squared_error', min_delta=hyperparameters['early_stopping_min_delta'], patience=hyperparameters['early_stopping_patience'], verbose=1) self.tensorboard = TensorBoard(log_dir='train_logs', histogram_freq=1) self.model.compile(optimizer=Adam(lr=hyperparameters['learning_rate']), loss='mean_squared_error', metrics=['mean_squared_error'])
def train(self, companies, industries, split_rate=0.2, batch_size=128, patience=5, model_weight_path=_classifier_weights_path, model_graph_path=_classifier_graph_path, save_best_only=True, save_weights_only=True, epochs=100): """ Train the LSTM model. """ companies = self._encode_company(companies, True) industries = self._encode_industry(industries, True) X_train, X_valid, y_train, y_valid = train_test_split( companies, industries, test_size=split_rate) valid_batch_size = min(batch_size, len(X_valid) // 3) train_gtr = KerasBatchGenerator(X_train, y_train, batch_size) valid_gtr = KerasBatchGenerator(X_valid, y_valid, valid_batch_size) earlystop = EarlyStopping(patience=patience) checkpoint = ModelCheckpoint(model_weight_path, save_best_only=save_best_only, save_weights_only=save_weights_only) history = History() model = Sequential() model.add( Embedding(input_dim=self._vocab_size, output_dim=self._embedding_size, input_length=self._pad_size)) model.add(Conv1D(self._filters, self._kernel_size, activation='relu')) model.add(MaxPooling1D(self._pool_size)) model.add(Dropout(rate=self._cnn_dropout)) model.add(Flatten()) model.add(Dense(self._ind_encoder.class_size, activation='sigmoid')) model.compile(optimizer=self._optimizer, loss=self._loss, metrics=self._metrics) model.fit_generator(train_gtr.generate(), len(X_train) // batch_size, epochs=epochs, validation_data=valid_gtr.generate(), validation_steps=len(X_valid) // valid_batch_size, callbacks=[earlystop, checkpoint, history]) for epoch in np.arange(0, len(model.history.history['loss'])): logger.info( f"Epoch={epoch + 1}, " f"{', '.join(f'{key}={value[epoch]}' for key, value in model.history.history.items())}" ) # Save the model structure. with open(model_graph_path, 'w') as f: f.write(model.to_json()) # Load the trained model. self._model = model
def CNN(x_train, y_train, x_test, y_test): history = History() input_shape = x_train[0].shape print("one sample input shape to the neural network = ", input_shape, "num of samples = ", x_train.shape[0]) batch_size = 5 num_classes = 2 epochs = 20 x_train = x_train.astype('float32') x_test = x_test.astype('float32') y_train = keras.utils.to_categorical(y_train, num_classes) y_test = keras.utils.to_categorical(y_test, num_classes) model = Sequential() model.add( Conv2D(32, kernel_size=(3, 3), padding="same", activation='relu', input_shape=input_shape)) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(64, (3, 3), padding="same", activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(128, (3, 3), padding="same", activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(128, (3, 3), padding="same", activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(256, (3, 3), padding="same", activation='relu')) model.add(Conv2D(256, (3, 3), padding="same", activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dense(100, activation='relu')) model.add(Dense(num_classes, activation='softmax')) model.compile(loss=keras.losses.binary_crossentropy, optimizer=keras.optimizers.Adam(), metrics=['accuracy']) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(x_test, y_test), callbacks=[history]) train_score = model.evaluate(x_train, y_train, verbose=0) print('Train loss: {}, Train accuracy: {}'.format(train_score[0], train_score[1])) test_score = model.evaluate(x_test, y_test, verbose=0) print('Test loss: {}, Test accuracy: {}'.format(test_score[0], test_score[1]))
def train(self, names, genders, split_rate=0.2, batch_size=128, patience=5, model_weight_path=_classifier_weights_path, model_graph_path=_classifier_graph_path, save_best_only=True, save_weights_only=True, epochs=100): """ Train the LSTM model. """ names = self._encode_name(names, True) genders = self._encode_gender(genders, True) X_train, X_valid, y_train, y_valid = train_test_split( names, genders, test_size=split_rate) valid_batch_size = min(batch_size, len(X_valid) // 3) train_gtr = KerasBatchGenerator(X_train, y_train, batch_size) valid_gtr = KerasBatchGenerator(X_valid, y_valid, valid_batch_size) earlystop = EarlyStopping(patience=patience) checkpoint = ModelCheckpoint(model_weight_path, save_best_only=save_best_only, save_weights_only=save_weights_only) history = History() self._model = Sequential() self._model.add( Embedding(self._name_encoder.char_size + 1, output_dim=self._embedding_size)) self._model.add( Bidirectional(LSTM(self._lstm_size1, return_sequences=True))) self._model.add(Dropout(rate=self._lstm_dropout1)) self._model.add(Bidirectional(LSTM(self._lstm_size2))) self._model.add(Dropout(rate=self._lstm_dropout2)) self._model.add(Dense(self._output_dim, activation='sigmoid')) self._model.compile(optimizer=self._optimizer, loss=self._loss, metrics=self._metrics) self._model.fit_generator(train_gtr.generate(), len(X_train) // batch_size, epochs=epochs, validation_data=valid_gtr.generate(), validation_steps=len(X_valid) // valid_batch_size, callbacks=[earlystop, checkpoint, history]) for epoch in np.arange(0, len(self._model.history.history['loss'])): logger.info( f"Epoch={epoch + 1}, " f"{', '.join(f'{key}={value[epoch]}' for key, value in self._model.history.history.items())}" ) # Save the model structure. with open(model_graph_path, 'w') as f: f.write(self._model.to_json())
def train(self, data: tf.keras.utils.Sequence, **kwargs): epochs = 1 left_kwargs = copy.deepcopy(kwargs) if "aggregate_every_n_epoch" in kwargs: epochs = kwargs["aggregate_every_n_epoch"] del left_kwargs["aggregate_every_n_epoch"] left_kwargs["callbacks"] = [History()] self._model.fit(x=data, epochs=epochs, verbose=1, shuffle=True, **left_kwargs) self._loss = left_kwargs["callbacks"][0].history["loss"] return epochs * len(data)
def __getstate__(self): state = self.__dict__.copy() if hasattr(self, "model") and self.model is not None: buf = io.BytesIO() with h5py.File(buf, compression="lzf", mode="w") as h5: save_model(self.model, h5, overwrite=True, save_format="h5") buf.seek(0) state["model"] = buf if hasattr(self, "history"): from tensorflow.python.keras.callbacks import History history = History() history.history = self.history.history history.params = self.history.params history.epoch = self.history.epoch state["history"] = history return state
def train(): X_train, y_train = get_train_data() X_test, y_test = get_valid_data() # data generater train_gen = ImageDataGenerator(rescale=1.0 / 255, horizontal_flip=True, width_shift_range=4.0 / 32.0, height_shift_range=4.0 / 32.0) test_gen = ImageDataGenerator(rescale=1.0 / 255) y_train = to_categorical(y_train) y_test = to_categorical(y_test) # load network model = resnet50() #model.compile(Adam(0.001), "categorical_crossentropy", ["accuracy"]) #model.compile(SGD(0.01, momentum = 0.9), "categorical_crossentropy", ["acc"]) model.compile(SGD(0.01, momentum=0.9), "categorical_crossentropy", ["acc", "top_k_categorical_accuracy"]) model.summary() # set GPU config = tf.ConfigProto() config.gpu_options.allow_growth = True session = tf.Session(config=config) set_session(session) # set batch_size = 128 scheduler = LearningRateScheduler(lr_scheduler) hist = History() start_time = time.time() model.fit_generator(train_gen.flow(X_train, y_train, batch_size, shuffle=True), steps_per_epoch=X_train.shape[0] // batch_size, validation_data=test_gen.flow(X_test, y_test, batch_size, shuffle=False), validation_steps=X_test.shape[0] // batch_size, callbacks=[scheduler, hist], max_queue_size=5, epochs=50) elapsed = time.time() - start_time print('training time', elapsed) history = hist.history history["elapsed"] = elapsed with open("resnet50_2_DS_with_res_no_bias.pkl", "wb") as fp: pickle.dump(history, fp)
def __init__(self, config, dataset): self.config = config # Training and testing datasets. self.dataset = dataset # ConvNet model. self.model = Sequential() # History object, holds training history. self.history = History() # Saved model path. self.saved_model_path = self.config.config_namespace.saved_model_path # Checkpoint for ConvNet model. self.checkpoint = ModelCheckpoint( self.saved_model_path, monitor='val_acc', verbose=self.config.config_namespace.checkpoint_verbose, save_best_only=True, mode='max') self.early_stopping = EarlyStopping(monitor='val_loss', min_delta=0, patience=10, mode='auto', restore_best_weights=True) # Callbacks list. self.callbacks_list = [self.checkpoint, self.early_stopping] # Evaluation scores. self.scores = [] # Training time. self.train_time = 0 # Predicted class labels. self.predictions = np.array([]) self.predictions_one_hot = np.array([]) # Construct the ConvNet model. self.define_model() # Configure the ConvNet model. self.compile_model() # Train the ConvNet model using testing dataset. self.fit_model() # Evaluate the ConvNet model using testing dataset. self.evaluate_model() # Predict the class labels of testing dataset. self.predict()
def __init__(self, stop_patience=10, lr_factor=0.5, lr_patience=1, lr_epsilon=0.001, lr_cooldown=4, lr_minimum=1e-5, outputDir=''): self.nl_begin = newline_callbacks_begin(outputDir) self.nl_end = newline_callbacks_end() self.stopping = EarlyStopping(monitor='val_loss', patience=stop_patience, verbose=1, mode='min') self.reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=lr_factor, patience=lr_patience, mode='min', verbose=1, epsilon=lr_epsilon, cooldown=lr_cooldown, min_lr=lr_minimum) self.modelbestcheck = ModelCheckpoint( outputDir + "/KERAS_check_best_model.h5", monitor='val_loss', verbose=1, save_best_only=True) self.modelbestcheckweights = ModelCheckpoint( outputDir + "/KERAS_check_best_model_weights.h5", monitor='val_loss', verbose=1, save_best_only=True, save_weights_only=True) self.modelcheckperiod = ModelCheckpoint( outputDir + "/KERAS_check_model_epoch{epoch:02d}.h5", verbose=1, period=10) self.modelcheck = ModelCheckpoint( outputDir + "/KERAS_check_model_last.h5", verbose=1) self.modelcheckweights = ModelCheckpoint( outputDir + "/KERAS_check_model_last_weights.h5", verbose=1, save_weights_only=True) self.tb = TensorBoard(log_dir=outputDir + '/logs') self.history = History() self.timer = Losstimer() self.callbacks = [ self.nl_begin, self.modelbestcheck, self.modelbestcheckweights, self.modelcheck, self.modelcheckweights, self.modelcheckperiod, self.reduce_lr, self.stopping, self.nl_end, self.tb, self.history, self.timer ]
def model_fit_predict(): """ Training example was implemented according to machine-learning-mastery forum The function takes data from the dictionary returned from splitWindows.create_windows function https://machinelearningmastery.com/stateful-stateless-lstm-time-series-forecasting-python/ :return: np.array of predictions """ X, y, test_input = windows_dict['X'], windows_dict['y'], windows_dict[ 'X_test'] # Predictions are stored in a list predictions = [] with tqdm(total=X.shape[0], desc="Training the model, saving predictions") as progress_bar: # Save model History in order to check error data history = History() # build model framework current_model = model_builder(X) # Make predictions for each window for i in range(X.shape[0]): # TRAIN (FIT) model for each epoch # history = current_model.fit( # input_X[i], target_X[i], # epochs=_epochs, batch_size=batch, # verbose=0, shuffle=False, validation_split=0.1, # callbacks=[history] # ) # print(X[i].shape, X[i].dtype, y[i].shape, y[i].dtype) for e in range(epochs): current_model.fit(X[i], y[i], epochs=1, batch_size=batch, verbose=0, shuffle=False, callbacks=[history]) current_model.reset_states() # PREDICT and save results predictions.append( current_model.predict(test_input[i], batch_size=batch_test, verbose=0)) progress_bar.update(1) return np.asarray(predictions)
def train(alpha): (X_train, y_train), (X_test, y_test) = cifar10.load_data() train_gen = ImageDataGenerator(rescale=1.0 / 255, horizontal_flip=True, width_shift_range=4.0 / 32.0, height_shift_range=4.0 / 32.0) test_gen = ImageDataGenerator(rescale=1.0 / 255) y_train = to_categorical(y_train) y_test = to_categorical(y_test) tf.logging.set_verbosity(tf.logging.FATAL) if alpha <= 0: model = create_normal_wide_resnet() else: model = create_octconv_wide_resnet(alpha) model.compile(SGD(0.1, momentum=0.9), "categorical_crossentropy", ["acc"]) model.summary() # convert to tpu model tpu_grpc_url = "grpc://" + os.environ["COLAB_TPU_ADDR"] tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver( tpu_grpc_url) strategy = keras_support.TPUDistributionStrategy(tpu_cluster_resolver) model = tf.contrib.tpu.keras_to_tpu_model(model, strategy=strategy) batch_size = 128 scheduler = LearningRateScheduler(lr_scheduler) hist = History() start_time = time.time() model.fit_generator(train_gen.flow(X_train, y_train, batch_size, shuffle=True), steps_per_epoch=X_train.shape[0] // batch_size, validation_data=test_gen.flow(X_test, y_test, batch_size, shuffle=False), validation_steps=X_test.shape[0] // batch_size, callbacks=[scheduler, hist], max_queue_size=5, epochs=200) elapsed = time.time() - start_time print(elapsed) history = hist.history history["elapsed"] = elapsed with open(f"octconv_alpha_{alpha}.pkl", "wb") as fp: pickle.dump(history, fp)
def update(self, names, genders, split_rate=0.2, batch_size=64, patience=1, model_weights_path=_classifier_weights_path, model_graph_path=_classifier_graph_path, model_weights_backup_path=_classifier_weights_backup_path, model_graph_backup_path=_classifier_graph_backup_path, save_best_only=True, save_weights_only=True, epochs=2): """ This function keep the original model, update the model and save it as default model. """ names = self._encode_name(names, True) genders = self._encode_gender(genders, True) X_train, X_valid, y_train, y_valid = train_test_split( names, genders, test_size=split_rate) valid_batch_size = min(batch_size, len(X_valid) // 3) train_gtr = KerasBatchGenerator(X_train, y_train, batch_size) valid_gtr = KerasBatchGenerator(X_valid, y_valid, valid_batch_size) earlystop = EarlyStopping(patience=patience) checkpoint = ModelCheckpoint(model_weights_path, save_best_only=save_best_only, save_weights_only=save_weights_only) history = History() if not self._model: self.load() # Save the old model to backup. self._model.save_weights(model_weights_backup_path) with open(model_graph_backup_path, 'r') as f: f.write(self._model.to_json()) self._model.fit_generator(train_gtr.generate(), len(X_train) // batch_size, epochs=epochs, validation_data=valid_gtr.generate(), validation_steps=len(X_valid) // valid_batch_size, callbacks=[earlystop, checkpoint, history]) for epoch in np.arange(0, len(self._model.history.history['loss'])): logger.info( f"Epoch={epoch + 1}, " f"{', '.join(f'{key}={value[epoch]}' for key, value in self._model.history.history.items())}" ) # Save the model structure. with open(model_graph_path, 'w') as f: f.write(self._model.to_json())
def eval_callbacks_list(base_path='F:\\AI-modelsaver\\GTSRB\\LeNet5'): eval_log_dir = os.path.join(base_path, datetime.datetime.now().strftime("%Y-%m-%d"), datetime.datetime.now().strftime("%H-%M-%S"), 'Tensorboard', 'evaluate') if not os.path.exists(eval_log_dir): os.makedirs(eval_log_dir) eval_callback = [ TensorBoard(os.path.join(eval_log_dir), update_freq='batch'), History() ] return eval_callback
def appendix_trial(batch_size, use_tpu=True, sep=-1): tpu_flag = "tpu" if use_tpu else "gpu" filename = f"appendix_{tpu_flag}_batch_size_{batch_size}" if sep >= 0: filename += f"_sep_{sep}" filename += ".dat" result = {} for mode in range(3): if sep >= 0: if sep != mode: continue K.clear_session() model = create_wideresnet(7, 4, use_tpu) # mode 1 = そのままfit # mode 2 = バッチサイズの倍数に切り詰めてfit # mode 3 = fit_generator data_gen = ImageDataGenerator(rescale=1.0/255) nb_epochs = 20 (X_train, y_train), (_, _) = cifar100.load_data() timer = Timer() hist = History() print("Start training...") print("mode = ", mode) if mode == 0: X_train = X_train / 255.0 y_train = to_categorical(y_train) model.fit(X_train, y_train, batch_size=batch_size, epochs=nb_epochs, callbacks=[timer, hist]) elif mode == 1: n_train = (X_train.shape[0] // batch_size) * batch_size X_train = X_train[:n_train, :, :, :] / 255.0 y_train = to_categorical(y_train[:n_train, :]) model.fit(X_train, y_train, batch_size=batch_size, epochs=nb_epochs, callbacks=[timer, hist]) elif mode == 2: y_train = to_categorical(y_train) steps_per_epoch = X_train.shape[0] // batch_size model.fit_generator(data_gen.flow(X_train, y_train, batch_size=batch_size, shuffle=True), steps_per_epoch=steps_per_epoch, epochs=nb_epochs, callbacks=[timer, hist]) history = hist.history history["initial_time"] = timer.inital_time history["times"] = timer.times result[mode] = history with open(filename, "wb") as fp: pickle.dump(result, fp) return filename
def create_callbacks(data_root, model_id, weights_label='weights', patience=4): filepath = data_root + 'models/' + model_id + '_' + weights_label + '.hdf5' estop_cb = EarlyStopping(monitor='val_loss', min_delta=0, patience=patience, verbose=0, mode='auto') save_best_cb = ModelCheckpoint(filepath, monitor='val_loss', verbose=0, save_best_only=True, save_weights_only=True, mode='auto', period=1) history_cb = History() return [estop_cb, save_best_cb, history_cb], filepath
def load_run_render(model, frame): # Resize & Grayscale input images, reshape array im = cv2.resize(frame, (img_size, img_size)) im = cv2.cvtColor(im, cv2.COLOR_RGB2GRAY) im = np.expand_dims(np.expand_dims(im, axis=0).astype(np.float32), axis=-1) / 255 # Fit model and return loss history = History() model.fit(im, im, epochs=1, batch_size=1, shuffle=False, callbacks=[history], verbose=0) return history.history['loss'][-1]
def fit(self, type = 'evaluation'): ''' Fit the keras self.model ''' # If model as already been fit, check that if self.error is not None: return self.error if self.model is None: self.model = self.build() self.history = History() self.history = self.model.fit(self.X_train, self.Y_train, epochs = self.epochs, callbacks=[self.history], verbose=self.verbose) # Assign fitness if self.final: self.error = self.history.history['loss'][-1] else: self.error = self.model.evaluate(self.X_test, self.Y_test, verbose=self.verbose) if type == 'evaluation' else self.history.history['loss'][-1] return self.error
def solve(self, train_X, train_Y, test_X, test_Y): """ Initialize NN, train and test """ input_dims = 1 model = Sequential() model.add( Dense(self.hidden_neurons, activation='relu', input_shape=(input_dims, ))) model.add(Dense(self.output_neurons, activation='linear')) sgd = optimizers.Adam(lr=0.05) model.compile(loss='mean_squared_error', optimizer=sgd, metrics=['accuracy']) history = History() callbacks = [ history, ModelCheckpoint(filepath='best_model.h5', monitor='val_loss', save_best_only=True, mode='auto') ] # Train model.fit(train_X, train_Y, epochs=self.epochs, batch_size=self.batch_size, verbose=1, callbacks=callbacks) loss_and_metrics = model.evaluate(test_X, test_Y, batch_size=self.batch_size) # Predict y_pred = model.predict(test_X, batch_size=self.batch_size, verbose=0, steps=None) return y_pred
def execute(): data_in_chan = 1 data_out_chan = 1 data_x = 256 data_y = 256*data_in_chan model_x = 256 model_y = 256 batch_size = 10 num_epochs = 25 X_folder = 'C:\\Users\\axm3\\Documents\\data\\deepMRAC\\data\\bravo-tiff\\X' Y_folder = 'C:\\Users\\axm3\\Documents\\data\\deepMRAC\\data\\bravo-tiff\\Y' X_progress_file = 'C:\\Users\\axm3\\Documents\\data\\deepMRAC\\data\\bravo-tiff\\X\\train\\X_00001_00000001.tiff' Y_progress_file = 'C:\\Users\\axm3\\Documents\\data\\deepMRAC\\data\\bravo-tiff\\Y\\train\\Y_00001_00000001.tiff' print('creating model') model = Unet.UNetContinuous([model_x,model_y,data_in_chan],out_ch=data_out_chan,start_ch=16,depth=4,inc_rate=2.,activation='relu',dropout=0.5,batchnorm=True,maxpool=True,upconv=True,residual=False) model = deeprad_keras_tools.wrap_model( model, (data_x,data_y,1), (data_x,data_y,1), (model_x,model_y,1), (model_x,model_y,1) ) model.compile(optimizer=Adam(lr=1e-3), loss=smooth_L1_loss, metrics=[smooth_L1_loss,losses.mean_squared_error,losses.mean_absolute_error]) model.summary() print('creating data generators') train_gen = deeprad_keras_tools.get_keras_tiff_generator( os.path.join(X_folder,'train'), os.path.join(Y_folder,'train'), batch_size ) val_gen = deeprad_keras_tools.get_keras_tiff_generator( os.path.join(X_folder,'val'), os.path.join(Y_folder,'val'), batch_size ) print('creating callbacks') history = History() modelCheckpoint = ModelCheckpoint('weights.h5', monitor='loss', save_best_only=True) tblogdir = 'tblogs/{}'.format(time()) tensorboard = TensorBoard(log_dir=tblogdir) X_progress = deeprad_keras_tools.read_images( [X_progress_file] ) Y_progress = deeprad_keras_tools.read_images( [Y_progress_file] ) tensorboardimage = deeprad_keras_tools.TensorBoardIm2ImCallback(log_dir=tblogdir,X=X_progress,Y=Y_progress) print('fitting model') model.fit_generator( train_gen, validation_data=val_gen, epochs=num_epochs, use_multiprocessing=True, max_queue_size=20, workers=3, callbacks=[history, modelCheckpoint, tensorboard, tensorboardimage] )
def train(use_ricap): batch_size = 1024 if use_ricap: train_gen_instance = RICAPGenerator(rescale=1.0 / 255, width_shift_range=15.0 / 160, height_shift_range=15.0 / 160, horizontal_flip=True, ricap_beta=0.3) else: train_gen_instance = ImageDataGenerator(rescale=1.0 / 255, width_shift_range=15.0 / 160, height_shift_range=15.0 / 160, horizontal_flip=True) train_gen = train_gen_instance.flow_from_directory( "animeface-character-dataset/train", target_size=(160, 160), batch_size=batch_size) test_gen = ImageDataGenerator(rescale=1.0 / 255).flow_from_directory( "animeface-character-dataset/test", target_size=(160, 160), batch_size=batch_size) model = create_network() model.compile(tf.train.RMSPropOptimizer(1e-4), "categorical_crossentropy", ["acc"]) tpu_grpc_url = "grpc://" + os.environ["COLAB_TPU_ADDR"] tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver( tpu_grpc_url) strategy = keras_support.TPUDistributionStrategy(tpu_cluster_resolver) model = tf.contrib.tpu.keras_to_tpu_model(model, strategy=strategy) hist = History() model.fit_generator(train_gen, steps_per_epoch=10062 // batch_size, callbacks=[hist], validation_data=test_gen, validation_steps=4428 // batch_size, epochs=1) history = hist.history with open(f"anime_ricap_{use_ricap}.dat", "wb") as fp: pickle.dump(history, fp)
def train(): # データの読み込み data = np.load("wiki_crop/wiki_all.npz") image, gender, age = data["image"], data["gender"], data["age"] # TrainとTestのSplit(インデックスを指定するだけ) np.random.seed(45) indices = np.random.permutation(image.shape[0]) n_test = 8192 # 8192枚をテストとする test_indices = indices[:n_test] train_indices = indices[n_test:] # モデルの作成 model = create_model() # 損失関数を自作してコンパイル model.compile(tf.train.RMSPropOptimizer(3e-3), multitask_loss) # TPUモデルに変換 tpu_grpc_url = "grpc://" + os.environ["COLAB_TPU_ADDR"] tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver( tpu_grpc_url) strategy = keras_support.TPUDistributionStrategy(tpu_cluster_resolver) model = tf.contrib.tpu.keras_to_tpu_model(model, strategy=strategy) # 訓練 batch_size = 512 history = History() checkpoint = Checkpoint(model) model.fit_generator(data_generator(image, gender, age, train_indices, batch_size, True), steps_per_epoch=len(train_indices) // batch_size, validation_data=data_generator(image, gender, age, test_indices, batch_size, False), validation_steps=len(test_indices) // batch_size, max_queue_size=1, callbacks=[history, checkpoint], epochs=50) # 結果保存 hist = history.history with open("history.dat", "wb") as fp: pickle.dump(hist, fp)
def train_new(self, channel): """ Train LSTM model according to specifications in config.yaml. Args: channel (obj): Channel class object containing train/test data for X,y for a single channel """ cbs = [History(), EarlyStopping(monitor='val_loss', patience=self.config.patience, min_delta=self.config.min_delta, verbose=0)] self.model = Sequential() self.model.add(LSTM( self.config.layers[0], # input_shape=(None, channel.X_train.shape[2]), return_sequences=True)) self.model.add(Dropout(self.config.dropout)) self.model.add(LSTM( self.config.layers[1], return_sequences=False)) self.model.add(Dropout(self.config.dropout)) self.model.add(Dense( self.config.n_predictions)) self.model.add(Activation('linear')) self.model.compile(loss=self.config.loss_metric, optimizer=self.config.optimizer) self.model.fit(channel.X_train, channel.y_train, batch_size=self.config.lstm_batch_size, epochs=self.config.epochs, validation_split=self.config.validation_split, callbacks=cbs, verbose=True)