def load_model(self):
"""
Load model.
"""
database = utils.read_hdf5(self.args.database_file).astype(
numpy.float32)
log('[Testing] read %sd' % self.args.database_file)
self.N_font = database.shape[0]
self.N_class = database.shape[1]
database = database.reshape((database.shape[0] * database.shape[1],
database.shape[2], database.shape[3]))
database = torch.from_numpy(database)
if self.args.use_gpu:
database = database.cuda()
database = torch.autograd.Variable(database, False)
test_theta = utils.read_hdf5(self.args.test_theta_file)
N_theta = test_theta.shape[1]
log('[Testing] read %s' % self.args.test_theta_file)
log('[Testing] using %d N_theta' % N_theta)
self.model = models.AlternativeOneHotDecoder(database, self.N_font,
self.N_class, N_theta)
self.model.eval()
def load_data(self):
"""
Load data.
"""
test_codes = utils.read_hdf5(self.args.test_codes_file).astype(
numpy.int)
self.test_fonts = test_codes[:, 1]
self.test_classes = test_codes[:, 2]
log('[Testing] read %s' % self.args.test_codes_file)
self.perturbations = utils.read_hdf5(
self.args.perturbations_file).astype(numpy.float32)
self.N_attempts = self.perturbations.shape[0]
self.N_samples = self.perturbations.shape[1]
self.perturbations = numpy.swapaxes(self.perturbations, 0, 1)
self.perturbations = self.perturbations.reshape(
(self.perturbations.shape[0] * self.perturbations.shape[1], -1))
log('[Testing] read %s' % self.args.perturbations_file)
self.test_fonts = numpy.repeat(self.test_fonts[:self.N_samples],
self.N_attempts,
axis=0)
self.test_classes = numpy.repeat(self.test_classes[:self.N_samples],
self.N_attempts,
axis=0)
def main(self):
"""
Main.
"""
if not os.path.exists(self.args.images_file):
log('[Visualization] file %s not found' % self.args.images_file)
exit(1)
if not os.path.exists(
self.args.output_directory) and self.args.output_directory:
log('[Visualization] creating %s' % self.args.output_directory)
images = utils.read_hdf5(self.args.images_file)
if len(images.shape) > 3 and images.shape[3] != 3:
images = images.reshape(-1, images.shape[2], images.shape[3])
log('[Visualization] read %s' % self.args.images_file)
if self.args.codes_file:
codes = utils.read_hdf5(self.args.codes_file)
log('[Visualization] read %s' % self.args.codes_file)
codes = codes[:, self.args.label_index]
if self.args.label >= 0:
images = images[codes == self.args.label]
for n in range(min(images.shape[0], self.args.max_images)):
png_file = os.path.join(self.args.output_directory, '%d.png' % n)
vis.image(png_file, images[n], 5, 'gray', self.args.vmin,
self.args.vmax)
log('[Visualization] wrote %s' % png_file)
def main(self):
"""
Main.
"""
train_images_file = paths.celeba_train_images_file()
test_images_file = paths.celeba_test_images_file()
assert os.path.exists(train_images_file)
assert os.path.exists(test_images_file)
train_images = utils.read_hdf5(train_images_file)
log('read %s' % train_images_file)
test_images = utils.read_hdf5(test_images_file)
log('read %s' % test_images_file)
log('[Data] before train: %g %g' %
(numpy.min(train_images), numpy.max(train_images)))
log('[Data] before test: %g %g' %
(numpy.min(train_images), numpy.max(train_images)))
train_images *= 255
test_images *= 255
log('[Data] after train: %g %g' %
(numpy.min(train_images), numpy.max(train_images)))
log('[Data] after test: %g %g' %
(numpy.min(train_images), numpy.max(train_images)))
utils.write_hdf5(train_images_file, train_images.astype(numpy.float32))
log('[Data] wrote %s' % train_images_file)
utils.write_hdf5(test_images_file, test_images.astype(numpy.float32))
log('[Data] wrote %s' % test_images_file)
def main(self):
"""
Main method.
"""
database = utils.read_hdf5(self.args.database_file)
log('[Data] read %s' % self.args.database_file)
N_font = database.shape[0]
N_class = database.shape[1]
assert database.shape[2] == database.shape[3]
database = database.reshape((database.shape[0] * database.shape[1],
database.shape[2], database.shape[3]))
database = torch.from_numpy(database).float()
if self.args.use_gpu:
database = database.cuda()
database = torch.autograd.Variable(database)
codes = utils.read_hdf5(self.args.codes_file)
codes = codes[:, 0]
codes = common.numpy.one_hot(codes, N_font * N_class)
log('[Data] read %s' % self.args.codes_file)
theta = utils.read_hdf5(self.args.theta_file)
N = theta.shape[0]
N_theta = theta.shape[1]
log('[Data] read %s' % self.args.theta_file)
model = models.OneHotDecoder(database, N_theta)
images = []
num_batches = int(math.ceil(float(N) / self.args.batch_size))
for b in range(num_batches):
batch_theta = torch.from_numpy(
theta[b * self.args.batch_size:min((b + 1) *
self.args.batch_size, N)])
batch_codes = torch.from_numpy(
codes[b * self.args.batch_size:min((b + 1) *
self.args.batch_size, N)])
batch_codes, batch_theta = batch_codes.float(), batch_theta.float()
if self.args.use_gpu:
batch_codes, batch_theta = batch_codes.cuda(
), batch_theta.cuda()
batch_codes, batch_theta = torch.autograd.Variable(
batch_codes), torch.autograd.Variable(batch_theta)
output = model(batch_codes, batch_theta)
images.append(output.data.cpu().numpy().squeeze())
if b % 1000 == 0:
log('[Data] processed %d/%d batches' % (b + 1, num_batches))
images = numpy.concatenate(images, axis=0)
if len(images.shape) > 3:
images = numpy.transpose(images, (0, 2, 3, 1))
utils.write_hdf5(self.args.images_file, images)
log('[Data] wrote %s' % self.args.images_file)
def load_data(self):
"""
Load data.
"""
self.test_images = utils.read_hdf5(self.args.test_images_file)
log('[Testing] read %s' % self.args.test_images_file)
if len(self.test_images.shape) < 4:
self.test_images = numpy.expand_dims(self.test_images, axis=3)
self.resolution = self.test_images.shape[1]
self.image_channels = self.test_images.shape[3]
self.test_codes = utils.read_hdf5(self.args.test_codes_file)
self.test_codes = self.test_codes[:, self.args.label_index]
log('[Testing] read %s' % self.args.test_codes_file)
self.perturbations = utils.read_hdf5(
self.args.perturbations_file).astype(numpy.float32)
self.N_attempts = self.perturbations.shape[0]
self.N_samples = self.perturbations.shape[1]
self.perturbations = numpy.swapaxes(self.perturbations, 0, 1)
self.perturbations = self.perturbations.reshape(
(self.perturbations.shape[0] * self.perturbations.shape[1], -1))
log('[Testing] read %s' % self.args.perturbations_file)
self.test_codes = numpy.repeat(self.test_codes[:self.N_samples],
self.N_attempts,
axis=0)
self.test_images = numpy.repeat(self.test_images[:self.N_samples],
self.N_attempts,
axis=0)
def load_data(self):
"""
Load data.
"""
self.train_images = utils.read_hdf5(self.args.train_images_file).astype(numpy.float32)
log('[Training] read %s' % self.args.train_images_file)
self.test_images = utils.read_hdf5(self.args.test_images_file).astype(numpy.float32)
log('[Training] read %s' % self.args.test_images_file)
# For handling both color and gray images.
if len(self.train_images.shape) < 4:
self.train_images = numpy.expand_dims(self.train_images, axis=3)
self.test_images = numpy.expand_dims(self.test_images, axis=3)
log('[Training] no color images, adjusted size')
self.resolution = self.train_images.shape[2]
log('[Training] resolution %d' % self.resolution)
self.train_codes = utils.read_hdf5(self.args.train_codes_file).astype(numpy.float32)
log('[Training] read %s' % self.args.train_codes_file)
self.test_codes = utils.read_hdf5(self.args.test_codes_file).astype(numpy.float32)
log('[Training] read %s' % self.args.test_codes_file)
self.train_codes = self.train_codes[:, self.args.label_index]
self.test_codes = self.test_codes[:, self.args.label_index]
if self.args.label >= 0:
self.train_images = self.train_images[self.train_codes == self.args.label]
self.test_images = self.test_images[self.test_codes == self.args.label]
def load_data(self):
"""
Load data.
"""
self.test_images = utils.read_hdf5(self.args.test_images_file).astype(
numpy.float32)
log('[Attack] read %s' % self.args.test_images_file)
# For color and gray images.
if len(self.test_images.shape) < 4:
self.test_images = numpy.expand_dims(self.test_images, axis=3)
self.test_codes = utils.read_hdf5(self.args.test_codes_file).astype(
numpy.int)
self.test_codes = self.test_codes[:, self.args.label_index]
log('[Attack] read %s' % self.args.test_codes_file)
self.test_theta = utils.read_hdf5(self.args.test_theta_file).astype(
numpy.float32)
log('[Attack] read %s' % self.args.test_theta_file)
self.N_class = numpy.max(self.test_codes) + 1
self.min_bound = numpy.min(self.test_theta, 0)
self.max_bound = numpy.max(self.test_theta, 0)
if self.args.max_samples < 0:
self.args.max_samples = self.test_theta.shape[0]
else:
self.args.max_samples = min(self.args.max_samples,
self.test_theta.shape[0])
def load_data(self):
"""
Load data.
"""
self.test_images = utils.read_hdf5(self.args.test_images_file).astype(numpy.float32)
if len(self.test_images.shape) < 4:
self.test_images = numpy.expand_dims(self.test_images, axis=3)
log('[Testing] read %s' % self.args.test_images_file)
self.test_codes = utils.read_hdf5(self.args.test_codes_file).astype(numpy.int)
self.test_codes = self.test_codes[:, self.args.label_index]
log('[Testing] read %s' % self.args.test_codes_file)
self.perturbations = utils.read_hdf5(self.args.perturbations_file).astype(numpy.float32)
self.N_attempts = self.perturbations.shape[0]
self.N_samples = self.perturbations.shape[1]
self.perturbations = numpy.swapaxes(self.perturbations, 0, 1)
if len(self.perturbations.shape) <= 4:
self.perturbations = self.perturbations.reshape((self.perturbations.shape[0] * self.perturbations.shape[1], self.perturbations.shape[2], self.perturbations.shape[3], 1))
else:
self.perturbations = self.perturbations.reshape((self.perturbations.shape[0] * self.perturbations.shape[1], self.perturbations.shape[2], self.perturbations.shape[3], self.perturbations.shape[4]))
log('[Testing] read %s' % self.args.perturbations_file)
self.original_success = utils.read_hdf5(self.args.original_success_file)
self.original_success = numpy.swapaxes(self.original_success, 0, 1)
self.original_success = self.original_success.reshape((self.original_success.shape[0] * self.original_success.shape[1]))
log('[Testing] read %s' % self.args.original_success_file)
self.original_accuracy = utils.read_hdf5(self.args.original_accuracy_file)
log('[Testing] read %s' % self.args.original_accuracy_file)
self.perturbation_codes = numpy.repeat(self.test_codes[:self.N_samples], self.N_attempts, axis=0)
self.transfer_success = numpy.copy(self.original_success)
def load_data(self):
"""
Load data.
"""
self.test_images = utils.read_hdf5(self.args.test_images_file).astype(
numpy.float32)
log('[Visualization] read %s' % self.args.test_images_file)
self.test_codes = utils.read_hdf5(self.args.test_codes_file).astype(
numpy.int)
self.test_codes = self.test_codes[:, self.args.label_index]
log('[Visualization] read %s' % self.args.test_codes_file)
self.N_class = numpy.max(self.test_codes) + 1
self.resolution = self.test_images.shape[1]
self.image_channels = self.test_images.shape[3] if len(
self.test_images.shape) > 3 else 1
log('[Visualization] resolution %d' % self.resolution)
if self.args.max_samples < 0:
self.args.max_samples = self.test_codes.shape[0]
else:
self.args.max_samples = min(self.args.max_samples,
self.test_codes.shape[0])
def load_data(self):
"""
Load data and model.
"""
self.test_images = utils.read_hdf5(self.args.test_images_file).astype(
numpy.float32)
log('[Testing] read %s' % self.args.test_images_file)
if len(self.test_images.shape) < 4:
self.test_images = numpy.expand_dims(self.test_images, axis=3)
self.test_codes = utils.read_hdf5(self.args.test_codes_file)
self.test_codes = self.test_codes[:, self.args.label_index]
log('[Testing] read %s' % self.args.test_codes_file)
self.perturbations = utils.read_hdf5(self.args.perturbations_file)
if len(self.perturbations.shape) > 3:
self.perturbations = self.perturbations.reshape(
(self.perturbations.shape[0], self.perturbations.shape[1], -1))
self.perturbation_images = self.test_images[:self.perturbations.
shape[1]].reshape(
self.perturbations.
shape[1], -1)
self.perturbation_codes = self.test_codes[:self.perturbations.shape[1]]
log('[Testing] read %s' % self.args.perturbations_file)
assert not numpy.any(
self.perturbations != self.perturbations), 'NaN in perturbations'
self.success = utils.read_hdf5(self.args.success_file)
log('[Testing] read %s' % self.args.success_file)
self.probabilities = utils.read_hdf5(self.args.probabilities_file)
log('[Testing] read %s' % self.args.probabilities_file)
def main(self):
"""
Main which should be overwritten.
"""
self.test_images = utils.read_hdf5(self.args.test_images_file).astype(
numpy.float32)
log('[Testing] read %s' % self.args.test_images_file)
# For handling both color and gray images.
if len(self.test_images.shape) < 4:
self.test_images = numpy.expand_dims(self.test_images, axis=3)
log('[Testing] no color images, adjusted size')
self.resolution = self.test_images.shape[2]
log('[Testing] resolution %d' % self.resolution)
self.test_codes = utils.read_hdf5(self.args.test_codes_file).astype(
numpy.int)
self.test_codes = self.test_codes[:, self.args.label_index]
log('[Testing] read %s' % self.args.test_codes_file)
N_class = numpy.max(self.test_codes) + 1
network_units = list(map(int, self.args.network_units.split(',')))
log('[Testing] using %d input channels' % self.test_images.shape[3])
self.model = models.Classifier(
N_class,
resolution=(self.test_images.shape[3], self.test_images.shape[1],
self.test_images.shape[2]),
architecture=self.args.network_architecture,
activation=self.args.network_activation,
batch_normalization=not self.args.network_no_batch_normalization,
start_channels=self.args.network_channels,
dropout=self.args.network_dropout,
units=network_units)
assert os.path.exists(
self.args.state_file
), 'state file %s not found' % self.args.state_file
state = State.load(self.args.state_file)
log('[Testing] read %s' % self.args.state_file)
self.model.load_state_dict(state.model)
if self.args.use_gpu and not cuda.is_cuda(self.model):
log('[Testing] model is not CUDA')
self.model = self.model.cuda()
log('[Testing] loaded model')
self.model.eval()
log('[Testing] set classifier to eval')
self.test()
def main(self):
"""
Main method.
"""
with logw('[Data] read %s' % self.args.database_file):
database = utils.read_hdf5(self.args.database_file)
with logw('[Data] read %s' % self.args.codes_file):
codes = utils.read_hdf5(self.args.codes_file)
with logw('[Data] read %s' % self.args.theta_file):
theta = utils.read_hdf5(self.args.theta_file)
with logw('[Data] read %s' % self.args.images_file):
images = utils.read_hdf5(self.args.images_file)
with logw('[Data] read %s' % self.args.train_codes_file):
train_codes = utils.read_hdf5(self.args.train_codes_file)
with logw('[Data] read %s' % self.args.train_theta_file):
train_theta = utils.read_hdf5(self.args.train_theta_file)
with logw('[Data] read %s' % self.args.train_images_file):
train_images = utils.read_hdf5(self.args.train_images_file)
with logw('[Data] read %s' % self.args.test_codes_file):
test_codes = utils.read_hdf5(self.args.test_codes_file)
with logw('[Data] read %s' % self.args.test_theta_file):
test_theta = utils.read_hdf5(self.args.test_theta_file)
with logw('[Data] read %s' % self.args.test_images_file):
test_images = utils.read_hdf5(self.args.test_images_file)
log('[Data] database: %s' %
'x'.join([str(dim) for dim in database.shape]))
log('[Data] codes: %s' % 'x'.join([str(dim) for dim in codes.shape]))
log('[Data] theta: %s' % 'x'.join([str(dim) for dim in theta.shape]))
log('[Data] images: %s' % 'x'.join([str(dim) for dim in images.shape]))
log('[Data] train_codes: %s' %
'x'.join([str(dim) for dim in train_codes.shape]))
log('[Data] train_theta: %s' %
'x'.join([str(dim) for dim in train_theta.shape]))
log('[Data] train_images: %s' %
'x'.join([str(dim) for dim in train_images.shape]))
log('[Data] test_codes: %s' %
'x'.join([str(dim) for dim in test_codes.shape]))
log('[Data] test_theta: %s' %
'x'.join([str(dim) for dim in test_theta.shape]))
log('[Data] test_images: %s' %
'x'.join([str(dim) for dim in test_images.shape]))
def main(self):
"""
Main method.
"""
codes = utils.read_hdf5(self.args.codes_file)
log('[Data] read %s' % self.args.codes_file)
theta = utils.read_hdf5(self.args.theta_file)
log('[Data] read %s' % self.args.theta_file)
images = utils.read_hdf5(self.args.images_file)
log('[Data] read %s' % self.args.images_file)
#
# The set is not splitted randomly or so.
# This simplifies training set subselection while enforcing balanced datasets.
# For example, for 10 classes, every subset that is a multiple of 10 will
# be balanced by construction.
#
N = codes.shape[0]
N_train = self.args.N_train
train_codes = codes[:N_train]
test_codes = codes[N_train:]
train_theta = theta[:N_train]
test_theta = theta[N_train:]
train_images = images[:N_train]
test_images = images[N_train:]
utils.write_hdf5(self.args.train_codes_file, train_codes)
log('[Data] wrote %s' % self.args.train_codes_file)
utils.write_hdf5(self.args.test_codes_file, test_codes)
log('[Data] wrote %s' % self.args.test_codes_file)
utils.write_hdf5(self.args.train_theta_file, train_theta)
log('[Data] wrote %s' % self.args.train_theta_file)
utils.write_hdf5(self.args.test_theta_file, test_theta)
log('[Data] wrote %s' % self.args.test_theta_file)
utils.write_hdf5(self.args.train_images_file, train_images)
log('[Data] wrote %s' % self.args.train_images_file)
utils.write_hdf5(self.args.test_images_file, test_images)
log('[Data] wrote %s' % self.args.test_images_file)
def load_data(self):
"""
Load data.
"""
test_codes = utils.read_hdf5(self.args.test_codes_file).astype(numpy.int)
self.test_fonts = test_codes[:, 1]
self.test_classes = test_codes[:, 2]
log('[Attack] read %s' % self.args.test_codes_file)
self.test_theta = utils.read_hdf5(self.args.test_theta_file).astype(numpy.float32)
log('[Attack] read %s' % self.args.test_theta_file)
self.min_bound = numpy.min(self.test_theta, 0)
self.max_bound = numpy.max(self.test_theta, 0)
if self.args.max_samples < 0:
self.args.max_samples = self.test_theta.shape[0]
else:
self.args.max_samples = min(self.args.max_samples, self.test_theta.shape[0])
def main(self):
"""
Main method.
"""
theta = utils.read_hdf5(self.args.theta_file)
log('[Data] read %s' % self.args.theta_file)
if theta.shape[1] == 1:
log('[Data] theta min: [%f]' % (
numpy.min(theta[:, 0])))
log('[Data] theta max: [%f]' % (
numpy.max(theta[:, 0])))
elif theta.shape[1] == 2:
log('[Data] theta min: [%f, %f]' % (
numpy.min(theta[:, 0]), numpy.min(theta[:, 1])))
log('[Data] theta max: [%f, %f]' % (
numpy.max(theta[:, 0]), numpy.max(theta[:, 1])))
elif theta.shape[1] == 3:
log('[Data] theta min: [%f, %f, %f]' % (
numpy.min(theta[:, 0]), numpy.min(theta[:, 1]), numpy.min(theta[:, 2])))
log('[Data] theta max: [%f, %f, %f]' % (
numpy.max(theta[:, 0]), numpy.max(theta[:, 1]), numpy.max(theta[:, 2])))
elif theta.shape[1] == 4:
log('[Data] theta min: [%f, %f, %f, %f]' % (
numpy.min(theta[:, 0]), numpy.min(theta[:, 1]), numpy.min(theta[:, 2]),
numpy.min(theta[:, 3])))
log('[Data] theta max: [%f, %f, %f, %f]' % (
numpy.max(theta[:, 0]), numpy.max(theta[:, 1]), numpy.max(theta[:, 2]),
numpy.max(theta[:, 3])))
elif theta.shape[1] == 6:
log('[Data] theta min: [%f, %f, %f, %f, %f, %f]' % (
numpy.min(theta[:, 0]), numpy.min(theta[:, 1]), numpy.min(theta[:, 2]),
numpy.min(theta[:, 3]), numpy.min(theta[:, 4]), numpy.min(theta[:, 5])))
log('[Data] theta max: [%f, %f, %f, %f, %f, %f]' % (
numpy.max(theta[:, 0]), numpy.max(theta[:, 1]), numpy.max(theta[:, 2]),
numpy.max(theta[:, 3]), numpy.max(theta[:, 4]), numpy.max(theta[:, 5])))
codes = utils.read_hdf5(self.args.codes_file)
log('[Data] read %s' % self.args.codes_file)
print(codes)
def load_data(self):
"""
Load data.
"""
self.test_images = utils.read_hdf5(self.args.test_images_file).astype(
numpy.float32)
log('[Attack] read %s' % self.args.test_images_file)
if len(self.test_images.shape) < 4:
self.test_images = numpy.expand_dims(self.test_images, axis=3)
self.test_codes = utils.read_hdf5(self.args.test_codes_file).astype(
numpy.int)
self.test_codes = self.test_codes[:, self.args.label_index]
log('[Attack] read %s' % self.args.test_codes_file)
if self.args.max_samples < 0:
self.args.max_samples = self.test_images.shape[0]
else:
self.args.max_samples = min(self.args.max_samples,
self.test_images.shape[0])
def main(self):
"""
Main.
"""
if not os.path.exists(self.args.images_file):
log('[Visualization] file %s not found' % self.args.images_file)
exit(1)
if not os.path.exists(
self.args.output_directory) and self.args.output_directory:
log('[Visualization] creating %s' % self.args.output_directory)
assert self.args.cols > 0, 'number of columns has to be larger than 0'
assert self.args.rows > 0, 'number of rows has to be larger than 0'
images = utils.read_hdf5(self.args.images_file)
if len(images.shape) > 3 and images.shape[3] != 3:
images = images.reshape(-1, images.shape[2], images.shape[3])
log('[Visualization] read %s' % self.args.images_file)
if self.args.codes_file:
codes = utils.read_hdf5(self.args.codes_file)
log('[Visualization] read %s' % self.args.codes_file)
codes = codes[:, self.args.label_index]
if self.args.label >= 0:
images = images[codes == self.args.label]
batch_size = self.args.rows * self.args.cols
num_batches = math.ceil(images.shape[0] / batch_size)
for b in range(min(num_batches, self.args.max_images)):
png_file = os.path.join(self.args.output_directory, '%d.png' % b)
batch = images[b * batch_size:min((b + 1) *
batch_size, images.shape[0])]
vis.mosaic(png_file, batch, self.args.cols, 5, 'gray',
self.args.vmin, self.args.vmax)
log('[Visualization] wrote %s' % png_file)
def load_model(self):
"""
Load model.
"""
database = utils.read_hdf5(self.args.database_file).astype(numpy.float32)
log('[Attack] read %sd' % self.args.database_file)
self.N_font = database.shape[0]
self.N_class = database.shape[1]
resolution = database.shape[2]
database = database.reshape((database.shape[0] * database.shape[1], database.shape[2], database.shape[3]))
database = torch.from_numpy(database)
if self.args.use_gpu:
database = database.cuda()
database = torch.autograd.Variable(database, False)
N_theta = self.test_theta.shape[1]
log('[Attack] using %d N_theta' % N_theta)
decoder = models.AlternativeOneHotDecoder(database, self.N_font, self.N_class, N_theta)
decoder.eval()
image_channels = 1 if N_theta <= 7 else 3
network_units = list(map(int, self.args.network_units.split(',')))
log('[Attack] using %d input channels' % image_channels)
classifier = models.Classifier(self.N_class, resolution=(image_channels, resolution, resolution),
architecture=self.args.network_architecture,
activation=self.args.network_activation,
batch_normalization=not self.args.network_no_batch_normalization,
start_channels=self.args.network_channels,
dropout=self.args.network_dropout,
units=network_units)
assert os.path.exists(self.args.classifier_file), 'state file %s not found' % self.args.classifier_file
state = State.load(self.args.classifier_file)
log('[Attack] read %s' % self.args.classifier_file)
classifier.load_state_dict(state.model)
if self.args.use_gpu and not cuda.is_cuda(classifier):
log('[Attack] classifier is not CUDA')
classifier = classifier.cuda()
log('[Attack] loaded classifier')
# !
classifier.eval()
log('[Attack] set classifier to eval')
self.model = models.DecoderClassifier(decoder, classifier)
def load_data(self):
"""
Load data and model.
"""
self.test_images = utils.read_hdf5(self.args.test_images_file).astype(numpy.float32)
log('[Testing] read %s' % self.args.test_images_file)
# For handling both color and gray images.
if len(self.test_images.shape) < 4:
self.test_images = numpy.expand_dims(self.test_images, axis=3)
log('[Testing] no color images, adjusted size')
self.resolution = self.test_images.shape[2]
log('[Testing] resolution %d' % self.resolution)
self.train_images = utils.read_hdf5(self.args.train_images_file).astype(numpy.float32)
# !
self.train_images = self.train_images.reshape((self.train_images.shape[0], -1))
log('[Testing] read %s' % self.args.train_images_file)
self.test_codes = utils.read_hdf5(self.args.test_codes_file).astype(numpy.int)
self.test_codes = self.test_codes[:, self.args.label_index]
self.N_class = numpy.max(self.test_codes) + 1
log('[Testing] read %s' % self.args.test_codes_file)
self.accuracy = utils.read_hdf5(self.args.accuracy_file)
log('[Testing] read %s' % self.args.accuracy_file)
self.perturbations = utils.read_hdf5(self.args.perturbations_file).astype(numpy.float32)
self.N_attempts = self.perturbations.shape[0]
# First, repeat relevant data.
self.test_images = numpy.repeat(self.test_images[:self.perturbations.shape[1]], self.N_attempts, axis=0)
self.perturbation_codes = numpy.repeat(self.test_codes[:self.perturbations.shape[1]], self.N_attempts, axis=0)
self.perturbation_codes = numpy.squeeze(self.perturbation_codes)
self.accuracy = numpy.repeat(self.accuracy[:self.perturbations.shape[1]], self.N_attempts, axis=0)
# Then, reshape the perturbations!
self.perturbations = numpy.swapaxes(self.perturbations, 0, 1)
self.perturbations = self.perturbations.reshape((self.perturbations.shape[0] * self.perturbations.shape[1], -1))
assert self.perturbations.shape[1] == self.args.N_theta
log('[Testing] read %s' % self.args.perturbations_file)
assert not numpy.any(self.perturbations != self.perturbations), 'NaN in perturbations'
self.success = utils.read_hdf5(self.args.success_file)
self.success = numpy.swapaxes(self.success, 0, 1)
self.success = self.success.reshape((self.success.shape[0] * self.success.shape[1]))
log('[Testing] read %s' % self.args.success_file)
log('[Testing] using %d input channels' % self.test_images.shape[3])
assert self.args.N_theta > 0 and self.args.N_theta <= 9
decoder = models.STNDecoder(self.args.N_theta)
# decoder.eval()
log('[Testing] set up STN decoder')
self.model = decoder
def main(self):
"""
Main method.
"""
images = utils.read_hdf5(self.args.images_file)
log('[Data] read %s' % self.args.images_file)
log('[Data] #images: %d' % images.shape[0])
images = images.reshape((images.shape[0], -1))
l2_norm = numpy.average(numpy.linalg.norm(images, ord=2, axis=1))
l1_norm = numpy.average(numpy.linalg.norm(images, ord=1, axis=1))
linf_norm = numpy.average(
numpy.linalg.norm(images, ord=float('inf'), axis=1))
log('[Data] average L_2 norm: %g' % l2_norm)
log('[Data] average L_1 norm: %g' % l1_norm)
log('[Data] average L_inf norm: %g' % linf_norm)
def load_data(self):
"""
Load data and model.
"""
self.test_images = utils.read_hdf5(self.args.test_images_file)
self.test_images = self.test_images.reshape(
(self.test_images.shape[0], -1))
log('[Testing] read %s' % self.args.test_images_file)
self.train_images = utils.read_hdf5(self.args.train_images_file)
self.train_images = self.train_images.reshape(
(self.train_images.shape[0], -1))
log('[Testing] read %s' % self.args.train_images_file)
self.train_theta = utils.read_hdf5(self.args.train_theta_file)
log('[Testing] read %s' % self.args.train_theta_file)
self.test_theta = utils.read_hdf5(self.args.test_theta_file)
log('[Testing] read %s' % self.args.test_theta_file)
self.test_codes = utils.read_hdf5(self.args.test_codes_file)
self.test_codes = self.test_codes[:, self.args.label_index]
log('[Testing] read %s' % self.args.test_codes_file)
self.perturbations = utils.read_hdf5(self.args.perturbations_file)
if len(self.perturbations.shape) > 3:
self.perturbations = self.perturbations.reshape(
(self.perturbations.shape[0], self.perturbations.shape[1], -1))
self.perturbation_images = self.test_images[:self.perturbations.
shape[1]]
self.perturbation_codes = self.test_codes[:self.perturbations.shape[1]]
log('[Testing] read %s' % self.args.perturbations_file)
assert not numpy.any(
self.perturbations != self.perturbations), 'NaN in perturbations'
self.success = utils.read_hdf5(self.args.success_file)
log('[Testing] read %s' % self.args.success_file)
self.accuracy = utils.read_hdf5(self.args.accuracy_file)
self.accuracy = self.accuracy[:self.perturbations.shape[1]]
log('[Testing] read %s' % self.args.accuracy_file)
def main(self):
"""
Main method.
"""
images = utils.read_hdf5(self.args.images_file)
log('read %s' % self.args.images_file)
rows = 10
cols = 10
print(images.shape)
for n in range(
min(self.args.max_images, images.shape[0] // (rows * cols))):
log('%d/%d' % ((n + 1) * rows * cols, images.shape[0]))
plot_file = os.path.join(self.args.output_directory,
str(n) + '.png')
vis.mosaic(plot_file,
images[n * rows * cols:(n + 1) * rows * cols, :],
cols=10)
log('wrote %s' % plot_file)
def main(self):
"""
Main which should be overwritten.
"""
test_images = utils.read_hdf5(self.args.test_images_file)
log('[Sampling] read %s' % self.args.test_images_file)
if len(test_images.shape) < 4:
test_images = numpy.expand_dims(test_images, axis=3)
network_units = list(map(int, self.args.network_units.split(',')))
self.decoder = models.LearnedDecoder(
self.args.latent_space_size,
resolution=(test_images.shape[3], test_images.shape[1],
test_images.shape[2]),
architecture=self.args.network_architecture,
start_channels=self.args.network_channels,
activation=self.args.network_activation,
batch_normalization=not self.args.network_no_batch_normalization,
units=network_units)
log(self.decoder)
assert os.path.exists(self.args.decoder_file)
state = State.load(self.args.decoder_file)
log('[Sampling] loaded %s' % self.args.decoder_file)
self.decoder.load_state_dict(state.model)
log('[Sampling] loaded decoder')
if self.args.use_gpu and not cuda.is_cuda(self.decoder):
self.decoder = self.decoder.cuda()
log('[Sampling] model needs %gMiB' %
((cuda.estimate_size(self.decoder)) / (1024 * 1024)))
self.sample()
def load_model_and_scheduler(self):
"""
Load model.
"""
params = {
'lr': self.args.lr,
'lr_decay': self.args.lr_decay,
'lr_min': 0.0000001,
'weight_decay': self.args.weight_decay,
}
log('[Training] using %d input channels' % self.train_images.shape[3])
network_units = list(map(int, self.args.network_units.split(',')))
self.model = models.Classifier(
self.N_class,
resolution=(self.train_images.shape[3], self.train_images.shape[1],
self.train_images.shape[2]),
architecture=self.args.network_architecture,
activation=self.args.network_activation,
batch_normalization=not self.args.network_no_batch_normalization,
start_channels=self.args.network_channels,
dropout=self.args.network_dropout,
units=network_units)
self.epoch = 0
if os.path.exists(self.args.state_file):
state = State.load(self.args.state_file)
log('[Training] loaded %s' % self.args.state_file)
self.model.load_state_dict(state.model)
# needs to be done before costructing optimizer.
if self.args.use_gpu and not cuda.is_cuda(self.model):
self.model = self.model.cuda()
log('[Training] model is not CUDA')
log('[Training] loaded model')
optimizer = torch.optim.Adam(self.model.parameters(), params['lr'])
optimizer.load_state_dict(state.optimizer)
self.scheduler = ADAMScheduler(optimizer, **params)
self.epoch = state.epoch + 1
self.scheduler.update(self.epoch)
assert os.path.exists(self.args.training_file) and os.path.exists(
self.args.testing_file)
self.train_statistics = utils.read_hdf5(self.args.training_file)
log('[Training] read %s' % self.args.training_file)
self.test_statistics = utils.read_hdf5(self.args.testing_file)
log('[Training] read %s' % self.args.testing_file)
if utils.display():
self.plot()
else:
if self.args.use_gpu and not cuda.is_cuda(self.model):
self.model = self.model.cuda()
log('[Training] model is not CUDA')
log('[Training] did not load model, using new one')
self.scheduler = ADAMScheduler(self.model.parameters(), **params)
self.scheduler.initialize() # !
log(self.model)
def load_data(self):
"""
Load data.
"""
assert self.args.batch_size % 4 == 0
self.train_images = utils.read_hdf5(
self.args.train_images_file).astype(numpy.float32)
log('[Training] read %s' % self.args.train_images_file)
self.test_images = utils.read_hdf5(self.args.test_images_file).astype(
numpy.float32)
log('[Training] read %s' % self.args.test_images_file)
# For handling both color and gray images.
if len(self.train_images.shape) < 4:
self.train_images = numpy.expand_dims(self.train_images, axis=3)
self.test_images = numpy.expand_dims(self.test_images, axis=3)
log('[Training] no color images, adjusted size')
self.resolution = self.train_images.shape[2]
log('[Training] resolution %d' % self.resolution)
self.train_codes = utils.read_hdf5(self.args.train_codes_file).astype(
numpy.int)
assert self.train_codes.shape[1] >= self.args.label_index + 1
self.train_codes = self.train_codes[:, self.args.label_index]
log('[Training] read %s' % self.args.train_codes_file)
self.test_codes = utils.read_hdf5(self.args.test_codes_file).astype(
numpy.int)
assert self.test_codes.shape[1] >= self.args.label_index + 1
self.test_codes = self.test_codes[:, self.args.label_index]
log('[Training] read %s' % self.args.test_codes_file)
assert self.train_codes.shape[0] == self.train_images.shape[0]
assert self.test_codes.shape[0] == self.test_images.shape[0]
# Select subset of samples
if self.args.training_samples < 0:
self.args.training_samples = self.train_images.shape[0]
else:
self.args.training_samples = min(self.args.training_samples,
self.train_images.shape[0])
self.N_class = numpy.max(self.train_codes) + 1
log('[Training] using %d training samples' %
self.args.training_samples)
if self.args.test_samples < 0:
self.args.test_samples = self.test_images.shape[0]
else:
self.args.test_samples = min(self.args.test_samples,
self.test_images.shape[0])
if self.args.early_stopping:
assert self.args.validation_samples > 0
assert self.args.training_samples + self.args.validation_samples <= self.train_images.shape[
0]
self.val_images = self.train_images[self.train_images.shape[0] -
self.args.validation_samples:]
self.val_codes = self.train_codes[self.train_codes.shape[0] -
self.args.validation_samples:]
self.train_images = self.train_images[:self.train_images.shape[0] -
self.args.validation_samples]
self.train_codes = self.train_codeſ[:self.train_codes.shape[0] -
self.args.validation_samples]
assert self.val_images.shape[
0] == self.args.validation_samples and self.val_codes.shape[
0] == self.args.validation_samples
log('[Training] found %d classes' % self.N_class)
if self.args.random_samples:
perm = numpy.random.permutation(self.train_images.shape[0] // 10)
perm = perm[:self.args.training_samples // 10]
perm = numpy.repeat(perm, self.N_class, axis=0) * 10 + numpy.tile(
numpy.array(range(self.N_class)), (perm.shape[0]))
self.train_images = self.train_images[perm]
self.train_codes = self.train_codes[perm]
else:
self.train_images = self.train_images[:self.args.training_samples]
self.train_codes = self.train_codes[:self.args.training_samples]
# Check that the dataset is balanced.
number_samples = self.train_codes.shape[0] // self.N_class
for c in range(self.N_class):
number_samples_ = numpy.sum(self.train_codes == c)
if number_samples_ != number_samples:
log(
'[Training] dataset not balanced, class %d should have %d samples but has %d'
% (c, number_samples, number_samples_), LogLevel.WARNING)
def main(self):
"""
Main which should be overwritten.
"""
self.train_images = utils.read_hdf5(
self.args.train_images_file).astype(numpy.float32)
log('[Testing] read %s' % self.args.train_images_file)
self.test_images = utils.read_hdf5(self.args.test_images_file).astype(
numpy.float32)
log('[Testing] read %s' % self.args.test_images_file)
# For handling both color and gray images.
if len(self.train_images.shape) < 4:
self.train_images = numpy.expand_dims(self.train_images, axis=3)
self.test_images = numpy.expand_dims(self.test_images, axis=3)
log('[Testing] no color images, adjusted size')
self.resolution = self.train_images.shape[2]
log('[Testing] resolution %d' % self.resolution)
self.train_codes = utils.read_hdf5(self.args.train_codes_file).astype(
numpy.float32)
log('[Testing] read %s' % self.args.train_codes_file)
self.test_codes = utils.read_hdf5(self.args.test_codes_file).astype(
numpy.float32)
log('[Testing] read %s' % self.args.test_codes_file)
self.train_codes = self.train_codes[:, self.args.label_index]
self.test_codes = self.test_codes[:, self.args.label_index]
if self.args.label >= 0:
self.train_images = self.train_images[self.train_codes ==
self.args.label]
self.test_images = self.test_images[self.test_codes ==
self.args.label]
log('[Testing] using %d input channels' % self.test_images.shape[3])
network_units = list(map(int, self.args.network_units.split(',')))
self.encoder = models.LearnedVariationalEncoder(
self.args.latent_space_size,
0,
resolution=(self.train_images.shape[3], self.train_images.shape[1],
self.train_images.shape[2]),
architecture=self.args.network_architecture,
start_channels=self.args.network_channels,
activation=self.args.network_activation,
batch_normalization=not self.args.network_no_batch_normalization,
units=network_units)
self.decoder = models.LearnedDecoder(
self.args.latent_space_size,
resolution=(self.train_images.shape[3], self.train_images.shape[1],
self.train_images.shape[2]),
architecture=self.args.network_architecture,
start_channels=self.args.network_channels,
activation=self.args.network_activation,
batch_normalization=not self.args.network_no_batch_normalization,
units=network_units)
log(self.encoder)
log(self.decoder)
assert os.path.exists(self.args.encoder_file) and os.path.exists(
self.args.decoder_file)
state = State.load(self.args.encoder_file)
log('[Testing] loaded %s' % self.args.encoder_file)
self.encoder.load_state_dict(state.model)
log('[Testing] loaded encoder')
state = State.load(self.args.decoder_file)
log('[Testing] loaded %s' % self.args.decoder_file)
self.decoder.load_state_dict(state.model)
log('[Testing] loaded decoder')
if self.args.use_gpu and not cuda.is_cuda(self.encoder):
self.encoder = self.encoder.cuda()
if self.args.use_gpu and not cuda.is_cuda(self.decoder):
self.decoder = self.decoder.cuda()
log('[Testing] model needs %gMiB' %
((cuda.estimate_size(self.encoder) +
cuda.estimate_size(self.decoder)) / (1024 * 1024)))
self.test()
def load_data(self):
"""
Load data and model.
"""
with logw('[Detection] read %s' % self.args.train_images_file):
self.nearest_neighbor_images = utils.read_hdf5(
self.args.train_images_file)
assert len(self.nearest_neighbor_images.shape) == 3
with logw('[Detection] read %s' % self.args.test_images_file):
self.test_images = utils.read_hdf5(self.args.test_images_file)
if len(self.test_images.shape) < 4:
self.test_images = numpy.expand_dims(self.test_images, axis=3)
with logw('[Detection] read %s' % self.args.train_codes_file):
self.train_codes = utils.read_hdf5(self.args.train_codes_file)
with logw('[Detection] read %s' % self.args.test_codes_file):
self.test_codes = utils.read_hdf5(self.args.test_codes_file)
with logw('[Detection] read %s' % self.args.test_theta_file):
self.test_theta = utils.read_hdf5(self.args.test_theta_file)
with logw('[Detection] read %s' % self.args.perturbations_file):
self.perturbations = utils.read_hdf5(self.args.perturbations_file)
assert len(self.perturbations.shape) == 3
with logw('[Detection] read %s' % self.args.success_file):
self.success = utils.read_hdf5(self.args.success_file)
with logw('[Detection] read %s' % self.args.accuracy_file):
self.accuracy = utils.read_hdf5(self.args.accuracy_file)
self.perturbations = numpy.swapaxes(self.perturbations, 0, 1)
num_attempts = self.perturbations.shape[1]
self.test_images = self.test_images[:self.perturbations.shape[0]]
self.train_images = self.nearest_neighbor_images[:self.perturbations.
shape[0]]
self.test_codes = self.test_codes[:self.perturbations.shape[0]]
self.accuracy = self.accuracy[:self.perturbations.shape[0]]
self.test_theta = self.test_theta[:self.perturbations.shape[0]]
self.perturbations = self.perturbations.reshape(
(self.perturbations.shape[0] * self.perturbations.shape[1],
self.perturbations.shape[2]))
self.success = numpy.swapaxes(self.success, 0, 1)
self.success = self.success.reshape(
(self.success.shape[0] * self.success.shape[1]))
self.accuracy = numpy.repeat(self.accuracy, num_attempts, axis=0)
self.test_images = numpy.repeat(self.test_images, num_attempts, axis=0)
self.train_images = numpy.repeat(self.train_images,
num_attempts,
axis=0)
self.test_codes = numpy.repeat(self.test_codes, num_attempts, axis=0)
self.test_theta = numpy.repeat(self.test_theta, num_attempts, axis=0)
max_samples = self.args.max_samples
self.success = self.success[:max_samples]
self.accuracy = self.accuracy[:max_samples]
self.perturbations = self.perturbations[:max_samples]
self.test_images = self.test_images[:max_samples]
self.train_images = self.train_images[:max_samples]
self.test_codes = self.test_codes[:max_samples]
self.test_theta = self.test_theta[:max_samples]
with logw('[Testing] read %s' % self.args.database_file):
database = utils.read_hdf5(self.args.database_file)
self.N_font = database.shape[0]
self.N_class = database.shape[1]
self.N_theta = self.test_theta.shape[1]
database = database.reshape((database.shape[0] * database.shape[1],
database.shape[2], database.shape[3]))
database = torch.from_numpy(database)
if self.args.use_gpu:
database = database.cuda()
database = torch.autograd.Variable(database, False)
self.model = models.AlternativeOneHotDecoder(
database, self.N_font, self.N_class, self.N_theta)
self.model.eval()
self.compute_images()
def attack(self):
"""
Test the model.
"""
assert self.model is not None
assert self.model.classifier.training is False
concatenate_axis = -1
if os.path.exists(self.args.perturbations_file) and os.path.exists(self.args.success_file):
self.original_perturbations = utils.read_hdf5(self.args.perturbations_file)
assert len(self.original_perturbations.shape) == 3, self.original_perturbations.shape
log('[Attack] read %s' % self.args.perturbations_file)
self.original_success = utils.read_hdf5(self.args.success_file)
log('[Attack] read %s' % self.args.success_file)
assert self.original_perturbations.shape[0] == self.original_success.shape[0]
assert self.original_perturbations.shape[1] == self.original_success.shape[1]
assert self.original_perturbations.shape[2] == self.test_theta.shape[1]
if self.original_perturbations.shape[1] <= self.args.max_samples and self.original_perturbations.shape[0] <= self.args.max_attempts:
log('[Attack] found %d attempts, %d samples, requested no more' % (self.original_perturbations.shape[0], self.original_perturbations.shape[1]))
return
elif self.original_perturbations.shape[0] == self.args.max_attempts or self.original_perturbations.shape[1] == self.args.max_samples:
if self.original_perturbations.shape[0] == self.args.max_attempts:
self.test_theta = self.test_theta[self.original_perturbations.shape[1]:]
self.test_fonts = self.test_fonts[self.original_perturbations.shape[1]:]
self.test_classes = self.test_classes[self.original_perturbations.shape[1]:]
self.args.max_samples = self.args.max_samples - self.original_perturbations.shape[1]
concatenate_axis = 1
log('[Attack] found %d attempts with %d perturbations, computing %d more perturbations' % (
self.original_perturbations.shape[0], self.original_perturbations.shape[1], self.args.max_samples))
elif self.original_perturbations.shape[1] == self.args.max_samples:
self.args.max_attempts = self.args.max_attempts - self.original_perturbations.shape[0]
concatenate_axis = 0
log('[Attack] found %d attempts with %d perturbations, computing %d more attempts' % (
self.original_perturbations.shape[0], self.original_perturbations.shape[1], self.args.max_attempts))
self.perturbations = numpy.zeros((self.args.max_attempts, self.args.max_samples, self.test_theta.shape[1]))
self.success = numpy.ones((self.args.max_attempts, self.args.max_samples), dtype=int) * -1
if self.args.attack.find('Batch') >= 0:
batch_size = min(self.args.batch_size, self.args.max_samples)
else:
batch_size = 1
objective = self.objective_class()
num_batches = int(math.ceil(self.args.max_samples/batch_size))
for i in range(num_batches):
if i*batch_size == self.args.max_samples:
break
i_start = i * batch_size
i_end = min((i + 1) * batch_size, self.args.max_samples)
batch_fonts = self.test_fonts[i_start: i_end]
batch_classes = self.test_classes[i_start: i_end]
batch_code = numpy.concatenate((common.numpy.one_hot(batch_fonts, self.N_font), common.numpy.one_hot(batch_classes, self.N_class)), axis=1).astype(numpy.float32)
batch_classes = common.torch.as_variable(batch_classes, self.args.use_gpu)
batch_inputs = common.torch.as_variable(self.test_theta[i_start: i_end], self.args.use_gpu)
batch_code = common.torch.as_variable(batch_code, self.args.use_gpu)
t = 0
# This basically allows to only optimize over theta, keeping the font/class code fixed.
self.model.decoder.set_code(batch_code)
while True and t < self.args.max_attempts:
attack = self.setup_attack(batch_inputs, batch_classes)
success, perturbations, probabilities, norm, _ = attack.run(objective)
assert not numpy.any(perturbations != perturbations), perturbations
# Note that we save the perturbed image, not only the perturbation!
perturbations = perturbations.reshape(batch_inputs.size()) # hack for when only one dimensional latent space is used!
self.perturbations[t][i_start: i_end] = perturbations + batch_inputs.cpu().numpy()
self.success[t][i_start: i_end] = success
t += 1
log('[Attack] %d: completed' % i)
if concatenate_axis >= 0:
if self.perturbations.shape[0] == self.args.max_attempts:
self.perturbations = numpy.concatenate((self.original_perturbations, self.perturbations), axis=concatenate_axis)
self.success = numpy.concatenate((self.original_success, self.success), axis=concatenate_axis)
log('[Attack] concatenated')
utils.write_hdf5(self.args.perturbations_file, self.perturbations)
log('[Attack] wrote %s' % self.args.perturbations_file)
utils.write_hdf5(self.args.success_file, self.success)
log('[Attack] wrote %s' % self.args.success_file)
def load_data_and_model(self):
"""
Load data and model.
"""
database = utils.read_hdf5(self.args.database_file).astype(
numpy.float32)
log('[Visualization] read %s' % self.args.database_file)
N_font = database.shape[0]
N_class = database.shape[1]
resolution = database.shape[2]
database = database.reshape((database.shape[0] * database.shape[1],
database.shape[2], database.shape[3]))
database = torch.from_numpy(database)
if self.args.use_gpu:
database = database.cuda()
database = torch.autograd.Variable(database, False)
self.test_images = utils.read_hdf5(self.args.test_images_file).astype(
numpy.float32)
if len(self.test_images.shape) < 4:
self.test_images = numpy.expand_dims(self.test_images, axis=3)
self.perturbations = utils.read_hdf5(
self.args.perturbations_file).astype(numpy.float32)
self.perturbations = numpy.swapaxes(self.perturbations, 0, 1)
log('[Visualization] read %s' % self.args.perturbations_file)
self.success = utils.read_hdf5(self.args.success_file)
self.success = numpy.swapaxes(self.success, 0, 1)
log('[Visualization] read %s' % self.args.success_file)
self.accuracy = utils.read_hdf5(self.args.accuracy_file)
log('[Visualization] read %s' % self.args.success_file)
self.test_theta = utils.read_hdf5(self.args.test_theta_file).astype(
numpy.float32)
self.test_theta = self.test_theta[:self.perturbations.shape[0]]
N_theta = self.test_theta.shape[1]
log('[Visualization] using %d N_theta' % N_theta)
log('[Visualization] read %s' % self.args.test_theta_file)
self.test_codes = utils.read_hdf5(self.args.test_codes_file).astype(
numpy.int)
self.test_codes = self.test_codes[:self.perturbations.shape[0]]
self.test_codes = self.test_codes[:, 1:3]
self.test_codes = numpy.concatenate(
(common.numpy.one_hot(self.test_codes[:, 0], N_font),
common.numpy.one_hot(self.test_codes[:, 1], N_class)),
axis=1).astype(numpy.float32)
log('[Attack] read %s' % self.args.test_codes_file)
image_channels = 1 if N_theta <= 7 else 3
network_units = list(map(int, self.args.network_units.split(',')))
log('[Visualization] using %d input channels' % image_channels)
self.classifier = models.Classifier(
N_class,
resolution=(image_channels, resolution, resolution),
architecture=self.args.network_architecture,
activation=self.args.network_activation,
batch_normalization=not self.args.network_no_batch_normalization,
start_channels=self.args.network_channels,
dropout=self.args.network_dropout,
units=network_units)
self.decoder = models.AlternativeOneHotDecoder(database, N_font,
N_class, N_theta)
self.decoder.eval()
assert os.path.exists(
self.args.classifier_file
), 'state file %s not found' % self.args.classifier_file
state = State.load(self.args.classifier_file)
log('[Visualization] read %s' % self.args.classifier_file)
self.classifier.load_state_dict(state.model)
if self.args.use_gpu and not cuda.is_cuda(self.classifier):
log('[Visualization] classifier is not CUDA')
self.classifier = self.classifier.cuda()
log('[Visualization] loaded classifier')
self.classifier.eval()
log('[Visualization] set classifier to eval')
