def calculate_statistics_threshold(detector_results):
"""calculates all the relevant analyzer statistics"""
metrics = collections.OrderedDict()
labels = np.array(
list(
map(lambda d: 1
if d[lookup.label] == lookup.stego else 0, detector_results)))
prediction_single_classes = np.array(
list(map(lambda d: float(d[lookup.result]), detector_results)))
prediction_both_classes = np.array(
list(
map(
lambda d:
(float(d[lookup.result]), 1.0 - float(d[lookup.result])),
detector_results)))
if len(set(labels)) == 1:
print('roc values require at least 2 labels in the test dataset')
return {lookup.result_metric: metrics}
auc_score = roc_auc_score(labels, prediction_single_classes)
ap_score = average_precision_score(labels, prediction_single_classes)
skplt.metrics.plot_roc(labels, prediction_both_classes)
detector_result_dir = lookup.get_algo_asset_dirs()[lookup.detector]
roc_curve_name = fs.get_uuid() + '-roc.png'
roc_curve_path = abspath(join(detector_result_dir, roc_curve_name))
plt.savefig(roc_curve_path, bbox_inches='tight')
metrics[lookup.roc_auc] = auc_score
metrics[lookup.ap_score] = ap_score
metrics[lookup.roc_curve] = roc_curve_path
return {lookup.result_metric: metrics}
def convert_to_image(path_to_directory, db_name, img_pixel_values):
for pixels in img_pixel_values:
file_name = fs.get_uuid() + '.png'
file_path = join(path_to_directory, file_name)
img.convert_from_pixels(file_path, pixels)
db_uuid = process_directory({}, path_to_directory, db_name, {})
return db_uuid
def process_image_directory(path_to_directory, db_name, operation_dict):
"""processes an image directory"""
source_master_file = lookup.get_all_files()[lookup.source_db_file]
metadata_directory = lookup.get_db_dirs()[lookup.metadata]
output_directory = path_to_directory
db_uuid = fs.get_uuid()
target_directory = join(metadata_directory, db_uuid)
assert (fs.dir_exists(path_to_directory))
assert (fs.dir_exists(metadata_directory))
absolute_path = abspath(path_to_directory)
files = [
join(absolute_path, f) for f in listdir(absolute_path)
if img.is_image_file(join(absolute_path, f))
]
if operation_dict:
dataset_directory = lookup.get_db_dirs()[lookup.dataset]
output_directory = abspath(join(dataset_directory, fs.get_uuid()))
fs.make_dir(output_directory)
files = modify_images(absolute_path, output_directory, operation_dict)
else:
files = [
join(absolute_path, f) for f in listdir(absolute_path)
if img.is_image_file(join(absolute_path, f))
]
info_images, compatible_types = process_cover_list(files)
rows = [lookup.cover_image_header] + info_images
fs.make_dir(target_directory)
fs.write_to_csv_file(join(target_directory, lookup.db_file), rows)
num_images = len(files)
compatible_types = list(compatible_types)
dataset_info = [(db_uuid, abspath(output_directory), db_name, num_images,
compatible_types)]
fs.write_to_csv_file(source_master_file, dataset_info)
return db_uuid
def create_asset_file(type: str, content: str):
"""creates a text asset for the specificied directory"""
asset_directory = get_algo_asset_dirs()[type]
file_name = fs.create_name_from_uuid(fs.get_uuid()[:10], 'txt')
file_path = abspath(join(asset_directory, file_name))
fs.write_to_text_file(file_path, [content])
return file_path
def embed_ratio(self, db_name:str, source_db:str, embedding_ratio:float):
"""generates a test DB. if divided, embeddors are randomly distributed each of the db images. otherwise each image undergoes an operation by each embeddor"""
db_information = lookup.get_source_db_info(source_db)
db_compatible_states = set(db_information[lookup.compatible_descriptor])
db_embed_compatible = db_compatible_states.intersection(self.compatible_types)
if len(db_embed_compatible) <= 0:
raise ValueError('The embeddor set and dataset are not compatible')
if embedding_ratio > self.max_embedding_ratio:
raise ValueError('The embeddor set cannot support this embedding ratio')
image_dict = lookup.get_image_list(db_information[lookup.uuid_descriptor])
image_dict = list(filter(lambda img_info: img_info[lookup.image_type] in db_embed_compatible, image_dict))
random.shuffle(image_dict)
num_images = len(image_dict)
num_embeddors = len(self.embeddors)
input_partition = []
output_partition = []
output_directory_name = fs.get_uuid()
output_directory = abspath(join(lookup.get_db_dirs()[lookup.dataset], output_directory_name))
assert(not fs.dir_exists(output_directory))
fs.make_dir(output_directory)
images_per_embeddor = int(num_images / num_embeddors)
remainder = num_images - images_per_embeddor*num_embeddors
for i in range(num_embeddors):
start_idx = i*images_per_embeddor
end_idx = (i+1)*images_per_embeddor
input_list = image_dict[start_idx:end_idx].copy()
input_partition.append(input_list)
for idx in range(remainder):
input_partition[idx].append(image_dict[idx + num_embeddors*images_per_embeddor].copy())
ratio_embeddor = partial(generator.secret_message_from_embedding, embedding_ratio)
secret_message = [list(map(ratio_embeddor, input_list)) for input_list in input_partition]
output_partition = [generator.generate_output_list(embeddor, output_directory, input_partition[idx]) for idx, embeddor in enumerate(self.embeddors)]
partition = [[{
lookup.INPUT_IMAGE_PATH: input_partition[i][j][lookup.file_path],
lookup.OUTPUT_IMAGE_PATH: output_partition[i][j],
lookup.PAYLOAD: embedding_ratio,
lookup.SECRET_TXT_PLAINTEXT: secret_message[i][j],
lookup.PASSWORD: generator.generate_password(),
}
for j in range(len(input_partition[i]))] for i in range(num_embeddors)]
db_uuid = self.embed_db(db_name, partition, source_db, embedding_ratio)
return db_uuid
def train_test_val_split(path_to_directory, train_split, test_split,
val_split):
assert ((train_split + test_split + val_split <= 1.0))
input_directory = abspath(path_to_directory)
file_names = [
join(input_directory, f) for f in listdir(input_directory)
if img.is_image_file(join(input_directory, f))
]
random.shuffle(file_names)
train_size = int(len(file_names) * train_split)
test_size = int(len(file_names) * test_split)
val_size = int(len(file_names) * val_split)
train_files, test_files, val_files = file_names[0:train_size], file_names[
train_size:(train_size +
test_size)], file_names[(train_size +
test_size):(train_size +
test_size + val_size)]
db_directory = abspath(lookup.get_db_dirs()[lookup.dataset])
train_directory = join(db_directory, fs.get_uuid())
test_directory = join(db_directory, fs.get_uuid())
val_directory = join(db_directory, fs.get_uuid())
fs.make_dir(train_directory)
fs.make_dir(test_directory)
fs.make_dir(val_directory)
directory_pairs = [(train_directory, train_files),
(test_directory, test_files),
(val_directory, val_files)]
for directory_pair in directory_pairs:
copy_directory, copy_files = directory_pair
for file in copy_files:
fs.copy_file(file, copy_directory)
return train_directory, test_directory, val_directory
def create_algorithm_set(algorithm_type: str, algorithms: [str]):
"""creates a new algorithm set"""
set_uuid = fs.get_uuid()
set_file_directory = lookup.get_algo_set_dirs()[algorithm_type]
individual_set_file_path = join(set_file_directory,
fs.create_name_from_uuid(set_uuid, 'csv'))
fs.make_file(individual_set_file_path)
file_header = lookup.individual_set_header
data_to_write = [file_header]
for algorithm_uuid in algorithms:
algorithm_info = get_algorithm_info(algorithm_type, algorithm_uuid)
data_to_write.append([algorithm_info[lookup.uuid_descriptor]])
fs.write_to_csv_file(individual_set_file_path, data_to_write)
return set_uuid
def apply_attack(model_path, dataset, model_attack_config):
model = torch.load(model_path, map_location='cpu').model
input_shape = model_attack_config[lookup.input_shape]
criterion = model_attack_config[lookup.criterion]
optimizer = model_attack_config[lookup.optimizer]
nb_classes = model_attack_config[lookup.nb_classes]
attack_method = model_attack_config[lookup.attack_method]
robust_db_name = model_attack_config[lookup.robust_db_name]
if criterion == 'cross_entropy':
criterion = nn.CrossEntropyLoss()
else:
raise ValueError
if optimizer == 'SGD':
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)
elif optimizer == 'Adam':
optimizer = optim.Adam(model.parameters(), lr=1e-4)
else:
raise ValueError
classifier = PyTorchClassifier(model=model, input_shape=input_shape, loss=criterion, optimizer=optimizer, nb_classes=nb_classes)
x = np.array([x_element.numpy()[0] for x_element in dataset[0]])
y = np.array(dataset[1])
predictions = classifier.predict(x)
accuracy = np.sum(np.argmax(predictions, axis=1) == np.argmax(y, axis=1)) / len (y)
print('Accuracy on benign test examples: {}%'.format(accuracy * 100))
attack_function = get_attack_method(attack_method)
attack_instance = attack_function(classifier=classifier)
x_adv = attack_instance.generate(x=x)
predictions = classifier.predict(x_adv)
accuracy = np.sum(np.argmax(predictions, axis=1) == np.argmax(y, axis=1)) / len(y)
print('Accuracy on adversarial test examples: {}%'.format(accuracy * 100))
path_to_directory = join(abspath(lookup.get_db_dirs()[lookup.dataset]), fs.get_uuid())
fs.make_dir(path_to_directory)
db_uuid = processor.convert_to_image(path_to_directory, robust_db_name, x_adv)
return db_uuid
def limit_images(path_to_directory, amount_of_images):
input_directory = abspath(path_to_directory)
file_names = [
join(input_directory, f) for f in listdir(input_directory)
if img.is_image_file(join(input_directory, f))
]
random.shuffle(file_names)
db_directory = abspath(lookup.get_db_dirs()[lookup.dataset])
shortened_directory = join(db_directory, fs.get_uuid())
fs.make_dir(shortened_directory)
copy_files = file_names[:amount_of_images]
for file in copy_files:
fs.copy_file(file, shortened_directory)
return shortened_directory
def process_steganographic_directory(partition, db_name, embeddor_set,
source_db_uuid, payload):
"""processes a steganographic directory"""
embedded_master_file = lookup.get_all_files()[lookup.embedded_db_file]
metadata_directory = lookup.get_db_dirs()[lookup.metadata]
db_uuid = fs.get_uuid()
target_directory = join(metadata_directory, db_uuid)
assert (fs.dir_exists(metadata_directory))
embeddors = embeddor_set[lookup.embeddor]
embeddor_set_uuid = embeddor_set[lookup.uuid_descriptor]
info_images, compatible_types, directory, = process_steganographic_list(
partition, embeddors)
rows = [lookup.steganographic_image_header] + info_images
fs.make_dir(target_directory)
fs.write_to_csv_file(join(target_directory, lookup.db_file), rows)
num_images = len(info_images)
compatible_types = list(compatible_types)
steganographic_dataset_info = [(
db_uuid,
abspath(directory),
db_name,
num_images,
compatible_types,
source_db_uuid,
embeddor_set_uuid,
payload,
)]
fs.write_to_csv_file(embedded_master_file, steganographic_dataset_info)
return db_uuid
def preprocess_docker(algorithm_info, to_detect_list):
"""starts docker command and updates parameters appropriately"""
image_name = algorithm_info[lookup.DOCKER_IMAGE]
cmd = lookup.get_cmd(algorithm_info)
volumes = {}
if lookup.INPUT_IMAGE_DIRECTORY in cmd:
updated_detect_list = generator.get_directories(to_detect_list)
for updated_detect in updated_detect_list:
docker_directory = '/' + fs.get_uuid()
volumes[updated_detect[lookup.INPUT_IMAGE_DIRECTORY]] = {
'bind': docker_directory,
'mode': 'rw'
}
updated_detect[lookup.INPUT_IMAGE_DIRECTORY] = docker_directory
elif lookup.INPUT_IMAGE_PATH in cmd:
for to_detect in to_detect_list:
original_input_path = to_detect[lookup.INPUT_IMAGE_PATH]
original_input_path = abspath(original_input_path)
local_input_dir = fs.get_directory(original_input_path)
volumes[local_input_dir] = {'bind': lookup.input_dir, 'mode': 'rw'}
input_filename = fs.get_filename(original_input_path)
new_input_path = join(lookup.input_dir, input_filename)
to_detect[lookup.INPUT_IMAGE_PATH] = new_input_path
result_directory = abspath(lookup.get_algo_asset_dirs()[lookup.detector])
assert (fs.dir_exists(result_directory))
volumes[result_directory] = {'bind': lookup.result_dir, 'mode': 'rw'}
container_id = runner.start_docker(image_name, volumes=volumes)
for to_detect in to_detect_list:
to_detect[lookup.container_id] = container_id
return [], to_detect_list
def generate_output_list(algorithm_info, output_directory: str,
input_list: dict):
target_directory = output_directory
output_list = []
for file in input_list:
file_type = file[lookup.image_type]
if lookup.OUTPUT_FILE in algorithm_info:
replacements = {
lookup.INPUT_IMAGE_NAME:
fs.get_filename(abspath(file[lookup.file_path]),
extension=False)
}
output_file_name = replace(algorithm_info[lookup.OUTPUT_FILE],
replacements)
else:
output_file_name = fs.get_uuid()
output_file = fs.create_name_from_uuid(output_file_name, file_type)
output_file_path = join(target_directory, output_file)
output_list.append(output_file_path)
return output_list
def process_algorithm(algorithm_type, algorithm_dict, config_file_path): master_file = lookup.get_algo_master_files()[algorithm_type] master_file_path = lookup.get_all_files()[master_file] data_to_write = [[fs.get_uuid(), name, config_file_path] for name in algorithm_dict.keys()] fs.write_to_csv_file(master_file_path, data_to_write)
