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)