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),
