Список работ

Атака на нейронную сеть

Содержание

• Примеры атак на НС
• Эффективность атак на НС, обученных на ImageNet
• Приложение. Код получения прогноза НС, обученных на ImageNet
• Источники

Примеры атак на НС

В [1 и 2] приводится пример, в котором после незначительного изменения изображения (рис. 1 и 2) нейронная сеть (НС) GoogLeNet, обученная на ImageNet [3], начинает неверно классифицировать измененное изображение, хотя визуально оно практически неотличимо от исходного.

Рис. 1. Исходное (слева) и измененное изображения

Иное название GoogLeNet – Inception V1 [4]. Эта НС (рис. 2 и 3) включает начальные модули (inception modules).

Рис. 2. Начальный модуль GoogLeNet.

Рис. 3. Начальный модуль GoogLeNet с уменьшением размерности.

Подобные изменения приводят в качестве примеров успешной атаки на НС.
В [2] показан пример успешной атаки на НС AlexNet [5], так же обученной на ImageNet: после изменения одного пикселя изображения эта НС меняет свой прогноз (рис .4).

Рис. 4. Однопиксельные атаки на AlexNet

Атака НС, обученных на ImageNet (разд. 2), выполняется с применением изображения, показанного на рис. 5 справа.

Рис. 5. Исходное и атакующее изображения

Такие атаки, однако, эффективные для одной НС проходят совершенно бесследно для НС с другой архитектурой.
Один из способов сделать атаки более универсальными – это применение атакующих шумов [6]. Примеры таких шумов, взятые из [6], приведены на рис. 6.

Рис. 6. Примеры атакующих шумов:
а – AlexNet; б – VGG19; в – ResNet152; г – DenseNet; д – GoogLeNet; е – MobileNet; ж – VGG11; з – ResNet18.

Визуально исходное и зашумленные изображения малоразличимы, но точность классификации зашумленных изображений существенно ниже, чем исходных [6].
Пример употребления шума при подготовке атаки удачной на НС AlexNet [7] показан на рис. 7.

Рис. 7. Пример употребления шума для атаки удачной на AlexNet

Эффективность атак на НС, обученных на ImageNet

Проверяется, насколько токсичны зашумленные изображения (табл. 1), приведенные на рис. 1, 5 и 7 для следующих обученных на ImageNet НС:

• Xception;
• VGG16;
• VGG19;
• ResNet50;
• ResNet101;
• ResNet152;
• ResNet50V2;
• ResNet101V2;
• ResNet152V2;
• InceptionV3;
• InceptionResNetV2;
• MobileNet;
• MobileNetV2;
• DenseNet121;
• DenseNet169;
• DenseNet201;
• NASNetMobile;
• NASNetLarge;
• ConvNeXtTiny;
• ConvNeXtSmall;
• ConvNeXtLarge;
• ConvNeXtXLarge;
• EfficientNetB0;
• EfficientNetB1;
• EfficientNetB2;
• EfficientNetB3;
• EfficientNetB4;
• EfficientNetB5;
• EfficientNetB6;
• EfficientNetB7;
• EfficientNetV2B0;
• EfficientNetV2B1;
• EfficientNetV2B2;
• EfficientNetV2B3;
• EfficientNetV2S;
• EfficientNetV2M;
• EfficientNetV2L.

Прогноз НС выводит программа, приведенная в прил.

Таблица 1. Прогнозы НС

Замечание. В табл. 1 использовано сокращение: rbs – red-backed_sandpiper.

Приведенный выше код, если параметр get_cls = 0, получает значения следующих показателей различия/сходства изображений:

• MSE – среднеквадратическая ошибка;
• PSNR – пиковое отношение сигнала к шуму;
• SSIM – индекс структурного сходства;
• E_dist – евклидово расстояние;
• Cos_dist – косинусное расстояние (табл. 2).

Таблица 2. Оценки различия изображений (исходного и зашумленного)

Приложение. Код получения прогноза НС, обученных на ImageNet

Прогноз НС выводит следующий код:

