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)