# optimizer, otherwise I'd recommend the commented-out Adam optimizer.
#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)
#Set up the data generators for the training
# 1: Instantiate two `DataGenerator` objects: One for training, one for validation.
# Optional: If you have enough memory, consider loading the images into memory for the reasons explained above.
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.
VOC_2007_images_dir = '../../datasets/VOCdevkit/VOC2007/JPEGImages/'
# The directories that contain the annotations.
VOC_2007_annotations_dir = '../../datasets/VOCdevkit/VOC2007/Annotations/'
# The paths to the image sets.
VOC_2007_train_image_set_filename = '../../datasets/VOCdevkit/VOC2007/ImageSets/Main/train.txt'
# 加载之前保存的模型或者创建新模型
K.clear_session() # Clear previous models from memory.
if os.path.exists(model_saved):
# We need to create an SSDLoss object in order to pass that to the model loader.
ssd_loss = SSDLoss(neg_pos_ratio=3, alpha=1.0)
model = load_model(model_saved,
custom_objects={
'AnchorBoxes': AnchorBoxes,
'compute_loss': ssd_loss.compute_loss
})
else:
logger.error(f'无法加载训练好的模型:{model_saved}')
val_dataset = DataGenerator(load_images_into_memory=False,
hdf5_dataset_path=dataset_prefix +
'traffic_val.h5')
val_dataset_size = val_dataset.get_dataset_size()
logger.info("Number of images in the validation dataset:\t{:>6}".format(
val_dataset_size))
predictor_sizes = [
model.get_layer('classes4').output_shape[1:3],
model.get_layer('classes5').output_shape[1:3],
model.get_layer('classes6').output_shape[1:3],
model.get_layer('classes7').output_shape[1:3]
]
ssd_input_encoder = SSDInputEncoder(img_height=img_height,
img_width=img_width,
n_classes=n_classes,
def run(train_dir, valid_dir, set_dir, model_dir):
# train_dir = arguments.train_dir
# valid_dir = arguments.valid_dir
train_dataset_dir = train_dir
train_annot_dir = train_dir + '/annot/'
train_set = train_dir + '/img_set.txt'
valid_dataset_dir = valid_dir
valid_annot_dir = valid_dir + '/annot/'
valid_set = valid_dir + '/valid_set.txt'
# Set Training and Validation dataset paths
batch_size = 16
print('Using batch size of: {}'.format(batch_size))
#model_path = 'COCO_512.h5'
model_path = model_dir
# model_path = 'saved_model.h5'
# Needs to know classes and order to map to integers
classes = ['background', 'car', 'bus', 'truck']
# Set required parameters for training of SSD
img_height = 512
img_width = 512
img_channels = 3 # Colour image
mean_color = [123, 117, 104] # DO NOT CHANGE
swap_channels = [2, 1, 0] # Original SSD used BGR
n_classes = 3 # 80 for COCO
scales_coco = [0.04, 0.1, 0.26, 0.42, 0.58, 0.74, 0.9, 1.06]
scales = scales_coco
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, 3.0, 1.0 / 3.0], [1.0, 2.0, 0.5],
[1.0, 2.0, 0.5]]
two_boxes_for_ar1 = True
steps = [8, 16, 32, 64, 128, 256, 512]
offsets = [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5]
clip_boxes = False
variances = [0.1, 0.1, 0.2, 0.2]
normalize_coords = True
K.clear_session()
model = ssd_512(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)
model.load_weights(model_path, by_name=True)
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)
# model = load_model(model_path, custom_objects={'AnchorBoxes': AnchorBoxes,
# 'L2Normalization': L2Normalization,
# 'compute_loss': ssd_loss.compute_loss})
# Create Data Generators for train and valid sets
train_dataset = DataGenerator(load_images_into_memory=False,
hdf5_dataset_path=None)
valid_dataset = DataGenerator(load_images_into_memory=False,
hdf5_dataset_path=None)
train_dataset.parse_xml(images_dirs=[train_dataset_dir],
image_set_filenames=[train_set],
annotations_dirs=[train_annot_dir],
classes=classes,
include_classes='all',
exclude_truncated=False,
exclude_difficult=False,
ret=False)
valid_dataset.parse_xml(images_dirs=[valid_dataset_dir],
image_set_filenames=[valid_set],
annotations_dirs=[valid_annot_dir],
classes=classes,
include_classes='all',
exclude_truncated=False,
exclude_difficult=False,
ret=False)
# Will speed up trainig but requires more memory
# Can comment out to avoid memory requirements
'''
train_dataset.create_hdf5_dataset(file_path='dataset_pascal_voc_07+12_trainval.h5',
resize=False,
variable_image_size=True,
verbose=True)
valid_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=img_height,
img_width=img_width,
background=mean_color)
convert_to_3_channels = ConvertTo3Channels()
resize = Resize(height=img_height, width=img_width)
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],
model.get_layer('conv10_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 = valid_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()
valid_dataset_size = valid_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(
valid_dataset_size))
model_checkpoint = ModelCheckpoint(
filepath=
'ssd_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='ssd512_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
]
#callbacks = [learning_rate_scheduler,
# terminate_on_nan]
initial_epoch = 0
final_epoch = 150 # 150
steps_per_epoch = math.ceil(119 /
batch_size) # ceil(num_samples/batch_size)
# Training
history = model.fit_generator(generator=train_generator,
steps_per_epoch=steps_per_epoch,
epochs=final_epoch,
callbacks=callbacks,
validation_data=val_generator,
validation_steps=math.ceil(
valid_dataset_size / batch_size),
initial_epoch=initial_epoch)
# Save final trained model
model.save('trained.h5')
# Make predictions
predict_generator = valid_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)
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]))
y_pred = model.predict(batch_images)
y_pred_decoded = decode_detections(y_pred,
confidence_thresh=0.2,
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])
# Set the colors for the bounding boxes
colors = plt.cm.hsv(np.linspace(0, 1, n_classes + 1)).tolist()
# classes = ['background', 'car', 'bus', 'truck', 'motorbike'] # Already set at start
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
})
plt.show()
return
# 2: Load the trained weights into the model. weights_path = "C:/Users/t_tor/Unsynced/ssd_weights/VGG_VOC0712Plus_SSD_300x300_ft_iter_160000.h5" model.load_weights(weights_path, by_name=True) # 3: Compile the model so that Keras won't complain the next time you load it. 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) dataset = DataGenerator() # The directories that contain the images. images = "C:/Users/t_tor/Unsynced/complete_dataset/jpeg/" # The directories that contain the annotations. annotations = "C:/Users/t_tor/Unsynced/complete_dataset/annotations/" # The paths to the image sets. imagenet_images = "C:/Users/t_tor/Unsynced/complete_dataset/imagenet_images.txt" custom_images = "C:/Users/t_tor/Unsynced/complete_dataset/custom_images.txt" coco_images = "C:/Users/t_tor/Unsynced/complete_dataset/coco_images.txt" voc07test_images = "C:/Users/t_tor/Unsynced/complete_dataset/voc07_test.txt" # The XML parser needs to now what object class names to look for and in which order to map them to integers. #classes = ['background', 'boat']
def load_VOC_IMG_generators(self,model):
print('Making VOC image generators')
datadir = self.datas['DATA_PATH']
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)
images_dir = os.path.join(datadir,'Images')
annotations_dir = os.path.join(datadir,'Annotations')
train_image_set_filename = os.path.join(datadir,'ImageSets','train.txt')
val_image_set_filename = os.path.join(datadir,'ImageSets','val.txt')
test_image_set_filename = os.path.join(datadir,'ImageSets','test.txt')
generator_options = self.datas['GENERATOR']
train_dataset.parse_xml(images_dirs=[images_dir],
image_set_filenames=[train_image_set_filename],
annotations_dirs=[annotations_dir],
classes=self.datas['CLASSES'],
include_classes='all',
exclude_truncated=False,
exclude_difficult=False,
ret=False)
val_dataset.parse_xml(images_dirs=[images_dir],
image_set_filenames=[val_image_set_filename],
annotations_dirs=[annotations_dir],
classes=self.datas['CLASSES'],
include_classes='all',
exclude_truncated=False,
exclude_difficult=False,
ret=False)
test_dataset.parse_xml(images_dirs=[images_dir],
image_set_filenames=[test_image_set_filename],
annotations_dirs=[annotations_dir],
classes=self.datas['CLASSES'],
include_classes='all',
exclude_truncated=False,
exclude_difficult=False,
ret=False)
convert_to_3_channels = ConvertTo3Channels()
target_size = generator_options['TARGET_SIZE']
resize = Resize(height=target_size[0], width=target_size[1])
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]]
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
steps = [8, 16, 32, 64, 100, 300] # The space between two adjacent anchor box center points for each predictor layer.
two_boxes_for_ar1 = True
mean_color=[123,117,104] #TODO : add this as a parameter
offsets = [0.5, 0.5, 0.5, 0.5, 0.5, 0.5]
clip_boxes=False
variances=[0.1, 0.1, 0.2, 0.2]
normalize_coords=True
ssd_input_encoder = SSDInputEncoder(img_height = target_size[0],
img_width = target_size[1],
n_classes = 20, #TODO : handle subsampling
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=generator_options['BATCH_SIZE'],
shuffle=True,
transformations=[convert_to_3_channels,
resize],
label_encoder=ssd_input_encoder,
returns={'processed_images',
'encoded_labels'},
keep_images_without_gt=False)
val_generator = val_dataset.generate(batch_size=generator_options['BATCH_SIZE'],
shuffle=True,
transformations=[convert_to_3_channels,
resize],
label_encoder=ssd_input_encoder,
returns={'processed_images',
'encoded_labels'},
keep_images_without_gt=False)
test_generator = test_dataset.generate(batch_size=generator_options['BATCH_SIZE'],
shuffle=True,
transformations=[convert_to_3_channels,
resize],
label_encoder=ssd_input_encoder,
returns={'processed_images',
'encoded_labels'},
keep_images_without_gt=False)
return [train_generator,train_dataset.get_dataset_size()],[val_generator,val_dataset.get_dataset_size()],[test_generator,train_dataset.get_dataset_size()]
def data_generator_func(config: Dict):
"""Data Generator for training data and validation data
Parameters
----------
config : Dict
Config yaml/json containing all parameter
Returns
-------
train_dataset, val_dataset
"""
# Init DataGenerator
start_data = timer()
train_dataset = DataGenerator(load_images_into_memory=config['training']
['train_load_images_into_memory'],
hdf5_dataset_path=None)
val_dataset = DataGenerator(load_images_into_memory=config['training']
['validation_load_images_into_memory'],
hdf5_dataset_path=None)
if config['training']['train_load_images_into_memory'] is not False:
print("[INFO]... You have chosen to load data into memory")
else:
print(
"[WARNING]... You have chosen not to load data into memory. It will still work but will be much slower"
)
train_img_dir = config['training']['train_img_dir']
val_img_dir = config['training']['val_img_dir']
train_annotation_dir = config['training']['train_annotation_dir']
val_annotation_dir = config['training']['val_annotation_dir']
train_image_set_filename = config['training']['train_image_set_filename']
val_image_set_filename = config['training']['val_image_set_filename']
classes = config['training']['classes']
if config['training']['annotation_type'] == 'xml':
train_dataset.parse_xml(images_dirs=[train_img_dir],
image_set_filenames=[train_image_set_filename],
annotations_dirs=[train_annotation_dir],
classes=classes,
include_classes='all',
exclude_truncated=False,
exclude_difficult=False,
ret=False)
val_dataset.parse_xml(images_dirs=[val_img_dir],
image_set_filenames=[val_image_set_filename],
annotations_dirs=[val_annotation_dir],
classes=classes,
include_classes='all',
exclude_truncated=False,
exclude_difficult=True,
ret=False)
if config['training']['annotation_type'] == 'csv':
train_dataset.parse_csv(images_dir=train_img_dir,
labels_filename=train_annotation_dir,
input_format=[
'image_name', 'xmin', 'xmax', 'ymin',
'ymax', 'class_id'
],
include_classes='all')
val_dataset.parse_csv(images_dir=val_img_dir,
labels_filename=val_annotation_dir,
input_format=[
'image_name', 'xmin', 'xmax', 'ymin', 'ymax',
'class_id'
],
include_classes='all')
end_data = timer()
print(
f"[INFO]...Time taken by Data loading/transformation Job is {(end_data - start_data)/60:.2f} min(s)"
)
return train_dataset, val_dataset
# The `DataGenerator` itself is fairly generic. I doesn't contain any data augmentation or bounding box encoding logic. Instead, you pass a list of image transformations and an encoder for the bounding boxes in the `transformations` and `label_encoder` arguments of the data generator's `generate()` method, and the data generator will then apply those given transformations and the encoding to the data. Everything here is preset already, but if you'd like to learn more about the data generator and its data augmentation capabilities, take a look at the detailed tutorial in [this](https://github.com/pierluigiferrari/data_generator_object_detection_2d) repository.
#
# The data augmentation settings defined further down reproduce the data augmentation pipeline of the original SSD training. The training generator receives an object `ssd_data_augmentation`, which is a transformation object that is itself composed of a whole chain of transformations that replicate the data augmentation procedure used to train the original Caffe implementation. The validation generator receives an object `resize`, which simply resizes the input images.
#
# An `SSDInputEncoder` object, `ssd_input_encoder`, is passed to both the training and validation generators. As explained above, it matches the ground truth labels to the model's anchor boxes and encodes the box coordinates into the format that the model needs.
#
# In order to train the model on a dataset other than Pascal VOC, either choose `DataGenerator`'s appropriate parser method that corresponds to your data format, or, if `DataGenerator` does not provide a suitable parser for your data format, you can write an additional parser and add it. Out of the box, `DataGenerator` can handle datasets that use the Pascal VOC format (use `parse_xml()`), the MS COCO format (use `parse_json()`) and a wide range of CSV formats (use `parse_csv()`).
# In[ ]:
# 1: Instantiate two `DataGenerator` objects: One for training, one for validation.
# Optional: If you have enough memory, consider loading the images into memory for the reasons explained above.
train_dataset = DataGenerator(
load_images_into_memory=False,
hdf5_dataset_path='dataset_udacity_traffic_train.h5')
val_dataset = DataGenerator(load_images_into_memory=False,
hdf5_dataset_path='dataset_udacity_traffic_val.h5')
# 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.
# VOC_2007_images_dir = '../../datasets/VOCdevkit/VOC2007/JPEGImages/'
# VOC_2012_images_dir = '../../datasets/VOCdevkit/VOC2012/JPEGImages/'
# The directories that contain the annotations.
# VOC_2007_annotations_dir = '../../datasets/VOCdevkit/VOC2007/Annotations/'
# VOC_2012_annotations_dir = '../../datasets/VOCdevkit/VOC2012/Annotations/'
print("Weights file loaded:", weights_path)
# 3: Instantiate an Adam optimizer and the SSD loss function and compile the model.
adam = Adam(lr=0.00001, 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)
# 1: Instantiate two `DataGenerator` objects: One for training, one for validation.
# Optional: If you have enough memory, consider loading the images into memory for the reasons explained above.
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.
images_train_dir = '/home/2017018/rblin01/BD_QCAV/train_polar/PARAM_POLAR/RetinaNet_Stokes'
images_test_dir = '/home/2017018/rblin01/BD_QCAV/test_polar/PARAM_POLAR/RetinaNet_Stokes'
# The directories that contain the annotations.
annotations_train_dir = '/home/2017018/rblin01/BD_QCAV/train_polar/LABELS'
annotations_test_dir = '/home/2017018/rblin01/BD_QCAV/test_polar/LABELS'
# The paths to the image sets.
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)
# The `DataGenerator` itself is fairly generic. I doesn't contain any data augmentation or bounding box encoding logic. Instead, you pass a list of image transformations and an encoder for the bounding boxes in the `transformations` and `label_encoder` arguments of the data generator's `generate()` method, and the data generator will then apply those given transformations and the encoding to the data. Everything here is preset already, but if you'd like to learn more about the data generator and its data augmentation capabilities, take a look at the detailed tutorial in [this](https://github.com/pierluigiferrari/data_generator_object_detection_2d) repository. # # The data augmentation settings defined further down reproduce the data augmentation pipeline of the original SSD training. The training generator receives an object `ssd_data_augmentation`, which is a transformation object that is itself composed of a whole chain of transformations that replicate the data augmentation procedure used to train the original Caffe implementation. The validation generator receives an object `resize`, which simply resizes the input images. # # An `SSDInputEncoder` object, `ssd_input_encoder`, is passed to both the training and validation generators. As explained above, it matches the ground truth labels to the model's anchor boxes and encodes the box coordinates into the format that the model needs. # # In order to train the model on a dataset other than Pascal VOC, either choose `DataGenerator`'s appropriate parser method that corresponds to your data format, or, if `DataGenerator` does not provide a suitable parser for your data format, you can write an additional parser and add it. Out of the box, `DataGenerator` can handle datasets that use the Pascal VOC format (use `parse_xml()`), the MS COCO format (use `parse_json()`) and a wide range of CSV formats (use `parse_csv()`). # 1: Instantiate two `DataGenerator` objects: One for training, one for validation. # Optional: If you have enough memory, consider loading the images into memory for the reasons explained above. # train_dataset = DataGenerator(load_images_into_memory=False, hdf5_dataset_path=None) # val_dataset = DataGenerator(load_images_into_memory=False, hdf5_dataset_path=None) train_dataset = DataGenerator(load_images_into_memory=False, hdf5_dataset_path='dataset_pascal_voc_07+12_trainval.h5') val_dataset = DataGenerator(load_images_into_memory=False, hdf5_dataset_path='dataset_pascal_voc_07_test.h5') # 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. VOC_2007_images_dir = '../../datasets/VOCdevkit/VOC2007/JPEGImages/' VOC_2012_images_dir = '../../datasets/VOCdevkit/VOC2012/JPEGImages/' # The directories that contain the annotations. VOC_2007_annotations_dir = '../../datasets/VOCdevkit/VOC2007/Annotations/' VOC_2012_annotations_dir = '../../datasets/VOCdevkit/VOC2012/Annotations/' # The paths to the image sets.
#
# The image processing chain defined further down in the object named `data_augmentation_chain` is just one possibility of what a data augmentation pipeline for unform-size images could look like. Feel free to put together other image processing chains, you can use the `DataAugmentationConstantInputSize` class as a template. Or you could use the original SSD data augmentation pipeline by instantiting an `SSDDataAugmentation` object and passing that to the generator instead. This procedure is not exactly efficient, but it evidently produces good results on multiple datasets.
#
# An `SSDInputEncoder` object, `ssd_input_encoder`, is passed to both the training and validation generators. As explained above, it matches the ground truth labels to the model's anchor boxes and encodes the box coordinates into the format that the model needs.
# ### Note:
#
# The example setup below was used to train SSD7 on two road traffic datasets released by [Udacity](https://github.com/udacity/self-driving-car/tree/master/annotations) with around 20,000 images in total and 5 object classes (car, truck, pedestrian, bicyclist, traffic light), although the vast majority of the objects are cars. The original datasets have a constant image size of 1200x1920 RGB. I consolidated the two datasets, removed a few bad samples (although there are probably many more), and resized the images to 300x480 RGB, i.e. to one sixteenth of the original image size. In case you'd like to train a model on the same dataset, you can download the consolidated and resized dataset I used [here](https://drive.google.com/open?id=1tfBFavijh4UTG4cGqIKwhcklLXUDuY0D) (about 900 MB).
# In[4]:
# 1: Instantiate two `DataGenerator` objects: One for training, one for validation.
# Optional: If you have enough memory, consider loading the images into memory for the reasons explained above.
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.
# TODO: Set the paths to your dataset here.
# Images
images_dir = '../gray_images/'
# Ground truth
train_labels_filename = '../train.csv'
val_labels_filename = '../val.csv'
train_dataset.parse_csv(
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
# 1: Instantiate two `DataGenerator` objects: One for training, one for validation.
# Optional: If you have enough memory, consider loading the images into memory for the reasons explained above.
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.
dataset_dir = 'D:/Develop/data/raccoon_dataset/'
# The directories that contain the images.
VOC_2007_images_dir = 'D:/Develop/data/VOCdevkit/VOC2007/JPEGImages/'
VOC_2007_images_dir = 'D:/Develop/data/raccoon_dataset/images/'
VOC_2007_images_dir = dataset_dir + 'images/'
#VOC_2012_images_dir = 'D:/Develop/data/VOCdevkit/VOC2012/JPEGImages/'
# Make datagen
images_dir = '../FLIR_ADAS/validation/PreviewData'
annotation_csv = '../validation.csv'
input_format = ["image_name", "class_id", "xmin", "xmax", "ymin",
"ymax"] # order of columns in csv
#dataset = DataGenerator()
#dataset.parse_csv(
# images_dir,
# annotation_csv,
# input_format,
# verbose=True
# )
dataset = DataGenerator(load_images_into_memory=False,
hdf5_dataset_path='./validation.h5')
evaluator = Evaluator(model=model,
n_classes=n_classes,
data_generator=dataset,
model_mode=model_mode)
results = evaluator(img_height=img_height,
img_width=img_width,
batch_size=32,
data_generator_mode='resize',
round_confidences=False,
matching_iou_threshold=0.5,
border_pixels='include',
sorting_algorithm='quicksort',
average_precision_mode='sample',
def main():
model_mode = 'inference'
K.clear_session() # Clear previous models from memory.
model = build_model(image_size=(Config.img_height, Config.img_width, Config.img_channels),
n_classes=Config.n_classes, mode=model_mode, l2_regularization=Config.l2_regularization,
scales=Config.scales,
aspect_ratios_per_layer=Config.steps,
two_boxes_for_ar1=True, steps=Config.steps, offsets=Config.offsets, clip_boxes=False,
variances=Config.variances, normalize_coords=Config.normalize_coords,
subtract_mean=Config.intensity_mean,
swap_channels=[2, 1, 0], confidence_thresh=0.01, iou_threshold=0.45, top_k=200,
nms_max_output_size=400)
# 2: Load the trained weights into the model.
weights_path = os.getcwd() + '/weights/' + args.model_name + ".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)
ssd_loss = SSDLoss(neg_pos_ratio=3, alpha=1.0)
model.compile(optimizer=adam, loss=ssd_loss.compute_loss)
test_dataset = DataGenerator(load_images_into_memory=True,
hdf5_dataset_path=os.getcwd() + "/data/" + args.dataset + '/polyp_test.h5')
test_dataset_size = test_dataset.get_dataset_size()
print("Number of images in the test dataset:\t{:>6}".format(test_dataset_size))
classes = ['background', 'polyp']
evaluator = Evaluator(model=model, n_classes=Config.n_classes, data_generator=test_dataset, model_mode=model_mode)
results = evaluator(img_height=Config.img_height, img_width=Config.img_width, batch_size=args.batch_size,
data_generator_mode='resize',
round_confidences=False, matching_iou_threshold=0.5, border_pixels='include',
sorting_algorithm='quicksort',
average_precision_mode='sample', num_recall_points=11, ignore_neutral_boxes=True,
return_precisions=True, return_recalls=True, return_average_precisions=True, verbose=True)
mean_average_precision, average_precisions, precisions, recalls = results
for i in range(1, len(average_precisions)):
print("{:<14}{:<6}{}".format(classes[i], 'AP', round(average_precisions[i], 3)))
print("{:<14}{:<6}{}".format('', 'mAP', round(mean_average_precision, 3)))
m = max((Config.n_classes + 1) // 2, 2)
n = 2
fig, cells = plt.subplots(m, n, figsize=(n * 8, m * 8))
val = 0
for i in range(m):
for j in range(n):
if n * i + j + 1 > Config.n_classes: break
cells[i, j].plot(recalls[n * i + j + 1], precisions[n * i + j + 1], color='blue', linewidth=1.0)
cells[i, j].set_xlabel('recall', fontsize=14)
cells[i, j].set_ylabel('precision', fontsize=14)
cells[i, j].grid(True)
cells[i, j].set_xticks(np.linspace(0, 1, 11))
cells[i, j].set_yticks(np.linspace(0, 1, 11))
cells[i, j].set_title("{}, AP: {:.3f}".format(classes[n * i + j + 1], average_precisions[n * i + j + 1]),
fontsize=16)
image = plt.gcf()
# plt.show()
plt.draw()
image.savefig(os.getcwd() + "/test_out/test_" + str(val) + ".png", dpi=100)
val += 1
############################################################
# 4. Draw the predicted boxes onto the image
############################################################
classes = [
'background', 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus',
'car', 'cat', 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike',
'person', 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor'
]
num_classes = len(classes) - 1
images_dir = '/home/adam/.keras/datasets/VOCdevkit'
# Ground truth
test_hdf5_path = osp.join(images_dir, '07_test.h5')
test_dataset = DataGenerator(load_images_into_memory=False,
hdf5_dataset_path=test_hdf5_path)
model_mode = 'training'
evaluator = Evaluator(model=model,
n_classes=num_classes,
data_generator=test_dataset,
model_mode=model_mode)
results = evaluator(img_height=image_height,
img_width=image_width,
batch_size=4,
data_generator_mode='resize',
round_confidences=False,
matching_iou_threshold=0.5,
border_pixels='include',
sorting_algorithm='quicksort',
average_precision_mode='sample',
# TODO: Set the path to the weights you want to load.
weights_path = '/home/ubuntu/Result/ssd_face/ssd_face_initial_weights.h5'
model.load_weights(weights_path, by_name=True)
# 3: Instantiate an optimizer and the SSD loss function and compile the model.
sgd = SGD(lr=0.001, momentum=0.9, decay=0.0005)
ssd_loss = SSDLoss(neg_pos_ratio=3, alpha=1.0)
model.compile(optimizer=sgd, loss=ssd_loss.compute_loss)
# 1: Instantiate two `DataGenerator` objects: One for training, one for validation.
# Optional: If you have enough memory, consider loading the images into memory for the reasons explained above.
train_dataset = DataGenerator(load_images_into_memory=True,
hdf5_dataset_path=None)
val_dataset = DataGenerator(load_images_into_memory=True,
hdf5_dataset_path=None)
# 2: Parse the image and label lists for the training and validation datasets.
# TODO: Set the paths to your dataset here.
# Images
images_dir = '/home/ubuntu/Datasets/WiderFace/'
# Ground truth
train_labels_filename = '/home/ubuntu/Datasets/WiderFace/labels_train.csv'
val_labels_filename = '/home/ubuntu/Datasets/WiderFace/labels_val.csv'
train_dataset.parse_csv(
# Load the weights that we've just created via sub-sampling.
model.load_weights(weights_path, by_name=True)
print("Weights file loaded:", weights_path)
# 3: Instantiate an Adam 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)
#---
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 = '/home/student/Documents/GitHub/darknet/data/obj'
train_labels_filename = 'onsite-images-export.csv'
val_labels_filename = 'onsite-images-valid.csv'
train_dataset.parse_csv(
images_dir=images_dir,
labels_filename=train_labels_filename,
input_format=[
'image_name', 'xmin', 'ymin', 'xmax', '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')
def main():
# create dataset
dataset = DataGenerator()
dataset.parse_xml(images_dirs=[dataset_images_dir],
image_set_filenames=[test_image_set_filename],
annotations_dirs=[dataset_annotations_dir],
classes=classes,
include_classes='all',
exclude_truncated=False,
exclude_difficult=False,
ret=False)
# create model
model = ssd_512(image_size=(img_height, img_width, img_channels),
n_classes=n_classes,
mode=model_mode,
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)
# load weights and compile it
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)
ssd_loss = SSDLoss(neg_pos_ratio=3, alpha=1.0)
model.compile(optimizer=adam, loss=ssd_loss.compute_loss)
evaluator = Evaluator(model=model,
n_classes=n_classes,
data_generator=dataset,
model_mode=model_mode)
results = evaluator(img_height=img_height,
img_width=img_width,
batch_size=8,
data_generator_mode='resize',
round_confidences=False,
matching_iou_threshold=0.5,
border_pixels='include',
sorting_algorithm='quicksort',
average_precision_mode='sample',
num_recall_points=11,
ignore_neutral_boxes=True,
return_precisions=True,
return_recalls=True,
return_average_precisions=True,
verbose=True)
mean_average_precision, average_precisions, precisions, recalls = results
for i in range(1, len(average_precisions)):
print("{:<14}{:<6}{}".format(classes[i], 'AP',
round(average_precisions[i], 3)))
print()
print("{:<14}{:<6}{}".format('', 'mAP', round(mean_average_precision, 3)))
m = max((n_classes + 1) // 2, 2)
n = 2
fig, cells = plt.subplots(m, n, figsize=(n * 8, m * 8))
for i in range(m):
for j in range(n):
if n * i + j + 1 > n_classes: break
cells[i, j].plot(recalls[n * i + j + 1],
precisions[n * i + j + 1],
color='blue',
linewidth=1.0)
cells[i, j].set_xlabel('recall', fontsize=14)
cells[i, j].set_ylabel('precision', fontsize=14)
cells[i, j].grid(True)
cells[i, j].set_xticks(np.linspace(0, 1, 6))
cells[i, j].set_yticks(np.linspace(0, 1, 6))
cells[i, j].set_xlim(0.0, 1.0)
cells[i, j].set_ylim(0.0, 1.0)
cells[i, j].set_title("{}, AP: {:.3f}".format(
classes[n * i + j + 1], average_precisions[n * i + j + 1]),
fontsize=16)
if not os.path.isdir("evaluate_result"):
os.makedirs("evaluate_result")
plt.savefig('evaluate_result/ssd512_face_detection.png')
train = json.load(
open("/home/jsearcy/Desktop/ML Data Sets/malaria/training.json"))
test = json.load(open("/home/jsearcy/Desktop/ML Data Sets/malaria/test.json"))
write_new_json(
train,
'/home/jsearcy/UO Data Science Dropbox/Public Datasets/BBBC041o/train.json',
folder='train')
write_new_json(
test,
'/home/jsearcy/UO Data Science Dropbox/Public Datasets/BBBC041o/test.json',
folder='test')
oa.aosefoeji
train_dataset = DataGenerator(load_images_into_memory=True,
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),
