def train_model(dataset, transform_type):
"""
Train specific model on given dataset.
:param dataset:
:param transform_type:
"""
print('Training model ({}) on {}...'.format(transform_type, dataset))
(X_train, Y_train), (X_test, Y_test) = load_data(dataset)
nb_examples, img_rows, img_cols, nb_channels = X_train.shape
nb_classes = Y_train.shape[1]
input_shape = (img_rows, img_cols, nb_channels)
X_train = transform(X_train, transform_type)
model_name = 'model-{}-cnn-{}'.format(dataset, transform_type)
require_preprocess = False
if (dataset == DATA.cifar_10):
require_preprocess = True
# train
model = models.create_model(dataset, input_shape, nb_classes)
models.train(model, X_train, Y_train, model_name, require_preprocess)
# save to disk
models.save_model(model, model_name)
# evaluate the new model
X_test = transform(X_test, transform_type)
loaded_model = models.load_model(model_name)
scores = loaded_model.evaluate(X_test, Y_test, verbose=2)
print('*** Evaluating the new model: {}'.format(scores))
del loaded_model
def train_composition(dataset, transformation_list):
"""
Train a model on dataset on which a sequence of transformations applied
:param dataset: the original dataset
:param transformation_list: the sequence of transformations
:return:
"""
# Apply a sequence of transformations
(X_train, Y_train), (X_test, Y_test) = load_data(dataset)
X_train = transform(X_train, transformation_list)
nb_examples, img_rows, img_cols, nb_channels = X_train.shape
nb_classes = Y_train.shape[1]
input_shape = (img_rows, img_cols, nb_channels)
# Train a model and save
model_name = 'model-{}-cnn-{}'.format(dataset, 'composition')
require_preprocess = (dataset == DATA.cifar_10)
model = models.create_model(dataset, input_shape, nb_classes)
models.train(model, X_train, Y_train, model_name, require_preprocess)
# save to disk
models.save_model(model, model_name)
# evaluate the new model
loaded_model = models.load_model(model_name)
X_test = transform(X_test, transformation_list)
if require_preprocess:
X_test = normalize(X_test)
scores = loaded_model.evaluate(X_test, Y_test, verbose=2)
print('*** Evaluating the new model: {}'.format(scores))
del loaded_model
def reset(X, trans_type):
if trans_type == TRANSFORMATION.rotate90:
X = transform(X, TRANSFORMATION.rotate270)
elif trans_type == TRANSFORMATION.rotate270:
X = transform(X, TRANSFORMATION.rotate90)
elif trans_type == TRANSFORMATION.rotate180:
X = transform(X, TRANSFORMATION.rotate180)
return X
def prediction(data, models, nClasses, transformationList):
'''
input:
data: nSamples X <Sample Dimension>
models: a list of classification models
output:
prediction matrix M - nWeakModels X nSamples X nClasses.
'''
nSamples, nWeakModels = data.shape[0], len(models)
rawPred = np.zeros((nWeakModels, nSamples, nClasses))
transTCs = []
predTCs = []
for mIdx in range(nWeakModels):
testData = data.copy() # some transformation will change the data.
startTime = time.time()
transformationType = transformationList[mIdx]
testData = transform(testData, transformationType)
transTCs.append(time.time() - startTime)
startTime = time.time()
rawPred[mIdx] = models[mIdx].predict(testData)
predTCs.append(time.time() - startTime)
return rawPred, transTCs, predTCs
def prediction(data, models, nClasses, transformationList, batch_size=32, channel_last=True):
'''
input:
data: nSamples X <Sample Dimension>
models: a list of classification models
output:
prediction matrix M - nWeakModels X nSamples X nClasses.
'''
nSamples, nWeakModels = data.shape[0], len(models)
rawPred = np.zeros((nWeakModels, nSamples, nClasses))
transTCs = []
predTCs = []
data = np.float32(data)
for mIdx in range(nWeakModels):
startTime = time.time()
transformationType = transformationList[mIdx]
testData = transform(data, transformationType)
transTCs.append(time.time()-startTime)
if not channel_last:
# input shape of cnn model is <n_samples, n_channels, rows, cols>
testData = data_utils.set_channels_first(testData)
startTime = time.time()
rawPred[mIdx] = models[mIdx].predict(testData, batch_size=batch_size)
predTCs.append(time.time() - startTime)
return rawPred, transTCs, predTCs
def get_aeloaders(dataset,
batch,
dataroot,
ae_file,
trans_type=TRANSFORMATION.clean):
train_sampler, trainloader, validloader, _ = get_dataloaders(
dataset, batch, dataroot, trans_type)
_, test_aug = get_augmentation(dataset)
_, (_, y_test) = load_data(dataset)
x_ae = load_model(ae_file)
x_ae = transform(x_ae, trans_type)
x_ae = data_utils.rescale(x_ae)
x_ae = data_utils.set_channels_first(x_ae)
testset = MyDataset(x_ae, y_test, aug=test_aug)
testloader = torch.utils.data.DataLoader(
testset,
batch_size=batch,
shuffle=False,
num_workers=32,
pin_memory=torch.cuda.is_available(),
drop_last=False)
return train_sampler, trainloader, validloader, testloader
def test_model(model, test_data, transformation_type=TRANSFORMATION.clean):
X, Y = test_data
print('Transforming test data set...')
X = transform(X, transformation_type)
print('Testing model [{}]...'.format(transformation_type))
models.evaluate_model(model, X, Y)
del X, Y
def train_model(data, transformation_type=TRANSFORMATION.clean):
X, Y = data
print('Transforming training data set [{}]...'.format(transformation_type))
X = transform(X, transformation_type)
model_name = 'model-{}-cnn-{}'.format(DATA.CUR_DATASET_NAME,
transformation_type)
model = models.create_model(DATA.CUR_DATASET_NAME)
print('Training model [{}]...'.format(model_name))
model = models.train(model, X, Y, model_name)
print('Saving model...')
models.save_model(model, model_name)
print('Done.')
return model
def eval_single_model(model_name, testset_name, labels_name):
"""
Evaluate model on test set
:param model_name:
:param testset_name:
:return:
"""
prefix, dataset, architect, trans_type = model_name.split('-')
X_test = np.load('{}/{}.npy'.format(PATH.ADVERSARIAL_FILE, testset_name))
labels = np.load('{}/{}.npy'.format(PATH.ADVERSARIAL_FILE, labels_name))
if 'composition' in trans_type:
trans_type = TRANSFORMATION.get_transformation_compositions()
print(type(trans_type), trans_type)
# apply transformation(s)
X_test = transform(X_test, trans_type)
# evaluate each of the composition
if 'composition' in trans_type:
for trans in trans_type:
print(type(trans), trans)
m_name = '{}-{}-{}-{}'.format(prefix, dataset, architect, trans)
model = models.load_model(m_name)
print('*** Evaluating ({}) on ({})...'.format(
m_name, testset_name))
scores = model.evaluate(X_test, labels, verbose=2)
print(scores)
del model
# evaluate the model
model = models.load_model(model_name)
if (dataset == DATA.cifar_10):
X_test = normalize(X_test)
print('*** Evaluating ({}) on ({})...'.format(model_name, testset_name))
scores = model.evaluate(X_test, labels, verbose=2)
print(scores)
return scores
def train_models_with_newLabels(dataset_name,
AE_type_tag,
defense_tag,
transform_type,
num_of_samples,
X,
Y,
validation_rate=0.2,
need_argument=False):
print(
'Training model ({}) on {} {} new labels collected from ensemble ({}) built upon {}...'
.format(transform_type, num_of_samples, dataset_name, defense_tag,
AE_type_tag))
if transform_type != TRANSFORMATION.clean:
# transform images on demand.
X = transform(X, transform_type)
model_name = 'model-{}-cnn-{}-{}-{}-{}'.format(dataset_name,
transform_type, AE_type_tag,
defense_tag, num_of_samples)
models.train_and_save(model_name, X, Y, validation_rate, need_argument)
return model
"""
if __name__ == '__main__':
transformations = TRANSFORMATION.supported_types()
data = {
'dataset': DATA.mnist,
'architecture': 'svm',
}
(X_train, Y_train), (X_test, Y_test) = load_data(data['dataset'])
Y_train = np.argmax(Y_train, axis=1)
Y_test = np.argmax(Y_test, axis=1)
for trans in transformations:
data['trans'] = trans
data['train'] = (transform(X_train, trans), Y_train)
data['test'] = (transform(X_test, trans), Y_test)
model = train(data, training_params=default_train_params)
filename = 'model-{}-{}-{}.pkl'.format(data['dataset'],
data['architecture'],
data['trans'])
filename = os.path.join(PATH.MODEL, filename)
model_utils.save(model, filename)
if __name__ == '__main__':
transformations = TRANSFORMATION.supported_types()
data = {
'dataset': DATA.mnist,
'architecture': 'cnn',
}
(X_train, y_train), (X_test, y_test) = load_data(data['dataset'])
nb_classes = y_train.shape[-1]
X_train = data_utils.set_channels_last(X_train)
X_test = data_utils.set_channels_last(X_test)
y_train = np.argmax(y_train, axis=1)
y_test = np.argmax(y_test, axis=1)
for trans in transformations:
data['trans'] = trans
data['train'] = (data_utils.rescale(transform(X_train,
trans)), y_train)
data['test'] = (data_utils.rescale(transform(X_test, trans)), y_test)
model = train(data, nb_classes=nb_classes, eval=True, conf=train_conf)
filename = 'model-{}-{}-{}.h5'.format(data['dataset'],
data['architecture'],
data['trans'])
filename = os.path.join(PATH.MODEL, filename)
model_utils.save(model, filename)
training_params = {
'model': 'rf',
'dataset': DATA.mnist,
'n_estimators': 100,
'criterion': 'gini',
}
transformations = TRANSFORMATION.supported_types()
# transformations = [TRANSFORMATION.clean]
(X_train, Y_train), (X_test, Y_test) = load_data(DATA.mnist)
print(X_train.shape, Y_train.shape)
print(X_test.shape, Y_test.shape)
MODEL_DIR = os.path.join(PATH.MODEL, 'rf_mnist')
save_path = 'mnist-rf-'
if not os.path.exists(MODEL_DIR):
import pathlib
print(MODEL_DIR, 'does not exist. Create it.')
pathlib.Path(MODEL_DIR).mkdir(parents=True, exist_ok=True)
for trans in transformations:
save_path = 'mnist-rf-' + trans + '.rf'
save_path = os.path.join(MODEL_DIR, save_path)
# apply transformation on data set
X_train_trans = transform(X_train, trans)
X_test_trans = transform(X_test, trans)
train(train_set=(X_train_trans, Y_train), test_set=(X_test_trans, Y_test),
save_path=save_path, **training_params)
def load_data(dataset, trans_type=TRANSFORMATION.clean, trans_set='both'):
assert dataset in DATA.get_supported_datasets()
assert trans_set is None or trans_set in ['none', 'train', 'test', 'both']
X_train = None
Y_train = None
X_test = None
Y_test = None
img_rows = 0
img_cols = 0
nb_channels = 0
nb_classes = 0
if DATA.mnist == dataset:
"""
Dataset of 60,000 28x28 grayscale images of the 10 digits,
along with a test set of 10,000 images.
"""
(X_train, Y_train), (X_test, Y_test) = mnist.load_data()
nb_examples, img_rows, img_cols = X_test.shape
nb_channels = 1
nb_classes = 10
elif DATA.fation_mnist == dataset:
"""
Dataset of 60,000 28x28 grayscale images of 10 fashion categories,
along with a test set of 10,000 images. The class labels are:
Label Description
0 T-shirt/top
1 Trouser
2 Pullover
3 Dress
4 Coat
5 Sandal
6 Shirt
7 Sneaker
8 Bag
9 Ankle boot
"""
(X_train, Y_train), (X_test, Y_test) = fashion_mnist.load_data()
nb_examples, img_rows, img_cols = X_test.shape
nb_channels = 1
nb_classes = 10
elif DATA.cifar_10 == dataset:
"""
Dataset of 50,000 32x32 color training images, labeled over 10 categories, and 10,000 test images.
"""
(X_train, Y_train), (X_test, Y_test) = cifar10.load_data()
nb_examples, img_rows, img_cols, nb_channels = X_test.shape
nb_classes = 10
elif DATA.cifar_100 == dataset:
(X_train, Y_train), (X_test,
Y_test) = cifar100.load_data(label_mode='fine')
nb_examples, img_rows, img_cols, nb_channels = X_test.shape
nb_classes = 100
X_train = X_train.reshape(-1, img_rows, img_cols, nb_channels)
X_test = X_test.reshape(-1, img_rows, img_cols, nb_channels)
"""
cast pixels to floats, normalize to [0, 1] range
"""
X_train = X_train.astype(np.float32)
X_test = X_test.astype(np.float32)
X_train = data_utils.rescale(X_train, range=(0., 1.))
X_test = data_utils.rescale(X_test, range=(0., 1.))
"""
one-hot-encode the labels
"""
Y_train = keras.utils.to_categorical(Y_train, nb_classes)
Y_test = keras.utils.to_categorical(Y_test, nb_classes)
"""
transform images
"""
if trans_set is not None:
if trans_set in ['train', 'both']:
X_train = transform(X_train, trans_type)
X_train = data_utils.rescale(X_train, range=(0., 1.))
X_train = data_utils.set_channels_first(X_train)
if trans_set in ['test', 'both']:
X_test = transform(X_test, trans_type)
X_test = data_utils.rescale(X_test, range=(0., 1.))
X_test = data_utils.set_channels_first(X_test)
"""
summarize data set
"""
print('Dataset({}) Summary:'.format(dataset.upper()))
print('Train set: {}, {}'.format(X_train.shape, Y_train.shape))
print('Test set: {}, {}'.format(X_test.shape, Y_test.shape))
return (X_train, Y_train), (X_test, Y_test)
def craft(dataset,
gen_test=True,
method=ATTACK.FGSM,
trans_type=TRANSFORMATION.clean):
print('loading original images...')
if gen_test:
# generate for test set
_, (X, Y) = load_data(dataset)
prefix = 'test'
else:
# generate for train set (the last 20% of the original train set)
(X, Y), _ = load_data(dataset)
nb_trainings = int(X.shape[0] * 0.8)
X = X[nb_trainings:]
Y = Y[nb_trainings:]
prefix = 'val'
"""
In debugging mode, crafting for 50 samples.
"""
if MODE.DEBUG:
X = X[:30]
Y = Y[:30]
X = transform(X, trans_type)
model_name = 'model-{}-cnn-{}'.format(dataset, trans_type)
if method == ATTACK.FGSM:
for eps in ATTACK.get_fgsm_eps():
print('{}: (eps={})'.format(method.upper(), eps))
X_adv, _ = get_adversarial_examples(model_name,
method,
X,
Y,
eps=eps)
attack_params = 'eps{}'.format(int(1000 * eps))
reset(X, trans_type)
reset(X_adv, trans_type)
save_adv_examples(X_adv,
prefix=prefix,
dataset=dataset,
transformation=trans_type,
attack_method=method,
attack_params=attack_params)
elif method == ATTACK.BIM:
for ord in ATTACK.get_bim_norm():
for nb_iter in ATTACK.get_bim_nbIter():
for eps in ATTACK.get_bim_eps(ord):
print('{}: (ord={}, nb_iter={}, eps={})'.format(
method.upper(), ord, nb_iter, eps))
X_adv, _ = get_adversarial_examples(model_name,
method,
X,
Y,
ord=ord,
nb_iter=nb_iter,
eps=eps)
if ord == np.inf:
norm = 'inf'
else:
norm = ord
attack_params = 'ord{}_nbIter{}_eps{}'.format(
norm, nb_iter, int(1000 * eps))
reset(X, trans_type)
reset(X_adv, trans_type)
save_adv_examples(X_adv,
prefix=prefix,
dataset=dataset,
transformation=trans_type,
attack_method=method,
attack_params=attack_params)
elif method == ATTACK.DEEPFOOL:
for order in [2]:
for overshoot in ATTACK.get_df_overshoots(order):
print('attack {} -- order: {}; overshoot: {}'.format(
method.upper(), order, overshoot))
X_adv, _ = get_adversarial_examples(model_name,
method,
X,
Y,
ord=order,
overshoot=overshoot)
attack_params = 'l{}_overshoot{}'.format(order, int(overshoot))
reset(X, trans_type)
reset(X_adv, trans_type)
save_adv_examples(X_adv,
prefix=prefix,
bs_samples=X,
dataset=dataset,
transformation=trans_type,
attack_method=method,
attack_params=attack_params)
elif method == ATTACK.CW_L2:
binary_search_steps = 16 #9
cw_batch_size = 2 #1
initial_const = 1 #10
for learning_rate in ATTACK.get_cwl2_lr():
for max_iter in ATTACK.get_cwl2_maxIter():
print('{}: (ord={}, max_iterations={})'.format(
method.upper(), 2, max_iter))
X_adv, _ = get_adversarial_examples(
model_name,
method,
X,
Y,
ord=2,
max_iterations=max_iter,
binary_search_steps=binary_search_steps,
cw_batch_size=cw_batch_size,
initial_const=initial_const,
learning_rate=learning_rate)
attack_params = 'lr{}_maxIter{}'.format(
int(learning_rate * 1000), max_iter)
reset(X, trans_type)
reset(X_adv, trans_type)
save_adv_examples(X_adv,
prefix=prefix,
bs_samples=X,
dataset=dataset,
transformation=trans_type,
attack_method=method,
attack_params=attack_params)
elif method == ATTACK.CW_Linf:
initial_const = 1e-5
# X *= 255.
for learning_rate in ATTACK.get_cwl2_lr():
for max_iter in ATTACK.get_cwl2_maxIter():
print('{}: (ord={}, max_iterations={})'.format(
method.upper(), np.inf, max_iter))
X_adv, _ = get_adversarial_examples(
model_name,
method,
X,
Y,
max_iterations=max_iter,
initial_const=initial_const,
learning_rate=learning_rate)
attack_params = 'lr{}_maxIter{}'.format(
int(learning_rate * 10), max_iter)
reset(X, trans_type)
reset(X_adv, trans_type)
save_adv_examples(X_adv,
prefix=prefix,
bs_samples=X,
dataset=dataset,
transformation=trans_type,
attack_method=method,
attack_params=attack_params)
elif method == ATTACK.CW_L0:
initial_const = 1e-5
for learning_rate in ATTACK.get_cwl2_lr():
for max_iter in ATTACK.get_cwl2_maxIter():
print('{}: (ord={}, max_iterations={})'.format(
method.upper(), np.inf, max_iter))
X_adv, _ = get_adversarial_examples(
model_name,
method,
X,
Y,
max_iterations=max_iter,
initial_const=initial_const,
learning_rate=learning_rate)
attack_params = 'lr{}_maxIter{}'.format(
int(learning_rate * 10), max_iter)
reset(X, trans_type)
reset(X_adv, trans_type)
save_adv_examples(X_adv,
prefix=prefix,
bs_samples=X,
dataset=dataset,
transformation=trans_type,
attack_method=method,
attack_params=attack_params)
elif method == ATTACK.JSMA:
for theta in ATTACK.get_jsma_theta():
for gamma in ATTACK.get_jsma_gamma():
print('{}: (theta={}, gamma={})'.format(
method.upper(), theta, gamma))
X_adv, _ = get_adversarial_examples(model_name,
method,
X,
Y,
theta=theta,
gamma=gamma)
attack_params = 'theta{}_gamma{}'.format(
int(100 * theta), int(100 * gamma))
reset(X, trans_type)
reset(X_adv, trans_type)
save_adv_examples(X_adv,
prefix=prefix,
bs_samples=X,
dataset=dataset,
transformation=trans_type,
attack_method=method,
attack_params=attack_params)
elif method == ATTACK.PGD:
nb_iter = 1000
eps_iter = 0.05 #0.01
for eps in ATTACK.get_pgd_eps():
if eps < 0.05:
eps_iter = 0.01
elif eps <= 0.01:
eps_iter = 0.005
X_adv, _ = get_adversarial_examples(model_name,
method,
X,
Y,
eps=eps,
nb_iter=nb_iter,
eps_iter=eps_iter)
attack_params = 'eps{}_nbIter{}_epsIter{}'.format(
int(1000 * eps), nb_iter, int(1000 * eps_iter))
reset(X, trans_type)
reset(X_adv, trans_type)
save_adv_examples(X_adv,
prefix=prefix,
bs_samples=X,
dataset=dataset,
transformation=trans_type,
attack_method=method,
attack_params=attack_params)
elif method == ATTACK.ONE_PIXEL:
for pixel_counts in ATTACK.get_op_pxCnt():
for max_iter in ATTACK.get_op_maxIter():
for pop_size in ATTACK.get_op_popsize():
attack_params = {
'pixel_counts': pixel_counts,
'max_iter': max_iter,
'pop_size': pop_size
}
X_adv, _ = get_adversarial_examples(
model_name, method, X, Y, **attack_params)
X_adv = np.asarray(X_adv)
attack_params = 'pxCount{}_maxIter{}_popsize{}'.format(
pixel_counts, max_iter, pop_size)
reset(X, trans_type)
reset(X_adv, trans_type)
save_adv_examples(X_adv,
prefix=prefix,
bs_samples=X,
dataset=dataset,
transformation=trans_type,
attack_method=method,
attack_params=attack_params)
elif method == ATTACK.MIM:
for eps in ATTACK.get_mim_eps():
for nb_iter in ATTACK.get_mim_nbIter():
attack_params = {'eps': eps, 'nb_iter': nb_iter}
X_adv, _ = get_adversarial_examples(model_name, method, X, Y,
**attack_params)
attack_params = 'eps{}_nbIter{}'.format(
int(eps * 100), nb_iter)
reset(X, trans_type)
reset(X_adv, trans_type)
save_adv_examples(X_adv,
prefix=prefix,
bs_samples=X,
dataset=dataset,
transformation=trans_type,
attack_method=method,
attack_params=attack_params)
del X
del Y
def generate_single(sess,
x,
y,
attacker=ATTACK.FGSM,
candidates=None,
attack_count=None,
max_perturb=get_perturb_upperbound(),
strategy=ATTACK_STRATEGY.RANDOM.value):
# candidate_names = candidates.copy()
candidate_names = copy.deepcopy(list(candidates.keys()))
fooled = []
attack_params = get_attack_params(attacker)
x_adv = x
perturbed_norm = measure.frobenius_norm(x_adv, x)
max_iteration = len(candidate_names)
iter = 0
while ((len(fooled) < attack_count) and (iter < max_iteration)):
# generate adversarial example for target model
print('ITERATION {}: candidates/fooled ::: {}/{}'.format(
iter, len(candidate_names), len(fooled)))
iter += 1
target_name = pick_target_model(candidate_names, strategy)
transformation = target_name.split('.')[0].split('-')[-1]
x_trans = transform(x_adv, transformation)
if len(x_trans.shape) < 4:
print('x_trans shape:', x_trans.shape)
x_trans = np.expand_dims(x_trans, axis=0)
x_tmp = attack_single(sess, candidates[target_name], attacker, x_trans,
y, **attack_params)
perturbed_norm = measure.frobenius_norm(x_tmp,
transform(x, transformation))
if perturbed_norm >= max_perturb:
# keep the last x_adv if current one is out of the boundary
print('out of perturbed boundary, stop.')
break
x_adv = reset(x_tmp, transformation)
if MODE.DEBUG:
plot_image(x_adv[0], transformation)
del x_trans
# filter out candidates that are fooled by x_adv
true_label = np.argmax(y)
for cand_name in candidate_names:
transformation = cand_name.split('.')[0].split('-')[-1]
# apply transformation
x_trans = transform(x_adv, transformation)
pred_label = np.argmax(candidates[cand_name].predict(x_trans))
if MODE.DEBUG:
print('prediction: [{}/{}/{}]'.format(transformation,
true_label, pred_label))
if (true_label != pred_label):
# remove candidate being fooled by x_adv
candidate_names.remove(cand_name)
# record only the name of the weak defense
print('+++ fooled [{}]'.format(cand_name))
fooled.append(cand_name)
# release
del x_trans
# use current adversarial example as the input of next iteration
print('')
del target_name
return x_adv[0]
def train(dataset,
model=None,
trans_type=TRANSFORMATION.clean,
save_path='cnn_mnist.h5',
eval=True,
**kwargs):
"""
Train a cnn model on MNIST or Fashion-MNIST.
:param dataset:
:param model: a model to train.
:param trans_type: transformation associated to the model.
:param save_path: file name, including the path, to save the trained model.
:param kwargs: customized loss function, optimizer, etc. for cleverhans to craft AEs.
:return: the trained model
"""
lr = 0.001
validation_rate = 0.2
optimizer = kwargs.get('optimizer', keras.optimizers.Adam(lr=lr))
loss_fn = kwargs.get('loss', keras.losses.categorical_crossentropy)
metrics = kwargs.get('metrics', 'default')
logger.info('optimizer: [{}].'.format(optimizer))
logger.info('loss function: [{}].'.format(loss_fn))
logger.info('metrics: [{}].'.format(metrics))
(X_train, Y_train), (X_test, Y_test) = data.load_data(dataset)
X_train = data_utils.set_channels_last(X_train)
X_test = data_utils.set_channels_last(X_test)
# Apply transformation (associated to the weak defending model)
X_train = data_utils.rescale(transform(X_train, trans_type))
X_test = data_utils.rescale(transform(X_test, trans_type))
nb_examples, img_rows, img_cols, nb_channels = X_train.shape
nb_train_samples = int(nb_examples * (1. - validation_rate))
train_examples = X_train[:nb_train_samples]
train_labels = Y_train[:nb_train_samples]
val_examples = X_train[nb_train_samples:]
val_labels = Y_train[nb_train_samples:]
if model is None:
model = create_model(input_shape=(img_rows, img_cols, nb_channels))
# Compile model
if ('default' == metrics):
model.compile(optimizer=optimizer, loss=loss_fn, metrics=['accuracy'])
else:
model.compile(optimizer=optimizer,
loss=loss_fn,
metrics=['accuracy', metrics])
# Train model
batch_size = kwargs.get('batch_size', 128)
epochs = kwargs.get('epochs', 20)
start = time.monotonic()
history = model.fit(train_examples,
train_labels,
batch_size=batch_size,
epochs=epochs,
verbose=2,
validation_data=(val_examples, val_labels))
cost = time.monotonic() - start
logger.info('Done training. It costs {} minutes.'.format(cost / 60.))
if eval:
scores_train = model.evaluate(train_examples,
train_labels,
batch_size=128,
verbose=0)
scores_val = model.evaluate(val_examples,
val_labels,
batch_size=128,
verbose=0)
scores_test = model.evaluate(X_test, Y_test, batch_size=128, verbose=0)
logger.info('Evaluation on [{} set]: {}.'.format(
'training', scores_train))
logger.info('Evaluation on [{} set]: {}.'.format(
'validation', scores_val))
logger.info('Evaluation on [{} set]: {}.'.format(
'testing', scores_test))
logger.info('Save the trained model to [{}].'.format(save_path))
model.save(save_path)
checkpoints_file = save_path.split('/')[-1].split('.')[0]
checkpoints_file = 'checkpoints_train_' + checkpoints_file + '.csv'
checkpoints_file = os.path.join(LOG_DIR, checkpoints_file)
if not os.path.dirname(LOG_DIR):
os.mkdir(LOG_DIR)
logger.info('Training checkpoints have been saved to file [{}].'.format(
checkpoints_file))
file.dict2csv(history.history, checkpoints_file)
save_path = save_path.split('/')[-1].split('.')[0]
save_path = 'hist_train_' + save_path + '.pdf'
plot_training_history(history, save_path)
return model
