def __init__(self, original_target=None, model=None, x_original_train=None, y_original_train=None, batch_size=128, strategy=SAU.replace30, graph=None): self.config = ExperimentalConfig.gen_config() self.au = Augmenter() self.batch_size = batch_size self.original_target = original_target self.x_original_train = x_original_train self.y_original_train = y_original_train self.strategy = strategy self.model = model self.graph = graph if self.config.enable_optimize: self.skipped_node = 0 self.is_robust = [False] * len(x_original_train) self.prev_is_robust = [False] * len(x_original_train) # statistic record self.total_time = 0 self.predict_time = 0 self.label_record = [[0 for x in range(original_target.num_classes)] for y in range(original_target.num_classes)] temp_x_original_train = copy.deepcopy(self.x_original_train) self.y_train = y_original_train self.x_train = original_target.preprocess_original_imgs(temp_x_original_train) if self.strategy.value == SAU.ga_loss.value: self.ga_selector = GASelect(self.x_original_train, self.y_original_train, self.original_target) elif self.strategy.value == SAU.ga_cov.value: self.nc = NeuralCoverage(model) self.ga_selector = GASelect(self.x_original_train, self.y_original_train, self.original_target)
def __init__(self, model): self.config = ExperimentalConfig.gen_config() self.model = model self.pool = multiprocessing.Pool(self.config.num_processor) layer_name = [ layer.name for layer in self.model.layers if 'flatten' not in layer.name and 'input' not in layer.name ][-2] self.intermediate_layer_model = Model( inputs=self.model.input, outputs=[self.model.get_layer(layer_name).output])
class GridTransformation: config = ExperimentalConfig.gen_config() def __init__(self, num_class): self.class_grid_transformation = dict() self.class_index = dict() trs = self.generate_transformations() for i in range(num_class): trs_temp = copy.deepcopy(trs) random.shuffle(trs_temp) self.class_grid_transformation[i] = trs_temp self.class_index[i] = 0 @staticmethod def generate_transformations(): trs = [] for p1 in GridTransformation.config.rotation_range[ 12::18]: # 6 [-30, 30] for p2 in GridTransformation.config.translate_range[ 1::2]: # 1 [-3, 3] for p2_v in GridTransformation.config.translate_range[ 1::2]: # 1 [-3, 3] for p3 in GridTransformation.config.shear_range[ 8::12]: # 4 [-20, 20] if GridTransformation.config.enable_filters: for p4 in GridTransformation.config.zoom_range[ 4::6]: # 2 [-10, 10] for p5 in GridTransformation.config.blur_range[:: 1]: # for p6 in GridTransformation.config.brightness_range[ 4::12]: # 4 [-16, 16] for p7 in GridTransformation.config.contrast_range[ 2::6]: # 2 [-8, 8] tr = Transformation( p1, p2, p2_v, p3, p4, p5, p6, p7) trs.append(tr) else: tr = Transformation(p1, p2, p2_v, p3) trs.append(tr) return trs def get_next_transformation(self, label): index = self.class_index[label] trs = self.class_grid_transformation[label] if index >= len(trs): random.shuffle(trs) self.class_grid_transformation[label] = trs index = 0 self.class_index[label] = 0 else: self.class_index[label] = index + 1 return trs[index]
def __init__(self): config = ExperimentalConfig.gen_config() self.config = config self.pt = Perturbator() self.rotation_range = config.rotation_range self.translate_range = config.translate_range self.shear_range = config.shear_range self.zoom_range = config.zoom_range self.blur_range = config.blur_range self.brightness_range = config.brightness_range self.contrast_range = config.contrast_range
def __init__(self, x_train=None, y_train=None, original_target=None): config = ExperimentalConfig.gen_config() self.config = config self.queue_set = [] # num_test * num_mutate self.queue_len = config.queue_len self.pt = Perturbator() self.original_target = original_target self.x_train = x_train self.y_train = y_train # using grid strategy to init population if not self.config.random_init: self.gt = GridTransformation(original_target.num_classes) # generate first population temp_x_original_train = copy.deepcopy(x_train) for i in range(len(temp_x_original_train)): label = np.argmax(y_train[i]) q = list() # add original data to initial population q.append(Item(Transformation(), 1)) # initialize loss as 1 for j in range(9): if self.config.random_init: # random init population angle = random.choice(config.rotation_range) translation = random.choice(config.translate_range) shear = random.choice(config.shear_range) # transformation based on filter if config.enable_filters: zoom = random.choice(config.zoom_range) blur = random.choice(config.blur_range) brightness = random.choice(config.brightness_range) contrast = random.choice(config.contrast_range) tr = Transformation(angle, translation, shear, zoom, blur, brightness, contrast) else: tr = Transformation(angle, translation, shear) q.append(Item(tr, 1)) else: tr = self.gt.get_next_transformation(label) q.append(Item(tr, 1)) self.queue_set.append(q)
def __init__(self, model): self.config = ExperimentalConfig.gen_config() self.model = model # self.model_layer_dict = OrderedDict() # for layer in model.layers: # if 'flatten' in layer.name or 'input' in layer.name: # continue # # for index in range(layer.output_shape[-1]): # self.model_layer_dict[(layer.name, index)] = False self.layer_names = [layer.name for layer in model.layers if 'flatten' not in layer.name and 'input' not in layer.name][-2:] self.intermediate_layer_model = Model(inputs=model.input, outputs=[model.get_layer(layer_name).output for layer_name in self.layer_names]) self.pool = multiprocessing.Pool(self.config.num_processor) self.class_size = int_shape(model.get_layer(self.layer_names[-1]).output)[-1]
def __init__(self, rotation=0, translate=0, translate_v=0, shear=0, zoom=1, blur=0, brightness=0, contrast=1): self.config = ExperimentalConfig.gen_config() self.rotation = rotation self.translate = translate self.translate_v = translate_v self.shear = shear self.zoom = zoom self.blur = blur self.brightness = brightness self.contrast = contrast
def __init__(self): config = ExperimentalConfig.gen_config() self.rotation_range = config.rotation_range self.translate_range = config.translate_range self.shear_range = config.shear_range self.zoom_range = config.zoom_range self.blur_range = config.blur_range self.brightness_range = config.brightness_range self.contrast_range = config.contrast_range self.trans_functions = dict() self.trans_functions["rotate"] = rotate_image self.trans_functions["translate"] = image_translation_cropped self.trans_functions["shear"] = image_shear_cropped # the function of filters self.trans_functions["zoom"] = image_zoom self.trans_functions["blur"] = image_blur self.trans_functions["contrast"] = image_contrast self.trans_functions["brightness"] = image_brightness self.enable_filters = config.enable_filters
def __init__(self, target=None): self.target = target self.config = ExperimentalConfig.gen_config()
if len(args.strategy) <= 0 or len(args.dataset) <= 0: logger.error(parser) exit(1) # augmentation strategy aug_strategy = args.strategy if aug_strategy not in SAU.list(): print("unsupported strategy, please use --help to find supported ones") exit(1) # target dataset dataset = args.dataset if dataset not in DATASET.list(): print("unsupported dataset, please use --help to find supported ones") exit(1) config = ExperimentalConfig.gen_config() config.enable_filters = args.enable_filter config.enable_optimize = args.enable_optimize model_index = int(args.model) # initialize dataset dat = DATASET.get_name(dataset) if dat.value == DATASET.gtsrb.value: target0 = GtsrbModel(source_dir='GTSRB') elif dat.value == DATASET.cifar10.value: target0 = Cifar10Model() elif dat.value == DATASET.fashionmnist.value: target0 = FashionMnist() elif dat.value == DATASET.svhn.value: target0 = SVHN()