def build(self, hp, inputs=None):
input_node = nest.flatten(inputs)[0]
output_node = input_node
# Translate
translation_factor = self.translation_factor
if translation_factor is None:
translation_factor = hp.Choice("translation_factor", [0.0, 0.1])
if translation_factor != 0 and translation_factor != (0, 0):
height_factor, width_factor = self._get_fraction_value(
translation_factor)
output_node = preprocessing.RandomTranslation(
height_factor, width_factor)(output_node)
# Flip
horizontal_flip = self.horizontal_flip
if horizontal_flip is None:
horizontal_flip = hp.Boolean("horizontal_flip", default=True)
vertical_flip = self.vertical_flip
if self.vertical_flip is None:
vertical_flip = hp.Boolean("vertical_flip", default=True)
if not horizontal_flip and not vertical_flip:
flip_mode = ""
elif horizontal_flip and vertical_flip:
flip_mode = "horizontal_and_vertical"
elif horizontal_flip and not vertical_flip:
flip_mode = "horizontal"
elif not horizontal_flip and vertical_flip:
flip_mode = "vertical"
if flip_mode != "":
output_node = preprocessing.RandomFlip(mode=flip_mode)(output_node)
# Rotate
rotation_factor = self.rotation_factor
if rotation_factor is None:
rotation_factor = hp.Choice("rotation_factor", [0.0, 0.1])
if rotation_factor != 0:
output_node = preprocessing.RandomRotation(rotation_factor)(
output_node)
# Zoom
zoom_factor = self.zoom_factor
if zoom_factor is None:
zoom_factor = hp.Choice("zoom_factor", [0.0, 0.1])
if zoom_factor != 0 and zoom_factor != (0, 0):
height_factor, width_factor = self._get_fraction_value(zoom_factor)
# TODO: Add back RandomZoom when it is ready.
# output_node = preprocessing.RandomZoom(
# height_factor, width_factor)(output_node)
# Contrast
contrast_factor = self.contrast_factor
if contrast_factor is None:
contrast_factor = hp.Choice("contrast_factor", [0.0, 0.1])
if contrast_factor != 0 and contrast_factor != (0, 0):
output_node = preprocessing.RandomContrast(contrast_factor)(
output_node)
return output_node
def get_augmenter(min_area, brightness, jitter):
zoom_factor = 1.0 - tf.sqrt(min_area)
return keras.Sequential([
keras.Input(shape=(image_size, image_size, image_channels)),
preprocessing.Rescaling(1 / 255),
preprocessing.RandomFlip("horizontal"),
preprocessing.RandomTranslation(zoom_factor / 2, zoom_factor / 2),
preprocessing.RandomZoom((-zoom_factor, 0.0), (-zoom_factor, 0.0)),
RandomColorAffine(brightness, jitter),
])
def _get_data_augment_layer(self):
data_augment_layer = tf.keras.models.Sequential([
KerasPreprocessing.RandomFlip('horizontal'),
KerasPreprocessing.RandomRotation(0.2),
KerasPreprocessing.RandomZoom(0.2),
KerasPreprocessing.RandomHeight(0.2),
KerasPreprocessing.Resizing(height=self.IMAGE_DIM[0], width=self.IMAGE_DIM[1])
])
return data_augment_layer
def create_data_augmentation_layer():
# When you don't have a large image dataset,
# it's a good practice to artificially introduce sample diversity
# by applying random yet realistic transformations to the training images.
data_augmentation = keras.Sequential(
[
preprocessing.RandomFlip("horizontal"),
preprocessing.RandomRotation(0.1),
]
)
return data_augmentation
def load_pipeline(self, img_path: Path, grayscale: bool, seed: int, augment: bool):
img = tf.keras.preprocessing.image.load_img(img_path, grayscale=grayscale)
img = tf.expand_dims(tf.keras.preprocessing.image.img_to_array(img), axis=0)
if augment:
tf.random.set_seed(seed) # RandomFlip is stupid, this stays until tf 2.4
img = preprocessing.RandomFlip("horizontal", seed=seed)(img)
# img = preprocessing.RandomTranslation(height_factor=(-0.1, 0.1),
# width_factor=(-0.1, 0.1), seed=seed)(img)
img = preprocessing.RandomCrop(height=tf.cast(0.9 * img.shape[1], dtype=tf.int32),
width=tf.cast(0.9 * img.shape[2], dtype=tf.int32),
seed=seed)(img)
# img = preprocessing.RandomZoom((0., -0.1), seed=seed)(img)
img = tf.keras.layers.experimental.preprocessing.Resizing(self.resolution, self.resolution)(img)
img = tf.keras.layers.experimental.preprocessing.Rescaling(1. / 127.5, offset=-1)(img)
return img
def __init__(self):
super(ClassifierHybrid, self).__init__()
self.global_step = 0
self.backbone = self.get_backbone()
self.backbone.trainable = False
trainable_count = np.sum(
[K.count_params(w) for w in self.backbone.trainable_weights])
non_trainable_count = np.sum(
[K.count_params(w) for w in self.backbone.non_trainable_weights])
print('Total params: {:,}'.format(trainable_count +
non_trainable_count))
print('Trainable params: {:,}'.format(trainable_count))
print('Non-trainable params: {:,}'.format(non_trainable_count))
# self.head = tf.keras.Sequential([
# layers.Flatten(),
# layers.Dense(256, activation='relu'),
# layers.Dense(196)
# ])
# self.vision_transformer = ViT(img_size=9, channels=1408, patch_size=1, num_layers=8,
# num_classes=196, d_model=512, num_heads=8, d_mlp=512)
self.vision_transformer = ViT(img_size=args.num_patches,
channels=args.num_channels,
patch_size=args.patch_size,
num_layers=args.num_layers,
num_classes=args.num_classes,
d_model=args.d_model,
num_heads=args.num_heads,
d_mlp=args.d_mlp)
self.prepare_datasets()
self.flag = True
self.augmentation = tf.keras.Sequential(
[
tf.keras.Input(shape=(260, 260, 3)),
preprocessing.RandomRotation(factor=0.15),
preprocessing.RandomTranslation(height_factor=0.1,
width_factor=0.1),
preprocessing.RandomFlip(),
preprocessing.RandomContrast(factor=0.1),
],
name="augmentation",
)
def build(self, hp, inputs=None):
input_node = nest.flatten(inputs)[0]
output_node = input_node
if self.translation_factor != 0 and self.translation_factor != (0, 0):
height_factor, width_factor = self._get_fraction_value(
self.translation_factor)
output_node = preprocessing.RandomTranslation(
height_factor, width_factor)(output_node)
horizontal_flip = self.horizontal_flip
if horizontal_flip is None:
horizontal_flip = hp.Boolean('horizontal_flip', default=True)
vertical_flip = self.vertical_flip
if self.vertical_flip is None:
vertical_flip = hp.Boolean('vertical_flip', default=True)
if not horizontal_flip and not vertical_flip:
flip_mode = ''
elif horizontal_flip and vertical_flip:
flip_mode = 'horizontal_and_vertical'
elif horizontal_flip and not vertical_flip:
flip_mode = 'horizontal'
elif not horizontal_flip and vertical_flip:
flip_mode = 'vertical'
if flip_mode != '':
output_node = preprocessing.RandomFlip(mode=flip_mode)(output_node)
if self.rotation_factor != 0:
output_node = preprocessing.RandomRotation(
self.rotation_factor)(output_node)
if self.zoom_factor != 0 and self.zoom_factor != (0, 0):
height_factor, width_factor = self._get_fraction_value(
self.zoom_factor)
# TODO: Add back RandomZoom when it is ready.
# output_node = preprocessing.RandomZoom(
# height_factor, width_factor)(output_node)
if self.contrast_factor != 0 and self.contrast_factor != (0, 0):
output_node = preprocessing.RandomContrast(
self.contrast_factor)(output_node)
return output_node
def __init__(self, model_name, learning_rate, pre_trained_model_path):
self.model_name = model_name
self.lr = float(learning_rate)
self.base_model, self.image_size = base_model[model_name]
if model_name.startswith('b'):
self.weight_path = os.path.join(pre_trained_model_path,
self.model_name + ".h5")
else:
self.weight_path = 'imagenet'
self.img_augmentation = Sequential(
[
preprocessing.RandomRotation(factor=0.15),
preprocessing.RandomTranslation(height_factor=0.1,
width_factor=0.1),
preprocessing.RandomFlip(),
preprocessing.RandomContrast(factor=0.1),
],
name="img_augmentation",
)
def get_data_augmentation_layers(rotation: bool = False, flip: bool = False,
zoom: bool = False, contrast: bool = False) -> List[PreprocessingLayer]:
"""
Creates a list of augmentation layers which can be applied later.
:param rotation: Data Augmentation: Whether to apply random rotation to the images.
:param flip: Data Augmentation: Whether to apply random horizontal flip to the images.
:param zoom: Data Augmentation: Whether to apply random zoom to the images.
:param contrast: Data Augmentation: Whether to apply random contrast enhancement to the images.
:return: The list of data augmentation layers.
"""
data_augmentation = []
if rotation:
data_augmentation.append(preprocessing.RandomRotation(factor=(1 / 6))) # Between +/- 30deg
if flip:
data_augmentation.append(preprocessing.RandomFlip("horizontal"))
if zoom:
data_augmentation.append(preprocessing.RandomZoom(height_factor=0.2)) # Zoom +/- 20%
if contrast:
data_augmentation.append(preprocessing.RandomContrast(factor=0.1))
return data_augmentation
def build_model(NUM_CLASSES, IMG_SIZE):
"""モデルの構築
Args:
NUM_CLASSES (int): 種類数
IMG_SIZE (int): サイズ
Returns:
tf.keras.Model: モデル
int: Adamのハイパーパラメータ
"""
img_augmentation = Sequential([
preprocessing.RandomRotation(factor=0.15),
preprocessing.RandomTranslation(height_factor=0.1, width_factor=0.1),
preprocessing.RandomFlip(),
preprocessing.RandomContrast(factor=0.1)
],
name='img_augmentation')
inputs = Input(shape=(IMG_SIZE, IMG_SIZE, 3))
x = img_augmentation(inputs)
model = EfficientNetB3(include_top=False,
input_tensor=x,
weights='imagenet')
model.trainable = False
x = GlobalAveragePooling2D(name='avg_pool')(model.output)
x = BatchNormalization(trainable=True)(x)
top_dropout_rate = 0.2
x = Dropout(top_dropout_rate, name='top_dropout')(x)
outputs = Dense(NUM_CLASSES, activation='softmax', name='pred')(x)
model = Model(inputs, outputs, name='EfficientNet')
lr = 1e-4
optimizer = Adam(learning_rate=lr)
model.compile(optimizer=optimizer,
loss='categorical_crossentropy',
metrics=['accuracy'])
return (model, lr)
input_shape,
random_labels=config.random_labels)
x_test, y_test = prepare_all_data(config, x_test, y_test, input_shape)
if input_shape[-1] > 1:
means = x_train.mean(axis=(0, 1, 2))
std = x_train.std(axis=(0, 1, 2))
x_train = (x_train - means) / std
x_test = (x_test - means) / std
print("LOADING OVER", flush=True)
augmenter = tf.keras.Sequential([
preprocessing.RandomContrast(0.2),
preprocessing.RandomRotation(0.05), # = 12° rotation maximum
preprocessing.RandomTranslation(0.13, 0.13,
fill_mode='reflect'), # nearest better
preprocessing.RandomFlip('horizontal')
])
augmenter.build((None, ) + input_shape)
class CustomSequential(Sequential):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
def train_step(self, data):
x, y = data
x = augmenter(x, training=True)
with tf.GradientTape() as tape:
y_pred = self(x, training=True)
if config.alpha == 'adaptive':
self.eager_loss.histogram_update_margins(y, y_pred)
X = X / 255.0
# One hot encoding. The data labels must be reformatted in a 3-bit vector
enc = OneHotEncoder()
y = enc.fit_transform(y[:, np.newaxis]).toarray()
early_stopping = EarlyStopping(
min_delta=0.001, # minimium amount of change to count as an improvement
patience=5, # how many epochs to wait before stopping
restore_best_weights=True,
)
# elaborate convnet
model = Sequential()
# data augmentation
model.add(preprocessing.RandomFlip('horizontal')) # flip left-to-right
model.add(preprocessing.RandomContrast(0.5)) # contrast change by up to 50%)
#first convolution layer
model.add(
Conv2D(filters=64,
kernel_size=3,
input_shape=X.shape[1:],
activation="relu",
padding='same'))
model.add(MaxPooling2D(pool_size=(2, 2)))
#second convolution layer
model.add(Conv2D(filters=128, kernel_size=3, activation="relu",
padding='same'))
model.add(MaxPooling2D(pool_size=(2, 2)))
if ds_info.features['label'].num_classes > 3:
top3 = np.argsort(pred, axis=1)[0, -3:]
for label in top3:
print(f'{format_label(label, ds_info)}: {pred[0,label]}')
pred_label = format_label(np.argmax(pred), ds_info)
if show_image:
plt.imshow(img.astype("uint8"))
plt.title("{}".format(format_label(np.argmax(pred), ds_info)))
return pred_label
img_augmentation = Sequential(
[
preprocessing.RandomRotation(factor=0.15),
preprocessing.RandomTranslation(height_factor=0.1, width_factor=0.1),
preprocessing.RandomFlip(),
preprocessing.RandomContrast(factor=0.1),
],
name="img_augmentation",
)
def build_model(num_classes):
inputs = layers.Input(shape=(IMG_SIZE, IMG_SIZE, 3))
x = img_augmentation(inputs)
model = EfficientNetB0(include_top=False, input_tensor=x, weights="imagenet")
# Freeze the pretrained weights
model.trainable = False
# Rebuild top
x = layers.GlobalAveragePooling2D(name="avg_pool")(model.output)
#print(X_test.shape)
#print(y_test.shape)
#print(y_test.shape)
X_train = X_train.reshape(X_train.shape[0], 48, 48, 1)
X_test = X_test.reshape(X_test.shape[0], 48, 48, 1)
#print(X_train.shape)
y_train = keras.utils.to_categorical(y_train, num_classes=7)
y_test = keras.utils.to_categorical(y_test, num_classes=7)
# In[4]:
model = keras.Sequential([
layers.experimental.preprocessing.Rescaling(1. / 255,
input_shape=(48, 48, 1)),
preprocessing.RandomFlip(mode='horizontal'),
preprocessing.RandomRotation(factor=0.05),
layers.BatchNormalization(renorm=True),
layers.Conv2D(filters=16, kernel_size=3, activation='relu',
padding='same'),
layers.MaxPool2D(),
layers.Conv2D(filters=32, kernel_size=3, activation='relu',
padding='same'),
layers.BatchNormalization(renorm=True),
layers.Conv2D(filters=64, kernel_size=3, activation='relu',
padding='same'),
layers.Flatten(),
layers.Dense(256, activation='relu'),
layers.Dense(64, activation='relu'),
layers.Dense(7, activation='softmax'),
])
plot_hist(hist)
from tensorflow.keras.layers.experimental import preprocessing
from tensorflow.keras.models import Sequential
from tensorflow.keras import layers
img_augmentation = Sequential(
[
# representing lower and upper bound for rotating clockwise and counter-clockwise.
preprocessing.RandomRotation(factor=0.15), # a float represented as fraction of 2pi, ex :0.15 (= 54 degree!)
preprocessing.RandomTranslation(height_factor=0.1, # lower and upper bound for shifting vertically
width_factor=0.1 #lower and upper bound for shifting horizontally.
),
preprocessing.RandomFlip(), # Randomly flip each image horizontally and vertically.
preprocessing.RandomContrast(factor=0.1),
],
name="img_augmentation",
) # 각각의 layer가 순서대로? 실행된다고 생각
for image, label in train_dataset.take(1):
for i in range(9):
ax = plt.subplot(3, 3, i + 1)
aug_img = img_augmentation(tf.expand_dims(image, axis=0))
plt.imshow(aug_img[0].numpy().astype("uint8")) # 이동에 대한 ~가 줄어들고, 일반화 잘됨. 데이터는 많아지겠지. 학습시간도
plt.title(f"{format_label(label)}")
plt.axis("off")
from tensorflow.keras.applications.efficientnet import EfficientNetB0
"""
"""
## Quick recipes
### Image data augmentation (on-device)
Note that image data augmentation layers are only active during training (similarly to
the `Dropout` layer).
"""
from tensorflow import keras
from tensorflow.keras import layers
# Create a data augmentation stage with horizontal flipping, rotations, zooms
data_augmentation = keras.Sequential([
preprocessing.RandomFlip("horizontal"),
preprocessing.RandomRotation(0.1),
preprocessing.RandomZoom(0.1),
])
# Create a model that includes the augmentation stage
input_shape = (32, 32, 3)
classes = 10
inputs = keras.Input(shape=input_shape)
# Augment images
x = data_augmentation(inputs)
# Rescale image values to [0, 1]
x = preprocessing.Rescaling(1.0 / 255)(x)
# Add the rest of the model
outputs = keras.applications.ResNet50(weights=None,
input_shape=input_shape,
example['image'] = tf.image.convert_image_dtype(example['image'], dtype=tf.uint8)
example['image'] = tf.image.resize(example['image'], tf.constant([RESIZE_TO, RESIZE_TO]))
return example['image'], tf.one_hot(example['image/label'], depth=NUM_CLASSES)
def create_dataset(filenames, batch_size):
"""Create dataset from tfrecords file
:tfrecords_files: Mask to collect tfrecords file of dataset
:returns: tf.data.Dataset
"""
return tf.data.TFRecordDataset(filenames)\
.map(parse_proto_example, num_parallel_calls=tf.data.AUTOTUNE)\
.batch(batch_size)\
.prefetch(tf.data.AUTOTUNE)
data_augmentation = tf.keras.Sequential([
preprocessing.RandomFlip(mode="horizontal_and_vertical")
])
def build_model():
inputs = tf.keras.Input(shape=(RESIZE_TO, RESIZE_TO, 3))
x = data_augmentation(inputs)
x = EfficientNetB0(include_top=False, weights='imagenet', input_tensor = x)
x.trainable = False
x = tf.keras.layers.GlobalAveragePooling2D()(x.output)
outputs = tf.keras.layers.Dense(NUM_CLASSES, activation=tf.keras.activations.softmax)(x)
return tf.keras.Model(inputs=inputs, outputs=outputs)
def main():
args = argparse.ArgumentParser()
args.add_argument('--train', type=str, help='Glob pattern to collect train tfrecord files, use single quote to escape *')
def visualize_flip(image):
visualize_plots([
image,
Sequential([preprocessing.RandomFlip("horizontal")])(tf.expand_dims(image, 0))[0]
], "flip")
# couple of simple transformations to the model from Tutorial 1.
from tensorflow import keras
from tensorflow.keras import layers
# these are a new feature in TF 2.2
from tensorflow.keras.layers.experimental import preprocessing
pretrained_base = tf.keras.models.load_model(
'vgg16-pretrained-base',
)
pretrained_base.trainable = False
model = keras.Sequential([
# Preprocessing
preprocessing.RandomFlip('horizontal'), # flip left-to-right
preprocessing.RandomContrast(0.5), # contrast change by up to 50%
# Base
pretrained_base,
# Head
layers.Flatten(),
layers.Dense(6, activation='relu'),
layers.Dense(1, activation='sigmoid'),
])
""" STEP 3 - TRAIN AND EVALUATE """
model.compile(
optimizer='adam',
loss='binary_crossentropy',
metrics=['binary_accuracy'],
def build_augmenters(imgaug=True):
if imgaug:
ia.seed(SEED)
sometimes = lambda aug: iaa.Sometimes(0.8, aug, seed=SEED)
augmenters = iaa.Sequential(
[
iaa.SomeOf(
(1, 3) if EXTRACT_IMAGES else (2, 4),
[
iaa.Add((-10, 10), per_channel=0.5, seed=SEED),
iaa.AdditiveGaussianNoise(loc=0,
scale=(0.0, 0.05 * 255),
per_channel=0.5,
seed=SEED),
iaa.OneOf(
[
iaa.GaussianBlur(sigma=(0, 0.5), seed=SEED),
iaa.AverageBlur(k=1, seed=SEED),
iaa.MedianBlur(k=1, seed=SEED),
],
seed=SEED,
),
iaa.LinearContrast(
(0.8, 1.2), per_channel=0.5, seed=SEED),
],
),
sometimes(
iaa.OneOf(
[
iaa.Fliplr(0.5, seed=SEED),
iaa.Flipud(0.2, seed=SEED),
],
seed=SEED,
), ),
sometimes(
iaa.Affine(
scale={
"x": (0.5, 1) if EXTRACT_IMAGES else (0.8, 1.2),
"y": (0.5, 1) if EXTRACT_IMAGES else (0.8, 1.2)
},
translate_percent={
"x": (-0.01, 0.01) if EXTRACT_IMAGES else
(-0.2, 0.2),
"y": (-0.01, 0.01) if EXTRACT_IMAGES else
(-0.2, 0.2),
},
rotate=(-25, 25) if EXTRACT_IMAGES else (-45, 45),
shear=(-16, 16),
order=[0, 1],
cval=(0, 255),
mode=ia.ALL,
seed=SEED,
)),
],
random_order=True,
seed=SEED,
)
return augmenters
else:
img_augmentation = Sequential(
[
preprocessing.RandomRotation(factor=0.3, seed=SEED),
preprocessing.RandomTranslation(
height_factor=0.01 if EXTRACT_IMAGES else 0.2,
width_factor=0.01 if EXTRACT_IMAGES else 0.2,
seed=SEED),
preprocessing.RandomFlip(seed=SEED),
preprocessing.RandomContrast(
factor=0.1 if EXTRACT_IMAGES else 0.2, seed=SEED),
],
name="img_augmentation",
)
return img_augmentation
plt.figure(figsize=(16, 12))
for n in range(30):
ax = plt.subplot(5, 6, n + 1)
plt.imshow(img_test[n].astype("uint8"))
plt.title(np.array(class_names)[label_test[n] == True][0])
plt.axis("off")
"""
## Augmentation
Define image augmentation using keras preprocessing layers and apply them to the training set.
"""
# Define image augmentation model
image_augmentation = keras.Sequential([
preprocessing.RandomFlip(mode="horizontal"),
preprocessing.RandomRotation(factor=0.1),
preprocessing.RandomZoom(height_factor=(-0.1, -0)),
preprocessing.RandomContrast(factor=0.1),
], )
# Apply the augmentations to the training images and plot a few examples
img_train = image_augmentation(img_train).numpy()
plt.figure(figsize=(16, 12))
for n in range(30):
ax = plt.subplot(5, 6, n + 1)
plt.imshow(img_train[n].astype("uint8"))
plt.title(np.array(class_names)[label_train[n] == True][0])
plt.axis("off")
"""
def main():
# Loading data.
# Load data from tensorflow_dataset (hereafter TFDS). Stanford Dogs
# dataset is provided in TFDS as stanford_dogs. It features 20,580
# images that belong to 120 classes of dog breeds (12,000 for
# training and 8,580 for testing).
# By simply changing dataset_name below, you may also try this
# notebook for other datasets in TFDS such as cifar10, cifar100,
# food101, etc. When the images are much smaller than the size of
# Efficientnet input, we can simply upsample the input images. It
# has been shown in Tan and Le, 2019 that transfer learning result
# is better for increased resolution even if input images remain
# small.
# For TPU: if using TFDS datasets, a GCS bucket location is
# required to save the datasets. For example:
# tfds.load(dataset_name, data_dir="gs://example-bucket/datapath")
# Also, both the current environment and the TPU service account
# have proper access to the bucket. Alternatively, for small
# datasets you may try loading data into the memory and use
# tf.data.Dataset.from_tensor_slices().
batch_size = 64
dataset_name = "stanford_dogs"
(ds_train, ds_test), ds_info = tfds.load(dataset_name,
split=["train", "test"],
with_info=True,
as_supervised=True)
num_classes = ds_info.features["label"].num_classes
# When the dataset include images with various size, need to resize
# them into a shared size. The Stanford Dogs dataset includes only
# images at least 200x200 pixels in size. Here, resize the images
# to the input size needed for EfficientNet.
size = (IMG_SIZE, IMG_SIZE)
ds_train = ds_train.map(lambda image, label:
(tf.image.resize(image, size), label))
ds_test = ds_test.map(lambda image, label:
(tf.image.resize(image, size), label))
# Visualize the data.
# The following code shows the first 9 images with their labels.
#'''
def format_label(label):
string_label = label_info.int2str(label)
return string_label.split("-")[1]
label_info = ds_info.features["labels"]
for i, (image, label) in enumerate(ds_train.take(9)):
ax = plt.subplot(3, 3, i + 1)
plt.imshow(image.numpy().astype("uint8"))
plt.title("{}".format(format_label(label)))
plt.axis("off")
#'''
# Data augmentation.
# Use preprocessing layers APIs for image augmentation.
img_augmentation = Sequential(
[
preprocessing.RandomRotation(factor - 0.15),
preprocessing.RandomTranslation(height_factor=0.1,
width_factor=0.1),
preprocessing.RandomFlip(),
preprocessing.RandomContrast(factor=0.1),
],
name="img_augmentation",
)
# This sequential model object can be used both as part of the
# model built later, and as a function to preprocess data before
# feeding into the model. Using them as a function makes it easy to
# visualize the augmented images. Here, plot 9 examples of
# augmentation result of a given figure.
#'''
for image, label in ds_train.take(1):
for i in range(9):
ax = plt.subplot(3, 3, i + 1)
aug_img = img_augmentation(tf.expand_dims(image, axis=0))
plt.imshow(image[0].numpy().astype("uint8"))
plt.title("{}".format(format_label(label)))
plt.axis("off")
#'''
# Prepare inputs.
# Once verified the input data and augmentation are working
# correctly, prepared dataset for training. The input data is
# resized to uniform IMG_SIZE. The labels are put into a one-hot
# (a.k.a categorical) encoding. The dataset is batched.
# Note: prefetch and AUTOTUNE may in some situation improve
# performance, but depends on environment and the specific dataset
# used. See this guide for more information on data pipeline
# performance.
# One-hot / categorical encoding.
def input_preprocess(image, label):
label = tf.one_hot(label, num_classes)
return image, label
ds_train = ds_train.map(input_preprocess,
num_parallel_calls=tf.data.experimental.AUTOTUNE)
ds_train = ds_train.batch(batch_size=batch_size, drop_remainder=True)
ds_train = ds_train.prefetch(tf.data.experimental.AUTOTUNE)
ds_test = ds_test.map(input_preprocess)
ds_test = ds_test.batch(batch_size=batch_size, drop_remainder=True)
# Train a model from scratch.
# Build an EfficientNetB0 with 120 output classes, that is
# initialized from scratch.
# Note: the accuracy will increase very slowly and may overfit.
with strategy.scope():
inputs = la
# Exit the program.
exit(0)
def convert_to_float(image, label):
image = tf.image.convert_image_dtype(image, dtype=tf.float32)
return image, label
AUTOTUNE = tf.data.experimental.AUTOTUNE
ds_train = (ds_train_.map(convert_to_float).cache().prefetch(
buffer_size=AUTOTUNE))
# Data Augmentation
augment = keras.Sequential([
preprocessing.RandomContrast(factor=0.5),
preprocessing.RandomFlip(mode='horizontal'), # meaning, left-to-right
preprocessing.RandomFlip(mode='vertical'), # meaning, top-to-bottom
preprocessing.RandomWidth(factor=0.15), # horizontal stretch
preprocessing.RandomRotation(factor=0.20),
preprocessing.RandomTranslation(height_factor=0.1, width_factor=0.1),
preprocessing.RandomContrast(factor=0.10),
preprocessing.RandomFlip(mode='horizontal'),
preprocessing.RandomRotation(factor=0.10),
])
ex = next(iter(ds_train.unbatch().map(lambda x, y: x).batch(1)))
plt.figure(figsize=(10, 10))
for i in range(16):
image = augment(ex, training=True)
plt.subplot(4, 4, i + 1)
)
model_.fit(train_gen_data, epochs = 2, validation_data=)
for x, y in train_gen_data.take(1):
print(x.shape, y.shape)
from tensorflow.keras.layers.experimental import preprocessing
from tensorflow.keras import Sequential
# Doing preprocessing inside the model
# Standardization
# Data augmentation
augmentations = Sequential([
preprocessing.RandomFlip("horizontal"),
preprocessing.RandomRotation(0.1),
preprocessing.RandomZoom(0.1),
])
scaling = preprocessing.Rescaling(1.0 / 255)
model_ = Sequential([
augmentations,
scaling,
model
])
plt.figure(figsize=(10, 10))
for i in range(9):
plt.subplot(3, 3, i + 1)
aug_img = model_(tf.expand_dims(x_train[i], 0))
