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