def convert_to_h5(images_dir, annotation_csv, h5_file_name):
dataset = DataGenerator(load_images_into_memory=False)
dataset.parse_csv(images_dir, annotation_csv, input_format, verbose=True)
dataset.create_hdf5_dataset(file_path=h5_file_name + ".h5", verbose=True)
return
def load_dataset_from_data(self):
"""
从原始图片和CSV, 加载数据集, 同时写入HDF5文件
"""
train_dataset = DataGenerator(load_images_into_memory=False,
hdf5_dataset_path=None)
val_dataset = DataGenerator(load_images_into_memory=False,
hdf5_dataset_path=None)
images_dir = self.dataset_dir # 图片文件夹
# Ground truth, 真值, 图片, 物体框(4个点), 物体类别
train_labels_filename = os.path.join(self.dataset_dir,
'labels_train.csv')
val_labels_filename = os.path.join(self.dataset_dir, 'labels_val.csv')
train_dataset.parse_csv(images_dir=images_dir,
labels_filename=train_labels_filename,
input_format=[
'image_name', 'xmin', 'xmax', 'ymin',
'ymax', 'class_id'
],
include_classes='all') # 解析csv文件
val_dataset.parse_csv(images_dir=images_dir,
labels_filename=val_labels_filename,
input_format=[
'image_name', 'xmin', 'xmax', 'ymin', 'ymax',
'class_id'
],
include_classes='all') # 解析csv文件
# HDF5 文件
train_dataset_hdf5 = os.path.join(self.data_dir,
'dataset_udacity_traffic_train.h5')
val_dataset_hdf5 = os.path.join(self.data_dir,
'dataset_udacity_traffic_val.h5')
train_dataset.create_hdf5_dataset(file_path=train_dataset_hdf5,
resize=False,
variable_image_size=True,
verbose=True)
val_dataset.create_hdf5_dataset(file_path=val_dataset_hdf5,
resize=False,
variable_image_size=True,
verbose=True)
# Get the number of samples in the training and validations datasets.
train_dataset_size = train_dataset.get_dataset_size()
val_dataset_size = val_dataset.get_dataset_size()
print("Number of images in the training dataset:\t{:>6}".format(
train_dataset_size))
print("Number of images in the validation dataset:\t{:>6}".format(
val_dataset_size))
return train_dataset, train_dataset_size, val_dataset, val_dataset_size
], # This is the order of the first six columns in the CSV file that contains the labels for your dataset. If your labels are in XML format, maybe the XML parser will be helpful, check the documentation.
include_classes='all')
val_dataset.parse_csv(
images_dir=images_dir,
labels_filename=val_labels_filename,
input_format=['image_name', 'xmin', 'xmax', 'ymin', 'ymax', 'class_id'],
include_classes='all')
# Optional: Convert the dataset into an HDF5 dataset. This will require more disk space, but will
# speed up the training. Doing this is not relevant in case you activated the `load_images_into_memory`
# option in the constructor, because in that cas the images are in memory already anyway. If you don't
# want to create HDF5 datasets, comment out the subsequent two function calls.
train_dataset.create_hdf5_dataset(file_path='your image date save name.h5',
resize=(img_height, img_width),
variable_image_size=True,
verbose=True)
val_dataset.create_hdf5_dataset(file_path='your image date save name.h5',
resize=(img_height, img_width),
variable_image_size=True,
verbose=True)
# Get the number of samples in the training and validations datasets.
train_dataset_size = train_dataset.get_dataset_size()
val_dataset_size = val_dataset.get_dataset_size()
print("Number of images in the training dataset:\t{:>6}".format(
train_dataset_size))
print("Number of images in the validation dataset:\t{:>6}".format(
val_dataset_size))
def train_VOC(config):
'''
Train the given configuration ; the configuration must be constructed
according to the utility script found in utils/generateconfig.py.
Arguments:
config : the configuration of the model to use ; should already be
loaded
'''
###################################
### PATHS AND PARAMETERS
##################################
datadir = config.DATA_DIR
local_dir = config.ROOT_FOLDER
img_shape = config.IMG_SHAPE
classes = config.CLASSES
checkpoint_output = os.path.join(local_dir, 'models',
config.CHECKPOINT_NAME)
model_output = os.path.join(local_dir, 'models', config.MODEL_NAME)
img_height = img_shape[0] # Height of the model input images
img_width = img_shape[1] # Width of the model input images
img_channels = img_shape[
2] # Number of color channels of the model input images
mean_color = [
123, 117, 104
] # The per-channel mean of the images in the dataset. Do not change this value if you're using any of the pre-trained weights.
swap_channels = [
2, 1, 0
] # The color channel order in the original SSD is BGR, so we'll have the model reverse the color channel order of the input images.
n_classes = 20 # Number of positive classes, e.g. 20 for Pascal VOC, 80 for MS COCO
scales_pascal = [
0.1, 0.2, 0.37, 0.54, 0.71, 0.88, 1.05
] # The anchor box scaling factors used in the original SSD300 for the Pascal VOC datasets
scales = scales_pascal
aspect_ratios = [
[1.0,
2.0, 0.5], [1.0, 2.0, 0.5, 3.0,
1.0 / 3.0],
[1.0, 2.0, 0.5,
3.0, 1.0 / 3.0], [1.0, 2.0, 0.5, 3.0, 1.0 / 3.0
], [1.0, 2.0, 0.5
], [1.0, 2.0, 0.5]
] # The anchor box aspect ratios used in the original SSD300; the order matters
two_boxes_for_ar1 = True
steps = [
8, 16, 32, 64, 100, 300
] # The space between two adjacent anchor box center points for each predictor layer.
offsets = [
0.5, 0.5, 0.5, 0.5, 0.5, 0.5
] # The offsets of the first anchor box center points from the top and left borders of the image as a fraction of the step size for each predictor layer.
clip_boxes = False # Whether or not to clip the anchor boxes to lie entirely within the image boundaries
variances = [
0.1, 0.1, 0.2, 0.2
] # The variances by which the encoded target coordinates are divided as in the original implementation
normalize_coords = True
batch_size = config.BATCH_SIZE # Change the batch size if you like, or if you run into GPU memory issues.
###################################
### BUILDING MODEL
##################################
K.clear_session() # Clear previous models from memory.
model = ssd_300(image_size=(img_height, img_width, img_channels),
n_classes=n_classes,
mode='training',
l2_regularization=0.0005,
scales=scales,
aspect_ratios_per_layer=aspect_ratios,
two_boxes_for_ar1=two_boxes_for_ar1,
steps=steps,
offsets=offsets,
clip_boxes=clip_boxes,
variances=variances,
normalize_coords=normalize_coords,
subtract_mean=mean_color,
swap_channels=swap_channels)
weights_path = os.path.join(local_dir, 'weights',
'VGG_VOC0712_SSD_300x300_iter_120000.h5')
model.load_weights(weights_path, by_name=True)
#adam = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)
sgd = SGD(lr=0.001, momentum=0.9, decay=0.0, nesterov=False)
ssd_loss = SSDLoss(neg_pos_ratio=3, alpha=1.0)
model.compile(optimizer=sgd, loss=ssd_loss.compute_loss)
###################################
### LOADING DATAS
##################################
train_dataset = DataGenerator(load_images_into_memory=False,
hdf5_dataset_path=None)
val_dataset = DataGenerator(load_images_into_memory=False,
hdf5_dataset_path=None)
images_dir = os.path.join(datadir, 'Images')
annotations_dir = os.path.join(datadir, 'Annotations')
trainval_image_set_filename = os.path.join(datadir, 'ImageSets',
'train.txt')
test_image_set_filename = os.path.join(datadir, 'ImageSets', 'val.txt')
# The XML parser needs to now what object class names to look for and in which order to map them to integers.
#
train_dataset.parse_xml(images_dirs=[images_dir],
image_set_filenames=[trainval_image_set_filename],
annotations_dirs=[annotations_dir],
classes=classes,
include_classes='all',
exclude_truncated=False,
exclude_difficult=False,
ret=False)
val_dataset.parse_xml(images_dirs=[images_dir],
image_set_filenames=[test_image_set_filename],
annotations_dirs=[annotations_dir],
classes=classes,
include_classes='all',
exclude_truncated=False,
exclude_difficult=True,
ret=False)
train_dataset.create_hdf5_dataset(file_path='flowers_train.h5',
resize=False,
variable_image_size=True,
verbose=True)
val_dataset.create_hdf5_dataset(file_path='flowers_val.h5',
resize=False,
variable_image_size=True,
verbose=True)
ssd_data_augmentation = SSDDataAugmentation(img_height=img_height,
img_width=img_width,
background=mean_color)
convert_to_3_channels = ConvertTo3Channels()
resize = Resize(height=img_height, width=img_width)
# The encoder constructor needs the spatial dimensions of the model's predictor layers to create the anchor boxes.
predictor_sizes = [
model.get_layer('conv4_3_norm_mbox_conf').output_shape[1:3],
model.get_layer('fc7_mbox_conf').output_shape[1:3],
model.get_layer('conv6_2_mbox_conf').output_shape[1:3],
model.get_layer('conv7_2_mbox_conf').output_shape[1:3],
model.get_layer('conv8_2_mbox_conf').output_shape[1:3],
model.get_layer('conv9_2_mbox_conf').output_shape[1:3]
]
ssd_input_encoder = SSDInputEncoder(img_height=img_height,
img_width=img_width,
n_classes=n_classes,
predictor_sizes=predictor_sizes,
scales=scales,
aspect_ratios_per_layer=aspect_ratios,
two_boxes_for_ar1=two_boxes_for_ar1,
steps=steps,
offsets=offsets,
clip_boxes=clip_boxes,
variances=variances,
matching_type='multi',
pos_iou_threshold=0.5,
neg_iou_limit=0.5,
normalize_coords=normalize_coords)
train_generator = train_dataset.generate(
batch_size=batch_size,
shuffle=True,
transformations=[ssd_data_augmentation],
label_encoder=ssd_input_encoder,
returns={'processed_images', 'encoded_labels'},
keep_images_without_gt=False)
val_generator = val_dataset.generate(
batch_size=batch_size,
shuffle=False,
transformations=[convert_to_3_channels, resize],
label_encoder=ssd_input_encoder,
returns={'processed_images', 'encoded_labels'},
keep_images_without_gt=False)
# Get the number of samples in the training and validations datasets.
train_dataset_size = train_dataset.get_dataset_size()
val_dataset_size = val_dataset.get_dataset_size()
print("Number of images in the training dataset:\t{:>6}".format(
train_dataset_size))
print("Number of images in the validation dataset:\t{:>6}".format(
val_dataset_size))
###################################
### PREPARE TRAINING
##################################
def lr_schedule(epoch):
if epoch < 80:
return 0.001
elif epoch < 100:
return 0.0001
else:
return 0.00001
model_checkpoint = ModelCheckpoint(filepath=checkpoint_output,
monitor='val_loss',
verbose=1,
save_best_only=True,
save_weights_only=False,
mode='auto',
period=1)
early_stopping = EarlyStopping(monitor='val_loss',
min_delta=0.0,
patience=10,
verbose=1)
learning_rate_scheduler = LearningRateScheduler(schedule=lr_schedule,
verbose=1)
terminate_on_nan = TerminateOnNaN()
callbacks = [
model_checkpoint, learning_rate_scheduler, terminate_on_nan,
early_stopping
]
###################################
### TRAINING
##################################
epochs = config.EPOCHS
steps_per_epoch = ceil(train_dataset_size / batch_size)
model.summary()
history = model.fit_generator(generator=train_generator,
steps_per_epoch=steps_per_epoch,
epochs=epochs,
callbacks=callbacks,
validation_data=val_generator,
validation_steps=ceil(val_dataset_size /
batch_size))
model.save(model_output)
image_set_filenames=[test_image_set_filename],
annotations_dirs=[annotations_dir],
classes=classes,
include_classes='all',
exclude_truncated=False,
exclude_difficult=False,
ret=False)
# Optional: Convert the dataset into an HDF5 dataset. This will require more disk space, but will
# speed up the training. Doing this is not relevant in case you activated the `load_images_into_memory`
# option in the constructor, because in that cas the images are in memory already anyway. If you don't
# want to create HDF5 datasets, comment out the subsequent two function calls.
train_dataset.create_hdf5_dataset(
file_path='dataset_pascal_voc_07+12_trainval.h5',
resize=False,
variable_image_size=True,
verbose=True)
val_dataset.create_hdf5_dataset(file_path='dataset_pascal_voc_07_test.h5',
resize=False,
variable_image_size=True,
verbose=True)
# 4: Set the image transformations for pre-processing and data augmentation options.
# For the training generator:
ssd_data_augmentation = SSDDataAugmentation(img_height=img_height,
img_width=img_width,
background=mean_color)
# For the validation generator:
classes=val_classes,
include_classes=val_include_classes,
exclude_truncated=False,
exclude_difficult=True,
ret=False)
# Optional: Convert the dataset into an HDF5 dataset. This will require more disk space, but will
# speed up the training. Doing this is not relevant in case you activated the `load_images_into_memory`
# option in the constructor, because in that cas the images are in memory already anyway. If you don't
# want to create HDF5 datasets, comment out the subsequent two function calls.
# After create these h5 files, if you have resized the input image, you need to reload these files. Otherwise,
# the images and the labels will not change.
train_dataset.create_hdf5_dataset(file_path=os.path.join(processed_dataset_path, 'dataset_train.h5'),
resize=resize_image_to,
variable_image_size=True,
verbose=True)
val_dataset.create_hdf5_dataset(file_path=os.path.join(processed_dataset_path, 'dataset_test.h5'),
resize=False,
variable_image_size=True,
verbose=True)
train_dataset = DataGenerator(dataset='train',
load_images_into_memory=False,
hdf5_dataset_path=os.path.join(processed_dataset_path, 'dataset_train.h5'),
filenames=train_source_image_set_filename,
target_filenames=train_target_image_set_filename,
filenames_type='text',
images_dir=train_source_images_dir,
target_images_dir=train_target_images_dir)
def get_dataset(
args: argparse.Namespace, model: Model
) -> Tuple[Iterable[List[np.array]], Iterable[List[np.array]], int]:
train_dataset = DataGenerator(load_images_into_memory=False,
hdf5_dataset_path=None)
val_dataset = DataGenerator(load_images_into_memory=False,
hdf5_dataset_path=None)
VOC_2007_images_dir = os.path.join(args.data_dir, '/VOC2007/JPEGImages/')
VOC_2012_images_dir = os.path.join(args.data_dir, '/VOC2012/JPEGImages/')
VOC_2007_annotations_dir = os.path.join(args.data_dir,
'/VOC2007/Annotations/')
VOC_2012_annotations_dir = os.path.join(args.data_dir,
'/VOC2012/Annotations/')
VOC_2007_trainval_image_set_filename = os.path.join(
args.data_dir, '/VOC2007/ImageSets/Main/trainval.txt')
VOC_2012_trainval_image_set_filename = os.path.join(
args.data_dir, '/VOC2012/ImageSets/Main/trainval.txt')
VOC_2007_test_image_set_filename = os.path.join(
args.data_dir, '/VOC2007/ImageSets/Main/test.txt')
classes = [
'background', 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus',
'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse',
'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train',
'tvmonitor'
]
train_dataset.parse_xml(
images_dirs=[VOC_2007_images_dir, VOC_2012_images_dir],
image_set_filenames=[
VOC_2007_trainval_image_set_filename,
VOC_2012_trainval_image_set_filename
],
annotations_dirs=[VOC_2007_annotations_dir, VOC_2012_annotations_dir],
classes=classes,
include_classes='all',
exclude_truncated=False,
exclude_difficult=False,
ret=False)
val_dataset.parse_xml(
images_dirs=[VOC_2007_images_dir],
image_set_filenames=[VOC_2007_test_image_set_filename],
annotations_dirs=[VOC_2007_annotations_dir],
classes=classes,
include_classes='all',
exclude_truncated=False,
exclude_difficult=True,
ret=False)
train_dataset.create_hdf5_dataset(
file_path='dataset_pascal_voc_07+12_trainval.h5',
resize=False,
variable_image_size=True,
verbose=True)
val_dataset.create_hdf5_dataset(file_path='dataset_pascal_voc_07_test.h5',
resize=False,
variable_image_size=True,
verbose=True)
ssd_data_augmentation = SSDDataAugmentation(img_height=args.img_height,
img_width=args.img_width,
background=args.mean_color)
# For the validation generator:
convert_to_3_channels = ConvertTo3Channels()
resize = Resize(height=args.img_height, width=args.img_width)
# 5: Instantiate an encoder that can encode ground truth labels into the format needed by the SSD loss function.
# The encoder constructor needs the spatial dimensions of the model's predictor layers to create the anchor boxes.
predictor_sizes = [
model.get_layer('conv4_3_norm_mbox_conf').output_shape[1:3],
model.get_layer('fc7_mbox_conf').output_shape[1:3],
model.get_layer('conv6_2_mbox_conf').output_shape[1:3],
model.get_layer('conv7_2_mbox_conf').output_shape[1:3],
model.get_layer('conv8_2_mbox_conf').output_shape[1:3],
model.get_layer('conv9_2_mbox_conf').output_shape[1:3]
]
ssd_input_encoder = SSDInputEncoder(
img_height=args.img_height,
img_width=args.img_width,
n_classes=args.n_classes,
predictor_sizes=predictor_sizes,
scales=args.scales,
aspect_ratios_per_layer=args.aspect_ratios,
two_boxes_for_ar1=args.two_boxes_for_ar1,
steps=args.steps,
offsets=args.offsets,
clip_boxes=args.clip_boxes,
variances=args.variances,
matching_type='multi',
pos_iou_threshold=0.5,
neg_iou_limit=0.5,
normalize_coords=args.normalize_coords)
train_generator = train_dataset.generate(
batch_size=args.batch_size,
shuffle=True,
transformations=[ssd_data_augmentation],
label_encoder=ssd_input_encoder,
returns={'processed_images', 'encoded_labels'},
keep_images_without_gt=False)
val_generator = val_dataset.generate(
batch_size=args.batch_size,
shuffle=False,
transformations=[convert_to_3_channels, resize],
label_encoder=ssd_input_encoder,
returns={'processed_images', 'encoded_labels'},
keep_images_without_gt=False)
return train_generator, val_generator, val_dataset.get_dataset_size()
def _main_(args):
print('Hello World! This is {:s}'.format(args.desc))
# config_path = args.conf
# with open(config_path) as config_buffer:
# config = json.loads(config_buffer.read())
#############################################################
# Set model parameters
#############################################################
img_height = 300 # Height of the model input images
img_width = 300 # Width of the model input images
img_channels = 3 # Number of color channels of the model input images
mean_color = [123, 117, 104] # The per-channel mean of the images in the dataset. Do not change this value if you're using any of the pre-trained weights.
swap_channels = [2, 1, 0] # The color channel order in the original SSD is BGR, so we'll have the model reverse the color channel order of the input images.
n_classes = 20 # Number of positive classes, e.g. 20 for Pascal VOC, 80 for MS COCO
scales_pascal = [0.1, 0.2, 0.37, 0.54, 0.71, 0.88, 1.05] # The anchor box scaling factors used in the original SSD300 for the Pascal VOC datasets
scales_coco = [0.07, 0.15, 0.33, 0.51, 0.69, 0.87, 1.05] # The anchor box scaling factors used in the original SSD300 for the MS COCO datasets
scales = scales_pascal
aspect_ratios = [[1.0, 2.0, 0.5],
[1.0, 2.0, 0.5, 3.0, 1.0 / 3.0],
[1.0, 2.0, 0.5, 3.0, 1.0 / 3.0],
[1.0, 2.0, 0.5, 3.0, 1.0 / 3.0],
[1.0, 2.0, 0.5],
[1.0, 2.0, 0.5]] # The anchor box aspect ratios used in the original SSD300; the order matters
two_boxes_for_ar1 = True
steps = [8, 16, 32, 64, 100, 300] # The space between two adjacent anchor box center points for each predictor layer.
offsets = [0.5, 0.5, 0.5, 0.5, 0.5, 0.5] # The offsets of the first anchor box center points from the top and left borders of the image as a fraction of the step size for each predictor layer.
clip_boxes = False # Whether or not to clip the anchor boxes to lie entirely within the image boundaries
variances = [0.1, 0.1, 0.2, 0.2] # The variances by which the encoded target coordinates are divided as in the original implementation
normalize_coords = True
#############################################################
# Create the model
#############################################################
# 1: Build the Keras model.
model = ssd_300(image_size=(img_height, img_width, img_channels),
n_classes=n_classes,
mode='training',
l2_regularization=0.0005,
scales=scales,
aspect_ratios_per_layer=aspect_ratios,
two_boxes_for_ar1=two_boxes_for_ar1,
steps=steps,
offsets=offsets,
clip_boxes=clip_boxes,
variances=variances,
normalize_coords=normalize_coords,
subtract_mean=mean_color,
swap_channels=swap_channels)
# 2: Load some weights into the model.
# 3: Instantiate an optimizer and the SSD loss function and compile the model.
adam = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)
ssd_loss = SSDLoss(neg_pos_ratio=3, alpha=1.0)
model.compile(optimizer=adam, loss=ssd_loss.compute_loss)
#############################################################
# Prepare the data
#############################################################
# 1: Instantiate two `DataGenerator` objects: One for training, one for validation.
train_dataset = DataGenerator(load_images_into_memory=False, hdf5_dataset_path=None)
val_dataset = DataGenerator(load_images_into_memory=False, hdf5_dataset_path=None)
# 2: Parse the image and label lists for the training and validation datasets. This can take a while.
VOC_2007_images_dir = '/home/minhnc-lab/WORKSPACES/AI/data/VOC/VOCtrainval_06-Nov-2007/VOCdevkit/VOC2007/JPEGImages'
VOC_2007_annotations_dir = '/home/minhnc-lab/WORKSPACES/AI/data/VOC/VOCtrainval_06-Nov-2007/VOCdevkit/VOC2007/Annotations'
VOC_2007_train_image_set_filename = '/home/minhnc-lab/WORKSPACES/AI/data/VOC/VOCtrainval_06-Nov-2007/VOCdevkit/VOC2007/ImageSets/Main/train.txt'
VOC_2007_val_image_set_filename = '/home/minhnc-lab/WORKSPACES/AI/data/VOC/VOCtrainval_06-Nov-2007/VOCdevkit/VOC2007/ImageSets/Main/val.txt'
# VOC_2007_trainval_image_set_filename = '/home/minhnc-lab/WORKSPACES/AI/data/VOC/VOCtrainval_06-Nov-2007/VOCdevkit/VOC2007/ImageSets/Main/trainval.txt'
# VOC_2007_test_image_set_filename = '/home/minhnc-lab/WORKSPACES/AI/data/VOC/VOCtest_06-Nov-2007/VOCdevkit/VOC2007/ImageSets/Main/test.txt'
classes = ['background',
'aeroplane', 'bicycle', 'bird', 'boat',
'bottle', 'bus', 'car', 'cat',
'chair', 'cow', 'diningtable', 'dog',
'horse', 'motorbike', 'person', 'pottedplant',
'sheep', 'sofa', 'train', 'tvmonitor']
train_dataset.parse_xml(images_dirs=[VOC_2007_images_dir],
image_set_filenames=[VOC_2007_train_image_set_filename],
annotations_dirs=[VOC_2007_annotations_dir],
classes=classes,
include_classes='all',
exclude_truncated=False,
exclude_difficult=False,
ret=False)
val_dataset.parse_xml(images_dirs=[VOC_2007_images_dir],
image_set_filenames=[VOC_2007_val_image_set_filename],
annotations_dirs=[VOC_2007_annotations_dir],
classes=classes,
include_classes='all',
exclude_truncated=False,
exclude_difficult=True,
ret=False)
train_dataset.create_hdf5_dataset(file_path='dataset_pascal_voc_07+12_trainval.h5',
resize=False,
variable_image_size=True,
verbose=True)
val_dataset.create_hdf5_dataset(file_path='dataset_pascal_voc_07_test.h5',
resize=False,
variable_image_size=True,
verbose=True)
# 3: Set the batch size.
batch_size = 8 # Change the batch size if you like, or if you run into GPU memory issues.
# 4: Set the image transformations for pre-processing and data augmentation options.
ssd_data_augmentation = SSDDataAugmentation(img_height=img_height,
img_width=img_width,
background=mean_color)
convert_to_3_channels = ConvertTo3Channels()
resize = Resize(height=img_height, width=img_width)
# 5: Instantiate an encoder that can encode ground truth labels into the format needed by the SSD loss function.
predictor_sizes = [model.get_layer('conv4_3_norm_mbox_conf').output_shape[1:3],
model.get_layer('fc7_mbox_conf').output_shape[1:3],
model.get_layer('conv6_2_mbox_conf').output_shape[1:3],
model.get_layer('conv7_2_mbox_conf').output_shape[1:3],
model.get_layer('conv8_2_mbox_conf').output_shape[1:3],
model.get_layer('conv9_2_mbox_conf').output_shape[1:3]]
ssd_input_encoder = SSDInputEncoder(img_height=img_height,
img_width=img_width,
n_classes=n_classes,
predictor_sizes=predictor_sizes,
scales=scales,
aspect_ratios_per_layer=aspect_ratios,
two_boxes_for_ar1=two_boxes_for_ar1,
steps=steps,
offsets=offsets,
clip_boxes=clip_boxes,
variances=variances,
matching_type='multi',
pos_iou_threshold=0.5,
neg_iou_limit=0.5,
normalize_coords=normalize_coords)
# 6: Create the generator handles that will be passed to Keras' `fit_generator()` function.
train_generator = train_dataset.generate(batch_size=batch_size,
shuffle=True,
transformations=[ssd_data_augmentation],
label_encoder=ssd_input_encoder,
returns={'processed_images',
'encoded_labels'},
keep_images_without_gt=False)
val_generator = val_dataset.generate(batch_size=batch_size,
shuffle=False,
transformations=[convert_to_3_channels,
resize],
label_encoder=ssd_input_encoder,
returns={'processed_images',
'encoded_labels'},
keep_images_without_gt=False)
# Get the number of samples in the training and validations datasets.
train_dataset_size = train_dataset.get_dataset_size()
val_dataset_size = val_dataset.get_dataset_size()
print("Number of images in the training dataset:\t{:>6}".format(train_dataset_size))
print("Number of images in the validation dataset:\t{:>6}".format(val_dataset_size))
#############################################################
# Kick off the training
#############################################################
# Define model callbacks.
model_checkpoint = ModelCheckpoint(
filepath='ssd300_pascal_07+12_epoch-{epoch:02d}_loss-{loss:.4f}_val_loss-{val_loss:.4f}.h5',
monitor='val_loss',
verbose=1,
save_best_only=True,
save_weights_only=False,
mode='auto',
period=1)
csv_logger = CSVLogger(filename='ssd300_pascal_07+12_training_log.csv',
separator=',',
append=True)
learning_rate_scheduler = LearningRateScheduler(schedule=lr_schedule,
verbose=1)
terminate_on_nan = TerminateOnNaN()
callbacks = [model_checkpoint,
csv_logger,
learning_rate_scheduler,
terminate_on_nan]
# Train
initial_epoch = 0
final_epoch = 120
steps_per_epoch = 1000
history = model.fit_generator(generator=train_generator,
steps_per_epoch=steps_per_epoch,
epochs=final_epoch,
callbacks=callbacks,
validation_data=val_generator,
validation_steps=ceil(val_dataset_size / batch_size),
initial_epoch=initial_epoch)
#############################################################
# Run the evaluation
#############################################################
# 1: Set the generator for the predictions.
predict_generator = val_dataset.generate(batch_size=1,
shuffle=True,
transformations=[convert_to_3_channels,
resize],
label_encoder=None,
returns={'processed_images',
'filenames',
'inverse_transform',
'original_images',
'original_labels'},
keep_images_without_gt=False)
# 2: Generate samples.
batch_images, batch_filenames, batch_inverse_transforms, batch_original_images, batch_original_labels = next(
predict_generator)
i = 0 # Which batch item to look at
print("Image:", batch_filenames[i])
print()
print("Ground truth boxes:\n")
print(np.array(batch_original_labels[i]))
# 3: Make predictions.
y_pred = model.predict(batch_images)
# 4: Decode the raw predictions in `y_pred`.
y_pred_decoded = decode_detections(y_pred,
confidence_thresh=0.5,
iou_threshold=0.4,
top_k=200,
normalize_coords=normalize_coords,
img_height=img_height,
img_width=img_width)
# 5: Convert the predictions for the original image.
y_pred_decoded_inv = apply_inverse_transforms(y_pred_decoded, batch_inverse_transforms)
np.set_printoptions(precision=2, suppress=True, linewidth=90)
print("Predicted boxes:\n")
print(' class conf xmin ymin xmax ymax')
print(y_pred_decoded_inv[i])
# 6: Draw the predicted boxes onto the image
# Set the colors for the bounding boxes
colors = plt.cm.hsv(np.linspace(0, 1, n_classes + 1)).tolist()
classes = ['background',
'aeroplane', 'bicycle', 'bird', 'boat',
'bottle', 'bus', 'car', 'cat',
'chair', 'cow', 'diningtable', 'dog',
'horse', 'motorbike', 'person', 'pottedplant',
'sheep', 'sofa', 'train', 'tvmonitor']
plt.figure(figsize=(20, 12))
plt.imshow(batch_original_images[i])
current_axis = plt.gca()
for box in batch_original_labels[i]:
xmin = box[1]
ymin = box[2]
xmax = box[3]
ymax = box[4]
label = '{}'.format(classes[int(box[0])])
current_axis.add_patch(
plt.Rectangle((xmin, ymin), xmax - xmin, ymax - ymin, color='green', fill=False, linewidth=2))
current_axis.text(xmin, ymin, label, size='x-large', color='white', bbox={'facecolor': 'green', 'alpha': 1.0})
for box in y_pred_decoded_inv[i]:
xmin = box[2]
ymin = box[3]
xmax = box[4]
ymax = box[5]
color = colors[int(box[0])]
label = '{}: {:.2f}'.format(classes[int(box[0])], box[1])
current_axis.add_patch(
plt.Rectangle((xmin, ymin), xmax - xmin, ymax - ymin, color=color, fill=False, linewidth=2))
current_axis.text(xmin, ymin, label, size='x-large', color='white', bbox={'facecolor': color, 'alpha': 1.0})
exclude_truncated=False,
exclude_difficult=False,
ret=False)
val_dataset.parse_hand_xml(images_dirs=[VOC_2012_images_dir],
image_set_filenames=[VOC_2012_test_image_set_filename],
annotations_dirs=[VOC_2012_annotations_dir],
classes=classes,
include_classes=include_classes,
exclude_truncated=False,
exclude_difficult=True,
ret=False)
## Optional: Convert the dataset into an HDF5 dataset.
train_dataset.create_hdf5_dataset(file_path='dataset_pascal_voc_12_train_hand.h5',
resize=False,
variable_image_size=True,
verbose=True)
val_dataset.create_hdf5_dataset(file_path='dataset_pascal_voc_12_val_hand.h5',
resize=False,
variable_image_size=True,
verbose=True)
##Set the batch size.
batch_size = 10
ssd_data_augmentation = SSDDataAugmentation(img_height=img_height,
img_width=img_width,
background=subtract_mean)
# For the validation generator:
convert_to_3_channels = ConvertTo3Channels()
include_classes='all',
exclude_truncated=False,
exclude_difficult=True,
ret=False)
# Optional: Convert the dataset into an HDF5 dataset. This will require more disk space, but will
# speed up the training. Doing this is not relevant in case you activated the `load_images_into_memory`
# option in the constructor, because in that cas the images are in memory already anyway. If you don't
# want to create HDF5 datasets, comment out the subsequent two function calls.
# After create these h5 files, if you have resized the input image, you need to reload these files. Otherwise,
# the images and the labels will not change.
resize_image_to = (300, 600)
train_dataset.create_hdf5_dataset(file_path='dataset_cityscapes_train.h5',
resize=resize_image_to,
variable_image_size=True,
verbose=True)
val_dataset.create_hdf5_dataset(file_path='dataset_cityscapes_test.h5',
resize=resize_image_to,
variable_image_size=True,
verbose=True)
train_filename_paths = [Cityscapes_train_source_image_set_filename,
Cityscapes_train_target_image_set_filename]
train_filenames = []
for filename_path in train_filename_paths:
with open(filename_path, 'r') as f:
train_filenames.extend([os.path.join(Cityscapes_images_dir, line.strip()) for line in f])
train_dataset = DataGenerator(dataset='train',
dataset.parse_csv(
images_dir=images_path,
labels_filename=labels_path,
input_format=[
'image_name', 'xmin', 'xmax', 'ymin', 'ymax', 'class_id'
], # This is the order of the first six columns in the CSV file that contains the labels for your dataset. If your labels are in XML format, maybe the XML parser will be helpful, check the documentation.
include_classes='all',
random_sample=False)
# Optional: Convert the dataset into an HDF5 dataset. This will require more disk space, but will
# speed up the training. Doing this is not relevant in case you activated the `load_images_into_memory`
# option in the constructor, because in that cas the images are in memory already anyway. If you don't
# want to create HDF5 datasets, comment out the subsequent two function calls.
dataset.create_hdf5_dataset(file_path='dataset_custom.h5',
resize=False,
variable_image_size=True,
verbose=True)
# 3: Set the batch size.
batch_size = 32 # Change the batch size if you like, or if you run into GPU memory issues.
# 4: Set the image transformations for pre-processing and data augmentation options.
# For the training generator:
ssd_data_augmentation = SSDDataAugmentation(img_height=img_height,
img_width=img_width,
background=mean_color)
convert_to_3_channels = ConvertTo3Channels()
resize = Resize(height=img_height, width=img_width)
val_dataset.parse_csv(images_dir=images_dir,
labels_filename=val_labels_filename,
input_format=['image_name', 'xmin', 'xmax', 'ymin', 'ymax', 'class_id'],
include_classes='all')
# Optional: Convert the dataset into an HDF5 dataset. This will require more disk space, but will
# speed up the training. Doing this is not relevant in case you activated the `load_images_into_memory`
# option in the constructor, because in that cas the images are in memory already anyway. If you don't
# want to create HDF5 datasets, comment out the subsequent two function calls.
train_h5 = './datasets/dataset_udacity_traffic_train.h5'
val_h5 = './datasets/dataset_udacity_traffic_val.h5'
if not Path(train_h5).exists():
train_dataset.create_hdf5_dataset(file_path=train_h5,
resize=False,
variable_image_size=True,
verbose=True)
if not Path(val_h5).exists():
val_dataset.create_hdf5_dataset(file_path=val_h5,
resize=False,
variable_image_size=True,
verbose=True)
# Get the number of samples in the training and validations datasets.
train_dataset_size = train_dataset.get_dataset_size()
val_dataset_size = val_dataset.get_dataset_size()
print("Number of images in the training dataset:\t{:>6}".format(train_dataset_size))
print("Number of images in the validation dataset:\t{:>6}".format(val_dataset_size))
def main(args=args):
"""
main function that parses the arguments and trains
:param args: arguments related
:return: None
"""
# pylint: disable=line-too-long
# Images
images_dir = os.path.abspath(os.path.join(
os.getcwd(), '')) + "/data/" + args.dataset + "/images/"
# # Ground truth
train_labels_filename = os.path.abspath(os.path.join(
os.getcwd(), '')) + "/data/" + args.dataset + "/train.csv"
val_labels_filename = os.path.abspath(os.path.join(
os.getcwd(), '')) + "/data/" + args.dataset + "/val.csv"
test_labels_filename = os.path.abspath(os.path.join(
os.getcwd(), '')) + "/data/" + args.dataset + "/test.csv"
train_dataset = DataGenerator(load_images_into_memory=False,
hdf5_dataset_path=None)
val_dataset = DataGenerator(load_images_into_memory=False,
hdf5_dataset_path=None)
test_dataset = DataGenerator(load_images_into_memory=False,
hdf5_dataset_path=None)
#
train_dataset.parse_csv(
images_dir=images_dir,
labels_filename=train_labels_filename,
input_format=[
'image_name', 'xmin', 'xmax', 'ymin', 'ymax', 'class_id'
],
# This is the order of the first six columns in the CSV file that contains the labels for your dataset. If your labels are in XML format, maybe the XML parser will be helpful, check the documentation.
include_classes='all')
val_dataset.parse_csv(images_dir=images_dir,
labels_filename=val_labels_filename,
input_format=[
'image_name', 'xmin', 'xmax', 'ymin', 'ymax',
'class_id'
],
include_classes='all')
test_dataset.parse_csv(images_dir=images_dir,
labels_filename=test_labels_filename,
input_format=[
'image_name', 'xmin', 'xmax', 'ymin', 'ymax',
'class_id'
],
include_classes='all')
# Optional: Convert the dataset into an HDF5 dataset. This will require more disk space, but will
# speed up the training. Doing this is not relevant in case you activated the `load_images_into_memory`
# option in the constructor, because in that cas the images are in memory already anyway. If you don't
# want to create HDF5 datasets, comment out the subsequent two function calls.
train_dataset.create_hdf5_dataset(
file_path=os.path.abspath(os.path.join(os.getcwd(), '')) + "/data/" +
args.dataset + "/polyp_train.h5",
resize=False,
variable_image_size=True,
verbose=True,
images_dir=images_dir)
val_dataset.create_hdf5_dataset(
file_path=os.path.abspath(os.path.join(os.getcwd(), '')) + "/data/" +
args.dataset + "/polyp_val.h5",
resize=False,
variable_image_size=True,
verbose=True,
images_dir=images_dir)
test_dataset.create_hdf5_dataset(
file_path=os.path.abspath(os.path.join(os.getcwd(), '')) + "/data/" +
args.dataset + "/polyp_test.h5",
resize=False,
variable_image_size=True,
verbose=True,
images_dir=images_dir)
"""
Parse ACTIVE VISION DATASET
"""
from data_generator.object_detection_2d_data_generator import DataGenerator
train_dataset = DataGenerator(load_images_into_memory=False, hdf5_dataset_path=None)
#val_dataset = DataGenerator(load_images_into_memory=False, hdf5_dataset_path=None)
# 2: Parse the image and label lists for the training and validation datasets. This can take a while.
# TODO: Set the paths to the datasets here.
# The directories that contain the images.
AVD_images_dir = '.../ActiveVisionDataset/example_scene/Home_003_1'
AVD_trainval_image_set_filename = '.../ActiveVisionDataset/example_scene/Home_003_1/jpg_rgb/train.txt'
Parse_Out = train_dataset.parse_AVD_json(images_dirs=[AVD_images_dir],
image_set_filenames=[AVD_trainval_image_set_filename],
ret=True)
print(Parse_Out)
"""
train_dataset.create_hdf5_dataset(file_path='dataset_AVD.h5',
resize=False,
variable_image_size=True,
verbose=True)#"""
resize = Resize(height=img_height, width=img_width)
# Images
images_dir = 'your image path/'
# Ground truth
val_labels_filename = 'your csv path/labels_val.csv'
val_dataset = DataGenerator(load_images_into_memory=False, hdf5_dataset_path=None)
# val_dataset = DataGenerator(load_images_into_memory=False, hdf5_dataset_path='your image date save name.h5')
val_dataset.parse_csv(images_dir=images_dir,
labels_filename=val_labels_filename,
input_format=['image_name', 'xmin', 'xmax', 'ymin', 'ymax', 'class_id'],
include_classes='all')
val_dataset.create_hdf5_dataset(file_path='dataset_high_trainval_320_11cls.h5',
resize=(img_height, img_width),
variable_image_size=True,
verbose=True)
val_dataset_size = val_dataset.get_dataset_size()
predict_generator = val_dataset.generate(batch_size=1,
shuffle=False,
transformations=[convert_to_3_channels, resize],
label_encoder=None,
returns={'processed_images',
'filenames',
'inverse_transform',
'original_images',
'original_labels'},
keep_images_without_gt=False)
val_dataset.parse_xml(images_dirs=[images_test_dir],
image_set_filenames=[test_image_set_filename],
annotations_dirs=[annotations_test_dir],
classes=classes,
include_classes='all',
exclude_truncated=False,
exclude_difficult=True,
ret=False)
# Optional: Convert the dataset into an HDF5 dataset. This will require more disk space, but will
# speed up the training. Doing this is not relevant in case you activated the `load_images_into_memory`
# option in the constructor, because in that cas the images are in memory already anyway. If you don't
# want to create HDF5 datasets, comment out the subsequent two function calls.
train_dataset.create_hdf5_dataset(file_path='/home/2017018/rblin01/networks/ssd_keras/dataset_I_trainval.h5',
resize=False,
variable_image_size=True,
verbose=True)
val_dataset.create_hdf5_dataset(file_path='/home/2017018/rblin01/networks/ssd_keras/dataset_I_test.h5',
resize=False,
variable_image_size=True,
verbose=True)
# 3: Set the batch size.
batch_size = 1 # Change the batch size if you like, or if you run into GPU memory issues.
convert_to_3_channels = ConvertTo3Channels()
resize = Resize(height=img_height, width=img_width)
# 5: Instantiate an encoder that can encode ground truth labels into the format needed by the SSD loss function.
train_dataset = DataGenerator(load_images_into_memory=False,
hdf5_dataset_path=None)
train_dataset.parse_xml(
images_dirs=[VOC2007_images_dir, VOC2012_images_dir],
image_set_filenames=[VOC2007_image_set_train, VOC2012_image_set_train],
annotations_dirs=[VOC2007_annotations_dir, VOC2012_annotations_dir],
classes=classes,
include_classes='all',
exclude_truncated=False,
exclude_difficult=False,
ret=False)
train_dataset.create_hdf5_dataset(
file_path=f'{root_path}/data/VOC_07+12_train.h5',
resize=False,
variable_image_size=True,
verbose=True)
if 'valid' in datasets:
val_dataset = DataGenerator(load_images_into_memory=False,
hdf5_dataset_path=None)
val_dataset.parse_xml(
images_dirs=[VOC2007_images_dir, VOC2012_images_dir],
image_set_filenames=[VOC2007_image_set_val, VOC2012_image_set_val],
annotations_dirs=[VOC2007_annotations_dir, VOC2012_annotations_dir],
classes=classes,
include_classes='all',
exclude_truncated=False,
exclude_difficult=True,
val_dataset.parse_xml(images_dirs=[VOC_2007_images_dir],
image_set_filenames=[VOC_2007_val_image_set_filename],
annotations_dirs=[VOC_2007_annotations_dir],
classes=classes,
include_classes='all',
exclude_truncated=False,
exclude_difficult=True,
ret=False)
# Optional: Convert the dataset into an HDF5 dataset. This will require more disk space, but will
# speed up the training. Doing this is not relevant in case you activated the `load_images_into_memory`
# option in the constructor, because in that cas the images are in memory already anyway. If you don't
# want to create HDF5 datasets, comment out the subsequent two function calls.
train_dataset.create_hdf5_dataset(file_path='/home/ogai1234/lala/ssd_keras-master/tia_trained_weight/dataset_pascal_voc_07+12_trainval.h5',
resize=False,
variable_image_size=True,
verbose=True)
val_dataset.create_hdf5_dataset(file_path='dataset_pascal_voc_07_test.h5',
resize=False,
variable_image_size=True,
verbose=True)
# 3: Set the batch size.
batch_size = 32 # Change the batch size if you like, or if you run into GPU memory issues.
# 4: Set the image transformations for pre-processing and data augmentation options.
# For the training generator:
ssd_data_augmentation = SSDDataAugmentation(img_height=img_height,
val_dataset.parse_xml(images_dirs=[VOC_2007_images_dir],
image_set_filenames=[VOC_2007_test_image_set_filename],
annotations_dirs=[VOC_2007_annotations_dir],
classes=classes,
include_classes='all',
exclude_truncated=False,
exclude_difficult=True,
ret=False)
# Optional: Convert the dataset into an HDF5 dataset. This will require more disk space, but will
# speed up the training. Doing this is not relevant in case you activated the `load_images_into_memory`
# option in the constructor, because in that cas the images are in memory already anyway. If you don't
# want to create HDF5 datasets, comment out the subsequent two function calls.
train_dataset.create_hdf5_dataset(file_path='dataset_raccoon_trainval.h5',
resize=False,
variable_image_size=True,
verbose=True)
val_dataset.create_hdf5_dataset(file_path='dataset_raccoon_test.h5',
resize=False,
variable_image_size=True,
verbose=True)
#import h5py
#with h5py.File('input/file.hdf5dataset_raccon_trainval.h5', 'r') as f:
# x_data = f['x_data']
#
# 3: Set the batch size.
#batch_size = 32 # Change the batch size if you like, or if you run into GPU memory issues.
batch_size = 2 # Change the batch size if you like, or if you run into GPU memory issues.
], # This is the order of the first six columns in the CSV file that contains the labels for your dataset. If your labels are in XML format, maybe the XML parser will be helpful, check the documentation.
include_classes='all')
val_dataset.parse_csv(
images_dir=images_dir,
labels_filename=val_labels_filename,
input_format=['image_name', 'xmin', 'ymin', 'xmax', 'ymax', 'class_id'],
include_classes='all')
# Optional: Convert the dataset into an HDF5 dataset. This will require more disk space, but will
# speed up the training. Doing this is not relevant in case you activated the `load_images_into_memory`
# option in the constructor, because in that cas the images are in memory already anyway. If you don't
# want to create HDF5 datasets, comment out the subsequent two function calls.
train_dataset.create_hdf5_dataset(file_path='train_imgs.h5',
resize=False,
variable_image_size=True,
verbose=True)
val_dataset.create_hdf5_dataset(file_path='val_imgs.h5',
resize=False,
variable_image_size=True,
verbose=True)
# Get the number of samples in the training and validations datasets.
train_dataset_size = train_dataset.get_dataset_size()
val_dataset_size = val_dataset.get_dataset_size()
print("Number of images in the training dataset:\t{:>6}".format(
train_dataset_size))
print("Number of images in the validation dataset:\t{:>6}".format(
val_dataset_size))
val_dataset.parse_xml(images_dirs=[test_images_dir],
image_set_filenames=[test_set_filename],
annotations_dirs=[test_annotation_dir],
classes=['background', 'cone'],
include_classes='all',
exclude_truncated=False,
exclude_difficult=False,
ret=False,
verbose=True)
# Optional: Convert the dataset into an HDF5 dataset. This will require more disk space, but will
# speed up the training. Doing this is not relevant in case you activated the `load_images_into_memory`
# option in the constructor, because in that cas the images are in memory already anyway. If you don't
# want to create HDF5 datasets, comment out the subsequent two function calls.
'''
train_dataset.create_hdf5_dataset(file_path='dataset_cone_train.h5',
resize=False,
variable_image_size=True,
verbose=True)
val_dataset.create_hdf5_dataset(file_path='dataset_cone_val.h5',
resize=False,
variable_image_size=True,
verbose=True)
'''
# train_dataset.load_hdf5_dataset('dataset_cone_train.h5')
# val_dataset.load_hdf5_dataset('dataset_cone_val.h5')
# Get the number of samples in the training and validations datasets.
train_dataset_size = train_dataset.get_dataset_size()
], # This is the order of the first six columns in the CSV file that contains the labels for your dataset. If your labels are in XML format, maybe the XML parser will be helpful, check the documentation.
include_classes='all')
val_dataset.parse_csv(
images_dir=images_dir,
labels_filename=val_labels_filename,
input_format=['image_name', 'xmin', 'xmax', 'ymin', 'ymax', 'class_id'],
include_classes='all')
# Optional: Convert the dataset into an HDF5 dataset. This will require more disk space, but will
# speed up the training. Doing this is not relevant in case you activated the `load_images_into_memory`
# option in the constructor, because in that cas the images are in memory already anyway. If you don't
# want to create HDF5 datasets, comment out the subsequent two function calls.
train_dataset.create_hdf5_dataset(file_path='dataset_udacity_traffic_train.h5',
resize=False,
variable_image_size=True,
verbose=True)
val_dataset.create_hdf5_dataset(file_path='dataset_udacity_traffic_val.h5',
resize=False,
variable_image_size=True,
verbose=True)
# Get the number of samples in the training and validations datasets.
train_dataset_size = train_dataset.get_dataset_size()
val_dataset_size = val_dataset.get_dataset_size()
print("Number of images in the training dataset:\t{:>6}".format(
train_dataset_size))
print("Number of images in the validation dataset:\t{:>6}".format(
val_dataset_size))
train_dataset.parse_csv(
images_dir, labels_file_train,
['image_name', 'xmin', 'xmax', 'ymin', 'ymax', 'class_id'])
val_dataset.parse_csv(
images_dir, labels_file_test,
['image_name', 'xmin', 'xmax', 'ymin', 'ymax', 'class_id'])
# Optional: Convert the dataset into an HDF5 dataset. This will require more disk space, but will
# speed up the training. Doing this is not relevant in case you activated the `load_images_into_memory`
# option in the constructor, because in that cas the images are in memory already anyway. If you don't
# want to create HDF5 datasets, comment out the subsequent two function calls.
train_dataset.create_hdf5_dataset(
file_path='../datasets/belgas_train_dataset.h5',
resize=False,
variable_image_size=True,
verbose=True)
val_dataset.create_hdf5_dataset(file_path='../datasets/belgas_val_dataset.h5',
resize=False,
variable_image_size=True,
verbose=True)
# In[8]:
# 3: Set the batch size.
batch_size = 32 # Change the batch size if you like, or if you run into GPU memory issues.
# 4: Set the image transformations for pre-processing and data augmentation options.
def test_config(config):
'''
Test the given configuration ; the configuration should already have been
used for training purposes, or this will return an error (see ssd_train.py)
Arguments:
config : the configuration of the model to use ; should already be
loaded.
'''
local_dir = config.ROOT_FOLDER
data_dir = config.DATA_DIR
img_shape = config.IMG_SHAPE
img_height = img_shape[0] # Height of the model input images
img_width = img_shape[1] # Width of the model input images
img_channels = img_shape[
2] # Number of color channels of the model input images
n_classes = 20 # Number of positive classes, e.g. 20 for Pascal VOC, 80 for MS COCO
normalize_coords = True
K.clear_session() # Clear previous models from memory.
print("[INFO] loading model...")
model_path = os.path.join(local_dir, 'models', config.MODEL_NAME)
# We need to create an SSDLoss object in order to pass that to the model loader.
ssd_loss = SSDLoss(neg_pos_ratio=3, n_neg_min=0, alpha=1.0)
model = load_model(model_path,
custom_objects={
'AnchorBoxes': AnchorBoxes,
'L2Normalization': L2Normalization,
'DecodeDetections': DecodeDetections,
'compute_loss': ssd_loss.compute_loss
})
classes = config.CLASSES
dataset = DataGenerator(load_images_into_memory=False,
hdf5_dataset_path=None)
dataset_images_dir = os.path.join(data_dir, 'Images')
dataset_annotations_dir = os.path.join(data_dir, 'Annotations/')
dataset_test_image_set_filename = os.path.join(data_dir,
'ImageSets\\test.txt')
dataset.parse_xml(images_dirs=[dataset_images_dir],
image_set_filenames=[dataset_test_image_set_filename],
annotations_dirs=[dataset_annotations_dir],
classes=classes,
include_classes='all',
exclude_truncated=False,
exclude_difficult=True,
ret=False)
dataset.create_hdf5_dataset(file_path=config.MODEL_NAME,
resize=False,
variable_image_size=True,
verbose=True)
convert_to_3_channels = ConvertTo3Channels()
resize = Resize(height=img_height, width=img_width)
dataset_size = dataset.get_dataset_size()
print("Number of images in the dataset:\t{:>6}".format(dataset_size))
predict_generator = dataset.generate(
batch_size=config.PREDICT_BATCH_SIZE,
shuffle=True,
transformations=[convert_to_3_channels, resize],
label_encoder=None,
returns={
'processed_images', 'filenames', 'inverse_transform',
'original_images', 'original_labels'
},
keep_images_without_gt=False)
count = 0
while True and count < dataset_size:
batch_images, batch_filenames, batch_inverse_transforms, batch_original_images, batch_original_labels = next(
predict_generator)
i = 0
print("Image:", batch_filenames[i])
print()
print("Ground truth boxes:\n")
print(np.array(batch_original_labels[i]))
y_pred = model.predict(batch_images)
y_pred_decoded = decode_detections(y_pred,
confidence_thresh=0.5,
iou_threshold=0.4,
top_k=200,
normalize_coords=normalize_coords,
img_height=img_height,
img_width=img_width)
y_pred_decoded_inv = apply_inverse_transforms(
y_pred_decoded, batch_inverse_transforms)
np.set_printoptions(precision=2, suppress=True, linewidth=90)
print("Predicted boxes:\n")
print(' class conf xmin ymin xmax ymax')
print(y_pred_decoded_inv[i])
# cv2.imshow('original image',batch_original_images[i])
# cv2.waitKey(800)
# cv2.destroyAllWindows()
colors = plt.cm.hsv(np.linspace(0, 1, n_classes + 1)).tolist()
plt.figure(figsize=(15, 8))
plt.imshow(batch_original_images[i])
current_axis = plt.gca()
len_orig = 0
for box in batch_original_labels[i]:
len_orig += 1
xmin = box[1]
ymin = box[2]
xmax = box[3]
ymax = box[4]
label = '{}'.format(classes[int(box[0])])
current_axis.add_patch(
plt.Rectangle((xmin, ymin),
xmax - xmin,
ymax - ymin,
color='green',
fill=False,
linewidth=2))
current_axis.text(xmin,
ymin,
label,
size='x-large',
color='white',
bbox={
'facecolor': 'green',
'alpha': 1.0
})
len_found = 0
for box in y_pred_decoded_inv[i]:
len_found += 1
xmin = box[2]
ymin = box[3]
xmax = box[4]
ymax = box[5]
color = colors[int(box[0])]
label = '{}: {:.2f}'.format(classes[int(box[0])], box[1])
current_axis.add_patch(
plt.Rectangle((xmin, ymin),
xmax - xmin,
ymax - ymin,
color=color,
fill=False,
linewidth=2))
current_axis.text(xmin,
ymin,
label,
size='x-large',
color='white',
bbox={
'facecolor': color,
'alpha': 1.0
})
print('Number of original boxes : {}'.format(len_orig))
print('Number of found boxes : {}'.format(len_found))
plt.show()
count += 1
image_set_filenames=[validation_setFileName],
annotations_dirs=[validation_annotations_path],
classes=classes,
include_classes='all',
exclude_truncated=False,
exclude_difficult=True,
ret=False)
# Optional: Convert the dataset into an HDF5 dataset. This will require more disk space, but will
# speed up the training. Doing this is not relevant in case you activated the `load_images_into_memory`
# option in the constructor, because in that cas the images are in memory already anyway. If you don't
# want to create HDF5 datasets, comment out the subsequent two function calls.
train_dataset.create_hdf5_dataset(
file_path='../ConeData/dataset_cones_train.h5',
resize=False,
variable_image_size=True,
verbose=True)
val_dataset.create_hdf5_dataset(
file_path='../ConeData/dataset_cones_validation.h5',
resize=False,
variable_image_size=True,
verbose=True)
# In[6]:
# 3: Set the batch size.
batch_size = 5 # 32 # Change the batch size if you like, or if you run into GPU memory issues.
if cfgs.CREATE_IMAGE_H5:
val_dataset = DataGenerator(load_images_into_memory=False,
hdf5_dataset_path=None)
else:
val_dataset = DataGenerator(load_images_into_memory=False,
hdf5_dataset_path=cfgs.TEST_HDF_DATASET)
val_dataset.parse_csv(
images_dir=cfgs.IMAGE_DIR,
labels_filename=cfgs.TEST_LABEL_FILENAME,
input_format=['image_name', 'xmin', 'xmax', 'ymin', 'ymax', 'class_id'],
include_classes='all')
if cfgs.CREATE_IMAGE_H5:
val_dataset.create_hdf5_dataset(file_path=cfgs.TEST_HDF_DATASET,
resize=(cfgs.IMG_SHORT_SIDE_LEN,
cfgs.IMG_SHORT_SIDE_LEN),
variable_image_size=True,
verbose=True)
val_dataset_size = val_dataset.get_dataset_size()
predict_generator = val_dataset.generate(
batch_size=1,
shuffle=False,
transformations=[convert_to_3_channels, resize],
label_encoder=None,
returns={
'processed_images', 'filenames', 'inverse_transform',
'original_images', 'original_labels'
},
keep_images_without_gt=False)
n_classes = 7
hdf5_dataset_path=None)
train_dataset.parse_json(images_dirs=images_dir,
annotations_filenames=["output_train.json"],
ground_truth_available=True,
include_classes=use_list)
val_dataset = DataGenerator(load_images_into_memory=False,
hdf5_dataset_path=None)
val_dataset.parse_json(images_dirs=images_dir,
annotations_filenames=["output_test.json"],
ground_truth_available=True,
include_classes=use_list)
val_dataset.create_hdf5_dataset(file_path='val_dataset.h5',
resize=(1200, 1600),
variable_image_size=True,
verbose=True)
train_generator = train_dataset.generate(
batch_size=1,
shuffle=True,
transformations=[],
label_encoder=None,
returns={'processed_images', 'processed_labels', 'filenames'},
keep_images_without_gt=False)
batch_images, batch_labels, batch_filenames = next(train_generator)
# 5: Draw the predicted boxes onto the image
plt.figure(figsize=(20, 12))