from sys import exit
import numpy as np
from keras.preprocessing import image
import matplotlib.pyplot as plt
get_cls = 1
mdl_no = 0
mdl_lst = ['Xception', 'VGG16', 'VGG19', 'ResNet50', 'ResNet101', 'ResNet152', # 0 - 5
           'ResNet50V2', 'ResNet101V2', 'ResNet152V2', 'InceptionV3', # 6 - 9
           'InceptionResNetV2', 'MobileNet', 'MobileNetV2', # 10 - 12
           'MobileNetV3Small', 'MobileNetV3Large', # 13 - 14
           'DenseNet121', 'DenseNet169', 'DenseNet201', # 15 - 17
           'NASNetMobile', 'NASNetLarge', 'ConvNeXtTiny', 'ConvNeXtSmall', # 18 - 21
           'ConvNeXtBase', 'ConvNeXtLarge', 'ConvNeXtXLarge', # 22 - 24
           'EfficientNetB0', 'EfficientNetB1', 'EfficientNetB2', # 25 - 27
           'EfficientNetB3', 'EfficientNetB4', 'EfficientNetB5', # 28 - 30
           'EfficientNetB6', 'EfficientNetB7', 'EfficientNetV2B0', # 31 - 33
           'EfficientNetV2B1', 'EfficientNetV2B2', 'EfficientNetV2B3', # 34 - 36
           'EfficientNetV2S', 'EfficientNetV2M', 'EfficientNetV2L'] # 37 - 39
show_summary = 0
show_img = 0
img_nm1 = 'panda_true.png'
img_nm2 = 'panda_noise.png'
img_nm1 = 'cup_true.png' # cup.png, teapot.png, as_cheetah.png
img_nm2 = 'cup_hole.png'
# img_nm1 = 'bird_true.png' # Песочник с красной спинкой
# img_nm2 = 'bird_noise.png' # или американский бекасовидный веретенник
imgs_list = [img_nm1, img_nm2]
# imgs_list = ['elephant.jpg', 'wolf.jpg', 'amur_tiger.jpg']
imgs_loaded = []
def show_pics(imgs_list, imgs_loaded):
    n_imgs = len(imgs_list)
    _, axs = plt.subplots(1, n_imgs, figsize = (7, 4))
    for i in range(n_imgs):
        ax1 = axs[i]
        ax1.set_axis_off()
        ax1.set_title(imgs_list[i])
        ax1.imshow(imgs_loaded[i])
    plt.show()
if get_cls == 0:
    from skimage.metrics import mean_squared_error
    import cv2, scipy
    from skimage.metrics import structural_similarity as ssim
    from scipy.spatial.distance import euclidean as e_dist
    for img_nm in imgs_list:
        img = image.load_img(img_nm, target_size = (224, 224))
        img = image.img_to_array(img) # Массив формы (224, 224, 3)
        img /= 255
        imgs_loaded.append(img)
    if show_img:
        show_pics(imgs_list, imgs_loaded)
    # Средняя квадратическая ошибка
    image1 = imgs_loaded[0]
    image2 = imgs_loaded[1]
    mse = mean_squared_error(image1, image2)
    # mse2 = ((image1 - image2) ** 2).mean()
    # Пиковое отношение сигнала к шуму
    # https://habr.com/ru/articles/126848/
    psnr = cv2.PSNR(image1, image2, mse)
    # Индекс структурного сходства
    # https://habr.com/ru/articles/126848/
    # https://scikit-image.org/docs/stable/auto_examples/transform/plot_ssim.html
    # score_ssim, diff = ssim(image1, image2, full = True, multichannel = True)
    # или (в зависимости от версии)
    dr1 = image1.max() - image1.min()
    dr2 = image2.max() - image2.min()
    dr = max(dr1, dr2)
    # score_ssim, diff = ssim(image1, image2, full = True, channel_axis = 2, data_range = dr)
    score_ssim2, diff = ssim(image1.flatten(), image2.flatten(), full = True, data_range = dr)
    # Евклидово расстояние
    ec_dst = np.linalg.norm(image1 - image2)
    # ec_dst2 = e_dist(image1.flatten(), image2.flatten())
    # Косинусное расстояние между векторами
    # https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.distance.cosine.html
    cs_dst = scipy.spatial.distance.cosine(image1.flatten(), image2.flatten())
    print('mse =', round(mse, 6))
    # print('mse2 =', round(mse2, 6))
    print('psnr =', round(psnr, 6))
    # print('1 - ssim =', round(1 - score_ssim, 6))
    print('1 - ssim2 =', round(1 - score_ssim2, 6))
    print('ec_dst =', round(ec_dst, 6))
    # print('ec_dst2 =', round(ec_dst2, 6))
    print('cs_dst =', round(cs_dst, 6))
