model.add(Activation(lrelu))
if i % 2 == 0:
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(128))
model.add(BatchNormalization())
model.add(Activation(lrelu))
model.add(Dense(32))
model.add(BatchNormalization())
model.add(Activation(lrelu))
model.add(Dense(num_classes, activation='softmax'))
model = multi_gpu_model(model, gpus=len(gpus), cpu_merge=False)
model.compile(loss='categorical_crossentropy',
optimizer=RAdamOptimizer(learning_rate=1e-4),
metrics=['accuracy'])
model.summary()
history = model.fit(x_train,
y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test))
# Save model and weights
if not os.path.isdir(save_dir):
os.makedirs(save_dir)
model_path = os.path.join(save_dir, model_name)
print("[INFO] Searching Latest checkpoint... ")
checkpoints = [m for m in os.listdir(dir)]
checkpoints = [int(x) for x in checkpoints]
checkpoints.sort()
checkpoints = [str(x) for x in checkpoints]
# create the base pre-trained model
if G <= 1:
print("[INFO] training with 1 GPU...")
model = saved_model.load_keras_model(dir + checkpoints[-1])
else:
print("[INFO] training with {} GPUs...".format(G))
with tf.device("/cpu:0"):
model = saved_model.load_keras_model(dir + checkpoints[-1])
model = multi_gpu_model(model, gpus=G)
# we need to recompile the model for these modifications to take effect
# we use SGD with a low learning rate
print("[INFO] Compiling Model ... ")
from tensorflow.keras.optimizers import SGD
model.compile(optimizer=SGD(lr=INIT_LR, momentum=0.9),
loss='categorical_crossentropy',
metrics=['accuracy'])
print("[INFO] Loading Data... ")
filename = "data1.txt"
filename2 = "labels1.txt"
counter = 1
le = preprocessing.LabelEncoder()
def main(args):
annotation_file = args.annotation_file
log_dir = 'logs/000/'
classes_path = args.classes_path
class_names = get_classes(classes_path)
num_classes = len(class_names)
anchors = get_anchors(args.anchors_path)
num_anchors = len(anchors)
# get freeze level according to CLI option
if args.weights_path:
freeze_level = 0
else:
freeze_level = 1
if args.freeze_level is not None:
freeze_level = args.freeze_level
# callbacks for training process
logging = TensorBoard(log_dir=log_dir, histogram_freq=0, write_graph=False, write_grads=False, write_images=False, update_freq='batch')
checkpoint = ModelCheckpoint(log_dir + 'ep{epoch:03d}-loss{loss:.3f}-val_loss{val_loss:.3f}.h5',
monitor='val_loss',
verbose=1,
save_weights_only=False,
save_best_only=True,
period=1)
reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=10, verbose=1, cooldown=0, min_lr=1e-10)
early_stopping = EarlyStopping(monitor='val_loss', min_delta=0, patience=50, verbose=1)
terminate_on_nan = TerminateOnNaN()
callbacks=[logging, checkpoint, reduce_lr, early_stopping, terminate_on_nan]
# get train&val dataset
dataset = get_dataset(annotation_file)
if args.val_annotation_file:
val_dataset = get_dataset(args.val_annotation_file)
num_train = len(dataset)
num_val = len(val_dataset)
dataset.extend(val_dataset)
else:
val_split = args.val_split
num_val = int(len(dataset)*val_split)
num_train = len(dataset) - num_val
# get different model type & train&val data generator
if num_anchors == 9:
# YOLOv3 use 9 anchors
get_train_model = get_yolo3_train_model
data_generator = yolo3_data_generator_wrapper
tiny_version = False
elif num_anchors == 6:
# Tiny YOLOv3 use 6 anchors
get_train_model = get_yolo3_train_model
data_generator = yolo3_data_generator_wrapper
tiny_version = True
elif num_anchors == 5:
# YOLOv2 use 5 anchors
get_train_model = get_yolo2_train_model
data_generator = yolo2_data_generator_wrapper
tiny_version = False
else:
raise ValueError('Unsupported anchors number')
# prepare online evaluation callback
if args.eval_online:
eval_callback = EvalCallBack(args.model_type, dataset[num_train:], anchors, class_names, args.model_image_size, args.model_pruning, log_dir, eval_epoch_interval=args.eval_epoch_interval, save_eval_checkpoint=args.save_eval_checkpoint)
callbacks.append(eval_callback)
# prepare train/val data shuffle callback
if args.data_shuffle:
shuffle_callback = DatasetShuffleCallBack(dataset)
callbacks.append(shuffle_callback)
# prepare model pruning config
pruning_end_step = np.ceil(1.0 * num_train / args.batch_size).astype(np.int32) * args.total_epoch
if args.model_pruning:
pruning_callbacks = [sparsity.UpdatePruningStep(), sparsity.PruningSummaries(log_dir=log_dir, profile_batch=0)]
callbacks = callbacks + pruning_callbacks
# prepare optimizer
optimizer = get_optimizer(args.optimizer, args.learning_rate, decay_type=None)
# get train model
model = get_train_model(args.model_type, anchors, num_classes, weights_path=args.weights_path, freeze_level=freeze_level, optimizer=optimizer, label_smoothing=args.label_smoothing, model_pruning=args.model_pruning, pruning_end_step=pruning_end_step)
# support multi-gpu training
template_model = None
if args.gpu_num >= 2:
# keep the template model for saving result
template_model = model
model = multi_gpu_model(model, gpus=args.gpu_num)
# recompile multi gpu model
model.compile(optimizer=optimizer, loss={'yolo_loss': lambda y_true, y_pred: y_pred})
model.summary()
# Transfer training some epochs with frozen layers first if needed, to get a stable loss.
input_shape = args.model_image_size
assert (input_shape[0]%32 == 0 and input_shape[1]%32 == 0), 'Multiples of 32 required'
initial_epoch = args.init_epoch
epochs = initial_epoch + args.transfer_epoch
print("Transfer training stage")
print('Train on {} samples, val on {} samples, with batch size {}, input_shape {}.'.format(num_train, num_val, args.batch_size, input_shape))
model.fit_generator(data_generator(dataset[:num_train], args.batch_size, input_shape, anchors, num_classes),
steps_per_epoch=max(1, num_train//args.batch_size),
validation_data=data_generator(dataset[num_train:], args.batch_size, input_shape, anchors, num_classes),
validation_steps=max(1, num_val//args.batch_size),
epochs=epochs,
initial_epoch=initial_epoch,
workers=1,
use_multiprocessing=False,
max_queue_size=10,
callbacks=callbacks)
# Wait 2 seconds for next stage
time.sleep(2)
if args.decay_type:
# rebuild optimizer to apply learning rate decay, only after
# unfreeze all layers
callbacks.remove(reduce_lr)
steps_per_epoch = max(1, num_train//args.batch_size)
decay_steps = steps_per_epoch * (args.total_epoch - args.init_epoch - args.transfer_epoch)
optimizer = get_optimizer(args.optimizer, args.learning_rate, decay_type=args.decay_type, decay_steps=decay_steps)
# Unfreeze the whole network for further tuning
# NOTE: more GPU memory is required after unfreezing the body
print("Unfreeze and continue training, to fine-tune.")
for i in range(len(model.layers)):
model.layers[i].trainable = True
model.compile(optimizer=optimizer, loss={'yolo_loss': lambda y_true, y_pred: y_pred}) # recompile to apply the change
if args.multiscale:
rescale_interval = args.rescale_interval
else:
rescale_interval = -1 #Doesn't rescale
print('Train on {} samples, val on {} samples, with batch size {}, input_shape {}.'.format(num_train, num_val, args.batch_size, input_shape))
model.fit_generator(data_generator(dataset[:num_train], args.batch_size, input_shape, anchors, num_classes, rescale_interval),
steps_per_epoch=max(1, num_train//args.batch_size),
validation_data=data_generator(dataset[num_train:], args.batch_size, input_shape, anchors, num_classes),
validation_steps=max(1, num_val//args.batch_size),
epochs=args.total_epoch,
initial_epoch=epochs,
workers=1,
use_multiprocessing=False,
max_queue_size=10,
callbacks=callbacks)
# Finally store model
if args.model_pruning:
if template_model is not None:
template_model = sparsity.strip_pruning(template_model)
else:
model = sparsity.strip_pruning(model)
if template_model is not None:
template_model.save(log_dir + 'trained_final.h5')
else:
model.save(log_dir + 'trained_final.h5')
def on_epoch_end(self, epoch, logs=None):
fmt = checkpoint_models_path + 'final.%02d-%.4f.hdf5'
self.model_to_save.save(fmt % (epoch, logs['val_loss']))
# Load our model, added support for Multi-GPUs
num_gpu = len(get_available_gpus())
if num_gpu >= 2:
with tf.device("/cpu:0"):
model = build_encoder_decoder()
model = build_refinement(model)
# if pretrained_path is not None:
# model.load_weights(pretrained_path)
final = multi_gpu_model(model, gpus=num_gpu)
# rewrite the callback: saving through the original model and not the multi-gpu model.
model_checkpoint = MyCbk(model)
else:
model = build_encoder_decoder()
final = build_refinement(model)
# if pretrained_path is not None:
# final.load_weights(pretrained_path)
if len(os.listdir(checkpoint_dir)) > 0:
latest = tf.train.latest_checkpoint(checkpoint_dir)
final.load_weights(latest)
initial_epoch = get_initial_epoch(latest)
else:
initial_epoch = 0
final.compile(optimizer='nadam', loss=overall_loss)
print(train_data.class_indices)
decay_lr = ReduceLROnPlateau(factor=0.001, patience=3, min_lr=0.000001)
callbacks = [decay_lr]
pretrained_model = ResNet50(include_top=False,
weights='imagenet',
input_shape=(50, 50, 3))
for layer in pretrained_model.layers:
layer.trainable = False
x = pretrained_model.output
x = Flatten()(x)
x = Dense(1, activation='sigmoid')(x)
model = Model(pretrained_model.input, x)
if gpu_count > 1:
model = multi_gpu_model(model, gpus=gpu_count)
model.compile(optimizer='adam',
metrics=['accuracy'],
loss='binary_crossentropy')
history = model.fit(x=train_data,
epochs=epochs,
validation_data=validation_data,
callbacks=callbacks,
verbose=2)
score = model.evaluate(x=validation_data, verbose=0)
print('Validation loss :', score[0])
print('Validation accuracy:', score[1])
model = Model(inputs=input_tensor, outputs=x)
return model
if __name__ == '__main__':
with tf.device("/cpu:0"):
encoder_decoder = build_encoder_decoder()
print(encoder_decoder.summary())
plot_model(encoder_decoder,
to_file='encoder_decoder.svg',
show_layer_names=True,
show_shapes=True)
with tf.device("/cpu:0"):
refinement = build_refinement(encoder_decoder)
print(refinement.summary())
plot_model(refinement,
to_file='refinement.svg',
show_layer_names=True,
show_shapes=True)
parallel_model = multi_gpu_model(refinement, gpus=None)
print(parallel_model.summary())
plot_model(parallel_model,
to_file='parallel_model.svg',
show_layer_names=True,
show_shapes=True)
K.clear_session()
with open(__file__, 'r') as training_script: training_script_content = training_script.read()
training_script_content = '#' + str(sys.argv) + '\n' + training_script_content
with open(runPath+'/'+__file__, 'w') as training_script: training_script.write(training_script_content)
# Generate model plot
plot_model(model, to_file=runPath+'/model_plot.svg', show_shapes=True, show_layer_names=True)
# Save model summary to file
from contextlib import redirect_stdout
with open(runPath+'/model_summary.txt', 'w') as f:
with redirect_stdout(f): model.summary()
'''
# Multi-gpu setup:
basemodel = model
if args.gpus > 1: model = multi_gpu_model(model, gpus=args.gpus)
# Optimizer
optimizer = Adam(lr=args.lr, amsgrad=True)
# Compile the model
print(
'\n\n\n', 'Compiling model..', runID, '\n\n\tGPU ' +
(str(args.gpus) + ' gpus' if args.gpus > 1 else args.gpuids) +
'\t\tBatch size [ ' + str(args.bs) + ' ] ' + ' \n\n')
model.compile(loss=depth_loss_function, optimizer=optimizer)
print('Ready for training!\n')
# Callbacks
callbacks = []
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--logdir",
dest="log_dir",
type=str,
default="./logs/untitled-{}".format(
datetime.now().strftime("%y%m%d-%H%M%S")))
parser.add_argument("--num_gpus",
default=len(get_available_gpus()),
type=int)
parser.add_argument("--multi-gpu",
default=False,
action='store_true',
dest='multi_gpu')
# Hyperparameters
parser.add_argument("--epoch", dest="num_epochs", default=100, type=int)
parser.add_argument("--batch_size", default=128, type=int)
parser.add_argument("--valid_batch_size", default=1024, type=int)
parser.add_argument("--lr", default=0.001, type=float)
parser.add_argument(
"--clipnorm",
default=-1,
type=float,
help="if it is greater than 0, then graidient clipping is activated")
parser.add_argument("--clipvalue", default=-1, type=float)
parser.add_argument("--use-class-weight",
dest="use_class_weight",
default=False,
action="store_true")
# Frequencies
parser.add_argument("--valid_freq", type=int, default=32)
parser.add_argument("--save_freq", type=int, default=32)
parser.add_argument("-v", "--verbose", action="store_true")
# Project parameters
parser.add_argument("--min-pt", dest="min_pt", default=100, type=int)
args = parser.parse_args()
###################
#
###################
log_dir = Directory(path=args.log_dir)
log_dir.mkdir("script")
log_dir.mkdir("model_checkpoint")
log_dir.mkdir("learning_curve")
log_dir.mkdir("roc_curve")
log_dir.mkdir("model_response")
backup_scripts(log_dir.script.path)
config = Config(log_dir.path, "w")
config.append(args)
config["hostname"] = os.environ["HOSTNAME"]
########################################
# Load training and validation datasets
########################################
dset = get_dataset_paths(args.min_pt)
config.append(dset)
config["seq_maxlen"] = {"x": 30}
train_iter = get_data_iter(path=dset["training"],
batch_size=args.batch_size,
seq_maxlen=config.seq_maxlen,
fit_generator_mode=True)
valid_iter = get_data_iter(path=dset["validation"],
batch_size=args.valid_batch_size,
seq_maxlen=config.seq_maxlen,
fit_generator_mode=True)
test_iter = get_data_iter(path=dset["test"],
batch_size=args.valid_batch_size,
seq_maxlen=config.seq_maxlen,
fit_generator_mode=False)
if args.use_class_weight:
class_weight = get_class_weight(train_iter)
config["class_weight"] = list(class_weight)
else:
class_weight = None
#################################
# Build & Compile a model.
#################################
x_shape = train_iter.get_shape("x", batch_shape=False)
model = build_a_model(x_shape=x_shape)
config["model"] = model.get_config()
if args.multi_gpu:
model = multi_gpu_model(_model, gpus=args.num_gpus)
model_plot_path = log_dir.concat("model.png")
plot_model(model, to_file=model_plot_path, show_shapes=True)
loss = 'categorical_crossentropy'
# TODO capsulisation
optimizer_kwargs = {}
if args.clipnorm > 0:
optimzer_kwargs["clipnorm"] = args.clipnorm
if args.clipvalue > 0:
optimzer_kwargs["clipvalue"] = args.clipvalue
optimizer = optimizers.Adam(lr=args.lr, **optimizer_kwargs)
metric_list = ["accuracy", roc_auc]
model.compile(loss=loss, optimizer=optimizer, metrics=metric_list)
config["loss"] = loss
config["optimizer"] = "Adam"
config["optimizer_config"] = optimizer.get_config()
###########################################################################
# Callbacks
###########################################################################
ckpt_format_str = "weights_epoch-{epoch:02d}_loss-{val_loss:.4f}_acc-{val_acc:.4f}_auc-{val_roc_auc:.4f}.hdf5"
ckpt_path = log_dir.model_checkpoint.concat(ckpt_format_str)
csv_log_path = log_dir.concat("log_file.csv")
learning_curve = LearningCurve(directory=log_dir.learning_curve.path)
learning_curve.book(x="step", y="roc_auc", best="max")
learning_curve.book(x="step", y="acc", best="max")
learning_curve.book(x="step", y="loss", best="min")
callback_list = [
callbacks.ModelCheckpoint(filepath=ckpt_path),
callbacks.EarlyStopping(monitor="val_loss", patience=5),
callbacks.ReduceLROnPlateau(),
callbacks.CSVLogger(csv_log_path),
learning_curve,
]
############################################################################
# Training
############################################################################
model.fit_generator(train_iter,
steps_per_epoch=len(train_iter),
epochs=50,
validation_data=valid_iter,
validation_steps=len(valid_iter),
callbacks=callback_list,
shuffle=True,
class_weight=class_weight)
print("Training is over! :D")
del model
###########################################
# Evaluation
############################################
train_iter.fit_generator_mode = False
train_iter.cycle = False
good_ckpt = find_good_checkpoint(log_dir.model_checkpoint.path,
which={
"max": ["auc", "acc"],
"min": ["loss"]
})
for idx, each in enumerate(good_ckpt, 1):
print("[{}/{}] {}".format(idx, len(good_ckpt), each))
K.clear_session()
evaluate(custom_objects={"roc_auc": roc_auc},
checkpoint_path=each,
train_iter=train_iter,
test_iter=test_iter,
log_dir=log_dir)
config.save()
def entry_func(args=None):
# Project base path
args = vars(get_argparser().parse_args(args))
basedir = os.path.abspath(args["project_dir"])
overwrite = args["overwrite"]
continue_training = args["continue_training"]
eval_prob = args["eval_prob"]
await_PID = args["wait_for"]
dice_weight = args["dice_weight"]
print("Fitting fusion model for project-folder: %s" % basedir)
# Minimum images in validation set before also using training images
min_val_images = 15
# Fusion model training params
epochs = args['epochs']
fm_batch_size = args["batch_size"]
# Early stopping params
early_stopping = args["early_stopping"]
# Wait for PID?
if await_PID:
from MultiPlanarUNet.utils import await_PIDs
await_PIDs(await_PID)
# Fetch GPU(s)
num_GPUs = args["num_GPUs"]
force_gpu = args["force_GPU"]
# Wait for free GPU
if not force_gpu:
await_and_set_free_gpu(N=num_GPUs, sleep_seconds=120)
num_GPUs = 1
else:
set_gpu(force_gpu)
num_GPUs = len(force_gpu.split(","))
# Get logger
logger = Logger(base_path=basedir,
active_file="train_fusion",
overwrite_existing=overwrite)
# Get YAML hyperparameters
hparams = YAMLHParams(os.path.join(basedir, "train_hparams.yaml"))
# Get some key settings
n_classes = hparams["build"]["n_classes"]
if hparams["build"]["out_activation"] == "linear":
# Trained with logit targets?
hparams["build"][
"out_activation"] = "softmax" if n_classes > 1 else "sigmoid"
# Get views
views = np.load("%s/views.npz" % basedir)["arr_0"]
del hparams["fit"]["views"]
# Get weights and set fusion (output) path
weights = get_best_model("%s/model" % basedir)
weights_name = os.path.splitext(os.path.split(weights)[-1])[0]
fusion_weights = "%s/model/fusion_weights/" \
"%s_fusion_weights.h5" % (basedir, weights_name)
create_folders(os.path.split(fusion_weights)[0])
# Log a few things
log(logger, hparams, views, weights, fusion_weights)
# Check if exists already...
if not overwrite and os.path.exists(fusion_weights):
from sys import exit
print("\n[*] A fusion weights file already exists at '%s'."
"\n Use the --overwrite flag to overwrite." % fusion_weights)
exit(0)
# Load validation data
images = ImagePairLoader(**hparams["val_data"], logger=logger)
is_validation = {m.id: True for m in images}
# Define random sets of images to train on simul. (cant be all due
# to memory constraints)
image_IDs = [m.id for m in images]
if len(images) < min_val_images:
# Pick N random training images
diff = min_val_images - len(images)
logger("Adding %i training images to set" % diff)
# Load the training data and pick diff images
train = ImagePairLoader(**hparams["train_data"], logger=logger)
indx = np.random.choice(np.arange(len(train)),
diff,
replace=diff > len(train))
# Add the images to the image set set
train_add = [train[i] for i in indx]
for m in train_add:
is_validation[m.id] = False
image_IDs.append(m.id)
images.add_images(train_add)
# Append to length % sub_size == 0
sub_size = args["images_per_round"]
rest = int(sub_size * np.ceil(len(image_IDs) / sub_size)) - len(image_IDs)
if rest:
image_IDs += list(np.random.choice(image_IDs, rest, replace=False))
# Shuffle and split
random.shuffle(image_IDs)
sets = [
set(s) for s in np.array_split(image_IDs,
len(image_IDs) / sub_size)
]
assert (contains_all_images(sets, image_IDs))
# Define fusion model (named 'org' to store reference to orgiginal model if
# multi gpu model is created below)
fusion_model_org = FusionModel(n_inputs=len(views),
n_classes=n_classes,
weight=dice_weight,
logger=logger,
verbose=False)
if continue_training:
fusion_model_org.load_weights(fusion_weights)
print("\n[OBS] CONTINUED TRAINING FROM:\n", fusion_weights)
# Define model
unet = init_model(hparams["build"], logger)
print("\n[*] Loading weights: %s\n" % weights)
unet.load_weights(weights, by_name=True)
if num_GPUs > 1:
from tensorflow.keras.utils import multi_gpu_model
# Set for predictor model
n_classes = n_classes
unet = multi_gpu_model(unet, gpus=num_GPUs)
unet.n_classes = n_classes
# Set for fusion model
fusion_model = multi_gpu_model(fusion_model_org, gpus=num_GPUs)
else:
fusion_model = fusion_model_org
# Compile the model
logger("Compiling...")
metrics = [
"sparse_categorical_accuracy", sparse_fg_precision, sparse_fg_recall
]
fusion_model.compile(optimizer=Adam(lr=1e-3),
loss=fusion_model_org.loss,
metrics=metrics)
fusion_model_org._log()
try:
_run_fusion_training(sets, logger, hparams, min_val_images,
is_validation, views, n_classes, unet,
fusion_model_org, fusion_model, early_stopping,
fm_batch_size, epochs, eval_prob, fusion_weights)
except KeyboardInterrupt:
pass
finally:
if not os.path.exists(os.path.split(fusion_weights)[0]):
os.mkdir(os.path.split(fusion_weights)[0])
# Save fusion model weights
# OBS: Must be original model if multi-gpu is performed!
fusion_model_org.save_weights(fusion_weights)
def train(opt):
K.clear_session()
video_input = Input(shape=(None, None, None, 3))
model = nets.network[opt.network](video_input, num_classes=opt.num_classes)
print("Create {} model with {} classes".format(opt.network,
opt.num_classes))
if opt.pretrained_weights is not None:
model.load_weights(opt.pretrained_weights)
print("Loading weights from {}".format(opt.pretrained_weights))
optimizer = get_optimizer(opt)
train_data_generator = DataGenerator(opt.data_name, opt.video_path,
opt.train_list, opt.name_path,
'train', opt.batch_size,
opt.num_classes, True, opt.short_side,
opt.crop_size, opt.clip_len,
opt.n_samples_for_each_video)
val_data_generator = DataGenerator(opt.data_name, opt.video_path,
opt.val_list, opt.name_path, 'val',
opt.batch_size, opt.num_classes, False,
opt.short_side, opt.crop_size,
opt.clip_len,
opt.n_samples_for_each_video)
predict_data_generator = DataGenerator(opt.data_name,
opt.test_videos_path,
opt.test_list_path,
opt.name_path,
'val',
1,
opt.num_classes,
False,
opt.short_side,
opt.crop_size,
opt.clip_len,
opt.n_samples_for_each_video,
to_fit=False)
callbacks = create_callbacks(opt, max(1, train_data_generator.__len__()),
model)
if len(opt.gpus) > 1:
print('Using multi gpus')
parallel_model = multi_gpu_model(model, gpus=len(opt.gpus))
parallel_model.compile(optimizer=optimizer,
loss=categorical_crossentropy,
metrics=['accuracy'])
parallel_model.fit_generator(
train_data_generator,
steps_per_epoch=max(1, train_data_generator.__len__()),
epochs=opt.epochs,
validation_data=val_data_generator,
validation_steps=max(1, val_data_generator.__len__()),
workers=opt.workers,
callbacks=callbacks)
else:
print("GPU <1 run")
model.compile(optimizer=optimizer,
loss=categorical_crossentropy,
metrics=['accuracy'])
print("compile done")
print("mbashat : Val_steps, steps_per_epoch, Val_dat",
max(1, val_data_generator.__len__()),
max(1, train_data_generator.__len__()), val_data_generator)
#history = model.fit_generator(train_data_generator, steps_per_epoch=max(1, train_data_generator.__len__()),
#epochs=opt.epochs, validation_data=val_data_generator, validation_steps=max(1, val_data_generator.__len__()),
#workers=opt.workers, callbacks=callbacks)
history = model.fit_generator(
train_data_generator,
steps_per_epoch=max(1, train_data_generator.__len__()),
epochs=opt.epochs,
validation_data=val_data_generator,
validation_steps=max(1, val_data_generator.__len__()),
workers=opt.workers)
print("model fit done")
print("mbashat: saving model")
model.save('SlowFast_refrigerator.h5')
print("mbashat: saving weights at :",
os.path.join(os.path.join(opt.root_path, opt.result_path)))
model.save_weights(
os.path.join(os.path.join(opt.root_path, opt.result_path),
'trained_weights_final.h5'))
print("mbashat: predict on val data")
model_predicted = model.predict(predict_data_generator)
import numpy as np
print(np.argmax(model_predicted, axis=1))
print("mbashat: saving weights to variable")
#for layer in model.layers:
#weights = layer.get_weights()
#print(weights)
#for video_batch, labels_batch in train_data_generator:
#print('video batch shape, label shape:', video_batch.shape, labels_batch)
import matplotlib.pyplot as plt
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(1, len(acc) + 1)
plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Validation acc')
plt.title('Training and validation accuracy')
plt.legend()
plt.figure()
plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()
plt.show()
print("end of code")
def graph_rise_compile(args, shape):
# optizem
sgd = tf.keras.optimizers.SGD(lr=args.lr, decay=0.00004,
momentum=0.9) #, clipvalue=0.5
print('optimizer_initialize_finish')
#build_model
if args.gpu_num == 1:
sgd = tf.keras.optimizers.SGD(lr=args.lr,
clipvalue=0.5,
decay=0.00004,
momentum=0.9) # , clipvalue=0.5
embedding_ly = embedding_layer([7, 7, 2048], args.embed_dim)
output_ly = output_layer1(args.embed_dim, shape) # [7, 7, 2048]
ResNet = resnet.ResNet101(include_top=False,
weights=None,
input_shape=(224, 224, 3)) # ResNet
if args.pretrain:
ResNet.load_weights(
'./save/resnet101_weights_tf_dim_ordering_tf_kernels_notop.h5')
body_model = build_model(ResNet, embedding_ly, output_ly)
if args.resume:
body_model.load_weights(filepath=args.save_path)
parallel_model = body_model
print('build_model_finish')
parallel_model.compile(
optimizer=sgd,
loss={
'output_layer': 'categorical_crossentropy',
'tf_op_layer_Sub': graph_loss
},
loss_weights={
'output_layer': 1,
'tf_op_layer_Sub': args.alpha
},
metrics=['accuracy']) # predict_loss'categorical_crossentropy'
print('compile_finish')
else:
strategy = tf.distribute.MirroredStrategy(
devices=["/gpu:0", "/gpu:1",
"/gpu:3"]) #, "/gpu:1", "/gpu:2", "/gpu:3
with strategy.scope():
embedding_ly = embedding_layer([7, 7, 2048], args.embed_dim)
output_ly = output_layer1(args.embed_dim, shape) # [7, 7, 2048]
ResNet = resnet.ResNet101(include_top=False,
weights=None,
input_shape=(224, 224, 3)) # ResNet
#load_pretrain_model
if args.pretrain:
ResNet.load_weights(
'./save/resnet101_weights_tf_dim_ordering_tf_kernels_notop.h5'
)
body_model = build_model(ResNet, embedding_ly, output_ly)
# load_check_point
if args.resume:
body_model.load_weights(filepath=args.save_path)
parallel_model = multi_gpu_model(body_model, gpus=3)
parallel_model.compile(
optimizer=sgd,
loss={
'output_layer': 'categorical_crossentropy',
'tf_op_layer_Sub': graph_loss
},
loss_weights={
'output_layer': 1,
'tf_op_layer_Sub': args.alpha
},
metrics=['accuracy']) #predict_loss'categorical_crossentropy'
return parallel_model
def train(opt):
K.clear_session()
video_input = Input(shape=(None, None, None, 3))
model = nets.network[opt.network](video_input, num_classes=opt.num_classes)
print("Create {} model with {} classes".format(opt.network,
opt.num_classes))
if opt.pretrained_weights is not None:
model.load_weights(opt.pretrained_weights)
print("Loading weights from {}".format(opt.pretrained_weights))
optimizer = get_optimizer(opt)
train_data_generator = DataGenerator(opt.data_name, opt.video_path,
opt.train_list, opt.name_path,
'train', opt.batch_size,
opt.num_classes, True, opt.short_side,
opt.crop_size, opt.clip_len,
opt.n_samples_for_each_video)
val_data_generator = DataGenerator(opt.data_name, opt.video_path,
opt.val_list, opt.name_path, 'val',
opt.batch_size, opt.num_classes, False,
opt.short_side, opt.crop_size,
opt.clip_len,
opt.n_samples_for_each_video)
#predict_data_generator = DataGenerator(opt.data_name, opt.test_videos_path, opt.test_list_path, opt.name_path,
# 'val', 1, opt.num_classes, False, opt.short_side,
# opt.crop_size, opt.clip_len, opt.n_samples_for_each_video, to_fit=False)
callbacks = create_callbacks(opt, max(1, train_data_generator.__len__()),
model)
if len(opt.gpus) > 1:
print('Using multi gpus')
parallel_model = multi_gpu_model(model, gpus=len(opt.gpus))
parallel_model.compile(optimizer=optimizer,
loss=categorical_crossentropy,
metrics=['accuracy'])
parallel_model.fit_generator(
train_data_generator,
steps_per_epoch=max(1, train_data_generator.__len__()),
epochs=opt.epochs,
validation_data=val_data_generator,
validation_steps=max(1, val_data_generator.__len__()),
workers=opt.workers,
callbacks=callbacks)
else:
print("GPU <1 run")
model.compile(optimizer=optimizer,
loss=categorical_crossentropy,
metrics=['accuracy'])
print("compile done")
print("mbashat : Val_steps, steps_per_epoch, Val_dat",
max(1, val_data_generator.__len__()),
max(1, train_data_generator.__len__()), val_data_generator)
global history_mbt
#history_mbt = model.fit_generator(train_data_generator, steps_per_epoch=max(1, train_data_generator.__len__()),
#epochs=opt.epochs, validation_data=val_data_generator, validation_steps=max(1, val_data_generator.__len__()),
#workers=opt.workers, callbacks=callbacks)
history_mbt = model.fit_generator(
train_data_generator,
steps_per_epoch=max(1, train_data_generator.__len__()),
epochs=opt.epochs,
validation_data=val_data_generator,
validation_steps=max(1, val_data_generator.__len__()),
workers=opt.workers)
#model.summary()
from tensorflow.keras.utils import plot_model
plot_model(model, to_file='model.png', show_shapes=True)
print("model fit done")
print("mbashat: saving model")
model.save('SlowFast_refrigerator_0204_3.h5')
#print("mbashat: saving weights at :", os.path.join(os.path.join(opt.root_path, opt.result_path) ))
#model.save_weights(os.path.join(os.path.join(opt.root_path, opt.result_path), 'trained_weights_final_200.h5'))
#print("mbashat: predict on val data")
#model_predicted = model.predict(predict_data_generator)
#import numpy as np
#print(np.argmax(model_predicted, axis=1))
#print("mbashat: saving weights to variable")
#for layer in model.layers:
#weights = layer.get_weights()
#print(weights)
#for video_batch, labels_batch in train_data_generator:
#print('video batch shape, label shape:', video_batch.shape, labels_batch)
print('printking Keys in history')
for key in history_mbt.history:
print(key)
#%matplotlib inline
acc = history_mbt.history['acc']
val_acc = history_mbt.history['val_acc']
loss = history_mbt.history['loss']
val_loss = history_mbt.history['val_loss']
epochs = range(1, len(acc) + 1)
plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Validation acc')
plt.title('Training and validation accuracy')
plt.legend()
#plt.figure()
plt.show()
plt.savefig('accuracy_0204_3.png')
plt.plot(epochs, loss, 'ro', label='Training loss')
plt.plot(epochs, val_loss, 'r', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()
plt.show()
plt.savefig('loss_0204_3.png')
np.savetxt('loss_acc_0204_3.txt', history_mbt)
with open('loss_acc_0204_3.csv', 'w') as f:
for key in history_mbt.history():
f.write("%s,%s\n" % (key, history_mbt[key]))
f.close()
print("end of code")
output_model_file = os.path.join(tmp_logdir, 'trained_model')
# copy the input config file to the logdir
shutil.copyfile(args.cfg_file, os.path.join(tmp_logdir, 'config.json'))
#-----------------------------------------------------------------------------------------------
# set up the model to train
n_gpus = len(
[x for x in device_lib.list_local_devices() if x.device_type == 'GPU'])
if n_gpus >= 2:
# define not parallized model on CPU
with tf.device('/cpu:0'):
model = apetnet(**model_kwargs)
parallel_model = multi_gpu_model(model, gpus=n_gpus, cpu_merge=False)
else:
parallel_model = apetnet(**model_kwargs)
if loss == 'ssim':
loss = ssim_3d_loss
elif loss == 'mix_ssim_mae':
loss = mix_ssim_3d_mae_loss
metrics = [ssim_3d_loss, mix_ssim_3d_mae_loss, 'mse', 'mae']
parallel_model.compile(optimizer=Adam(lr=learning_rate),
loss=loss,
metrics=metrics)
#----------------------------------------------------------------------------------------------
metrics=METRICS)
model_fit = model.fit(
X_train,
y_train,
validation_split=VALIDATION_SPLIT,
epochs=epochs,
shuffle=True,
batch_size=BATCH_SIZE,
callbacks=[checkpointer, hist, tensorboard],
verbose=1)
model.save(MODEL_PATH)
print("SUCCESSFULLY SAVED MODEL --- ITERATION {}".format(i))
# if using multiple gpu to train model
elif NUM_GPU >= 2:
parallel_model = multi_gpu_model(model,
gpus=NUM_GPU,
cpu_merge=True)
parallel_model.compile(loss='mean_squared_error',
optimizer=adam_optimizer,
metrics=['accuracy'])
parallel_model.fit(X_train,
y_train,
validation_split=0.30,
epochs=epochs,
batch_size=batch_size,
callbacks=[checkpointer, hist],
verbose=1)
parallel_model.save('models/model_128_9.h5')
print("Save model successfully")
except KeyboardInterrupt:
print("Saving Model...")
def _main(args):
global lr_base, total_epochs
lr_base = args.learning_rate
total_epochs = args.total_epoch
annotation_file = args.annotation_file
log_dir = 'logs/000/'
classes_path = args.classes_path
class_names = get_classes(classes_path)
num_classes = len(class_names)
if args.tiny_version:
anchors_path = 'configs/tiny_yolo_anchors.txt'
else:
anchors_path = 'configs/yolo_anchors.txt'
anchors = get_anchors(anchors_path)
print("\nanchors = ", anchors)
print("\nnum_classes = ", num_classes)
# get freeze level according to CLI option
if args.weights_path:
freeze_level = 0
else:
freeze_level = 1
if args.freeze_level is not None:
freeze_level = args.freeze_level
print("\n\nFREEZE LEVEL = ", freeze_level)
# callbacks for training process
logging = TensorBoard(log_dir=log_dir,
histogram_freq=0,
write_graph=False,
write_grads=False,
write_images=False,
update_freq='batch')
checkpoint = ModelCheckpoint(
log_dir + 'ep{epoch:03d}-loss{loss:.3f}-val_loss{val_loss:.3f}.h5',
monitor='val_loss',
verbose=1,
save_weights_only=False,
save_best_only=True,
period=5)
reduce_lr = ReduceLROnPlateau(monitor='val_loss',
factor=0.5,
patience=5,
verbose=1,
cooldown=0,
min_lr=1e-10)
lr_scheduler = LearningRateScheduler(learning_rate_scheduler)
early_stopping = EarlyStopping(monitor='val_loss',
min_delta=0,
patience=30,
verbose=1)
terminate_on_nan = TerminateOnNaN()
callbacks = [
logging, checkpoint, reduce_lr, early_stopping, terminate_on_nan
]
# get train&val dataset
dataset = get_dataset(annotation_file)
if args.val_annotation_file:
val_dataset = get_dataset(args.val_annotation_file)
num_train = len(dataset)
num_val = len(val_dataset)
dataset.extend(val_dataset)
else:
val_split = args.val_split
num_val = int(len(dataset) * val_split)
num_train = len(dataset) - num_val
# prepare model pruning config
pruning_end_step = np.ceil(1.0 * num_train / args.batch_size).astype(
np.int32) * args.total_epoch
if args.model_pruning:
pruning_callbacks = [
sparsity.UpdatePruningStep(),
sparsity.PruningSummaries(log_dir=log_dir, profile_batch=0)
]
callbacks = callbacks + pruning_callbacks
# prepare optimizer
optimizer = get_optimizer(args.optimizer, args.learning_rate)
# get train model
model = get_yolo3_train_model(args.model_type,
anchors,
num_classes,
weights_path=args.weights_path,
freeze_level=freeze_level,
optimizer=optimizer,
label_smoothing=args.label_smoothing,
model_pruning=args.model_pruning,
pruning_end_step=pruning_end_step)
# support multi-gpu training
if args.gpu_num >= 2:
model = multi_gpu_model(model, gpus=args.gpu_num)
model.summary()
# Train some initial epochs with frozen layers first if needed, to get a stable loss.
input_shape = args.model_image_size
assert (input_shape[0] % 32 == 0
and input_shape[1] % 32 == 0), 'Multiples of 32 required'
batch_size = args.batch_size
initial_epoch = 0
epochs = args.init_epoch
print("Initial training stage")
print(
'Train on {} samples, val on {} samples, with batch size {}, input_shape {}.'
.format(num_train, num_val, batch_size, input_shape))
model.fit_generator(data_generator_wrapper(dataset[:num_train], batch_size,
input_shape, anchors,
num_classes),
steps_per_epoch=max(1, num_train // batch_size),
validation_data=data_generator_wrapper(
dataset[num_train:], batch_size, input_shape,
anchors, num_classes),
validation_steps=max(1, num_val // batch_size),
epochs=epochs,
initial_epoch=initial_epoch,
callbacks=callbacks)
# Apply Cosine learning rate decay only after
# unfreeze all layers
if args.cosine_decay_learning_rate:
callbacks.remove(reduce_lr)
callbacks.append(lr_scheduler)
# Unfreeze the whole network for further training
# NOTE: more GPU memory is required after unfreezing the body
print("Unfreeze and continue training, to fine-tune.")
for i in range(len(model.layers)):
model.layers[i].trainable = True
model.compile(optimizer=optimizer,
loss={
'yolo_loss': lambda y_true, y_pred: y_pred
}) # recompile to apply the change
if args.multiscale:
# prepare multiscale config
input_shape_list = get_multiscale_list(args.model_type,
args.tiny_version)
interval = args.rescale_interval
# Do multi-scale training on different input shape
# change every "rescale_interval" epochs
for epoch_step in range(epochs + interval, args.total_epoch, interval):
# shuffle train/val dataset for cross-validation
if args.data_shuffle:
np.random.shuffle(dataset)
initial_epoch = epochs
epochs = epoch_step
# rescale input only from 2nd round, to make sure unfreeze stable
if initial_epoch != args.init_epoch:
input_shape = input_shape_list[random.randint(
0,
len(input_shape_list) - 1)]
print(
'Train on {} samples, val on {} samples, with batch size {}, input_shape {}.'
.format(num_train, num_val, batch_size, input_shape))
model.fit_generator(
data_generator_wrapper(dataset[:num_train], batch_size,
input_shape, anchors, num_classes),
steps_per_epoch=max(1, num_train // batch_size),
validation_data=data_generator_wrapper(dataset[num_train:],
batch_size, input_shape,
anchors, num_classes),
validation_steps=max(1, num_val // batch_size),
epochs=epochs,
initial_epoch=initial_epoch,
callbacks=callbacks)
else:
# Do single-scale training
print(
'Train on {} samples, val on {} samples, with batch size {}, input_shape {}.'
.format(num_train, num_val, batch_size, input_shape))
model.fit_generator(data_generator_wrapper(dataset[:num_train],
batch_size, input_shape,
anchors, num_classes),
steps_per_epoch=max(1, num_train // batch_size),
validation_data=data_generator_wrapper(
dataset[num_train:], batch_size, input_shape,
anchors, num_classes),
validation_steps=max(1, num_val // batch_size),
epochs=args.total_epoch,
initial_epoch=epochs,
callbacks=callbacks)
# Finally store model
if args.model_pruning:
model = sparsity.strip_pruning(model)
model.save(log_dir + 'trained_final.h5')
def get_model(input_shape,
weights_dir,
resume,
bayesian,
vnet,
prior_std,
kernel_size,
activation,
padding,
alpha,
num_gpus,
scale_factor=1,
weights_path=None):
"""Loads or creates model.
If a weights path is specified, loads from that path. Otherwise, loads
the most recently modified model.
"""
os.makedirs(weights_dir + "/bayesian", exist_ok=True)
os.makedirs(weights_dir + "/dropout", exist_ok=True)
# Sets variables for bayesian model.
if bayesian:
checkpoint_path = (weights_dir + "/bayesian/bayesian-{epoch:02d}"
"-{val_acc:.3f}-{val_loss:.0f}.h5")
if weights_path:
latest_weights_path = weights_path
else:
latest_weights_path = get_latest_file(weights_dir + "/bayesian")
net = bayesian_vnet if vnet else bayesian_unet
# Sets variables for dropout model.
else:
checkpoint_path = (weights_dir + "/dropout/dropout-{epoch:02d}"
"-{val_acc:.3f}-{val_loss:.2f}.h5")
if weights_path:
latest_weights_path = weights_path
else:
latest_weights_path = get_latest_file(weights_dir + "/dropout")
net = dropout_vnet if vnet else dropout_unet
# Loads or creates model.
if latest_weights_path and resume:
model = load_model(input_shape, latest_weights_path, net)
else:
model = net(input_shape,
kernel_size=kernel_size,
activation=activation,
padding=padding,
prior_std=prior_std)
# Prints model summary.
model.summary(line_length=127)
# Converts to multi-gpu model if applicable.
if num_gpus > 1:
model = multi_gpu_model(model, gpus=num_gpus)
# Sets loss function.
if bayesian:
loss = variational_free_energy_loss(model, scale_factor, alpha)
else:
loss = binary_crossentropy
# Compiles model with Adam optimizer.
model.compile(loss=loss, optimizer=Adam(), metrics=["accuracy"])
return model, checkpoint_path
def create_models(backbone_retinanet,
num_classes,
weights,
multi_gpu=0,
freeze_backbone=False,
lr=1e-5,
config=None):
""" Creates three models (model, training_model, prediction_model).
Args
backbone_retinanet : A function to call to create a retinanet model with a given backbone.
num_classes : The number of classes to train.
weights : The weights to load into the model.
multi_gpu : The number of GPUs to use for training.
freeze_backbone : If True, disables learning for the backbone.
config : Config parameters, None indicates the default configuration.
Returns
model : The base model. This is also the model that is saved in snapshots.
training_model : The training model. If multi_gpu=0, this is identical to model.
prediction_model : The model wrapped with utility functions to perform object detection (applies regression values and performs NMS).
"""
modifier = freeze_model if freeze_backbone else None
# load anchor parameters, or pass None (so that defaults will be used)
anchor_params = None
num_anchors = None
if config and 'anchor_parameters' in config:
anchor_params = parse_anchor_parameters(config)
num_anchors = anchor_params.num_anchors()
# Keras recommends initialising a multi-gpu model on the CPU to ease weight sharing, and to prevent OOM errors.
# optionally wrap in a parallel model
if multi_gpu > 1:
from tensorflow.keras.utils import multi_gpu_model
with tf.device('/cpu:0'):
model = model_with_weights(backbone_retinanet(
num_classes, num_anchors=num_anchors, modifier=modifier),
weights=weights,
skip_mismatch=True)
training_model = multi_gpu_model(model, gpus=multi_gpu)
else:
model = model_with_weights(backbone_retinanet(num_classes,
num_anchors=num_anchors,
modifier=modifier),
weights=weights,
skip_mismatch=True)
training_model = model
# make prediction model
prediction_model = retinanet_bbox(model=model, anchor_params=anchor_params)
# compile model
training_model.compile(loss={
'regression': losses.smooth_l1(),
'classification': losses.focal()
},
optimizer=keras.optimizers.Adam(lr=lr,
clipnorm=0.001))
return model, training_model, prediction_model
def main():
print('LOAD PARAMETERS')
args = parse_args()
cfg_params = parse_params(args.config)
params_train = cfg_params['train']
params_model = cfg_params['model']
params_dataloader = cfg_params['dataloader']
params_generator = cfg_params['generator']
tensorboard_save_path, weights_save_file_path, plots_save_path = create_save_folders(
cfg_params['general'])
work_dir_path = os.path.join(cfg_params['general']['work_dir'],
cfg_params['general']['project_name'])
weights_save_path = os.path.join(work_dir_path, 'weights/')
initial_lr = params_train['learning_rate']
decay_factor = params_train['decay_factor']
step_size = params_train['step_size']
if params_dataloader['validate']:
callback_monitor = 'val_loss'
else:
callback_monitor = 'loss'
print('LOADING COMPLETED')
callbacks = [
LearningRateScheduler(
lambda x: initial_lr * decay_factor**np.floor(x / step_size)),
ReduceLROnPlateau(monitor=callback_monitor,
factor=0.1,
patience=4,
verbose=1),
EarlyStopping(monitor=callback_monitor, patience=10, verbose=1),
ModelCheckpoint(filepath=weights_save_file_path,
monitor=callback_monitor,
save_best_only=True,
verbose=1)
]
print('CREATE DATALOADER')
data_loader = ENDataLoader(**params_dataloader)
print('DATALOADER CREATED!')
if cfg_params['general']['tensorboard_callback']:
callbacks.append(TensorBoard(log_dir=tensorboard_save_path))
if cfg_params['general']['wandb_callback']:
import wandb
from wandb.keras import WandbCallback
wandb.init()
callbacks.append(
WandbCallback(data_type="image", labels=data_loader.class_names))
val_generator = None
print('CREATE MODEL AND DATA GENETATORS')
if params_model['mode'] == 'siamese':
model = SiameseNet(cfg_params, training=True)
train_generator = SiameseDataGenerator(
class_files_paths=data_loader.train_data,
class_names=data_loader.class_names,
**params_generator)
if data_loader.validate:
val_generator = SiameseDataGenerator(
class_files_paths=data_loader.val_data,
class_names=data_loader.class_names,
val_gen=True,
**params_generator)
losses = {'output_siamese': contrastive_loss}
metric = {'output_siamese': accuracy}
else:
if cfg_params['general']['gpu_ids']:
print('Multiple gpu mode')
gpu_ids = cfg_params['general']['gpu_ids']
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = gpu_ids
print(f'Using gpu ids: {gpu_ids}')
gpu_ids_list = gpu_ids.split(',')
n_gpu = len(gpu_ids_list)
else:
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = '0'
n_gpu = 1
print('Use single gpu mode')
model = TripletNet(cfg_params, training=True)
if n_gpu > 1:
strategy = tf.distribute.MirroredStrategy()
with strategy.scope():
model.base_model = multi_gpu_model(model.base_model,
gpus=n_gpu)
# model.base_model = tf.keras.utils.multi_gpu_model(model.base_model, gpus=n_gpu)
train_generator = TripletsDataGenerator(
embedding_model=model.base_model,
class_files_paths=data_loader.train_data,
class_names=data_loader.class_names,
**params_generator)
if data_loader.validate:
val_generator = SimpleTripletsDataGenerator(
data_loader.val_data, data_loader.class_names,
**params_generator)
losses = triplet_loss(params_generator['margin'])
metric = ['accuracy']
print('DONE')
if args.resume_from is not None:
model.load_model(args.resume_from)
print('COMPILE MODEL')
model.model.compile(loss=losses,
optimizer=params_train['optimizer'],
metrics=metric)
if 'softmax' in cfg_params:
params_softmax = cfg_params['softmax']
params_save_paths = cfg_params['general']
pretrain_backbone_softmax(model.backbone_model, data_loader,
params_softmax, params_save_paths)
history = model.model.fit_generator(train_generator,
validation_data=val_generator,
epochs=params_train['n_epochs'],
callbacks=callbacks,
verbose=1,
use_multiprocessing=False)
if params_train['plot_history']:
plot_grapths(history, plots_save_path)
def __init__(self, conf):
"""
Parameters
----------
conf: dictionary
Semantic segmentation model configuration dictionary.
"""
# Check exception.
assert conf['nn_arch']['output_stride'] == 8 or conf['nn_arch'][
'output_stride'] == 16
# Initialize.
self.conf = conf
self.raw_data_path = self.conf['raw_data_path']
self.hps = self.conf['hps']
self.nn_arch = self.conf['nn_arch']
self.model_loading = self.conf['model_loading']
if self.model_loading:
opt = optimizers.Adam(lr=self.hps['lr'],
beta_1=self.hps['beta_1'],
beta_2=self.hps['beta_2'],
decay=self.hps['decay'])
with CustomObjectScope({
'CategoricalCrossentropyWithLabelGT':
CategoricalCrossentropyWithLabelGT,
'MeanIoUExt': MeanIoUExt
}):
if self.conf['multi_gpu']:
self.model = load_model(
os.path.join(self.raw_data_path, self.MODEL_PATH))
self.parallel_model = multi_gpu_model(
self.model, gpus=self.conf['num_gpus'])
self.parallel_model.compile(optimizer=opt,
loss=self.model.losses,
metrics=self.model.metrics)
else:
self.model = load_model(
os.path.join(self.raw_data_path, self.MODEL_PATH))
# self.model.compile(optimizer=opt,
# , loss=CategoricalCrossentropyWithLabelGT(num_classes=self.nn_arch['num_classes'])
# , metrics=[MeanIoUExt(num_classes=NUM_CLASSES)]
else:
# Design the semantic segmentation model.
# Load a base model.
if self.conf['base_model'] == BASE_MODEL_MOBILENETV2:
# Load mobilenetv2 as the base model.
mv2 = MobileNetV2(
include_top=False
) # , depth_multiplier=self.nn_arch['mv2_depth_multiplier'])
if self.nn_arch['output_stride'] == 8:
self.base = Model(
inputs=mv2.inputs,
outputs=mv2.get_layer('block_5_add').output
) # Layer satisfying output stride of 8.
else:
self.base = Model(
inputs=mv2.inputs,
outputs=mv2.get_layer('block_12_add').output
) # Layer satisfying output stride of 16.
self.base.trainable = True
for layer in self.base.layers:
layer.trainable = True # ?
self.base._init_set_name('base')
elif self.conf['base_model'] == BASE_MODEL_XCEPTION:
# Load xception as the base model.
mv2 = Xception(
include_top=False
) # , depth_multiplier=self.nn_arch['mv2_depth_multiplier'])
if self.nn_arch['output_stride'] == 8:
self.base = Model(
inputs=mv2.inputs,
outputs=mv2.get_layer('block4_sepconv2_bn').output
) # Layer satisfying output stride of 8.
else:
self.base = Model(
inputs=mv2.inputs,
outputs=mv2.get_layer('block13_sepconv2_bn').output
) # Layer satisfying output stride of 16.
self.base.trainable = True
for layer in self.base.layers:
layer.trainable = True # ?
self.base._init_set_name('base')
# Make the encoder-decoder model.
self._make_encoder()
self._make_decoder()
inputs = self.encoder.inputs
features = self.encoder(inputs)
outputs = self.decoder([inputs[0], features]) if self.nn_arch['boundary_refinement'] \
else self.decoder(features)
self.model = Model(inputs, outputs)
# Compile.
opt = optimizers.Adam(lr=self.hps['lr'],
beta_1=self.hps['beta_1'],
beta_2=self.hps['beta_2'],
decay=self.hps['decay'])
self.model.compile(optimizer=opt,
loss=CategoricalCrossentropyWithLabelGT(
num_classes=self.nn_arch['num_classes']),
metrics=[MeanIoUExt(num_classes=NUM_CLASSES)])
self.model._init_set_name('deeplabv3plus_mnv2')
if self.conf['multi_gpu']:
self.parallel_model = multi_gpu_model(
self.model, gpus=self.conf['num_gpus'])
self.parallel_model.compile(optimizer=opt,
loss=self.model.losses,
metrics=self.model.metrics)
def main(args):
log_dir = 'logs/'
class_names = get_classes(args.classes_path)
num_classes = len(class_names)
if args.matchpoint_path:
matchpoints = get_matchpoints(args.matchpoint_path)
else:
matchpoints = None
# choose model type
if args.tiny:
num_channels = 128
#input_size = (192, 192)
else:
num_channels = 256
#input_size = (256, 256)
input_size = args.model_image_size
# get train/val dataset
train_dataset = hourglass_dataset(args.dataset_path,
class_names,
input_size=input_size,
is_train=True,
matchpoints=matchpoints)
val_dataset = hourglass_dataset(args.dataset_path,
class_names,
input_size=input_size,
is_train=False)
train_gen = train_dataset.generator(args.batch_size,
args.num_stacks,
sigma=1,
is_shuffle=True,
rot_flag=True,
scale_flag=True,
h_flip_flag=True,
v_flip_flag=True)
model_type = get_model_type(args.num_stacks, args.mobile, args.tiny,
input_size)
# callbacks for training process
tensorboard = TensorBoard(log_dir=log_dir,
histogram_freq=0,
write_graph=False,
write_grads=False,
write_images=False,
update_freq='batch')
eval_callback = EvalCallBack(log_dir, val_dataset, class_names, input_size,
model_type)
terminate_on_nan = TerminateOnNaN()
callbacks = [tensorboard, eval_callback, terminate_on_nan]
# prepare optimizer
#optimizer = RMSprop(lr=5e-4)
optimizer = get_optimizer(args.optimizer,
args.learning_rate,
decay_type=None)
# get train model, doesn't specify input size
model = get_hourglass_model(num_classes,
args.num_stacks,
num_channels,
mobile=args.mobile)
print(
'Create {} Stacked Hourglass model with stack number {}, channel number {}. train input size {}'
.format('Mobile' if args.mobile else '', args.num_stacks, num_channels,
input_size))
model.summary()
if args.weights_path:
model.load_weights(args.weights_path,
by_name=True) #, skip_mismatch=True)
print('Load weights {}.'.format(args.weights_path))
# support multi-gpu training
template_model = None
if args.gpu_num >= 2:
# keep the template model for saving result
template_model = model
model = multi_gpu_model(model, gpus=args.gpu_num)
model.compile(optimizer=optimizer, loss=mean_squared_error)
# start training
model.fit_generator(generator=train_gen,
steps_per_epoch=train_dataset.get_dataset_size() //
args.batch_size,
epochs=args.total_epoch,
initial_epoch=args.init_epoch,
workers=1,
use_multiprocessing=False,
max_queue_size=10,
callbacks=callbacks)
if template_model is not None:
template_model.save(os.path.join(log_dir, 'trained_final.h5'))
else:
model.save(os.path.join(log_dir, 'trained_final.h5'))
return
def create_model_bottleneck(input_shape, anchors, num_classes, freeze_body=2,
weights_path=None, nb_gpu=1):
"""create the training model"""
# K.clear_session() # get a new session
cnn_h, cnn_w = input_shape
image_input = Input(shape=(cnn_w, cnn_h, 3))
num_anchors = len(anchors)
y_true = [Input(shape=(cnn_h // {0: 32, 1: 16, 2: 8}[layer_idx],
cnn_w // {0: 32, 1: 16, 2: 8}[layer_idx],
num_anchors // 3,
num_classes + 5))
for layer_idx in range(3)]
_LOSS_ARGUMENTS = {
'anchors': anchors,
'num_classes': num_classes,
'ignore_thresh': 0.5
}
if not nb_gpu: # disable all GPUs
os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
model_body = yolo_body_full(image_input, num_anchors // 3, num_classes)
logging.info('Create YOLOv3 model with %i anchors and %i classes.',
num_anchors, num_classes)
if weights_path is not None:
weights_path = update_path(weights_path)
if os.path.isfile(weights_path):
logging.warning('missing weights: %s', weights_path)
else:
logging.info('Load weights %s.', weights_path)
model_body.load_weights(weights_path, by_name=True, skip_mismatch=True)
if freeze_body in [1, 2]:
# Freeze darknet53 body or freeze all but 3 output layers.
num = (185, len(model_body.layers) - 3)[freeze_body - 1]
for i in range(num):
model_body.layers[i].trainable = False
logging.info('Freeze the first %i layers of total %i layers.',
num, len(model_body.layers))
# get output of second last layers and create bottleneck model of it
out1 = model_body.layers[246].output
out2 = model_body.layers[247].output
out3 = model_body.layers[248].output
model_bottleneck = Model([model_body.input, *y_true], [out1, out2, out3])
# create last layer model of last layers from yolo model
in0 = Input(shape=model_bottleneck.output[0].shape[1:].as_list())
in1 = Input(shape=model_bottleneck.output[1].shape[1:].as_list())
in2 = Input(shape=model_bottleneck.output[2].shape[1:].as_list())
last_out0 = model_body.layers[249](in0)
last_out1 = model_body.layers[250](in1)
last_out2 = model_body.layers[251](in2)
model_last = Model(inputs=[in0, in1, in2], outputs=[last_out0, last_out1, last_out2])
fn_loss = Lambda(yolo_loss, output_shape=(1,), name='yolo_loss', arguments=_LOSS_ARGUMENTS)
model_loss_last = fn_loss([*model_last.output, *y_true])
last_layer_model = Model([in0, in1, in2, *y_true], model_loss_last)
fn_loss = Lambda(yolo_loss, output_shape=(1,), name='yolo_loss', arguments=_LOSS_ARGUMENTS)
model_loss = fn_loss([*model_body.output, *y_true])
model = Model([model_body.input, *y_true], model_loss)
if nb_gpu >= 2:
model = multi_gpu_model(model, gpus=nb_gpu)
model_bottleneck = multi_gpu_model(model_bottleneck, gpus=nb_gpu)
return model, model_bottleneck, last_layer_model
def main(argv=None):
os.environ['CUDA_VISIBLE_DEVICES'] = FLAGS.gpu_list
# check if checkpoint path exists
if not os.path.exists(FLAGS.checkpoint_path):
os.mkdir(FLAGS.checkpoint_path)
else:
#if not FLAGS.restore:
# shutil.rmtree(FLAGS.checkpoint_path)
# os.mkdir(FLAGS.checkpoint_path)
shutil.rmtree(FLAGS.checkpoint_path)
os.mkdir(FLAGS.checkpoint_path)
if len(gpus) <= 1:
print('Training with 1 GPU')
east = EAST_model(FLAGS.input_size)
parallel_model = east.model
else:
print('Training with %d GPUs' % len(gpus))
with tf.device("/cpu:0"):
east = EAST_model(FLAGS.input_size)
if FLAGS.restore_model is not '':
east.model.load_weights(FLAGS.restore_model)
parallel_model = multi_gpu_model(east.model, gpus=len(gpus))
score_map_loss_weight = K.variable(0.01, name='score_map_loss_weight')
small_text_weight = K.variable(0., name='small_text_weight')
# opt = AdamW(FLAGS.init_learning_rate)
opt = Adam(learning_rate=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-4)
parallel_model.compile(loss=[
dice_loss(east.overly_small_text_region_training_mask,
east.text_region_boundary_training_mask,
score_map_loss_weight, small_text_weight),
rbox_loss(east.overly_small_text_region_training_mask,
east.text_region_boundary_training_mask, small_text_weight,
east.target_score_map)
],
loss_weights=[1., 1.],
optimizer=opt)
east.model.summary()
model_json = east.model.to_json()
with open(FLAGS.checkpoint_path + '/model.json', 'w') as json_file:
json_file.write(model_json)
plot_model(east.model,
to_file=FLAGS.checkpoint_path + '/east-train.png',
show_shapes=True,
show_layer_names=True,
expand_nested=True)
plot_model(east.resnet,
to_file=FLAGS.checkpoint_path + '/resnet.png',
show_shapes=True,
show_layer_names=True,
expand_nested=True)
train_data_generator = data_processor.TrainDataSequence(FLAGS)
#train_data_generator = data_processor.generator(FLAGS)
#train_data_x, train_data_y = data_processor.load_train_data(FLAGS)
#print('# of train data: %d' %(len(train_data_x[0])))
train_samples_count = data_processor.count_samples(FLAGS)
print("train_samples_count: %d" % (train_samples_count))
val_data = data_processor.load_data(FLAGS)
lr_scheduler = LearningRateScheduler(lr_decay)
ckpt = CustomModelCheckpoint(model=east.model,
path=FLAGS.checkpoint_path,
period=FLAGS.save_checkpoint_epochs,
save_weights_only=False)
# tb = CustomTensorBoard(log_dir=FLAGS.checkpoint_path + '/train', score_map_loss_weight=score_map_loss_weight, small_text_weight=small_text_weight, data_generator=train_data_generator, write_graph=True)
small_text_weight_callback = SmallTextWeight(small_text_weight)
validation_evaluator = ValidationEvaluator(
val_data, validation_log_dir=FLAGS.checkpoint_path + '/val')
callbacks = [
lr_scheduler, ckpt, small_text_weight_callback, validation_evaluator
]
#callbacks = [lr_scheduler, ckpt, small_text_weight_callback]
#history = parallel_model.fit(x=train_data_x, y=train_data_y, batch_size=FLAGS.batch_size, epochs=FLAGS.max_epochs, verbose=1, callbacks=callbacks, max_queue_size=10, workers=FLAGS.nb_workers, use_multiprocessing=True)
#history = parallel_model.fit(x=train_data_generator, epochs=FLAGS.max_epochs, steps_per_epoch=train_samples_count/FLAGS.batch_size, callbacks=callbacks, max_queue_size=10, verbose=1)
history = parallel_model.fit(x=train_data_generator,
epochs=FLAGS.max_epochs,
callbacks=callbacks,
max_queue_size=10,
workers=FLAGS.nb_workers,
use_multiprocessing=False,
verbose=1)
file_name = FLAGS.checkpoint_path + '/model-train.h5'
east.model.save(file_name, overwrite=True)
plot_model(east.model_core,
to_file=FLAGS.checkpoint_path + '/east.png',
show_shapes=True,
show_layer_names=True,
expand_nested=True)
file_name = FLAGS.checkpoint_path + '/model.h5'
east.model_core.save(file_name, overwrite=True, include_optimizer=False)
tflite_model = lite.TFLiteConverter.from_keras_model_file(
file_name,
input_arrays=["input_image"],
input_shapes={
"input_image": [1, 224, 320, 3]
}).convert()
with open(file_name + '.tflite', 'wb') as tflite_file:
tflite_file.write(tflite_model)
return dataset
testing_dataset = get_training_dataset(tfrecord_test)
####################################
# Load model and params
####################################
print('Loading model.')
if pred_p['n_gpus'] > 1:
# Load weights on CPU to avoid taking up GPU space
with tf.device('/cpu:0'):
template_model = load_model(
op.join(ckpt_dir, pred_p['model_arch_fname']),
op.join(ckpt_dir, pred_p['model_weights_fname']))
parallel_model = multi_gpu_model(template_model, gpus=pred_p['n_gpus'])
else:
template_model = load_model(
op.join(ckpt_dir, pred_p['model_arch_fname']),
op.join(ckpt_dir, pred_p['model_weights_fname']))
# template_model = load_model(op.join(ckpt_dir, pred_p['model_weights_fname']))
parallel_model = template_model
# Turn off training. This is supposed to be faster (haven't seen this empirically though)
K.set_learning_phase = 0
for layer in template_model.layers:
layer.trainable = False
# Load model parameters for printing
with open(op.join(ckpt_dir, pred_p['model_params_fname']),
'r') as f_model_params:
# If model_creation_device == '/cpu:1', '/gpu:0', '/gpu:1', '/gpu:2', or '/gpu:3'
# Warning related to device placement is raised,
# Warning related to memory shortage is raised, and
# GPU usage is unbalanced and highly concentrated to the model_creation device.
# Except that the GPU usage is concentrated to gpu:0 when model_creation device == '/cpu:1'.
cells = StackedSTLSTMCells([STLSTMCell(filters=FILTERS, kernel_size=KERNEL_SIZE) for _ in range(NUM_CELL)])
predRNN = keras.Sequential([
STLSTM2D(cells, return_sequences=True, input_shape=(TOTAL_LEN, IMG_SIZE, IMG_SIZE, 1)),
keras.layers.Reshape(target_shape=(IMG_SIZE*TOTAL_LEN, IMG_SIZE, FILTERS)),
keras.layers.Conv2D(filters=1, kernel_size=1),
keras.layers.Reshape(target_shape=(TOTAL_LEN, IMG_SIZE, IMG_SIZE, 1))
])
predRNN.summary()
predRNN_multi = utils.multi_gpu_model(predRNN, gpus=NUM_GPU) # Make Multi GPU model.
optimizer = keras.optimizers.Adam(lr=0.001)
predRNN_multi.compile(optimizer = optimizer,
loss = l1_l2_loss,
metrics = [tf.keras.metrics.mse])
train_dataset, valid_dataset = input_fn() # Make TF datasets
callbacks = [] # Make training callback list
callbacks.append(
tf.keras.callbacks.TensorBoard(log_dir='./logs',
histogram_freq=0,
batch_size=BATCH_SIZE,
write_graph=True,
write_grads=False))
callbacks.append(
def __init__(self, preprocess=False, name='DeepSense', n_gpu=1, **kwargs):
super(DeepSenseOrigin, self).__init__(name=name)
self.ics_model = None
self.mcs_model = None
self.gru_model = None
# MODEL hyperparameters
########################
# Model Compile
########################
self.LEARNING_RATE = kwargs['lr'] if 'lr' in kwargs.keys() else 0.001
self.DECAY = kwargs['decay'] if 'decay' in kwargs.keys() else 0.9
self.OPTIMIZER = kwargs['optimizer'] if 'optimizer' in kwargs.keys() else \
keras.optimizers.RMSprop(lr=self.LEARNING_RATE, decay=self.DECAY)
self.LOSS = kwargs['loss'] if 'loss' in kwargs.keys(
) else 'categorical_crossentropy'
self.METRICS = kwargs['metrics'] if 'metrics' in kwargs.keys() else [
'acc'
]
########################
# Data Config
########################
self.WIN_SIZE = kwargs['winsize'] if 'winsize' in kwargs.keys() else 10
self.WIN_WIDTH = kwargs['winwidth'] if 'winwidth' in kwargs.keys(
) else 11
# for window const to put win_width
self.WIN_SHAPE = kwargs['winshape'] if 'winshape' in kwargs.keys(
) else [1, 1]
# window width in seconds
self.WIN_T = kwargs['winT'] if 'winT' in kwargs.keys() else 1
self.K_SIZE = kwargs['Ksize'] if 'Ksize' in kwargs.keys() else 1
self.N_COMPS = kwargs['ncomps'] if 'ncomps' in kwargs.keys(
) else 2 * self.WIN_WIDTH
########################
# CNN params
########################
self.CONV1_KERNEL = kwargs['c1kernel'] if 'c1kernel' in kwargs.keys(
) else [3, 2]
self.CONV1_STRIDE = kwargs['c1stride'] if 'c1stride' in kwargs.keys(
) else [1, 1]
self.CONV2_KERNEL = kwargs['c2kernel'] if 'c2kernel' in kwargs.keys(
) else [1, 3]
self.CONV2_STRIDE = kwargs['c2stride'] if 'c2stride' in kwargs.keys(
) else [1, 1]
self.CONV3_KERNEL = kwargs['c3kernel'] if 'c3kernel' in kwargs.keys(
) else [1, 2]
self.CONV3_STRIDE = kwargs['c3stride'] if 'c3stride' in kwargs.keys(
) else [1, 1]
self.CONV4_KERNEL = kwargs['c4kernel'] if 'c4kernel' in kwargs.keys(
) else [self.K_SIZE, 2]
self.CONV4_STRIDE = kwargs['c4stride'] if 'c4stride' in kwargs.keys(
) else [self.K_SIZE, 1]
self.CONV5_KERNEL = kwargs['c5kernel'] if 'c5kernel' in kwargs.keys(
) else [1, 3]
self.CONV5_STRIDE = kwargs['c5stride'] if 'c5stride' in kwargs.keys(
) else [1, 1]
self.CONV6_KERNEL = kwargs['c6kernel'] if 'c6kernel' in kwargs.keys(
) else [1, 2]
self.CONV6_STRIDE = kwargs['c6stride'] if 'c6stride' in kwargs.keys(
) else [1, 1]
self.GRU_DROPOUT = kwargs['grudropout'] if 'grudropout' in kwargs.keys(
) else 0.5
self.GRU_UNITS_1 = kwargs['gruunits1'] if 'gruunits1' in kwargs.keys(
) else 128
self.GRU_UNITS_2 = kwargs['gruunits2'] if 'gruunits2' in kwargs.keys(
) else 3
self.INPUT_SHAPE = (3, self.N_COMPS, self.WIN_SIZE
) # (d, n_features, T)
self.CONV_FILTER = kwargs['cfilter'] if 'cfilter' in kwargs.keys(
) else 64
########################
# Model Input Shapes
########################
self.ICS_INPUT_SHAPE = (3, self.N_COMPS, 1)
self.MCS_INPUT_SHAPE = (1, (self.N_COMPS - (self.CONV1_KERNEL[1] - 1) -
(self.CONV2_KERNEL[1] - 1) -
(self.CONV3_KERNEL[1] - 1)) *
self.CONV_FILTER, 1)
self.GRU_INPUT_SHAPE = (
self.WIN_SIZE,
(self.MCS_INPUT_SHAPE[1] - (self.CONV4_KERNEL[1] - 1) -
(self.CONV5_KERNEL[1] - 1) -
(self.CONV6_KERNEL[1] - 1)) * self.CONV_FILTER + 1)
if preprocess:
self.pre_processing_ds()
print('Model, features, labels are done.')
# build model based on config
if n_gpu == 1:
self.cpu_model = None
self.model = self.build_model()
else:
with tf.device('/cpu:0'):
self.cpu_model = self.build_model()
self.model = multi_gpu_model(self.cpu_model, gpus=n_gpu)
return
os.remove(f"{chkpt_dir}/newest.h5")
classifier.save_weights(f"{chkpt_dir}/newest.h5")
if __name__ == '__main__':
os.makedirs(Config.results_dir, exist_ok=True)
shutil.copyfile('config.py', f'{Config.results_dir}/config.py')
ms = get_ms()
dataloader = DataLoader(Config, ms)
train_dataloader, val_dataloader = dataloader.get_train_dataloaders()
train_dataloader = iter(train_dataloader)
Config.num_steps = dataloader.train_len // dataloader.get_batch_size()
with ms.scope():
model = tf.keras.applications.ResNet50(include_top=True,
weights=None,
input_shape=(224, 224, 3),
pooling=None,
classes=Config.num_classes)
parallel_model = multi_gpu_model(
model, gpus=Config.n_gpus) if Config.n_gpus > 1 else model
optimizer = RMSprop(learning_rate=Config.lr, momentum=0.9)
model.compile(optimizer=optimizer,
loss={"predictions": categorical_crossentropy},
metrics={"predictions": "accuracy"})
model.summary()
train(model, train_dataloader, val_dataloader)
# train_and_val_model_input = {name: x_train_val[name] for name in feature_names}
with tf.device("/cpu:0"):
# model = DeepFM(linear_feature_columns=linear_feature_columns,
# dnn_feature_columns=dnn_feature_columns,
# dnn_dropout=0.1,
# dnn_hidden_units=(512, 128),
# task='binary')
model = DeepFM(
linear_feature_columns,
dnn_feature_columns,
task='binary',
dnn_dropout=0.1,
dnn_hidden_units=(512, 128),
)
model = multi_gpu_model(model, NUM_WORKERS)
model.compile(
optimizer=tf.keras.optimizers.Adam(3e-4),
# loss="binary_crossentropy",
loss=multi_category_focal_loss2(alpha=0.1),
metrics=[auroc],
)
dirpath = Path('checkpoint')
if dirpath.exists() and dirpath.is_dir():
shutil.rmtree(dirpath)
os.mkdir('checkpoint')
hist = model.fit(online_train_model_input,
train_df['label'].values,
batch_size=BATCH_SIZE,
def unet_new_ini(pretrained_weights=False, input_size=(256, 256, 1)):
inputs = Input(input_size)
conv1 = Conv2D(64,
3,
activation='relu',
padding='same',
kernel_initializer='glorot_normal')(inputs)
conv1 = Conv2D(64,
3,
activation='relu',
padding='same',
kernel_initializer='glorot_normal')(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = Conv2D(128,
3,
activation='relu',
padding='same',
kernel_initializer='glorot_normal')(pool1)
conv2 = Conv2D(128,
3,
activation='relu',
padding='same',
kernel_initializer='glorot_normal')(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = Conv2D(256,
3,
activation='relu',
padding='same',
kernel_initializer='glorot_normal')(pool2)
conv3 = Conv2D(256,
3,
activation='relu',
padding='same',
kernel_initializer='glorot_normal')(conv3)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = Conv2D(512,
3,
activation='relu',
padding='same',
kernel_initializer='glorot_normal')(pool3)
conv4 = Conv2D(512,
3,
activation='relu',
padding='same',
kernel_initializer='glorot_normal')(conv4)
drop4 = Dropout(0.5)(conv4)
pool4 = MaxPooling2D(pool_size=(2, 2))(drop4)
conv5 = Conv2D(1024,
3,
activation='relu',
padding='same',
kernel_initializer='glorot_normal')(pool4)
conv5 = Conv2D(1024,
3,
activation='relu',
padding='same',
kernel_initializer='glorot_normal')(conv5)
drop5 = Dropout(0.5)(conv5)
up6 = Conv2D(512,
2,
activation='relu',
padding='same',
kernel_initializer='glorot_normal')(
UpSampling2D(size=(2, 2))(drop5))
merge6 = concatenate([drop4, up6], axis=3)
conv6 = Conv2D(512,
3,
activation='relu',
padding='same',
kernel_initializer='glorot_normal')(merge6)
conv6 = Conv2D(512,
3,
activation='relu',
padding='same',
kernel_initializer='glorot_normal')(conv6)
up7 = Conv2D(256,
2,
activation='relu',
padding='same',
kernel_initializer='glorot_normal')(
UpSampling2D(size=(2, 2))(conv6))
merge7 = concatenate([conv3, up7], axis=3)
conv7 = Conv2D(256,
3,
activation='relu',
padding='same',
kernel_initializer='glorot_normal')(merge7)
conv7 = Conv2D(256,
3,
activation='relu',
padding='same',
kernel_initializer='glorot_normal')(conv7)
up8 = Conv2D(128,
2,
activation='relu',
padding='same',
kernel_initializer='glorot_normal')(
UpSampling2D(size=(2, 2))(conv7))
merge8 = concatenate([conv2, up8], axis=3)
conv8 = Conv2D(128,
3,
activation='relu',
padding='same',
kernel_initializer='glorot_normal')(merge8)
conv8 = Conv2D(128,
3,
activation='relu',
padding='same',
kernel_initializer='glorot_normal')(conv8)
up9 = Conv2D(64,
2,
activation='relu',
padding='same',
kernel_initializer='glorot_normal')(
UpSampling2D(size=(2, 2))(conv8))
merge9 = concatenate([conv1, up9], axis=3)
conv9 = Conv2D(64,
3,
activation='relu',
padding='same',
kernel_initializer='glorot_normal')(merge9)
conv9 = Conv2D(64,
3,
activation='relu',
padding='same',
kernel_initializer='glorot_normal')(conv9)
conv9 = Conv2D(2,
3,
activation='relu',
padding='same',
kernel_initializer='glorot_normal')(conv9)
conv10 = Conv2D(1, 1, activation='sigmoid')(conv9)
if (G == 1):
model = Model(inputs=inputs, outputs=conv10)
else:
with tf.device("/cpu:0"):
model = Model(inputs=inputs, outputs=conv10)
model = multi_gpu_model(model, gpus=G)
print(model.summary())
model.compile(optimizer=Adam(lr=1e-4),
loss='binary_crossentropy',
metrics=['accuracy'])
if (pretrained_weights):
model.load_weights(pretrained_weights)
return model
def _generate_model(self):
'''to generate the bounding boxes'''
weights_path = os.path.expanduser(self.weights_path)
assert weights_path.endswith(
'.h5'), 'Keras model or weights must be a .h5 file.'
# Load model, or construct model and load weights.
num_anchors = len(self.anchors)
num_classes = len(self.class_names)
#YOLOv3 model has 9 anchors and 3 feature layers but
#Tiny YOLOv3 model has 6 anchors and 2 feature layers,
#so we can calculate feature layers number to get model type
num_feature_layers = num_anchors // 3
try:
if self.model_type.startswith(
'scaled_yolo4_') or self.model_type.startswith('yolo5_'):
# Scaled-YOLOv4 & YOLOv5 entrance
yolo_model, _ = get_yolo5_model(
self.model_type,
num_feature_layers,
num_anchors,
num_classes,
input_shape=self.model_image_size + (3, ),
model_pruning=self.pruning_model)
elif self.model_type.startswith('yolo3_') or self.model_type.startswith('yolo4_') or \
self.model_type.startswith('tiny_yolo3_') or self.model_type.startswith('tiny_yolo4_'):
# YOLOv3 & v4 entrance
yolo_model, _ = get_yolo3_model(
self.model_type,
num_feature_layers,
num_anchors,
num_classes,
input_shape=self.model_image_size + (3, ),
model_pruning=self.pruning_model)
elif self.model_type.startswith(
'yolo2_') or self.model_type.startswith('tiny_yolo2_'):
# YOLOv2 entrance
yolo_model, _ = get_yolo2_model(
self.model_type,
num_anchors,
num_classes,
input_shape=self.model_image_size + (3, ),
model_pruning=self.pruning_model)
else:
raise ValueError('Unsupported model type')
yolo_model.load_weights(
weights_path) # make sure model, anchors and classes match
if self.pruning_model:
yolo_model = sparsity.strip_pruning(yolo_model)
yolo_model.summary()
except Exception as e:
print(repr(e))
assert yolo_model.layers[-1].output_shape[-1] == \
num_anchors/len(yolo_model.output) * (num_classes + 5), \
'Mismatch between model and given anchor and class sizes'
print('{} model, anchors, and classes loaded.'.format(weights_path))
if self.gpu_num >= 2:
yolo_model = multi_gpu_model(yolo_model, gpus=self.gpu_num)
return yolo_model
def dcnn_resnet(model_config,
input_shape,
metrics,
n_classes=2,
output_bias=None,
gpus=1):
'''
Defines a deep convolutional neural network model for multiclass X-ray classification.
:param model_config: A dictionary of parameters associated with the model architecture
:param input_shape: The shape of the model input
:param metrics: Metrics to track model's performance
:return: a Keras Model object with the architecture defined in this method
'''
# Set hyperparameters
nodes_dense0 = model_config['NODES_DENSE0']
lr = model_config['LR']
dropout = model_config['DROPOUT']
l2_lambda = model_config['L2_LAMBDA']
if model_config['OPTIMIZER'] == 'adam':
optimizer = Adam(learning_rate=lr)
elif model_config['OPTIMIZER'] == 'sgd':
optimizer = SGD(learning_rate=lr)
else:
optimizer = Adam(learning_rate=lr) # For now, Adam is default option
init_filters = model_config['INIT_FILTERS']
filter_exp_base = model_config['FILTER_EXP_BASE']
conv_blocks = model_config['CONV_BLOCKS']
kernel_size = eval(model_config['KERNEL_SIZE'])
max_pool_size = eval(model_config['MAXPOOL_SIZE'])
strides = eval(model_config['STRIDES'])
# Set output bias
if output_bias is not None:
output_bias = Constant(output_bias)
print("MODEL CONFIG: ", model_config)
# Input layer
X_input = Input(input_shape)
X = X_input
# Add convolutional (residual) blocks
for i in range(conv_blocks):
X_res = X
X = Conv2D(init_filters * (filter_exp_base**i),
kernel_size,
strides=strides,
padding='same',
kernel_initializer='he_uniform',
activity_regularizer=l2(l2_lambda),
name='conv' + str(i) + '_0')(X)
X = BatchNormalization()(X)
X = LeakyReLU()(X)
X = Conv2D(init_filters * (filter_exp_base**i),
kernel_size,
strides=strides,
padding='same',
kernel_initializer='he_uniform',
activity_regularizer=l2(l2_lambda),
name='conv' + str(i) + '_1')(X)
X = concatenate([X, X_res], name='concat' + str(i))
X = BatchNormalization()(X)
X = LeakyReLU()(X)
X = MaxPool2D(max_pool_size, padding='same')(X)
# Add fully connected layers
X = Flatten()(X)
X = Dropout(dropout)(X)
X = Dense(nodes_dense0,
kernel_initializer='he_uniform',
activity_regularizer=l2(l2_lambda))(X)
X = LeakyReLU()(X)
X = Dense(n_classes, bias_initializer=output_bias)(X)
Y = Activation('softmax', dtype='float32', name='output')(X)
# Set model loss function, optimizer, metrics.
model = Model(inputs=X_input, outputs=Y)
if gpus >= 2:
model = multi_gpu_model(model, gpus=gpus)
model.compile(loss='categorical_crossentropy',
optimizer=optimizer,
metrics=metrics)
model.summary()
return model
