def from_txt_generator(batch_size):
print("Getting augmented data from text files")
index = rn.randint(0,27)*8 #Start at random image\
img_datagen = idg( #Transformation parameters
rotation_range=360,
width_shift_range=0.2,
height_shift_range=0.2,
horizontal_flip=True,
fill_mode="reflect"
)
rgb_datagen = idg(
rescale=1./255,
rotation_range=360,
width_shift_range=0.2,
height_shift_range=0.2,
horizontal_flip=True,
fill_mode="reflect"
)
while(1):
seed = rn.randint(0,5000)
img_list = load_data(TRAINING_DATA_DIR+"rgb", batch_size, index) #Get images
dxy_list = util.batch_from_txt(TRAINING_DATA_DIR+"txt", batch_size, index, False)
mask_list = load_data(TRAINING_DATA_DIR+"mask", batch_size, index)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
mask_list = [skimage.transform.resize(mask, (IMAGE_H, IMAGE_W)) for mask in mask_list]
mask_list = [skimage.color.rgb2gray(i) for i in mask_list]
mask_list = [skimage.exposure.rescale_intensity(i) for i in mask_list]
img_list = np.array(img_list, dtype=np.float32)
mask_list = np.array(mask_list, dtype=np.float32)
mask_list = np.expand_dims(mask_list, 3)
mask_list = np.nan_to_num(mask_list) #Need this for some reason???
index += batch_size
if(index >= number_of_files()):
index = 0
#Generate next batch of images by applying random transformations
img_gen = rgb_datagen.flow(img_list, mask_list, batch_size=batch_size, shuffle=True, seed=seed)
dx_gen = img_datagen.flow(dxy_list, mask_list, batch_size=batch_size, shuffle=True, seed=seed)
mask_gen = img_datagen.flow(mask_list, mask_list, batch_size=batch_size, shuffle=True, seed=seed)
img = img_gen.next()[0] #flow method always produces a tuple of data+labels, but we only want the data
dxy = dx_gen.next()[0]
mask = mask_gen.next()[0]
out = np.concatenate((img, dxy), 3) #Combine layers
mask = mask.reshape(batch_size, IMAGE_H*IMAGE_W, NUMBER_OF_CLASSES)
yield out, mask
def get_datagenerators_v1(self):
'''
Define the image manipulation steps to be randomly applied to each
image. Multiple versions of this function will likely exist to test
different strategies.
Return a generator for both train and test data.
'''
train_generator = idg(
featurewise_center=False, # default
samplewise_center=False, # default
featurewise_std_normalization=False, # default
samplewise_std_normalization=False, # default
zca_whitening=False, # default
zca_epsilon=1e-6, # default
rotation_range=0., # default
width_shift_range=0., # default
height_shift_range=0., # default
shear_range=0., # default
zoom_range=0., # default
channel_shift_range=0., # default
fill_mode='nearest', # default
cval=0., # default
horizontal_flip=False, # default
vertical_flip=False, # default
rescale=1. / 255, # rescale RGB vales
preprocessing_function=None, # default
data_format='channels_last') # default
test_generator = idg(
featurewise_center=False, # default
samplewise_center=False, # default
featurewise_std_normalization=False, # default
samplewise_std_normalization=False, # default
zca_whitening=False, # default
zca_epsilon=1e-6, # default
rotation_range=0., # default
width_shift_range=0., # default
height_shift_range=0., # default
shear_range=0., # default
zoom_range=0., # default
channel_shift_range=0., # default
fill_mode='nearest', # default
cval=0., # default
horizontal_flip=False, # default
vertical_flip=False, # default
rescale=1. / 255, # rescale RGB vales
preprocessing_function=None, # default
data_format='channels_last') # default
return train_generator, test_generator
def from_txt_generator(batch_size):
print("Getting augmented data from text files")
index = 0
img_datagen = idg( #Transformation params
rotation_range=360,
width_shift_range=0.2,
height_shift_range=0.2,
horizontal_flip=True,
fill_mode="reflect")
while (1):
seed = rn.randint(0, 5000)
output = batch_from_txt(TRAINING_DATA_DIR + "txt", batch_size, index,
False) #Get batch of dxy images from txt
mask_list = load_data(TRAINING_DATA_DIR + "mask", batch_size,
index) #Get masks
with warnings.catch_warnings(): #Rescale etc
warnings.simplefilter("ignore")
mask_list = [
skimage.transform.resize(mask, (IMAGE_H, IMAGE_W))
for mask in mask_list
]
mask_list = [skimage.color.rgb2gray(i) for i in mask_list]
mask_list = [
skimage.exposure.rescale_intensity(i) for i in mask_list
]
mask_list = np.array(mask_list, dtype=np.float32)
mask_list = np.expand_dims(mask_list, 3)
mask_list = np.nan_to_num(mask_list) #Need this for some reason???
index += batch_size #Move index along to grab next batch
if (index >= number_of_files()):
index = 0
dx_gen = img_datagen.flow(output,
mask_list,
batch_size=batch_size,
shuffle=True,
seed=seed)
mask_gen = img_datagen.flow(mask_list,
mask_list,
batch_size=batch_size,
shuffle=True,
seed=seed)
dxy = dx_gen.next()[0] #Obtain a batch of transformed images
mask = mask_gen.next(
)[0] #The flow method produces a tuple of images + labels, but we don't want labels for this task
"""cv2.imshow("dx1", dxy[0,:,:,0])
cv2.imshow("dx2", dxy[1,:,:,0])
cv2.imshow("m1", np.reshape(mask[0], (256,256)))
cv2.imshow("m2", np.reshape(mask[1],(256,256)))
cv2.waitKey(0)"""
mask = mask.reshape(batch_size, IMAGE_H * IMAGE_W, NUMBER_OF_CLASSES)
yield dxy, mask
def variation_gen(batch_size):
data_aug = idg( #Transformation parameters- applied to images and masks
rescale=1. / 255,
rotation_range=360,
width_shift_range=0.2,
height_shift_range=0.2,
horizontal_flip=True,
fill_mode="reflect")
img_datagen = data_aug
mask_datagen = data_aug
shuffle = True #order images are taken from folder- if True, random selection determined by seed
seed = rn.randint(
0,
65535) #determines what flips and rotations are applied to each image
img_gen = img_datagen.flow_from_directory(TRAINING_DATA_DIR,
classes=["rgb"],
target_size=(IMAGE_H, IMAGE_W),
color_mode="rgb",
class_mode=None,
batch_size=batch_size,
shuffle=shuffle,
seed=seed)
mask_gen = mask_datagen.flow_from_directory(TRAINING_DATA_DIR,
classes=["mask"],
target_size=(IMAGE_H, IMAGE_W),
color_mode="grayscale",
class_mode=None,
batch_size=batch_size,
shuffle=shuffle,
seed=seed)
print("Loading augmented data")
while (1):
imgs = img_gen.next() #Get next batch of transformed images
masks = mask_gen.next()
masks = skimage.exposure.rescale_intensity(masks)
masks = masks.reshape(batch_size, IMAGE_H * IMAGE_W, NUMBER_OF_CLASSES)
yield imgs, masks
model = models.Sequential()
model.add(conv_base)
model.add(layers.Flatten())
model.add(layers.Dense(256, activation='relu', input_dim=4 * 4 * 512))
model.add(layers.Dropout(0.5))
model.add(layers.Dense(1, activation='sigmoid'))
# endregion
batch_size = 16
# region generators and pretrained convolution base
train_datagen = idg(rescale=1./255,
rotation_range=45,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
test_datagen = idg(rescale=1./255)
train_generator = train_datagen.flow_from_directory(train_dir, target_size=(150, 150),
batch_size=batch_size, class_mode='binary')
validation_generator = test_datagen.flow_from_directory(validation_dir, target_size=(150, 150),
batch_size=batch_size, class_mode='binary')
# endregion
# region training
model.compile(loss='binary_crossentropy', optimizer=optimizers.RMSprop(lr=1e-5), metrics=['acc'])
history = model.fit_generator(train_generator,
steps_per_epoch=2000 // batch_size,
def get_datagenerators_v1(X_train, y_train, X_test, y_test):
'''
Define the image manipulation steps to be randomly applied to each image.
Multiple versions of this function will likely exist to test different
strategies. Return a generator for both train and test data.
'''
print("Create Image Data Generators for train and test ... ")
train_datagen = idg(
featurewise_center=False, # default
samplewise_center=False, # default
featurewise_std_normalization=False, # default
samplewise_std_normalization=False, # default
zca_whitening=False, # default
zca_epsilon=1e-6, # default
rotation_range=0., # default
width_shift_range=0., # default
height_shift_range=0., # default
shear_range=0., # default
zoom_range=0., # default
channel_shift_range=0., # default
fill_mode='nearest', # default
cval=0., # default
horizontal_flip=False, # default
vertical_flip=False, # default
rescale=1. / 255, # rescale RGB vales
preprocessing_function=None, # default
data_format='channels_last') # default
test_datagen = idg(
featurewise_center=False, # default
samplewise_center=False, # default
featurewise_std_normalization=False, # default
samplewise_std_normalization=False, # default
zca_whitening=False, # default
zca_epsilon=1e-6, # default
rotation_range=0., # default
width_shift_range=0., # default
height_shift_range=0., # default
shear_range=0., # default
zoom_range=0., # default
channel_shift_range=0., # default
fill_mode='nearest', # default
cval=0., # default
horizontal_flip=False, # default
vertical_flip=False, # default
rescale=1. / 255, # rescale RGB vales
preprocessing_function=None, # default
data_format='channels_last') # default
train_generator = train_datagen.flow(
X_train,
y_train, # labels just get passed through
batch_size=BATCH_SIZE,
shuffle=False,
seed=None)
test_generator = test_datagen.flow(
X_test,
y_test, # labels just get passed through
batch_size=BATCH_SIZE,
shuffle=False,
seed=None)
return train_generator, test_generator
'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
]
print("Your letter is: " + str(alpha[visual_train[num][0] - 1]))
elif visu_one != 'Y':
print("\n~~~~~~~~~~ Learning Resuming ~~~~~~~~~~\n")
from keras.preprocessing.image import ImageDataGenerator as idg
conditions = {
'rotation_range': 12,
'width_shift_range': 0.1,
'shear_range': 0.3,
'height_shift_range': 0.1,
'zoom_range': 0.1,
'data_format': 'channels_first'
}
aug_gen = idg(**conditions)
all_batches = aug_gen.flow(train, train_labels, batch_size=batch_size)
testing = aug_gen.flow(test, test_labels, batch_size=batch_size)
steps = int(np.ceil(all_batches.n / batch_size))
val_steps = int(np.ceil(testing.n / batch_size))
############################################################
# func: normalize
#
############################################################
def normalize(x):
# print('normalized')
return (x - train.mean().astype(np.float32)) / train.std().astype(
np.float32)
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(150, 150, 3)))
model.add(layers.MaxPooling2D((4, 4)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((4, 4)))
model.add(layers.Flatten())
model.add(layers.Dense(512, activation='relu'))
model.add(layers.Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer=optimizers.RMSprop(lr=1e-4), metrics=['acc'])
# endregion
# region generators
train_datagen = idg(rescale=1./255)
test_datagen = idg(rescale=1./255)
train_generator = train_datagen.flow_from_directory(train_dir, target_size=(150, 150),
batch_size=4, class_mode='binary')
validation_generator = test_datagen.flow_from_directory(validation_dir, target_size=(150, 150),
batch_size=4, class_mode='binary')
# endregion
# region training
history = model.fit_generator(train_generator, steps_per_epoch=100, epochs=100,
validation_data=validation_generator, validation_steps=50)
model.save('cat_vs_dog_small_1.h5')
# endregion
def smooth(points, starting_point=0, factor=0.9):
for i in listClass:
numpy.random.seed(2018)
dataFake = dataTrain.loc[dataTrain["result"]==i].sample(intTrainBalanceSize, replace =True)
listFakeTrain.append(dataFake)
dataFakeTrain = pandas.concat(listFakeTrain)
dataFakeTrain["id"] = range(dataFakeTrain.shape[0])
strTrainPath = strOutputPath + "Holdout/" + "Train/"
os.makedirs(strTrainPath, exist_ok = True)
dataFakeTrain.to_csv(strTrainPath + "Table.csv", index = False)
for index, data in dataFakeTrain.iterrows():
file = data["image"]
result = str(data["result"])
image = pil.open("Holdout/Train/Image/" + result + '/' + file)
##
## Image generator
generator = idg(rotation_range = 360, horizontal_flip=True, vertical_flip=True)
##
## Old
old = numpy.array(image)
old = old.reshape((1,) + old.shape)
##
## New
new = generator.flow(old).next()
new = new[0,:,:,:].astype("uint8")
new = pil.fromarray(new)
strImagePath = strOutputPath + "Holdout/Train/Image/" + result + "/"
os.makedirs(strImagePath, exist_ok = True)
new.save(strImagePath + str(data["id"]) + ".jpg")
##
## Valid data
dataValid = pandas.read_csv("Holdout/Valid/Table.csv")
model.add(Conv2D(64, [3, 3], strides=1, padding='valid', activation='relu'))
model.add(Conv2D(128, [3, 3], strides=1, padding='valid', activation='relu'))
model.add(MaxP2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(1024, activation='relu'))
model.add(Dropout(0.4))
model.add(Dense(36, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
train_datagen = idg(rescale=rescl,
shear_range=0.2,
zoom_range=0.2,
rotation_range=5,
horizontal_flip=True)
test_datagen = idg(rescale=rescl)
train_generator = train_datagen.flow_from_directory(training_dir,
target_size=(image_width,
image_height),
batch_size=batch_s,
class_mode='categorical')
test_generator = test_datagen.flow_from_directory(testing_dir,
target_size=(image_width,
image_height),
batch_size=batch_s,
"""
# endregion
# region model
model = models.Sequential()
model.add(layers.Dense(256, activation='relu', input_dim=4 * 4 * 512))
model.add(layers.Dropout(0.5))
model.add(layers.Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer=optimizers.RMSprop(lr=2e-5), metrics=['acc'])
# endregion
# region generators and pretrained convolution base
conv_base = VGG16(weights='imagenet', include_top=False, input_shape=(150, 150, 3))
datagen = idg(rescale=1./255)
batch_size = 1
def extract_features(directory, num_sample):
features = np.zeros(shape=(num_sample, 4, 4, 512))
labels = np.zeros(shape=(num_sample))
generator = datagen.flow_from_directory(directory,
target_size=(150, 150),
batch_size=batch_size,
class_mode='binary')
i = 0
for inputs_batch, labels_batch in generator:
features_batch = conv_base.predict(inputs_batch)
features[i * batch_size: (i + 1) * batch_size] = features_batch
labels[i * batch_size: (i + 1) * batch_size] = labels_batch
i += 1
if i * batch_size >= num_sample:
# endregion
# region adversarial network
discriminator.trainable = False
gan_input = keras.Input(shape=(latent_dim, ))
gan_output = discriminator(generator(gan_input))
gan = keras.models.Model(gan_input, gan_output)
gan_optimizer = keras.optimizers.RMSprop(lr=2e-4, clipvalue=1.)
gan.compile(optimizer=gan_optimizer, loss='binary_crossentropy')
gan.summary()
# endregion
# region load data
datagen = idg()
def extract_features(directory, num_sample):
batch_size = 1
features = np.zeros(shape=(num_sample, height, height, channels))
labels = np.zeros(shape=(num_sample, ))
gen = datagen.flow_from_directory(directory,
target_size=(height, width),
batch_size=batch_size,
class_mode='binary')
i = 0
for inputs_batch, labels_batch in gen:
features[i * batch_size:(i + 1) * batch_size] = inputs_batch
labels[i * batch_size:(i + 1) * batch_size] = labels_batch
i += 1