else:
    from google.colab import drive
    drv = '/content/drive/'
    drive.mount(drv)
    # Путь к изображениям в Colab
    pathToData = drv + 'My Drive/imgs/'
    for mdl_no in range(len(mdl_lst)):
        print('mdl_name =', mdl_lst[mdl_no])
        target_size = (224, 224)
        if mdl_no in [13, 14, 22]: continue
        if mdl_no == 0: # Создание модели нейронной сети
            from keras.applications.xception import Xception as img_net
            from keras.applications.xception import preprocess_input as pri
            from keras.applications.xception import decode_predictions as dep
            target_size = (299, 299)
        elif mdl_no == 1:
            from keras.applications.vgg16 import VGG16 as img_net
            from keras.applications.vgg16 import preprocess_input as pri
            from keras.applications.vgg16 import decode_predictions as dep
        elif mdl_no == 2:
            from keras.applications.vgg19 import VGG19 as img_net
            from keras.applications.vgg19 import preprocess_input as pri
            from keras.applications.vgg19 import decode_predictions as dep
        elif mdl_no in [3, 4, 5]:
            if mdl_no == 3:
                from keras.applications.resnet import ResNet50 as img_net
            elif mdl_no == 4:
                from keras.applications.resnet import ResNet101 as img_net
            elif mdl_no == 5:
                from keras.applications.resnet import ResNet152 as img_net
            from keras.applications.resnet import preprocess_input as pri
            from keras.applications.resnet import decode_predictions as dep
        elif mdl_no in [6, 7, 8]:
            if mdl_no == 6:
                from keras.applications.resnet_v2 import ResNet50V2 as img_net
            elif mdl_no == 7:
                from keras.applications.resnet_v2 import ResNet101V2 as img_net
            elif mdl_no == 8:
                from keras.applications.resnet_v2 import ResNet152V2 as img_net
            from keras.applications.resnet_v2 import preprocess_input as pri
            from keras.applications.resnet_v2 import decode_predictions as dep
        elif mdl_no == 9:
            from keras.applications.inception_v3 import InceptionV3 as img_net
            from keras.applications.inception_v3 import preprocess_input as pri
            from keras.applications.inception_v3 import decode_predictions as dep
            target_size = (299, 299)
        elif mdl_no == 10:
            from keras.applications.inception_resnet_v2 import InceptionResNetV2 as img_net
            from keras.applications.inception_resnet_v2 import preprocess_input as pri
            from keras.applications.inception_resnet_v2 import decode_predictions as dep
            target_size = (299, 299)
        elif mdl_no == 11:
            from keras.applications.mobilenet import MobileNet as img_net
            from keras.applications.mobilenet import preprocess_input as pri
            from keras.applications.mobilenet import decode_predictions as dep
        elif mdl_no == 12:
            from keras.applications.mobilenet_v2 import MobileNetV2 as img_net
            from keras.applications.mobilenet_v2 import preprocess_input as pri
            from keras.applications.mobilenet_v2 import decode_predictions as dep
        elif mdl_no in [13, 14]:
            if mdl_no == 13:
                from keras.applications.mobilenet_v3 import MobileNetV3Small as img_net
            elif mdl_no == 14:
                from keras.applications.mobilenet_v3 import MobileNetV3Large as img_net
            from keras.applications.mobilenet_v3 import preprocess_input as pri
            from keras.applications.mobilenet_v3 import decode_predictions as dep
        elif mdl_no in [15, 16, 17]:
            if mdl_no == 15:
                from keras.applications.densenet import DenseNet121 as img_net
            elif mdl_no == 16:
                from keras.applications.densenet import DenseNet169 as img_net
            elif mdl_no == 17:
                from keras.applications.densenet import DenseNet201 as img_net
            from keras.applications.densenet import preprocess_input as pri
            from keras.applications.densenet import decode_predictions as dep
        elif mdl_no in [18, 19]:
            if mdl_no == 18:
                from keras.applications.nasnet import NASNetMobile as img_net
            elif mdl_no == 19:
                from keras.applications.nasnet import NASNetLarge as img_net
                target_size = (331, 331)
            from keras.applications.nasnet import preprocess_input as pri
            from keras.applications.nasnet import decode_predictions as dep
        elif mdl_no in [20, 21, 23, 24]:
            if mdl_no == 20:
                from keras.applications.convnext import ConvNeXtTiny as img_net
            elif mdl_no == 21:
                from keras.applications.convnext import ConvNeXtSmall as img_net
            elif mdl_no == 22:
                from keras.applications.convnext import ConvNeXtBase as img_net
            elif mdl_no == 23:
                from keras.applications.convnext import ConvNeXtLarge as img_net
            elif mdl_no == 24:
                from keras.applications.convnext import ConvNeXtXLarge as img_net
            from keras.applications.convnext import preprocess_input as pri
            from keras.applications.convnext import decode_predictions as dep
        elif mdl_no in [25, 26, 27, 28, 29, 30, 31, 32]: # efficientnet
            if mdl_no == 25:
                from keras.applications.efficientnet import EfficientNetB0 as img_net
            elif mdl_no == 26:
                from keras.applications.efficientnet import EfficientNetB1 as img_net
                target_size = (240, 240)
            elif mdl_no == 27:
                from keras.applications.efficientnet import EfficientNetB2 as img_net
                target_size = (260, 260)
            elif mdl_no == 28:
                from keras.applications.efficientnet import EfficientNetB3 as img_net
                target_size = (300, 300)
            elif mdl_no == 29:
                from keras.applications.efficientnet import EfficientNetB4 as img_net
                target_size = (380, 380)
            elif mdl_no == 30:
                from keras.applications.efficientnet import EfficientNetB5 as img_net
                target_size = (456, 456)
            elif mdl_no == 31:
                from keras.applications.efficientnet import EfficientNetB6 as img_net
                target_size = (528, 528)
            elif mdl_no == 32:
                from keras.applications.efficientnet import EfficientNetB7 as img_net
                target_size = (600, 600)
            from keras.applications.efficientnet import preprocess_input as pri
            from keras.applications.efficientnet import decode_predictions as dep
        elif mdl_no in [33, 34, 35, 36, 37, 38, 39]: # efficientnet_v2
            if mdl_no == 33:
                from keras.applications.efficientnet_v2 import EfficientNetV2B0 as img_net
            elif mdl_no == 34:
                from keras.applications.efficientnet_v2 import EfficientNetV2B1 as img_net
                target_size = (240, 240)
            elif mdl_no == 35:
                from keras.applications.efficientnet_v2 import EfficientNetV2B2 as img_net
                target_size = (260, 260)
            elif mdl_no == 36:
                from keras.applications.efficientnet_v2 import EfficientNetV2B3 as img_net
                target_size = (300, 300)
            elif mdl_no == 37:
                from keras.applications.efficientnet_v2 import EfficientNetV2S as img_net
                target_size = (384, 384)
            elif mdl_no == 38:
                from keras.applications.efficientnet_v2 import EfficientNetV2M as img_net
                target_size = (480, 480)
            elif mdl_no == 39:
                from keras.applications.efficientnet_v2 import EfficientNetV2L as img_net
                target_size = (480, 480)
            from keras.applications.efficientnet_v2 import preprocess_input as pri
            from keras.applications.efficientnet_v2 import decode_predictions as dep
        def predit(imgs, imgs_list):
            print('Прогноз:')
            top = 2 # Число прогнозов для каждого изображения
            k = -1
            for x in imgs:
                features = model.predict(x, verbose = 0) # features.shape: (1, 1000)
                dp = dep(features, top = top)[0]
                k += 1
                print(imgs_list[k])
                for p in dp:
                    print(p)
        # Функция возвращает список загруженных и обработанных изображений
        def load_imgs(pathToData, imgs_list):
            imgs_loaded = []
            imgs_for_show = []
            for img in imgs_list:
                    img_path = pathToData + img
                    img = image.load_img(img_path, target_size = target_size)
                    x = image.img_to_array(img) # Массив формы (224, 224, 3)
                    imgs_for_show.append(x / 255)
                    # Добавляем измерение протяженностью 1
                    x = np.expand_dims(x, axis = 0) # Массив формы (1, 224, 224, 3)
                    # Подготовка данных для передачи на вход нейронной сети VGG16
                    x = pri(x)
                    imgs_loaded.append(x)
            if show_img:
                show_pics(imgs_list, imgs_for_show)
                exit()
            return imgs_loaded
        # Загрузка изображений
        imgs_loaded = load_imgs(pathToData, imgs_list)
        model = img_net(weights = 'imagenet', include_top = True)
        if show_summary:
            model.summary() # Вывод сведений о слоях нейронной сети
        # Прогнозирование
        predit(imgs_loaded, imgs_list)

Источники

1. Исследование устойчивости сверточных нейросетей. https://habr.com/ru/companies/huawei/articles/509816/.
2. Арлазаров В. В., Лимонова Е. Е. Вопросы устойчивости искусственного интеллекта на основе нейронных сетей: теория и практика. (ФИЦ ИУ РАН) https://rutube.ru/video/3dd79744f919052709014475b8169bd2/.
3. ImageNet. https://image-net.org/index.php.
4. Understanding GoogLeNet Model – CNN Architecture. https://www.geeksforgeeks.org/understanding-googlenet-model-cnn-architecture/
5. AlexNet. https://en.wikipedia.org/wiki/AlexNet.
6. Карпенко А. П., Овчинников В. А. Как обмануть нейронную сеть? Синтез шума для уменьшения точности нейросетевой классификации изображений. Вестник МГТУ им. Н.Э. Баумана. Сер. Приборостроение, 2021, № 1 (134), с. 102–119. DOI: https://doi.org/10.18698/0236-3933-2021-1-102-119.
7. FA_Attack_on_AlexNet. https://github.com/Carco-git/FA_Attack_on_AlexNet.

Список работ