def __init__(self,
name='Stick',
description='',
damage=10,
weapon_type='',
cost=0,
condition='sturdy',
attacks=[Attack(), Attack(), Attack()]):
self.name = name
# a weapon's name consists of it's condition and regular name, e.g. 'Sturdy Sword'
self.description = description
self.condition = condition
# condition effects the weapon's damage and other attributes, condition is defaulted to sturdy
self.default_damage = damage
self.damage = int(
self.default_damage *
condition_dictionary[self.condition]['damage_multiplier'])
# damage changes depending on condition, but it is defaulted at the default damage
# weapon's default damage is set by the parameter damage
self.weapon_type = weapon_type
self.cost = cost
# how much it costs to purchase the weapon
self.attacks = attacks
# list of attacks that the weapon can perform
self.critical_chance = condition_dictionary[
self.condition]['critical_chance']
self.critical_multiplier = condition_dictionary[
self.condition]['critical_multiplier']
def __init__(self, args, model, dataloarder):
self.args = args
# Basic
# self.cuda = (args.cuda and torch.cuda.is_available())
# setting device
if args.cuda and torch.cuda.is_available():
"""
if argument is given and cuda is available
"""
self.device = torch.device('cuda')
else:
self.device = torch.device('cpu')
self.epoch = args.epoch
self.batch_size = args.batch_size
self.eps = args.eps
self.lr = args.lr
self.y_dim = args.y_dim
self.target = args.target
self.dataset = args.dataset
self.data_loader = dataloarder # dict
self.global_epoch = 0
self.global_iter = 0
self.print_ = not args.silent
self.net = model #need the model to be initialized here
self.env_name = args.env_name
self.tensorboard = args.tensorboard
self.visdom = args.visdom
self.ckpt_dir = Path(args.ckpt_dir).joinpath(args.env_name)
if not self.ckpt_dir.exists():
self.ckpt_dir.mkdir(parents=True, exist_ok=True)
self.output_dir = Path(args.output_dir).joinpath(args.env_name)
if not self.output_dir.exists():
self.output_dir.mkdir(parents=True, exist_ok=True)
# Visualization Tools
self.visualization_init(args)
# Histories
self.history = dict()
self.history['acc'] = 0.
self.history['epoch'] = 0
self.history['iter'] = 0
# Models & Optimizers
# self.model_init(args)
self.load_ckpt = args.load_ckpt
if self.load_ckpt != '':
self.load_checkpoint(self.load_ckpt)
# Adversarial Perturbation Generator
#criterion = cuda(torch.nn.CrossEntropyLoss(), self.cuda)
criterion = F.cross_entropy
self.attack = Attack(self.net, criterion=criterion)
def unpack_attacks_into_objects(buff_output_dictionary):
"""unpacks attack attributes into objects within a dictionary"""
attack_output_dictionary = {}
for attack_group_key in attack_attribute_dictionary:
attack_list = []
for attack_attributes in attack_attribute_dictionary[attack_group_key]:
if attack_attributes['buff'] in buff_object_dictionary:
attack_buff = buff_output_dictionary[attack_attributes['buff']]
else:
attack_buff = ""
attack_list.append(
Attack(attack_attributes['name'],
attack_attributes['multiplier'],
attack_attributes['variance'], attack_buff))
attack_output_dictionary[attack_group_key] = attack_list
return attack_output_dictionary
def askUser():
print("==========================================")
print("\n Please select an attack type:")
print("\n 1. UDP Flood")
print("\n 2. Ping of death")
print("\n=========================================")
try:
valid = [1,2]
answer = int(input("Choice [1-2]: "))
if answer not in valid:
print("Please enter a valid number.")
askUser()
else:
if answer == 1:
host = input('Host: ')
port = int(input('Post: '))
att = Attack('udpflood', host, port)
isUp = att.checkTargetAlive()
print(isUp)
if isUp:
att.attack()
else:
print("Could not check if target is up.")
keepGoing = input("Do you still want to attack target? (y/n)")
if keepGoing == 'y' or keepGoing == 'Y':
att.attack()
elif answer == 'n' or answer == 'N':
askUser()
else:
pass
else:
pass
finally:
print("Done.")
def choose(arg):
attack = str(accueil(arg))
if attack == "1":
print("\n\t\t\t ***** Wiener Attack *****")
args = input(
"\n\t\t[*] Arguments ([-h] -n modulus -e exponent):\n\n\t\t\t"
).split()
parser = argparse.ArgumentParser(
description='This program allows to carry out a Wiener Attack')
parser.add_argument('-n',
dest='n',
type=int,
help='RSA public key modulus',
required=True)
parser.add_argument('-e',
dest='e',
type=int,
help='RSA public key exponent',
required=True)
params = parser.parse_args(args)
attack_object = Attack(params)
attack_object.wiener()
elif attack == "2":
print("\n\t\t\t ***** Hastad Attack *****")
try:
args = input(
"\n\t\t[*] Arguments ([-h] -n0 modulus_key0 -n1 modulus_key1 -n2 modulus_key2 -e public_exponent -c0 cipher1 -c1 cipher2 -c2 cipher3):\n\n\t\t\t"
).split()
except:
print("\n\t\t\t[-] Argument Error: Please verify your inputs\n")
exit()
parser = argparse.ArgumentParser(
description='This program allows to carry out an Hastad Attack')
parser.add_argument(
'-n0',
dest='n0',
type=int,
help='Modulus of the first RSA pulic key (decimal)',
required=True)
parser.add_argument(
'-n1',
dest='n1',
type=int,
help='Modulus of the second RSA pulic key (decimal)',
required=True)
parser.add_argument(
'-n2',
dest='n2',
type=int,
help='Modulus of the third RSA pulic key (decimal)',
required=True)
parser.add_argument('-e',
dest='e',
type=int,
help='Common public exponent (decimal)',
required=True)
parser.add_argument('-c0',
dest='c0',
type=int,
help='first ciphertext (decimal)',
required=True)
parser.add_argument('-c1',
dest='c1',
type=int,
help='second ciphertext (decimal)',
required=True)
parser.add_argument('-c2',
dest='c2',
type=int,
help='third ciphertext (decimal)',
required=True)
params = parser.parse_args(args)
attack_object = Attack(params)
attack_object.hastad()
elif attack == "3":
print("\n\t\t\t ***** Fermat Attack *****")
try:
args = input(
"\n\t\t[*] Arguments ([-h] -n modulus -e exponent):\n\n\t\t\t"
).split()
except:
print("\n\t\t\t[-] Argument Error: Please verify your inputs\n")
exit()
parser = argparse.ArgumentParser(
description=
'This program allows to carry out a Fermat Factorization')
parser.add_argument('-n',
dest='n',
type=int,
help='RSA public key modulus',
required=True)
parser.add_argument('-e',
dest='e',
type=int,
help='RSA public key exponent',
required=True)
params = parser.parse_args(args)
attack_object = Attack(params)
attack_object.fermat()
elif attack == "4":
print("\n\t\t\t ***** Bleichenbacher Attack *****")
try:
args = input(
"\n\t\t[*] Arguments ([-h] -n modulus -e exponent -c ciphertext --host hostname -p port --error error padding message):\n\n\t\t\t"
).split()
except:
print("\n\t\t\t[-] Argument Error: Please verify your inputs\n")
exit()
parser = argparse.ArgumentParser(
description=
'This program allows to carry out a Bleichenbacher Attack')
parser.add_argument('-n',
dest='n',
type=int,
help='RSA public key modulus (int)',
required=True)
parser.add_argument('-e',
dest='e',
type=int,
help='RSA public key exponent (int)',
required=True)
parser.add_argument('-c',
dest='c',
type=int,
help='ciphertext (int)',
required=True)
parser.add_argument('--host',
dest='host',
type=str,
help='hostname',
required=True)
parser.add_argument('-p',
dest='port',
type=int,
help='port',
required=True)
parser.add_argument('--error',
dest='error',
type=str,
help='Oracle Padding Error',
required=True)
params = parser.parse_args(args)
attack_object = Attack(params)
attack_object.bleichenbacher()
elif attack == "5":
print("\n\t\t\t ***** Common Modulus Attack *****")
try:
args = input(
"\n\t\t[*] Arguments [-h] -n common modulus -e1 first exponent -e2 second exponent -c1 first cipher -c2 second cipher:\n\n\t\t\t"
).split()
except:
print("\n\t\t\t[-] Argument Error: Please verify your inputs\n")
exit()
parser = argparse.ArgumentParser(
description=
'This program allows to carry out a Common Modulus Attack')
parser.add_argument('-n',
dest='n',
type=int,
help='RSA public key modulus',
required=True)
parser.add_argument('-e1',
dest='e1',
type=int,
help='First RSA public key exponent',
required=True)
parser.add_argument('-e2',
dest='e2',
type=int,
help='Second RSA public key exponent',
required=True)
parser.add_argument('-c1',
dest='c1',
type=int,
help='First ciphered text',
required=True)
parser.add_argument('-c2',
dest='c2',
type=int,
help='Second ciphered text',
required=True)
params = parser.parse_args(args)
attack_object = Attack(params)
attack_object.comod()
elif attack == "6":
print("\n\t\t\t ***** Chosen Plaintext Attack *****")
try:
args = input(
"\n\t\t[*] Arguments ([-h] -n modulus -e public_exponent -c ciphertext):\n\n\t\t\t"
).split()
except:
print("\n\t\t\t[-] Argument Error: Please verify your inputs\n")
exit()
parser = argparse.ArgumentParser(
description=
'This program allows to carry out a Chosen Plaintext Attack')
parser.add_argument('-n',
dest='n',
type=int,
help='RSA public key modulus',
required=True)
parser.add_argument('-e',
dest='e',
type=int,
help='first RSA public key exponent',
required=True)
parser.add_argument('-c',
dest='c',
type=int,
help='ciphertext',
required=True)
params = parser.parse_args(args)
params = parser.parse_args(args)
attack_object = Attack(params)
attack_object.chopla()
elif attack == "a":
print("\n\t\t\t ***** RSA Public Key parameters extraction *****")
try:
args = input("\n\t\t[*] Argument ([-h] -k K):\n\n\t\t\t").split()
except:
print("\n\t\t\t[-] Argument Error: Please verify your inputs\n")
exit()
if args[0] == '-k' and args[1] != '/':
args[1] = getcwd() + "/" + args[1]
parser = argparse.ArgumentParser(
description=
'This program allows to extract the modulus and the exponent of an RSA public key (PEM)'
)
parser.add_argument('-k',
dest='k',
type=str,
help='path of the RSA public key',
required=True)
params = parser.parse_args(args)
tool_object = Tool(params)
tool_object.pubex()
elif attack == "b":
print("\n\t\t\t ***** RSA Private Key paramters extraction *****")
try:
args = input("\n\t\t[*] Argument ([-h] -k K):\n\n\t\t\t").split()
except:
print("\n\t\t\t[-] Argument Error: Please verify your inputs\n")
exit()
if args[0] == '-k' and args[1] != '/':
args[1] = getcwd() + "/" + args[1]
parser = argparse.ArgumentParser(
description=
'This program allows to extract the parameters of an RSA private key (PEM)'
)
parser.add_argument('-k',
dest='k',
type=str,
help='path of the RSA private key',
required=True)
params = parser.parse_args(args)
tool_object = Tool(params)
tool_object.privex()
elif attack == "c":
print("\n\t\t\t ***** RSA Private Key constructor *****")
try:
args = input(
"\n\t\t[*] Argument ([-h] -p first_factorization_element -q second_factorization_element -e public_exponent [-o output_file]):\n\n\t\t\t"
).split()
except:
print("\n\t\t\t[-] Argument Error: Please verify your inputs\n")
exit()
parser = argparse.ArgumentParser(
description=
'This program allows to construct an RSA Private Key with its parameters'
)
parser.add_argument('-p',
dest='p',
type=int,
help='first element of the modulus factorization',
required=True)
parser.add_argument('-q',
dest='q',
type=int,
help='second element of the modulus factorization',
required=True)
parser.add_argument('-e',
dest='e',
type=int,
help='public exponent',
required=True)
parser.add_argument('-o', dest='o', type=str, help='output file')
params = parser.parse_args(args)
tool_object = Tool(params)
tool_object.privkeyconstruct()
elif attack == "d":
print("\n\t\t\t ***** RSA Public Key constructor *****")
try:
args = input(
"\n\t\t[*] Argument ([-h] -n modulus -e public_exponent [-o output_file]):\n\n\t\t\t"
).split()
except:
print("\n\t\t\t[-] Argument Error: Please verify your inputs\n")
exit()
parser = argparse.ArgumentParser(
description=
'This program allows to construct an RSA Public Key with its parameters'
)
parser.add_argument('-n',
dest='n',
type=int,
help='modulus',
required=True)
parser.add_argument('-e',
dest='e',
type=int,
help='public exponent',
required=True)
parser.add_argument('-o', dest='o', type=str, help='output file')
params = parser.parse_args(args)
tool_object = Tool(params)
tool_object.pubkeyconstruct()
elif attack == "e":
print("\n\t\t\t ***** RSA Decipher *****")
try:
args = input(
"\n\t\t[*] Argument ([-h] -n modulus -d private_exponent -c ciphertext):\n\n\t\t\t"
).split()
except:
print("\n\t\t\t[-] Argument Error: Please verify your inputs\n")
exit()
parser = argparse.ArgumentParser(
description=
'This simple program allows to decipher a message using RSA')
parser.add_argument('-n',
dest='n',
type=int,
help='RSA public key modulus',
required=True)
parser.add_argument('-d',
dest='d',
type=int,
help='RSA private key exponent',
required=True)
parser.add_argument('-c',
dest='c',
type=int,
help='ciphertext',
required=True)
params = parser.parse_args(args)
tool_object = Tool(params)
tool_object.decipher()
elif attack == "f":
print("\n\t\t\t ***** RSA Encipher *****")
try:
args = input(
"\n\t\t[*] Argument ([-h] -n modulus -e public_exponent -p plaintext):\n\n\t\t\t"
).split()
except:
print("\n\t\t\t[-] Argument Error: Please verify your inputs\n")
exit()
parser = argparse.ArgumentParser(
description=
'This simple program allows to encipher a message using RSA')
parser.add_argument('-n',
dest='n',
type=int,
help='RSA public key modulus',
required=True)
parser.add_argument('-e',
dest='e',
type=int,
help='RSA public key exponent',
required=True)
parser.add_argument('-p',
dest='p',
type=int,
help='plaintext',
required=True)
params = parser.parse_args(args)
tool_object = Tool(params)
tool_object.encipher()
else:
choose("again")
class Solver(object):
def __init__(self, args, model, dataloarder):
self.args = args
# Basic
# self.cuda = (args.cuda and torch.cuda.is_available())
# setting device
if args.cuda and torch.cuda.is_available():
"""
if argument is given and cuda is available
"""
self.device = torch.device('cuda')
else:
self.device = torch.device('cpu')
self.epoch = args.epoch
self.batch_size = args.batch_size
self.eps = args.eps
self.lr = args.lr
self.y_dim = args.y_dim
self.target = args.target
self.dataset = args.dataset
self.data_loader = dataloarder # dict
self.global_epoch = 0
self.global_iter = 0
self.print_ = not args.silent
self.net = model #need the model to be initialized here
self.env_name = args.env_name
self.tensorboard = args.tensorboard
self.visdom = args.visdom
self.ckpt_dir = Path(args.ckpt_dir).joinpath(args.env_name)
if not self.ckpt_dir.exists():
self.ckpt_dir.mkdir(parents=True, exist_ok=True)
self.output_dir = Path(args.output_dir).joinpath(args.env_name)
if not self.output_dir.exists():
self.output_dir.mkdir(parents=True, exist_ok=True)
# Visualization Tools
self.visualization_init(args)
# Histories
self.history = dict()
self.history['acc'] = 0.
self.history['epoch'] = 0
self.history['iter'] = 0
# Models & Optimizers
# self.model_init(args)
self.load_ckpt = args.load_ckpt
if self.load_ckpt != '':
self.load_checkpoint(self.load_ckpt)
# Adversarial Perturbation Generator
#criterion = cuda(torch.nn.CrossEntropyLoss(), self.cuda)
criterion = F.cross_entropy
self.attack = Attack(self.net, criterion=criterion)
def visualization_init(self, args):
# Visdom
if self.visdom:
from utils.visdom_utils import VisFunc
self.port = args.visdom_port
self.vf = VisFunc(enval=self.env_name, port=self.port)
# TensorboardX
if self.tensorboard:
from tensorboardX import SummaryWriter
self.summary_dir = Path(args.summary_dir).joinpath(args.env_name)
if not self.summary_dir.exists():
self.summary_dir.mkdir(parents=True, exist_ok=True)
self.tf = SummaryWriter(log_dir=str(self.summary_dir))
self.tf.add_text(tag='argument',
text_string=str(args),
global_step=self.global_epoch)
# def model_init(self, args):
# # Network
# self.net = cuda(ToyNet(y_dim=self.y_dim), self.cuda)
# self.net.weight_init(_type='kaiming')
# # Optimizers
# self.optim = optim.Adam([{'params':self.net.parameters(), 'lr':self.lr}],
# betas=(0.5, 0.999))
def train(self):
self.set_mode('train')
for e in range(self.epoch):
self.global_epoch += 1
correct = 0.
cost = 0.
total = 0.
for batch_idx, (images,
labels) in enumerate(self.data_loader['train']):
self.global_iter += 1
x = Variable(images).to(self.device)
y = Variable(labels).to(self.device)
logit = self.net(x)
prediction = logit.max(1)[1]
correct = torch.eq(prediction, y).float().mean().data[0]
cost = F.cross_entropy(logit, y)
self.optim.zero_grad()
cost.backward()
self.optim.step()
if batch_idx % 100 == 0:
if self.print_:
print()
print(self.env_name)
print('[{:03d}:{:03d}]'.format(self.global_epoch,
batch_idx))
print('acc:{:.3f} loss:{:.3f}'.format(
correct, cost.data[0]))
if self.tensorboard:
self.tf.add_scalars(main_tag='performance/acc',
tag_scalar_dict={'train': correct},
global_step=self.global_iter)
self.tf.add_scalars(
main_tag='performance/error',
tag_scalar_dict={'train': 1 - correct},
global_step=self.global_iter)
self.tf.add_scalars(
main_tag='performance/cost',
tag_scalar_dict={'train': cost.data[0]},
global_step=self.global_iter)
self.test()
if self.tensorboard:
self.tf.add_scalars(main_tag='performance/best/acc',
tag_scalar_dict={'test': self.history['acc']},
global_step=self.history['iter'])
print(" [*] Training Finished!")
def test(self):
self.set_mode('eval')
correct = 0.
cost = 0.
total = 0.
data_loader = self.data_loader['test']
for batch_idx, (images, labels) in enumerate(data_loader):
x = Variable(images).to(self.device)
y = Variable(labels).to(self.device)
logit = self.net(x)
prediction = logit.max(1)[1]
correct += torch.eq(prediction, y).float().sum().data[0]
cost += F.cross_entropy(logit, y, size_average=False).data[0]
total += x.size(0)
accuracy = correct / total
cost /= total
if self.print_:
print()
print('[{:03d}]\nTEST RESULT'.format(self.global_epoch))
print('ACC:{:.4f}'.format(accuracy))
print('*TOP* ACC:{:.4f} at e:{:03d}'.format(
accuracy,
self.global_epoch,
))
print()
if self.tensorboard:
self.tf.add_scalars(main_tag='performance/acc',
tag_scalar_dict={'test': accuracy},
global_step=self.global_iter)
self.tf.add_scalars(main_tag='performance/error',
tag_scalar_dict={'test': (1 - accuracy)},
global_step=self.global_iter)
self.tf.add_scalars(main_tag='performance/cost',
tag_scalar_dict={'test': cost},
global_step=self.global_iter)
if self.history['acc'] < accuracy:
self.history['acc'] = accuracy
self.history['epoch'] = self.global_epoch
self.history['iter'] = self.global_iter
self.save_checkpoint('best_acc.tar')
self.set_mode('train')
def generate(self,
num_sample=100,
target=-1,
epsilon=0.03,
alpha=2 / 255,
iteration=1):
self.set_mode('eval')
x_true, y_true = self.sample_data(num_sample)
if isinstance(target, int) and (target in range(self.y_dim)):
y_target = torch.LongTensor(y_true.size()).fill_(target)
else:
y_target = None
x_adv, changed, values = self.FGSM(x_true, y_true, y_target, epsilon,
alpha, iteration)
accuracy, cost, accuracy_adv, cost_adv = values
save_image(x_true,
self.output_dir.joinpath(
'legitimate(t:{},e:{},i:{}).jpg'.format(
target, epsilon, iteration)),
nrow=10,
padding=2,
pad_value=0.5)
save_image(x_adv,
self.output_dir.joinpath(
'perturbed(t:{},e:{},i:{}).jpg'.format(
target, epsilon, iteration)),
nrow=10,
padding=2,
pad_value=0.5)
save_image(changed,
self.output_dir.joinpath(
'changed(t:{},e:{},i:{}).jpg'.format(
target, epsilon, iteration)),
nrow=10,
padding=3,
pad_value=0.5)
if self.visdom:
self.vf.imshow_multi(x_true.cpu(), title='legitimate', factor=1.5)
self.vf.imshow_multi(x_adv.cpu(),
title='perturbed(e:{},i:{})'.format(
epsilon, iteration),
factor=1.5)
self.vf.imshow_multi(changed.cpu(),
title='changed(white)'.format(epsilon),
factor=1.5)
print('[BEFORE] accuracy : {:.2f} cost : {:.3f}'.format(
accuracy, cost))
print('[AFTER] accuracy : {:.2f} cost : {:.3f}'.format(
accuracy_adv, cost_adv))
self.set_mode('train')
def sample_data(self, num_sample=100):
total = len(self.data_loader['test'].dataset)
# seed = torch.FloatTensor(num_sample).uniform_(1, total).long()#if dataset is in tensor format
#otherwise indexing is not supported for ndarray[torch seed]
seed = np.random.random_integers(1, total, size=num_sample)
# print(seed)
x = torch.from_numpy(self.data_loader['test'].dataset.test_data[seed])
x = x.type(torch.cuda.FloatTensor)
x = Variable(x, requires_grad=True).to(self.device)
x = self.scale(x.float().unsqueeze(1).div(255))
print(type(self.data_loader['test'].dataset.test_data),
self.data_loader['test'].dataset.test_data[0].shape)
y = self.data_loader['test'].dataset.test_data[seed]
#y = Variable(torch.from_numpy(self.data_loader['test'].dataset.test_labels[seed]),requires_grad = False).to(self.device)
return x, y
def FGSM(self,
x,
y_true,
y_target=None,
eps=0.03,
alpha=2 / 255,
iteration=1):
self.set_mode('eval')
if type(x) == np.ndarray:
x = torch.from_numpy(x)
if type(y_true) == np.ndarray:
y_true = torch.from_numpy(y_true)
x = Variable(x, requires_grad=True).to(self.device)
y_true = Variable(y_true, requires_grad=False).to(self.device)
if y_target is not None:
targeted = True
y_target = Variable(y_target, requires_grad=False).to(self.device)
else:
targeted = False
h = self.net(x)
prediction = h.max(1)[1]
accuracy = torch.eq(prediction, y_true).float().mean()
cost = F.cross_entropy(h, y_true)
if iteration == 1:
if targeted:
x_adv, h_adv, h = self.attack.fgsm(x, y_target, True, eps)
else:
x_adv, h_adv, h = self.attack.fgsm(x, y_true, False, eps)
else:
if targeted:
x_adv, h_adv, h = self.attack.i_fgsm(x, y_target, True, eps,
alpha, iteration)
else:
x_adv, h_adv, h = self.attack.i_fgsm(x, y_true, False, eps,
alpha, iteration)
prediction_adv = h_adv.max(1)[1]
accuracy_adv = torch.eq(prediction_adv, y_true).float().mean()
cost_adv = F.cross_entropy(h_adv, y_true)
# make indication of perturbed images that changed predictions of the classifier
if targeted:
changed = torch.eq(y_target, prediction_adv)
else:
changed = torch.eq(prediction, prediction_adv)
changed = torch.eq(changed, 0)
changed = changed.float().view(-1, 1, 1, 1).repeat(1, 3, 28, 28)
changed[:, 0, :, :] = where(changed[:, 0, :, :] == 1, 252, 91)
changed[:, 1, :, :] = where(changed[:, 1, :, :] == 1, 39, 252)
changed[:, 2, :, :] = where(changed[:, 2, :, :] == 1, 25, 25)
changed = self.scale(changed / 255)
changed[:, :, 3:-2, 3:-2] = x_adv.repeat(1, 3, 1, 1)[:, :, 3:-2, 3:-2]
self.set_mode('train')
return x_adv.data, changed.data,\
(accuracy.data[0], cost.data[0], accuracy_adv.data[0], cost_adv.data[0])
def save_checkpoint(self, filename='ckpt.tar'):
model_states = {
'net': self.net.state_dict(),
}
optim_states = {
'optim': self.optim.state_dict(),
}
states = {
'iter': self.global_iter,
'epoch': self.global_epoch,
'history': self.history,
'args': self.args,
'model_states': model_states,
'optim_states': optim_states,
}
file_path = self.ckpt_dir / filename
torch.save(states, file_path.open('wb+'))
print("=> saved checkpoint '{}' (iter {})".format(
file_path, self.global_iter))
def load_checkpoint(self, filename='best_acc.tar'):
file_path = self.ckpt_dir / filename
if file_path.is_file():
print("=> loading checkpoint '{}'".format(file_path))
checkpoint = torch.load(file_path.open('rb'))
self.global_epoch = checkpoint['epoch']
self.global_iter = checkpoint['iter']
self.history = checkpoint['history']
self.net.load_state_dict(checkpoint['model_states']['net'])
self.optim.load_state_dict(checkpoint['optim_states']['optim'])
print("=> loaded checkpoint '{} (iter {})'".format(
file_path, self.global_iter))
else:
print("=> no checkpoint found at '{}'".format(file_path))
def set_mode(self, mode='train'):
if mode == 'train':
self.net.train()
elif mode == 'eval':
self.net.eval()
else:
raise ('mode error. It should be either train or eval')
def scale(self, image):
return image.mul(2).add(-1)
def unscale(self, image):
return image.add(1).mul(0.5)
def summary_flush(self, silent=True):
rm_dir(self.summary_dir, silent)
def checkpoint_flush(self, silent=True):
rm_dir(self.ckpt_dir, silent)
from attacks import Attack
# Initialize all attacks
# ----------------------------------------------------------------------------------------- #
# Fire type---------------------------
#new moves added
blastburn = Attack(name='blast burn',
attCategory='fire',
baseDamage=150,
pokemonLevel=0,
baseCount=5,
recoil=15,
heal=0,
accuracy=0.9)
blazekick = Attack(name='blaze kick',
attCategory='fire',
baseDamage=85,
pokemonLevel=0,
baseCount=10,
recoil=0,
heal=0,
accuracy=0.9)
fierydance = Attack(name='fiery dance',
attCategory='fire',
baseDamage=80,
pokemonLevel=0,
baseCount=10,
recoil=0,
heal=0,
def main():
graph = graph_loader(graph_type='water', seed=1)
params = {
'runs': 1,
'steps': 30,
'seed': 1,
'attack': 'rb_node',
'attack_approx': int(0.1 * len(graph)),
'plot_transition': True,
'gif_animation': True,
'gif_snaps': True,
'edge_style': None,
'node_style': None,
'fa_iter': 20
}
print("Creating example visualization")
a = Attack(graph, **params)
a.run_simulation()
node_attacks = ['rnd_node', 'id_node', 'rd_node', 'ib_node', 'rb_node']
edge_attacks = ['rnd_edge', 'id_edge', 'rd_edge', 'ib_edge', 'rb_edge']
params['runs'] = 10
params['steps'] = len(graph) - 1
params['plot_transition'] = False
params['gif_animation'] = False
params['gif_snaps'] = False
print("Running node attacks")
results = defaultdict(str)
for attack in node_attacks:
params['attack'] = attack
if 'rb' in attack or 'ib' in attack:
params['attack_approx'] = int(0.1 * len(graph))
else:
params['attack_approx'] = None
a = Attack(graph, **params)
results[attack] = a.run_simulation()
plot_results(graph,
params['steps'],
results,
title='water:node-attacks_runs={}'.format(params['runs']))
print("Running edge attacks")
results = defaultdict(str)
for attack in edge_attacks:
params['attack'] = attack
if 'rb' in attack or 'ib' in attack:
params['attack_approx'] = int(0.1 * len(graph))
else:
params['attack_approx'] = None
a = Attack(graph, **params)
results[attack] = a.run_simulation()
plot_results(graph,
params['steps'],
results,
title='water:edge-attacks_runs={}'.format(params['runs']))