diff --git a/dist/fawkes-0.0.1-py3-none-any.whl b/dist/fawkes-0.0.1-py3-none-any.whl deleted file mode 100644 index a45d1ca..0000000 Binary files a/dist/fawkes-0.0.1-py3-none-any.whl and /dev/null differ diff --git a/dist/fawkes-0.0.1.tar.gz b/dist/fawkes-0.0.1.tar.gz deleted file mode 100644 index 33dc352..0000000 Binary files a/dist/fawkes-0.0.1.tar.gz and /dev/null differ diff --git a/fawkes/__init__.py b/fawkes/__init__.py index e69de29..1c4f29b 100644 --- a/fawkes/__init__.py +++ b/fawkes/__init__.py @@ -0,0 +1,24 @@ +# -*- coding: utf-8 -*- +# @Date : 2020-07-01 +# @Author : Shawn Shan (shansixiong@cs.uchicago.edu) +# @Link : https://www.shawnshan.com/ + + +__version__ = '0.0.2' + +from .differentiator import FawkesMaskGeneration +from .utils import load_extractor, init_gpu, select_target_label, dump_image, reverse_process_cloaked, \ + Faces +from .protection import main +import logging +import sys +import os +logging.getLogger('tensorflow').disabled = True + + +__all__ = ( + '__version__', + 'FawkesMaskGeneration', 'load_extractor', + 'init_gpu', + 'select_target_label', 'dump_image', 'reverse_process_cloaked', 'Faces', 'main' +) \ No newline at end of file diff --git a/fawkes/__main__.py b/fawkes/__main__.py new file mode 100644 index 0000000..b8315cf --- /dev/null +++ b/fawkes/__main__.py @@ -0,0 +1,4 @@ +from .protection import main + +if __name__ == '__main__': + main() diff --git a/fawkes/__pycache__/align_face.cpython-36.pyc b/fawkes/__pycache__/align_face.cpython-36.pyc index f843b43..ab5f8cd 100644 Binary files a/fawkes/__pycache__/align_face.cpython-36.pyc and b/fawkes/__pycache__/align_face.cpython-36.pyc differ diff --git a/fawkes/__pycache__/detect_face.cpython-36.pyc b/fawkes/__pycache__/detect_face.cpython-36.pyc index ce8b893..8ee42f7 100644 Binary files a/fawkes/__pycache__/detect_face.cpython-36.pyc and b/fawkes/__pycache__/detect_face.cpython-36.pyc differ diff --git a/fawkes/__pycache__/differentiator.cpython-36.pyc b/fawkes/__pycache__/differentiator.cpython-36.pyc index fc55780..0b8b35f 100644 Binary files a/fawkes/__pycache__/differentiator.cpython-36.pyc and b/fawkes/__pycache__/differentiator.cpython-36.pyc differ diff --git a/fawkes/__pycache__/utils.cpython-36.pyc b/fawkes/__pycache__/utils.cpython-36.pyc index c1e14d5..fba5d6f 100644 Binary files a/fawkes/__pycache__/utils.cpython-36.pyc and b/fawkes/__pycache__/utils.cpython-36.pyc differ diff --git a/fawkes/align_face.py b/fawkes/align_face.py index cf762b2..0d7aa96 100644 --- a/fawkes/align_face.py +++ b/fawkes/align_face.py @@ -1,6 +1,5 @@ -import detect_face +from .detect_face import detect_face, create_mtcnn import numpy as np -import tensorflow as tf # modify the default parameters of np.load np_load_old = np.load @@ -15,7 +14,7 @@ def to_rgb(img): def aligner(sess): - pnet, rnet, onet = detect_face.create_mtcnn(sess, None) + pnet, rnet, onet = create_mtcnn(sess, None) return [pnet, rnet, onet] @@ -31,7 +30,7 @@ def align(orig_img, aligner, margin=0.8, detect_multiple_faces=True): orig_img = to_rgb(orig_img) orig_img = orig_img[:, :, 0:3] - bounding_boxes, _ = detect_face.detect_face(orig_img, minsize, pnet, rnet, onet, threshold, factor) + bounding_boxes, _ = detect_face(orig_img, minsize, pnet, rnet, onet, threshold, factor) nrof_faces = bounding_boxes.shape[0] if nrof_faces > 0: det = bounding_boxes[:, 0:4] diff --git a/fawkes/detect_face.py b/fawkes/detect_face.py index 54c67a2..dff56c0 100644 --- a/fawkes/detect_face.py +++ b/fawkes/detect_face.py @@ -29,7 +29,6 @@ from __future__ import print_function import os -# from math import floor import cv2 import numpy as np import tensorflow as tf diff --git a/fawkes/differentiator.py b/fawkes/differentiator.py index 2fd9175..98a46e0 100644 --- a/fawkes/differentiator.py +++ b/fawkes/differentiator.py @@ -10,7 +10,7 @@ from decimal import Decimal import numpy as np import tensorflow as tf -from utils import preprocess, reverse_preprocess +from .utils import preprocess, reverse_preprocess class FawkesMaskGeneration: diff --git a/fawkes/protection.py b/fawkes/protection.py index 9df50fb..da04387 100644 --- a/fawkes/protection.py +++ b/fawkes/protection.py @@ -1,3 +1,7 @@ +# from __future__ import absolute_import +# from __future__ import division +# from __future__ import print_function + import argparse import glob import os @@ -5,26 +9,28 @@ import random import sys import numpy as np -from differentiator import FawkesMaskGeneration -from utils import load_extractor, init_gpu, select_target_label, dump_image, reverse_process_cloaked, \ + +from .differentiator import FawkesMaskGeneration +from .utils import load_extractor, init_gpu, select_target_label, dump_image, reverse_process_cloaked, \ Faces random.seed(12243) np.random.seed(122412) -BATCH_SIZE = 10 +BATCH_SIZE = 32 -def generate_cloak_images(sess, feature_extractors, image_X, target_emb=None, th=0.01, faces=None): +def generate_cloak_images(sess, feature_extractors, image_X, target_emb=None, th=0.01, faces=None, sd=1e9, lr=2, + max_step=500): batch_size = BATCH_SIZE if len(image_X) > BATCH_SIZE else len(image_X) differentiator = FawkesMaskGeneration(sess, feature_extractors, batch_size=batch_size, mimic_img=True, intensity_range='imagenet', - initial_const=args.sd, - learning_rate=args.lr, - max_iterations=args.max_step, + initial_const=sd, + learning_rate=lr, + max_iterations=max_step, l_threshold=th, verbose=1, maximize=False, keep_final=False, image_shape=image_X.shape[1:], faces=faces) @@ -33,26 +39,6 @@ def generate_cloak_images(sess, feature_extractors, image_X, target_emb=None, th return cloaked_image_X -def get_mode_config(mode): - if mode == 'low': - args.feature_extractor = "low_extract" - # args.th = 0.003 - args.th = 0.001 - elif mode == 'mid': - args.feature_extractor = "mid_extract" - args.th = 0.004 - elif mode == 'high': - args.feature_extractor = "high_extract" - args.th = 0.004 - elif mode == 'ultra': - args.feature_extractor = "high_extract" - args.th = 0.03 - elif mode == 'custom': - pass - else: - raise Exception("mode must be one of 'low', 'mid', 'high', 'ultra', 'custom'") - - def check_imgs(imgs): if np.max(imgs) <= 1 and np.min(imgs) >= 0: imgs = imgs * 255.0 @@ -63,20 +49,72 @@ def check_imgs(imgs): return imgs -def fawkes(): +def main(*argv): + if not argv: + argv = list(sys.argv) + + # attach SIGPIPE handler to properly handle broken pipe + try: # sigpipe not available under windows. just ignore in this case + import signal + signal.signal(signal.SIGPIPE, signal.SIG_DFL) + except Exception as e: + pass + + parser = argparse.ArgumentParser() + parser.add_argument('--directory', '-d', type=str, + help='directory that contain images for cloaking', default='imgs/') + + parser.add_argument('--gpu', type=str, + help='GPU id', default='0') + + parser.add_argument('--mode', type=str, + help='cloak generation mode', default='high') + parser.add_argument('--feature-extractor', type=str, + help="name of the feature extractor used for optimization", + default="high_extract") + + parser.add_argument('--th', type=float, default=0.01) + parser.add_argument('--max-step', type=int, default=500) + parser.add_argument('--sd', type=int, default=1e9) + parser.add_argument('--lr', type=float, default=2) + + parser.add_argument('--separate_target', action='store_true') + + parser.add_argument('--format', type=str, + help="final image format", + default="jpg") + args = parser.parse_args(argv[1:]) + + if args.mode == 'low': + args.feature_extractor = "high_extract" + args.th = 0.003 + elif args.mode == 'mid': + args.feature_extractor = "high_extract" + args.th = 0.005 + elif args.mode == 'high': + args.feature_extractor = "high_extract" + args.th = 0.007 + elif args.mode == 'ultra': + args.feature_extractor = "high_extract" + args.th = 0.01 + elif args.mode == 'custom': + pass + else: + raise Exception("mode must be one of 'low', 'mid', 'high', 'ultra', 'custom'") + assert args.format in ['png', 'jpg', 'jpeg'] if args.format == 'jpg': args.format = 'jpeg' - get_mode_config(args.mode) sess = init_gpu(args.gpu) - # feature_extractors_ls = [load_extractor(args.feature_extractor)] - # fs_names = ['mid_extract', 'high_extract'] fs_names = [args.feature_extractor] feature_extractors_ls = [load_extractor(name) for name in fs_names] image_paths = glob.glob(os.path.join(args.directory, "*")) image_paths = [path for path in image_paths if "_cloaked" not in path.split("/")[-1]] + if not image_paths: + print("No images in the directory") + exit(1) faces = Faces(image_paths, sess) @@ -94,7 +132,8 @@ def fawkes(): target_embedding = select_target_label(orginal_images, feature_extractors_ls, fs_names) protected_images = generate_cloak_images(sess, feature_extractors_ls, orginal_images, - target_emb=target_embedding, th=args.th, faces=faces) + target_emb=target_embedding, th=args.th, faces=faces, sd=args.sd, + lr=args.lr, max_step=args.max_step) faces.cloaked_cropped_faces = protected_images @@ -102,42 +141,9 @@ def fawkes(): final_images = faces.merge_faces(cloak_perturbation) for p_img, cloaked_img, path in zip(final_images, protected_images, image_paths): - file_name = "{}_{}_{}_{}_cloaked.{}".format(".".join(path.split(".")[:-1]), args.mode, args.th, - args.feature_extractor, args.format) + file_name = "{}_{}_{}_cloaked.{}".format(".".join(path.split(".")[:-1]), args.mode, args.th, args.format) dump_image(p_img, file_name, format=args.format) - # - # file_name = "{}_{}_{}_{}_cloaked_cropped.png".format(".".join(path.split(".")[:-1]), args.mode, args.th, - # args.feature_extractor) - # dump_image(reverse_process_cloaked(cloaked_img), file_name, format="png") - - -def parse_arguments(argv): - parser = argparse.ArgumentParser() - parser.add_argument('--directory', '-d', type=str, - help='directory that contain images for cloaking', default='imgs/') - - parser.add_argument('--gpu', type=str, - help='GPU id', default='0') - - parser.add_argument('--mode', type=str, - help='cloak generation mode', default='high') - parser.add_argument('--feature-extractor', type=str, - help="name of the feature extractor used for optimization", - default="high_extract") - - parser.add_argument('--th', type=float, default=0.01) - parser.add_argument('--max-step', type=int, default=200) - parser.add_argument('--sd', type=int, default=1e9) - parser.add_argument('--lr', type=float, default=10) - - parser.add_argument('--separate_target', action='store_true') - - parser.add_argument('--format', type=str, - help="final image format", - default="jpg") - return parser.parse_args(argv) if __name__ == '__main__': - args = parse_arguments(sys.argv[1:]) - fawkes() + main(*sys.argv) diff --git a/fawkes/utils.py b/fawkes/utils.py index 4083ac2..6f8f590 100644 --- a/fawkes/utils.py +++ b/fawkes/utils.py @@ -4,21 +4,26 @@ import json import os import pickle import random +import sys +stderr = sys.stderr +sys.stderr = open(os.devnull, 'w') import keras + +sys.stderr = stderr import keras.backend as K import numpy as np import tensorflow as tf -from align_face import align, aligner -from keras.applications.vgg16 import preprocess_input +from PIL import Image, ExifTags +# from keras.applications.vgg16 import preprocess_input from keras.layers import Dense, Activation from keras.models import Model from keras.preprocessing import image from keras.utils import get_file -from keras.utils import to_categorical from skimage.transform import resize from sklearn.metrics import pairwise_distances -from PIL import Image, ExifTags + +from .align_face import align, aligner def clip_img(X, preprocessing='raw'): @@ -81,7 +86,14 @@ class Faces(object): self.cropped_index.extend(cur_index) self.callback_idx.extend([i] * len(cur_faces_square)) - self.cropped_faces = preprocess_input(np.array(self.cropped_faces)) + if not self.cropped_faces: + print("No faces detected") + exit(1) + + self.cropped_faces = np.array(self.cropped_faces) + + self.cropped_faces = preprocess(self.cropped_faces, 'imagenet') + self.cloaked_cropped_faces = None self.cloaked_faces = np.copy(self.org_faces) @@ -89,8 +101,6 @@ class Faces(object): return self.cropped_faces def merge_faces(self, cloaks): - # import pdb - # pdb.set_trace() self.cloaked_faces = np.copy(self.org_faces) @@ -300,7 +310,6 @@ def load_extractor(name): return model - def get_dataset_path(dataset): model_dir = os.path.join(os.path.expanduser('~'), '.fawkes') if not os.path.exists(os.path.join(model_dir, "config.json")): @@ -335,7 +344,7 @@ def load_dir(path): im = image.img_to_array(im) x_ls.append(im) raw_x = np.array(x_ls) - return preprocess_input(raw_x) + return preprocess(raw_x, 'imagenet') def load_embeddings(feature_extractors_names): @@ -394,10 +403,19 @@ def select_target_label(imgs, feature_extractors_ls, feature_extractors_names, m max_sum = np.min(pair_dist, axis=0) max_id = np.argmax(max_sum) - image_paths = glob.glob(os.path.join(model_dir, "target_data/{}/*".format(paths[int(max_id)]))) + target_data_id = paths[int(max_id)] + image_dir = os.path.join(model_dir, "target_data/{}/*".format(target_data_id)) + if not os.path.exists(image_dir): + get_file("{}.h5".format(name), "http://sandlab.cs.uchicago.edu/fawkes/files/target_images".format(name), + cache_dir=model_dir, cache_subdir='') + + image_paths = glob.glob(image_dir) + target_images = [image.img_to_array(image.load_img(cur_path)) for cur_path in image_paths] - target_images = preprocess_input(np.array([resize(x, (224, 224)) for x in target_images])) + + target_images = np.array([resize(x, (224, 224)) for x in target_images]) + target_images = preprocess(target_images, 'imagenet') target_images = list(target_images) while len(target_images) < len(imgs): @@ -406,152 +424,151 @@ def select_target_label(imgs, feature_extractors_ls, feature_extractors_names, m target_images = random.sample(target_images, len(imgs)) return np.array(target_images) - -class CloakData(object): - def __init__(self, protect_directory=None, img_shape=(224, 224)): - - self.img_shape = img_shape - # self.train_data_dir, self.test_data_dir, self.number_classes, self.number_samples = get_dataset_path(dataset) - # self.all_labels = sorted(list(os.listdir(self.train_data_dir))) - self.protect_directory = protect_directory - - self.protect_X = self.load_label_data(self.protect_directory) - - self.cloaked_protect_train_X = None - - self.label2path_train, self.label2path_test, self.path2idx = self.build_data_mapping() - self.all_training_path = self.get_all_data_path(self.label2path_train) - self.all_test_path = self.get_all_data_path(self.label2path_test) - self.protect_class_path = self.get_class_image_files(os.path.join(self.train_data_dir, self.protect_class)) - - def get_class_image_files(self, path): - return [os.path.join(path, f) for f in os.listdir(path)] - - def extractor_ls_predict(self, feature_extractors_ls, X): - feature_ls = [] - for extractor in feature_extractors_ls: - cur_features = extractor.predict(X) - feature_ls.append(cur_features) - concated_feature_ls = np.concatenate(feature_ls, axis=1) - concated_feature_ls = normalize(concated_feature_ls) - return concated_feature_ls - - def load_embeddings(self, feature_extractors_names): - dictionaries = [] - for extractor_name in feature_extractors_names: - path2emb = pickle.load(open("../feature_extractors/embeddings/{}_emb_norm.p".format(extractor_name), "rb")) - dictionaries.append(path2emb) - - merge_dict = {} - for k in dictionaries[0].keys(): - cur_emb = [dic[k] for dic in dictionaries] - merge_dict[k] = np.concatenate(cur_emb) - return merge_dict - - def select_target_label(self, feature_extractors_ls, feature_extractors_names, metric='l2'): - original_feature_x = self.extractor_ls_predict(feature_extractors_ls, self.protect_train_X) - - path2emb = self.load_embeddings(feature_extractors_names) - items = list(path2emb.items()) - paths = [p[0] for p in items] - embs = [p[1] for p in items] - embs = np.array(embs) - - pair_dist = pairwise_distances(original_feature_x, embs, metric) - max_sum = np.min(pair_dist, axis=0) - sorted_idx = np.argsort(max_sum)[::-1] - - highest_num = 0 - paired_target_X = None - final_target_class_path = None - for idx in sorted_idx[:5]: - target_class_path = paths[idx] - cur_target_X = self.load_dir(target_class_path) - cur_target_X = np.concatenate([cur_target_X, cur_target_X, cur_target_X]) - cur_tot_sum, cur_paired_target_X = self.calculate_dist_score(self.protect_train_X, cur_target_X, - feature_extractors_ls, - metric=metric) - if cur_tot_sum > highest_num: - highest_num = cur_tot_sum - paired_target_X = cur_paired_target_X - final_target_class_path = target_class_path - - np.random.shuffle(paired_target_X) - return final_target_class_path, paired_target_X - - def calculate_dist_score(self, a, b, feature_extractors_ls, metric='l2'): - features1 = self.extractor_ls_predict(feature_extractors_ls, a) - features2 = self.extractor_ls_predict(feature_extractors_ls, b) - - pair_cos = pairwise_distances(features1, features2, metric) - max_sum = np.min(pair_cos, axis=0) - max_sum_arg = np.argsort(max_sum)[::-1] - max_sum_arg = max_sum_arg[:len(a)] - max_sum = [max_sum[i] for i in max_sum_arg] - paired_target_X = [b[j] for j in max_sum_arg] - paired_target_X = np.array(paired_target_X) - return np.min(max_sum), paired_target_X - - def get_all_data_path(self, label2path): - all_paths = [] - for k, v in label2path.items(): - cur_all_paths = [os.path.join(k, cur_p) for cur_p in v] - all_paths.extend(cur_all_paths) - return all_paths - - def load_label_data(self, label): - train_label_path = os.path.join(self.train_data_dir, label) - test_label_path = os.path.join(self.test_data_dir, label) - train_X = self.load_dir(train_label_path) - test_X = self.load_dir(test_label_path) - return train_X, test_X - - def load_dir(self, path): - assert os.path.exists(path) - x_ls = [] - for file in os.listdir(path): - cur_path = os.path.join(path, file) - im = image.load_img(cur_path, target_size=self.img_shape) - im = image.img_to_array(im) - x_ls.append(im) - raw_x = np.array(x_ls) - return preprocess_input(raw_x) - - def build_data_mapping(self): - label2path_train = {} - label2path_test = {} - idx = 0 - path2idx = {} - for label_name in self.all_labels: - full_path_train = os.path.join(self.train_data_dir, label_name) - full_path_test = os.path.join(self.test_data_dir, label_name) - label2path_train[full_path_train] = list(os.listdir(full_path_train)) - label2path_test[full_path_test] = list(os.listdir(full_path_test)) - for img_file in os.listdir(full_path_train): - path2idx[os.path.join(full_path_train, img_file)] = idx - for img_file in os.listdir(full_path_test): - path2idx[os.path.join(full_path_test, img_file)] = idx - idx += 1 - return label2path_train, label2path_test, path2idx - - def generate_data_post_cloak(self, sybil=False): - assert self.cloaked_protect_train_X is not None - while True: - batch_X = [] - batch_Y = [] - cur_batch_path = random.sample(self.all_training_path, 32) - for p in cur_batch_path: - cur_y = self.path2idx[p] - if p in self.protect_class_path: - cur_x = random.choice(self.cloaked_protect_train_X) - elif sybil and (p in self.sybil_class): - cur_x = random.choice(self.cloaked_sybil_train_X) - else: - im = image.load_img(p, target_size=self.img_shape) - im = image.img_to_array(im) - cur_x = preprocess_input(im) - batch_X.append(cur_x) - batch_Y.append(cur_y) - batch_X = np.array(batch_X) - batch_Y = to_categorical(np.array(batch_Y), num_classes=self.number_classes) - yield batch_X, batch_Y +# class CloakData(object): +# def __init__(self, protect_directory=None, img_shape=(224, 224)): +# +# self.img_shape = img_shape +# # self.train_data_dir, self.test_data_dir, self.number_classes, self.number_samples = get_dataset_path(dataset) +# # self.all_labels = sorted(list(os.listdir(self.train_data_dir))) +# self.protect_directory = protect_directory +# +# self.protect_X = self.load_label_data(self.protect_directory) +# +# self.cloaked_protect_train_X = None +# +# self.label2path_train, self.label2path_test, self.path2idx = self.build_data_mapping() +# self.all_training_path = self.get_all_data_path(self.label2path_train) +# self.all_test_path = self.get_all_data_path(self.label2path_test) +# self.protect_class_path = self.get_class_image_files(os.path.join(self.train_data_dir, self.protect_class)) +# +# def get_class_image_files(self, path): +# return [os.path.join(path, f) for f in os.listdir(path)] +# +# def extractor_ls_predict(self, feature_extractors_ls, X): +# feature_ls = [] +# for extractor in feature_extractors_ls: +# cur_features = extractor.predict(X) +# feature_ls.append(cur_features) +# concated_feature_ls = np.concatenate(feature_ls, axis=1) +# concated_feature_ls = normalize(concated_feature_ls) +# return concated_feature_ls +# +# def load_embeddings(self, feature_extractors_names): +# dictionaries = [] +# for extractor_name in feature_extractors_names: +# path2emb = pickle.load(open("../feature_extractors/embeddings/{}_emb_norm.p".format(extractor_name), "rb")) +# dictionaries.append(path2emb) +# +# merge_dict = {} +# for k in dictionaries[0].keys(): +# cur_emb = [dic[k] for dic in dictionaries] +# merge_dict[k] = np.concatenate(cur_emb) +# return merge_dict +# +# def select_target_label(self, feature_extractors_ls, feature_extractors_names, metric='l2'): +# original_feature_x = self.extractor_ls_predict(feature_extractors_ls, self.protect_train_X) +# +# path2emb = self.load_embeddings(feature_extractors_names) +# items = list(path2emb.items()) +# paths = [p[0] for p in items] +# embs = [p[1] for p in items] +# embs = np.array(embs) +# +# pair_dist = pairwise_distances(original_feature_x, embs, metric) +# max_sum = np.min(pair_dist, axis=0) +# sorted_idx = np.argsort(max_sum)[::-1] +# +# highest_num = 0 +# paired_target_X = None +# final_target_class_path = None +# for idx in sorted_idx[:5]: +# target_class_path = paths[idx] +# cur_target_X = self.load_dir(target_class_path) +# cur_target_X = np.concatenate([cur_target_X, cur_target_X, cur_target_X]) +# cur_tot_sum, cur_paired_target_X = self.calculate_dist_score(self.protect_train_X, cur_target_X, +# feature_extractors_ls, +# metric=metric) +# if cur_tot_sum > highest_num: +# highest_num = cur_tot_sum +# paired_target_X = cur_paired_target_X +# final_target_class_path = target_class_path +# +# np.random.shuffle(paired_target_X) +# return final_target_class_path, paired_target_X +# +# def calculate_dist_score(self, a, b, feature_extractors_ls, metric='l2'): +# features1 = self.extractor_ls_predict(feature_extractors_ls, a) +# features2 = self.extractor_ls_predict(feature_extractors_ls, b) +# +# pair_cos = pairwise_distances(features1, features2, metric) +# max_sum = np.min(pair_cos, axis=0) +# max_sum_arg = np.argsort(max_sum)[::-1] +# max_sum_arg = max_sum_arg[:len(a)] +# max_sum = [max_sum[i] for i in max_sum_arg] +# paired_target_X = [b[j] for j in max_sum_arg] +# paired_target_X = np.array(paired_target_X) +# return np.min(max_sum), paired_target_X +# +# def get_all_data_path(self, label2path): +# all_paths = [] +# for k, v in label2path.items(): +# cur_all_paths = [os.path.join(k, cur_p) for cur_p in v] +# all_paths.extend(cur_all_paths) +# return all_paths +# +# def load_label_data(self, label): +# train_label_path = os.path.join(self.train_data_dir, label) +# test_label_path = os.path.join(self.test_data_dir, label) +# train_X = self.load_dir(train_label_path) +# test_X = self.load_dir(test_label_path) +# return train_X, test_X +# +# def load_dir(self, path): +# assert os.path.exists(path) +# x_ls = [] +# for file in os.listdir(path): +# cur_path = os.path.join(path, file) +# im = image.load_img(cur_path, target_size=self.img_shape) +# im = image.img_to_array(im) +# x_ls.append(im) +# raw_x = np.array(x_ls) +# return preprocess_input(raw_x) +# +# def build_data_mapping(self): +# label2path_train = {} +# label2path_test = {} +# idx = 0 +# path2idx = {} +# for label_name in self.all_labels: +# full_path_train = os.path.join(self.train_data_dir, label_name) +# full_path_test = os.path.join(self.test_data_dir, label_name) +# label2path_train[full_path_train] = list(os.listdir(full_path_train)) +# label2path_test[full_path_test] = list(os.listdir(full_path_test)) +# for img_file in os.listdir(full_path_train): +# path2idx[os.path.join(full_path_train, img_file)] = idx +# for img_file in os.listdir(full_path_test): +# path2idx[os.path.join(full_path_test, img_file)] = idx +# idx += 1 +# return label2path_train, label2path_test, path2idx +# +# def generate_data_post_cloak(self, sybil=False): +# assert self.cloaked_protect_train_X is not None +# while True: +# batch_X = [] +# batch_Y = [] +# cur_batch_path = random.sample(self.all_training_path, 32) +# for p in cur_batch_path: +# cur_y = self.path2idx[p] +# if p in self.protect_class_path: +# cur_x = random.choice(self.cloaked_protect_train_X) +# elif sybil and (p in self.sybil_class): +# cur_x = random.choice(self.cloaked_sybil_train_X) +# else: +# im = image.load_img(p, target_size=self.img_shape) +# im = image.img_to_array(im) +# cur_x = preprocess_input(im) +# batch_X.append(cur_x) +# batch_Y.append(cur_y) +# batch_X = np.array(batch_X) +# batch_Y = to_categorical(np.array(batch_Y), num_classes=self.number_classes) +# yield batch_X, batch_Y