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")