def start_gpu_thread(part_csv):
args['datalist'] = part_csv
attacker = Attacker(transform, img2tensor, args)
img_pairs = pd.read_csv(args['datalist'])
for idx in tqdm(img_pairs.index.values):
pair_dict = {'source': img_pairs.loc[idx].source_imgs.split('|'),
'target': img_pairs.loc[idx].target_imgs.split('|')}
attacker.attack_method = attacker.FoolBox
attacker.attack(pair_dict)
def start_gpu_thread(part_csv, logdir):
args['logdir'] = logdir
args['datalist'] = part_csv
if os.path.exists(args['logdir']):
shutil.rmtree(args['logdir'])
# exit(1)
attacker = Attacker(transform, img2tensor, args)
img_pairs = pd.read_csv(args['datalist'])
for idx in tqdm(img_pairs.index.values):
pair_dict = {
'source': img_pairs.loc[idx].source_imgs.split('|'),
'target': img_pairs.loc[idx].target_imgs.split('|')
}
attacker.attack_method = attacker.M_DI_2_FGSM
attacker.attack(pair_dict)
def trainAndAttackRaw(classifier=None,
train_X=None,
train_y=None,
audioPath=None):
try:
print("Imported data " + str(len(train_X)) + " and " +
str(len(train_y)))
testData = Data()
test_X, test_y = testData.process(audioPath, attack=True, peak=True)
model_creator = Model(classifier=classifier)
print("Imported data " + str(len(train_X)) + " and " +
str(len(train_y)))
model_creator.fit_data(train_X, train_y)
attacker = Attacker()
attacker.attack(X=test_X, y=test_y, model=model_creator)
except Exception as e:
print("Exception in train and attack raw: ", e.__cause__)
traceback.print_exc(file=sys.stdout)
def trainAndAttack(classifier=None,
train_X=None,
train_y=None,
test_X=None,
test_y=None):
try:
model_creator = Model(classifier=classifier)
model_creator.fit_data(train_X, train_y)
predictions = model_creator.predict(test_X)
accuracy = accuracy_score(test_y, predictions)
print("Accuracy for " + str(classifier) + " : " + str(accuracy))
attacker = Attacker()
attacker.attack(X=test_X, y=test_y, model=model_creator)
except Exception as e:
print(
"Exception in train and attack: ",
e,
)
class Trainer:
def __init__(self, config):
self.config = config
self.ckpt_dir = config.ckpt_dir
if not os.path.exists(self.ckpt_dir):
os.makedirs(self.ckpt_dir)
self.save_config(config)
self.timer = Timer()
self.lr = config.lr
self.datasets, self.loaders = get_loader(config.batch_size,
config.aug,
data=config.data)
self.epochs = config.epochs
self.start_epoch = 0
self.is_ode = 'resnet' not in self.config.model
self.model = ModelSelector[config.model](**{
'channel': config.channel,
'num_blocks': config.nb,
'strides': config.strides,
'solver': config.solver,
'adjoint': config.adj,
'tol': config.tol,
'num_classes': config.nc
})
if self.config.use_gpu:
self.model = nn.DataParallel(self.model).cuda()
self.attacker = Attacker(self.model, self.loaders['test'])
self.criterion = nn.CrossEntropyLoss()
self.optimizer = optim.SGD(self.model.parameters(),
lr=config.lr,
momentum=0.9,
weight_decay=config.wd)
if config.resume:
success = self.load(config.resume_path)
if success:
self.writer = SummaryWriter(log_dir=config.ckpt_dir,
purge_step=self.start_epoch)
else:
self.writer = SummaryWriter(log_dir=config.ckpt_dir)
logger.info(self.model)
logger.info(
f'Number of Total Params: {sum(p.numel() for p in self.model.parameters() if p.requires_grad)}'
)
else:
self.writer = SummaryWriter(log_dir=config.ckpt_dir)
logger.info(self.model)
logger.info(
f'Number of Total Params: {sum(p.numel() for p in self.model.parameters() if p.requires_grad)}'
)
def train_and_test(self):
for epoch in range(self.start_epoch, self.epochs):
logger.info(f"Epoch :[{epoch}/{self.epochs}]")
self.train(epoch)
test_acc = self.test(epoch)
if epoch % 5 == 0:
self.save(
{
'net': self.model.state_dict(),
'test_acc': test_acc,
'epoch': epoch,
'optim': self.optimizer.state_dict()
}, epoch)
# self.writer.add_hparams(self.config.__dict__, {'hparam/test_best_acc': test_acc})
self.writer.close()
def train(self, epoch):
lr = adjust_learning_rate(self.lr, self.optimizer, self.config.lr_d,
epoch)
self.model.train()
losses = AveMeter()
f_nfe_meter = AveMeter()
b_nfe_meter = AveMeter()
correct = 0
for i, (inputs, targets) in enumerate(self.loaders['train']):
inputs = inputs + self.config.noise * torch.randn_like(inputs)
if self.config.use_gpu:
inputs, targets = inputs.cuda(), targets.cuda()
self.optimizer.zero_grad()
if self.is_ode:
self.model.module.nfe = 0
outputs = self.model(inputs)
if self.is_ode:
nfe_forward = self.model.module.nfe.item()
if self.config.loss == 'ce':
loss = self.criterion(outputs, targets)
elif self.config.loss == 'tr':
loss = self.criterion(outputs, targets) + trades_loss(
self.model,
inputs,
self.optimizer,
distance=self.config.attack_type)
elif self.config.loss == 'ma':
loss = madry_loss(self.model, inputs, targets, self.optimizer)
if self.is_ode:
self.model.module.nfe = 0
loss.backward()
self.optimizer.step()
if self.is_ode:
nfe_backward = self.model.module.nfe.item()
self.model.module.nfe = 0
if self.is_ode:
f_nfe_meter.update(nfe_forward)
b_nfe_meter.update(nfe_backward)
losses.update(loss.item(), inputs.size()[0])
correct += outputs.max(1)[1].eq(targets).sum().item()
acc = 100 * correct / len(self.datasets['train'])
logger.info(
f"Train: [{i + 1}/{len(self.loaders['train'])}] | "
f"Time: {self.timer.timeSince()} | "
f"loss: {losses.avg:.4f} | "
f"acc: {acc:.2f}% | NFE-F: {f_nfe_meter.avg:.2f} | NFE-B: {b_nfe_meter.avg:.2f}"
)
self.writer.add_scalar('train/lr', lr, epoch)
self.writer.add_scalar('train/loss', losses.avg, epoch)
self.writer.add_scalar('train/acc', acc, epoch)
self.writer.add_scalar('train/nfe-f', f_nfe_meter.avg, epoch)
self.writer.add_scalar('train/nfe-b', b_nfe_meter.avg, epoch)
for name, param in self.model.named_parameters():
if param.grad is not None:
self.writer.add_histogram(name,
param.clone().cpu().data.numpy(),
epoch)
self.writer.add_histogram(
name + '/grad',
param.grad.clone().cpu().data.numpy(), epoch)
def test(self, epoch):
self.model.eval()
losses = AveMeter()
correct = 0
with torch.no_grad():
for i, (inputs, targets) in enumerate(self.loaders['test']):
if self.config.use_gpu:
inputs, targets = inputs.cuda(), targets.cuda()
outputs = self.model(inputs)
loss = self.criterion(outputs, targets)
losses.update(loss.item(), inputs.size()[0])
correct += outputs.max(1)[1].eq(targets).sum().item()
acc = 100 * correct / len(self.datasets['test'])
out = f"Test: [{i + 1}/{len(self.loaders['test'])}] | " \
f"Time: {self.timer.timeSince()} | " \
f"loss: {losses.avg:.4f} | " \
f"acc: {acc:.2f}%"
if epoch % self.config.save_freq == 0 and epoch != 0:
acc_adv, grad_norm = self.attacker.attack(
self.config.attack_type, self.config.num_steps,
self.config.step_size, self.config.epsilon)
out = f"Test: [{i + 1}/{len(self.loaders['test'])}] | " \
f"Time: {self.timer.timeSince()} | " \
f"loss: {losses.avg:.4f} | " \
f"acc: {acc:.2f}% | " \
f"acc_adv_{self.config.attack_type}_{self.config.num_steps}: {acc_adv:.2f}% " \
f"grad_norm: {grad_norm:.4f}"
self.writer.add_scalar(
f'test/acc_adv_{self.config.attack_type}_{self.config.num_steps}',
acc_adv, epoch)
logger.info(out)
self.writer.add_scalar('test/loss', losses.avg, epoch)
self.writer.add_scalar('test/acc', acc, epoch)
return acc
def save(self, state, epoch):
torch.save(state, os.path.join(self.ckpt_dir, f'ckpt_{epoch}.pt'))
logger.info('***Saving model***')
def load(self, path):
assert os.path.exists(path), f"resume {path} not exists!"
ckpt_dict = {}
for file in os.listdir(path):
if file.startswith('ckpt_'):
ckpt_dict[file] = int(re.findall('_([0-9]+).pt', file)[0])
if len(ckpt_dict) == 0:
logger.info(
'Do not find any checkpoint file, will train from start!')
return False
else:
resume_file = sorted(ckpt_dict.items(), key=lambda x: x[1])[-1][0]
state = torch.load(
os.path.join(path, resume_file),
map_location='cuda' if self.config.use_gpu else 'cpu')
self.model.load_state_dict(state['net'])
self.optimizer.load_state_dict(state['optim'])
self.start_epoch = state['epoch'] + 1
logger.info('******************************************')
logger.info(f'Successfully load ckpt from {resume_file}')
return True
def save_config(self, config):
with open(os.path.join(self.ckpt_dir, 'config.json'), 'w+') as f:
f.write(json.dumps(config.__dict__, indent=4))
f.close()
size = test_data.shape[0]
idx_array = np.arange(size)
attacker = Attacker(run_tag=opt.run_tag, top_k=opt.topk, e=opt.e,
model_type=opt.model, cuda=opt.cuda, normalize=opt.normalize)
# record of the running time
start_time = time.time()
# count the number of the successful instances, mse,iterations,queries
success_cnt = 0
right_cnt = 0
total_mse = 0
total_iterations = 0
total_quries = 0
for idx in idx_array:
print('###Start %s : generating adversarial example of the %d sample ###' % (opt.run_tag, idx))
attack_ts, info = attacker.attack(sample_idx=idx, target_class=opt.target_class,
factor=opt.magnitude_factor, max_iteration=opt.maxitr,
popsize=opt.popsize)
# only save the successful adversarial example
if info[-1] == 'Success':
success_cnt = success_cnt + 1
total_iterations += info[-2]
total_mse += info[-3]
total_quries += info[-4]
file = open('result_' + str(opt.magnitude_factor) + '_' + str(opt.topk) + '_' + opt.model
+ '/' + opt.run_tag + '/attack_time_series.txt', 'a+')
file.write('%d %d ' % (idx, info[3]))
for i in attack_ts:
file.write('%.4f ' % i)
file.write('\n')
# session: reflects the session within a DB. It is deprecated. Just set it to ABC
#user = User("WordpressX", 0, "http://localhost:8080/wp-login.php", login_data = {"log": "admin", "pwd": "admin"}, session="ABC")
# Crawl without user session. Parameter desc: Name of DB - Privilege level - session
user = User("Test", 0, session="ABC")
url = "http://localhost/"
# Creates the crawler config: URL: start url of the crawler(independent from login) - max_dept: how deep to crawl(link), max_click_depth: how deep to follow events - Crawlspeed: Fast is the best value here
crawler_config = CrawlConfig("Some Name, doesn't matter",
url,
max_depth=1,
max_click_depth=2,
crawl_speed=CrawlSpeed.Fast)
# From here you have nothing to chance. Except you want no attacking, then comment out the lines down
logging.info("Crawler started...")
database_manager = DatabaseManager(user, dropping=True)
crawler = Crawler(
crawl_config=crawler_config,
database_manager=database_manager) #, proxy="localhost", port=8082)
crawler.crawl(user)
logging.info("Crawler finished")
# If you want no attacking comment out the lines below.
logging.info("Start attacking...")
attack_config = AttackConfig(url)
attacker = Attacker(
attack_config,
database_manager=database_manager) #, proxy="localhost", port=8082)
attacker.attack(user)
logging.info("Finish attacking...")
def tencent_run_test(event, context):
logging.info('Tencent Serverless.')
logging.info(context)
args = process_args_dict(event)
attacker = Attacker(*args)
attacker.attack()
def huawei_run_test(event, context):
logging.info('Huawei Serverless.')
logging.info(context)
args = process_args_dict(event)
attacker = Attacker(*args)
attacker.attack()
def aliyun_run_test(event, context):
logging.info('Aliyun Serverless.')
logging.info(context)
args = process_args_dict(json.loads(event))
attacker = Attacker(*args)
attacker.attack()
def tencent_run_api(event, context):
logging.info('Tencent Serverless.')
logging.info(context)
args = process_args_dict(event['queryString'])
attacker = Attacker(*args)
attacker.attack()
from args_parser import process_args_dict, console_get_args_dict
from attacker import Attacker, Mode
if __name__ == "__main__":
# print(get_args())
args = process_args_dict(console_get_args_dict())
attacker = Attacker(*args)
attacker.attack()
# In the Userobject, the first string you set is the name of the crawl run and also the name of the created database.
# So if you want to keep old runs then just give different names for each crawl
# The first of the line below, starts a scan with a logged in user.
# Parameter desc: Name of DB - Privilege level: deprecated(Just let it 0) - URL where the login form is stored - login data as dict. The key is the parameter name in the login form that has to be set -
# session: reflects the session within a DB. It is deprecated. Just set it to ABC
#user = User("WordpressX", 0, "http://localhost:8080/wp-login.php", login_data = {"log": "admin", "pwd": "admin"}, session="ABC")
# Crawl without user session. Parameter desc: Name of DB - Privilege level - session
user = User("Test", 0, session="ABC")
url = "http://localhost/"
# Creates the crawler config: URL: start url of the crawler(independent from login) - max_dept: how deep to crawl(link), max_click_depth: how deep to follow events - Crawlspeed: Fast is the best value here
crawler_config = CrawlConfig("Some Name, doesn't matter", url, max_depth=1, max_click_depth=2, crawl_speed=CrawlSpeed.Fast)
# From here you have nothing to chance. Except you want no attacking, then comment out the lines down
logging.info("Crawler started...")
database_manager = DatabaseManager(user, dropping=True)
crawler = Crawler(crawl_config=crawler_config, database_manager=database_manager)#, proxy="localhost", port=8082)
crawler.crawl(user)
logging.info("Crawler finished")
# If you want no attacking comment out the lines below.
logging.info("Start attacking...")
attack_config = AttackConfig(url)
attacker = Attacker(attack_config, database_manager=database_manager)#, proxy="localhost", port=8082)
attacker.attack(user)
logging.info("Finish attacking...")
# set dataset
dataset = ImageNet_A(args.input_dir)
loader = torch.utils.data.DataLoader(dataset,
batch_size=args.batch_size,
shuffle=False)
# set attacker
attacker = Attacker(steps=args.steps,
max_norm=args.max_norm / 255.0,
div_prob=args.div_prob,
device=torch.device('cuda'))
for ind, (img, label_true, label_target, filenames) in enumerate(loader):
# run attack
adv = attacker.attack(model, img.cuda(), label_true.cuda(),
label_target.cuda())
# save results
for bind, filename in enumerate(filenames):
out_img = adv[bind].detach().cpu().numpy()
delta_img = np.abs(out_img - img[bind].numpy()) * 255.0
print('Attack on {}:'.format(os.path.split(filename)[-1]))
print('Max: {0:.0f}, Mean: {1:.2f}'.format(np.max(delta_img),
np.mean(delta_img)))
out_img = np.transpose(out_img, axes=[1, 2, 0]) * 255.0
out_img = out_img[:, :, ::-1]
out_filename = os.path.join(output_dir,
os.path.split(filename)[-1])
help='How many folds to use for cross-validation')
parser.add_argument('--nocv',
type=int,
default=False,
help='Disables cross-validation')
args = parser.parse_args()
if not args.wav:
print("Can't work without wav file!")
# FILE IMPORT
data = Data()
X, y = data.process(args.wav, attack=bool(args.attack))
# attack mode
if args.attack:
print(args.attack)
attacker = Attacker()
attacker.attack(X, y, args.attack)
# train mode
else:
# ML Model creating and training
model_creator = Model()
model = model_creator.fit_data(X, y)
model_creator.dump(args.wav)
print("Dumped")
if not args.nocv:
model_creator.predict_accuracy(X, y)