def get_input_cifar10():
train, test = dataset.Cifar10('train'), dataset.Cifar10('test',
shuffle=False)
def preprocess(x):
image, label = x
onehot = np.zeros(10)
onehot[label] = 1.0
return image, onehot
return MapData(train,
preprocess), MapData(test,
preprocess), ((32, 32, 3), (10, ))
def get_data(train_or_test, isMixup, alpha):
isTrain = train_or_test == 'train'
ds = dataset.Cifar10(train_or_test)
if isTrain:
augmentors = [
imgaug.CenterPaste((40, 40)),
imgaug.RandomCrop((32, 32)),
imgaug.Flip(horiz=True),
]
ds = AugmentImageComponent(ds, augmentors)
batch = BATCH_SIZE
ds = BatchData(ds, batch, remainder=not isTrain)
def f(dp):
images, labels = dp
one_hot_labels = np.eye(CLASS_NUM)[labels] # one hot coding
if not isTrain or not isMixup:
return [images, one_hot_labels]
# mixup implementation:
# Note that for larger images, it's more efficient to do mixup on GPUs (i.e. in the graph)
weight = np.random.beta(alpha, alpha, BATCH_SIZE)
x_weight = weight.reshape(BATCH_SIZE, 1, 1, 1)
y_weight = weight.reshape(BATCH_SIZE, 1)
index = np.random.permutation(BATCH_SIZE)
x1, x2 = images, images[index]
x = x1 * x_weight + x2 * (1 - x_weight)
y1, y2 = one_hot_labels, one_hot_labels[index]
y = y1 * y_weight + y2 * (1 - y_weight)
return [x, y]
ds = MapData(ds, f)
return ds
def get_data(train_or_test, cifar_classnum):
isTrain = train_or_test == 'train'
if cifar_classnum == 10:
ds = dataset.Cifar10(train_or_test)
else:
ds = dataset.Cifar100(train_or_test)
if isTrain:
augmentors = [
imgaug.RandomCrop((30, 30)),
imgaug.Flip(horiz=True),
imgaug.Brightness(63),
imgaug.Contrast((0.2, 1.8)),
imgaug.GaussianDeform([(0.2, 0.2), (0.2, 0.8), (0.8, 0.8),
(0.8, 0.2)], (30, 30), 0.2, 3),
imgaug.MeanVarianceNormalize(all_channel=True)
]
else:
augmentors = [
imgaug.CenterCrop((30, 30)),
imgaug.MeanVarianceNormalize(all_channel=True)
]
ds = AugmentImageComponent(ds, augmentors)
ds = BatchData(ds, 128, remainder=not isTrain)
if isTrain:
ds = PrefetchDataZMQ(ds, 5)
return ds
def get_data(phase):
is_train = phase == "train"
ds = dataset.Cifar10(phase)
pp_mean = ds.get_per_pixel_mean(("train", ))
if is_train:
augmentors = [
imgaug.CenterPaste((40, 40)),
imgaug.RandomCrop((32, 32)),
imgaug.Flip(horiz=True),
imgaug.MapImage(lambda x: x - pp_mean),
]
else:
augmentors = [imgaug.MapImage(lambda x: x - pp_mean)]
ds = AugmentImageComponent(ds, augmentors)
ds = BatchData(ds, BATCH_SIZE, remainder=not is_train)
return ds
def create_dataflow(partition='train'):
ds = dataset.Cifar10(partition)
pp_mean = ds.get_per_pixel_mean()
if partition == 'train':
augmentors = [
imgaug.CenterPaste((40, 40)),
imgaug.RandomCrop((32, 32)),
imgaug.Flip(horiz=True),
imgaug.MapImage(lambda x: x - pp_mean),
]
else:
augmentors = [imgaug.MapImage(lambda x: x - pp_mean)]
ds = AugmentImageComponent(ds, augmentors)
ds = BatchData(ds, batch_size, remainder=(partition != 'train'))
if partition == 'train':
ds = PrefetchData(ds, 3, 2)
return ds
def get_data(train_or_test):
isTrain = train_or_test == 'train'
ds = dataset.Cifar10(train_or_test)
pp_mean = ds.get_per_pixel_mean()
if isTrain:
augmentors = [
imgaug.CenterPaste((40, 40)),
imgaug.RandomCrop((32, 32)),
imgaug.Flip(horiz=True),
imgaug.MapImage(lambda x: x - pp_mean),
]
else:
augmentors = [imgaug.MapImage(lambda x: x - pp_mean)]
ds = AugmentImageComponent(ds, augmentors)
ds = BatchData(ds, BATCH_SIZE, remainder=not isTrain)
if isTrain:
ds = PrefetchData(ds, 3, 2)
return ds
def get_data(train_or_test, isMixup, alpha):
isTrain = train_or_test == 'train'
ds = dataset.Cifar10(train_or_test)
pp_mean = ds.get_per_pixel_mean()
if isTrain:
augmentors = [
imgaug.CenterPaste((40, 40)),
imgaug.RandomCrop((32, 32)),
imgaug.Flip(horiz=True),
imgaug.MapImage(lambda x: x - pp_mean),
]
else:
augmentors = [
imgaug.MapImage(lambda x: x - pp_mean)
]
ds = AugmentImageComponent(ds, augmentors)
if isMixup:
batch = 2 * BATCH_SIZE
else:
batch = BATCH_SIZE
ds = BatchData(ds, batch, remainder=not isTrain)
def f(ds):
images, labels = ds
one_hot_labels = np.eye(CLASS_NUM)[labels] # one hot coding
if not isTrain or not isMixup:
return [images, one_hot_labels]
# mixup:
weight = np.random.beta(alpha, alpha, BATCH_SIZE)
x_weight = weight.reshape(BATCH_SIZE, 1, 1, 1)
y_weight = weight.reshape(BATCH_SIZE, 1)
x1, x2 = np.split(images, 2, axis=0)
x = x1 * x_weight + x2 * (1 - x_weight)
y1, y2 = np.split(one_hot_labels, 2, axis=0)
y = y1 * y_weight + y2 * (1 - y_weight)
return [x, y]
ds = MapData(ds, f)
if isTrain:
ds = PrefetchData(ds, 3, 2)
return ds
def get_cifar_augmented_data(subset,
options,
do_multiprocess=True,
do_validation=False,
shuffle=None):
isTrain = subset == 'train' and do_multiprocess
shuffle = shuffle if shuffle is not None else isTrain
if options.num_classes == 10 and options.ds_name == 'cifar10':
ds = dataset.Cifar10(subset,
shuffle=shuffle,
do_validation=do_validation)
cutout_length = 16
n_holes = 1
elif options.num_classes == 100 and options.ds_name == 'cifar100':
ds = dataset.Cifar100(subset,
shuffle=shuffle,
do_validation=do_validation)
cutout_length = 8
n_holes = 1
else:
raise ValueError(
'Number of classes must be set to 10(default) or 100 for CIFAR')
logger.info('{} set has n_samples: {}'.format(subset, len(ds.data)))
pp_mean = ds.get_per_pixel_mean()
if isTrain:
logger.info('Will do cut-out with length={} n_holes={}'.format(
cutout_length, n_holes))
augmentors = [
imgaug.CenterPaste((40, 40)),
imgaug.RandomCrop((32, 32)),
imgaug.Flip(horiz=True),
imgaug.MapImage(lambda x: (x - pp_mean) / 128.0),
Cutout(length=cutout_length, n_holes=n_holes),
]
else:
augmentors = [imgaug.MapImage(lambda x: (x - pp_mean) / 128.0)]
ds = AugmentImageComponent(ds, augmentors)
ds = BatchData(ds,
options.batch_size // options.nr_gpu,
remainder=not isTrain)
if do_multiprocess:
ds = PrefetchData(ds, 3, 2)
return ds
def get_data_cifar(train_or_test, cifar_classnum, image_shape, batch_size):
from tensorpack.dataflow import dataset
isTrain = train_or_test == 'train'
if cifar_classnum == 10:
ds = dataset.Cifar10(train_or_test)
else:
ds = dataset.Cifar100(train_or_test)
if isTrain:
import numpy as np
import cv2
augmentors = [
GoogleNetResize(target_shape=image_shape),
imgaug.RandomOrderAug([
imgaug.BrightnessScale((0.6, 1.4), clip=False),
imgaug.Contrast((0.6, 1.4), clip=False),
imgaug.Saturation(0.4, rgb=False),
# rgb-bgr conversion for the constants copied from fb.resnet.torch
imgaug.Lighting(
0.1,
eigval=np.asarray([0.2175, 0.0188, 0.0045][::-1]) * 255.0,
eigvec=np.array([[-0.5675, 0.7192, 0.4009],
[-0.5808, -0.0045, -0.8140],
[-0.5836, -0.6948, 0.4203]],
dtype='float32')[::-1, ::-1])
]),
imgaug.Flip(horiz=True),
]
else:
import cv2
re_size = 256
if image_shape == 32:
re_size = 40
augmentors = [
imgaug.ResizeShortestEdge(re_size, cv2.INTER_CUBIC),
imgaug.CenterCrop((image_shape, image_shape)),
]
ds = AugmentImageComponent(ds, augmentors)
ds = BatchData(ds, batch_size, remainder=not isTrain)
if isTrain:
ds = PrefetchDataZMQ(ds, 5)
return ds
def get_data(self, train_or_test):
isTrain = train_or_test == 'train'
ds = dataset.Cifar10(train_or_test, dir='.')
pp_mean = ds.get_per_pixel_mean()
if isTrain:
augmentors = [
imgaug.CenterPaste((40, 40)),
imgaug.RandomCrop((32, 32)),
imgaug.Flip(horiz=True),
# imgaug.Brightness(20),
# imgaug.Contrast((0.6,1.4)),
imgaug.MapImage(lambda x: x - pp_mean),
]
else:
augmentors = [imgaug.MapImage(lambda x: x - pp_mean)]
ds = AugmentImageComponent(ds, augmentors)
ds = BatchData(ds, self.batch_size, remainder=not isTrain)
if isTrain:
ds = PrefetchData(ds, 3, 2)
return ds
def get_data(train_or_test, classnum):
isTrain = train_or_test == 'train'
if classnum == 10:
ds = dataset.Cifar10(train_or_test)
else:
ds = dataset.Cifar100(train_or_test)
# if isTrain:
# augmentors = [
# imgaug.Flip(horiz=True),
# imgaug.Brightness(63),
# imgaug.Contrast((0.2, 1.8)),
# imgaug.MeanVarianceNormalize(all_channel=True)
# ]
# else:
# augmentors = [
# imgaug.MeanVarianceNormalize(all_channel=True)
# ]
# ds = AugmentImageComponent(ds, augmentors)
ds = BatchData(ds, 256, remainder=not isTrain)
return ds
def get_data(train_or_test):
isTrain = train_or_test == 'train'
ds = dataset.Cifar10(train_or_test)
cifar10_mean = np.asarray([0.4914, 0.4822, 0.4465], dtype="float32") * 255.
cifar10_invstd = 1.0 / (
np.asarray([0.2471, 0.2435, 0.2616], dtype="float32") * 255)
if isTrain:
augmentors = imgaug.AugmentorList([
imgaug.RandomCrop((32, 32)),
imgaug.Flip(horiz=True),
imgaug.RandomCutout(8, 8),
])
def mapf(dp):
img, label = dp
img = (img.astype("float32") - cifar10_mean) * cifar10_invstd
if isTrain:
img = np.pad(img, [(4, 4), (4, 4), (0, 0)], mode='reflect')
img = augmentors.augment(img)
onehot = np.zeros((10, ), dtype=np.float32) + 0.2 / 9
onehot[label] = 0.8
else:
onehot = np.zeros((10, ), dtype=np.float32)
onehot[label] = 1.
if DATA_FORMAT == "NCHW":
img = img.transpose(2, 0, 1)
return img, onehot
if not isTrain:
ds = MapData(ds, mapf)
ds = BatchData(ds, BATCH, remainder=False)
return ds
ds = MultiProcessMapAndBatchDataZMQ(ds, 8, mapf, BATCH, buffer_size=20000)
ds = RepeatedData(ds, -1)
return ds
def get_data(train_or_test):
isTrain = train_or_test == 'train'
ds = dataset.Cifar10(train_or_test)
if isTrain:
augmentors = [
imgaug.CenterPaste((40, 40)),
imgaug.RandomCrop((32, 32)),
imgaug.Flip(horiz=True),
]
ds = AugmentImageComponent(ds, augmentors)
batch = BATCH_SIZE
ds = BatchData(ds, batch, remainder=not isTrain)
def f(dp):
images, labels = dp
one_hot_labels = np.eye(CLASS_NUM)[labels] # one hot coding
return [images, one_hot_labels]
ds = MapData(ds, f)
return ds
def get_data(train_or_test, args):
isTrain = train_or_test == 'train'
if args.classnum == 10:
ds = dataset.Cifar10(train_or_test)
else:
ds = dataset.Cifar100(train_or_test)
data_size = ds.size()
pp_mean = ds.get_per_pixel_mean()
if args.model == 'resnet':
if isTrain:
augmentors = [
imgaug.CenterPaste((40, 40)),
imgaug.RandomCrop((32, 32)),
imgaug.Flip(horiz=True),
imgaug.MapImage(lambda x: x - pp_mean),
]
else:
augmentors = [imgaug.MapImage(lambda x: x - pp_mean)]
else:
if isTrain:
augmentors = [
imgaug.RandomCrop((30, 30)),
imgaug.Flip(horiz=True),
imgaug.Brightness(63),
imgaug.Contrast((0.2, 1.8)),
imgaug.MeanVarianceNormalize(all_channel=True)
]
else:
augmentors = [
imgaug.CenterCrop((30, 30)),
imgaug.MeanVarianceNormalize(all_channel=True)
]
ds = AugmentImageComponent(ds, augmentors)
ds = BatchData(ds, args.batch_size, remainder=not isTrain)
# ds = BatchData(ds, 16, remainder=not isTrain)
if isTrain:
ds = PrefetchDataZMQ(ds, 5)
return ds, data_size
def get_data_adaMixup(train_or_test, isMixup, alpha):
isTrain = train_or_test == 'train'
if isResNet:
ds = dataset.Cifar10(train_or_test)
else:
ds =Mnist(train_or_test)
if isResNet:
if isTrain:
augmentors = [
imgaug.CenterPaste((40, 40)),
imgaug.RandomCrop((32, 32)),
imgaug.Flip(horiz=True),
]
ds = AugmentImageComponent(ds, augmentors)
batch = BATCH_SIZE
ds = BatchData(ds, batch, remainder=not isTrain)
def f(dp):
images, labels = dp
num_samples = labels.shape[0]
one_hot_labels = np.eye(CLASS_NUM)[labels] # one hot coding
index = np.random.permutation(num_samples)
if isTrain:
x1, x2 = images, images[index]
y1, y2 = one_hot_labels, one_hot_labels[index]
else:
x1, x2 = images, images
y1, y2 = one_hot_labels, one_hot_labels
return [x1,x2,y1,y2]
ds = MapData(ds, f)
return ds
480000, 0.2, True)
wd_cost = tf.multiply(wd_w, regularize_cost('.*/W', tf.nn.l2_loss), name='wd_cost')
add_moving_summary(cost, wd_cost)
add_param_summary(('.*/W', ['histogram'])) # monitor W
return tf.add_n([cost, wd_cost], name='cost')
def optimizer(self):
lr = tf.get_variable('learning_rate', initializer=0.01, trainable=False)
opt = tf.train.MomentumOptimizer(lr, 0.9)
return opt
def get_data(train_or_test):
isTrain = train_or_test == 'train'
ds = dataset.Cifar10(train_or_test)
pp_mean = ds.get_per_pixel_mean()
if isTrain:
augmentors = [
imgaug.CenterPaste((40, 40)),
imgaug.RandomCrop((32, 32)),
imgaug.Flip(horiz=True),
imgaug.MapImage(lambda x: x - pp_mean),
]
else:
augmentors = [
imgaug.MapImage(lambda x: x - pp_mean)
]
ds = AugmentImageComponent(ds, augmentors)
ds = BatchData(ds, BATCH_SIZE, remainder=not isTrain)
if isTrain:
assert len(log_prob.get_shape().as_list()) == 3
if single_model:
probs = tf.nn.softmax(log_prob[0])
correct = tf.reduce_mean(tf.to_float(tf.nn.in_top_k(probs, label_ph, 1)))
else:
log_probs = tf.log(tf.reduce_mean(tf.nn.softmax(log_prob), axis=0))
probs = tf.nn.softmax(log_probs)
# correct = tf.reduce_mean(tf.to_float(tf.nn.in_top_k(probs, label_ph, 1)))
ds_train, _ = get_data('train', args)
ds_test, _ = get_data('test', args)
# Untargeted BIM
from tensorpack.dataflow import dataset
pp_mean = dataset.Cifar10('train').get_per_pixel_mean()
stepsize_ph = tf.placeholder(tf.float32, [])
orig_input_ph = tf.placeholder(tf.float32, image_ph.get_shape().as_list())
# adv_inp = fgm(image_ph, probs, y=tf.one_hot(label_ph, depth=10), eps=tf.to_float(1))
pp_mean_sym = tf.tile(tf.constant(pp_mean[None]),
[tf.shape(image_ph)[0], 1, 1, 1])
# adv_inp = tf.clip_by_value(adv_inp, -pp_mean_sym, 255 - pp_mean_sym)
# adv_inp = tf.clip_by_value(adv_inp, orig_input_ph - stepsize_ph, orig_input_ph + stepsize_ph)
adv_inp = fgm(
image_ph,
probs, #y=tf.one_hot(label_ph, depth=10)
eps=tf.to_float(stepsize_ph))
adv_inp = tf.clip_by_value(adv_inp, -pp_mean_sym, 255 - pp_mean_sym)
adv_inp = tf.clip_by_value(adv_inp, orig_input_ph - stepsize_ph,
orig_input_ph + stepsize_ph)
import tensorpack.dataflow.dataset as dataset
import numpy as np
import tensorflow as tf
import random
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
train, test = dataset.Cifar10('train'), dataset.Cifar10('test')
n = 50000
x_train = np.array([train.data[i][0] for i in range(n)], dtype=np.float32)
y_train = np.array([train.data[i][1] for i in range(n)], dtype=np.int32)
x_test = np.array([ex[0] for ex in test.data], dtype=np.float32)
y_test = np.array([ex[1] for ex in test.data], dtype=np.int32)
del (train, test) # frees approximately 180 MB
Y = np.zeros([n, 10])
for i in range(y_train.shape[0]):
Y[i, y_train[i]] = 1
y_train = Y
Y = np.zeros([10000, 10])
for i in range(y_test.shape[0]):
Y[i, y_test[i]] = 1
y_test = Y
# standardization
x_train_pixel_mean = x_train.mean(axis=0) # per-pixel mean
x_train_pixel_std = x_train.std(axis=0) # per-pixel std
x_train -= x_train_pixel_mean
