def get_ranks(args):
# Load the data and make it global
global x_attack, y_attack, dk_plain, key_guesses
x_attack, y_attack, key_guesses, real_key, dk_plain = load_data(args)
model_params = {}
map_accuracy = {}
folder = "{}/{}/".format(args.models_path, generate_folder_name(args))
model_params.update({"max_pool": args.max_pool})
for channel_size in args.channels:
model_params.update({"channel_size": channel_size})
for layers in args.layers:
model_params.update({"num_layers": layers})
for kernel in args.kernels:
model_params.update({"kernel_size": kernel})
# Calculate the accuracy
mean_acc = 0.0
no_data = False
for run in range(args.runs):
model_path = '{}/model_r{}_{}.pt'.format(
folder,
run,
get_save_name(args.network_name, model_params))
if not os.path.exists(model_path):
print(util.BColors.WARNING + f"Path {model_path} does not exists" + util.BColors.ENDC)
no_data = True
break
print('path={}'.format(model_path))
model = load_model(args.network_name, model_path)
model.eval()
print("Using {}".format(model))
model.to(args.device)
# Calculate predictions
if require_domain_knowledge(args.network_name):
_, acc = accuracy2(model, x_attack, y_attack, dk_plain)
else:
_, acc = accuracy2(model, x_attack, y_attack, None)
print('Accuracy: {} - {}%'.format(acc, acc * 100))
acc = acc * 100
mean_acc = mean_acc + acc
if not no_data:
mean_acc = mean_acc / float(args.runs)
map_accuracy.update({f"c_{channel_size}_l{layers}_k{kernel}": mean_acc})
print(util.BColors.WARNING + f"Mean accuracy {mean_acc}" + util.BColors.ENDC)
if args.noise_level >= 0:
acc_filename = f"{folder}/acc_{args.network_name}_noise{args.noise_level}.json"
else:
acc_filename = f"{folder}/acc_{args.network_name}.json"
print(acc_filename)
with open(acc_filename, "w") as acc_file:
acc_file.write(json.dumps(map_accuracy))
def get_ranks(args, network_name, model_params):
# Load the data and make it global
global x_attack, y_attack, dk_plain, key_guesses
x_attack, y_attack, key_guesses, real_key, dk_plain = load_data(
args, network_name)
folder = "{}/{}/".format(args.models_path, generate_folder_name(args))
# Calculate the predictions before hand
predictions = []
for run in args.runs:
model_path = '{}/model_r{}_{}.pt'.format(
folder, run, get_save_name(network_name, model_params))
print('path={}'.format(model_path))
model = load_model(network_name, model_path)
model.eval()
print("Using {}".format(model))
model.to(args.device)
# Calculate predictions
if require_domain_knowledge(network_name):
prediction = accuracy(model, x_attack, y_attack, dk_plain)
predictions.append(prediction.cpu().numpy())
else:
prediction = accuracy(model, x_attack, y_attack, None)
predictions.append(prediction.cpu().numpy())
# Check if it is only one run, if so don't do multi threading
if len(args.runs) == 1:
threaded_run_test(args, predictions[0], folder, args.runs[0],
network_name, model_params, real_key)
else:
# Start a thread for each run
processes = []
for i, run in enumerate(args.runs):
p = Process(target=threaded_run_test,
args=(args, predictions[i], folder, run, network_name,
model_params, real_key))
processes.append(p)
p.start()
# Wait for them to finish
for p in processes:
p.join()
print('Joined process')
def get_ranks(x_attack, y_attack, key_guesses, real_key, runs, train_size,
epochs, lr, sub_key_index, attack_size, network_name, batch_size,
spread_factor, use_hw, data_set_name):
ranks_x = []
ranks_y = []
for run in runs:
model_path = '/media/rico/Data/TU/thesis/runs2/' \
'{}/subkey_{}/{}_SF{}_E{}_BZ{}_LR{}/train{}/model_r{}_{}.pt'.format(
data_set_name,
sub_key_index,
'HW' if use_hw else 'ID',
spread_factor,
epochs,
batch_size,
'%.2E' % Decimal(lr),
train_size,
run,
network_name
)
print('path={}'.format(model_path))
# Load the model
model = load_model(network_name=network_name, model_path=model_path)
print("Using {}".format(model))
model.to(device)
# permutation = np.random.permutation(x_attack.shape[0])
# x_attack = shuffle_permutation(permutation, np.array(x_attack))
# y_attack = shuffle_permutation(permutation, np.array(y_attack))
x, y = test_with_key_guess(x_attack,
y_attack,
key_guesses,
model,
attack_size=attack_size,
real_key=real_key,
use_hw=use_hw)
# Add the ranks
ranks_x.append(x)
ranks_y.append(y)
return ranks_x, ranks_y
def get_ranks(args, network_name, model_params, edit_model=disable_filter):
folder = "{}/{}/".format(args.models_path, generate_folder_name(args))
# Calculate the predictions before hand
# TODO: for multiple runs
model_path = '{}/model_r{}_{}.pt'.format(
folder, args.run, get_save_name(network_name, model_params))
print('path={}'.format(model_path))
if not os.path.exists(f"{model_path}.predictions1.npy"):
# Load the data and make it global
global x_attack, y_attack, dk_plain, key_guesses
x_attack, y_attack, key_guesses, real_key, dk_plain = load_data(
args, network_name)
model = load_model(network_name, model_path)
model.eval()
model.to(args.device)
predictions, correct_indices, sum_indices = edit_model(model)
np_predictions = np.array(predictions)
np_correct_indices = np.array(correct_indices)
np_sum_indices = np.array(sum_indices)
np.save(f"{model_path}.predictions1", np_predictions)
np.save(f"{model_path}.correct_indices", np_correct_indices)
np.save(f"{model_path}.sum_indices", np_sum_indices)
print(sum_indices)
else:
predictions = np.load(f"{model_path}.predictions1.npy")
real_key = util.load_csv('{}/{}/secret_key.csv'.format(
args.traces_path, str(load_args.data_set)),
dtype=np.int)
key_guesses = util.load_csv(
'{}/{}/Value/key_guesses_ALL_transposed.csv'.format(
args.traces_path, str(load_args.data_set)),
delimiter=' ',
dtype=np.int,
start=load_args.train_size + load_args.validation_size,
size=load_args.attack_size)
# Start a thread for each prediction
groups_of = 7
for k in range(math.ceil(len(predictions) / float(groups_of))):
# Start groups of processes
processes = []
for i in range(k * groups_of, (k + 1) * groups_of, 1):
if i >= len(predictions):
break
print(f"i: {i}")
p = Process(target=threaded_run_test,
args=(args, predictions[i], folder, args.run,
network_name, model_params, real_key, i))
processes.append(p)
p.start()
# Wait for the processes to finish
for p in processes:
p.join()
print('Joined process')
def model_predict(data_loader, data_set, cls_number=17, model_times=0):
model,_ = load_model(model_name=opt.model,resume=opt.resume,start_epoch=opt.start_epoch,cn=opt.cn, \
save_dir=opt.save_dir,width=opt.width,start=opt.start,cls_number=cls_number, \
avg_number=opt.avg_number,gpus=opt.gpus,model_times=model_times,kfold=opt.kfold,train=False)
model.eval()
criterion = CrossEntropyLoss()
test_size = ceil(len(data_set['test']) / data_loader['test'].batch_size)
test_preds = np.zeros((len(data_set['test'])), dtype=np.int8)
raw_results = []
true_label = np.zeros((len(data_set['test'])), dtype=np.int)
idx = 0
test_loss = 0
test_corrects = 0
for batch_cnt_test, data_test in enumerate(data_loader['test']):
# print data
if batch_cnt_test % 100 == 2:
print("{0}/{1}".format(batch_cnt_test, int(test_size)))
inputs, labels = data_test
#print (inputs.size())
inputs = Variable(inputs.cuda())
labels = Variable(torch.from_numpy(np.array(labels)).long().cuda())
# forward
if opt.crop_five > 1 and opt.cn == 3:
#print inputs.size()
bs, ncrops, c, h, w = inputs.size()
result = model(inputs.view(-1, c, h, w))
outputs = result.view(bs, ncrops, -1).mean(1)
elif opt.crop_five > 1 and opt.cn > 3:
bs, CC, h, w = inputs.size()
ncrops = CC // opt.cn
result = model(inputs.view(-1, opt.cn, h, w))
outputs = result.view(bs, ncrops, -1).mean(1)
elif opt.crop_five == 1:
outputs = model(inputs)
#print(outputs.size())
#continue
# statistics
if isinstance(outputs, list):
loss = criterion(outputs[0], labels)
loss += criterion(outputs[1], labels)
outputs = (outputs[0] + outputs[1]) / 2
else:
loss = criterion(outputs, labels)
_, preds = torch.max(outputs, 1)
test_loss += loss.item()
#test_loss += loss.data[0]
batch_corrects = torch.sum((preds == labels)).item()
#batch_corrects = torch.sum((preds == labels)).data[0]
test_corrects += batch_corrects
raw_result = [prob.tolist() for prob in outputs.data]
raw_results += raw_result
test_preds[idx:(idx + labels.size(0))] = preds.cpu().numpy()
true_label[idx:(idx + labels.size(0))] = labels.data.cpu().numpy()
# statistics
idx += labels.size(0)
test_loss = test_loss / test_size
test_acc = 1.0 * test_corrects / len(data_set['test'])
test_probs = np.array(raw_results)
#print test_probs.shape
np.save(
'analysis_result/test_probs_' + str(opt.model) + '_' + str(opt.width) +
'_' + str(opt.batchsize), test_probs)
print('test-loss: %.4f ||test-acc@1: %.4f' % (test_loss, test_acc))
return test_preds, test_probs
def run_prediction(filename, output = None, modelTag = 993, viterbi = False, outFormat = 'csv', FULLCONV = True,
verbose = True, plot = False):
"""
Collect the sound files to process and run the prediction on each file
Parameters
----------
filename : list
List containing paths to sound files (wav or aiff) or folders containing sound files to
be analyzed.
output : str or None
Path to directory for saving output files. If None, output files will
be saved to the directory containing the input file.
model : model to be used for prediction with pre-loaded weights
viterbi : bool
Apply viterbi smoothing to the estimated pitch curve. False by default.
save_activation : bool
Save the output activation matrix to an .npy file. False by default.
save_plot: bool
Save a plot of the output activation matrix to a .png file. False by
default.
plot_voicing : bool
Include a visual representation of the voicing activity detection in
the plot of the output activation matrix. False by default, only
relevant if save_plot is True.
verbose : bool
Print status messages and keras progress (default=True).
"""
# load model:
load_from_json = False
if(modelTag == 'CREPE'):
load_from_json = True
if(load_from_json):
model = load_model(modelTag, from_json=True)
else:
model = load_model(modelTag, FULLCONV = FULLCONV)
files = []
for path in filename:
if os.path.isdir(path):
found = ([file for file in os.listdir(path) if
(file.lower().endswith('.wav') or file.lower().endswith('.aiff') or file.lower().endswith('.aif'))])
if len(found) == 0:
print('FCN-f0: No sound files (only wav or aiff supported) found in directory {}'.format(path),
file=sys.stderr)
files += [os.path.join(path, file) for file in found]
elif os.path.isfile(path):
if not (path.lower().endswith('.wav') or path.lower().endswith('.aiff') or path.lower().endswith('.aif')):
print('FCN-f0: Expecting sound file(s) (only wav or aiff supported) but got {}'.format(path),
file=sys.stderr)
else:
files.append(path)
else:
print('FCN-f0: File or directory not found: {}'.format(path),
file=sys.stderr)
if len(files) == 0:
print('FCN-f0: No sound files found in {} (only wav or aiff supported), aborting.'.format(filename))
sys.exit(-1)
for i, file in enumerate(files):
if verbose:
print('FCN-f0: Processing {} ... ({}/{})'.format(
file, i+1, len(files)), file=sys.stderr)
run_prediction_on_file(file, output=output, model=model, modelTag=modelTag, viterbi=viterbi,
outFormat=outFormat, FULLCONV=FULLCONV, plot=plot, verbose=verbose)
return
batch_size=batch_size,
shuffle=True,
num_workers=8)
dataloader['val'] = torch.utils.data.DataLoader(valid_dataset,
batch_size=batch_size,
shuffle=False,
num_workers=8)
####print the mean and std of dataset
#print (get_mean_and_std(train_dataset,cn=opt.cn))
#print (get_mean_and_std(valid_dataset,cn=opt.cn))
model, start_epoch = load_model(model_name=opt.model,
resume=opt.resume,
start_epoch=opt.start_epoch,
cn=opt.cn,
save_dir=opt.save_dir,
width=opt.width,
start=opt.start,
cls_number=cls_number,
avg_number=opt.avg_number)
base_lr = 0.001
weight_decay = 1e-4
load_model_flag = False
if load_model_flag:
conv1_params = list(map(id, model.conv1.parameters()))
fc_params = list(map(id, model.fc.parameters()))
base_params = filter(lambda p: id(p) not in conv1_params + fc_params,
model.parameters())
optimizer = optim.Adam([{'params': base_params},{'params': model.conv1.parameters(), 'lr': base_lr * 10}, \
{'params': model.fc.parameters(), 'lr': base_lr * 10}
from utils import pose_utils as util
import torch
import numpy as np
from tqdm import tqdm
from imageio import get_writer
from skimage.io import imsave
opt = Options().parse(save=False)
opt.nThreads = 1 # test code only supports nThreads = 1
opt.batchSize = 1 # test code only supports batchSize = 1
opt.serial_batches = True # no shuffle
opt.no_flip = True # no flip
opt.use_first_frame = False #??
dataset = load_dataset(opt) #CreateDataset(opt)
model = load_model(opt) #create_model(opt)
data = dataset[0]
prev_frame = torch.zeros_like(data['image'])
start_from = 0
generated = []
for i in tqdm(range(start_from, dataset.clip_length)):
label = data['label'][i:i + 1]
inst = None if opt.no_instance else data['inst'][i:i + 1]
cur_frame = model.inference(label, inst, torch.unsqueeze(prev_frame,
dim=0))
prev_frame = cur_frame.data[0]
imsave('./datasets/cardio_dance_test/test_sync/{:05d}.png'.format(i),
def train_main(x_train,x_test,y_train,y_test,model_times=0):
if opt.process:
#x_train = x_train[:1000]
#x_test = x_test[:100]
print np.mean(x_train),np.mean(x_test),np.min(x_train),np.min(x_test),np.max(x_train),np.max(x_test)
x_train,x_test = process_data(x_train,x_test)
print np.mean(x_train),np.mean(x_test),np.min(x_train),np.min(x_test),np.max(x_train),np.max(x_test)
if opt.cn == 3:
data_transforms = {
'train' : transforms.Compose([
transforms.ToPILImage(),
transforms.RandomRotation(degrees=45,resample=Image.BICUBIC),
#transforms.RandomRotation(degrees=30,resample=Image.BICUBIC),
transforms.RandomHorizontalFlip(),
transforms.RandomVerticalFlip(),
#transforms.ColorJitter(brightness=0.2,contrast=0.2,saturation=0.2, hue=0.2),
transforms.RandomResizedCrop(target_size,scale=(0.64,1.0)),
#transforms.RandomResizedCrop(target_size,scale=(0.36,1.0)),
transforms.ToTensor(),
#transforms.Normalize(mean = (0.485, 0.456, 0.406), std = (0.229, 0.224, 0.225))
]),
'val': transforms.Compose([
transforms.ToPILImage(),
#transforms.Resize(org_size),
#transforms.CenterCrop(target_size),
transforms.ToTensor(),
#transforms.Normalize(mean = (0.485, 0.456, 0.406), std = (0.229, 0.224, 0.225))
])
}
else:
data_transforms = {
'train' : Compose([
#RandomRotate((0,45),bound=True),
RandomRotate((0,45)),
RandomHVShift(),
RandomHflip(),
RandomVflip(),
RandomErasing(),
#Resize((target_size,target_size)),
RandomResizedCrop((target_size,target_size)),
#Normalize()
]),
'val': Compose([
Resize((target_size,target_size)),
#Normalize()
#CenterCrop((target_size,target_size)),
])
}
#traindir = r'/media/disk1/fordata/web_server/multiGPU/cccccc/cloud/train/' ##train_dir
#train_dataset = datasets.ImageFolder(traindir,data_transforms['train'])
#test_dataset = datasets.ImageFolder(traindir,data_transforms['val'])
train_x = torch.stack([torch.Tensor(i) for i in x_train])
train_y = torch.Tensor(y_train)
#train_y = torch.stack([torch.Tensor(i) for i in y_train])
val_x = torch.stack([torch.Tensor(i) for i in x_test])
val_y = torch.Tensor(y_test)
#val_y = torch.stack([torch.Tensor(i) for i in y_test])
#train_dataset = torch.utils.data.TensorDataset(train_x,train_y)
#valid_dataset = torch.utils.data.TensorDataset(val_x,val_y)
train_dataset = myTensorDataset(train_x,train_y,data_transforms['train'])
valid_dataset = myTensorDataset(val_x,val_y,data_transforms['val'])
data_set = {}
data_set['train'] = train_dataset
data_set['val'] = valid_dataset
dataloader = {}
dataloader['train'] = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size,
shuffle=True, num_workers=16)
dataloader['val'] = torch.utils.data.DataLoader(valid_dataset, batch_size=batch_size,
shuffle=False, num_workers=16)
####print the mean and std of dataset
#print (get_mean_and_std(train_dataset,cn=opt.cn))
#print (get_mean_and_std(valid_dataset,cn=opt.cn))
model,start_epoch = load_model(model_name=opt.model,resume=opt.resume,start_epoch=opt.start_epoch,cn=opt.cn, \
save_dir=opt.save_dir,width=opt.width,start=opt.start,cls_number=cls_number,avg_number=opt.avg_number, \
gpus=opt.gpus,model_times=model_times,kfold=opt.kfold)
base_lr = opt.baselr
weight_decay = opt.wd
load_model_flag = False
if load_model_flag:
conv1_params = list(map(id, model.conv1.parameters()))
fc_params = list(map(id, model.fc.parameters()))
base_params = filter(lambda p: id(p) not in conv1_params + fc_params,model.parameters())
optimizer = optim.Adam([{'params': base_params},{'params': model.conv1.parameters(), 'lr': base_lr * 10}, \
{'params': model.fc.parameters(), 'lr': base_lr * 10}
], lr=base_lr, weight_decay=weight_decay, amsgrad=True)
else:
#optimizer = optim.Adam(model.parameters(), lr=base_lr, weight_decay=weight_decay, amsgrad=True)
if opt.optimizer == 'Adam':
optimizer = optim.Adam(model.parameters(), lr=base_lr, weight_decay=weight_decay, amsgrad=True)
elif opt.optimizer == 'SGD':
optimizer = optim.SGD(model.parameters(), lr=base_lr, weight_decay=weight_decay,momentum=0.9)
criterion = CrossEntropyLoss()
exp_lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=15, gamma=0.33)
#exp_lr_scheduler = lr_scheduler.ReduceLROnPlateau(optimizer,mode='min',factor=0.5,patience=4)
#exp_lr_scheduler = lr_scheduler.MultiStepLR(optimizer, milestones = [10,20,30,40], gamma=0.1)
#exp_lr_scheduler = lr_scheduler.CosineAnnealingLR(optimizer,T_max=5,eta_min=4e-08)
iter_per_epoch = len(data_set['train']) // opt.batchsize
#print (iter_per_epoch)
model_name = opt.model + '_' + str(opt.width) + '_' + str(opt.start) + '_' + str(opt.cn)
if opt.kfold > 1:
model_name = str(model_times) + '_' + model_name
train(model,
model_name=model_name,
end_epoch=opt.end_epoch,
start_epoch=start_epoch,
optimizer=optimizer,
criterion=criterion,
exp_lr_scheduler=exp_lr_scheduler,
data_set=data_set,
data_loader=dataloader,
save_dir=opt.save_dir,
cls_number=cls_number,
print_inter=iter_per_epoch // 4,
val_inter=iter_per_epoch,
mixup=opt.mixup,
label_smoothing=opt.label_smoothing,
focal_loss=opt.focal_loss
)
torch.cuda.empty_cache()
"train_size": 1000,
"kernel_size": 20,
"num_layers": 2,
"channel_size": 16,
"network_name": "SpreadV3", #""DenseNorm",
"init_weights": "",
"run": 0
}
args = util.EmptySpace()
for key, value in settings.items():
setattr(args, key, value)
folder = "/media/rico/Data/TU/thesis/runs{}/{}".format(args.experiment, util.generate_folder_name(args))
filename = folder + f"/model_r{args.run}_" + util_classes.get_save_name(args.network_name, settings) + ".pt"
model = load_model(args.network_name, filename)
print(model)
x_test, _, _, _, _ = util.load_ascad_test_traces({
"sub_key_index": 2,
"desync": 0,
"traces_path": "/media/rico/Data/TU/thesis/data",
"unmask": args.unmask,
"use_hw": args.use_hw
})
x_test = x_test
print(f"Shape x_test {np.shape(x_test)}")
x_test = torch.from_numpy(x_test.astype(np.float32)).to(util.device)
def get_ranks(use_hw,
runs,
train_size,
epochs,
lr,
sub_key_index,
attack_size,
rank_step,
unmask,
network_name,
kernel_size_string=""):
ranks_x = []
ranks_y = []
(_, _), (x_attack,
y_attack), (metadata_profiling,
metadata_attack) = load_ascad(trace_file,
load_metadata=True)
key_guesses = util.load_csv(
'/media/rico/Data/TU/thesis/data/ASCAD/key_guesses.csv',
delimiter=' ',
dtype=np.int,
start=0,
size=attack_size)
x_attack = x_attack[:attack_size]
y_attack = y_attack[:attack_size]
if unmask:
if use_hw:
y_attack = np.array([
y_attack[i] ^ metadata_attack[i]['masks'][0]
for i in range(len(y_attack))
])
else:
y_attack = np.array([
util.HW[y_attack[i] ^ metadata_attack[i]['masks'][0]]
for i in range(len(y_attack))
])
real_key = metadata_attack[0]['key'][sub_key_index]
for run in runs:
folder = '/media/rico/Data/TU/thesis/runs2/{}/subkey_{}/{}{}{}_SF{}_' \
'E{}_BZ{}_LR{}/train{}/'.format(
str(data_set),
sub_key_index,
'' if unmask else 'masked/',
'' if desync is 0 else 'desync{}/'.format(desync),
type_network,
spread_factor,
epochs,
batch_size,
'%.2E' % Decimal(lr),
train_size)
model_path = '{}/model_r{}_{}{}.pt'.format(folder, run, network_name,
kernel_size_string)
print('path={}'.format(model_path))
model = load_model(network_name, model_path)
model.eval()
print("Using {}".format(model))
model.to(device)
# Load additional plaintexts
dk_plain = None
if network_name in req_dk:
dk_plain = metadata_attack[:]['plaintext'][:, sub_key_index]
dk_plain = hot_encode(dk_plain,
9 if use_hw else 256,
dtype=np.float)
# Calculate predictions
predictions = accuracy(model, x_attack, y_attack, dk_plain)
predictions = predictions.cpu().numpy()
x, y = [], []
for exp_i in range(num_exps):
permutation = permutations[exp_i]
# Shuffle data
predictions_shuffled = shuffle_permutation(permutation,
np.array(predictions))
key_guesses_shuffled = shuffle_permutation(permutation,
key_guesses)
# Test the data
x_exp, y_exp = test_with_key_guess_p(key_guesses_shuffled,
predictions_shuffled,
attack_size=attack_size,
real_key=real_key,
use_hw=use_hw)
x = x_exp
y.append(y_exp)
# Calculate the mean over the experimentfs
y = np.mean(y, axis=0)
util.save_np('{}/model_r{}_{}{}.exp'.format(folder, run, network_name,
kernel_size_string),
y,
f="%f")
if isinstance(model, SpreadNetIn):
# Get the intermediate values right after the first fully connected layer
z = np.transpose(model.intermediate_values2[0])
# Calculate the mse for the maximum and minimum from these traces and the learned min and max
min_z = np.min(z, axis=1)
max_z = np.max(z, axis=1)
msq_min = np.mean(np.square(min_z - model.tensor_min), axis=None)
msq_max = np.mean(np.square(max_z - model.tensor_max), axis=None)
print('msq min: {}'.format(msq_min))
print('msq max: {}'.format(msq_max))
# Plot the distribution of each neuron right after the first fully connected layer
for k in [50]:
plt.grid(True)
plt.axvline(x=model.tensor_min[k], color='green')
plt.axvline(x=model.tensor_max[k], color='green')
plt.hist(z[:][k], bins=40)
plt.show()
exit()
# Retrieve the intermediate values right after the spread layer,
# and order them such that each 6 values after each other belong to the neuron of the
# previous layer
v = model.intermediate_values
order = [
int((x % spread_factor) * 100 + math.floor(x / spread_factor))
for x in range(spread_factor * 100)
]
inter = []
for x in range(len(v[0])):
inter.append([v[0][x][j] for j in order])
# Calculate the standard deviation of each neuron in the spread layer
std = np.std(inter, axis=0)
threshold = 1.0 / attack_size * 10
print("divby: {}".format(threshold))
res = np.where(std < threshold, 1, 0)
# Calculate the mean of each neuron in the spread layer
mean_res = np.mean(inter, axis=0)
# mean_res2 = np.where(mean_res < threshold, 1, 0)
mean_res2 = np.where(mean_res == 0.0, 1, 0)
print('Sum std results {}'.format(np.sum(res)))
print('Sum mean results {}'.format(np.sum(mean_res2)))
# Check which neurons have a std and mean where it is smaller than threshold
total_same = 0
for j in range(len(mean_res2)):
if mean_res2[j] == 1 and res[j] == 1:
total_same += 1
print('Total same: {}'.format(total_same))
# Plot the standard deviations
plt.title('Comparison of networks')
plt.xlabel('#neuron')
plt.ylabel('std')
xcoords = [j * spread_factor for j in range(100)]
for xc in xcoords:
plt.axvline(x=xc, color='green')
plt.grid(True)
plt.plot(std, label='std')
plt.figure()
# Plot the means
plt.title('Performance of networks')
plt.xlabel('#neuron')
plt.ylabel('mean')
for xc in xcoords:
plt.axvline(x=xc, color='green')
plt.grid(True)
plt.plot(mean_res, label='mean')
plt.legend()
plt.show()
ranks_x.append(x)
ranks_y.append(y)
return ranks_x, ranks_y
'' if args['desync'] is 0 else 'desync{}/'.format(args['desync']),
args['type_network'],
args['spread_factor'],
args['epochs'],
args['batch_size'],
'%.2E' % Decimal(args['lr']),
args['train_size'])
# Calculate the predictions before hand
predictions = []
for run in args['runs']:
model_path = '{}/model_r{}_{}.pt'.format(
folder, run, get_save_name(network_name, model_params))
print('path={}'.format(model_path))
model = load_model(network_name, model_path)
variables = ["conv1", "conv2", "conv3"]
for var in variables:
weights = model.__getattr__(var).weight.data.cpu().numpy()
ones = np.ones(np.shape(weights))
zeros = np.zeros(np.shape(weights))
plus = np.where(weights < THRESHOLD, ones, zeros)
minus = np.where(-THRESHOLD < weights, ones, zeros)
z = plus + minus
res = np.where(z == 2, ones, zeros)
# print(res)
count = np.sum(res, axis=2)
# ones = np.ones(np.shape(res))
def get_ranks(x_attack,
y_attack,
key_guesses,
runs,
train_size,
epochs,
lr,
sub_key_index,
attack_size,
rank_step,
unmask,
network_name,
kernel_size_string=""):
ranks_x = []
ranks_y = []
for run in runs:
model_path = '/media/rico/Data/TU/thesis/runs2/' \
'{}/subkey_{}/{}_SF{}_E{}_BZ{}_LR{}/train{}/model_r{}_{}{}.pt'.format(
data_set_name,
sub_key_index,
type_network,
spread_factor,
epochs,
batch_size,
'%.2E' % Decimal(lr),
train_size,
run,
network_name,
kernel_size_string)
print('path={}'.format(model_path))
# Load the model
model = load_model(network_name=network_name, model_path=model_path)
model.eval()
print("Using {}".format(model))
model.to(device)
# Number of times we test a single model + shuffle the test traces
num_exps = 100
x, y = [], []
for exp_i in range(num_exps):
permutation = np.random.permutation(x_attack.shape[0])
# permutation = np.arange(0, x_attack.shape[0])
x_attack_shuffled = util.shuffle_permutation(
permutation, np.array(x_attack))
y_attack_shuffled = util.shuffle_permutation(
permutation, np.array(y_attack))
key_guesses_shuffled = util.shuffle_permutation(
permutation, key_guesses)
# Check if we need domain knowledge
dk_plain = None
if network_name in util.req_dk:
dk_plain = plain
dk_plain = util.shuffle_permutation(permutation, dk_plain)
x_exp, y_exp = test_with_key_guess(x_attack_shuffled,
y_attack_shuffled,
key_guesses_shuffled,
model,
attack_size=attack_size,
real_key=real_key,
use_hw=use_hw,
plain=dk_plain)
x = x_exp
y.append(y_exp)
# Take the mean of the different experiments
y = np.mean(y, axis=0)
# Add the ranks
ranks_x.append(x)
ranks_y.append(y)
return ranks_x, ranks_y
from data.load_data import load_dataset
from models.load_model import load_model
import util.util as util
import torch
from imageio import get_writer
import numpy as np
from tqdm import tqdm
opt = DemoTestOptions().parse(save=False)
opt.nThreads = 1 # test code only supports nThreads = 1
opt.batchSize = 1 # test code only supports batchSize = 1
opt.serial_batches = True # no shuffle
opt.no_flip = True # no flip
dataset = load_dataset(opt)
model = load_model(opt)
#if opt.verbose: # demo changed
# print(model)
# test whole video sequence
# 20181009: do we use first frame as input?
data = dataset[0]
#if opt.use_first_frame: # demo changed
# prev_frame = data['image']
# start_from = 1
# from skimage.io import imsave
# imsave('results/ref.png', util.tensor2im(prev_frame))
# generated = [util.tensor2im(prev_frame)]
if 1: #else:
prev_frame = torch.zeros_like(data['image'])
def get_ranks(use_hw,
runs,
train_size,
epochs,
lr,
sub_key_index,
attack_size,
rank_step,
unmask,
network_name,
kernel_size_string=""):
ranks_x = []
ranks_y = []
(_, _), (x_attack,
y_attack), (metadata_profiling,
metadata_attack) = load_ascad(trace_file,
load_metadata=True)
key_guesses = util.load_csv('{}/ASCAD/key_guesses.csv'.format(traces_path),
delimiter=' ',
dtype=np.int,
start=0,
size=attack_size)
x_attack = x_attack[:attack_size]
y_attack = y_attack[:attack_size]
if unmask:
if use_hw:
y_attack = np.array([
y_attack[i] ^ metadata_attack[i]['masks'][0]
for i in range(len(y_attack))
])
else:
y_attack = np.array([
util.HW[y_attack[i] ^ metadata_attack[i]['masks'][0]]
for i in range(len(y_attack))
])
real_key = metadata_attack[0]['key'][sub_key_index]
for run in runs:
folder = '{}/{}/subkey_{}/{}{}{}_SF{}_' \
'E{}_BZ{}_LR{}/train{}/'.format(
models_path,
str(data_set),
sub_key_index,
'' if unmask else 'masked/',
'' if desync is 0 else 'desync{}/'.format(desync),
type_network,
spread_factor,
epochs,
batch_size,
'%.2E' % Decimal(lr),
train_size)
model_path = '{}/model_r{}_{}{}.pt'.format(folder, run, network_name,
kernel_size_string)
print('path={}'.format(model_path))
model = load_model(network_name, model_path)
model.eval()
print("Using {}".format(model))
model.to(device)
# Load additional plaintexts
dk_plain = None
if network_name in req_dk:
dk_plain = metadata_attack[:]['plaintext'][:, sub_key_index]
dk_plain = hot_encode(dk_plain,
9 if use_hw else 256,
dtype=np.float)
# Calculate predictions
predictions = accuracy(model, x_attack, y_attack, dk_plain)
predictions = predictions.cpu().numpy()
# Shuffle the data using same permutation for n_exp and calculate mean for GE of the model
x, y = [], []
for exp_i in range(num_exps):
permutation = permutations[exp_i]
# Shuffle data
predictions_shuffled = shuffle_permutation(permutation,
np.array(predictions))
key_guesses_shuffled = shuffle_permutation(permutation,
key_guesses)
# Test the data
x_exp, y_exp = test_with_key_guess_p(key_guesses_shuffled,
predictions_shuffled,
attack_size=attack_size,
real_key=real_key,
use_hw=use_hw)
x = x_exp
y.append(y_exp)
# Calculate the mean over the experiments
y = np.mean(y, axis=0)
util.save_np('{}/model_r{}_{}{}.exp'.format(folder, run, network_name,
kernel_size_string),
y,
f="%f")
ranks_x.append(x)
ranks_y.append(y)
return ranks_x, ranks_y