def fit(model, data):
datagen = ImageDataGenerator(featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
rotation_range=10,
zoom_range=0.1,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=False,
vertical_flip=False)
learning_rate_reduction = ReduceLROnPlateau(monitor='val_accuracy',
patience=3,
verbose=1,
factor=0.5,
min_lr=0.00001)
datagen.fit(data[0])
history = model.fit_generator(datagen.flow(data[0],
data[2],
batch_size=batch_size),
epochs=epochs,
validation_data=(data[1], data[3]),
verbose=2,
steps_per_epoch=data[0].shape[0] //
batch_size,
callbacks=[learning_rate_reduction])
model.save(model_dir + name + "_" + str(epochs) + "_" + str(batch_size) +
".h5")
return history
def imageAugmentation(directory,
export_directory=None,
prefix="aug",
extension="jpg",
logger=None):
aug = ImageDataGenerator(rotation_range=10,
zoom_range=0.15,
width_shift_range=0.1,
height_shift_range=0.1,
shear_range=0.15,
horizontal_flip=True,
fill_mode="nearest")
dir_path = os.path.abspath(directory)
if export_directory is None:
export_directory = dir_path + "\\augmented"
try:
os.mkdir(export_directory)
print("Directory", export_directory, "Created ")
except FileExistsError:
print("Directory", export_directory, "already exists")
extension = extension.lower()
try:
file_names = os.listdir(dir_path)
counter = 1
for file_name in file_names:
if not file_name.lower().endswith(extension):
continue
fp = FilePath(dir_path + "\\" + file_name)
try:
image = np.expand_dims(load_img(fp.getAbsPath()), axis=0)
except Exception:
continue
print("Processing Image " + str(counter) + ": " + file_name)
if logger is not None:
logger.info("Processing Image " + str(counter) + ": " +
file_name)
aug.fit(image)
for x, val in zip(
aug.flow(image,
save_to_dir=export_directory,
save_format=extension,
save_prefix=prefix), range(10)):
pass
# if logger is not None:
# logger.info("...... saving augmented image " + str(val + 1) + " ......")
counter += 1
print("Done")
if logger is not None:
logger.info("Done")
except Exception as e:
if logger is not None:
logger.info(e)
print(e)
def setUpClass(cls):
(x_train, y_train), (x_test, y_test), min_, max_ = load_mnist()
x_train, y_train = x_train[:NB_TRAIN], y_train[:NB_TRAIN]
cls.mnist = (x_train, y_train), (x_test, y_test), (min_, max_)
# Create simple keras model
import tensorflow as tf
tf_version = [int(v) for v in tf.__version__.split(".")]
if tf_version[0] == 2 and tf_version[1] >= 3:
tf.compat.v1.disable_eager_execution()
from tensorflow.keras import backend as k
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten, Conv2D, MaxPooling2D
else:
import keras.backend as k
from keras.models import Sequential
from keras.layers import Dense, Flatten, Conv2D, MaxPooling2D
k.set_learning_phase(1)
model = Sequential()
model.add(
Conv2D(32,
kernel_size=(3, 3),
activation="relu",
input_shape=x_train.shape[1:]))
model.add(MaxPooling2D(pool_size=(3, 3)))
model.add(Flatten())
model.add(Dense(10, activation="softmax"))
model.compile(loss="categorical_crossentropy",
optimizer="adam",
metrics=["accuracy"])
from art.estimators.classification.keras import KerasClassifier
cls.classifier = KerasClassifier(model=model, clip_values=(min_, max_))
cls.classifier.fit(x_train, y_train, nb_epochs=1, batch_size=128)
cls.defence = ActivationDefence(cls.classifier, x_train, y_train)
datagen = ImageDataGenerator()
datagen.fit(x_train)
data_gen = KerasDataGenerator(datagen.flow(x_train,
y_train,
batch_size=NB_TRAIN),
size=NB_TRAIN,
batch_size=NB_TRAIN)
cls.defence_gen = ActivationDefence(cls.classifier,
None,
None,
generator=data_gen)
def train(self):
# training parameters
batch_size = 128
maxepoches = 50
learning_rate = 0.1
lr_decay = 1e-6
lr_drop = 20
# The data, shuffled and split between train and test sets:
trainX_norm, testX_norm = self.normalize(self.trainX, self.testX)
def lr_scheduler(epoch):
return learning_rate * (0.5**(epoch // lr_drop))
reduce_lr = keras.callbacks.LearningRateScheduler(lr_scheduler)
# data augmentation
datagen = ImageDataGenerator(
featurewise_center=False, # set input mean to 0 over the dataset
samplewise_center=False, # set each sample mean to 0
featurewise_std_normalization=
False, # divide inputs by std of the dataset
samplewise_std_normalization=False, # divide each input by its std
zca_whitening=False, # apply ZCA whitening
rotation_range=
15, # randomly rotate images in the range (degrees, 0 to 180)
width_shift_range=
0.1, # randomly shift images horizontally (fraction of total width)
height_shift_range=
0.1, # randomly shift images vertically (fraction of total height)
horizontal_flip=True, # randomly flip images
vertical_flip=False) # randomly flip images
# (std, mean, and principal components if ZCA whitening is applied).
datagen.fit(trainX_norm)
# optimization details
sgd = optimizers.SGD(lr=learning_rate,
decay=lr_decay,
momentum=0.9,
nesterov=True)
self.model.compile(loss='categorical_crossentropy',
optimizer=sgd,
metrics=['accuracy'])
# training process in a for loop with learning rate drop every 25 epoches.
history = self.model.fit_generator(
datagen.flow(trainX_norm, self.trainY, batch_size=batch_size),
steps_per_epoch=trainX_norm.shape[0] // batch_size,
epochs=maxepoches,
validation_data=(testX_norm, self.testY),
callbacks=[reduce_lr],
verbose=2)
self.model.save_weights('weights/vgg16_cifar10.h5')
return history
def data_augmentation(x_train_in, x_train_out, augment_size):
def histogram_equalization(x):
if np.random.random() < 0.5:
x = exposure.equalize_hist(x)
def adaptive_equalization(x):
if np.random.random() < 0.5:
x = exposure.equalize_adapthist(x, clip_limit=0.01)
def contrast_stretching(x):
if np.random.random() < 0.5:
p2, p98 = np.percentile(x, (2, 98))
x = exposure.rescale_intensity(x, in_range=(p2, p98))
def to_lab(x):
if np.random.random() < 0.5:
x = exposure.rgb2lab(x, illuminant='D65', observer='2')
x_train_in = np.reshape(
x_train_in, (x_train_in.shape[0], 120, 120, 1)).astype('float32') / 255
x_train_out = np.reshape(
x_train_out,
(x_train_out.shape[0], 120, 120, 1)).astype('float32') / 255
image_generator = ImageDataGenerator(
#rescale=1.0/255.0,
rotation_range=10,
#shear_range=0.8,
featurewise_center=False,
samplewise_std_normalization=False,
zoom_range=0.05,
width_shift_range=0.2,
height_shift_range=0.2,
horizontal_flip=True,
vertical_flip=True,
#preprocessing_function=histogram_equalization
)
# fit data for zca whitening
image_generator.fit(x_train_in, augment=True)
# get transformed images
randidx = np.random.randint(x_train_in.shape[0], size=augment_size)
x_augmented = x_train_in[randidx].copy()
y_augmented = x_train_out[randidx].copy()
x_augmented = image_generator.flow(x_augmented,
np.zeros(augment_size),
batch_size=augment_size,
shuffle=False).next()[0]
# append augmented data to trainset
x_train = np.concatenate((x_train_in, x_augmented))
y_train = np.concatenate((x_train_out, y_augmented))
return x_train, y_train
def _train_seed_amateur(model,
loaders,
log=False,
checkpoint=False,
logfile='',
checkpointFile=''):
(x_train, y_train), (x_test, y_test) = loaders
lr_decay = CustomLearningRateScheduler(initial_lr=0.1)
callbacks = [lr_decay]
# callbacks = []
optimizer = tf.keras.optimizers.SGD(learning_rate=0.1,
momentum=0.9,
nesterov=True)
model.build(input_shape=(None, ) + x_train[0].shape)
model.summary()
model.compile(optimizer=optimizer,
loss=tf.keras.losses.sparse_categorical_crossentropy,
metrics=[tf.keras.metrics.sparse_categorical_accuracy])
image_gen = ImageDataGenerator(featurewise_center=True,
featurewise_std_normalization=True,
data_format='channels_last')
image_gen.fit(x_train)
x_train = (x_train - image_gen.mean) / image_gen.std
x_test = (x_test - image_gen.mean) / image_gen.std
history = model.fit(x_train,
y_train,
epochs=200,
batch_size=128,
validation_split=0.1,
callbacks=callbacks,
verbose=1)
loss, acc = model.evaluate(x_test, y_test)
results = history.history
filename = 'history_epochs{4}_{0}_batchsize{1}_eta{2}_{3}'.format(
args.dataset, args.batch_size,
str(args.learning_rate).replace('.', '_'), model.get_filename(),
args.epochs)
results['test_loss'] = loss
results['test_acc'] = acc
print('test loss is {} and acc is {}'.format(loss, acc))
return acc
def augment_data(set_to_augment,
prefix="",
total_size=35000,
batchsize=64,
use_cached_training_data=None,
verbose=True):
""" Helper function to load the CIFAR-10 data
"""
filepath = prefix + use_cached_training_data + str(total_size)
# Look for cached training data
if use_cached_training_data:
x, y = load_2d_numpy_array_if_exists(filepath)
if x is not None and y is not None:
print(" Found cached training data for {}".format(
use_cached_training_data))
return (x, y), True
# Enhance training set with augmentation
generated_data = set_to_augment[0].copy(), set_to_augment[1].copy()
if not len(generated_data[0]) >= total_size:
datagen = ImageDataGenerator(
rotation_range=15,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=True,
)
datagen.fit(set_to_augment[0])
generator = datagen.flow(set_to_augment[0],
set_to_augment[1],
batch_size=batchsize)
print_percentage = 0.1
while len(generated_data[0]) < total_size:
next_sample = generator.next()
generated_data = np.concatenate((generated_data[0], next_sample[0]), axis=0), \
np.concatenate((generated_data[1], next_sample[1]), axis=0)
if verbose and len(
generated_data[0]) / total_size > print_percentage:
print("{}%..".format(int(print_percentage * 100)),
end="",
flush=True)
print_percentage += 0.1
if verbose:
print("100%! Done!")
# Look for cached training data
if use_cached_training_data:
save_2d_numpy_array_if_exists(filepath, generated_data[0][:total_size],
generated_data[1][:total_size])
generated_data = shuffle(*generated_data)
return (generated_data[0][:total_size],
generated_data[1][:total_size]), False
def data_generator(batch_size):
(X_train, Y_train), (X_test, Y_test) = keras.datasets.cifar10.load_data()
X_train = X_train.astype(np.float32) / 255
X_test = X_test.astype(np.float32) / 255
datagen = ImageDataGenerator(featurewise_center=True, zca_whitening=True)
datagen.fit(X_train)
X_train = datagen.standardize(X_train)
X_test = datagen.standardize(X_test)
return tf.data.Dataset.from_tensor_slices((X_train, Y_train)).batch(batch_size), \
tf.data.Dataset.from_tensor_slices((X_test, Y_test)).batch(batch_size)
def cifar10_data_generator(x_train):
"""
set up image augmentation for cifar 10
:param x_train: x_train data
:return: data generator
"""
datagen = ImageDataGenerator(rotation_range=15,
horizontal_flip=True,
width_shift_range=0.1,
height_shift_range=0.1
# zoom_range=0.3
)
datagen.fit(x_train)
return datagen
def train_classifier(classes, path, epoch, lr, weights_path=None):
model = res18(classes)
if weights_path:
model.load_weights(weights_path)
model.compile(optimizer=Adam(lr=float(lr)),
loss='binary_crossentropy',
metrics=['accuracy'])
trains, labels = img_reader()
generator = ImageDataGenerator(featurewise_center=True,
featurewise_std_normalization=True,
width_shift_range=0.1,
height_shift_range=0.1,
rotation_range=10,
shear_range=0.2,
zoom_range=(0.8, 1.2),
rescale=1. / 255,
horizontal_flip=True,
validation_split=0.2)
generator.fit(trains)
train_flow = generator.flow(trains,
labels,
shuffle=True,
subset='training')
validate_flow = generator.flow(trains,
labels,
shuffle=True,
subset='validation')
STEP_SIZE_TRAIN = train_flow.n // train_flow.batch_size
STEP_SIZE_VALID = validate_flow.n // validate_flow.batch_size
p = os.path.abspath('.')
weights_name = 'lr_0' + lr[2:] + '_weights_{epoch:02d}_{val_acc:.2f}.hdf5'
model_checkpoint = ModelCheckpoint(os.path.join(p, weights_name),
monitor='val_acc',
save_best_only=True)
reduce_lr = ReduceLROnPlateau(monitor='val_acc', factor=0.1, patience=10)
callbacks = [model_checkpoint, reduce_lr]
history = model.fit_generator(train_flow,
epochs=epoch,
steps_per_epoch=STEP_SIZE_TRAIN,
verbose=1,
callbacks=callbacks,
validation_data=validate_flow,
validation_steps=STEP_SIZE_VALID)
with open('history.json', 'w') as f:
json.dump(history.history, f)
def fit(self, X, bag_of_cells, epochs=30, batch_size=6):
self.boc = bag_of_cells
# Compute initial labels using LDA
self.lda = LDATopicGen(self.boc, topics=self.K)
y = self.lda.fit_predict()
self.X = X
self.y = y
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=0.3)
self.X_train = X_train
self.y_train = y_train
self.X_test = X_test
self.y_test = y_test
datagen = ImageDataGenerator(
# featurewise_center=True,
# featurewise_std_normalization=True,
# rotation_range=20,
# width_shift_range=0.2,
# height_shift_range=0.2,
# horizontal_flip=True
)
datagen.fit(self.X_train)
for e in range(epochs):
print("=" * 5, "Epoch %s" % str(e), "=" * 5)
batches = 0
# self._update_labels()
for x_batch, y_batch in datagen.flow(self.X_train,
self.y_train,
batch_size=batch_size):
loss = self.model.train_on_batch(x_batch, y_batch)
print("loss: %s - accuracy: %s" % (loss[0], loss[1]))
batches += 1
if batches >= len(X_train) / batch_size:
break
self.model.evaluate(x=X_test, y=y_test)
def preprocess_train_data(x, y):
y_train = keras.utils.to_categorical(y, config['model']['num_classes'])
x_train = x.astype('float32')
x_train /= 255
datagen = ImageDataGenerator(
# featurewise_center=False, # set input mean to 0 over the dataset
# samplewise_center=False, # set each sample mean to 0
# featurewise_std_normalization=False, # divide inputs by std of the dataset
# samplewise_std_normalization=False, # divide each input by its std
# zca_whitening=False, # apply ZCA whitening
# zca_epsilon=1e-06, # epsilon for ZCA whitening
rotation_range=
7, # randomly rotate images in the range (degrees, 0 to 180)
# randomly shift images horizontally (fraction of total width)
width_shift_range=0.1,
# randomly shift images vertically (fraction of total height)
# brightness_range=[0.7, 1.3],
height_shift_range=0.1,
shear_range=0., # set range for random shear
zoom_range=0., # set range for random zoom
channel_shift_range=0., # set range for random channel shifts
# set mode for filling points outside the input boundaries
fill_mode='nearest',
cval=0., # value used for fill_mode = "constant"
horizontal_flip=True, # randomly flip images
vertical_flip=False, # randomly flip images
# set rescaling factor (applied before any other transformation)
rescale=None,
# set function that will be applied on each input
preprocessing_function=None,
# image data format, either "channels_first" or "channels_last"
data_format='channels_last',
# fraction of images reserved for validation (strictly between 0 and 1)
validation_split=0.0)
# Compute quantities required for feature-wise normalization
# (std, mean, and principal components if ZCA whitening is applied).
datagen.fit(x_train, augment=True)
return datagen, x_train, y_train
def training_set_generator(X_train, Y_train):
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,
rescale=1. / 255)
# Provide the same seeda and keyword arguments to the fit and flow methods
seed = 1
image_datagen = ImageDataGenerator(**data_gen_args)
mask_datagen = ImageDataGenerator(**data_gen_args)
image_datagen.fit(X_train, augment=True, seed=seed)
mask_datagen.fit(Y_train, augment=True, seed=seed)
image_generator = image_datagen.flow(X_train, seed=seed, batch_size=1)
mask_generator = mask_datagen.flow(Y_train, seed=seed, batch_size=1)
for (img, mask) in zip(image_generator, mask_generator):
yield (img, mask)
def imgGen(img,
zca=False,
rotation=0.,
w_shift=0.,
h_shift=0.,
shear=0.,
zoom=0.,
h_flip=False,
v_flip=False,
preprocess_fcn=None,
batch_size=20):
"""
Datagen generation, tool to carry out the various image
augmentation transformations automatically, based on the
value of the parameters set. The DataGen is returned.
Parameters:
----------
- img, zca, rotation, w_shift, h_shift, shear, zoom, h_flip,
vflip, preprocess_fcn, batch size
#Return:
----------
- datagen
"""
datagen = ImageDataGenerator(zca_whitening=zca,
rotation_range=rotation,
width_shift_range=w_shift,
height_shift_range=h_shift,
shear_range=shear,
zoom_range=zoom,
fill_mode='nearest',
horizontal_flip=h_flip,
vertical_flip=v_flip,
preprocessing_function=preprocess_fcn,
data_format=K.image_data_format())
datagen.fit(img)
return datagen
print("y_train shape = ",yTrain.shape)
print("\nx_test shape = ",xTest.shape)
print("y_test shape = ",yTest.shape)
y_train_cat = to_categorical(yTrain)
y_test_cat = to_categorical(yTest)
#5) create generator for data augmentation
datagenTrain = ImageDataGenerator(
featurewise_center=True,
featurewise_std_normalization=True,
rotation_range=20,
width_shift_range=0.2,
height_shift_range=0.2,
horizontal_flip=True)
datagenTrain.fit(xTrain)
#6) create the model
prefix = ""
if MODEL == "SIMPLE_CNN":
prefix = "simpleCNN"
model = build_simple_CNN()
elif MODEL == "TRANSFER_LEARNING":
model = transfer_learning()
else:
print("Model not available, using default TRANSFER_LEARNING")
model = transfer_learning()
#7) model compiling and training
INIT_LR = 1e-3
BS = 32
PATH = '/Users/Anna/work/data/'
dg = DataGenerator()
(x_train, y_train), (x_test, y_test) = dg.load_data(PATH)
x_train = np.swapaxes(x_train, 1, 3)
x_test = np.swapaxes(x_test, 1, 3)
print('{} {}'.format(x_train.shape, y_train.shape))
###############
datagen = ImageDataGenerator()
datagen.fit(x_train)
# Create model
input, model = create_googlenet("../googLeNet/googlenet_weights.h5")
print("[INFO] compiling model...")
# for index, layer in enumerate(model.layers):
# print("{} {}".format(str(index), str(layer.name)))
# model.compile(optimizer='rmsprop', loss='categorical_crossentropy')
sgd = SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(optimizer=sgd, loss='categorical_crossentropy')
# Plugging into old net
loss1_classifier = Dense(2, name='loss1/classifier', kernel_regularizer=l2(0.0002))(model.layers[100].output)
loss2_classifier = Dense(2, name='loss2/classifier', kernel_regularizer=l2(0.0002))(model.layers[101].output)
loss3_classifier = Dense(2, name='loss3/classifier', kernel_regularizer=l2(0.0002))(model.layers[102].output)
x_train = np.asarray(x_train)
y_train = np.asarray(y_train)
x_test = np.asarray(x_test)
y_test = np.asarray(y_test)
# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
from keras_preprocessing.image import ImageDataGenerator
datagen = ImageDataGenerator(rotation_range=30,
width_shift_range=0.1,
height_shift_range=0.1,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
# fit augmented data
datagen.fit(x_train, augment=True)
for X_batch, y_batch in datagen.flow(x_train, y_train, batch_size=12):
# Show 10 images
for i in range(0, 10):
pyplot.subplot(3, 4, i + 1)
pyplot.imshow(X_batch[i].reshape(img_rows, img_cols, 3).astype(np.uint8))
# show the plot
pyplot.show()
break
def train(dataset, ckpt=None, output=None):
"""
Train the model
**input: **
*dataset: (String) Dataset folder to used
*ckpt: (String) [Optional] Path to the ckpt file to restore
*output: (String) [Optional] Path to the output folder to used. ./outputs/ by default
"""
def preprocessing_function(img):
"""
Custom preprocessing_function
"""
img = img * 255
img = PIL.Image.fromarray(img.astype('uint8'), 'RGB')
img = ImageEnhance.Brightness(img).enhance(random.uniform(0.6, 1.5))
img = ImageEnhance.Contrast(img).enhance(random.uniform(0.6, 1.5))
return np.array(img) / 255
X_train, y_train, X_valid, y_valid, X_test, y_test = get_images(dataset)
X_train = X_train / 255
X_valid = X_valid / 255
X_test = X_test / 255
train_datagen = ImageDataGenerator()
train_datagen_augmented = ImageDataGenerator(
rotation_range=20,
shear_range=0.2,
width_shift_range=0.2,
height_shift_range=0.2,
horizontal_flip=True,
preprocessing_function=preprocessing_function)
inference_datagen = ImageDataGenerator()
train_datagen.fit(X_train)
#train_datagen_augmented.fit(X_train)
inference_datagen.fit(X_valid)
inference_datagen.fit(X_test)
# Utils method to print the current progression
def plot_progression(b, cost, acc, label):
print("[%s] Batch ID = %s, loss = %s, acc = %s" %
(label, b, cost, acc))
# Init model
model = ModelTreemap("Treemap", output_folder=output)
if ckpt is None:
model.init()
else:
model.load(ckpt)
# Training pipeline
b = 0
valid_batch = inference_datagen.flow(X_valid,
y_valid,
batch_size=BATCH_SIZE)
best_validation_loss = None
augmented_factor = 0.99
decrease_factor = 0.80
train_batches = train_datagen.flow(X_train, y_train, batch_size=BATCH_SIZE)
augmented_train_batches = train_datagen_augmented.flow(
X_train, y_train, batch_size=BATCH_SIZE)
while True:
next_batch = next(augmented_train_batches if random.
uniform(0, 1) < augmented_factor else train_batches)
x_batch, y_batch = next_batch
### Training
cost, acc = model.optimize(x_batch, y_batch)
### Validation
x_batch, y_batch = next(valid_batch, None)
# Retrieve the cost and acc on this validation batch and save it in tensorboard
cost_val, acc_val = model.evaluate(x_batch, y_batch, tb_test_save=True)
if b % 10 == 0: # Plot the last results
plot_progression(b, cost, acc, "Train")
plot_progression(b, cost_val, acc_val, "Validation")
if b % 1000 == 0: # Test the model on all the validation
print("Evaluate full validation dataset ...")
loss, acc, _ = model.evaluate_dataset(X_valid, y_valid)
print("Current loss: %s Best loss: %s" %
(loss, best_validation_loss))
plot_progression(b, loss, acc, "TOTAL Validation")
if best_validation_loss is None or loss < best_validation_loss:
best_validation_loss = loss
model.save()
augmented_factor = augmented_factor * decrease_factor
print("Augmented Factor = %s" % augmented_factor)
b += 1
def test_mnist():
import os
os.environ['CUDA_VISIBLE_DEVICES']="2"
os.environ['TF_FORCE_GPU_ALLOW_GROWTH']="true"
#os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import keras
from keras.datasets import mnist,cifar10
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten, Input, Add, ReLU
from keras.layers import Conv2D, MaxPooling2D, AveragePooling2D, GlobalAveragePooling2D
from keras.layers import BatchNormalization,Activation, Concatenate
from keras.regularizers import l2,l1
from keras.callbacks import LearningRateScheduler, ModelCheckpoint, TensorBoard
from keras_preprocessing.image import ImageDataGenerator
from keras.optimizers import SGD, Adadelta
#from keras.initializers import glorot_uniform as w_ini
from keras.initializers import he_uniform as w_ini
from keras.initializers import VarianceScaling as VS_ini
from keras import backend as K
from keras_utils import RecordVariable, PrintLayerVariableStats, SGDwithLR
#config = tf.ConfigProto()
#config.gpu_options.allow_growth = True
#config.gpu_options.per_process_gpu_memory_fraction = 0.1
# Create a session with the above options specified.
#K.tensorflow_backend.set_session(tf.Session(config=config))
sid = 9
#sess = K.get_session()
K.clear_session()
#sess = tf.Session(graph=g)
#K.set_session(sess)
np.random.seed(sid)
tf.random.set_random_seed(sid)
tf.compat.v1.random.set_random_seed(sid)
#dset='cifar10'
dset = 'mnist'
batch_size = 512
num_classes = 10
epochs =200
test_acnn = True
regulazer = None
prfw = 5
fw = 5
residual = False
data_augmentation = False
if dset=='mnist':
# input image dimensions
img_rows, img_cols = 28, 28
# the data, split between train and test sets
(x_train, y_train), (x_test, y_test) = mnist.load_data()
n_channels=1
elif dset=='cifar10':
img_rows, img_cols = 32,32
n_channels=3
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
if K.image_data_format() == 'channels_first':
x_train = x_train.reshape(x_train.shape[0], n_channels, img_rows, img_cols)
x_test = x_test.reshape(x_test.shape[0], n_channels, img_rows, img_cols)
input_shape = (n_channels, img_rows, img_cols)
else:
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, n_channels)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, n_channels)
input_shape = (img_rows, img_cols, n_channels)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
trn_mn = np.mean(x_train, axis=0)
x_train -= trn_mn
x_test -= trn_mn
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')
# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
network=[]
network.append(Input(shape=input_shape))
# if test_acnn:
#
# prev_layer = network[-1]
#
#
# conv_node = Conv2DAdaptive(rank=2,nfilters=32,kernel_size=(fw,fw),
# data_format='channels_last',strides=1,
# padding='same',name='acnn-1', activation='linear',
# trainSigmas=True, trainWeights=True,
# init_sigma=[0.15,1.0],
# gain = np.sqrt(1.0),
# kernel_regularizer=None,
# init_bias=initializers.Constant(0))(prev_layer)
# if residual:
# network.append(Add()([conv_node,prev_layer]))
# else:
# network.append(conv_node)
# #, input_shape=input_shape))
# else:
#
# network.append(Conv2D(24, (fw, fw), activation='linear',
# kernel_initializer=w_ini(),
# kernel_regularizer=None,
# padding='same')(network[-1]))
network.append(Conv2D(32, kernel_size=(prfw, prfw),
activation='linear',padding='same', kernel_initializer=w_ini(),
kernel_regularizer=regulazer)(network[-1]))
network.append(BatchNormalization()(network[-1]))
network.append(Activation('relu')(network[-1]))
network.append(Dropout(0.2)(network[-1]))
network.append(Conv2D(32, (prfw, prfw), activation='linear',
kernel_initializer=w_ini(), padding='same',
kernel_regularizer=regulazer)(network[-1]))
#odel.add(MaxPooling2D(pool_size=(2, 2)))
network.append(BatchNormalization()(network[-1]))
network.append(Activation('relu')(network[-1]))
network.append(Dropout(0.2)(network[-1]))
# model.add(Conv2D(32, (3, 3), activation='linear',
# kernel_initializer=w_ini(), padding='same',
# kernel_regularizer=regulazer))
# #odel.add(MaxPooling2D(pool_size=(2, 2)))
# model.add(BatchNormalization())
# model.add(Activation('relu'))
#
# model.add(Dropout(0.2))
#
#odel.add(Dense(128, activation='relu'))
#odel.add(Dropout(0.25))
#=============================================================================
nfilter= 32
if test_acnn:
prev_layer = network[-1]
conv_node = Conv2DAdaptive(rank=2,nfilters=nfilter,kernel_size=(fw,fw),
data_format='channels_last',strides=1,
padding='same',name='acnn-1', activation='linear',
trainSigmas=True, trainWeights=True,
init_sigma=[0.25,0.75],
gain = 1.0,
kernel_regularizer=None,
init_bias=initializers.Constant(0),
norm=2)(prev_layer)
if residual:
network.append(Add()([conv_node,prev_layer]))
else:
network.append(conv_node)
#, input_shape=input_shape))
else:
#fw = 7
#v_ini = VS_ini(scale=0.25,mode='fan_in',distribution='uniform')
network.append(Conv2D(nfilter, (fw, fw), activation='linear',
kernel_initializer=w_ini(),
kernel_regularizer=None,
padding='same')(network[-1]))
#, input_shape=input_shape))
network.append(BatchNormalization()(network[-1]))
network.append(ReLU()(network[-1]))
#network.append(ReLU(negative_slope=0.01)(network[-1]))
#network.append(Activation('selu'))
network.append(MaxPooling2D(pool_size=(2,2))(network[-1]))
print("MAY BE MAXPOOL LAYER IS AFFECTING SIGNAL ")
network.append(Dropout(0.2)(network[-1]))
#model.add(keras.layers.AlphaDropout(0.2))
#network.append(GlobalAveragePooling2D()(network[-1]))
network.append(Flatten()(network[-1]))
network.append(Dense(units=128, activation='linear',
kernel_regularizer=regulazer)(network[-1]))
network.append(BatchNormalization()(network[-1]))
network.append(ReLU()(network[-1]))
network.append(Dropout(0.2)(network[-1]))
network.append(Dense(num_classes, activation='softmax',
kernel_regularizer=regulazer)(network[-1]))
model = keras.models.Model(inputs=[network[0]], outputs=network[-1])
model.summary()
print("MAY BE MAXPOOL LAYER IS AFFECTING SIGNAL ")
from lr_multiplier import LearningRateMultiplier
#lr=0.001
#multipliers = {'acnn-1/Sigma:0': 1.0,'acnn-1/Weights:0': 1000.0,
# 'acnn-2/Sigma:0': 1.0,'acnn-2/Weights:0': 1000.0}
#opt = LearningRateMultiplier(SGD, lr_multipliers=multipliers,
# lr=lr, momentum=0.9,decay=0)
#opt= SGD(lr=lr,momentum=0.9,decay=0,nesterov=False)
'''lr_dict = {'all':0.01,'acnn-1/Sigma:0': 0.01,'acnn-1/Weights:0': 1.0,
'acnn-2/Sigma:0': 0.01,'acnn-2/Weights:0': 0.1}
mom_dict = {'all':0.9,'acnn-1/Sigma:0': 0.5,'acnn-1/Weights:0': 0.9,
'acnn-2/Sigma:0': 0.9,'acnn-2/Weights:0': 0.9}
decay_dict = {'all':0.95, 'acnn-1/Sigma:0': 0.05, 'acnn-1/Weights:0':0.95,
'acnn-1/Sigma:0': 0.05,'acnn-2/Weights:0': 0.95}
clip_dict = {'acnn-1/Sigma:0':(0.05,1.0),'acnn-2/Sigma:0':(0.05,1.0)}
'''
lr_dict = {'all':0.1,'acnn/Sigma:0': 0.1,'acnn/Weights:0': 0.1,
'acnn-2/Sigma:0': 0.0001,'acnn-2/Weights:0': 0.01}
mom_dict = {'all':0.9,'acnn/Sigma:0': 0.9,'acnn/Weights:0': 0.9,
'acnn-2/Sigma:0': 0.9,'acnn-2/Weights:0': 0.9}
clip_dict = {'acnn/Sigma:0': [0.1, 2.0]}
decay_dict = {}
decay_dict.update({'focus-1'+'/Sigma:0':0.9}) #best results 0.5
decay_dict.update({'focus-1'+'/Mu:0':0.9})
decay_dict.update({'all':0.9})
e_i = x_train.shape[0] // batch_size
decay_epochs =[e_i*10,e_i*30,e_i*60,e_i*90,e_i*100]
opt = SGDwithLR(lr=lr_dict, momentum = mom_dict, decay=decay_dict, clips=clip_dict,
decay_epochs=decay_epochs,clipvalue=0.01)
e_i = x_train.shape[0] // batch_size
#decay_epochs =np.array([e_i*10], dtype='int64') #for 20 epochs
#decay_epochs =np.array([e_i*10,e_i*80,e_i*120,e_i*160], dtype='int64')
#opt = SGDwithLR(lr_dict, mom_dict,decay_dict,clip_dict, decay_epochs)#, decay=None)
#opt= Adadelta()
#lr_scheduler = LearningRateScheduler(lr_schedule,lr)
# Prepare model model saving directory.
save_dir = os.path.join(os.getcwd(), 'saved_models')
if test_acnn:
model_name = '%s_acnn%dx_model.{epoch:03d}.h5'% (dset, fw)
else:
model_name = '%s_cnn%dx_model.{epoch:03d}.h5'% (dset, fw)
if not os.path.isdir(save_dir):
os.makedirs(save_dir)
filepath = os.path.join(save_dir, model_name)
print("Saving in ", filepath)
# # Prepare callbacks for model saving and for learning rate adjustment.
# checkpoint = ModelCheckpoint(filepath=filepath,
# monitor='val_acc',
# verbose=1,
# save_best_only=True)
chkpt= keras.callbacks.ModelCheckpoint('best-model.h5',
monitor='val_acc',
verbose=1,
save_best_only=True,
save_weights_only=True,
mode='max', period=1)
tb = TensorBoard(log_dir='./tb_logs/mnist/acnn-res-lr5',
histogram_freq = 1,
write_grads=True,
write_graph=False)
stat_func_name = ['max: ', 'mean: ', 'min: ', 'var: ', 'std: ']
stat_func_list = [np.max, np.mean, np.min, np.var, np.std]
callbacks = [tb]
callbacks = []
if test_acnn:
pr_1 = PrintLayerVariableStats("acnn-1","Weights:0",stat_func_list,stat_func_name)
pr_2 = PrintLayerVariableStats("acnn-1","Sigma:0",stat_func_list,stat_func_name)
rv_weights_1 = RecordVariable("acnn-1","Weights:0")
rv_sigma_1 = RecordVariable("acnn-1","Sigma:0")
callbacks+=[pr_1,pr_2,rv_weights_1,rv_sigma_1]
else:
pr_1 = PrintLayerVariableStats("conv2d_3","kernel:0",stat_func_list,stat_func_name)
rv_weights_1 = RecordVariable("conv2d_3","kernel:0")
callbacks+=[pr_1, rv_weights_1]
pr_3 = PrintLayerVariableStats("conv2d_1","kernel:0",stat_func_list,stat_func_name)
rv_kernel = RecordVariable("conv2d_1","kernel:0")
callbacks+=[pr_3,rv_kernel]
print("CALLBACKS:",callbacks)
print("TRAINABLE WEIGHTS:",model.trainable_weights)
print("WARNING by BTEK: if you see An operation has `None` for gradient. \
Please make sure that all of your ops have a gradient defined \
(i.e. are differentiable). Common ops without gradient: \
K.argmax, K.round, K.eval. REMOVE TENSORBOARD CALLBACK OR EDIT IT!")
#print(opt)
#opt = SGD(lr=0.01,momentum=0.9)
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=opt,
metrics=['accuracy'])
plt = False
if plt and test_acnn:
print("Plotting kernels before...")
import matplotlib.pyplot as plt
acnn_layer = model.get_layer('acnn-1')
ws = acnn_layer.get_weights()
print("Sigmas before",ws[0])
u_func = K.function(inputs=[model.input], outputs=[acnn_layer.U()])
output_func = K.function(inputs=[model.input], outputs=[acnn_layer.output])
U_val=u_func([np.expand_dims(x_test[0], axis=0)])
print("U shape", U_val[0].shape)
print("U max:", np.max(U_val[0][:,:,:,:]))
num_filt=min(U_val[0].shape[3],12)
fig=plt.figure(figsize=(20,8))
for i in range(num_filt):
ax1=plt.subplot(1, num_filt, i+1)
im = ax1.imshow(np.squeeze(U_val[0][:,:,0,i]))
fig.colorbar(im, ax=ax1)
plt.show(block=False)
fig=plt.figure(figsize=(20,8))
num_show = min(U_val[0].shape[3],12)
indices = np.int32(np.linspace(0,U_val[0].shape[3]-1,num_show))
for i in range(num_show):
ax1=plt.subplot(1, num_filt, i+1)
#print("U -shape: ", acnn_layer.U().shape,type(K.eval(acnn_layer.U()[:,:,0,i])))
#print("Prod-shape", (ws[1][:,:,0,i]*acnn_layer.U()[:,:,0,i]).shape)
plt.imshow(np.float32(ws[1][:,:,0,indices[i]]*
K.eval(acnn_layer.U()[:,:,0,indices[i]])))
plt.show(block=False)
# Run training, with or without data augmentation.
if not data_augmentation:
print('Not using data augmentation.')
model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test),
shuffle=True,
callbacks=callbacks,verbose=2)
else:
print('Using real-time data augmentation.')
# This will do preprocessing and realtime data augmentation:
datagen = ImageDataGenerator(
# set input mean to 0 over the dataset
featurewise_center=False,
# set each sample mean to 0
samplewise_center=False,
# divide inputs by std of dataset
featurewise_std_normalization=False,
# divide each input by its std
samplewise_std_normalization=False,
# apply ZCA whitening
zca_whitening=False,
# epsilon for ZCA whitening
zca_epsilon=1e-06,
# randomly rotate images in the range (deg 0 to 180)
rotation_range=0,
# randomly shift images horizontally
width_shift_range=0.1,
# randomly shift images vertically
height_shift_range=0.1,
# set range for random shear
shear_range=0.,
# set range for random zoom
zoom_range=0.,
# set range for random channel shifts
channel_shift_range=0.,
# set mode for filling points outside the input boundaries
fill_mode='nearest',
# value used for fill_mode = "constant"
cval=0.,
# randomly flip images
horizontal_flip=True,
# randomly flip images
vertical_flip=False,
# set rescaling factor (applied before any other transformation)
rescale=None,
# set function that will be applied on each input
preprocessing_function=None,
# image data format, either "channels_first" or "channels_last"
data_format='channels_last',
# fraction of images reserved for validation (strictly between 0 and 1)
validation_split=0.0)
# Compute quantities required for featurewise normalization
# (std, mean, and principal components if ZCA whitening is applied).
datagen.fit(x_train)
# Fit the model on the batches generated by datagen.flow().
model.fit_generator(datagen.flow(x_train, y_train, batch_size=batch_size),
validation_data=(x_test, y_test),
epochs=epochs, verbose=2, workers=4,
callbacks=callbacks,
steps_per_epoch=x_train.shape[0]//batch_size)
score = model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
if plt and test_acnn:
print("Plotting kernels after ...")
print("U max:", np.max(U_val[0][:,:,:,:]))
import matplotlib.pyplot as plt
ws = acnn_layer.get_weights()
print("Sigmas after",ws[0])
U_val=u_func([np.expand_dims(x_test[2], axis=0)])
print("U shape", U_val[0].shape)
num_filt=min(U_val[0].shape[3],12)
indices = np.int32(np.linspace(0,U_val[0].shape[3]-1,num_filt))
fig=plt.figure(figsize=(16,5))
for i in range(num_filt):
ax=plt.subplot(1, num_filt, i+1)
kernel_u = U_val[0][:,:,0,indices[i]]
im = ax.imshow(np.squeeze(kernel_u))
print("kernel mean,var,max,min",np.mean(kernel_u),
np.var(kernel_u),
np.max(kernel_u), np.min(kernel_u))
#fig.colorbar(im, ax=ax1)
plt.show(block=False)
print("outputs ...")
n=5
out_val=output_func([np.expand_dims(x_test[5], axis=0)])
print("Outputs shape", out_val[0].shape)
num_filt=min(out_val[0].shape[3],12)
indices = np.int32(np.linspace(0,out_val[0].shape[3]-1,num_filt))
fig=plt.figure(figsize=(20,8))
ax=plt.subplot(1, num_filt+1, 1)
im = ax.imshow(np.squeeze(x_test[5]))
print(y_test[5])
print("input mean,var,max",np.mean(x_test[n]),np.var(x_test[n]),np.max(x_test[n]))
for i in range(num_filt):
ax=plt.subplot(1, num_filt+1, i+2)
out_im = out_val[0][0,:,:,indices[i]]
im = ax.imshow(np.squeeze(out_im))
print("ouput mean,var,max",np.mean(out_im),
np.var(out_im),
np.max(out_im),np.min(out_im))
#plt.colorbar(im,ax=ax)
plt.show(block=False)
print("Weights")
fig=plt.figure(figsize=(20,8))
num_show = min(U_val[0].shape[3],12)
indices = np.int32(np.linspace(0,U_val[0].shape[3]-1,num_show))
for i in range(num_show):
ax1=plt.subplot(1, num_filt, i+1)
#print("U -shape: ", acnn_layer.U().shape,type(K.eval(acnn_layer.U()[:,:,0,i])))
#print("Prod-shape", (ws[1][:,:,0,i]*acnn_layer.U()[:,:,0,i]).shape)
plt.imshow(np.float32(ws[1][:,:,0,indices[i]]),cmap='gray')
plt.show(block=False)
print("ACNN Filters after")
fig=plt.figure(figsize=(20,8))
num_show = min(U_val[0].shape[3],12)
indices = np.int32(np.linspace(0,U_val[0].shape[3]-1,num_show))
for i in range(num_show):
ax1=plt.subplot(1, num_filt, i+1)
#print("U -shape: ", acnn_layer.U().shape,type(K.eval(acnn_layer.U()[:,:,0,i])))
#print("Prod-shape", (ws[1][:,:,0,i]*acnn_layer.U()[:,:,0,i]).shape)
plt.imshow(np.float32(ws[1][:,:,0,indices[i]]*
K.eval(acnn_layer.U()[:,:,0,indices[i]])),cmap='gray')
plt.show(block=False)
cnn_layer = model.get_layer('conv2d_1')
wcnn = cnn_layer.get_weights()
print("CNN Filters of", cnn_layer)
fig=plt.figure(figsize=(20,8))
num_show = min(wcnn[0].shape[3],12)
indices = np.int32(np.linspace(0,wcnn[0].shape[3]-1,num_show))
for i in range(num_show):
ax1=plt.subplot(1, num_filt, i+1)
#print("U -shape: ", acnn_layer.U().shape,type(K.eval(acnn_layer.U()[:,:,0,i])))
#print("Prod-shape", (ws[1][:,:,0,i]*acnn_layer.U()[:,:,0,i]).shape)
plt.imshow(np.float32(wcnn[0][:,:,0,indices[i]]),cmap='gray')
plt.show(block=False)
rv_sigma_arr = np.array(rv_sigma_1.record)
fig=plt.figure(figsize=(4,8))
plt.plot(rv_sigma_arr)
plt.title('Sigma')
plt.show(block=False)
rv_weights_arr = np.array(rv_weights_1.record)
rv_weights_arr2d = np.reshape(rv_weights_arr,
(rv_weights_arr.shape[0],
np.prod(rv_weights_arr.shape[1:])))
print(rv_weights_arr.shape)
fig=plt.figure(figsize=(4,8))
klist=[1,1,5,9,12,15,18,25,32,132,1132]
for i in klist:
plt.plot(rv_weights_arr2d[:,i])
plt.title('weights-acnn')
plt.show(block=False)
rv_kernel_arr = np.array(rv_kernel.record)
rv_kernel_arr2d = np.reshape(rv_kernel_arr,
(rv_kernel_arr.shape[0],
np.prod(rv_kernel_arr.shape[1:])))
print(rv_kernel_arr.shape)
fig=plt.figure(figsize=(4,8))
klist=[1,1,5,9,12,15,18,25,32]
for i in klist:
plt.plot(rv_kernel_arr2d[:,i])
plt.title('weights-conv2d-1')
plt.show(block=False)
# xtas, ytas = [], []
# for i in range(X_train.shape[0]):
# num_aug = 0
# x = X_train[i] # (32, 32, )
# x = x.reshape((1, ) + x.shape) # (1, 32, 32, 3)
# for x_aug in datagen.flow(x, batch_size=1,
# save_to_dir='preview',
# save_prefix='cifar',
# save_format='jpeg'):
# if num_aug >= NUM_TO_AUGMENT:
# break
# xtas.append(x_aug[0])
# num_aug += 1
# fit the dataset
datagen.fit(X_train)
# train
model = keras.models.Sequential([
keras.layers.Conv2D(32, (3, 3), padding='SAME',
activation='relu',
input_shape=(IMG_ROWS, IMG_COLS, IMG_CHANNELS)),
keras.layers.Conv2D(32, (3, 3), padding='SAME',
activation='relu'),
keras.layers.MaxPool2D(pool_size=(2, 2)),
keras.layers.Dropout(0.25),
keras.layers.Conv2D(64, (3, 3), padding='SAME',
activation='relu'),
keras.layers.Conv2D(64, 3, 3, activation='relu'),
keras.layers.MaxPool2D(pool_size=(2, 2)),
from keras_preprocessing.image import ImageDataGenerator, img_to_array, load_img
import os
datagen = ImageDataGenerator(rotation_range=20,
width_shift_range=0.15,
height_shift_range=0.15,
zoom_range=0.15,
shear_range=0.2,
horizontal_flip=False,
fill_mode='nearest')
dirs = os.listdir("picture")
print("文件总数%d" % len(dirs))
for filename in dirs:
img = load_img("picture//{}".format(filename))
x = img_to_array(img)
x = x.reshape((1, ) + x.shape)
datagen.fit(x)
prefix = filename.split('.')[0]
print(prefix)
counter = 0
for batch in datagen.flow(x,
batch_size=4,
save_to_dir="augmentation_pic",
save_prefix=prefix,
save_format='jpg'):
print("生成图片增强%s第%d张" % (filename, counter))
counter += 1
if counter > 400:
break
def augm_gen(data):
datagen = ImageDataGenerator(rotation_range=5, horizontal_flip=True, vertical_flip=True, zoom_range=0.1)
datagen.fit(data)
return datagen
x_test,y_test=generateds(kinds, test_path)
x_train=tf.convert_to_tensor(x_train)
x_test=tf.convert_to_tensor(x_test)
y_train = tf.convert_to_tensor(y_train)
y_test = tf.convert_to_tensor(y_test)
#数据增强
image_gen_train = ImageDataGenerator(
rescale=1./255,#归至0～1
rotation_range=45,#随机45度旋转
width_shift_range=.15,#宽度偏移
height_shift_range=.15,#高度偏移
horizontal_flip=True,#水平翻转
zoom_range=0.5#将图像随机缩放到50％
)
image_gen_train.fit(x_train)
model = tf.keras.models.Sequential([
tf.keras.layers.Conv2D(input_shape=(32, 32, 3),filters=32,kernel_size=(5, 5),padding='same'), # 卷积层
tf.keras.layers.BatchNormalization(), # BN层
tf.keras.layers.Activation('relu'), # 激活层
tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=2, padding='same'), # 池化层
tf.keras.layers.Dropout(0.2), # dropout层
tf.keras.layers.Conv2D(64, kernel_size=(5,5), padding='same'),
tf.keras.layers.BatchNormalization(),
tf.keras.layers.Activation('relu'),
tf.keras.layers.MaxPool2D(pool_size=(2,2), strides=2, padding='same'),
tf.keras.layers.Dropout(0.2),
x_test = x_test.reshape(x_test.shape[0], x_test.shape[1], x_test.shape[2], 1)
x_validation = x_validation.reshape(x_validation.shape[0],
x_validation.shape[1],
x_validation.shape[2], 1)
print(x_train.shape)
#Argumenting the images like zooming,rotating, etc to make the dataset more generic
dataGen = ImageDataGenerator(width_shift_range=0.1,
height_shift_range=0.1,
zoom_range=0.2,
shear_range=0.1,
rotation_range=10)
#help our generator perform some statistics before calculation
dataGen.fit(x_train)
#One Hot encoding our data
y_train = to_categorical(y_train, noOfClasses)
y_test = to_categorical(y_test, noOfClasses)
y_validation = to_categorical(y_validation, noOfClasses)
#Creating our model
#### CREATING THE MODEL
def myModel():
noOfFilters = 60
sizeOfFilter1 = (5, 5)
sizeOfFilter2 = (3, 3)
sizeOfPool = (2, 2)
noOfNodes = 500
def runCNNconfusion(a, b, c, d, e, f, g, h):
# In -> [[Conv2D->relu]*2 -> MaxPool2D -> Dropout]*2 -> Flatten -> Dense -> Dropout -> Out
batch_size = 128
num_classes = f
epochs = g
#img_rows, img_cols = X_train.shape[1],b.shape[2]
input_shape = (128, 128, 3)
model = Sequential()
model.add(
Conv2D(filters=32,
kernel_size=(3, 3),
padding='Same',
activation='relu',
input_shape=input_shape,
strides=h))
model.add(
Conv2D(filters=32,
kernel_size=(3, 3),
padding='Same',
activation='relu'))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(BatchNormalization())
model.add(Dropout(0.25))
model.add(
Conv2D(filters=128,
kernel_size=(3, 3),
padding='Same',
activation='relu'))
model.add(
Conv2D(filters=128,
kernel_size=(3, 3),
padding='Same',
activation='relu'))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(BatchNormalization())
model.add(Dropout(0.25))
model.add(
Conv2D(filters=86,
kernel_size=(3, 3),
padding='Same',
activation='relu'))
model.add(
Conv2D(filters=86,
kernel_size=(3, 3),
padding='Same',
activation='relu'))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(BatchNormalization())
model.add(Dropout(0.25))
model.add(Flatten())
#model.add(Dense(1024, activation = "relu"))
#model.add(Dropout(0.5))
model.add(Dense(512, activation="relu"))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation="softmax"))
# Define the optimizer
optimizer = Adagrad()
model.compile(optimizer=optimizer,
loss="categorical_crossentropy",
metrics=["accuracy"])
datagen = ImageDataGenerator(
featurewise_center=False, # set input mean to 0 over the dataset
samplewise_center=True, # set each sample mean to 0
featurewise_std_normalization=
False, # divide inputs by std of the dataset
samplewise_std_normalization=False, # divide each input by its std
zca_whitening=False, # apply ZCA whitening
rotation_range=
40, # randomly rotate images in the range (degrees, 0 to 180)
width_shift_range=
0.4, # randomly shift images horizontally (fraction of total width)
height_shift_range=
0.4, # randomly shift images vertically (fraction of total height)
horizontal_flip=True, # randomly flip images
vertical_flip=False) # randomly flip images
datagen.fit(a)
history = model.fit_generator(datagen.flow(a, b, batch_size=32),
steps_per_epoch=len(a) / 32,
epochs=epochs,
class_weight=e,
validation_data=[c, d],
callbacks=[MetricsCheckpoint('logs')])
score = model.evaluate(c, d, verbose=0)
plot_learning_curve(history)
plt.show()
plotKerasLearningCurve()
plt.show()
print('\nKeras CNN #2B - accuracy:', score[1], '\n')
Y_pred = model.predict(c)
print('\n',
sklearn.metrics.classification_report(np.where(d > 0)[1],
np.argmax(Y_pred, axis=1),
target_names=list(
dict_characters.values())),
sep='')
Y_pred_classes = np.argmax(Y_pred, axis=1)
Y_true = np.argmax(d, axis=1)
confusion_mtx = confusion_matrix(Y_true, Y_pred_classes)
plot_confusion_matrix(confusion_mtx,
classes=list(dict_characters.values()))
plt.show()
from keras.optimizers import Adam
adam = Adam(lr=0.0001)
model.compile(optimizer=adam, loss='categorical_crossentropy', metrics=['accuracy'])
train_datagen = ImageDataGenerator(
rotation_range=40,
shear_range=0.2,
zoom_range=0.2,
width_shift_range=0.2,
height_shift_range=0.2,
horizontal_flip=True,
fill_mode='nearest')
train_datagen.fit(train_image)
train_generator = train_datagen.flow(
train_image,
train_label,
batch_size=16)
test_datagen = ImageDataGenerator()
test_datagen.fit(test_image)
validation_generator = test_datagen.flow(
test_image, test_label,
batch_size=16)
model.fit_generator(
x_train = x_train.reshape(x_train.shape[0], 28, 28, 1)
x_test = x_test.reshape(x_test.shape[0], 28, 28, 1)
input_shape = (28, 28, 1)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
image_gen = ImageDataGenerator(
rotation_range=15,
width_shift_range=.25,
height_shift_range=.2,
)
# training the image preprocessing
image_gen.fit(x_train, augment=True)
image_gen.fit(x_test, augment=True)
x_train, x_test = x_train / 255.0, x_test / 255.0
def makeModel():
model = Sequential()
model.add(
Conv2D(64, kernel_size=(3, 3), padding='same',
input_shape=(28, 28, 1)))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64, kernel_size=(3, 3), padding='same'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(256, activation=tf.nn.relu))
# Number of epochs
epoch = 50 # 500 for augmentation
batch_size = 32 #32 used by authors
x_train, y_train, x_val, y_val = L.getArrays()
x_train = numpy.array(x_train)
y_train = numpy.array(y_train)
x_val = numpy.array(x_val)
y_val = numpy.array(y_val)
datagen = ImageDataGenerator(rotation_range=20,
width_shift_range=0.2,
height_shift_range=0.2,
horizontal_flip=True)
datagen.fit(x_train)
validation_generator = ImageDataGenerator(rotation_range=20,
width_shift_range=0.2,
height_shift_range=0.2,
horizontal_flip=True)
validation_generator.fit(x_val)
# To stop if sufficietly trained
es = keras.callbacks.EarlyStopping(monitor='val_loss', mode='min', verbose=1)
mc = keras.callbacks.ModelCheckpoint('best_model' + suffix + '.h5',
monitor='val_loss',
mode='min')
cb = [mc]
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--dir',
default='../data/FIDS30/',
help='Root folder for the (unprocessed) data set.')
parser.add_argument(
'--log_dir',
default=
'C:\\Users\\Patrick\\Documents\\TU\\2019S\\ML\\ML_Exercise3\\ML_Exercise3',
help='Root folder for TensorBoard logging.')
dir = parser.parse_args().dir
log_dir = parser.parse_args().log_dir
os.chdir(dir)
fileNames = glob.glob("*/*.jpg")
targetLabels = []
imageList = []
for fileName in fileNames:
pathSepIndex = fileName.index(os.path.sep)
targetLabels.append(fileName[:pathSepIndex])
# print(np.array(Image.open(fileName)).shape)
image = cv2.resize(np.array(Image.open(fileName)), image_size)
imageList.append(np.array(image))
toDelete = np.where(np.array([x.shape for x in imageList]) == 4)[0][0]
del imageList[toDelete]
imageArr = np.array(imageList)
#imageArr = imageArr / 255.0
le = preprocessing.LabelEncoder()
le.fit(targetLabels)
target = le.transform(targetLabels)
target = np.delete(target, toDelete, 0)
target_C = to_categorical(target)
# imageArr = np.array(imageList)
X_train, X_test, y_train, y_test = train_test_split(imageArr,
target_C,
random_state=42)
datagen_train = ImageDataGenerator(
rescale=1. / 255,
featurewise_center=True,
featurewise_std_normalization=True,
rotation_range=10,
#width_shift_range=0.1,
#height_shift_range=0.1,
#shear_range=0.1,
#zoom_range=0.1,
horizontal_flip=True,
#vertical_flip=True
)
datagen_train.fit(X_train)
generator_train = datagen_train.flow(X_train,
y_train,
batch_size=batch_size)
datagen_test = ImageDataGenerator(rescale=1. / 255,
featurewise_center=True,
featurewise_std_normalization=True)
datagen_test.fit(X_train)
generator_test = datagen_test.flow(X_test, y_test, batch_size=batch_size)
# Instantiate an empty model
model = Sequential()
# 1st Convolutional Layer
model.add(
Conv2D(filters=96,
input_shape=(224, 224, 3),
kernel_size=(11, 11),
strides=(4, 4),
padding='valid'))
model.add(Activation('relu'))
# Max Pooling
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))
# 2nd Convolutional Layer
model.add(
Conv2D(filters=256,
kernel_size=(11, 11),
strides=(1, 1),
padding='valid'))
model.add(Activation('relu'))
# Max Pooling
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))
# 3rd Convolutional Layer
model.add(
Conv2D(filters=384,
kernel_size=(3, 3),
strides=(1, 1),
padding='valid'))
model.add(Activation('relu'))
# 4th Convolutional Layer
model.add(
Conv2D(filters=384,
kernel_size=(3, 3),
strides=(1, 1),
padding='valid'))
model.add(Activation('relu'))
# 5th Convolutional Layer
model.add(
Conv2D(filters=256,
kernel_size=(3, 3),
strides=(1, 1),
padding='valid'))
model.add(Activation('relu'))
# Max Pooling
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))
# Passing it to a Fully Connected layer
model.add(Flatten())
# 1st Fully Connected Layer
model.add(Dense(4096, input_shape=(224 * 224 * 3, )))
model.add(Activation('relu'))
# Add Dropout to prevent overfitting
# model.add(Dropout(0.2))
# 2nd Fully Connected Layer
model.add(Dense(4096))
model.add(Activation('relu'))
# Add Dropout
# model.add(Dropout(0.2))
# 3rd Fully Connected Layer
model.add(Dense(1000))
model.add(Activation('relu'))
# Add Dropout
# model.add(Dropout(0.2))
# Output Layer
model.add(Dense(30))
model.add(Activation('softmax'))
model.summary()
# Compile the model
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
now = time.strftime("%b%d_%H-%M")
model.fit_generator(generator_train,
steps_per_epoch=512 // batch_size,
epochs=50,
validation_data=generator_test,
validation_steps=500 // batch_size,
callbacks=[
TensorBoard(histogram_freq=0,
log_dir=os.path.join(
log_dir, 'logs', now + '-' + NAME),
write_graph=True)
])
print("Augmentation process begins ...")
# we create two instances with the same arguments
data_gen_args = dict(featurewise_center=True,
rescale=0.5,
samplewise_center=True,
featurewise_std_normalization=True,
horizontal_flip=True)
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(all_images, augment=True, seed=seed)
# mask_datagen.fit(masks, augment=True, seed=seed)
print("*************")
image_gen = image_datagen.flow(all_images, save_to_dir="C:/Users/nana/PycharmProjects/Lane_detection/data/augmented/")
aug = np.array([next(image_gen).astype(np.uint8) for i in range(1)])
image_generator = image_datagen.flow_from_directory(
"data/input/",
target_size=(960, 540),
class_mode=None,
seed=seed,
save_to_dir="data/augmented/")
