def process(data):
src_img_path = data['filepath']
bboxes = data['bboxes']
class_count = {}
for bbox in bboxes:
class_label = bbox['class']
if class_label not in class_count:
class_count[class_label] = 0
else:
class_count[class_label] += 1
box_xy = (bbox['x1'], bbox['y1'], bbox['x2'], bbox['y2'])
# if class_count[class_label] == 0:
# bbox_name ="{}{}".format(data['image_name'].split('.')[0], '.jpg')
# else:
# bbox_name ="{}-{}{}".format(data['image_name'].split('.')[0], class_count[class_label], '.jpg')
bbox_name = "{}-{}{}".format(data['image_name'].split('.')[0],
class_count[class_label], '.jpg')
class_label_folder = os.path.join(save_path, class_label)
io_utils.mkdir(class_label_folder)
save_bbox_path = os.path.join(class_label_folder, bbox_name)
crop_bbox(src_img_path, box_xy, save_bbox_path)
def count_and_cut(input_path, count):
annot_path = os.path.join(input_path, 'Annotations')
img_path = os.path.join(input_path, 'JPEGImages')
save_folder = os.path.join(input_path, 'label_bbox')
io_utils.mkdir(save_folder)
io_utils.remove_all(save_folder)
annots = [os.path.join(annot_path, s) for s in os.listdir(annot_path)]
for annot in annots: # read a xml
try:
et = ET.parse(annot)
element = et.getroot()
element_objs = element.findall('object')
img_name = element.find('filename').text
new_img_path = os.path.join(img_path, img_name)
for element_obj in element_objs:
class_name = element_obj.find('name').text # find label
count[class_name][img_name] = count[class_name][img_name] + 1
save_path = os.path.join(save_folder, class_name)
save_name = img_name.split('.')[0] + '-' + str(
count[class_name][img_name]) + '.jpg'
io_utils.mkdir(save_path)
xmin = int(element_obj.find("bndbox").find(
"xmin").text) # find bbox boundary
ymin = int(element_obj.find("bndbox").find("ymin").text)
xmax = int(element_obj.find("bndbox").find("xmax").text)
ymax = int(element_obj.find("bndbox").find("ymax").text)
box = (xmin, ymin, xmax, ymax)
img = Image.open(new_img_path)
region = img.crop(box)
region.save(os.path.join(save_path, save_name))
except Exception as e:
print('Exception: {}'.format(e))
continue
def read_data(data_path):
all_imgs = []
print('Parsing annotation files')
annot_path = os.path.join(data_path, 'Annotations')
imgs_path = os.path.join(data_path, 'JPEGImages')
imgs_out_path = os.path.join(data_path, 'JPEGImages_with_bbox')
io_utils.delete_file_folder(imgs_out_path)
io_utils.mkdir(imgs_out_path)
annots = [os.path.join(annot_path, s) for s in os.listdir(annot_path)]
for annot in annots:
try:
et = ET.parse(annot)
element = et.getroot()
element_objs = element.findall('object')
element_filename = element.find('filename').text
element_width = int(element.find('size').find('width').text)
element_height = int(element.find('size').find('height').text)
if len(element_objs) > 0:
# annotation format 封装后的注释格式
annotation_data = {'filepath': os.path.join(imgs_path, element_filename),
'file_out_path': os.path.join(imgs_out_path, element_filename),
'width': element_width,
'height': element_height,
'bboxes': []}
for element_obj in element_objs:
class_name = element_obj.find('name').text
obj_bbox = element_obj.find('bndbox')
x1 = int(round(float(obj_bbox.find('xmin').text)))
y1 = int(round(float(obj_bbox.find('ymin').text)))
x2 = int(round(float(obj_bbox.find('xmax').text)))
y2 = int(round(float(obj_bbox.find('ymax').text)))
# annotation format of bounding box 矩形框的封装格式
annotation_data['bboxes'].append(
{'class': class_name,
'x1': x1,
'x2': x2,
'y1': y1,
'y2': y2})
all_imgs.append(annotation_data)
image = cv2.imread(annotation_data['filepath'])
for bbox in annotation_data['bboxes']:
cv2.rectangle(image, (bbox['x1'], bbox['y1']), (bbox['x2'], bbox['y2']), (55,255,155),5)
# 各参数依次是：照片/添加的文字/左上角坐标/字体/字体大小/颜色/字体粗细
cv2.putText(image, bbox['class'], (bbox['x1']-5, bbox['y1']-5), cv2.FONT_HERSHEY_COMPLEX, 2, (255, 255, 0), 3)
print(annotation_data['file_out_path'])
cv2.imwrite(annotation_data['file_out_path'], image)
except Exception as e:
print('Exception in pascal_voc_parser: {}'.format(e))
continue
def create_zip(src_dir):
# root_home = os.path.dirname(args.parent_dir)
# JPEGImages_dir = os.path.join(args.parent_dir,'-'.format(idx) ,'JPEGImages\\')
# Annotations_dir = os.path.join(args.parent_dir, '-'.format(idx) ,'Annotations\\')
# io_utils.mkdir(JPEGImages_dir)
# io_utils.mkdir(Annotations_dir)
# io_utils.remove_all(JPEGImages_dir)
# io_utils.remove_all(Annotations_dir)
JPEGImages_dir = os.path.join(src_dir, 'JPEGImages\\')
Annotations_dir = os.path.join(src_dir, 'Annotations\\')
idx_j = 0
folder_j = 0
idx_a = 0
folder_a = 0
temp_dir = os.path.join(
src_dir, str_date[0:4] + '-' + str_date[4:6] + '-' + str_date[6:8])
for s in os.listdir(JPEGImages_dir): #JPEGImages分包
if idx_j % 200 == 0: #每200张图片操作一次,从第0张开始
if folder_a >= 1:
parent = temp_dir + '-{}'.format(folder_j - 1)
parent_zip = temp_dir + '-{}.zip'.format(folder_j - 1)
zip_dir(parent, parent_zip)
childJPEGImages_dir = os.path.join(
temp_dir + '-{}'.format(folder_j), 'JPEGImages\\')
io_utils.mkdir(childJPEGImages_dir)
io_utils.remove_all(childJPEGImages_dir) #确保目标文件夹是空白的
folder_j += 1
idx_j += 1
file = os.path.join(JPEGImages_dir, s)
io_utils.copy(file, childJPEGImages_dir)
#
parent = temp_dir + '-{}'.format(folder_j - 1)
parent_zip = temp_dir + '-{}.zip'.format(folder_j - 1)
zip_dir(parent, parent_zip)
for s in os.listdir(Annotations_dir): # JPEGImages分包
if idx_a % 200 == 0: # 每200张图片操作一次,从第0张开始
if folder_a >= 1:
parent = temp_dir + '-{}'.format(folder_a - 1)
parent_zip = temp_dir + '-{}.zip'.format(folder_a - 1)
zip_dir(parent, parent_zip)
childAnnotations_dir = os.path.join(
temp_dir + '-{}'.format(folder_a), 'Annotations\\')
io_utils.mkdir(childAnnotations_dir)
io_utils.remove_all(childAnnotations_dir)
folder_a += 1
idx_a += 1
file = os.path.join(Annotations_dir, s)
io_utils.copy(file, childAnnotations_dir)
#
parent = temp_dir + '-{}'.format(folder_a - 1)
parent_zip = temp_dir + '-{}.zip'.format(folder_a - 1)
zip_dir(parent, parent_zip)
def main():
# test config
CKPT_PATH = './output/cifar10/vgg11/rnd_0/best.ckpt'
MODEL = 'vgg11'
# create model
print("=> Creating model '{}'".format(MODEL))
model = models.cifar10.__dict__[MODEL]()
assert torch.cuda.is_available(), 'CUDA is required'
model = model.cuda()
# load checkpoint
print("=> Loading checkpoint '{}'".format(CKPT_PATH))
checkpoint = torch.load(CKPT_PATH)
print("=> Loaded checkpoint '{}' (epoch {})".format(
CKPT_PATH, checkpoint['epoch']))
assert checkpoint['model'] == MODEL, 'Inconsistent model definition'
state_dict = convert_state_dict(checkpoint['state_dict'], to_cpu=False)
model.load_state_dict(state_dict)
print('=> Preparing data...')
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(PIXEL_MEANS, PIXEL_STDS),
])
dataset = torchvision.datasets.CIFAR10(root=DATA_ROOT_DIR,
train=False,
download=False,
transform=transform)
dataset.test_data = dataset.test_data[0:100, ...]
data_loader = torch.utils.data.DataLoader(dataset,
batch_size=1,
shuffle=False)
# switch to evaluate mode
model.eval()
output_dir = osp.splitext(__file__)[0] + '_output'
mkdir(output_dir)
with torch.no_grad():
softmax = nn.Softmax(dim=1)
for batch_ind, (input, label) in enumerate(data_loader):
input = input.cuda(non_blocking=True)
# forward to get final outputs
logit = model(input)
prob = softmax(logit)
prob = prob.cpu().numpy()[0]
print(prob, label)
# get raw image, [H,W,C]
img = dataset.test_data[batch_ind]
fname = osp.join(output_dir, '%03d.jpg' % batch_ind)
print("Plotting prediction %d" % batch_ind)
plot_pred(img, prob, fname)
def copy_file(src, dst, name):
image_src_path = os.path.join(src, 'JPEGImages', name + '.jpg')
dst_dir = os.path.join(dst, 'JPEGImages')
mkdir(dst_dir)
copy(image_src_path, dst_dir)
anno_src_path = os.path.join(src, 'Annotations', name + '.xml')
dst_dir = os.path.join(dst, 'Annotations')
mkdir(dst_dir)
copy(anno_src_path, dst_dir)
def copy_all(dirs):
dest_im_dir = os.path.join(ROOT_HOME, 'data/all_data/JPEGImages')
dest_anno_dir = os.path.join(ROOT_HOME, 'data/all_data/Annotations')
mkdir(dest_anno_dir)
remove_all(dest_anno_dir)
copy_Annotationss(dirs, dest_anno_dir)
print("numbers of Annotations:{}".format(len(os.listdir(dest_anno_dir))))
mkdir(dest_im_dir)
remove_all(dest_im_dir)
copy_JPEGImagess(dirs, dest_im_dir)
print("numbers of JPEGImages:{}".format(len(os.listdir(dest_im_dir))))
def show_bar_figure(attName, modelname, data_type, dict, adv_outputs, origin_outputs, path, index, datatype):
mkdir(path)
top_k = 3
softmax_adv = F.softmax(adv_outputs[index], dim=0)
softmaxsort_adv = torch.argsort(softmax_adv)
softmax_oric = F.softmax(origin_outputs[index], dim=0)
softmaxsort_oric = torch.argsort(softmax_oric)
from matplotlib import pyplot as plt
x = []
y = []
x2 = []
y2 = []
length = len(softmaxsort_adv.data.cpu().numpy())
plt.clf()
plt.rcParams['savefig.dpi'] = 300 #图片像素
if "ImageNet" in data_type :
#print(data_type)
plt.xticks(fontsize=4)
plt.figure(figsize=(16, 12))
plt.xticks(rotation=-25)
for i in range(top_k):
ratiox = softmaxsort_adv.data.cpu().numpy()[length - 1 - i]
ratiox_oric = softmaxsort_oric.data.cpu().numpy()[length - 1 - i]
typename = dict[ratiox]
typename2 = dict[ratiox_oric]
x.append(typename)
y.append(softmax_adv.data.cpu().numpy()[ratiox])
x2.append(typename2)
value_ratioy = softmax_oric.data.cpu().numpy()[ratiox_oric]
y2.append(value_ratioy)
else:
plt.xticks(fontsize=10)
for i in range(top_k):
ratiox = softmaxsort_adv.data.cpu().numpy()[length - 1 - i]
ratiox_oric = softmaxsort_oric.data.cpu().numpy()[length - 1 - i]
typename = dict[str(ratiox)]
typename2 = dict[str(ratiox_oric)]
x.append(typename)
y.append(softmax_adv.data.cpu().numpy()[ratiox])
x2.append(typename2)
value_ratioy = softmax_oric.data.cpu().numpy()[ratiox_oric]
y2.append(value_ratioy)
plt.bar(x, y, color = 'r', align = 'center') # adv_label
plt.bar(x2, y2, color = 'g', align = 'center') # the output of cln samples
plt.ylabel('Prob value')
plt.xlabel('Type')
plt.savefig(path + "top_" + str(top_k) + "_" + str(index) + "_" + attName +"_"+modelname+ "_"+datatype + ".jpg")
def resize_images(images_path, image_dir):
new_data_dir = image_dir + '_resize'
io_utils.mkdir(new_data_dir)
new_jpg_path = image_dir + '_resize' + '/JPEGImages'
io_utils.mkdir(new_jpg_path)
new_annot_path = image_dir + '_resize' + '/Annotations'
io_utils.mkdir(new_annot_path)
for image in images_path:
a = os.path.split(image)[1][:-4]
# print(a,image)
im = cv2.imread(image)
scale = cal_scale(im.shape)
resize_im = cv2.resize(im, None, fx=(1 / scale), fy=(1 / scale))
xml_path = os.path.join(image_dir, 'Annotations', a + ".xml")
object_infos = xml_store.get_object_infos_from_xml(xml_path)
new_object_infos = resize_box(object_infos, scale)
# show_object_cv_box(new_object_infos, resize_im)
new_image_path = os.path.join(
image_dir + "_resize", 'JPEGImages',
os.path.split(image)[1][:-4] + "_resize.jpg")
# print(new_image_path)
cv2.imwrite(new_image_path, resize_im)
im_info = xml_utils.create_image_info(
os.path.split(new_image_path)[1],
os.path.split(new_image_path)[0], resize_im.shape[1],
resize_im.shape[0], resize_im.shape[2])
new_xml_path = new_annot_path
xml_store.save_annotations(new_xml_path, im_info, new_object_infos)
def save_adv_result(adv_xs, adv_labels_numpy, class_num,\
device, attack_method, data_type, save_as_black_path, label_path, save_method, args_Attack_param):
save_as_black_path = gen_attack_adv_save_path(save_as_black_path, args_Attack_param)
mkdir(save_as_black_path)
path_adv_xs = []
path_adv_ys = []
path_adv_xs_json = []
path_adv_ys_json = []
# 保存生成的攻击样
if data_type == 'cifar10' or data_type == "cifar100" or save_method==".npy":
print('saving adv samples...')
np.save(save_as_black_path + '/{}_{}_advs.npy'.format(attack_method, adv_xs.shape[0]), np.array(adv_xs))
path_adv_xs = save_as_black_path + '/{}_{}_advs.npy'.format(attack_method, adv_xs.shape[0])
path_adv_xs_json = save_as_black_path + '/{}_{}_advs.json'.format(attack_method, adv_xs.shape[0])
save_json(path_adv_xs_json, adv_xs)
print('saving adv labels...')
# convert the adv_labels_numpy in vector type
ys_save = []
for i in range(adv_labels_numpy.shape[0]):
y = np.zeros((1, class_num), dtype = np.uint8)
y[0][adv_labels_numpy[i]] = 1
ys_save.append(y[0])
np.save(save_as_black_path + '/{}_{}_adv_preds_labels.npy'.format(attack_method, adv_xs.shape[0]), np.array(ys_save))
path_adv_ys = save_as_black_path + '/{}_{}_adv_preds_labels.npy'.format(attack_method, adv_xs.shape[0])
path_adv_ys_json = save_as_black_path + '/{}_{}_adv_preds_labels.json'.format(attack_method, adv_xs.shape[0])
save_json(path_adv_ys_json, torch.from_numpy(np.array(ys_save)))
else:
# 保存成图片方式
# 原始的一些图片和label信息
print(label_path,"Saving in Image Model")
image_names, label_list, number = get_label_lines(label_path)
val_temp_path_name = "/Image/"
image_temp_path_name = "/Image/Adv_Images/"
save_val_path = save_as_black_path + val_temp_path_name
mkdir(save_val_path)
save_image_path = save_as_black_path + image_temp_path_name
mkdir(save_image_path)
val_file_name_adv_preds = save_val_path + "adv_preds_val_" + str(number) + '.txt'
val_file_name_origins = save_val_path + "origins_val_" + str(number) + '.txt'
with open(val_file_name_adv_preds, 'w') as f_adv:
with open(val_file_name_origins, 'w') as f_origin:
for i in range(adv_labels_numpy.shape[0]):
tensor_x = adv_xs[i]
path_name = "Adv_" + image_names[i]
resize_shape = (tensor_x.shape[1], tensor_x.shape[2])
adv_one_xs_resize = preprocess(image = tensor_x, resize = resize_shape, device = device)
vutils.save_image(adv_one_xs_resize.cpu(), save_image_path + path_name)
content_adv = path_name + " " + str(adv_labels_numpy[i]) + "\n"
f_adv.write(content_adv)
# content_origin = path_name + " " + str(cln_labels_numpy[i]) + "\n"
# f_origin.write(content_origin)
f_adv.close()
f_origin.close()
return path_adv_xs, path_adv_ys, path_adv_xs_json, path_adv_ys_json
copy(anno_src_path, dst_dir)
parser = argparse.ArgumentParser(description='Get the data info')
parser.add_argument('-d',
'--data_dir',
help='the folder of data',
default='/home/syh/train_data/data/all_train_data_resize2')
parser.add_argument('-s',
'--save_path',
help='the folder of data',
default='/home/syh/train_data/data/all_train_data_resize2')
parser.add_argument('-id',
'--label_name',
help='the folder of data',
default='wrong')
args = parser.parse_args()
if __name__ == '__main__':
input_path = args.data_dir
label_name = args.label_name
save_path = args.save_path
save_path = '{}_{}'.format(args.save_path, label_name)
mkdir(save_path)
ids = search(input_path, label_name)
for id in ids:
copy_file(input_path, save_path, id)
def main():
# fix random seed
np.random.seed(0)
# aliases
nb_samples = args.nb_samples
sample_ndim = args.sample_ndim
sample_iter = args.sample_iter
mat_root_dir = args.mat_dir
seed0 = args.s0
seed1 = args.s1
mat_prefix = args.mat_prefix
mat_prefix2 = mat_prefix if args.mat_prefix2 is None else args.mat_prefix2
epsilon = args.eps
# setup output and logger
output_dir = mat_root_dir.replace('matrix', 'max_match')
output_dir = osp.join(output_dir, mat_prefix,
'rnd_{}_{}'.format(seed0, seed1))
output_dir = mkdir(output_dir)
logger = create_logger(output_dir,
log_file='eps_{:.3f}'.format(epsilon),
enable_console=True)
logger.info('arguments:\n' + pprint.pformat(args))
# load features
mat_path0 = osp.join(mat_root_dir, 'rnd_{}'.format(seed0),
mat_prefix + '.npz')
mat_path1 = osp.join(mat_root_dir, 'rnd_{}'.format(seed1),
mat_prefix2 + '.npz')
logger.info('Loading mat_path0: {}'.format(mat_path0))
mat_dict0 = np.load(mat_path0)
logger.info('Loading mat_path1: {}'.format(mat_path1))
mat_dict1 = np.load(mat_path1)
if args.target_layer is None:
layers = mat_dict0.keys()
else:
layers = [args.target_layer]
logger.info('target layers: {}'.format(layers))
match_dict = OrderedDict()
for layer in layers:
logger.info('=> Calculating layer {} ...'.format(layer))
# lazy load
tic = time.time()
mat0 = mat_dict0[layer]
mat1 = mat_dict1[layer]
toc = time.time()
print('Loaded data with {:.2f}s'.format(toc - tic))
# reshape
mat0 = mat0[:nb_samples, ...]
mat1 = mat1[:nb_samples, ...]
# mat1 = mat1[np.random.permutation(nb_samples), ...]
logger.info("mat0 with shape {}".format(mat0.shape))
logger.info("mat1 with shape {}".format(mat1.shape))
if 'classifier' in layer:
mat0 = mat0.reshape([mat0.shape[0], -1]).transpose()
mat1 = mat1.reshape([mat1.shape[0], -1]).transpose()
assert mat0.shape[1] == mat1.shape[
1], 'Check the dimension of each feature vector'
# # check norm of features
# norm0 = np.linalg.norm(mat0, axis=1)
# norm1 = np.linalg.norm(mat1, axis=1)
# mean_norm0 = np.mean(norm0) / np.sqrt(mat0.shape[1])
# mean_norm1 = np.mean(norm1) / np.sqrt(mat1.shape[1])
# logger.info("mean norm0 = {:.3f}, mean norm1 = {:.3f}".format(mean_norm0, mean_norm1))
# # check how many neurons are inactive
# norm0 = np.linalg.norm(mat0, axis=0) / np.sqrt(len(mat0))
# norm1 = np.linalg.norm(mat1, axis=0) / np.sqrt(len(mat1))
# inactive0 = np.sum(norm0 < 1e-3) / mat0.shape[1]
# inactive1 = np.sum(norm1 < 1e-3) / mat1.shape[1]
# logger.info("inactive ratio0 = {:.2f}%, "
# "inactive ratio1 = {:.2f}%"
# .format(100 * inactive0, 100 * inactive1))
# logger.info(np.histogram(mat0.ravel(), bins=10))
# logger.info(np.histogram(mat1.ravel(), bins=10))
X = mat0
Y = mat1
max_epsilon = find_maximal_epsilon(X, Y)
logger.info('max epsilon={:.3f}'.format(max_epsilon))
tic = time.time()
idx_X, idx_Y = find_maximal_match(X, Y, epsilon)
toc = time.time()
logger.info('Find max match with {:.2f}s'.format(toc - tic))
mms = float(len(idx_X) + len(idx_Y)) / (len(X) + len(Y))
logger.info("==> {}: max match similarity={:.2f}%".format(
layer, 100 * mms))
match_dict[layer] = {
'idx_X': idx_X,
'idx_Y': idx_Y,
'similarity': mms,
'max_epsilon': max_epsilon,
}
elif 'features' in layer:
# [N, C, H, W] -> [C, N, H, W]
mat0 = mat0.transpose([1, 0, 2, 3])
mat1 = mat1.transpose([1, 0, 2, 3])
mat0 = mat0.reshape([mat0.shape[0], -1])
mat1 = mat1.reshape([mat1.shape[0], -1])
assert mat0.shape[1] == mat1.shape[
1], 'Check the sizes of two sets'
# logger.info(np.histogram(mat0.ravel(), bins=10))
# logger.info(np.histogram(mat1.ravel(), bins=10))
layer_dict = {
'idx_X': [],
'idx_Y': [],
'similarity': [],
'max_epsilon': [],
}
tic = time.time()
for iter in range(sample_iter):
sample_idx = np.random.choice(mat0.shape[1],
sample_ndim,
replace=False)
X = mat0[:, sample_idx]
Y = mat1[:, sample_idx]
idx_X, idx_Y = find_maximal_match(X, Y, epsilon)
mms = float(len(idx_X) + len(idx_Y)) / (len(X) + len(Y))
max_epsilon = find_maximal_epsilon(X, Y)
layer_dict['idx_X'].append(idx_X)
layer_dict['idx_Y'].append(idx_Y)
layer_dict['similarity'].append(mms)
layer_dict['max_epsilon'].append(max_epsilon)
print('Sampling iter {}: mms = {:.2f}%, max_epsilon = {:.3f}'.
format(iter, 100 * mms, max_epsilon))
toc = time.time()
logger.info('find max match with {:.2f}s'.format(toc - tic))
logger.info("==> {}: max match similarity={:.2f}%".format(
layer, 100 * np.mean(layer_dict['similarity'])))
match_dict[layer] = layer_dict
else:
raise NotImplementedError()
fname = osp.join(output_dir, 'eps_{:.3f}.pkl'.format(epsilon))
write_pkl(match_dict, fname)
logger.info("finish")
return obj_info
def mutil_process():
all_data = get_images(image_dir)
cpus = 10
p = multiprocessing.pool.Pool(cpus)
p.map_async(resize_image, all_data)
p.close()
p.join()
image_dir = '/home/syh/train_data/test_data'
new_data_dir = image_dir + '_resize'
io_utils.mkdir(new_data_dir)
new_jpg_path = image_dir + '_resize' + '/JPEGImages'
io_utils.mkdir(new_jpg_path)
new_annot_path = image_dir + '_resize' + '/Annotations'
io_utils.mkdir(new_annot_path)
# parser = argparse.ArgumentParser(description='Get the data info')
# parser.add_argument('-p', '--parent_data',help='the parent folder of data', default='/home/syh/train_data/data/')
# parser.add_argument('-d', '--datadir',help='the folder of data', default='all_train_data_resize2')
# args = parser.parse_args()
if __name__ == "__main__":
images_path = get_images(image_dir)
# resize_images(images_path,image_dir)
mutil_process()
def main():
# load config
cfg = importlib.import_module('configs.cifar10.{}'.format(args.config)).config
# accuracy
best_acc = 0
best_epoch = 0
start_epoch = 0
# fix random seed
if args.rng_seed is not None:
rng_seed = args.rng_seed
else:
rng_seed = cfg.TRAIN.rng_seed
random.seed(rng_seed)
np.random.seed(rng_seed)
torch.manual_seed(rng_seed)
# setup output and logger
output_dir = mkdir(osp.join(OUTPUT_ROOT_DIR, args.config, 'rnd_%d' % rng_seed))
logger = create_logger(output_dir)
logger.info('config:\n' + pprint.pformat(cfg))
logger.info('arguments:\n' + pprint.pformat(args))
logger.info('gpu(s): ' + str(os.environ.get('CUDA_VISIBLE_DEVICES')))
print("=> Creating model '{}'".format(cfg.model))
model = models.cifar10.__dict__[cfg.model]()
module_dict = dict(model.named_modules())
logger.info('module:\n' + pprint.pformat(module_dict))
# define loss function (criterion)
criterion = nn.CrossEntropyLoss()
# gpu support
assert torch.cuda.is_available(), 'Training requires cuda'
# if the input size is fixed, enable it
import torch.backends.cudnn as cudnn
cudnn.benchmark = True
# cudnn.deterministic = True
# enable DataParallel, default use all cuda devices
model = nn.DataParallel(model).cuda()
# model = model.cuda()
criterion = criterion.cuda()
# define optimizer
optimizer = torch.optim.SGD(model.parameters(), cfg.TRAIN.lr,
momentum=cfg.TRAIN.momentum, weight_decay=cfg.TRAIN.wd)
# optionally resume from a checkpoint
if args.resume:
if osp.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
best_acc = checkpoint['best_acc']
best_epoch = checkpoint['best_epoch']
start_epoch = checkpoint['epoch']
model.load_state_dict(checkpoint['state_dict'])
if not args.eval:
optimizer.load_state_dict(checkpoint['optimizer'])
logger.info("=> loaded checkpoint '{}' (epoch {})".format(args.resume, checkpoint['epoch']))
else:
logger.warn("=> no checkpoint found at '{}'".format(args.resume))
# load data
print('=> Preparing data')
transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(), # transform into [0.0, 1.0]
transforms.Normalize(PIXEL_MEANS, PIXEL_STDS),
])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(PIXEL_MEANS, PIXEL_STDS),
])
train_set = torchvision.datasets.CIFAR10(root=DATA_ROOT_DIR, train=True, download=True, transform=transform_train)
train_loader = torch.utils.data.DataLoader(train_set, batch_size=cfg.TRAIN.batch_size,
shuffle=True, num_workers=args.num_worker)
val_set = torchvision.datasets.CIFAR10(root=DATA_ROOT_DIR, train=False, download=True, transform=transform_test)
val_loader = torch.utils.data.DataLoader(val_set, batch_size=cfg.TEST.batch_size,
shuffle=False, num_workers=args.num_worker)
if args.eval:
logger.info('evaluating trained model')
acc = validate(val_loader, model, criterion)
logger.info(
'Val-Epoch: [{0}]\t'
'Prec@1: {acc:.3f})'.format(start_epoch, acc=acc)
)
return
def do_checkpoint(epoch, path):
torch.save({
'epoch': epoch,
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
'model': cfg.model,
'best_acc': best_acc,
'best_epoch': best_epoch,
}, path)
# save initialization state
do_checkpoint(0, osp.join(output_dir, 'init.ckpt'))
for epoch in range(start_epoch, cfg.TRAIN.end_epoch):
adjust_learning_rate(optimizer, epoch, cfg.TRAIN.lr, cfg.TRAIN.lr_step)
# train for one epoch
epoch_result = train(train_loader, model, criterion, optimizer, epoch)
logger.info(
'Train-Epoch: [{0}]\t'
'Loss: {loss:.4f}\t'
'Prec@1: {acc:.3f}'.format(
epoch + 1, **epoch_result)
)
# evaluate on validation set
acc = validate(val_loader, model, criterion)
logger.info(
'Val-Epoch: [{0}]\t'
'Prec@1: {acc:.3f}'.format(
epoch + 1, acc=acc)
)
# remember best acc and save checkpoint
is_best = acc > best_acc
epoch_t = epoch + 1
if is_best:
best_epoch = epoch_t
best_acc = acc
do_checkpoint(best_epoch, osp.join(output_dir, 'best.ckpt'))
if (args.ckpt_interval is not None) and (epoch_t % args.ckpt_interval == 0):
do_checkpoint(epoch_t, osp.join(output_dir, '%03d.ckpt' % epoch_t))
logger.info(
'=> Best-Epoch: [{0}]\t'
'Prec@1: {acc:.3f}'.format(
best_epoch, acc=best_acc)
)
# save_path = os.path.join(args.input, 'crop_commdity')
# else:
# save_path = args.output
def main(data_path, save_path):
all_data = get_data(data_path)
cpus = cpu_count() // 2 #取整除
p = Pool(cpus)
p.map_async(process, all_data)
p.close()
p.join()
if __name__ == '__main__':
data_path = args.input
if args.output == '':
save_path = os.path.join(args.input, 'crop_commdity')
else:
save_path = os.path.join(args.output, 'crop_commdity')
io_utils.mkdir(save_path)
main(data_path, save_path)
print('finished')
"""
cd /home/syh/RetinaNet/data_processing
"""
def Save_Eval_Visualization_Result(attName, data_type, file_name, Dict_path, device, adv_xs_npy, save_base_path,\
IS_COMPARE_MODEL, model_name, defense_model_name = None,\
model = None, defense_model = None, CAM_layer=28,\
image_origin_path = None, label_path = None,\
black_adv_outputs = None, black_origin_outputs = None,\
black_defense_adv_outputs = None, black_defense_origin_outputs = None, topk_show_list = None):
dict_path = Dict_path
dict_meta_batch = read_dict_from_file(dict_path)
if 'ImageNet' in data_type:
_, _, paths_number = get_label_lines(label_path)
path_index = file_name.split(".")[0]
base_path = save_base_path + "/" + str(attName[0]) + "/" + path_index
mkdir(base_path)
topk_path = base_path + "/topk/"
mkdir(topk_path)
CAM_path = base_path + "/OriginSample_"
CAM_pathAttack = base_path + "/AttackSample_"
# 展示的分类概率的数目
topk_number = paths_number
adv_outputs = torch.from_numpy(black_adv_outputs)
origin_outputs = torch.from_numpy(black_origin_outputs)
r_v = Rebust_Visual(attName, model_name, dict_meta_batch, adv_outputs, origin_outputs, topk_path, topk_number, "ImageNet", topk_show_list)
r_v.gen_visualization()
if IS_COMPARE_MODEL:
r_v_defense = Rebust_Visual(attName, defense_model_name, dict_meta_batch, adv_outputs, origin_outputs, topk_path, topk_number, "ImageNet", topk_show_list)
r_v_defense.gen_visualization()
Crop_ImageSize = (224, 224)
#print(topk_show_list)
if topk_show_list == None:
for i in range(paths_number):
save_cam_result(image_origin_path, i, Crop_ImageSize, adv_xs_npy, device, \
model, CAM_layer, CAM_path, CAM_pathAttack, model_name, IS_COMPARE_MODEL \
, defense_model, defense_model_name)
else:
for index in topk_show_list:
save_cam_result(image_origin_path, int(index), Crop_ImageSize, adv_xs_npy, device, \
model, CAM_layer, CAM_path, CAM_pathAttack, model_name, IS_COMPARE_MODEL \
, defense_model, defense_model_name)
elif 'cifar10' in data_type:
topk_number = int(adv_xs_npy.shape[0] * 0.5)
adv_outputs = torch.from_numpy(black_adv_outputs)
origin_outputs = torch.from_numpy(black_origin_outputs)
# 展示的分类概率的数目
path_index = file_name.split(".")[0]
base_path = save_base_path + "/"+str(attName[0])+"/" + path_index
mkdir(base_path)
topk_path = base_path + "/topk/"
mkdir(topk_path)
r_v = Rebust_Visual(attName, model_name, dict_meta_batch, adv_outputs, origin_outputs,
topk_path, topk_number, data_type, topk_show_list)
r_v.gen_visualization()
if IS_COMPARE_MODEL:
topk_defense_number = int(adv_xs_npy.shape[0] * 0.5)
adv_defense_outputs = torch.from_numpy(black_defense_adv_outputs)
origin_defense_outputs = torch.from_numpy(black_defense_origin_outputs)
r_v_defense = Rebust_Visual(attName, defense_model_name, dict_meta_batch, adv_defense_outputs,
origin_defense_outputs,
topk_path, topk_defense_number, data_type, topk_show_list)
r_v_defense.gen_visualization()
else:
topk_number = int(adv_xs_npy.shape[0] * 0.5)
adv_outputs = torch.from_numpy(black_adv_outputs)
origin_outputs = torch.from_numpy(black_origin_outputs)
# 展示的分类概率的数目
path_index = file_name.split(".")[0]
base_path = save_base_path + "/" + str(attName[0]) + "/" + path_index
mkdir(base_path)
topk_path = base_path + "/topk/"
mkdir(topk_path)
r_v = Rebust_Visual(attName, model_name, dict_meta_batch, adv_outputs, origin_outputs,
topk_path, topk_number, data_type, topk_show_list)
r_v.gen_visualization()
if IS_COMPARE_MODEL:
topk_defense_number = int(adv_xs_npy.shape[0] * 0.5)
adv_defense_outputs = torch.from_numpy(black_defense_adv_outputs)
origin_defense_outputs = torch.from_numpy(black_defense_origin_outputs)
r_v_defense = Rebust_Visual(attName, defense_model_name, dict_meta_batch, adv_defense_outputs,
origin_defense_outputs, topk_path, topk_defense_number, data_type, topk_show_list)
r_v_defense.gen_visualization()
def main():
# setup output and logger
assert osp.exists(
args.ckpt), "Checkpoint path '{}' does not exist.".format(args.ckpt)
output_path = osp.splitext(args.ckpt)[0]
output_path = output_path.replace('cifar10', 'cifar10_matrix')
output_path += '_train' if args.train else '_test'
output_dir = mkdir(osp.dirname(output_path))
logger = create_logger(output_dir,
log_file=osp.basename(output_path),
enable_console=True)
logger.info('arguments:\n' + pprint.pformat(args))
print("=> Creating model '{}'".format(args.model))
model = models.cifar10.__dict__[args.model]()
assert torch.cuda.is_available(), 'CUDA is required'
model = model.cuda()
print("=> Loading checkpoint '{}'".format(args.ckpt))
checkpoint = torch.load(args.ckpt)
logger.info("=> Loaded checkpoint '{}' (epoch {})".format(
args.ckpt, checkpoint['epoch']))
assert checkpoint['model'] == args.model, 'Inconsistent model definition'
# remove module prefix if you use multiple gpus for training
state_dict = convert_state_dict(checkpoint['state_dict'])
model.load_state_dict(state_dict)
print('=> Preparing data...')
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(PIXEL_MEANS, PIXEL_STDS),
])
dataset = torchvision.datasets.CIFAR10(root=DATA_ROOT_DIR,
train=args.train,
download=False,
transform=transform)
if args.train:
dataset.train_data = dataset.train_data[:args.nb_samples,
...] # allow nb_samples to be None
else:
dataset.test_data = dataset.test_data[:args.nb_samples, ...]
data_loader = torch.utils.data.DataLoader(dataset,
batch_size=args.batch_size,
shuffle=False)
# sanity check
acc = validate(data_loader, model)
logger.info('=> Sanity check\t' 'Prec@1: {acc:.3f}'.format(acc=acc))
# setup feature extractor
feature_extractor = FeatureExtractor(model)
if args.target_layer is not None: # assign certain layer
target_layers = (args.target_layer, )
target_types = (nn.Module, )
output_path += '_{}'.format(args.target_layer)
elif args.target_type is not None: # assign certain type
target_layers = feature_extractor.parse_default_layers()
target_types = feature_extractor.parse_type(args.target_type)
output_path += '_{}'.format(args.target_type)
else:
target_layers = feature_extractor.parse_default_layers()
target_types = (nn.Module, )
feature_extractor.append_target_layers(target_layers, target_types)
logger.info('module:\n' + pprint.pformat(feature_extractor.module_dict))
logger.info('target_layers:\n' +
pprint.pformat(feature_extractor.target_outputs.keys()))
predicate(data_loader, feature_extractor, output_path)
print("=> finish")