image_generator = ImageGenerator(ground_truth_data, prior_box_manager, batch_size, image_shape[0:2], train_keys, validation_keys, image_prefix, vertical_flip_probability=0, horizontal_flip_probability=0.5) model_names = ('../trained_models/model_checkpoints/' + 'weights.{epoch:02d}-{val_loss:.2f}.hdf5') model_checkpoint = ModelCheckpoint(model_names, monitor='val_loss', verbose=1, save_best_only=False, save_weights_only=True) learning_rate_schedule = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=10, verbose=1, cooldown=20) model.fit_generator(image_generator.flow(mode='train'), len(train_keys), num_epochs, callbacks=[model_checkpoint, learning_rate_schedule], validation_data=image_generator.flow(mode='val'), nb_val_samples=len(validation_keys))
box_creator.draw_boxes(image_path + image_key, box_coordinates) data_path = '../datasets/VOCdevkit/VOC2007/' ground_truths = XMLParser(data_path + 'Annotations/').get_data() prior_box_manager = PriorBoxAssigner(prior_boxes, ground_truths) assigned_boxes = prior_box_manager.assign_boxes() prior_box_manager.draw_assigned_boxes(image_path, image_shape[0:2], image_key) batch_size = 7 train_keys, validation_keys = split_data(assigned_boxes, training_ratio=.8) assigned_image_generator = ImageGenerator(assigned_boxes, batch_size, image_shape[0:2], train_keys, validation_keys, data_path + 'JPEGImages/') transformed_image = next(assigned_image_generator.flow(mode='demo'))[0] transformed_image = np.squeeze(transformed_image[0]).astype('uint8') original_image = read_image(data_path + 'JPEGImages/' + validation_keys[0]) original_image = resize_image(original_image, image_shape[0:2]) plt.figure(1) plt.subplot(121) plt.title('Original image') plt.imshow(original_image) plt.subplot(122) plt.title('Transformed image') plt.imshow(transformed_image) plt.show() box_transfomer = BoxTransformer(assigned_boxes, ground_truths) encoded_boxes = box_transfomer.encode_boxes()
# In[10]: base_lr = 3e-4 optim = keras.optimizers.Adam(lr=base_lr) # optim = keras.optimizers.RMSprop(lr=base_lr) # optim = keras.optimizers.SGD(lr=base_lr, momentum=0.9, decay=decay, nesterov=True) model.compile(optimizer=optim, loss=MultiboxLoss(NUM_CLASSES, neg_pos_ratio=2.0).compute_loss) # In[11]: # #nb_epoch = 30 #history = model.fit_generator(gen.generate(True), gen.train_batches, # nb_epoch, verbose=1, # callbacks=callbacks, # validation_data=gen.generate(False), # nb_val_samples=gen.val_batches, # nb_worker=1) # nb_epoch = 30 history = model.fit_generator(gen.flow(mode='train'), len(train_keys), nb_epoch, verbose=1, callbacks=callbacks, validation_data=gen.flow('val'), nb_val_samples=len(val_keys), nb_worker=1)
# parameters root_prefix = '../datasets/VOCdevkit/VOC2007/' image_prefix = root_prefix + 'JPEGImages/' ground_data_prefix = root_prefix + 'Annotations/' model = my_SSD(num_classes=21) image_shape = model.input_shape[1:] background_id = 0 ground_truth_manager = XMLParser(ground_data_prefix, background_id) ground_truth_data = ground_truth_manager.get_data() box_creator = PriorBoxCreator(model) prior_boxes = box_creator.create_boxes() prior_box_manager = PriorBoxManager(prior_boxes, background_id) prior_boxes = flatten_prior_boxes(prior_boxes) train_keys, validation_keys = split_data(ground_truth_data, training_ratio=.8) batch_size = 10 image_generator = ImageGenerator(ground_truth_data, prior_box_manager, batch_size, image_shape[0:2], train_keys, validation_keys, image_prefix, vertical_flip_probability=0, horizontal_flip_probability=0.5) data = next(image_generator.flow(mode='train'))
'min_size': 222.0, 'max_size': 276.0, 'aspect_ratios': [1.0, 1.0, 2.0, 1 / 2.0, 3.0, 1 / 3.0] }, { 'layer_width': 1, 'layer_height': 1, 'num_prior': 6, 'min_size': 276.0, 'max_size': 330.0, 'aspect_ratios': [1.0, 1.0, 2.0, 1 / 2.0, 3.0, 1 / 3.0] }, ] priors = create_prior_box(image_shape[0:2], box_configs, variances) bounding_box_utils = BoundingBoxUtility(num_classes, priors) ground_truth_data = XML_preprocessor(data_path + 'Annotations/').data keys = sorted(ground_truth_data.keys()) num_train = int(round(training_data_ratio * len(keys))) train_keys = keys[:num_train] validation_keys = keys[num_train:] num_val = len(validation_keys) image_generator = ImageGenerator(ground_truth_data, bounding_box_utils, batch_size, data_path + 'JPEGImages/', train_keys, validation_keys, image_shape[:2]) gen = image_generator.flow(True) next(gen)
base_learning_rate = 3e-4 def schedule(epoch, decay=0.9): return base_learning_rate * decay**(epoch) learning_rate_scheduler = LearningRateScheduler(schedule) callbacks = [model_checkpoint, learning_rate_scheduler] # In[16]: multibox_loss = MultiboxLoss(num_classes, neg_pos_ratio=2.0).compute_loss # In[17]: optimizer = Adam(lr=base_learning_rate) model.compile(optimizer=optimizer, loss=multibox_loss) # In[18]: nb_epoch = 30 history = model.fit_generator(image_generator.flow(True), num_train, nb_epoch, verbose=1, callbacks=callbacks, validation_data=image_generator.flow(False), nb_val_samples=num_val, nb_worker=1)
images_path = '../datasets/german_open_dataset/images/' labels = get_labels(dataset_name) num_classes = len(list(labels.keys())) use_bounding_boxes = True data_loader = XMLParser(ground_truth_path, dataset_name, use_bounding_boxes=use_bounding_boxes) ground_truth_data = data_loader.get_data() train_keys, val_keys = split_data(ground_truth_data, training_ratio=.5, do_shuffle=True) image_generator = ImageGenerator(ground_truth_data, batch_size, input_shape[:2], train_keys, val_keys, None, path_prefix=images_path, vertical_flip_probability=0, do_random_crop=True, use_bounding_boxes=use_bounding_boxes) batch_data = next(image_generator.flow('demo')) batch_images = batch_data[0]['image_array_input'] batch_classes = batch_data[1]['predictions'] for image_arg in range(batch_size): image = batch_images[image_arg] label_arg = np.argmax(batch_classes[image_arg]) label = labels[label_arg] display_image(image, label)
decoded_positive_boxes = assigned_decoded_boxes[positive_mask] box_visualizer.draw_normalized_box(decoded_positive_boxes, selected_key) # drawing generator output train_keys, validation_keys = split_data(ground_truth_data, training_ratio=.8) image_generator = ImageGenerator(ground_truth_data, prior_box_manager, 1, image_shape, train_keys, validation_keys, image_prefix, vertical_flip_probability=0, horizontal_flip_probability=0.5) generated_data = next(image_generator.flow(mode='demo')) generated_input = generated_data[0]['input_1'] generated_output = generated_data[1]['predictions'] transformed_image = np.squeeze(generated_input[0]).astype('uint8') validation_image_name = image_prefix + validation_keys[0] original_image = read_image(validation_image_name) original_image = resize_image(original_image, image_shape) plot_images(original_image, transformed_image) # finally draw the assigned boxes given by the generator generated_encoded_boxes = np.squeeze(generated_output) generated_boxes = prior_box_manager.decode_boxes(generated_encoded_boxes) positive_mask = generated_boxes[:, 4] != 1 generated_positive_boxes = generated_boxes[positive_mask] box_visualizer.draw_normalized_box(generated_positive_boxes, validation_keys[0])
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) model.summary() # model callbacks csv_logger = CSVLogger(log_file_path, append=False) model_names = trained_models_path + '.{epoch:02d}-{val_acc:.2f}.hdf5' model_checkpoint = ModelCheckpoint(model_names, monitor='val_loss', verbose=1, save_best_only=True, save_weights_only=False) # model training model.fit_generator(image_generator.flow(mode='train'), steps_per_epoch=int(len(train_keys) / batch_size), epochs=num_epochs, verbose=1, callbacks=[csv_logger, model_checkpoint], validation_data= image_generator.flow('val'), validation_steps=int(len(val_keys) / batch_size)) #Adding Images for testing import cv2 from keras.models import load_model import numpy as np from statistics import mode from utils import preprocess_input from utils import get_labels