def __init__(self, data_directory, batch_size, shuffle=True):
self.batch_size = batch_size
self.datadir = data_directory # + '/all_files'
# Data Augmentation
if batch_size > 1: # training
self.gen = kp.ImageDataGenerator(rotation_range=5,
width_shift_range=0.2,
height_shift_range=0.2,
horizontal_flip=True,
vertical_flip=True,
channel_shift_range=0.1)
else: # batch_size 1 => validation
self.gen = kp.ImageDataGenerator(rotation_range=0,
width_shift_range=0,
height_shift_range=0,
horizontal_flip=False,
vertical_flip=False,
channel_shift_range=0)
self.get_one_batch_iter = self.gen.flow_from_directory(
self.datadir,
target_size=(args.resolution, args.resolution),
class_mode=None,
shuffle=shuffle,
batch_size=self.batch_size,
color_mode='rgb',
save_to_dir=None)
self.class_vectors = {
'B': np.array([1, 0, 0]),
'E': np.array([0, 1, 0]),
'W': np.array([0, 0, 1])
}
def get_data_generator():
train_datagen = image.ImageDataGenerator(
rotation_range=40,
width_shift_range=0.2,
height_shift_range=0.2,
preprocessing_function=preprocess_input,
shear_range=0.2,
zoom_range=0.35,
horizontal_flip=True,
fill_mode='nearest')
test_datagen = image.ImageDataGenerator(
preprocessing_function=preprocess_input)
train_generator = train_datagen.flow_from_directory(
'../data/uncropped/train',
target_size=(IMG_SIZE, IMG_SIZE),
batch_size=BATCH_SIZE)
validation_generator = test_datagen.flow_from_directory(
'../data/uncropped/validation',
target_size=(IMG_SIZE, IMG_SIZE),
batch_size=BATCH_SIZE)
return [train_generator, validation_generator]
def load_data_generators():
"""
Returns 3 keras image data generator objects that pull from the /data
folder of this directory.
"""
train_data_generator = image.ImageDataGenerator(horizontal_flip=True,
zoom_range=0.2,
rescale=1. / 225)
val_data_generator = image.ImageDataGenerator(rescale=1. / 225)
test_data_generator = image.ImageDataGenerator(rescale=1. / 225)
train_gen = train_data_generator.flow_from_directory(
'../../data/chest_xray/train/',
target_size=(100, 100),
batch_size=32,
class_mode='binary',
color_mode='grayscale')
val_gen = val_data_generator.flow_from_directory(
'../../data/chest_xray/val/',
target_size=(100, 100),
batch_size=32,
class_mode='binary',
color_mode='grayscale')
test_gen = test_data_generator.flow_from_directory(
'../../data/chest_xray/test//',
target_size=(100, 100),
batch_size=32,
class_mode='binary',
color_mode='grayscale')
return train_gen, val_gen, test_gen
def data_generator(dataset_train_path,
dataset_validation_path,
augmentation=True):
if augmentation:
# Reducing over-fitting by various augmentation
train_data_generator = image.ImageDataGenerator(rescale=1.0 / 255,
rotation_range=40,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
fill_mode='nearest')
valid_data_generator = image.ImageDataGenerator(rescale=1.0 / 255,
rotation_range=40,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
fill_mode='nearest')
else:
train_data_generator = image.ImageDataGenerator(rescale=1.0 / 255)
valid_data_generator = image.ImageDataGenerator(rescale=1.0 / 255)
train_generator = train_data_generator.flow_from_directory(
dataset_train_path, class_mode="categorical", target_size=(150, 150))
validation_generator = valid_data_generator.flow_from_directory(
dataset_validation_path,
class_mode="categorical",
target_size=(150, 150))
return train_generator, validation_generator
def preprocessImages(train_dir, val_dir, test_dir, batch_size):
train_gen = image.ImageDataGenerator(rescale = 1./255,
shear_range = 0.2,
zoom_range = 0.2,
width_shift_range = 0.1,
height_shift_range = 0.1,
horizontal_flip = True,
)
val_gen = image.ImageDataGenerator(rescale=1./255,)
test_gen = image.ImageDataGenerator(rescale=1./255,)
train_data_gen = train_gen.flow_from_directory(batch_size=batch_size,
directory=train_dir,
shuffle=True,
target_size=(IMG_HEIGHT, IMG_WIDTH),
class_mode='sparse'
)
val_data_gen = val_gen.flow_from_directory(batch_size=batch_size,
directory=val_dir,
target_size=(IMG_HEIGHT, IMG_WIDTH),
class_mode='sparse')
test_data_gen = test_gen.flow_from_directory(batch_size=batch_size,
directory=test_dir,
target_size=(IMG_HEIGHT, IMG_WIDTH),
class_mode='sparse'
)
return train_data_gen, val_data_gen, test_data_gen
def load_final_data_generators():
"""
Returns 3 keras image data generator objects that pull from the /data
folder of this directory. This function includes the ImageDataGenerator
parameters Horizontal flip, shear range, and zoom scale. We also
removed the grey scale color mode to use the images on pre-trained
models.
"""
train_datagen = image.ImageDataGenerator(horizontal_flip=True,
shear_range=0.2,
zoom_range=0.3,
rescale=1. / 225)
val_datagen = image.ImageDataGenerator(rescale=1. / 225)
directory_iteratorgen = image.ImageDataGenerator(rescale=1. / 225)
train_data = train_datagen.flow_from_directory(
'../../data/chest_xray/train/',
target_size=(100, 100),
batch_size=32,
class_mode='binary')
val_data = val_datagen.flow_from_directory('../../data/chest_xray/val/',
target_size=(100, 100),
batch_size=32,
class_mode='binary')
directory_iterator = directory_iteratorgen.flow_from_directory(
'../../data/chest_xray/test//',
target_size=(100, 100),
batch_size=32,
class_mode='binary')
return train_data, val_data, directory_iterator
def create_dataset(train_path, test_path=None, valid_size=0.1, batch_size=32):
X_train, X_val, y_train, y_val = utils.read_data(data_path=train_path,
valid_size=valid_size)
enc = LabelEncoder()
enc.fit(y_train)
print(enc.classes_)
with open("models/label_enc.pkl", "wb") as f:
pickle.dump(enc, f)
y_train = enc.transform(y_train)
y_train = to_categorical(y_train)
train_gen = image.ImageDataGenerator(
preprocessing_function=preprocess_input,
width_shift_range=0.1,
height_shift_range=0.1,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
train_gen.fit(X_train)
y_val = enc.transform(y_val)
y_val = to_categorical(y_val)
valid_gen = image.ImageDataGenerator(
preprocessing_function=preprocess_input)
valid_gen.fit(X_val)
print("train: {}".format(len(y_train)))
print("valid: {}".format(len(y_val)))
if test_path is not None:
X_test, y_test = utils.read_data(data_path=test_path, valid_size=0)
y_test = enc.transform(y_test)
y_test = to_categorical(y_test)
test_gen = image.ImageDataGenerator(
preprocessing_function=preprocess_input)
test_gen.fit(X_test)
train_gen = train_gen.flow(X_train, y_train, batch_size)
valid_gen = valid_gen.flow(X_val, y_val, batch_size)
test_gen = test_gen.flow(X_test, y_test, batch_size)
print("test: {}".format(len(y_test)))
return train_gen, valid_gen, test_gen
valid_gen = valid_gen.flow(X_val, y_val, batch_size)
test_gen = test_gen.flow(X_test, y_test, batch_size)
return train_gen, valid_gen
def main():
batch_size = 64
input_shape = (28, 28, 1)
n_classes = 26
epochs = 30
train_path = "/tmp/sign_mnist_train.csv"
test_path = "/tmp/sign_mnist_test.csv"
train_df = pd.read_csv(train_path)
test_df = pd.read_csv(test_path)
train_x = train_df.iloc[:, 1:].to_numpy().reshape(
-1, 28, 28) # .reshape(-1, 28, 28, 1)
train_x = np.expand_dims(train_x, axis=3)
train_y = train_df.iloc[:, 0].to_numpy()
test_x = test_df.iloc[:,
1:].to_numpy().reshape(-1, 28,
28) # .reshape(-1, 28, 28, 1)
test_x = np.expand_dims(test_x, axis=3)
test_y = test_df.iloc[:, 0].to_numpy()
print("train", train_x.shape)
print("valid", test_x.shape)
train_gen = image.ImageDataGenerator(rescale=1 / 255.,
rotation_range=40,
width_shift_range=.2,
height_shift_range=.2,
shear_range=.2,
zoom_range=.2,
horizontal_flip=True)
train_gen_obj = train_gen.flow(train_x, train_y, batch_size=batch_size)
valid_gen = image.ImageDataGenerator(rescale=1 / 255.)
valid_gen_obj = valid_gen.flow(test_x, test_y, batch_size=batch_size)
l = SignLanguage(input_shape=input_shape,
n_classes=n_classes,
is_targets_one_hot_encoded=False)
l.register_callbacks(StopTrainingCb())
l.compile()
l.model.summary()
l.fit_generator(train_gen_obj,
epochs=epochs,
steps_per_epoch=len(train_df) // batch_size,
valid_data_gen=valid_gen_obj,
validation_steps=len(test_df) // batch_size)
l.plot_history()
def main():
train_size, valid_size = [.8, .2]
base_dir_path = "/tmp/cats_and_dogs_filtered"
train_dir_path = base_dir_path + "/train"
valid_dir_path = base_dir_path + "/validation"
# path = Path(base_train_dir_path)
# fnames = list(path.rglob("*.jpg"))
# dataset = pd.DataFrame({"fnames": fnames})
# dataset['filename'] = dataset.fnames.apply(lambda x: "{}/{}".format(Path(x).parent.name, Path(x).name))
# dataset['y_col'] = dataset.fnames.apply(get_y_labels)
# idx = list(dataset.index)
# np.random.seed(42)
# np.random.shuffle(idx)
# dataset = dataset.reindex(idx).copy()
# dataset['is_valid'] = 0
# dataset['is_valid'].iloc[slice(int(len(dataset) * train_size), len(dataset))] = 1
train_gen = image.ImageDataGenerator(rescale=1 / 255.,
rotation_range=40,
width_shift_range=.2,
height_shift_range=.2,
shear_range=.2,
zoom_range=.2,
horizontal_flip=True)
train_gen_obj = train_gen.flow_from_directory(directory=train_dir_path,
target_size=(150, 150),
class_mode="binary",
batch_size=20)
valid_gen = image.ImageDataGenerator(rescale=1 / 255.)
valid_gen_obj = train_gen.flow_from_directory(directory=valid_dir_path,
target_size=(150, 150),
class_mode="binary",
batch_size=20)
input_shape = (150, 150, 3)
l = DogVsCat(input_shape=input_shape, n_classes=1)
l.register_callbacks(StopTrainingCb())
l.compile()
l.fit_generator(train_gen_obj,
epochs=20,
steps_per_epoch=100,
valid_data_gen=valid_gen_obj,
validation_steps=50)
l.plot_history()
def _preprocess_dataset(self, root: str):
"""
Helper function for creating Keras data generator from image folder.
Parameters
----------
root : path to directory containing subdirectories with image files.
Required structure:
root
|---class1
| |---image1
| |---image2
|---class2
| |---image3
| |---image4
Returns
-------
Keras DataGenerator
"""
datagen = image.ImageDataGenerator(
preprocessing_function=preprocess_input)
return datagen.flow_from_directory(root,
target_size=self.IMAGE_SIZE,
batch_size=32)
def augment(data, label, batch_size):
aug = KPI.ImageDataGenerator(width_shift_range=0.125,
height_shift_range=0.125,
horizontal_flip=True)
aug.fit(data)
dsgen = aug.flow(data, label, batch_size=batch_size)
return dsgen
def generate_train_val_data(self, data_dir="dataset/train/"):
"""
# Create an ImageDataGenerator by dividing the train and validation set
# by 0.8/0.2 based on the train dataset folder.
# train : 60600 imgs / validation : 15150 imgs
"""
num_data = 0
for root, dirs, files in os.walk(data_dir):
if files:
num_data += len(files)
self.num_train_data = num_data
_datagen = image.ImageDataGenerator(
rescale=1.0 / 255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
validation_split=0.2,
)
self.train_data = _datagen.flow_from_directory(
data_dir,
target_size=(self.img_height, self.img_width),
batch_size=self.batch_size,
class_mode="categorical",
subset="training",
)
self.validation_data = _datagen.flow_from_directory(
data_dir,
target_size=(self.img_height, self.img_width),
batch_size=self.batch_size,
class_mode="categorical",
subset="validation",
)
def get_iterator(frame_file,
label_flag=0,
batch_size=64,
img_shape=(299, 299)):
random.seed(1)
datagen = image.ImageDataGenerator(preprocessing_function=preprocess_input)
anno_frame = pd.read_csv(frame_file, dtype=str)
datasplit = frame_file.split('.')[-2].split('_')[-1]
biastype = frame_file.split('/')[-1].split('_')[0]
# Flag controls the shuffle type: true for training and flase for testing
shuffle_flag = True if datasplit == "train" else False
# Flag controls the label type: labeling or bias regression
if label_flag == 0:
y_label = "label"
class_mode = "categorical"
elif label_flag == 1:
y_label = "gaussian_kernel" if biastype != 'ct' else 'color_temp'
class_mode = "raw"
iterator = datagen.flow_from_dataframe(
dataframe=anno_frame,
directory=".",
x_col="filename",
y_col=y_label,
class_mode=class_mode,
batch_size=batch_size,
shuffle=shuffle_flag,
seed=1,
target_size=img_shape,
)
return iterator
def get_data(path,
target_size=(224, 224),
color_mode='grayscale',
gen=kp.ImageDataGenerator(),
save_to_dir=None):
batches = get_batches(path,
gen=gen,
shuffle=False,
batch_size=1,
class_mode=None,
target_size=target_size,
color_mode=color_mode,
save_to_dir=save_to_dir)
train_data = np.concatenate([
batches['train_batches'].next()
for i in range(batches['train_batches'].samples)
])
valid_data = np.concatenate([
batches['valid_batches'].next()
for i in range(batches['valid_batches'].samples)
])
res = {
'train_data': train_data.astype(float),
'valid_data': valid_data.astype(float)
}
return res
def get_batches(path,
gen=kp.ImageDataGenerator(),
shuffle=True,
batch_size=4,
class_mode='categorical',
target_size=(224, 224),
color_mode='grayscale',
save_to_dir=None):
train_path = path + '/' + 'train'
valid_path = path + '/' + 'valid'
train_batches = gen.flow_from_directory(train_path,
target_size=target_size,
class_mode=class_mode,
shuffle=shuffle,
batch_size=batch_size,
color_mode=color_mode,
save_to_dir=save_to_dir)
valid_batches = gen.flow_from_directory(valid_path,
target_size=target_size,
class_mode=class_mode,
shuffle=shuffle,
batch_size=batch_size,
color_mode=color_mode,
save_to_dir=save_to_dir)
res = {'train_batches': train_batches, 'valid_batches': valid_batches}
return res
def add_data_augmentation(self, batch_size=None):
if batch_size is None:
batch_size = 32
self.datagen = image.ImageDataGenerator(
featurewise_center=True,
featurewise_std_normalization=True,
vertical_flip=True,
horizontal_flip=True,
rotation_range=90)
self.datagen.fit(self.data)
self.train_samples, validation_samples, train_labels, validation_labels = train_test_split(
self.data, self.labels, test_size=.334)
train_generator = self.datagen.flow(self.train_samples,
train_labels,
batch_size=batch_size)
validation_generator = self.datagen.flow(validation_samples,
validation_labels,
batch_size=batch_size)
train_samples_ce, validation_samples_ce, train_labels_ce, validation_labels_ce = train_test_split(
self.data, self.labels_ce, test_size=.334)
self.train_ce_generator = self.datagen.flow(train_samples_ce,
train_labels_ce,
batch_size=batch_size)
self.validation_ce_generator = self.datagen.flow(validation_samples_ce,
validation_labels_ce,
batch_size=batch_size)
self.test_ce_generator = self.validation_ce_generator
logger.info("done ...")
def transform(self):
# This is one of the ways to create training data batch and label batch
image_generator = image.ImageDataGenerator(
rescale=1. / 255,
#rotation_range=0.2,
#zoom_range=[2,5],
brightness_range=[2, 5],
width_shift_range=0.2,
height_shift_range=0.2,
#horizontal_flip=False,
validation_split=0.25)
self.train_data_gen = image_generator.flow_from_directory(
directory=self.train_path,
batch_size=config.BATCH_SIZE,
shuffle=True,
class_mode='categorical',
target_size=(config.IMG_HEIGHT, config.IMG_WIDTH),
classes=config.CLASS_NAMES)
self.validation_generator = image_generator.flow_from_directory(
self.train_path,
shuffle=True,
subset='validation',
class_mode='categorical',
classes=config.CLASS_NAMES,
target_size=(config.IMG_HEIGHT, config.IMG_WIDTH))
self.test_generator = image_generator.flow_from_directory(
self.test_path,
shuffle=True,
class_mode='categorical',
target_size=(config.IMG_HEIGHT, config.IMG_WIDTH))
def train(self,
train_tensors,
target_tensors,
valid_train_tensors,
valid_target_tensors,
batch_size=32,
epochs=100):
datagen = image.ImageDataGenerator(
width_shift_range=
0.1, # randomly shift images horizontally (10% of total width)
height_shift_range=
0.1, # randomly shift images vertically (10% of total height)
horizontal_flip=True) # randomly flip images horizontally
# fit augmented image generator on data
datagen.fit(train_tensors)
checkpointer = ModelCheckpoint(filepath='weights.hdf5',
verbose=1,
save_best_only=True)
self.model.fit_generator(
datagen.flow(train_tensors, target_tensors, batch_size=batch_size),
validation_data=(valid_train_tensors, valid_target_tensors),
steps_per_epoch=train_tensors.shape[0] // batch_size,
epochs=epochs,
callbacks=[checkpointer],
verbose=1)
def get_test_iterator(x: np.ndarray,
y: np.ndarray) -> image.NumpyArrayIterator:
return image.ImageDataGenerator(samplewise_center=True,
samplewise_std_normalization=True).flow(
x,
y,
batch_size=common.batch_size,
shuffle=False)
def load_data():
_URL = 'https://storage.googleapis.com/mledu-datasets/cats_and_dogs_filtered.zip'
path_to_zip = tf.keras.utils.get_file('cats_and_dogs.zip',
origin=_URL,
extract=True)
PATH = os.path.join(os.path.dirname(path_to_zip), 'cats_and_dogs_filtered')
print("Data dir:", PATH)
train_dir = os.path.join(PATH, 'train')
validation_dir = os.path.join(PATH, 'validation')
train_cats_dir = os.path.join(train_dir, 'cats')
train_dogs_dir = os.path.join(train_dir, 'dogs')
validation_cats_dir = os.path.join(validation_dir, 'cats')
validation_dogs_dir = os.path.join(validation_dir, 'dogs')
num_cats_tr = len(os.listdir(train_cats_dir))
num_dogs_tr = len(os.listdir(train_dogs_dir))
num_cats_val = len(os.listdir(validation_cats_dir))
num_dogs_val = len(os.listdir(validation_dogs_dir))
total_train = num_cats_tr + num_dogs_tr
total_val = num_cats_val + num_dogs_val
info = [total_train, total_val]
train_image_generator = image.ImageDataGenerator(rescale=1. / 255,
width_shift_range=.15,
height_shift_range=.15,
horizontal_flip=True,
rotation_range=45,
zoom_range=0.5)
train_data_gen = train_image_generator.flow_from_directory(
batch_size=BATCH_SIZE,
directory=train_dir,
shuffle=True,
target_size=(IMG_HEIGHT, IMG_WIDTH),
class_mode='binary')
validation_image_generator = image.ImageDataGenerator(rescale=1. / 255)
val_data_gen = validation_image_generator.flow_from_directory(
batch_size=BATCH_SIZE,
directory=validation_dir,
target_size=(IMG_HEIGHT, IMG_WIDTH),
class_mode='binary')
return train_data_gen, val_data_gen, info
def data_source(directory):
datagen = image.ImageDataGenerator(rescale=1. / 255)
generator = datagen.flow_from_directory(directory,
target_size=(480, 640),
batch_size=32,
shuffle=True,
class_mode='input')
return generator
def extract_features():
datagen = image.ImageDataGenerator(preprocessing_function=preprocess_input)
dataset = datagen.flow_from_directory("query/",
target_size=(224, 224),
batch_size=128,
shuffle=False)
features = finetuned_feature_extractor.predict(dataset)
features = normalize(features)
return features
def make_val_generator():
data_val_gen = image.ImageDataGenerator(rescale=1. / 255,
validation_split=0.1)
validation_generator = data_val_gen.flow_from_directory(
DATASET_PATH,
target_size=(image_size, image_size),
class_mode='categorical',
subset='validation')
return validation_generator
def generator_predict(path):
val_datagen = image.ImageDataGenerator(
rescale=1. / 255, preprocessing_function=preprocess_input)
validation = val_datagen.flow_from_directory(path,
batch_size=batch_size,
class_mode='categorical',
target_size=img_shape)
prediction = model.predict(validation)
return prediction, validation
def get_validation_generator(directory, image_shape, batch_size):
test_datagen = image.ImageDataGenerator(rescale=1. / 255)
# this is a similar generator, for validation data
validation_generator = test_datagen.flow_from_directory(
directory,
target_size=image_shape,
batch_size=batch_size,
class_mode='categorical')
return validation_generator
def evaluate_hyperparameters(data: ImageDataset, configuration: dict) -> dict:
"""
Fits a single model to the training data, returning the final loss and
accuracy of training and validation.
"""
batch_size = configuration["batch_size"]
train_data, validation_data = model_selection.train_test_split(
data.train, test_size=VALIDATION_SPLIT)
category_list = data.categories.tolist()
data_generator = image.ImageDataGenerator(rescale=1. / 255)
train_generator = data_generator.flow_from_dataframe(
dataframe=train_data,
directory=f"./data/labeled-aliased-{IMAGE_SIZE}-png",
x_col="Filename",
y_col="Category",
target_size=(IMAGE_SIZE, IMAGE_SIZE),
color_mode=COLOR_MODE,
classes=category_list,
class_mode="categorical",
batch_size=batch_size)
validation_generator = data_generator.flow_from_dataframe(
dataframe=validation_data,
directory=f"./data/labeled-aliased-{IMAGE_SIZE}-png",
x_col="Filename",
y_col="Category",
target_size=(IMAGE_SIZE, IMAGE_SIZE),
color_mode=COLOR_MODE,
classes=category_list,
class_mode="categorical",
batch_size=batch_size)
output_size = len(data.categories)
model = create_and_compile_model(configuration, output_size)
epochs = configuration["epochs"]
train_steps = train_generator.n // train_generator.batch_size
validation_steps = validation_generator.n // validation_generator.batch_size
history = model.fit_generator(generator=train_generator,
steps_per_epoch=train_steps,
validation_data=validation_generator,
validation_steps=validation_steps,
epochs=epochs)
result = {
"train_loss": history.history["loss"][-1],
"train_accuracy": history.history["accuracy"][-1],
"val_loss": history.history["val_loss"][-1],
"val_accuracy": history.history["val_accuracy"][-1]
}
termcolor.cprint(f"Validation accuracy: {result['val_accuracy']:.2%}",
"yellow")
return result
def test_compare_with_augmentation_translate(self):
# create fake dataset
dataset_dir = create_fake_dataset_and_convert_to_tfrecords(
image_array=self.batch_random_images, n_images_per_class=10)
config = {
'name': 'tfrecords',
'data_dir': dataset_dir,
'batch_size': BATCH_SIZE,
'train_split_id': 'train',
'Translate': {
'width_shift_range': 0.125,
'height_shift_range': 0.125,
'padding_strategy': 'REFLECT'
}
}
dataset = get_dataset(config, ['Translate'], 1, 'train')
image, _ = next(iter(dataset))
# Normalize the image similar to DCN strategy
normalize = image / 255.
subtract_mean = tf.reduce_mean(normalize, axis=0)
x_train_from_our_dataloader = normalize - subtract_mean
# get x_train from dcn
x_data = self.get_dcn_dataloader(self.batch_random_images)
# DCN augmentation strategy
dcn_augmentations = keras_preprocessing.ImageDataGenerator(
height_shift_range=config['Translate']['height_shift_range'],
width_shift_range=config['Translate']['width_shift_range'],
horizontal_flip=False)
x_train_from_dcn_dataloader = next(
iter(
dcn_augmentations.flow(x_data,
None,
batch_size=BATCH_SIZE,
shuffle=False)))
# Test the tensor shape remains the same
self.assertTrue(x_train_from_dcn_dataloader.shape,
x_train_from_dcn_dataloader.shape)
# Note for translate we expect the mean to be different as the method to fill the missing pixels that keras and our data loader use are different.
# This doesn't cause an issue with the image being translated (see test_data_visualize), rather difference in pixel values at the shifted places.
# data visualization does confirm the translation works as expected.
self.assertAlmostEqual(np.mean(x_train_from_our_dataloader),
np.mean(x_train_from_dcn_dataloader),
places=3)
# clean up
shutil.rmtree(dataset_dir)
def evaluate_butterfly(images_path=TEST_DATA, weights=FILENAME):
test_datagen = image.ImageDataGenerator(
preprocessing_function=preprocess_input)
test_generator = test_datagen.flow_from_directory(images_path,
target_size=(IMG_SIZE, IMG_SIZE),
batch_size=BATCH_SIZE)
model = load_model(weights)
model.compile(optimizer='Adam',
loss='categorical_crossentropy',
metrics=['categorical_accuracy', top_3_metrics, 'acc'])
model.evaluate(test_generator)
def segmentation_aug(input_image, label, mean, std, augmentation_dict):
"""apply augmentation to one image respectively
"""
# For Keras ImageDataGenerator
data_gen_args = dict()
data_gen_args["fill_mode"] = "constant" # cvalの値で埋める
data_gen_args["cval"] = 0 # 黒で埋める
# (H,W[,C]) => (N,H,W,C)
input_image = input_image[np.newaxis]
label = label[np.newaxis, ..., np.newaxis]
image_datagen = image.ImageDataGenerator(**data_gen_args)
mask_datagen = image.ImageDataGenerator(**data_gen_args)
seed = np.random.randint(100)
image_datagen.fit(input_image, augment=True, seed=seed)
mask_datagen.fit(label, augment=True, seed=seed)
image_gen = image_datagen.flow(input_image, batch_size=1, seed=seed)
mask_gen = mask_datagen.flow(label, batch_size=1, seed=seed)
# combine generators into one which yields image and masks
gen = zip(image_gen, mask_gen)
img_batches, mask_batches = next(gen)
input_image_processed = img_batches.squeeze() # batch次元を捨てる
label_processed = mask_batches.squeeze() # batchとchannel次元を捨てる
# Not Keras ImageDataGenerator
if "augmix" in augmentation_dict and augmentation_dict["augmix"] is True:
"""AugMix: to Improve Robustness and Uncertainty
AugMixは最後に行う
TODO: ひとまずハードラベル
Affine変換系が施されたらソフトラベルにした方がいい？
"""
input_image_processed = augment_and_mix(
input_image_processed,
mean, std,
)
return input_image_processed, label_processed
def generator(dir,
gen=image.ImageDataGenerator(rescale=1. / 255),
shuffle=True,
batch_size=1,
target_size=(24, 24),
class_mode='categorical'):
return gen.flow_from_directory(dir,
batch_size=batch_size,
shuffle=shuffle,
color_mode='grayscale',
class_mode=class_mode,
target_size=target_size)
