reduceLROnPlat = keras.callbacks.ReduceLROnPlateau(monitor="val_loss", factor=0.8, patience=3, verbose=1, min_lr=0.0001) csv_logger = keras.callbacks.CSVLogger( os.path.join(PATH_SAVE_MODEL, "training.csv")) # Save model fit progress PATH_TRAING_MONITOR = os.path.join(PATH_SAVE_MODEL, "training_monitor") if not os.path.exists(PATH_TRAING_MONITOR): os.makedirs(PATH_TRAING_MONITOR) callbacks = [ TrainingMonitor(PATH_TRAING_MONITOR, metrics=["mean_absolute_error"]), reduceLROnPlat, csv_logger, ] #################################################################################### history = model.fit( [img_train, gdr_train], [age_train], batch_size=BATCH_SIZE, epochs=EPOCHS, shuffle=True, verbose=VERBOSE, validation_data=([img_valid, gdr_valid], [age_valid]), callbacks=callbacks, )
# Load weight if args["load_weights"] != None: print("Loading weights from", args["load_weights"]) autoencoder.load_weights(args["load_weights"]) autoencoder.compile(optimizer=OPTIMIZER, loss="binary_crossentropy") autoencoder_train = autoencoder.fit( x_train, x_train, epochs=EPOCHS, batch_size=BATCH_SIZE, shuffle=True, validation_data=(x_valid, x_valid), callbacks=[TrainingMonitor(PATH_TRAING_MONITOR, metrics=[])], ) # serialize model to YAML model_yaml = autoencoder.to_yaml() with open(os.path.join(PATH_SAVE_MODEL, "model.yaml"), "w") as yaml_file: yaml_file.write(model_yaml) # serialize weights to HDF5 autoencoder.save_weights(os.path.join(PATH_SAVE_MODEL, "model.h5")) print("Saved model to disk") plt.style.use("ggplot") plt.figure() plt.plot(autoencoder_train.history["loss"], label="Training") plt.plot(autoencoder_train.history["val_loss"], label="Validation")
# model.fit_generator(trainGen.generator(),steps_per_epoch=trainGen.numImages // 32,validation_data=valGen.generator(), # validation_steps=valGen.numImages // 32,epochs=3,max_queue_size=10, # callbacks=callbacks,verbose=1, class_weight=class_weight) # now that the head FC layers have been trained/initialized, lets # unfreeze the final set of CONV layers and make them trainable for layer in baseModel.layers[13:]: layer.trainable = True # for the changes to the model to take affect we need to recompile # the model, this time using SGD with a *very* small learning rate print("[INFO] re-compiling model...") path = os.path.sep.join([config.OUTPUT_PATH, "{}.png".format(os.getpid())]) callbacks = [EpochCheckpoint(config.MODEL_CHECKPOINT_PATH, every=2,startAt=5),TrainingMonitor(path)] #class_weight = {0:10,1: 1,2: 2} print("[INFO] training head...") # train the network #opt = SGD(lr=0.0008) # results were not satisfactory using new value opt = SGD(lr=0.0006) model.compile(loss="categorical_crossentropy", optimizer=opt, metrics=["accuracy"]) # train the model again, this time fine-tuning *both* the final set # of CONV layers along with our set of FC layers print("[INFO] fine-tuning model...") model.fit_generator(trainGen.generator(),steps_per_epoch=trainGen.numImages // 32,validation_data=valGen.generator(), validation_steps=valGen.numImages // 32,epochs=50,max_queue_size=10, callbacks=callbacks,verbose=1)
csv_logger = keras.callbacks.CSVLogger( os.path.join(PATH_SAVE_MODEL, "training.csv")) # Imagen summary model plot_model(model, to_file=os.path.join(PATH_SAVE_MODEL, "summary_model.png"), show_shapes=True) # Save model fit progress PATH_TRAING_MONITOR = os.path.join(PATH_SAVE_MODEL, "training_monitor") if not os.path.exists(PATH_TRAING_MONITOR): os.makedirs(PATH_TRAING_MONITOR) callbacks = [ TrainingMonitor(PATH_TRAING_MONITOR), # tbCallBack, # checkpoint, reduceLROnPlat, csv_logger, ] history = model.fit( [img_train, gdr_train], [age_train], batch_size=BATCH_SIZE, shuffle=True, epochs=EPOCHS, verbose=VERBOSE, validation_data=([img_valid, gdr_valid], [age_valid]), callbacks=callbacks,
classes=2, ) ## initalize an optimizer & compile model print("[INFO] compiling model...") adam = Adam(lr=0.001) #model = AlexNet.build(width=227, height=227, depth=3, classes=2, reg=0.002) model = AlexNet2.build(width=227, height=227, depth=3, classes=2, reg=0.002) model.compile(loss="binary_crossentropy", optimizer=adam, metrics=["accuracy"]) # build callbacks figpath = os.path.sep.join( [config.OUTPUT_PATH, "{}_learning_curve.png".format(os.getpid())]) tm = TrainingMonitor(figpath) cptpath = os.path.sep.join( [config.OUTPUT_PATH, "model-alexnet2-{epoch:03d}-{val_loss:0.4f}.hdf5"]) checkpt = ModelCheckpoint(cptpath, monitor="val_loss", mode="min", \ save_best_only=True, verbose=1) # train the NN model.fit_generator(trainGen.generator(), steps_per_epoch=trainGen.numImages // BATCH_SIZE, validation_data=valGen.generator(), validation_steps=valGen.numImages // BATCH_SIZE, epochs=75, max_queue_size=BATCH_SIZE, callbacks=[tm, checkpt], verbose=1)
testX = testX.astype("float") mean = np.mean(trainX, axis=0) trainX -= mean testX -= mean lb = LabelBinarizer() trainY = lb.fit_transform(trainY) testY = lb.fit_transform(testY) aug = ImageDataGenerator(width_shift_range=0.1, height_shift_range=0.1, horizontal_flip=True, fill_mode="nearest") figPath = os.path.sep.join([args["output"], "{}.png".format(os.getpid())]) jsonPath = os.path.sep.join([args["output"], "{}.json".format(os.getpid())]) callbacks = [TrainingMonitor(figPath, jsonPath=jsonPath), LearningRateScheduler(poly_decay)] print("[INFO] compiling model...") opt = SGD(lr=init_lr, decay=0.1 / 70, momentum=0.9) # opt = SGD(lr=init_lr, momentum=0.9) model = MiniGoogleNet.build(width=32, height=32, depth=3, classes=10) model.compile(loss="categorical_crossentropy", optimizer=opt, metrics=["accuracy"]) print("[INFO] training network...") model.fit_generator(aug.flow(trainX, trainY, batch_size=64), validation_data=(testX, testY), steps_per_epoch=len(trainX) // 64, epochs=num_epochs, callbacks=callbacks) print("[INFO] serializing network...") model.save(args["model"])
lr=0.001, betas=(0.9, 0.999)) if args.optimizer == 'adamw': optimizer = AdamW(model.parameters(), lr=0.001, betas=(0.9, 0.999), weight_decay=0.001) if args.optimizer == 'novograd': optimizer = NovoGrad(model.parameters(), lr=0.01, betas=(0.95, 0.98), weight_decay=0.001) train_monitor = TrainingMonitor(file_dir='./png', arch=args.model) if args.do_scheduler: lr_scheduler = CosineAnnealingLR(optimizer, epochs * len(loaders['train']), 1e-4) for epoch in range(1, epochs + 1): if args.do_scheduler: train_log = train(loaders['train'], lr_scheduler=lr_scheduler) else: train_log = train(loaders['train'], lr_scheduler=None) valid_log = test(loaders['valid']) logs = dict(train_log, **valid_log) show_info = f'\nEpoch: {epoch} - ' + "-".join( [f' {key}: {value:.4f} ' for key, value in logs.items()]) print(show_info) train_monitor.epoch_step(logs)
lb = LabelBinarizer() trainY = lb.fit_transform(trainY) testY = lb.fit_transform(testY) labelNames = [ "airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck" ] figPath = os.path.sep.join([args["output"], "{}.png".format(os.getpid())]) jsonPath = os.path.sep.join([args["output"], "{}.json".format(os.getpid())]) callbacks = [ TrainingMonitor(figPath, jsonPath=jsonPath), LearningRateScheduler(step_decay) ] opt = SGD(lr=0.01, momentum=0.9, nesterov=True) model = VggNet.load(width=32, height=32, depth=3, classes=10) model.compile(loss="categorical_crossentropy", optimizer=opt, metrics=['accuracy']) H = model.fit(trainX, trainY, validation_data=(testX, testY), batch_size=64, epochs=20, callbacks=callbacks,
metrics=["accuracy"]) else:# otherwise, we're using a checkpoint model # load the checkpoint from disk print("[INFO] loading {}...".format(args["model"])) model = load_model(args["model"]) # update the learning rate print("[INFO] old learning rate: {}".format(K.get_value(model.optimizer.lr))) K.set_value(model.optimizer.lr, 1e-2) print("[INFO] new learning rate: {}".format(K.get_value(model.optimizer.lr))) # build the path to the training plot and training history plotPath = os.path.sep.join(["output", "resnet_fashion_mnist.png"]) jsonPath = os.path.sep.join(["output", "resnet_fashion_mnist.json"]) # construct the set of callbacks callbacks = [EpochCheckpoint(args["checkpoints"], every=5, startAt=args["start_epoch"]), TrainingMonitor(plotPath, jsonPath=jsonPath, startAt=args["start_epoch"])] # train the network print("[INFO] training network...") model.fit_generator( aug.flow(trainX, trainY, batch_size=128), validation_data=(testX, testY), steps_per_epoch=len(trainX) // 128, epochs=80, callbacks=callbacks, verbose=1)
optimizer=opt, metrics=["accuracy"]) else: print("[INFO] loading {}...".format(args["model"])) model = load_model(args["model"]) print("[INFO] old learning rate:{}".format(K.get_value( model.optimizer.lr))) K.set_value(model.optimizer.lr, 1e-3) print("[INFO] new learning rate:{}".format(K.get_value( model.optimizer.lr))) callbacks = [ EpochCheckpoint(args["checkpoints"], every=5, startAt=args["start_epoch"]), TrainingMonitor("output/resnet56_cifar10.png", jsonPath="output/resnet56_cifar10.json", startAt=args["start_epoch"]) ] print("[INFO] training network...") print("trainX.shape:\n", trainX.shape) print("testX.shape:\n", testX.shape) print("trainY.shape:\n", trainY.shape) print("testY.shape:\n", testY.shape) model.fit_generator(aug.flow(trainX, trainY, batch_size=128), validation_data=(testX, testY), steps_per_epoch=len(trainX) // 128, epochs=10, callbacks=callbacks, verbose=1)
lb = LabelBinarizer() y_train = lb.fit_transform(y_train) y_test = lb.fit_transform(y_test) numOfEpoch = 10 model = MiniVGGNet.build(32, 32, 3, 10) model.compile(SGD(lr=0.01, momentum=0.9, nesterov=True), 'categorical_crossentropy', ['accuracy']) outFolder = 'Outputs' folPath = os.path.sep.join([outFolder, '{}.png'.format(os.getpid())]) jsonPath = os.path.sep.join([outFolder, '{}.json'.format(os.getpid())]) callbacks = [TrainingMonitor(folPath, jsonPath)] H = model.fit(X_train, y_train, 128, numOfEpoch, validation_data=(X_test, y_test), callbacks=callbacks) # graph of loss and accuracy fig = plt.figure() plt.plot(np.arange(0, numOfEpoch), H.history['loss'], label='training loss') plt.plot(np.arange(0, numOfEpoch), H.history['val_loss'], label='validation loss') plt.plot(np.arange(0, numOfEpoch), H.history['acc'], label='accuracy')
for layer in baseModel.layers: layer.trainable = False # initialize the new head of the network, a set of FC layers # followed by a softmax classifier headModel = FCHeadNet.build(baseModel, len(classNames), 256) # place the head FC model on top of the base model -- this will # become the actual model we will train model = Model(inputs=baseModel.input, outputs=headModel) path = os.path.sep.join([config.OUTPUT_PATH, "{}.png".format(os.getpid())]) callbacks = [ EpochCheckpoint(config.MODEL_CHECKPOINT_PATH, every=2, startAt=5), TrainingMonitor(path) ] model.compile(loss="categorical_crossentropy", optimizer=opt, metrics=["accuracy"]) # train the model again, this time fine-tuning *both* the final set # of CONV layers along with our set of FC layers print(model.summary()) print("[INFO] Training model...") print(trainGen.numImages) print(valGen.numImages) print(datetime.datetime.now()) model.fit_generator(trainGen.generator(),
print("[INFO] accessing CIFAR") (trainX, trainY), (testX, testY) = cifar10.load_data(); le = LabelBinarizer(); trainY, testY = le.fit_transform(trainY), le.fit_transform(testY); le.fit_transform(testY); print ("[INFO] Compiling model ..."); opt = SGD(lr = 0.01); model.compile(loss="categorical_crossentropy", optimizer=opt, metrics=["accuracy"]) print ("[INFO] BUILDING MODEL") checkpoint = ModelCheckpoint(weights, monitor = "val_loss", save_best_only=True, verbose =1 ); jsonpath = "/artifacts/mini_vggnet.json" picpath = "/artifacts/pic.jpg" callbacks = [checkpoint, TrainingMonitor(picpath, jsonPath = jsonpath)]; H = model.fit(trainX, trainY, validation_data=(testX, testY), batch_size=128, epochs=90, callbacks = callbacks, verbose=1) print("[INFO] evaluating network...") predictions = model.predict(testX, batch_size=128) print(classification_report(testY.argmax(axis=1), predictions.argmax(axis=1), target_names=[str(x) for x in le.classes_]));
aug = ImageDataGenerator(rotation_range=20, zoom_range=0.15, width_shift_range=0.2, height_shift_range=0.2, shear_range=0.15, horizontal_flip=True, fill_mode="nearest") means = json.loads(open(config.DATASET_MEAN).read()) sp = SimplePreprocessor(227, 227) pp = PatchPreprocessor(227, 227) mp = MeanPreprocessor(means["R"], means["G"], means["B"]) iap = ImageToArrayPreprocessor() trainGen = HDF5DatasetGenerator(config.TRAIN_HDF5, 128, aug=aug, preprocessors=[pp, mp, iap], classes=2) valGen = HDF5DatasetGenerator(config.VAL_HDF5, 128, aug=aug, preprocessors=[sp, mp, iap], classes=2) print("[INFO] compiling model...") opt = Adam(lr=1e-3) model = Alexnet.build(width=227, height=227, depth=3, classes=2, reg=0.0002) model.compile(loss="binary_crossentropy", optimizer=opt, metrics=["accuracy"]) path = os.path.sep.join([config.OUTPUT_PATH, "{}.png".format(os.getpid())]) callbacks = [TrainingMonitor(path)] model.fit_generator(trainGen.generator(), steps_per_epoch=trainGen.numImages // 128, validation_data=valGen.generator(), validation_steps=valGen.numImages // 128, epochs=75, max_queue_size=128*2, callbacks=callbacks, verbose=1) print("[INFO] serializing model...") model.save(config.MODEL_PATH, overwrite=True) trainGen.close() valGen.close()
# initialize the testing generator testGen = valAug.flow_from_directory(config.TEST_PATH, class_mode="categorical", target_size=(128, 128), color_mode="rgb", shuffle=False, batch_size=BS) path = os.path.sep.join([config.OUTPUT_PATH, "{}.png".format(os.getpid())]) checkpoint = ModelCheckpoint(config.Model_PATH, monitor='val_accuracy', verbose=1, save_best_only=True, mode='max') callbacks = [checkpoint, TrainingMonitor(path)] #callbacks_list = [checkpoint] # initialize our CancerNet model and compile it model = WasteNet.build(width=128, height=128, depth=3, classes=3) #opt = Adagrad(lr=INIT_LR, decay=INIT_LR / NUM_EPOCHS) opt = Adam(lr=INIT_LR, decay=INIT_LR / (NUM_EPOCHS * 0.6)) model.compile(loss="categorical_crossentropy", optimizer=opt, metrics=["accuracy"]) # fit the model H = model.fit_generator( trainGen, steps_per_epoch=totalTrain // BS, validation_data=valGen, validation_steps=totalVal // BS,
((trainX, trainY), (testX, testY)) = cifar10.load_data() trainX = trainX.astype("float") / 255.0 testX = testX.astype("float") / 255.0 lb=LabelBinarizer() # convert the labels from integers to vectors trainY = lb.fit_transform(trainY) testY = lb.transform(testY) # initialize the label names for the CIFAR-10 dataset labelNames = ["airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck"] #intialize the optimizer and model print("[INFO] compiling model") opt=SGD(lr=0.01, momentum=0.9, nesterov=True) model= MiniVGGNet.build(width=32,height=32,depth=3, classes=10) model.compile(loss="categorical_crossentropy",optimizer=opt, metrics=["accuracy"]) # construct the set of callbacks figPath = os.path.sep.join([args["output"], "{}.png".format(os.getpid())]) jsonPath = os.path.sep.join([args["output"], "{}.json".format(os.getpid())]) callbacks = [TrainingMonitor(figPath, jsonPath=jsonPath)] # train the network print("[INFO] training network...") model.fit(trainX, trainY, validation_data=(testX, testY), batch_size=64, epochs=100, callbacks=callbacks, verbose=1)
residual=False) #model=load_model('themodel') #opt = SGD(lr=0.01, momentum=0.9, nesterov=True) model.compile(loss="categorical_crossentropy", optimizer=opt, metrics=["accuracy"]) from tensorflow.keras.utils import plot_model os.environ["PATH"] += os.pathsep + 'C:/Program Files/Graphviz/bin/' import os plot_model(model, to_file="model_architecture.png", show_shapes=True) # construct the set of callbacks callbacks = [TrainingMonitor('Learning_rate.png')] print('doshlo') model.fit(train_gen, steps_per_epoch=360, validation_data=test_gen, validation_steps=40, epochs=5, max_queue_size=1, callbacks=callbacks, verbose=1) # save the model to file print("[INFO] serializing model...") model.save('themodel', overwrite=True)
parser.add_argument("--task", type=str, default='image') parser.add_argument("--optimizer", default='lookahead', type=str, choices=['lookahead', 'adam']) args = parser.parse_args() if args.optimizer == 'lookahead': arch = 'ResNet18_Lookahead_adam' optimizer = optim.Adam(model.parameters(), lr=0.001) optimizer = Lookahead(optimizer=optimizer, k=5, alpha=0.5) else: arch = 'ResNet18_Adam' optimizer = optim.Adam(model.parameters(), lr=0.001) train_monitor = TrainingMonitor(file_dir='./', arch=arch) def train(train_loader): pbar = ProgressBar(n_total=len(train_loader), desc='Training') train_loss = AverageMeter() model.train() for batch_idx, (data, target) in enumerate(train_loader): data, target = data.to(device), target.to(device) optimizer.zero_grad() output = model(data) loss = loss_fn(output, target) loss.backward() optimizer.step() pbar(step=batch_idx, info={'loss': loss.item()}) train_loss.update(loss.item(), n=1)
model.compile(loss="categorical_crossentropy", optimizer=opt, metrics=["accuracy"]) else: print("[INFO] loading {}...".format(args["models"])) model = load_model(args["models"]) print("[INFO] old learning rate:{}".format(K.get_value( model.optimizer.lr))) K.set_value(model.optimizer.lr, 1e-3) print("[INFO] new learning rate:{}".format(K.get_value( model.optimizer.lr))) callbacks = [ EpochCheckpoint(args["checkpoints"], every=5, startAt=args["start_epoch"]), TrainingMonitor(config.FIG_PATH, jsonPath=config.JSON_PATH, startAt=args["start_epoch"]) ] model.fit_generator(trainGen.generator(), steps_per_epoch=trainGen.numImages // 64, validation_data=valGen.generator(), validation_steps=valGen.numImages // 64, epochs=5, max_queue_size=64 * 2, callbacks=callbacks, verbose=1) trainGen.close() valGen.close()
K.get_value(parallel_model.optimizer.lr)) K.set_value(parallel_model.optimizer.lr, INIT_LR) print("[INFO] new learning rate =", K.get_value(parallel_model.optimizer.lr)) # set up callbacks FIG_PATH = os.path.sep.join( [args["checkpoints"], "resnet50_learning_curve.png"]) JSON_PATH = os.path.sep.join([args["checkpoints"], "resnet50.json"]) callbacks = [ # use new parallel checkpoint callback which saves single template model! ParallelCheckpoint(model, args["checkpoints"], every=5, startAt=args["start_epoch"]), TrainingMonitor(FIG_PATH, jsonPath=JSON_PATH, startAt=args["start_epoch"]), LearningRateScheduler(poly_decay), ] # distribute BATCH to 2 GPUs, each GPUs computes BATCH / 2 print("[INFO] training...") parallel_model.fit_generator( trainGen.generator(), steps_per_epoch=trainGen.numImages // BATCH, validation_data=valGen.generator(), validation_steps=valGen.numImages // BATCH, epochs=EPOCHS, max_queue_size=BATCH * 2, callbacks=callbacks, class_weight=data_class_weights, # counter imbalanced classes verbose=1)
# partition the data into training and validation split using 80% of the data for # training and the remaining 20% for testing (trainX, valX, trainY, valY) = train_test_split(trainX, trainY, test_size=0.20, stratify=trainY, random_state=42) # construct the image generator for data augmentation aug = ImageDataGenerator(width_shift_range=0.1, height_shift_range=0.1, horizontal_flip=True, fill_mode="nearest") callbacks = [ TrainingMonitor("fig.png", jsonPath="jsonPath.json"), LearningRateScheduler(poly_decay) ] # initialize the optimizer and model print("[INFO] compiling model...") opt = SGD(lr=INIT_LR, momentum=0.9) model = MiniGoogLeNet.build(width=64, height=64, depth=3, classes=imageClasses) model.compile(loss="categorical_crossentropy", optimizer=opt, metrics=["accuracy"]) # train the network print("[INFO] training network...") model.fit_generator(aug.flow(trainX, trainY, batch_size=64), validation_data=(testX, testY),