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)
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.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 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 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 attack(self):
"""
Test the model.
"""
assert self.model is not None
assert self.model.classifier.training is False
#assert self.model.decoder.training is False
batch_size = 1
objective = self.objective_class()
num_batches = int(math.ceil(self.args.max_samples / batch_size))
self.data = numpy.zeros((self.args.max_samples, 200, 2))
for i in range(num_batches):
i_start = i * batch_size
i_end = min((i + 1) * batch_size, self.args.max_samples)
batch_classes = common.torch.as_variable(
self.test_codes[i_start:i_end], self.args.use_gpu)
batch_theta = common.torch.as_variable(
numpy.zeros((batch_size, self.args.latent_space_size),
dtype=numpy.float32), self.args.use_gpu)
objective = self.objective_class()
self.model.decoder.set_code(batch_classes)
reference_logits = self.model.forward(batch_theta)
attack = self.setup_attack(batch_theta, batch_classes)
success, perturbations, _, _, _ = attack.run(objective)
steps = numpy.linspace(-1, 5, 200)
log('[Visualization] %d class=%d, predicted=%d' %
(i, batch_classes[0], torch.max(reference_logits, dim=1)[1]))
log('[Visualization] %d success=%d' % (i, success[0]))
for s in range(len(steps)):
step = steps[s]
batch_theta = common.torch.as_variable(
numpy.expand_dims(step *
perturbations[0].astype(numpy.float32),
axis=0), self.args.use_gpu)
output_images = self.model.decoder(batch_theta)
output_logits = self.model.classifier(output_images)
f = objective.f(output_logits, reference_logits, batch_classes)
#from matplotlib import pyplot
#pyplot.imshow(output_images[0, 0].cpu().detach().numpy())
#pyplot.show()
self.data[i, s, 0] = batch_theta[:, 5]
self.data[i, s, 1] = f.item()
log('[Visualization] %d step=%g, f=%g' % (i, step, f))
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 attack(self):
"""
Test the model.
"""
assert self.model is not None
assert self.model.classifier.training is False
#assert self.model.decoder.training is False
batch_size = 1
objective = self.objective_class()
num_batches = int(math.ceil(self.args.max_samples / batch_size))
self.data = numpy.zeros((self.args.max_samples, 200, 2))
for i in range(num_batches):
i_start = i * batch_size
i_end = min((i + 1) * batch_size, self.args.max_samples)
batch_classes = common.torch.as_variable(
self.test_codes[i_start:i_end], self.args.use_gpu)
batch_images = common.torch.as_variable(
numpy.expand_dims(self.test_images[i_start:i_end], axis=0),
self.args.use_gpu)
batch_theta = common.torch.as_variable(
numpy.zeros(
(batch_size, self.args.N_theta)).astype(numpy.float32),
self.args.use_gpu)
objective = self.objective_class()
self.model.decoder.set_image(batch_images)
reference_logits = self.model.forward(batch_theta)
log('[Visualization] %d class=%d, predicted=%d' %
(i, batch_classes[0], torch.max(reference_logits, dim=1)[1]))
rotations = numpy.linspace(self.min_bound[5], self.max_bound[5],
200)
for r in range(len(rotations)):
rotation = rotations[r]
batch_theta[:, 5] = rotation
output_images = self.model.decoder(batch_theta)
output_logits = self.model.classifier(output_images)
f = objective.f(output_logits, reference_logits, batch_classes)
#from matplotlib import pyplot
#pyplot.imshow(output_images[0, 0].cpu().numpy())
#pyplot.show()
self.data[i, r, 0] = batch_theta[:, 5]
self.data[i, r, 1] = f.item()
log('[Visualization] %d rotation=%g, f=%g' % (i, rotation, f))
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 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_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) <= 3:
self.test_images = numpy.expand_dims(self.test_images, axis=3)
log('[Testing] no color images, adjusted size')
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_theta = utils.read_hdf5(self.args.test_theta_file).astype(
numpy.float32)
log('[Testing] read %s' % self.args.test_theta_file)
self.train_theta = utils.read_hdf5(self.args.train_theta_file).astype(
numpy.float32)
log('[Testing] read %s' % self.args.train_theta_file)
self.test_codes = utils.read_hdf5(
self.args.test_codes_file).astype(int)
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.perturbation_theta = numpy.repeat(
self.test_theta[: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.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))
log('[Testing] read %s' % self.args.perturbations_file)
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)
database = utils.read_hdf5(self.args.database_file)
log('[Testing] read %s' % self.args.database_file)
self.N_font = database.shape[0]
self.N_class = database.shape[1]
N_theta = self.test_theta.shape[1]
log('[Testing] using %d N_theta' % N_theta)
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, N_theta)
self.model.eval()
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.perturbations_file):
self.perturbations = utils.read_hdf5(self.args.perturbations_file)
assert len(self.perturbations.shape) == 4
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.accuracy = self.accuracy[:self.perturbations.shape[0]]
self.perturbations = self.perturbations.reshape((self.perturbations.shape[0]*self.perturbations.shape[1], self.perturbations.shape[2], self.perturbations.shape[3]))
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)
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]
if self.args.mode == 'true':
assert self.args.database_file
assert self.args.test_codes_file
assert self.args.test_theta_file
self.test_codes = utils.read_hdf5(self.args.test_codes_file)
log('[Detection] read %s' % self.args.test_codes_file)
self.test_theta = utils.read_hdf5(self.args.test_theta_file)
log('[Detection] read %s' % self.args.test_theta_file)
self.test_codes = self.test_codes[:self.perturbations.shape[0]]
self.test_theta = self.test_theta[:self.perturbations.shape[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)
self.test_codes = self.test_codes[:max_samples]
self.test_theta = self.test_theta[:max_samples]
database = utils.read_hdf5(self.args.database_file)
log('[Detection] read %s' % 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()
log('[Detection] initialized decoder')
elif self.args.mode == 'appr':
assert self.args.decoder_files
assert self.args.test_codes_file
assert self.args.test_theta_file
self.test_codes = utils.read_hdf5(self.args.test_codes_file)
log('[Detection] read %s' % self.args.test_codes_file)
self.test_theta = utils.read_hdf5(self.args.test_theta_file)
log('[Detection] read %s' % self.args.test_theta_file)
self.test_codes = self.test_codes[:self.perturbations.shape[0]]
self.test_theta = self.test_theta[:self.perturbations.shape[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)
self.test_codes = self.test_codes[:max_samples]
self.test_theta = self.test_theta[:max_samples]
assert self.args.decoder_files
decoder_files = self.args.decoder_files.split(',')
for decoder_file in decoder_files:
assert os.path.exists(decoder_file), 'could not find %s' % decoder_file
resolution = [1 if len(self.test_images.shape) <= 3 else self.test_images.shape[3], self.test_images.shape[1], self.test_images.shape[2]]
decoder_units = list(map(int, self.args.decoder_units.split(',')))
if len(decoder_files) > 1:
log('[Detection] loading multiple decoders')
decoders = []
for i in range(len(decoder_files)):
decoder = models.LearnedDecoder(self.args.latent_space_size,
resolution=resolution,
architecture=self.args.decoder_architecture,
start_channels=self.args.decoder_channels,
activation=self.args.decoder_activation,
batch_normalization=not self.args.decoder_no_batch_normalization,
units=decoder_units)
state = State.load(decoder_files[i])
decoder.load_state_dict(state.model)
if self.args.use_gpu and not cuda.is_cuda(decoder):
decoder = decoder.cuda()
decoders.append(decoder)
decoder.eval()
log('[Detection] loaded %s' % decoder_files[i])
self.model = models.SelectiveDecoder(decoders, resolution=resolution)
else:
log('[Detection] loading one decoder')
decoder = models.LearnedDecoder(self.args.latent_space_size,
resolution=resolution,
architecture=self.args.decoder_architecture,
start_channels=self.args.decoder_channels,
activation=self.args.decoder_activation,
batch_normalization=not self.args.decoder_no_batch_normalization,
units=decoder_units)
state = State.load(decoder_files[0])
decoder.load_state_dict(state.model)
if self.args.use_gpu and not cuda.is_cuda(decoder):
decoder = decoder.cuda()
decoder.eval()
log('[Detection] read decoder')
self.model = decoder
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_theta = utils.read_hdf5(self.args.test_theta_file).astype(numpy.float32)
log('[Testing] read %s' % self.args.test_theta_file)
self.train_theta = utils.read_hdf5(self.args.train_theta_file).astype(numpy.float32)
log('[Testing] read %s' % self.args.train_theta_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]
assert not numpy.any(self.perturbations != self.perturbations), 'NaN in perturbations'
# First, repeat relevant data.
self.perturbation_theta = numpy.repeat(self.test_theta[: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))
log('[Testing] read %s' % self.args.perturbations_file)
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)
assert self.args.decoder_files
decoder_files = self.args.decoder_files.split(',')
for decoder_file in decoder_files:
assert os.path.exists(decoder_file), 'could not find %s' % decoder_file
log('[Testing] using %d input channels' % self.test_images.shape[3])
decoder_units = list(map(int, self.args.decoder_units.split(',')))
if len(decoder_files) > 1:
log('[Testing] loading multiple decoders')
decoders = []
for i in range(len(decoder_files)):
decoder = models.LearnedDecoder(self.args.latent_space_size, resolution=(self.test_images.shape[3], self.test_images.shape[1], self.test_images.shape[2]),
architecture=self.args.decoder_architecture,
start_channels=self.args.decoder_channels,
activation=self.args.decoder_activation,
batch_normalization=not self.args.decoder_no_batch_normalization,
units=decoder_units)
state = State.load(decoder_files[i])
decoder.load_state_dict(state.model)
if self.args.use_gpu and not cuda.is_cuda(decoder):
decoder = decoder.cuda()
decoders.append(decoder)
decoder.eval()
log('[Testing] loaded %s' % decoder_files[i])
self.model = models.SelectiveDecoder(decoders, resolution=(self.test_images.shape[3], self.test_images.shape[1], self.test_images.shape[2]))
else:
log('[Testing] loading one decoder')
decoder = models.LearnedDecoder(self.args.latent_space_size, resolution=(self.test_images.shape[3], self.test_images.shape[1], self.test_images.shape[2]),
architecture=self.args.decoder_architecture,
start_channels=self.args.decoder_channels,
activation=self.args.decoder_activation,
batch_normalization=not self.args.decoder_no_batch_normalization,
units=decoder_units)
state = State.load(decoder_files[0])
decoder.load_state_dict(state.model)
if self.args.use_gpu and not cuda.is_cuda(decoder):
decoder = decoder.cuda()
decoder.eval()
log('[Testing] read decoder')
self.model = decoder
def load_data(self):
"""
Load data.
"""
assert self.args.batch_size % 4 == 0
self.database = utils.read_hdf5(self.args.database_file).astype(
numpy.float32)
log('[Training] read %s' % self.args.database_file)
self.N_font = self.database.shape[0]
self.N_class = self.database.shape[1]
self.database = self.database.reshape(
(self.database.shape[0] * self.database.shape[1],
self.database.shape[2], self.database.shape[3]))
self.database = torch.from_numpy(self.database)
if self.args.use_gpu:
self.database = self.database.cuda()
self.database = torch.autograd.Variable(self.database, False)
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] == 3
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] == 3
log('[Training] read %s' % self.args.test_codes_file)
self.train_theta = utils.read_hdf5(self.args.train_theta_file).astype(
numpy.float32)
log('[Training] read %s' % self.args.train_theta_file)
self.min_bound = numpy.min(self.train_theta, axis=0)
self.max_bound = numpy.max(self.train_theta, axis=0)
self.test_theta = utils.read_hdf5(self.args.test_theta_file).astype(
numpy.float32)
log('[Training] read %s' % self.args.test_theta_file)
assert self.train_codes.shape[0] == self.train_images.shape[0]
assert self.test_codes.shape[0] == self.test_images.shape[0]
assert self.train_theta.shape[0] == self.train_images.shape[0]
assert self.test_theta.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])
log('[Training] found %d classes' % self.N_class)
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.args.label_index]
self.train_images = self.train_images[:self.train_images.shape[0] -
self.args.validation_samples]
self.train_codes = self.train_codes[: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
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]
self.train_theta = self.train_theta[perm]
else:
self.train_images = self.train_images[:self.args.training_samples]
self.train_codes = self.train_codes[:self.args.training_samples]
self.train_theta = self.train_theta[: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[:, self.args.label_index] == 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 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')
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.test_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.N_class = numpy.max(self.train_codes) + 1
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)
self.train_theta = utils.read_hdf5(self.args.train_theta_file).astype(
numpy.float32)
log('[Training] read %s' % self.args.train_theta_file)
assert self.test_images.shape[0] == self.test_codes.shape[0]
self.min_bound = numpy.min(self.train_theta, axis=0)
self.max_bound = numpy.max(self.train_theta, axis=0)
log('[Training] min bound: %s' % ' '.join(
['%g' % self.min_bound[i]
for i in range(self.min_bound.shape[0])]))
log('[Training] max bound: %s' % ' '.join(
['%g' % self.max_bound[i]
for i in range(self.max_bound.shape[0])]))
self.test_theta = utils.read_hdf5(self.args.test_theta_file).astype(
numpy.float32)
log('[Training] read %s' % self.args.test_theta_file)
assert self.train_codes.shape[0] == self.train_images.shape[0]
assert self.test_codes.shape[0] == self.test_images.shape[0]
assert self.train_theta.shape[
0] == self.train_images.shape[0], '%s != %s' % ('x'.join(
list(map(str, self.train_theta.shape))), 'x'.join(
list(map(str, self.train_images.shape))))
assert self.test_theta.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])
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
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]
self.train_theta = self.train_theta[perm]
else:
self.train_images = self.train_images[:self.args.training_samples]
self.train_codes = self.train_codes[:self.args.training_samples]
self.train_theta = self.train_theta[:self.args.training_samples]
self.train_valid = (numpy.max(numpy.abs(self.train_theta), axis=1) <=
self.args.bound).astype(int)
self.test_valid = (numpy.max(numpy.abs(self.test_theta), axis=1) <=
self.args.bound).astype(int)
# 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 load_data_and_model(self):
"""
Load data and model.
"""
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)
resolution = self.test_images.shape[2]
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]
N_class = numpy.max(self.test_codes) + 1
log('[Visualization] read %s' % self.args.test_codes_file)
self.perturbations = utils.read_hdf5(
self.args.perturbations_file).astype(numpy.float32)
if len(self.perturbations.shape) < 5:
self.perturbations = numpy.expand_dims(self.perturbations, axis=4)
self.perturbations = numpy.swapaxes(self.perturbations, 0, 1)
self.test_images = self.test_images[:self.perturbations.shape[0]]
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)
self.success = self.success >= 0
log('[Visualization] read %s' % self.args.success_file)
if self.args.selection_file:
selection = utils.read_hdf5(self.args.selection_file)
log('[Visualization] read %s' % self.args.selection_file)
selection = numpy.swapaxes(selection, 0, 1)
selection = selection[:self.success.shape[0]]
selection = selection >= 0
assert len(selection.shape) == len(self.success.shape)
self.success = numpy.logical_and(self.success, selection)
log('[Visualization] updated selection')
self.accuracy = utils.read_hdf5(self.args.accuracy_file)
log('[Visualization] read %s' % self.args.success_file)
log('[Visualization] using %d input channels' %
self.test_images.shape[3])
network_units = list(map(int, self.args.network_units.split(',')))
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.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.model.load_state_dict(state.model)
if self.args.use_gpu and not cuda.is_cuda(self.model):
log('[Visualization] classifier is not CUDA')
self.model = self.model.cuda()
log('[Visualization] loaded classifier')
self.model.eval()
log('[Visualization] set model to eval')
def load_data_and_model(self):
"""
Load data and model.
"""
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)
resolution = (self.test_images.shape[3], self.test_images.shape[1],
self.test_images.shape[2])
log('[Visualization] read %s' % self.args.test_images_file)
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]]
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.args.label_index]
self.N_class = numpy.max(self.test_codes) + 1
self.test_codes = self.test_codes[:self.perturbations.shape[0]]
log('[Visualization] read %s' % self.args.test_codes_file)
network_units = list(map(int, self.args.network_units.split(',')))
self.classifier = models.Classifier(
self.N_class,
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('[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')
assert self.args.decoder_files
decoder_files = self.args.decoder_files.split(',')
for decoder_file in decoder_files:
assert os.path.exists(
decoder_file), 'could not find %s' % decoder_file
log('[Visualization] using %d input channels' %
self.test_images.shape[3])
decoder_units = list(map(int, self.args.decoder_units.split(',')))
if len(decoder_files) > 1:
log('[Visualization] loading multiple decoders')
decoders = []
for i in range(len(decoder_files)):
decoder = models.LearnedDecoder(
self.args.latent_space_size,
resolution=resolution,
architecture=self.args.decoder_architecture,
start_channels=self.args.decoder_channels,
activation=self.args.decoder_activation,
batch_normalization=not self.args.
decoder_no_batch_normalization,
units=decoder_units)
state = State.load(decoder_files[i])
decoder.load_state_dict(state.model)
if self.args.use_gpu and not cuda.is_cuda(decoder):
decoder = decoder.cuda()
decoders.append(decoder)
decoder.eval()
log('[Visualization] loaded %s' % decoder_files[i])
self.decoder = models.SelectiveDecoder(decoders,
resolution=resolution)
else:
log('[Visualization] loading one decoder')
decoder = models.LearnedDecoder(
self.args.latent_space_size,
resolution=resolution,
architecture=self.args.decoder_architecture,
start_channels=self.args.decoder_channels,
activation=self.args.decoder_activation,
batch_normalization=not self.args.
decoder_no_batch_normalization,
units=decoder_units)
state = State.load(decoder_files[0])
decoder.load_state_dict(state.model)
if self.args.use_gpu and not cuda.is_cuda(decoder):
decoder = decoder.cuda()
decoder.eval()
log('[Visualization] read decoder')
self.decoder = decoder
