使用 TensorFlow-Keras API 进行数据增强

Question

The following code allows the images of a training set to be rotated 90º at the end of each epoch.

from skimage.io import imread
from skimage.transform import resize, rotate
import numpy as np

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
from keras.utils import Sequence 
from keras.models import Sequential
from keras.layers import Conv2D, Activation, Flatten, Dense

# Model architecture  (dummy)
model = Sequential()
model.add(Conv2D(32, (3, 3), input_shape=(15, 15, 4)))
model.add(Activation('relu'))
model.add(Flatten())
model.add(Dense(1))
model.add(Activation('sigmoid'))
model.compile(loss='binary_crossentropy',
              optimizer='rmsprop',
              metrics=['accuracy'])

# Data iterator 
class CIFAR10Sequence(Sequence):
    def __init__(self, filenames, labels, batch_size):
        self.filenames, self.labels = filenames, labels
        self.batch_size = batch_size
        self.angles = [0,90,180,270]
        self.current_angle_idx = 0

    # Method to loop throught the available angles
    def change_angle(self):
      self.current_angle_idx += 1
      if self.current_angle_idx >= len(self.angles):
        self.current_angle_idx = 0
  
    def __len__(self):
        return int(np.ceil(len(self.filenames) / float(self.batch_size)))

    # read, resize and rotate the image and return a batch of images
    def __getitem__(self, idx):
        angle = self.angles[self.current_angle_idx]
        print (f"Rotating Angle: {angle}")

        batch_x = self.filenames[idx * self.batch_size:(idx + 1) * self.batch_size]
        batch_y = self.labels[idx * self.batch_size:(idx + 1) * self.batch_size]
        return np.array([
            rotate(resize(imread(filename), (15, 15)), angle)
               for filename in batch_x]), np.array(batch_y)

# Custom call back to hook into on epoch end
class CustomCallback(keras.callbacks.Callback):
    def __init__(self, sequence):
      self.sequence = sequence

    # after end of each epoch change the rotation for next epoch
    def on_epoch_end(self, epoch, logs=None):
      self.sequence.change_angle()               


# Create data reader
sequence = CIFAR10Sequence(["f1.PNG"]*10, [0, 1]*5, 8)
# fit the model and hook in the custom call back
model.fit(sequence, epochs=10, callbacks=[CustomCallback(sequence)])

How can I modify the code so that the rotations of the images occur during each epoch?

Desired output:

Epoch 1/10
Rotating Angle: 0
Rotating Angle: 90
Rotating Angle: 180
Rotating Angle: 270

Epoch 2/10
Rotating Angle: 0
Rotating Angle: 90
Rotating Angle: 180
Rotating Angle: 270

(...)

Epoch 10/10
Rotating Angle: 0
Rotating Angle: 90
Rotating Angle: 180
Rotating Angle: 270

In other words, how can I write a callback that runs on the "end" of an epoch that changes the angle value and continues training on the same epoch (without changing to the next one)?

Thanks in Advance

Note: The code credits are from 'mujjiga'.

Answer 1

Since you have a custom sequence generator you can create a function that runs on either the start or end of an epoch. That is where you can put your code to modify the images. Documentation is [here.][1]

Epoch-level methods (training only)
on_epoch_begin(self, epoch, logs=None)
Called at the beginning of an epoch during training.

on_epoch_end(self, epoch, logs=None)
Called at the end of an epoch during training.


  [1]: https://keras.io/guides/writing_your_own_callbacks/

Answer 2

There is no need to create a CustomCallback for this purpose; in the end, you want augmentation during the training.

The solution is to apply the rotation operation with a probability

# read, resize and rotate the image and return a batch of images
def __getitem__(self, idx):
    angle = self.angles[self.current_angle_idx]
    print(f"Rotating Angle: {angle}")
    batch_x = self.filenames[idx * self.batch_size:(idx + 1) * self.batch_size]
    batch_y = self.labels[idx * self.batch_size:(idx + 1) * self.batch_size]
    #These new lines (say we augment with probability > 0.5)
    #Number between 0 and 1
    images = []
    for filename in batch_x:
        probability = random.random()
        apply_rotate = probability > 0.5
        if apply_rotate:
            images.append(rotate(resize(imread(filename), (15, 15)), angle))
        else:
            images.append(resize(imread(filename), (15, 15)))
    return np.array(images), np.array(batch_y)