def _main_(args): config_path = args.conf weights_path = args.weights keras.backend.tensorflow_backend.set_session(get_session()) with open(config_path) as config_buffer: config = json.loads(config_buffer.read()) if weights_path == '': weights_path = config['train']['pretrained_weights"'] ############################### # Parse the annotations ############################### without_valid_imgs = False if config['parser_annotation_type'] == 'xml': # parse annotations of the training set train_imgs, train_labels = parse_annotation_xml( config['train']['train_annot_folder'], config['train']['train_image_folder'], config['model']['labels']) # parse annotations of the validation set, if any. if os.path.exists(config['valid']['valid_annot_folder']): valid_imgs, valid_labels = parse_annotation_xml( config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['model']['labels']) else: without_valid_imgs = True elif config['parser_annotation_type'] == 'csv': # parse annotations of the training set train_imgs, train_labels = parse_annotation_csv( config['train']['train_csv_file'], config['model']['labels'], config['train']['train_csv_base_path']) # parse annotations of the validation set, if any. if os.path.exists(config['valid']['valid_csv_file']): valid_imgs, valid_labels = parse_annotation_csv( config['valid']['valid_csv_file'], config['model']['labels'], config['valid']['valid_csv_base_path']) else: without_valid_imgs = True else: raise ValueError( "'parser_annotations_type' must be 'xml' or 'csv' not {}.".format( config['parser_annotations_type'])) #remove samples without objects in the image for i in range(len(train_imgs) - 1, 0, -1): if len(train_imgs[i]['object']) == 0: del train_imgs[i] if len(config['model']['labels']) > 0: overlap_labels = set(config['model']['labels']).intersection( set(train_labels.keys())) print('Seen labels:\t', train_labels) print('Given labels:\t', config['model']['labels']) print('Overlap labels:\t', overlap_labels) if len(overlap_labels) < len(config['model']['labels']): print( 'Some labels have no annotations! Please revise the list of labels in the config.json file!' ) return else: print('No labels are provided. Evaluate on all seen labels.') config['model']['labels'] = train_labels.keys() with open("labels.json", 'w') as outfile: json.dump({"labels": list(train_labels.keys())}, outfile) ############################### # Construct the model ############################### yolo = YOLO(backend=config['model']['backend'], input_size=(config['model']['input_size_h'], config['model']['input_size_w']), labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors'], gray_mode=config['model']['gray_mode']) ############################### # Load the pretrained weights (if any) ############################### if weights_path != '': print("Loading pre-trained weights in", weights_path) yolo.load_weights(weights_path) elif os.path.exists(config['train']['pretrained_weights']): print("Loading pre-trained weights in", config['train']['pretrained_weights']) yolo.load_weights(config['train']['pretrained_weights']) else: raise Exception("No pretrained weights found.") ############################### # Evaluate the network ############################### print("calculing mAP for iou threshold = {}".format(args.iou)) generator_config = { 'IMAGE_H': yolo.input_size[0], 'IMAGE_W': yolo.input_size[1], 'IMAGE_C': yolo.input_size[2], 'GRID_H': yolo.grid_h, 'GRID_W': yolo.grid_w, 'BOX': yolo.nb_box, 'LABELS': yolo.labels, 'CLASS': len(yolo.labels), 'ANCHORS': yolo.anchors, 'BATCH_SIZE': 4, 'TRUE_BOX_BUFFER': yolo.max_box_per_image, } if not without_valid_imgs: valid_generator = BatchGenerator(valid_imgs, generator_config, norm=yolo.feature_extractor.normalize, jitter=False) valid_eval = YOLO.MAP_evaluation(yolo, valid_generator, iou_threshold=args.iou) mAP, average_precisions = valid_eval.evaluate_mAP() for label, average_precision in average_precisions.items(): print(yolo.labels[label], '{:.4f}'.format(average_precision)) print('validation dataset mAP: {:.4f}\n'.format(mAP)) train_generator = BatchGenerator(train_imgs, generator_config, norm=yolo.feature_extractor.normalize, jitter=False) train_eval = YOLO.MAP_evaluation(yolo, train_generator, iou_threshold=args.iou) mAP, average_precisions = train_eval.evaluate_mAP() for label, average_precision in average_precisions.items(): print(yolo.labels[label], '{:.4f}'.format(average_precision)) print('training dataset mAP: {:.4f}'.format(mAP))
def train(self, train_imgs, # the list of images to train the model valid_imgs, # the list of images used to validate the model train_times, # the number of time to repeat the training set, often used for small datasets valid_times, # the number of times to repeat the validation set, often used for small datasets nb_epoch, # number of epoches learning_rate, # the learning rate batch_size, # the size of the batch warmup_bs, # number of initial batches to let the model familiarize with the new dataset object_scale, no_object_scale, coord_scale, class_scale, saved_weights_name='best_weights.h5', debug=False): self.batch_size = batch_size self.warmup_bs = warmup_bs self.object_scale = object_scale self.no_object_scale = no_object_scale self.coord_scale = coord_scale self.class_scale = class_scale self.debug = debug ############################################ # Compile the model ############################################ optimizer = Adam(lr=learning_rate, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) self.model.compile(loss=self.custom_loss, optimizer=optimizer) ############################################ # Make train and validation generators ############################################ generator_config = { 'IMAGE_H' : self.input_size, 'IMAGE_W' : self.input_size, 'GRID_H' : self.grid_h, 'GRID_W' : self.grid_w, 'BOX' : self.nb_box, 'LABELS' : self.labels, 'CLASS' : len(self.labels), 'ANCHORS' : self.anchors, 'BATCH_SIZE' : self.batch_size, 'TRUE_BOX_BUFFER' : self.max_box_per_image, } # batch generater train_batch = BatchGenerator(train_imgs, generator_config, norm=self.feature_extractor.normalize) valid_batch = BatchGenerator(valid_imgs, generator_config, norm=self.feature_extractor.normalize, jitter=False) # early stopping early_stop = EarlyStopping( monitor='val_loss', min_delta=0.001, patience=2, mode='min', verbose=1) # checkpoint saved_weights_name = "./models/" + saved_weights_name.replace(" ", "") checkpoint = ModelCheckpoint( saved_weights_name, monitor='val_loss', verbose=1, save_best_only=True, mode='min', period=1) # TensorBoard counter dir_name = "yolo_" + self.architecture tb_counter = len([log for log in os.listdir("./logs") if dir_name in log]) + 1 log_dir = "./logs/" + dir_name + "_" + str(tb_counter) # TensorBoard dir if not os.path.exists(log_dir): os.makedirs(log_dir) # TensorBoard tensorboard = TensorBoard(log_dir=log_dir, histogram_freq=0, write_graph=True, write_images=False) # model fit self.model.fit_generator(generator = train_batch, steps_per_epoch = len(train_batch) * train_times, epochs = nb_epoch, verbose = 1, validation_data = valid_batch, validation_steps = len(valid_batch) * valid_times, callbacks = [early_stop, checkpoint, tensorboard], workers = 2, max_queue_size = 8)
'BATCH_SIZE' : BATCH_SIZE, 'TRUE_BOX_BUFFER' : 50, } def normalize(image): return image / 255. train_imgs, seen_train_labels = parse_annotation(train_annot_folder, train_image_folder, labels=LABELS) ### write parsed annotations to pickle for fast retrieval next time #with open('train_imgs', 'wb') as fp: # pickle.dump(train_imgs, fp) ### read saved pickle of parsed annotations #with open ('train_imgs', 'rb') as fp: # train_imgs = pickle.load(fp) train_batch = BatchGenerator(train_imgs, generator_config, norm=normalize) valid_imgs, seen_valid_labels = parse_annotation(valid_annot_folder, valid_image_folder, labels=LABELS) ### write parsed annotations to pickle for fast retrieval next time #with open('valid_imgs', 'wb') as fp: # pickle.dump(valid_imgs, fp) ### read saved pickle of parsed annotations #with open ('valid_imgs', 'rb') as fp: # valid_imgs = pickle.load(fp) valid_batch = BatchGenerator(valid_imgs, generator_config, norm=normalize, jitter=False) """**Setup a few callbacks and start the training**""" early_stop = EarlyStopping(monitor='val_loss', min_delta=0.001,
'CLASS': len(LABELS), 'ANCHORS': ANCHORS, 'BATCH_SIZE': 2, 'TRUE_BOX_BUFFER': 50, } #Path for training data and annotations image_path = './dataset-master/train/' annot_path = './dataset-master/microanno/' #print(os.listdir(annot_path)) #train_imgs, seen_labels = parse_annotation_new(annot_path, image_path, LABELS) train_imgs, seen_labels = parse_annotation_txt(annot_path, image_path, LABELS) train_img = train_imgs[0:126] valid_img = train_imgs[126:] train_batch = BatchGenerator(train_img, generator_config, jitter=False) valid_batch = BatchGenerator(valid_img, generator_config, jitter=False) # **Setup a few callbacks and start the training** early_stop = EarlyStopping(monitor='loss', min_delta=0.001, patience=10, mode='min', verbose=1) checkpoint = ModelCheckpoint('weights_yolo_adam_validdata_temp.h5', monitor='loss', verbose=1, save_best_only=True, mode='min',
def train( self, train_imgs, # the list of images to train the model valid_imgs, # the list of images used to validate the model train_times, # the number of time to repeat the training set, often used for small datasets valid_times, # the number of times to repeat the validation set, often used for small datasets nb_epochs, # number of epoches learning_rate, # the learning rate batch_size, # the size of the batch warmup_epochs, # number of initial batches to let the model familiarize with the new dataset object_scale, no_object_scale, coord_scale, class_scale, saved_weights_name='best_weights.h5', debug=False, workers=3, max_queue_size=8, early_stop=True, custom_callback=[], tb_logdir="./"): self.batch_size = batch_size self.object_scale = object_scale self.no_object_scale = no_object_scale self.coord_scale = coord_scale self.class_scale = class_scale self.debug = debug ############################################ # Make train and validation generators ############################################ generator_config = { 'IMAGE_H': self.input_size[0], 'IMAGE_W': self.input_size[1], 'IMAGE_C': self.input_size[2], 'GRID_H': self.grid_h, 'GRID_W': self.grid_w, 'BOX': self.nb_box, 'LABELS': self.labels, 'CLASS': len(self.labels), 'ANCHORS': self.anchors, 'BATCH_SIZE': self.batch_size, 'TRUE_BOX_BUFFER': self.max_box_per_image, } train_generator = BatchGenerator(train_imgs, generator_config, norm=self.feature_extractor.normalize) valid_generator = BatchGenerator(valid_imgs, generator_config, norm=self.feature_extractor.normalize, jitter=False) self.warmup_batches = warmup_epochs * ( train_times * len(train_generator) + valid_times * len(valid_generator)) ############################################ # Compile the model ############################################ optimizer = Adam(lr=learning_rate, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) self.model.compile(loss=self.custom_loss, optimizer=optimizer) ############################################ # Make a few callbacks ############################################ early_stop_cb = EarlyStopping(monitor='val_loss', min_delta=0.001, patience=3, mode='min', verbose=1) checkpoint_cb = ModelCheckpoint(saved_weights_name, monitor='val_loss', verbose=1, save_best_only=True, mode='min', period=1) tensorboard_cb = TensorBoard( log_dir=tb_logdir, histogram_freq=0, #write_batch_performance=True, write_graph=True, write_images=False) root, ext = os.path.splitext(saved_weights_name) map_evaluator_cb = self.MAP_evaluation(self, valid_generator, save_best=True, save_name=root + "_bestMap" + ext, tensorboard=tensorboard_cb) if not isinstance(custom_callback, list): custom_callback = [custom_callback] callbacks = [checkpoint_cb, tensorboard_cb, map_evaluator_cb ] + custom_callback if early_stop: callbacks.append(early_stop_cb) ############################################ # Start the training process ############################################ self.model.fit_generator( generator=train_generator, steps_per_epoch=len(train_generator) * train_times, epochs=warmup_epochs + nb_epochs, verbose=2 if debug else 1, validation_data=valid_generator, validation_steps=len(valid_generator) * valid_times, callbacks=callbacks, workers=workers, max_queue_size=max_queue_size)
# define paths for training valid_image_folder = 'data/Validation_Images/' valid_annot_folder = 'data/Validation_Annotations/' # define normalize for images def normalize(image): return image / 255. # define the image and label datasets for training valid_imgs, valid_labels = parse_annotation(valid_annot_folder, valid_image_folder, labels=LABELS) valid_generator = BatchGenerator(valid_imgs, generator_config, norm=normalize, jitter=False) # load new model from training model = load_model('new_model_6.h5', custom_objects={ 'tf': tf, 'custom_loss': custom_loss }) average_precisions = evaluate(model, valid_generator) # print evaluation print('mAP: {:.4f}'.format( sum(average_precisions.values()) / len(average_precisions)))
def train(self, train_imgs, valid_imgs, train_times, valid_times, object_scale, no_object_scale, coord_scale, class_scale, nb_epochs, learning_rate, batch_size, warmup_epochs, multi_gpu, saved_weights_dir, save_every_n_epoch, debug): self.batch_size = batch_size self.multi_gpu = multi_gpu self.object_scale = object_scale self.no_object_scale = no_object_scale self.coord_scale = coord_scale self.class_scale = class_scale self.debug = debug if self.multi_gpu: self.model = multi_gpu_model(self.model, gpus=2) ############################################ # Make train and validation generators ############################################ generator_config = { 'IMAGE_H': self.input_size, 'IMAGE_W': self.input_size, 'GRID_H': self.grid_h, 'GRID_W': self.grid_w, 'BOX': self.nb_box, 'LABELS': self.labels, 'CLASS': len(self.labels), 'ANCHORS': self.anchors, 'BATCH_SIZE': self.batch_size, 'TRUE_BOX_BUFFER': self.max_box_per_image, } train_generator = BatchGenerator(train_imgs, generator_config, norm=self.feature_extractor.normalize) valid_generator = BatchGenerator(valid_imgs, generator_config, norm=self.feature_extractor.normalize, jitter=False) self.warmup_batches = warmup_epochs * ( train_times * len(train_generator) + valid_times * len(valid_generator)) ############################################ # Compile the model ############################################ optimizer = Adam(lr=learning_rate, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) self.model.compile(loss=self.custom_loss, optimizer=optimizer, metrics=['accuracy', self.recall_metric]) ############################################ # Make a few callbacks ############################################ monitor_metric, metric_mode = 'val_recall', 'max' early_stop = EarlyStopping(monitor=monitor_metric, min_delta=0.0001, patience=20, mode=metric_mode, verbose=1) reduce_lrt = ReduceLROnPlateau(monitor=monitor_metric, verbose=1, patience=5, mode=metric_mode, min_lr=1e-07, factor=0.8) CheckpointModel = ModelCheckpointDetached if self.multi_gpu else ModelCheckpoint if not os.path.exists(saved_weights_dir): os.mkdir(saved_weights_dir) checkpoint = CheckpointModel(os.path.join( saved_weights_dir, 'weights.{epoch:02d}-{val_loss:.2f}.h5'), monitor=monitor_metric, verbose=1, save_best_only=False, save_weights_only=True, mode=metric_mode, period=save_every_n_epoch) backend_name = self.backend.replace(' ', '_').lower() tb_counter = len([ log for log in os.listdir(os.path.expanduser('~/logs/')) if backend_name in log ]) + 1 tensorboard = TensorBoard(log_dir=os.path.expanduser('~/logs/') + backend_name + '_' + str(tb_counter), histogram_freq=0, batch_size=self.batch_size, write_graph=True, write_images=True) ############################################ # Start the training process ############################################ self.model.fit_generator( generator=train_generator, steps_per_epoch=len(train_generator) * train_times, epochs=warmup_epochs + nb_epochs, verbose=1 if debug else 2, validation_data=valid_generator, validation_steps=len(valid_generator) * valid_times, callbacks=[ early_stop, reduce_lrt, TerminateOnNaN(), checkpoint, tensorboard ], workers=8, initial_epoch=0, use_multiprocessing=False, max_queue_size=8) ############################################ # Compute mAP on the validation set ############################################ average_precisions = self.evaluate(valid_generator) # print evaluation for label, average_precision in average_precisions.items(): print(self.labels[label], '{:.4f}'.format(average_precision)) print('mAP: {:.4f}'.format( sum(average_precisions.values()) / len(average_precisions)))
def _main_(args): config_path = args.conf weights_path = args.weights with open(config_path) as config_buffer: config = json.load(config_buffer) # parse annotations of the validation set, if any, otherwise raise an error if os.path.exists(config['valid']['valid_annot_folder']): valid_imgs, valid_labels = parse_annotation( config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['model']['labels']) else: print('Folder ' + config['valid']['valid_annot_folder'] + 'does not exist') ############################### # Make the model ############################### yolo = YOLO(backend=config['model']['backend'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) ############################### # Load trained weights ############################### yolo.load_weights(weights_path) ############################################ # Make validation generators ############################################ generator_config = { 'IMAGE_H': yolo.input_size, 'IMAGE_W': yolo.input_size, 'GRID_H': yolo.grid_h, 'GRID_W': yolo.grid_w, 'BOX': yolo.nb_box, 'LABELS': yolo.labels, 'CLASS': len(yolo.labels), 'ANCHORS': yolo.anchors, 'BATCH_SIZE': config['train']['batch_size'], 'TRUE_BOX_BUFFER': yolo.max_box_per_image, } valid_generator = BatchGenerator(valid_imgs, generator_config, norm=yolo.feature_extractor.normalize, jitter=False) ############################################ # Compute mAP on the validation set ############################################ average_precisions = yolo.evaluate(valid_generator) # print evaluation for label, average_precision in average_precisions.items(): print(yolo.labels[label], '{:.4f}'.format(average_precision)) print('mAP: {:.4f}'.format( sum(average_precisions.values()) / len(average_precisions)))
yolo = YOLO(backend=config['model']['backend'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) yolo.load_weights(config['train']['pretrained_weights']) generator_config = { 'IMAGE_H': config['model']['input_size'], 'IMAGE_W': config['model']['input_size'], 'GRID_H': config['model']['input_size'] // 32, 'GRID_W': config['model']['input_size'] // 32, 'BOX': len(config['model']['anchors']), 'LABELS': config['model']['labels'], 'CLASS': len(config['model']['labels']), 'ANCHORS': config['model']['anchors'], 'BATCH_SIZE': 1, 'TRUE_BOX_BUFFER': config['model']['max_box_per_image'], } val_generator = BatchGenerator( valid_imgs, generator_config, norm=normalize, flipflop=False, shoechanger=False, zeropad=False, ) yolo.evaluate(val_generator)
def train( self, train_imgs, # list of images to train the model valid_imgs, # list of images used to validate the model train_times, # number of time to repeat the training set, often used for small datasets valid_times, # number of times to repeat the validation set, often used for small datasets nb_epoch, # number of epoches learning_rate, # learning rate batch_size, # size of the batch warmup_bs, # number of initial batches to let the model familiarize with the new dataset object_scale, no_object_scale, coord_scale, class_scale, saved_weights_name='best_weights.h5', debug=False): self.batch_size = batch_size self.warmup_bs = warmup_bs self.object_scale = object_scale self.no_object_scale = no_object_scale self.coord_scale = coord_scale self.class_scale = class_scale self.debug = debug ############################################ # Compile the model ############################################ optimizer = Adam(lr=learning_rate, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) self.model.compile(loss=self.custom_loss, optimizer=optimizer) ############################################ # Make train and validation generators ############################################ generator_config = { 'IMAGE_H': self.input_size, 'IMAGE_W': self.input_size, 'GRID_H': self.grid_h, 'GRID_W': self.grid_w, 'BOX': self.nb_box, 'LABELS': self.labels, 'CLASS': len(self.labels), 'ANCHORS': self.anchors, 'BATCH_SIZE': self.batch_size, 'TRUE_BOX_BUFFER': self.max_box_per_image, } train_batch = BatchGenerator(train_imgs, generator_config, norm=self.feature_extractor.normalize) valid_batch = BatchGenerator(valid_imgs, generator_config, norm=self.feature_extractor.normalize, jitter=False) ############################################ # Make a few callbacks ############################################ date = datetime.today().strftime('%m-%d_%H%M') os.mkdir(os.path.join('logs', date)) """ early_stop = EarlyStopping(monitor='val_loss', patience=3, mode='min', verbose=1) """ checkpoint = ModelCheckpoint(saved_weights_name, monitor='val_loss', save_best_only=True, mode='min', period=1) tensorboard = TensorBoard(log_dir=os.path.join('logs', date), histogram_freq=1, write_graph=False, write_images=True, write_grads=True) reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=3, min_lr=5e-7) pauser = TrainPauseCallback() self.pauser = pauser ############################################ # Start the training process ############################################ self.model.fit_generator( generator=train_batch, steps_per_epoch=len(train_batch) * train_times, epochs=nb_epoch, verbose=1, validation_data=valid_batch, validation_steps=len(valid_batch) * valid_times, callbacks=[reduce_lr, checkpoint, tensorboard, pauser], workers=3, max_queue_size=8)
def train( self, train_imgs, # the list of images to train the model valid_imgs, # the list of images used to validate the model train_times, # the number of time to repeat the training set, often used for small datasets valid_times, # the number of times to repeat the validation set, often used for small datasets nb_epoch, # number of epoches learning_rate, # the learning rate batch_size, # the size of the batch warmup_epochs, # number of initial batches to let the model familiarize with the new dataset object_scale, no_object_scale, coord_scale, class_scale, logdir, saving_freq, saved_weights_name='weights.h5', debug=False): self.batch_size = batch_size self.warmup_bs = warmup_epochs * (train_times * (len(train_imgs) / batch_size + 1) + valid_times * (len(valid_imgs) / batch_size + 1)) self.object_scale = object_scale self.no_object_scale = no_object_scale self.coord_scale = coord_scale self.class_scale = class_scale self.debug = debug if warmup_epochs > 0: nb_epoch = warmup_epochs # if it's warmup stage, don't train more than warmup_epochs ############################################ # Compile the model ############################################ optimizer = Adam(lr=learning_rate, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) self.model.compile(loss=self.custom_loss, metrics=['accuracy', self.custom_loss], optimizer=optimizer) ############################################ # Make train and validation generators ############################################ generator_config = { 'IMAGE_H': self.input_size[1], 'IMAGE_W': self.input_size[0], 'GRID_H': self.grid_h, 'GRID_W': self.grid_w, 'BOX': self.nb_box, 'LABELS': self.labels, 'CLASS': len(self.labels), 'ANCHORS': self.anchors, 'BATCH_SIZE': self.batch_size, 'TRUE_BOX_BUFFER': self.max_box_per_image, } #Добавим информацию для графиков train_batch = BatchGenerator(train_imgs, generator_config, norm=self.feature_extractor.normalize) valid_batch = BatchGenerator(valid_imgs, generator_config, norm=self.feature_extractor.normalize, jitter=False) ############################################ # Make a few callbacks ############################################ early_stop = EarlyStopping( monitor='val_loss', min_delta=0.00005, #0.0008 patience=5, mode='min', verbose=1) checkpoint_best = ModelCheckpoint(logdir + saved_weights_name + '.hdf5', monitor='val_loss', verbose=1, save_best_only=True, save_weights_only=True, mode='min', period=1) tensorboard = TensorBoard(log_dir=os.path.expanduser(logdir), histogram_freq=0, write_graph=False, write_grads=False, write_images=False) # моё добавление https://keras.io/callbacks/#modelcheckpoint reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=3, min_lr=1e-5, verbose=1) time_callback = TimeCallback(logdir=logdir) csv_logger = CSVLogger('log.csv', append=True, separator=';') my_callbacks = [ checkpoint_best, tensorboard, reduce_lr, time_callback, csv_logger ] if saving_freq > 0: checkpoint_period = ModelCheckpoint(logdir + 'weights{epoch:03d}.hdf5', monitor='val_loss', verbose=1, save_best_only=False, save_weights_only=True, mode='min', period=saving_freq) my_callbacks.append(checkpoint_period) ############################################ # Start the training process ############################################ self.model.fit_generator( generator=train_batch, steps_per_epoch=len(train_batch) * train_times, epochs=nb_epoch, verbose=1, validation_data=valid_batch, validation_steps=len(valid_batch) * valid_times, callbacks=my_callbacks, workers=3, max_queue_size=8)
def train(self, train_imgs, valid_imgs, train_times, valid_times, nb_epochs, learning_rate, batch_size, warmup_epochs, object_scale, no_object_scale, coord_scale, class_scale, saved_weights_name="best_weights.h5", train=True): self.batch_size = batch_size self.object_scale = object_scale self.no_object_scale = no_object_scale self.coord_scale = coord_scale self.class_scale = class_scale generator_config = { "IMAGE_H": self.input_size, "IMAGE_W": self.input_size, "GRID_H": self.grid_h, "GRID_W": self.grid_w, "BOX": self.nb_box, "LABELS": self.labels, "CLASS": len(self.labels), "ANCHORS": self.anchors, "BATCH_SIZE": self.batch_size, "TRUE_BOX_BUFFER": self.max_box_per_img } train_generator = BatchGenerator(train_imgs, generator_config, norm=self.feature_extractor.normalize) valid_generator = BatchGenerator(valid_imgs, generator_config, norm=self.feature_extractor.normalize) self.model.compile(loss=self.custom_loss, optimizer="adam") early_stopping = EarlyStopping(monitor="loss", patience=20, mode="min", verbose=1) checkpoint = ModelCheckpoint(saved_weights_name, monitor="loss", verbose=1, save_best_only=False, mode="min") if train: self.model.fit_generator( generator=train_generator, steps_per_epoch=len(train_generator) * train_times, epochs=nb_epochs, validation_data=valid_generator, validation_steps=len(valid_generator) * valid_times, callbacks=[early_stopping, checkpoint])
def train(self, image_fps, image_annotations, number_of_images_to_use=20, use_all_imgs=False): if use_all_imgs: image_fps_list = list(image_fps) else: image_fps_list = list(image_fps[:number_of_images_to_use]) # split dataset into training vs. validation dataset # split ratio is set to 0.9 vs. 0.1 (train vs. validation, respectively) sorted(image_fps_list) random.seed(42) random.shuffle(image_fps_list) validation_split = 0.1 split_index = int((1 - validation_split) * len(image_fps_list)) image_fps_train = image_fps_list[:split_index] image_fps_val = image_fps_list[split_index:] image_annotations_train = { k: v for k, v in image_annotations.items() if k in image_fps_train } image_annotations_val = { k: v for k, v in image_annotations.items() if k in image_fps_val } train_generator = BatchGenerator(self.config, image_fps_train, image_annotations_train) test_generator = BatchGenerator(self.config, image_fps_val, image_annotations_val) optimizer = Adam(lr=0.5e-8, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) # optimizer = SGD(lr=1e-4, decay=0.0005, momentum=0.9) # optimizer = RMSprop(lr=1e-4, rho=0.9, epsilon=1e-08, decay=0.0) file_path = "weights-improvement-{epoch:02d}-{val_acc:.2f}.hdf5" self.model.compile(loss=self.custom_loss, optimizer=optimizer, metrics=['accuracy']) checkpoint = ModelCheckpoint(file_path, monitor='val_acc', verbose=1, save_best_only=True, mode='max') self.model.fit_generator(train_generator, steps_per_epoch=len(train_generator), epochs=10000, verbose=1, validation_data=test_generator, validation_steps=len(test_generator), callbacks=[checkpoint])
def eval( self, valid_imgs, # the list of images to train the model test_imgs, # the list of images used to validate the model learning_rate, # the learning rate batch_size, # the size of the batch object_scale, no_object_scale, coord_scale, class_scale, debug=False): self.batch_size = batch_size self.object_scale = object_scale self.no_object_scale = no_object_scale self.coord_scale = coord_scale self.class_scale = class_scale self.debug = debug ############################################ # Make train and validation generators ############################################ generator_config = { 'IMAGE_H': self.input_size, 'IMAGE_W': self.input_size, 'GRID_H': self.grid_h, 'GRID_W': self.grid_w, 'BOX': self.nb_box, 'LABELS': self.labels, 'CLASS': len(self.labels), 'ANCHORS': self.anchors, 'BATCH_SIZE': self.batch_size, 'TRUE_BOX_BUFFER': self.max_box_per_image, } valid_generator = BatchGenerator(valid_imgs, generator_config, norm=self.feature_extractor.normalize, jitter=False) test_generator = BatchGenerator(test_imgs, generator_config, norm=self.feature_extractor.normalize, jitter=False) self.warmup_batches = 0 ############################################ # Compile the model ############################################ optimizer = Adam(lr=learning_rate, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) self.model.compile(loss=self.custom_loss, optimizer=optimizer) ############################################ # Make a few callbacks ############################################ # early_stop = EarlyStopping(monitor='val_loss', # min_delta=0.0001, # patience=5, # mode='min', # verbose=1) # checkpoint = ModelCheckpoint(saved_weights_name, # monitor='val_loss', # verbose=1, # save_best_only=True, # mode='min', # period=1) # tensorboard = TensorBoard(log_dir=os.path.expanduser('./logs/'), # histogram_freq=0, # #write_batch_performance=True, # write_graph=True, # write_images=False) ############################################ # Start the training process ############################################ # self.model.fit_generator(generator = train_generator, # steps_per_epoch = len(train_generator) * train_times, # epochs = warmup_epochs + nb_epochs, # verbose = 2 if debug else 1, # validation_data = valid_generator, # validation_steps = len(valid_generator) * valid_times, # callbacks = [early_stop, checkpoint, tensorboard], # workers = 3, # max_queue_size = 8) ############################################ # Compute mAP on the validation set ############################################ print() print('Valid Evaluate') average_precisions, timeHistory = self.evaluate(valid_generator) # print evaluation for label, average_precision in average_precisions.items(): print(self.labels[label], '{:.4f}'.format(average_precision)) print('Valid mAP: {:.4f}'.format( sum(average_precisions.values()) / len(average_precisions))) print() print('Total Images: ', len(timeHistory)) print('Elapse Time: {:.4f}'.format(sum(timeHistory))) print('Avg Image Time: {:.4f}'.format( sum(timeHistory) / len(timeHistory))) print('FPS: ', int(1 / (sum(timeHistory) / len(timeHistory)))) print() print('Test Evaluate') average_precisions, timeHistory = self.evaluate(test_generator) # print evaluation for label, average_precision in average_precisions.items(): print(self.labels[label], '{:.4f}'.format(average_precision)) print('Test mAP: {:.4f}'.format( sum(average_precisions.values()) / len(average_precisions))) timeHistory = timeHistory[1:] print() print('Total Images: ', len(timeHistory)) print('Elapse Time: {:.4f}'.format(sum(timeHistory))) print('Avg Image Time: {:.4f}'.format(statistics.mean(timeHistory))) print('Desvio Padrão: {:.4f}'.format(statistics.stdev(timeHistory))) print('FPS: ', int(1 / (sum(timeHistory) / len(timeHistory))))
def train(self, train_imgs, valid_imgs, train_times, # the number of time to repeat the training set, often used for small datasets valid_times, # the number of times to repeat the validation set, often used for small datasets nb_epochs, # number of epoches learning_rate, # the learning rate batch_size, # the size of the batch warmup_epochs, # number of initial batches to let the model familiarize with the new dataset object_scale, no_object_scale, coord_scale, class_scale, full_log_dir, early_stop_patience, early_stop_min_delta, learning_rate_decay_factor, learning_rate_decay_patience, learning_rate_decay_min_lr, saved_weights_name='best_weights.h5', debug=False, sequence_length=10): self.batch_size = batch_size self.sequence_length = sequence_length self.object_scale = object_scale self.no_object_scale = no_object_scale self.coord_scale = coord_scale self.class_scale = class_scale self.debug = debug self.full_log_dir = full_log_dir self.early_stop_patience = early_stop_patience self.early_stop_min_delta = early_stop_min_delta self.learning_rate_decay_factor = learning_rate_decay_factor self.learning_rate_decay_patience = learning_rate_decay_patience self.learning_rate_decay_min_lr = learning_rate_decay_min_lr ############################################ # Make train and validation generators ############################################ generator_config = { 'IMAGE_H' : self.input_size, 'IMAGE_W' : self.input_size, 'GRID_H' : self.grid_h, 'GRID_W' : self.grid_w, 'BOX' : self.nb_box, 'LABELS' : self.labels, 'CLASS' : len(self.labels), 'ANCHORS' : self.anchors, 'BATCH_SIZE' : self.batch_size, 'TRUE_BOX_BUFFER' : self.max_box_per_image, 'SEQUENCE_LENGTH' : self.sequence_length } train_generator = BatchGenerator(train_imgs, generator_config, norm=self.feature_extractor.normalize, debug=self.debug) valid_generator = BatchGenerator(valid_imgs, generator_config, norm=self.feature_extractor.normalize, jitter=False) self.warmup_batches = warmup_epochs * (train_times*len(train_generator) + valid_times*len(valid_generator)) / 4 print("Using %d warmup batches" % self.warmup_batches) ############################################ # Define your callbacks ############################################ #HS HSS With a patience of 100 you finish in 200 epochs so I changed it to 400 early_stop = EarlyStopping(monitor='val_loss', min_delta=self.early_stop_min_delta, patience=self.early_stop_patience , verbose=1) #This didnt work with multi gpu checkpoint = ModelCheckpoint('{name}_{{epoch:02d}}.h5'.format(name=saved_weights_name), monitor='val_loss', verbose=0, save_best_only=True, mode='min', period=1) # define by Anuar because above didn't work with multi GPU checkpoint_multi = MultiGPUCheckpoint( '{name}_{{epoch:02d}}_multi.h5'.format(name=saved_weights_name), verbose=1, save_best_only=True, mode='min', period=1) #defined by hs for best val checkpoint_multi_hs = MultiGPUCheckpoint( '{name}_{{epoch:02d}}_hsBb_valLoss-{{val_loss:.2f}}.h5'.format(name=saved_weights_name), verbose=1, save_best_only=True,) #defined by HS # HS HSS originally i used monitor='val_loss', factor=0.5, patience=20, min_lr=1e-6 reduce_lr_hs = ReduceLROnPlateau(monitor='val_loss', factor=self.learning_rate_decay_factor, patience=self.learning_rate_decay_patience, min_lr=self.learning_rate_decay_min_lr) # written by Anuar evaluate_callback_train = EvaluateCallback(train_generator, self.evaluate) evaluate_callback_val = EvaluateCallback(valid_generator, self.evaluate) # written by Anuar decay_lr = DecayLR(27, 31, 0.2) optimizer = Adam(lr=learning_rate, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) ############################################ # Compile the model ############################################ with tf.device("/cpu:0"): self.model.compile(loss=self.custom_loss, optimizer=optimizer) ############################################ # Start the training process ############################################ steps_per_epoch = len(train_generator) * train_times parallel_model = multi_gpu_model(self.model, gpus=2) parallel_model.compile(loss=self.custom_loss, optimizer=optimizer) parallel_model.fit_generator( generator=train_generator, steps_per_epoch = steps_per_epoch, epochs = warmup_epochs + nb_epochs, verbose = 2 if debug else 1, validation_data = valid_generator, validation_steps = len(valid_generator) * valid_times, callbacks = [ early_stop, checkpoint_multi_hs, TrainValTensorBoard_HS(self.full_log_dir, write_graph=False, write_images=True), ValOnlyProgbarLogger(verbose=1, count_mode='steps'), reduce_lr_hs, evaluate_callback_val], workers = 4, max_queue_size = 10, use_multiprocessing=True) self.model.save(saved_weights_name + "_final.h5") ############################################ # Compute mAP on the validation set ############################################ average_precisions = self.evaluate(valid_generator, iou_threshold=0.5, score_threshold=0.5) for label, average_precision in list(average_precisions.items()): print(self.labels[label], '{:.4f}'.format(average_precision)) print('mAP: {:.4f}'.format(sum(average_precisions.values()) / len(average_precisions))) average_precisions = self.evaluate(valid_generator, iou_threshold=0.3, score_threshold=0.3) for label, average_precision in list(average_precisions.items()): print(self.labels[label], '{:.4f}'.format(average_precision)) print('mAP: {:.4f}'.format(sum(average_precisions.values()) / len(average_precisions)))
def train(self, train_imgs, # the list of images to train the model valid_imgs, # the list of images used to validate the model nb_epochs, # number of epoches learning_rate, # the learning rate batch_size, # the size of the batch object_scale, no_object_scale, coord_scale, class_scale, saved_weights_name='best_weights.h5', debug=False): self.batch_size = batch_size self.object_scale = object_scale self.no_object_scale = no_object_scale self.coord_scale = coord_scale self.class_scale = class_scale self.debug = debug ############################################ # Make train and validation generators ############################################ generator_config = { 'IMAGE_H' : self.input_size, 'IMAGE_W' : self.input_size, 'GRID_H' : self.grid_h, 'GRID_W' : self.grid_w, 'BOX' : self.nb_box, 'LABELS' : self.labels, 'CLASS' : len(self.labels), 'ACTIONS' : self.actions, 'MOVES' : len(self.actions), 'ANCHORS' : self.anchors, 'BATCH_SIZE' : self.batch_size, 'TRUE_BOX_BUFFER' : self.max_box_per_image, } train_generator = BatchGenerator(train_imgs, generator_config, norm=self.feature_extractor.normalize) valid_generator = BatchGenerator(valid_imgs, generator_config, norm=self.feature_extractor.normalize, jitter=False) ############################################ # Compile the model ############################################ optimizer = Adam(lr=learning_rate, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) self.model.compile(loss=self.losses, loss_weights=self.lossWeights, optimizer=optimizer) ############################################ # Make a few callbacks ############################################ early_stop = EarlyStopping(monitor='val_loss', min_delta=0.001, patience=3, mode='min', verbose=1) checkpoint = ModelCheckpoint(saved_weights_name, monitor='val_loss', verbose=1, save_best_only=True, mode='min', period=1) tensorboard = TensorBoard(log_dir=os.path.expanduser('~/logs/'), histogram_freq=0, #write_batch_performance=True, write_graph=True, write_images=False) ############################################ # Start the training process ############################################ self.model.fit_generator(generator = train_generator, steps_per_epoch = len(train_generator), epochs = nb_epochs, verbose = 2 if debug else 1, validation_data = valid_generator, validation_steps = len(valid_generator), callbacks = [early_stop, checkpoint, tensorboard])
s_train_val_split = int(0.8 * len(sup)) train_sup = sup[:s_train_val_split] #model val_sup = sup[s_train_val_split:] #model # splits # sup_train_imgs = train_imgs[:SUP_NUM_IMAGES] # # split the training set (supervised date) into train and validation 80%, 20% respectively: # train = sup_train_imgs[:int(SUP_NUM_IMAGES*0.8)] # val = sup_train_imgs[-int(SUP_NUM_IMAGES*0.2):] #takes the last 20% images from the training # ae_unsup = train_imgs[-UNSUP_NUM_IMAGES:] # ae_train = ae_unsup[:int(UNSUP_NUM_IMAGES*0.8)] # ae_val = ae_unsup[-int(UNSUP_NUM_IMAGES*0.2):] train_batch = BatchGenerator(train_sup, generator_config, norm=normalize) valid_batch = BatchGenerator(val_sup, generator_config, norm=normalize, jitter=False) #for the AE: """we use the unsupervised data to train the AE (which we get from the end of the training set""" #todo: play with the jitter -- input true output false tohar_train_batch = ToharGenerator( train, generator_config, norm=normalize, jitter=False) # outputs (input,input) rather than (input, ground truth) tohar_valid_batch = ToharGenerator( valid, generator_config, norm=normalize, jitter=False) # outputs (input,input) rather than (input, ground truth)
all_imgs = all_imgs[:10] train_valid_split = int(0.8 * len(all_imgs)) #train-sup,un , val, eval train = all_imgs[:train_valid_split] not_train = all_imgs[train_valid_split:] sup = train[:int(SUP * len(train))] unsup = train[int(SUP * len(train)):] val = not_train[:int(0.5 * len(not_train))] eval = not_train[int(0.5 * len(not_train)):] if len(eval) == 0: raise () #todo: normalize? train_batch = BatchGenerator(sup, generator_config, norm=normalize) valid_batch = BatchGenerator(val, generator_config, norm=normalize, jitter=False) ae_train_batch = ToharGenerator( train, generator_config, norm=normalize, jitter=False ) #AE trained on all of the train set (supervised and unsupervised) ae_valid_batch = ToharGenerator(val, generator_config, norm=normalize, jitter=False) eval_batch = BatchGenerator(eval, generator_config, norm=normalize,
annotated_imgs += [(row.dict) for index, row in df[(df['fish_number'].notnull()) & ( ~df.video_id.isin(list(cpt_zero.keys())))].iterrows()] blank_imgs = random.sample(blank_imgs, int(len(blank_imgs) * (1 - REMOVE_NEGATIVE_ITEMS))) all_imgs = annotated_imgs + blank_imgs train_imgs, valid_imgs = train_test_split(all_imgs, test_size=VALID_SHARE, random_state=42) del all_imgs, blank_imgs, annotated_imgs, df train_batch = BatchGenerator(train_imgs, generator_config, jitter=False, aug_freq=AUG_FREQ) valid_batch = BatchGenerator(valid_imgs, generator_config, jitter=False, aug_freq=AUG_FREQ) early_stop = EarlyStopping(monitor='val_loss', min_delta=0.001, patience=3, mode='min', verbose=1) checkpoint = ModelCheckpoint('weights/yolo_fish_3.h5', monitor='val_loss', verbose=1,
def train( self, train_imgs, # the list of images to train the model valid_imgs, # the list of images used to validate the model train_times, # the number of time to repeat the training set, often used for small datasets valid_times, # the number of times to repeat the validation set, often used for small datasets nb_epochs, # number of epoches learning_rate, # the learning rate batch_size, # the size of the batch warmup_epochs, # number of initial batches to let the model familiarize with the new dataset object_scale, no_object_scale, coord_scale, class_scale, saved_weights_name='best_weights.h5', debug=False): self.batch_size = batch_size self.object_scale = object_scale self.no_object_scale = no_object_scale self.coord_scale = coord_scale self.class_scale = class_scale self.debug = debug ############################################ # Make train and validation generators ############################################ generator_config = { 'IMAGE_H': self.input_size, 'IMAGE_W': self.input_size, 'GRID_H': self.grid_h, 'GRID_W': self.grid_w, 'BOX': self.nb_box, 'LABELS': self.labels, 'CLASS': len(self.labels), 'ANCHORS': self.anchors, 'BATCH_SIZE': self.batch_size, 'TRUE_BOX_BUFFER': self.max_box_per_image, } train_generator = BatchGenerator(train_imgs, generator_config, norm=self.feature_extractor.normalize) valid_generator = BatchGenerator(valid_imgs, generator_config, norm=self.feature_extractor.normalize, jitter=False) self.warmup_batches = warmup_epochs * ( train_times * len(train_generator) + valid_times * len(valid_generator)) ############################################ # Compile the model ############################################ optimizer = Adam(lr=learning_rate, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) self.model.compile(loss=self.custom_loss, optimizer=optimizer) ############################################ # Make a few callbacks ############################################ early_stop = EarlyStopping(monitor='val_loss', min_delta=0.001, patience=3, mode='min', verbose=1) checkpoint = ModelCheckpoint(saved_weights_name, monitor='val_loss', verbose=1, save_best_only=True, mode='min', period=1) tensorboard = TensorBoard( log_dir=os.path.expanduser('~/logs_2018_04_30/'), histogram_freq=0, #write_batch_performance=True, write_graph=True, write_images=False) ############################################ # Start the training process ############################################ run_meta = tf.RunMetadata() with tf.contrib.tfprof.ProfileContext( '/home/ubuntu/keras_tf/tain_log') as pctx: # High level API, such as slim, Estimator, etc. self.model.fit_generator( generator=train_generator, steps_per_epoch=len(train_generator) * train_times, epochs=warmup_epochs + nb_epochs, verbose=2 if debug else 1, validation_data=valid_generator, validation_steps=len(valid_generator) * valid_times, callbacks=[early_stop, checkpoint, tensorboard], workers=3, max_queue_size=8) #Profiling ... opts = tf.profiler.ProfileOptionBuilder.float_operation() flops = tf.profiler.profile(run_meta=run_meta, cmd='scope', options=opts) opts = tf.profiler.ProfileOptionBuilder.trainable_variables_parameter( ) params = tf.profiler.profile(run_meta=run_meta, cmd='scope', options=opts) print("{:,} --- {:,}".format(flops.total_float_ops, params.total_parameters)) ############################################ # Compute mAP on the validation set ############################################ average_precisions = self.evaluate(valid_generator) # print evaluation evlog = "eval_" + ".log" with open(evlog, 'w') as ef: for label, average_precision in average_precisions.items(): print(self.labels[label], '{:.4f}'.format(average_precision), file=ef) print('mAP: {:.4f}'.format( sum(average_precisions.values()) / len(average_precisions)), file=ef)
def makemodel(): # Layer 1 x = Conv2D(32, (3,3), strides=(1,1), padding='same', name='conv_1', use_bias=False)(input_image) x = BatchNormalization(name='norm_1')(x) x = LeakyReLU(alpha=0.1)(x) x = MaxPooling2D(pool_size=(2, 2))(x) # Layer 2 x = Conv2D(64, (3,3), strides=(1,1), padding='same', name='conv_2', use_bias=False)(x) x = BatchNormalization(name='norm_2')(x) x = LeakyReLU(alpha=0.1)(x) x = MaxPooling2D(pool_size=(2, 2))(x) # Layer 3 x = Conv2D(128, (3,3), strides=(1,1), padding='same', name='conv_3', use_bias=False)(x) x = BatchNormalization(name='norm_3')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 4 x = Conv2D(64, (1,1), strides=(1,1), padding='same', name='conv_4', use_bias=False)(x) x = BatchNormalization(name='norm_4')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 5 x = Conv2D(128, (3,3), strides=(1,1), padding='same', name='conv_5', use_bias=False)(x) x = BatchNormalization(name='norm_5')(x) x = LeakyReLU(alpha=0.1)(x) x = MaxPooling2D(pool_size=(2, 2))(x) # Layer 6 x = Conv2D(256, (3,3), strides=(1,1), padding='same', name='conv_6', use_bias=False)(x) x = BatchNormalization(name='norm_6')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 7 x = Conv2D(128, (1,1), strides=(1,1), padding='same', name='conv_7', use_bias=False)(x) x = BatchNormalization(name='norm_7')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 8 x = Conv2D(256, (3,3), strides=(1,1), padding='same', name='conv_8', use_bias=False)(x) x = BatchNormalization(name='norm_8')(x) x = LeakyReLU(alpha=0.1)(x) x = MaxPooling2D(pool_size=(2, 2))(x) # Layer 9 x = Conv2D(512, (3,3), strides=(1,1), padding='same', name='conv_9', use_bias=False)(x) x = BatchNormalization(name='norm_9')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 10 x = Conv2D(256, (1,1), strides=(1,1), padding='same', name='conv_10', use_bias=False)(x) x = BatchNormalization(name='norm_10')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 11 x = Conv2D(512, (3,3), strides=(1,1), padding='same', name='conv_11', use_bias=False)(x) x = BatchNormalization(name='norm_11')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 12 x = Conv2D(256, (1,1), strides=(1,1), padding='same', name='conv_12', use_bias=False)(x) x = BatchNormalization(name='norm_12')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 13 x = Conv2D(512, (3,3), strides=(1,1), padding='same', name='conv_13', use_bias=False)(x) x = BatchNormalization(name='norm_13')(x) x = LeakyReLU(alpha=0.1)(x) skip_connection = x x = MaxPooling2D(pool_size=(2, 2))(x) # Layer 14 x = Conv2D(1024, (3,3), strides=(1,1), padding='same', name='conv_14', use_bias=False)(x) x = BatchNormalization(name='norm_14')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 15 x = Conv2D(512, (1,1), strides=(1,1), padding='same', name='conv_15', use_bias=False)(x) x = BatchNormalization(name='norm_15')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 16 x = Conv2D(1024, (3,3), strides=(1,1), padding='same', name='conv_16', use_bias=False)(x) x = BatchNormalization(name='norm_16')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 17 x = Conv2D(512, (1,1), strides=(1,1), padding='same', name='conv_17', use_bias=False)(x) x = BatchNormalization(name='norm_17')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 18 x = Conv2D(1024, (3,3), strides=(1,1), padding='same', name='conv_18', use_bias=False)(x) x = BatchNormalization(name='norm_18')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 19 x = Conv2D(1024, (3,3), strides=(1,1), padding='same', name='conv_19', use_bias=False)(x) x = BatchNormalization(name='norm_19')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 20 x = Conv2D(1024, (3,3), strides=(1,1), padding='same', name='conv_20', use_bias=False)(x) x = BatchNormalization(name='norm_20')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 21 skip_connection = Conv2D(64, (1,1), strides=(1,1), padding='same', name='conv_21', use_bias=False)(skip_connection) skip_connection = BatchNormalization(name='norm_21')(skip_connection) skip_connection = LeakyReLU(alpha=0.1)(skip_connection) skip_connection = Lambda(space_to_depth_x2)(skip_connection) x = concatenate([skip_connection, x]) # Layer 22 x = Conv2D(1024, (3,3), strides=(1,1), padding='same', name='conv_22', use_bias=False)(x) x = BatchNormalization(name='norm_22')(x) x = LeakyReLU(alpha=0.1)(x) # Layer 23 x = Conv2D(BOX * (4 + 1 + CLASS), (1,1), strides=(1,1), padding='same', name='conv_23')(x) output = Reshape((GRID_H, GRID_W, BOX, 4 + 1 + CLASS))(x) # small hack to allow true_boxes to be registered when Keras build the model # for more information: https://github.com/fchollet/keras/issues/2790 output = Lambda(lambda args: args[0])([output, true_boxes]) model = Model([input_image, true_boxes], output) train_imgs, seen_train_labels = parse_annotation(train_annot_folder, train_image_folder, labels=LABELS) ### write parsed annotations to pickle for fast retrieval next time #with open('train_imgs', 'wb') as fp: # pickle.dump(train_imgs, fp) ### read saved pickle of parsed annotations #with open ('train_imgs', 'rb') as fp: # train_imgs = pickle.load(fp) train_batch = BatchGenerator(train_imgs, generator_config, norm=normalize) valid_imgs, seen_valid_labels = parse_annotation(valid_annot_folder, valid_image_folder, labels=LABELS) ### write parsed annotations to pickle for fast retrieval next time #with open('valid_imgs', 'wb') as fp: # pickle.dump(valid_imgs, fp) ### read saved pickle of parsed annotations #with open ('valid_imgs', 'rb') as fp: # valid_imgs = pickle.load(fp) optimizer = Adam(lr=0.5e-4, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) #optimizer = SGD(lr=1e-4, decay=0.0005, momentum=0.9) #optimizer = RMSprop(lr=1e-4, rho=0.9, epsilon=1e-08, decay=0.0) model.compile(loss=custom_loss, optimizer=optimizer) return model
def train( self, train_imgs, # the list of images to train the model valid_imgs, # the list of images used to validate the model train_times, # the number of time to repeat the training set, often used for small datasets valid_times, # the number of times to repeat the validation set, often used for small datasets nb_epoch, # number of epoches learning_rate, # the learning rate batch_size, # the size of the batch warmup_bs, # number of initial batches to let the model familiarize with the new dataset object_scale, no_object_scale, coord_scale, class_scale, saved_weights_name='best_weights.h5', debug=False): self.batch_size = batch_size self.warmup_bs = warmup_bs self.object_scale = object_scale self.no_object_scale = no_object_scale self.coord_scale = coord_scale self.class_scale = class_scale self.debug = debug ############################################ # Compile the model ############################################ optimizer = Adam(lr=learning_rate, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) self.model.compile(loss=self.custom_loss, optimizer=optimizer, metrics=['accuracy']) ############################################ # Make train and validation generators ############################################ generator_config = { 'IMAGE_H': self.input_size, 'IMAGE_W': self.input_size, 'GRID_H': self.grid_h, 'GRID_W': self.grid_w, 'BOX': self.nb_box, 'LABELS': self.labels, 'CLASS': len(self.labels), 'ANCHORS': self.anchors, 'BATCH_SIZE': self.batch_size, 'TRUE_BOX_BUFFER': self.max_box_per_image, } train_batch = BatchGenerator(train_imgs, generator_config, norm=self.feature_extractor.normalize) valid_batch = BatchGenerator(valid_imgs, generator_config, norm=self.feature_extractor.normalize, jitter=False) ############################################ # Make a few callbacks ############################################ early_stop = EarlyStopping(monitor='val_loss', min_delta=0.001, patience=3, mode='min', verbose=1) """ checkpoint = ModelCheckpoint(saved_weights_name, monitor='val_loss', verbose=1, save_best_only=True, mode='min', period=1) """ # prepare loss and acc cauculation callback histories = Histories() logs_path = os.getcwd() + "/logs/" if not os.path.exists(logs_path): logs_path = os.path.expanduser('~/logs/') tb_counter = len( [log for log in os.listdir(logs_path) if 'yolo' in log]) + 1 tensorboard = TensorBoard( log_dir=logs_path + 'yolo' + '_' + str(tb_counter), histogram_freq=0, #write_batch_performance=True, write_graph=True, write_images=False) ############################################ # Start the training process ############################################ #from IPython.core.debugger import Pdb; Pdb().set_trace() history = self.model.fit_generator( generator=train_batch, steps_per_epoch=len(train_batch) * train_times // self.gpus, epochs=nb_epoch * self.gpus, verbose=1, validation_data=valid_batch, validation_steps=len(valid_batch) * valid_times // self.gpus, callbacks=[early_stop, histories], #[early_stop, checkpoint, tensorboard], workers=3, max_queue_size=8) print('Loss: ', history) self.orgmodel.save_weights(saved_weights_name)
'BATCH_SIZE' : BATCH_SIZE, 'TRUE_BOX_BUFFER' : 50, } def normalize(image): return image / 255. train_imgs, seen_train_labels = parse_annotation(train_annot_folder, train_image_folder, labels=LABELS) ### write parsed annotations to pickle for fast retrieval next time #with open('train_imgs', 'wb') as fp: # pickle.dump(train_imgs, fp) ### read saved pickle of parsed annotations #with open ('train_imgs', 'rb') as fp: # train_imgs = pickle.load(fp) train_batch = BatchGenerator(train_imgs, generator_config, norm=normalize) # valid_imgs, seen_valid_labels = parse_annotation(valid_annot_folder, valid_image_folder, labels=LABELS) # ### write parsed annotations to pickle for fast retrieval next time # #with open('valid_imgs', 'wb') as fp: # # pickle.dump(valid_imgs, fp) # ### read saved pickle of parsed annotations # #with open ('valid_imgs', 'rb') as fp: # # valid_imgs = pickle.load(fp) # valid_batch = BatchGenerator(valid_imgs, generator_config, norm=normalize, jitter=False) # len(train_imgs) generator= train_batch generator
# image = batches[0][0][0][0] # plt.imshow(image.astype('uint8')) # ** Split the dataset into the training set and the validation set ** def normalize(image): return image / 255. # In[21]: train_valid_split = int(0.8 * len(all_imgs)) train_batch = BatchGenerator(all_imgs[:train_valid_split], generator_config) valid_batch = BatchGenerator(all_imgs[train_valid_split:], generator_config, norm=normalize) # train_batch = train_batch[:1] # # Construct the network # In[22]: # the function to implement the orgnization layer (thanks to github.com/allanzelener/YAD2K) def space_to_depth_x2(x): return tf.space_to_depth(x, block_size=2)
def _main_(args): config_path = args.conf weights_path = args.weights with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### yolo = YOLO(backend=config['model']['backend'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) ############################### # Load trained weights ############################### yolo.load_weights(weights_path) ############################### # Parse the annotations ############################### # parse annotations of the validation set, if any, otherwise split the training set if os.path.exists(config['valid']['valid_annot_folder']): valid_imgs, valid_labels = parse_annotation( config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['model']['labels']) else: raise ValueError( 'Validation folder does not exist or is not specified') ############################################ # Make validation generators ############################################ generator_config = { 'IMAGE_H': yolo.input_size, 'IMAGE_W': yolo.input_size, 'GRID_H': yolo.grid_h, 'GRID_W': yolo.grid_w, 'BOX': yolo.nb_box, 'LABELS': yolo.labels, 'CLASS': len(yolo.labels), 'ANCHORS': yolo.anchors, 'BATCH_SIZE': config['train']['batch_size'], 'TRUE_BOX_BUFFER': yolo.max_box_per_image, } generator = BatchGenerator(valid_imgs, generator_config, norm=yolo.feature_extractor.normalize, jitter=False) y_true = [] y_predicted = [] for i in range(generator.size()): raw_image = generator.load_image(i) raw_height, raw_width, raw_channels = raw_image.shape # make the boxes and the labels pred_boxes = yolo.predict(raw_image) score = np.array([box.score for box in pred_boxes]) pred_labels = np.array([box.label for box in pred_boxes]) if len(pred_boxes) > 0: pred_boxes = np.array([[ box.xmin * raw_width, box.ymin * raw_height, box.xmax * raw_width, box.ymax * raw_height, box.score ] for box in pred_boxes]) else: pred_boxes = np.array([[]]) # sort the boxes and the labels according to scores score_sort = np.argsort(-score) pred_labels = pred_labels[score_sort] pred_boxes = pred_boxes[score_sort] # store predicted label for the image i. # since multiple boxes may be predicted, choose the one with the highest score # TODO: find out why there are no predictions at all for certain images if pred_labels.any(): y_predicted.append(pred_labels[0]) else: y_predicted.append(4) # load true image annotations annotations = generator.load_annotation(i) if annotations.shape[0] > 1: raise ValueError('Multiple objects exist per image not supported') ### store the true label for the image i y_true.append(annotations[0, 4]) print('Processed ' + str(len(y_true)) + 'imgaes') print('Confusion Matrix') print(confusion_matrix(y_true, y_predicted)) print('Classification Report') # added NoPrediction label to number of classes as yolo model returned null prediction for some images target_names = config['model']['labels'] + ['NoPrediction'] print(classification_report(y_true, y_predicted, target_names=target_names))
def train(self, train_imgs, valid_imgs, train_times, valid_times, nb_epoch, learning_rate, batch_size, warmup_epochs, object_scale, no_object_scale, coord_scale, class_scale, saved_weights_name='best_weights.h5', debug=False): ########################## # Save the training parameters ########################## self.batch_size = batch_size self.object_scale = object_scale self.no_object_scale = no_object_scale self.coord_scale = coord_scale self.class_scale = class_scale self.debug = debug ############################################ # Make train and validation generators ############################################ generator_config = { 'IMAGE_H' :self.input_size, 'IMAGE_W' :self.input_size, 'GRID_H' :self.grid_h, 'GRID_W' :self.grid_w, 'BOX' :self.nb_box, 'LABELS' :self.labels, 'CLASS' :len(self.labels), 'ANCHORS' :self.anchors, 'BATCH_SIZE' :self.batch_size, 'TRUE_BOX_BUFFER' :self.max_box_per_image } train_generator = BatchGenerator(images=train_imgs, config=generator_config, norm=self.feature_extractor.normalize, shuffle=True, jitter=True) valid_generator = BatchGenerator(images=valid_imgs, config=generator_config, norm=self.feature_extractor.normalize, shuffle=True, jitter=False) self.warmup_batches = warmup_epochs * (train_times * len(train_generator) + valid_times * len(valid_generator)) ############################################ # Compile the model ############################################ optimizer = Adam(lr=learning_rate, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0, amsgrad=False) self.model.compile(loss=self.custom_loss, optimizer=optimizer) ############################################ # Start the training process ############################################ callbacks = self.create_callbacks(saved_weights_name=saved_weights_name, log_dir='./log_dir/') train_history = self.model.fit_generator(generator=train_generator, steps_per_epoch=len(train_generator) * train_times, epochs=warmup_epochs + nb_epoch, validation_data=valid_generator, validation_steps=len(valid_generator) * valid_times, callbacks=callbacks, verbose=2 if debug else 1, workers=3, max_queue_size=8) ############################################ # Compute mAP on the validation set ############################################ average_precisions = self.evaluate(generator=valid_generator) # print evaluation for label, average_precision in average_precisions.items(): print(self.labels[label], '{:.4f}'.format(average_precision)) print('mAP: {:.4f}'.format(sum(average_precisions.values()) / len(average_precisions))) return train_history
def train( self, train_imgs, # the list of images to train the model valid_imgs, # the list of images used to validate the model train_times, # the number of time to repeat the training set, often used for small datasets valid_times, # the number of times to repeat the validation set, often used for small datasets nb_epoch, # number of epoches learning_rate, # the learning rate batch_size, # the size of the batch warmup_epochs, # number of initial batches to let the model familiarize with the new dataset object_scale, no_object_scale, coord_scale, class_scale, saved_weights_name='best_weights.h5', debug=False): self.batch_size = batch_size self.warmup_bs = warmup_epochs * (train_times * (len(train_imgs) / batch_size + 1) + valid_times * (len(valid_imgs) / batch_size + 1)) self.object_scale = object_scale self.no_object_scale = no_object_scale self.coord_scale = coord_scale self.class_scale = class_scale self.debug = debug if warmup_epochs > 0: nb_epoch = warmup_epochs # if it's warmup stage, don't train more than warmup_epochs ############################################ # Compile the model ############################################ optimizer = Adam(lr=learning_rate, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) self.model.compile(loss=self.custom_loss, optimizer=optimizer) ############################################ # Make train and validation generators ############################################ generator_config = { 'IMAGE_H': self.input_size, 'IMAGE_W': self.input_size, 'GRID_H': self.grid_h, 'GRID_W': self.grid_w, 'BOX': self.nb_box, 'LABELS': self.labels, 'CLASS': len(self.labels), 'ANCHORS': self.anchors, 'BATCH_SIZE': self.batch_size, 'TRUE_BOX_BUFFER': self.max_box_per_image, } train_batch = BatchGenerator(train_imgs, generator_config, norm=self.feature_extractor.normalize) valid_batch = BatchGenerator(valid_imgs, generator_config, norm=self.feature_extractor.normalize, jitter=False) ############################################ # Make a few callbacks ############################################ early_stop = EarlyStopping(monitor='val_loss', min_delta=0.001, patience=3, mode='min', verbose=1) checkpoint = ModelCheckpoint(saved_weights_name, monitor='val_loss', verbose=1, save_best_only=True, mode='min', period=1) tb_counter = len([ log for log in os.listdir(os.path.expanduser('./logs/')) if 'yolo' in log ]) + 1 tensorboard = TensorBoard( log_dir=os.path.expanduser('./logs/') + 'yolo' + '_' + str(tb_counter), histogram_freq=0, #write_batch_performance=True, write_graph=True, write_images=False) ############################################ # Start the training process ############################################ self.model.fit_generator( generator=train_batch, steps_per_epoch=len(train_batch) * train_times, epochs=nb_epoch, verbose=1, validation_data=valid_batch, validation_steps=len(valid_batch) * valid_times, callbacks=[early_stop, checkpoint, tensorboard], workers=3, max_queue_size=8)
def train(self, train_imgs, # the list of images to train the model valid_imgs, # the list of images used to validate the model train_times, # the number of time to repeat the training set, often used for small datasets valid_times, # the number of times to repeat the validation set, often used for small datasets nb_epoch, # number of epoches learning_rate, # the learning rate batch_size, # the size of the batch warmup_bs, # number of initial batches to let the model familiarize with the new dataset object_scale, no_object_scale, coord_scale, class_scale, debug): self.batch_size = batch_size self.warmup_bs = warmup_bs self.object_scale = object_scale self.no_object_scale = no_object_scale self.coord_scale = coord_scale self.class_scale = class_scale self.debug = debug ############################################ # Compile the model ############################################ optimizer = Adam(lr=learning_rate, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) self.model.compile(loss=self.custom_loss, optimizer=optimizer) ############################################ # Make train and validation generators ############################################ generator_config = { 'IMAGE_H' : self.input_size, 'IMAGE_W' : self.input_size, 'GRID_H' : self.grid_h, 'GRID_W' : self.grid_w, 'BOX' : self.nb_box, 'LABELS' : self.labels, 'CLASS' : len(self.labels), 'ANCHORS' : self.anchors, 'BATCH_SIZE' : self.batch_size, 'TRUE_BOX_BUFFER' : self.max_box_per_image, } train_batch = BatchGenerator(train_imgs, generator_config) valid_batch = BatchGenerator(valid_imgs, generator_config, jitter=False) ############################################ # Make a few callbacks ############################################ early_stop = EarlyStopping(monitor='val_loss', min_delta=0.001, patience=3, mode='min', verbose=1) checkpoint = ModelCheckpoint('best_weights.h5', monitor='val_loss', verbose=1, save_best_only=True, mode='min', period=1) tensorboard = TensorBoard(log_dir='~/logs/yolo/', histogram_freq=0, write_graph=True, write_images=False) ############################################ # Start the training process ############################################ self.model.fit_generator(generator = train_batch.get_generator(), steps_per_epoch = train_batch.get_dateset_size() * train_times, epochs = nb_epoch, verbose = 1, validation_data = valid_batch.get_generator(), validation_steps = valid_batch.get_dateset_size() * valid_times, callbacks = [early_stop, checkpoint, tensorboard], max_queue_size = 3)
def train( self, train_imgs, # the list of images to train the model valid_imgs, # the list of images used to validate the model train_times, # the number of times to repeat the training set, often used for small datasets valid_times, # the number of times to repeat the validation set, often used for small datasets nb_epochs, # number of epoches learning_rate, # the learning rate batch_size, # the size of the batch warmup_epochs, # number of initial batches to let the model familiarize with the new dataset object_scale, no_object_scale, coord_scale, class_scale, saved_weights_name='best_weights.h5', debug=False): self.batch_size = batch_size self.object_scale = object_scale self.no_object_scale = no_object_scale self.coord_scale = coord_scale self.class_scale = class_scale self.debug = debug ############################################ # Make train and validation generators ############################################ generator_config = { 'IMAGE_H': self.input_size, 'IMAGE_W': self.input_size, 'GRID_H': self.grid_h, 'GRID_W': self.grid_w, 'BOX': self.nb_box, 'LABELS': self.labels, 'CLASS': len(self.labels), 'ANCHORS': self.anchors, 'BATCH_SIZE': self.batch_size, 'TRUE_BOX_BUFFER': self.max_box_per_image, } train_generator = BatchGenerator(train_imgs, generator_config, norm=self.feature_extractor.normalize) valid_generator = BatchGenerator(valid_imgs, generator_config, norm=self.feature_extractor.normalize, jitter=False) self.warmup_batches = warmup_epochs * ( train_times * len(train_generator) + valid_times * len(valid_generator)) ############################################ # Compile the model ############################################ optimizer = Adam(lr=learning_rate, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) self.model.compile(loss=self.custom_loss, optimizer=optimizer) ############################################ # Make a few callbacks ############################################ early_stop = EarlyStopping(monitor='val_loss', min_delta=0, patience=1, mode='min', verbose=1) checkpoint = ModelCheckpoint(saved_weights_name, monitor='val_loss', save_weights_only=False, verbose=1, save_best_only=True, mode='min', period=1) tensorboard = TensorBoard( log_dir=os.path.expanduser('~/logs/'), histogram_freq=0, #write_batch_performance=True, write_graph=True, write_images=False) ############################################ # Start the training process ############################################ self.model.fit_generator( generator=train_generator, steps_per_epoch=len(train_generator) * train_times, epochs=warmup_epochs + nb_epochs, verbose=2 if debug else 1, validation_data=valid_generator, validation_steps=len(valid_generator) * valid_times, callbacks=[early_stop, checkpoint, tensorboard], workers=3, max_queue_size=8) ############################################ # Compute mAP on the validation set ############################################ average_precisions = self.evaluate(valid_generator) # print evaluation for label, average_precision in average_precisions.items(): print(self.labels[label], '{:.4f}'.format(average_precision)) print('mAP: {:.4f}'.format( sum(average_precisions.values()) / len(average_precisions)))
def train(self): ############################################ # Make train and validation generators ############################################ objectReader = GroundTruth(self.config) objectReader.load_json() objectReader.objects_all() data = objectReader.objects_all() np.random.shuffle(data) size = int(len(data) * 0.8) train_instances, validation_instances = data[:size], data[size:] np.random.shuffle(train_instances) np.random.shuffle(validation_instances) checkpoint = ModelCheckpoint('weights_coco.h5', monitor='val_loss', verbose=1, save_best_only=True, mode='auto', period=1) train_generator = BatchGenerator(train_instances, self.config['generator_config'], norm=self.normalize) valid_generator = BatchGenerator(validation_instances, self.config['generator_config'], norm=self.normalize, jitter=False) ############################################ # Compile the model ############################################ optimizer = Adam(lr=self.config['train']['learning_rate'], beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) self.model.compile(loss=self.custom_loss, optimizer=optimizer) ############################################ # Start the training process ############################################ self.model.fit_generator(generator=train_generator, steps_per_epoch=len(train_generator), epochs= self.config['train']['nb_epochs'], verbose=2 if self.config['train']['debug'] else 1, validation_data=valid_generator, validation_steps=len(valid_generator), workers=3, callbacks=[checkpoint], max_queue_size=16) ############################################ # Compute mAP on the validation set ############################################ average_precisions = self.evaluate(valid_generator) # print evaluation for label, average_precision in average_precisions.items(): print('car', '{:.4f}'.format(average_precision)) print('mAP: {:.4f}'.format(sum(average_precisions.values()) / len(average_precisions)))