Data incremento Image Generatore di dati Keras Segmentazione semantica

Question

Sto installando una rete convoluzionale completa su alcuni dati di immagine per la segmentazione semantica usando Keras. Tuttavia, sto avendo alcuni problemi di sovralimentazione. Non ho tanti dati e voglio fare l'aumento dei dati. Tuttavia, dal momento che voglio fare una classificazione in pixel, ho bisogno di qualsiasi tipo di incremento, come salti mortali, rotazione e turni, da applicare sia alle immagini delle caratteristiche che alle immagini delle etichette. Idealmente mi piacerebbe utilizzare Keras ImageDataGenerator per le trasformazioni al volo. Tuttavia, per quanto posso dire, non è possibile eseguire trasformazioni equivalenti su entrambi i dati delle funzioni e delle etichette.

Qualcuno sa se questo è il caso e in caso contrario, qualcuno ha qualche idea? Altrimenti, userò altri strumenti per creare un set di dati più grande e lo inserirò tutto in una volta.

Grazie!

Answer 1

Ci sono lavori per estendere ImageDataGenerator per essere più flessibile esattamente per questo tipo di casi (vedi per esempio this issue on Github).

Inoltre, come menzionato da Mikael Rousson nei commenti, è possibile creare facilmente la propria versione di ImageDataGenerator autonomamente, sfruttando al contempo molte delle sue funzioni integrate per renderlo più semplice. Ecco un codice di esempio che ho usato per un problema di riduzione dell'immagine, in cui utilizzo colture random + rumore addizionale per generare coppie di immagini pulite e rumorose al volo. Potresti facilmente modificarlo per aggiungere altri tipi di ingrandimenti. Dopo di che, è possibile utilizzare Model.fit_generator per allenarsi utilizzando questi metodi.

from keras.preprocessing.image import load_img, img_to_array, list_pictures 

def random_crop(image, crop_size): 
    height, width = image.shape[1:] 
    dy, dx = crop_size 
    if width < dx or height < dy: 
     return None 
    x = np.random.randint(0, width - dx + 1) 
    y = np.random.randint(0, height - dy + 1) 
    return image[:, y:(y+dy), x:(x+dx)] 

def image_generator(list_of_files, crop_size, to_grayscale=True, scale=1, shift=0): 
    while True: 
     filename = np.random.choice(list_of_files) 
     try: 
      img = img_to_array(load_img(filename, to_grayscale)) 
     except: 
      return 
     cropped_img = random_crop(img, crop_size) 
     if cropped_img is None: 
      continue 
     yield scale * cropped_img - shift 
def corrupted_training_pair(images, sigma): 
    for img in images: 
     target = img 
     if sigma > 0: 
      source = img + np.random.normal(0, sigma, img.shape)/255.0 
     else: 
      source = img 
     yield (source, target) 
def group_by_batch(dataset, batch_size): 
    while True: 
     try: 
      sources, targets = zip(*[next(dataset) for i in xrange(batch_size)]) 
      batch = (np.stack(sources), np.stack(targets)) 
      yield batch 
     except: 
      return 
def load_dataset(directory, crop_size, sigma, batch_size): 
    files = list_pictures(directory) 
    generator = image_generator(files, crop_size, scale=1/255.0, shift=0.5) 
    generator = corrupted_training_pair(generator, sigma) 
    generator = group_by_batch(generator, batch_size) 
    return generator 

È quindi possibile utilizzare quanto sopra in questo modo:

train_set = load_dataset('images/train', (patch_height, patch_width), noise_sigma, batch_size) 
val_set = load_dataset('images/val', (patch_height, patch_width), noise_sigma, batch_size) 
model.fit_generator(train_set, samples_per_epoch=batch_size * 1000, nb_epoch=nb_epoch, validation_data=val_set, nb_val_samples=1000) 

Answer 2

Sì, è possibile. Ecco un esempio dei documenti di Keras. Comprimi insieme due generatori seminato con gli stessi semi e il fit_generator. https://keras.io/preprocessing/image/

# we create two instances with the same arguments 
data_gen_args = dict(featurewise_center=True, 
        featurewise_std_normalization=True, 
        rotation_range=90., 
        width_shift_range=0.1, 
        height_shift_range=0.1, 
        zoom_range=0.2) 
image_datagen = ImageDataGenerator(**data_gen_args) 
mask_datagen = ImageDataGenerator(**data_gen_args) 

# Provide the same seed and keyword arguments to the fit and flow methods seed = 1 
image_datagen.fit(images, augment=True, seed=seed) 
mask_datagen.fit(masks, augment=True, seed=seed) 

image_generator = image_datagen.flow_from_directory(
    'data/images', 
    class_mode=None, 
    seed=seed) 

mask_generator = mask_datagen.flow_from_directory(
    'data/masks', 
    class_mode=None, 
    seed=seed) 

# combine generators into one which yields image and masks 
train_generator = zip(image_generator, mask_generator) 

model.fit_generator(
    train_generator, 
    samples_per_epoch=2000, 
    nb_epoch=50)