def cls_predict_image(image_path,use_tta=False):
'''识别一张图片'''
num_folds =4
use_tta = False
y_pred = np.zeros(shape=(1,7))
resize_image_np,W,H = get_resize_image_np(image_path,224)
if use_tta:
for k_fold in range(num_folds+1):
run_name = "task3_inception_v3_k"+str(k_fold)+"_v0"
model = backbone("inception_v3").classification_model(load_from=run_name)
# 这里可以考虑使用多线程
if use_tta:
y_pred += inv_sigmoid(task3_tta_predict(model=model,img_arr=resize_image_np))
else:
y_pred += inv_sigmoid(model.predict_on_batch(resize_image_np))
else:
run_name = "task3_inception_v3_k" + str(num_folds) + "_v0"
model = backbone("inception_v3").classification_model(load_from=run_name)
y_pred += inv_sigmoid(model.predict_on_batch(resize_image_np))
y_pred = y_pred / num_folds
y_prob = softmax(y_pred)
print({
"result":y_prob
})
def seg_predict_image_task1(image_path, use_tta=False):
'''只针对一张图片'''
num_folds = 4
# use_tta = False # 如果为false,表示不采用取平均数方式
y_pred = np.zeros(shape=(1, 224, 224))
resize_image_np, W, H = get_resize_image_np(image_path, 224)
if use_tta:
# 采用取平均数的模式
for k_fold in range(num_folds + 1):
model_name = 'task1_vgg16'
run_name = 'task1_vgg16_k%d_v0' % k_fold
model = backbone('vgg16').segmentation_model(load_from=run_name)
# model.load_weights("/home/zhangfan/workData/LinuxCode/pythonProject/ISIC2018/model_data/task1_vgg16_k0_v0/task1_vgg16_k0_v0.hdf5")
y_pred += inv_sigmoid(
model.predict_on_batch(resize_image_np))[:, :, :, 0]
y_pred /= (num_folds + 1)
else:
# 只是用最后一组数据的权重
run_name = 'task1_vgg16_k%d_v0' % num_folds
model = backbone('vgg16').segmentation_model(load_from=run_name)
y_pred += inv_sigmoid(model.predict_on_batch(resize_image_np))[:, :, :,
0]
y_pred = sigmoid(y_pred)
current_pred = y_pred[0] * 255
current_pred[current_pred > 128] = 255
current_pred[current_pred <= 128] = 0
# 将resized_pred传给Nodejs
print({"image_np": current_pred, "width": W, "height": H})
def __init__(self):
self.graph = tf.get_default_graph()
self.task1_model = backbone('vgg16').segmentation_model(load_from=task1_model_name)
self.task2_model = UNet16(num_classes=5, pretrained='vgg')
process_task2_model(self.task2_model)
task3_model_ = backbone('inception_v3').classification_model(load_from=task3_model_name)
self.task3_model = Model(inputs=task3_model_.input,outputs=task3_model_.get_layer('predictions').output)
task4_model_ = backbone('inception_v3').classification_model(load_from=task4_model_name)
self.task4_model = Model(inputs=task4_model_.input,outputs=task4_model_.get_layer('predictions').output)
def load_model_from_run(backbone_name,
load_model_from,
load_weights_from=None,
skip_mismatch=True):
b = backbone(backbone_name)
json_path = get_json_filename(load_model_from)
if not os.path.exists(json_path):
h5_path = get_weights_filename(load_model_from)
if not os.path.exists(h5_path):
raise ValueError("run with name %s doesn't exist" %
load_model_from)
model = load_model(h5_path,
custom_objects=b.custom_objects,
compile=False)
else:
with open(json_path, 'r') as json_file:
json_string = json_file.read()
model = model_from_json(json_string, custom_objects=b.custom_objects)
if load_weights_from:
h5_path = get_weights_filename(load_weights_from)
if os.path.exists(h5_path):
model.load_weights(h5_path,
by_name=True,
skip_mismatch=skip_mismatch)
return model
def cls_predict_images(image_paths):
'''识别一组图片'''
num_folds = 5
use_tta = False
run_name = "task3_inception_v3_k" + str(num_folds) + "_v0"
model = backbone("inception_v3").classification_model(load_from=run_name)
for image_path in image_paths:
y_pred = np.zeros(shape=(1,7))
resize_image_np, W, H = get_resize_image_np(image_path,224)
y_pred += inv_sigmoid(model.predict_on_batch(resize_image_np))
y_prod = softmax(y_pred)
print({
"result": y_prod
})
def seg_predict_images_task1(image_paths, use_tta=False):
'''输入图片地址，预测一组图片'''
num_folds = 4
use_tta = False
image_num = len(image_paths) # 得到图片的数量
if use_tta:
pass
else:
y_pred = np.zeros(shape=(1, 224, 224))
run_name = 'task1_vgg16_k%d_v0' % num_folds
model = backbone('vgg16').segmentation_model(load_from=run_name)
for image_path in image_paths:
resize_image_np, W, H = get_resize_image_np(image_path, 224)
y_pred += inv_sigmoid(
model.predict_on_batch(resize_image_np))[:, :, :, 0]
y_pred = sigmoid(y_pred)
current_pred = y_pred[0] * 255
current_pred[current_pred > 128] = 255
current_pred[current_pred <= 128] = 0
print({"image_np": current_pred, "width": W, "height": H})
y_train = one_hot(h5f['y_train'][:])
x_valid = h5f['X_test'][:]
y_valid = one_hot(h5f['y_test'][:])
h5f.close()
run_name = model_name + '_2'
root_path = os.path.dirname(os.path.abspath(__file__))
dest_path = os.path.join(root_path, run_name)
if not os.path.exists(dest_path):
os.mkdir(dest_path)
if not MC: # normal evaluation
model = backbone(backbone_name).classification_model(
load_weights_from=model_name,
num_classes=num_cls,
num_dense_layers=num_dense_layers,
num_dense_units=num_dense_units,
dropout_rate=0.,
pooling=pooling,
kernel_regularizer=dense_layer_regularizer)
y_pred = model.predict(x_valid)
y_prob = softmax(y_pred)
fig_path = os.path.join(dest_path, 'confusion_matrix' + '.png')
save_confusion_matrix(y_valid.argmax(axis=1).astype(int),
y_prob.argmax(axis=1).astype(int),
classes=np.array(label_name),
dest_path=fig_path,
title='Confusion matrix, without normalization')
fig_path = os.path.join(dest_path,
'normalized_confusion_matrix' + '.png')
x_valid = x_valid[:32]
y_valid = y_valid[:32]
bv = BatchVisualization(images=x_train, true_labels=y_train)
bv()
num_classes = y_train.shape[1]
callbacks = config_cls_callbacks(run_name)
model = backbone(backbone_name, **backbone_options).classification_model(
input_shape=x_train.shape[1:],
num_classes=num_classes,
num_dense_layers=num_dense_layers,
num_dense_units=num_dense_units,
pooling=pooling,
dropout_rate=dropout_rate,
kernel_regularizer=dense_layer_regularizer,
save_to=run_name,
lr=lr)
n_samples_train = x_train.shape[0]
n_samples_valid = x_valid.shape[0]
class_weights = compute_class_weights(y_train, wt_type=class_wt_type)
batch_size = 32
use_data_aug = True
horizontal_flip = True
vertical_flip = True
rotation_angle = 180
if debug_visualize:
x_train = x_train[:32]
y_train = y_train[:32]
x_valid = x_valid[:32]
y_valid = y_valid[:32]
bv = BatchVisualization(images=x_train, true_masks=y_train)
bv()
callbacks = config_seg_callbacks(run_name)
if from_run_name:
model = backbone(backbone_name).segmentation_model(
load_from=from_run_name, lr=init_lr)
else:
model = backbone(backbone_name,
**backbone_options).segmentation_model(
input_shape=x_train.shape[1:],
num_classes=y_train.shape[3],
upsampling_type=upsampling_type,
bottleneck=bottleneck,
init_nb_filters=init_nb_filters,
growth_rate=growth_rate,
nb_layers_per_block=nb_layers_per_block,
max_nb_filters=max_nb_filters,
activation=decoder_activation,
use_activation=use_activation,
save_to=run_name,
print_model_summary=print_model_summary,
data_dir = os.path.join(BASE_DIR, 'preprocessed_data.h5')
x_train, y_train, x_valid, y_valid = load_data(data_dir)
##################################
# Create the model
##################################
callbacks = config_cls_callbacks(save_dir)
backbone_options = {}
model = backbone(options.backbone_name, **backbone_options).classification_model(
input_shape=x_train.shape[1:],
num_classes=options.num_classes,
num_dense_layers=options.num_dense_layers,
num_dense_units=options.num_dense_units,
pooling=options.pooling,
dropout_rate=options.dropout_rate,
kernel_regularizer=options.dense_layer_regularizer,
save_to=save_dir,
load_from=None,
print_model_summary=True,
plot_model_summary=False,
lr=options.lr)
class_weights = compute_class_weights(y_train, wt_type=options.class_wt_type)
log_variable(var_name='num_dense_layers', var_value=options.num_dense_layers)
log_variable(var_name='num_dense_units', var_value=options.num_dense_units)
log_variable(var_name='dropout_rate', var_value=options.dropout_rate)
log_variable(var_name='pooling', var_value=options.pooling)
log_variable(var_name='class_wt_type', var_value=options.class_wt_type)
log_variable(var_name='dense_layer_regularizer', var_value=options.dense_layer_regularizer)
def main(args=None):
# parse arguments
if args is None:
args = sys.argv[1:]
args = parse_args(args)
# optionally load config parameters
if args.config:
args.config = read_config_file(args, 'training')
# print("----------------------------------")
# print("ARGUMENTS IN CONFIG FILE:")
# for sec in args.config.sections():
# print(sec, "=", dict(args.config.items(sec)))
# print("----------------------------------")
#
# for arg in vars(args):
# print(arg, "=", getattr(args, arg))
# exit()
# create object that stores backbone information
backbone = models.backbone(args.backbone)
# make sure keras is the minimum required version
check_keras_version()
# optionally choose specific GPU
if args.gpu:
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
keras.backend.tensorflow_backend.set_session(get_session())
# create the generators
train_generator, validation_generator = create_generators(
args, backbone.preprocess_image)
# # Debuging
# for i in range(1):
# inputs, targets = train_generator.__getitem__(i)
# exit()
# create the model
if args.snapshot is not None:
print('Loading model, this may take a second...')
model = models.load_model(args.snapshot, backbone_name=args.backbone)
# When using as a second step for fine-tuning
for layer in model.layers:
layer.trainable = True
training_model = model
anchor_params = None
if args.config and 'anchor_parameters' in args.config:
anchor_params = parse_anchor_parameters(args.config)
prediction_model = retinanet_bbox(model=model,
anchor_params=anchor_params)
###################################################################################### BRUNO
# compile model
training_model.compile(loss={
'regression': losses.smooth_l1(),
'classification': losses.focal()
},
optimizer=keras.optimizers.adam(lr=args.lr,
clipnorm=0.001))
else:
weights = args.weights
# default to imagenet if nothing else is specified
if weights is None and args.imagenet_weights:
weights = backbone.download_imagenet()
print('Creating model, this may take a second...')
model, training_model, prediction_model = create_models(
backbone_retinanet=backbone.retinanet,
num_classes=train_generator.num_classes(),
weights=weights,
multi_gpu=args.multi_gpu,
freeze_backbone=args.freeze_backbone,
lr=args.lr,
config=args.config)
# Print model design
# print(model.summary())
# print(training_model.summary())
# plot_model(model, to_file='model_plot.png', show_shapes=True, show_layer_names=True)
# exit()
# Get the number of samples in the training and validations datasets.
train_size = train_generator.size()
val_size = validation_generator.size()
print('Train on {} samples, val on {} samples, with batch size {}.'.format(
train_size, val_size, args.batch_size))
# this lets the generator compute backbone layer shapes using the actual backbone model
if 'vgg' in args.backbone or 'densenet' in args.backbone:
train_generator.compute_shapes = make_shapes_callback(model)
if validation_generator:
validation_generator.compute_shapes = train_generator.compute_shapes
# create the callbacks
callbacks = create_callbacks(
model,
training_model,
prediction_model,
validation_generator,
train_size,
[1e-6, 1e-4],
args,
)
# Use multiprocessing if workers > 0
if args.workers > 0:
use_multiprocessing = True
else:
use_multiprocessing = False
# check to see if we are attempting to find an optimal learning rate
# before training for the full number of epochs
if args.find_lr:
# initialize the learning rate finder and then train with learning
# rates ranging from 1e-10 to 1e+1
print("[INFO] Finding learning rate...")
lrf = LearningRateFinder(training_model)
lrf.find(train_generator,
1e-10,
1e+1,
stepsPerEpoch=np.ceil((train_size / float(args.batch_size))),
batchSize=args.batch_size)
# plot the loss for the various learning rates and save the
# resulting plot to disk
lrf.plot_loss()
plt.savefig("lrfind_plot.png")
# save values into a csv file
lrf.save_csv("lr_loss.csv")
# gracefully exit the script so we can adjust our learning rates
# in the config and then train the network for our full set of
# epochs
print("[INFO] Learning rate finder complete")
print("[INFO] Examine plot and adjust learning rates before training")
sys.exit(0)
# Number of epochs and steps for training new layers
n_epochs = 350
steps = train_size // args.batch_size
# start training
training_model.fit_generator(generator=train_generator,
validation_data=validation_generator,
steps_per_epoch=steps,
epochs=n_epochs,
verbose=1,
callbacks=callbacks,
workers=args.workers,
use_multiprocessing=use_multiprocessing,
max_queue_size=args.max_queue_size)
# Unfreeze and continue training, to fine-tune.
# Train longer if the result is not good.
if True:
# for layer in model.layers:
# if layer.name is 'bn_conv1':
# print("Before\t-> Trainable: {}, Freeze: {}".format(layer.trainable, layer.freeze))
for layer in model.layers:
layer.trainable = True
# recompile to apply the change
model.compile(
loss={
'regression': losses.smooth_l1(),
'classification': losses.focal()
},
# Learning rate must be lower for training the entire network
optimizer=keras.optimizers.adam(lr=args.lr * 0.1, clipnorm=0.001),
metrics=['accuracy'])
if args.multi_gpu > 1:
from keras.utils import multi_gpu_model
with tf.device('/gpu:1'):
training_model = multi_gpu_model(model, gpus=args.multi_gpu)
else:
training_model = model
# recompile to apply the change
training_model.compile(
loss={
'regression': losses.smooth_l1(),
'classification': losses.focal()
},
# Learning rate must be lower for training the entire network
optimizer=keras.optimizers.adam(lr=args.lr * 0.1, clipnorm=0.001),
metrics=['accuracy'])
print('Unfreezing all layers.')
# for layer in model.layers:
# if layer.name is 'bn_conv1':
# print("After\t-> Trainable: {}, Freeze: {}".format(layer.trainable, layer.freeze))
# Print training_model design
# print(model.summary())
# print(training_model.summary())
# create the callbacks
callbacks = create_callbacks(
model,
training_model,
prediction_model,
validation_generator,
train_size,
[1e-8, 1e-6],
args,
)
batch_size = 2 # note that more GPU memory is required after unfreezing the body
steps = train_size // batch_size
print('Train on {} samples, val on {} samples, with batch size {}.'.
format(train_size, val_size, batch_size))
training_model.fit_generator(generator=train_generator,
validation_data=validation_generator,
steps_per_epoch=steps,
epochs=args.epochs,
initial_epoch=n_epochs,
verbose=1,
callbacks=callbacks,
workers=args.workers,
use_multiprocessing=use_multiprocessing,
max_queue_size=args.max_queue_size)
def main(args=None):
# parse arguments
if args is None:
args = sys.argv[1:]
args = parse_args(args)
# create object that stores backbone information
backbone = models.backbone(args.backbone)
# make sure keras is the minimum required version
check_keras_version()
# optionally choose specific GPU
if args.gpu:
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
keras.backend.tensorflow_backend.set_session(get_session())
# optionally load config parameters
if args.config:
args.config = read_config_file(args.config)
# create the generators
train_generator, validation_generator = create_generators(args, backbone.preprocess_image)
# create the model
if args.snapshot is not None:
print('Loading model, this may take a second...')
# model = models.load_model(args.snapshot, backbone_name=args.backbone)
model = model_with_weights(backbone.fsaf(train_generator.num_classes(),
modifier=None),
weights=args.snapshot, skip_mismatch=True)
training_model = model
prediction_model = fsaf_bbox(model=model)
# compile model
training_model.compile(
loss={
'cls_loss': lambda y_true, y_pred: y_pred,
'regr_loss': lambda y_true, y_pred: y_pred,
},
# optimizer=keras.optimizers.sgd(lr=1e-5, momentum=0.9, nesterov=True, decay=1e-6)
optimizer=keras.optimizers.adam(lr=1e-5)
)
else:
weights = args.weights
# default to imagenet if nothing else is specified
if weights is None and args.imagenet_weights:
weights = backbone.download_imagenet()
print('Creating model, this may take a second...')
model, training_model, prediction_model = create_models(
# backbone_retinanet=backbone.retinanet,
backbone_retinanet=backbone.fsaf,
num_classes=train_generator.num_classes(),
weights=weights,
num_gpus=args.num_gpus,
freeze_backbone=args.freeze_backbone,
lr=args.lr,
config=args.config
)
# print model summary
# print(model.summary())
# this lets the generator compute backbone layer shapes using the actual backbone model
if 'vgg' in args.backbone or 'densenet' in args.backbone:
train_generator.compute_shapes = make_shapes_callback(model)
if validation_generator:
validation_generator.compute_shapes = train_generator.compute_shapes
# create the callbacks
callbacks = create_callbacks(
model,
training_model,
prediction_model,
validation_generator,
args,
)
if not args.compute_val_loss:
validation_generator = None
# start training
return training_model.fit_generator(
generator=train_generator,
steps_per_epoch=args.steps,
initial_epoch=9,
epochs=args.epochs,
verbose=1,
callbacks=callbacks,
workers=args.workers,
use_multiprocessing=args.multiprocessing,
max_queue_size=args.max_queue_size,
validation_data=validation_generator
)
max_num_images = images.shape[0]
images = images[:max_num_images]
image_names = image_names[:max_num_images]
image_sizes = image_sizes[:max_num_images]
y_pred = np.zeros(shape=(max_num_images, 224, 224))
num_folds = 1
print('Starting prediction for set %s with TTA set to %r with num_folds %d' % (pred_set, use_tta, num_folds))
for k_fold in range(num_folds):
print('Processing fold ', k_fold)
model_name = 'task%d_%s' % (task_idx, task1_backbone_name) #adding task 1
run_name = 'task%d_%s_k%d_v%s' % (task_idx, task1_backbone_name, k_fold, task1_version)
model = backbone(backbone_name).segmentation_model(load_from=run_name)
if use_tta:
y_pred += inv_sigmoid(task1_tta_predict(model=model, img_arr=images))[:, :, :, 0]
else:
y_pred += inv_sigmoid(model.predict(images))[:, :, :, 0]
print('Done predicting task 1-- now doing post-processing')
y_pred = y_pred / num_folds
y_pred = sigmoid(y_pred)
y_pred = task1_post_process(y_prediction=y_pred, threshold=0.5, gauss_sigma=2.)
output_dir = submission_dir + '/Output' #change name to desired folder
mkdir_if_not_exist([output_dir])
for i_image, i_name in enumerate(image_names):
max_num_images = images.shape[0]
images = images[:max_num_images]
image_names = image_names[:max_num_images]
image_sizes = image_sizes[:max_num_images]
y_pred = np.zeros(shape=(max_num_images, 224, 224))
num_folds = 5
print('Starting prediction for set %s with TTA set to %r with num_folds %d' % (pred_set, use_tta, num_folds))
for k_fold in range(num_folds):
print('Processing fold ', k_fold)
model_name = 'task%d_%s' % (task_idx, backbone_name)
run_name = 'task%d_%s_k%d_v%s' % (task_idx, backbone_name, k_fold, version)
model = backbone(backbone_name).segmentation_model(load_from=run_name)
if use_tta:
y_pred += inv_sigmoid(task1_tta_predict(model=model, img_arr=images))[:, :, :, 0]
else:
y_pred += inv_sigmoid(model.predict(images))[:, :, :, 0]
print('Done predicting -- now doing post-processing')
y_pred = y_pred / num_folds
y_pred = sigmoid(y_pred)
y_pred = task1_post_process(y_prediction=y_pred, threshold=0.5, gauss_sigma=2.)
output_dir = submission_dir + '/task1_' + pred_set
mkdir_if_not_exist([output_dir])
def main(args=None):
# parse arguments
if args is None:
args = sys.argv[1:]
args = parse_args(args)
# create object that stores backbone information
#backbone = models.backbone(args.backbone)
backbone = models.backbone(args.backbone)
# make sure keras is the minimum required version
check_keras_version()
# optionally choose specific GPU
if args.gpu:
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
keras.backend.tensorflow_backend.set_session(get_session())
# optionally load config parameters
if args.config:
args.config = read_config_file(args.config)
# create the generators
#print(args)
train_generator, validation_generator = create_generators(
args, backbone.preprocess_image)
# Log configs
#run.log('batch-size', args.batch_size)
#run.log('gamma', args.fl_gamma)
#run.log('alpha', args.fl_alpha)
#run.log('lr', args.lr)
#run.log('neg-overlap', args.neg_overlap)
#run.log('pos-overlap', args.pos_overlap)
#run.log('fpn-layers', args.fpn_layers)
if args.class_weights is not None:
if args.class_weights == "cw1":
polyp_weight = 0.25
#class_weights = {'classification': {0:a_w, 1:a_w, 2:a_w, 3:a_w, 4:a_w, 5:a_w, 6:a_w, 7:polyp_weight}, 'regression': {0:0.25, 1:0.25, 2:0.25, 3:0.25}}
#class_weights = {'classification': [polyp_weight, a_w, a_w, a_w, a_w, a_w, a_w, a_w]}
elif args.class_weights == "cw2":
polyp_weight = 0.5
elif args.class_weights == "cw3":
polyp_weight = 0.75
a_w = (1 - polyp_weight) / 7
#class_weights = {'classification': [polyp_weight, a_w, a_w, a_w, a_w, a_w, a_w, a_w]}
class_weights = [polyp_weight, a_w, a_w, a_w, a_w, a_w, a_w, a_w]
else:
class_weights = None
if args.loss_weights is None:
loss_weights = [1, 1]
elif args.loss_weights == "lw0":
loss_weights = [1, 1, 1]
elif args.loss_weights == "lw1":
loss_weights = [1, 1, 3]
elif args.loss_weights == "lw2":
loss_weights = [1, 1, 10]
elif args.loss_weights == "lw3":
loss_weights = [1, 1, 20]
# create the model
if args.snapshot is not None:
print('Loading model, this may take a second...')
model = models.load_model(os.path.join(args.data_dir, args.snapshot),
backbone_name=args.backbone)
training_model = model
anchor_params = None
if args.config and 'anchor_parameters' in args.config:
anchor_params = parse_anchor_parameters(args.config)
prediction_model = retinanet_bbox(model=model,
anchor_params=anchor_params)
else:
if args.weights is None and args.imagenet_weights:
weights = backbone.download_imagenet()
else:
weights = args.weights
# default to imagenet if nothing else is specified
## SO the file that is downloaded is actually only the weights
## this means that I should be able to use --weights to give it my own model
sample_test = np.array([[0.25, 0.25, 0.25, 0.25, 0, 0, 0, 0],
[10, 10, 10, 10, 10, 10, 10, 10]])
print('Creating model, this may take a second...')
model, training_model, prediction_model = create_models(
backbone_retinanet=backbone.retinanet,
num_classes=train_generator.num_classes(),
weights=weights,
class_weights=class_weights,
loss_weights=loss_weights,
multi_gpu=args.multi_gpu,
freeze_backbone=args.freeze_backbone,
lr=args.lr,
config=args.config,
fl_gamma=args.fl_gamma,
fl_alpha=args.fl_alpha,
c_weight=args.c_weight,
r_weight=args.r_weight,
p_weight=args.p_weight,
train_type=args.train_type,
sample_t=sample_test)
# print model summary
#print(model.summary())
# this lets the generator compute backbone layer shapes using the actual backbone model
if 'vgg' in args.backbone or 'densenet' in args.backbone:
train_generator.compute_shapes = make_shapes_callback(model)
if validation_generator:
validation_generator.compute_shapes = train_generator.compute_shapes
# create the callbacks
callbacks = create_callbacks(
model,
training_model,
prediction_model,
validation_generator,
args,
)
# Use multiprocessing if workers > 0
if args.workers > 0:
use_multiprocessing = True
else:
use_multiprocessing = False
temp_df = pd.read_csv(
os.path.join(args.data_dir, args.annotations),
names=["image_path", "x1", "y1", "x2", "y2", "object_id"])
im_count = len(set(list(temp_df.image_path)))
# start training
training_model.fit_generator(generator=train_generator,
steps_per_epoch=int(im_count /
args.batch_size),
epochs=args.epochs,
verbose=1,
callbacks=callbacks,
workers=args.workers,
use_multiprocessing=use_multiprocessing,
max_queue_size=args.max_queue_size
#class_weight=class_weights
)
# max_num_images = 10
max_num_images = images.shape[0]
images = images[:max_num_images]
image_names = image_names[:max_num_images]
num_folds = 1
print('Starting prediction for set %s with TTA set to %r with num_folds %d' % (pred_set, use_tta, num_folds))
y_pred = np.zeros(shape=(max_num_images, 7))
for k_fold in range(num_folds):
print('Processing fold ', k_fold)
run_name = 'task3_' + backbone_name + '_k' + str(k_fold) + '_v' + version
model = backbone(backbone_name).classification_model(load_from=run_name)
predictions_model = Model(inputs=model.input, outputs=model.get_layer('predictions').output)
if use_tta:
y_pred += task3_tta_predict(model=predictions_model, img_arr=images)
else:
y_pred += predictions_model.predict(images)
y_pred = y_pred / num_folds
y_prob = softmax(y_pred)
print('Done predicting -- creating submission')
for i_image, i_name in enumerate(image_names):
i_line = i_name
print(i_name)
max_prob = 0
def fit(self,
*,
timeout: float = None,
iterations: int = None) -> CallResult[None]:
"""
Creates the image generators and then trains RetinaNet model on the image paths in the input
dataframe column.
Can choose to use validation generator.
If no weight file is provided, the default is to use the ImageNet weights.
"""
# Create object that stores backbone information
self.backbone = models.backbone(self.hyperparams['backbone'])
# Set up specific GPU
# if self.hyperparams['gpu_id'] is not None:
# setup_gpu(self.hyperparams['gpu_id'])
# Create the generators
train_generator = CSVGenerator(self.annotations, self.classes,
self.base_dir,
self.hyperparams['batch_size'],
self.backbone.preprocess_image)
# Running the model
## Assign weights
if self.hyperparams['weights'] is False:
weights = None
else:
weights = self.volumes[self.hyperparams['backbone']]
## Create model
print('Creating model...', file=sys.__stdout__)
model, self.training_model, prediction_model = self._create_models(
backbone_retinanet=self.backbone.retinanet,
num_classes=train_generator.num_classes(),
weights=weights,
freeze_backbone=self.hyperparams['freeze_backbone'],
lr=self.hyperparams['learning_rate'])
#print(model.summary(), file = sys.__stdout__)
model.summary()
### !!! vgg AND densenet BACKBONES CURRENTLY NOT IMPLEMENTED !!!
## Let the generator compute the backbone layer shapes using the actual backbone model
# if 'vgg' in self.hyperparams['backbone'] or 'densenet' in self.hyperparams['backbone']:
# train_generator.compute_shapes = make_shapes_callback(model)
# if validation_generator:
# validation_generator.compute_shapes = train_generator.compute_shapes
## Set up callbacks
callbacks = self._create_callbacks(
model,
self.training_model,
prediction_model,
)
start_time = time.time()
print('Starting training...', file=sys.__stdout__)
self.training_model.fit_generator(
generator=train_generator,
steps_per_epoch=self.hyperparams['n_steps'],
epochs=self.hyperparams['n_epochs'],
verbose=1,
callbacks=callbacks,
workers=self.workers,
use_multiprocessing=self.multiprocessing,
max_queue_size=self.max_queue_size)
print(
f'Training complete. Training took {time.time()-start_time} seconds.',
file=sys.__stdout__)
return CallResult(None)
def main():
backbone = models.backbone('resnet50')
# create the generators
#train_generator, validation_generator = create_generators(args, backbone.preprocess_image)
random_transform = True
val_annotations = './data/processed/val.csv'
annotations = './data/processed/train.csv'
classes = './data/processed/classes.csv'
common_args = {
'batch_size': 8,
'image_min_side': 224,
'image_max_side': 1333,
'preprocess_image': backbone.preprocess_image,
}
# create random transform generator for augmenting training data
if random_transform:
transform_generator = random_transform_generator(
min_rotation=-0.05,
max_rotation=0.05,
min_translation=(-0.1, -0.1),
max_translation=(0.1, 0.1),
#min_shear=-0.1,
#max_shear=0.1,
min_scaling=(0.8, 0.8),
max_scaling=(1.2, 1.2),
flip_x_chance=0.5,
#flip_y_chance=0.5,
)
else:
transform_generator = random_transform_generator(flip_x_chance=0.5)
train_generator = CSVGenerator(annotations,
classes,
transform_generator=transform_generator,
**common_args)
if val_annotations:
validation_generator = CSVGenerator(val_annotations, classes,
**common_args)
else:
validation_generator = None
#train_generator, validation_generator = create_generators(args, backbone.preprocess_image)
num_classes = 1 # change
model = backbone.retinanet(num_classes, backbone='resnet50')
training_model = model
# prediction_model = retinanet_bbox(model=model)
nms = True
class_specific_filter = True
name = 'retinanet-bbox'
anchor_params = AnchorParameters.default
# compute the anchors
features = [
model.get_layer(p_name).output
for p_name in ['P3', 'P4', 'P5', 'P6', 'P7']
]
anchor = [
layers.Anchors(size=anchor_params.sizes[i],
stride=anchor_params.strides[i],
ratios=anchor_params.ratios,
scales=anchor_params.scales,
name='anchors_{}'.format(i))(f)
for i, f in enumerate(features)
]
anchors = keras.layers.Concatenate(axis=1, name='anchors')(anchor)
# we expect the anchors, regression and classification values as first output
regression = model.outputs[0] # check
classification = model.outputs[1]
# "other" can be any additional output from custom submodels, by default this will be []
other = model.outputs[2:]
# apply predicted regression to anchors
boxes = layers.RegressBoxes(name='boxes')([anchors, regression])
boxes = layers.ClipBoxes(name='clipped_boxes')([model.inputs[0], boxes])
# filter detections (apply NMS / score threshold / select top-k)
detections = layers.FilterDetections(
nms=nms,
class_specific_filter=class_specific_filter,
name='filtered_detections')([boxes, classification] + other)
outputs = detections
# construct the model
prediction_model = keras.models.Model(inputs=model.inputs,
outputs=outputs,
name=name)
# end of prediction_model = retinanet_bbox(model=model)
# compile model
training_model.compile(loss={
'regression': losses.smooth_l1(),
'classification': losses.focal()
},
optimizer=keras.optimizers.SGD(lr=1e-2,
momentum=0.9,
decay=.0001,
nesterov=True,
clipnorm=1)
# , clipnorm=0.001)
)
print(model.summary())
# start of create_callbacks
#callbacks = create_callbacks(model,training_model,prediction_model,validation_generator,args,)
callbacks = []
tensorboard_callback = None
tensorboard_callback = keras.callbacks.TensorBoard(
log_dir='',
histogram_freq=0,
batch_size=8,
write_graph=True,
write_grads=False,
write_images=False,
embeddings_freq=0,
embeddings_layer_names=None,
embeddings_metadata=None)
callbacks.append(tensorboard_callback)
evaluation = Evaluate(validation_generator,
tensorboard=tensorboard_callback,
weighted_average=False)
evaluation = RedirectModel(evaluation, prediction_model)
callbacks.append(evaluation)
makedirs('./snapshots/')
checkpoint = keras.callbacks.ModelCheckpoint(os.path.join(
'./snapshots/', '{backbone}_{dataset_type}_{{epoch:02d}}.h5'.format(
backbone='resnet50', dataset_type='csv')),
verbose=1,
save_best_only=False,
monitor="mAP",
mode='max')
checkpoint = RedirectModel(checkpoint, model)
callbacks.append(checkpoint)
callbacks.append(
keras.callbacks.ReduceLROnPlateau(monitor='loss',
factor=0.9,
patience=4,
verbose=1,
mode='auto',
min_delta=0.0001,
cooldown=0,
min_lr=0))
steps = 2500
epochs = 25
# start training
history = training_model.fit(
generator=train_generator,
steps_per_epoch=steps,
epochs=epochs,
verbose=1,
callbacks=callbacks,
)
timestr = time.strftime("%Y-%m-%d-%H%M")
history_path = os.path.join(
'./snapshots/', '{timestr}_{backbone}.csv'.format(timestr=timestr,
backbone='resnet50',
dataset_type='csv'))
pd.DataFrame(history.history).to_csv(history_path)
y_valid = y_valid[:32]
bv = BatchVisualization(images=x_train, true_labels=y_train)
bv()
num_classes = y_train.shape[1]
callbacks = config_cls_callbacks(run_name)
model = backbone(backbone_name, **backbone_options).classification_model(
input_shape=x_train.shape[1:],
num_classes=num_classes,
num_dense_layers=num_dense_layers,
num_dense_units=num_dense_units,
pooling=pooling,
dropout_rate=dropout_rate,
kernel_regularizer=dense_layer_regularizer,
save_to=run_name,
load_from=prev_run_name,
print_model_summary=True,
plot_model_summary=False,
lr=lr)
n_samples_train = x_train.shape[0]
n_samples_valid = x_valid.shape[0]
class_weights = compute_class_weights(y_train, wt_type=class_wt_type)
batch_size = 32
use_data_aug = True
horizontal_flip = True
def main(args=None):
# create object that stores backbone information
backbone = models.backbone(args.backbone)
# create the generators
train_generator, validation_generator = create_generators(
args, backbone.preprocess_image)
# create the model
if args.snapshot is not None:
print('Loading model, this may take a second...')
model = models.load_model(args.snapshot, backbone_name=args.backbone)
training_model = model
anchor_params = None
if args.config and 'anchor_parameters' in args.config:
anchor_params = parse_anchor_parameters(args.config)
prediction_model = retinanet_bbox(model=model,
anchor_params=anchor_params)
# compile model
training_model.compile(
loss={
'regression': losses.iou_loss(args.loss, args.loss_weight),
'classification': losses.focal(),
'centerness': losses.bce(),
},
optimizer=keras.optimizers.Adam(lr=1e-5)
# optimizer=keras.optimizers.sgd(lr=1e-5, momentum=0.9, decay=1e-5, nesterov=True)
)
else:
weights = args.weights
# default to imagenet if nothing else is specified
if weights is None and args.imagenet_weights:
weights = backbone.download_imagenet()
print('Creating model, this may take a second...')
model, training_model, prediction_model = create_models(
backbone_retinanet=backbone.retinanet,
num_classes=train_generator.num_classes(),
weights=weights,
num_gpus=args.num_gpus,
freeze_backbone=args.freeze_backbone,
lr=args.lr,
config=args.config,
args=args)
parallel_model = multi_gpu_model(training_model, gpus=2)
parallel_model.compile(loss={
'regression':
losses.iou_loss(args.loss, args.loss_weight),
'classification':
losses.focal(),
'centerness':
losses.bce(),
},
optimizer=keras.optimizers.Adam(lr=1e-4))
# print model summary
# print(model.summary())
# this lets the generator compute backbone layer shapes using the actual backbone model
if 'vgg' in args.backbone or 'densenet' in args.backbone:
train_generator.compute_shapes = make_shapes_callback(model)
if validation_generator:
validation_generator.compute_shapes = train_generator.compute_shapes
# create the callbacks
callbacks = create_callbacks(
model,
training_model,
prediction_model,
validation_generator,
args,
)
if not args.compute_val_loss:
validation_generator = None
# start training
parallel_model.fit_generator(generator=train_generator,
steps_per_epoch=len(train_generator),
epochs=args.epochs,
verbose=1,
callbacks=callbacks,
validation_data=validation_generator)
