Разработка схем безопасности для алгоритмов глубокого обучения имеет решающее значение для защиты беспроводных сетей от злоумышленников. Однако единого мнения о том, как лучше всего это сделать, нет. В этом блоге я представляю уязвимость безопасности в глубоком обучении для прогнозирования формирования луча с использованием глубоких нейронных сетей (DNN) и предлагаю два метода устранения этой уязвимости. Экспериментальные результаты показывают, что эти методы эффективны для защиты моделей DNN от атак злоумышленников в беспроводных сетях следующего поколения.
Цитировать работу
Если вы считаете эти результаты полезными, укажите их :
@misc{kuzlu2022adversarial,
title={The Adversarial Security Mitigations of mmWave Beamforming Prediction Models using Defensive Distillation and Adversarial Retraining},
author={Murat Kuzlu and Ferhat Ozgur Catak and Umit Cali and Evren Catak and Ozgur Guler},
year={2022},
eprint={2202.08185},
archivePrefix={arXiv},
primaryClass={cs.CR}
}1. Введение
Первый стандарт 5G был объявлен и одобрен 3GPP в декабре 2017 года. Ожидается, что ранняя работа по стандартизации 5G обеспечит прочную и стабильную основу для скорейшего внедрения услуг 5G. Кроме того, 5G будет иметь важное значение для приложений Интернета вещей (IoT) и будущих мобильных сетей. При проектировании сетей 5G возникает множество проблем, в том числе схема безопасности для предсказания формирования луча. Это важная часть беспроводных сетей, изучаемая в системах связи и обработки сигналов. Разработка и реализация алгоритмов формирования луча в беспроводных сетях следующего поколения (например, 6G) также имеет решающее значение. В современных беспроводных сетях прогнозирование формирования луча на основе глубокого обучения (DL) уязвимо для враждебных атак машинного обучения. Поэтому крайне важно разработать схему безопасности для предсказания формирования луча в сетях 6G.
6G — новейшая технология беспроводной связи среди сотовых сетей, находящихся в стадии разработки. В решениях 6G алгоритмы на основе искусственного интеллекта (ИИ) будут одним из основных компонентов систем беспроводной связи для повышения общей производительности системы. Существующие решения в 5G будут перенесены в область ИИ, а точнее в область DL. Поэтому крайне важно разработать безопасные решения DL для моделей на основе ИИ в беспроводных сетях 6G. Новая поверхность атаки и существующие проблемы безопасности 5G являются уязвимостями безопасности DL. Исследователи и компании должны смягчить проблемы безопасности своих моделей DL, прежде чем развертывать их в производственных средах. Им необходимо выявлять, документировать и проводить оценку рисков новых угроз безопасности в системах беспроводной связи следующего поколения.
2. Оборонительная дистилляция
Дистилляция знаний была ранее введена Hinton et al. сжать большую модель в меньшую. Пейпернот и др. предложил эту технику для состязательной защиты от атак с помощью машинного обучения. Метод смягчения защитной дистилляции включает в себя более крупную модель учителя и сжатую модель ученика. Первый шаг — обучить модель учителя с параметром высокой температуры ($T$), чтобы смягчить выходные данные вероятности softmax модели DNN.
$i$th class и $z_{i}$ — логиты. Второй шаг — использовать ранее обученную модель учителя для получения программных меток обучающих данных. На этом этапе модель учителя прогнозирует каждую выборку в обучающих данных, используя одно и то же значение температуры ($T$), а прогнозы представляют собой метки (т. е. программные метки) для обучающих данных для обучения модели ученика. Модель ученика обучается с помощью мягких меток, полученных от модели учителя, опять же с высоким значением $T$ в softmax. После этапа обучения модели учащегося параметр $T$ устанавливается равным 1 в течение времени прогнозирования модели учащегося.
На рис. 1 показаны общие этапы этого метода.
3. Приступаем к кодированию
Я покажу предложенный нами подход на языке Python. Я импортирую обычные стандартные библиотеки, чтобы построить модель глубокого обучения для прогнозирования кодового слова формирования радиочастотного луча.
!pip install -q cleverhans
!pip install -q plot_keras_history
!pip install -q loguru
import util
from plot_keras_history import plot_history
import matplotlib.pyplot as plt
from tqdm.notebook import tqdm
import numpy as np
from sklearn.metrics import mean_squared_error
import pandas as pd
import seaborn as sns
SCENARIO_NAME = 'O1'
nb_epoch = 2000
batch_size = 1000
num_tot_TX=4
num_beams=512
loss_fn='mean_squared_error'
DS_PATH = '/Users/ozgur/Documents/Workshop/DeepMIMO_Dataset_Generation_v1.1/DLCB_dataset/'В этой работе я буду использовать общедоступный набор данных DeepMIMO для атаки на модель прогнозирования формирования радиочастотного луча. Я буду использовать атаку FGSM и функцию потери среднеквадратичной ошибки для обработки ввода. Моя реализация атаки FGSM здесь. В этом сценарии есть 4 базовых станции.
In_train, In_test, Out_train, Out_test = util.get_dataset(SCENARIO_NAME) AP_models,AP_models_history = util.train(In_train, Out_train, In_test, Out_test, nb_epoch, batch_size,loss_fn=loss_fn, n_BS=num_tot_TX, n_beams=num_beams, sc_name=SCENARIO_NAME) for i in range(num_tot_TX): plot_history(AP_models_history[i].history, side=3) plt.show()0%| | 0/4 [00:00<?, ?it/s] Restoring model weights from the end of the best epoch: 91. Epoch 00111: early stopping Restoring model weights from the end of the best epoch: 106. Epoch 00126: early stopping Restoring model weights from the end of the best epoch: 96. Epoch 00116: early stopping Restoring model weights from the end of the best epoch: 57. Epoch 00077: early stopping
Состязательные атаки машинного обучения
На этом этапе мы будем генерировать вредоносные сигналы восходящей линии связи, используя атаки Fast-Gradient Sign Method (FGSM), Basic Iterative Method (BIM), Momentum Iterative Method (MIM), Projected Gradient Descent (PGD).
FGSM (метод быстрого градиента)
epsilon_vals = [0.1, 0.2, 0.3] fgm_eps_mse = [] fgsm_all_mse = [] fgsm_all_eps = [] for eps_val in tqdm(epsilon_vals): fgsm_mse_malicious = [] for i_bs in range(num_tot_TX): adv_inputs = util.attack_models(model = AP_models[i_bs], attack_name = 'FGSM', eps_val = eps_val, testset = In_test, norm = np.inf) adv_inputs_pred = AP_models[i_bs].predict(adv_inputs) for j in range(adv_inputs_pred.shape[0]): tmp = mean_squared_error(Out_test[j,i_bs*num_beams:(i_bs+1)*num_beams], adv_inputs_pred[j,:]) fgsm_mse_malicious.append(tmp) fgsm_all_mse.append(tmp) fgsm_all_eps.append(eps_val) fgm_eps_mse.append(np.mean(fgsm_mse_malicious))0%| | 0/3 [00:00<?, ?it/s] WARNING:tensorflow:5 out of the last 5 calls to <function compute_gradient at 0x7f9d7ba1eb80> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details. WARNING:tensorflow:6 out of the last 6 calls to <function compute_gradient at 0x7f9d7ba1eb80> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has experimental_relax_shapes=True option that relaxes argument shapes that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.
PGD (проецируемый градиентный спуск)
pgd_eps_mse = [] pgd_all_mse = [] for eps_val in tqdm(epsilon_vals): pgd_mse_malicious = [] for i_bs in range(num_tot_TX): adv_inputs = util.attack_models(model = AP_models[i_bs], attack_name = 'PGD', eps_val = eps_val, testset = In_test, norm = np.inf) adv_inputs_pred = AP_models[i_bs].predict(adv_inputs) for j in range(adv_inputs_pred.shape[0]): tmp = mean_squared_error(Out_test[j,i_bs*num_beams:(i_bs+1)*num_beams], adv_inputs_pred[j,:]) pgd_mse_malicious.append(tmp) pgd_all_mse.append(tmp) pgd_eps_mse.append(np.mean(pgd_mse_malicious))0%| | 0/3 [00:00<?, ?it/s]
BIM (основной итерационный метод)
bim_eps_mse = [] bim_all_mse = [] for eps_val in tqdm(epsilon_vals): bim_mse_malicious = [] for i_bs in range(num_tot_TX): adv_inputs = util.attack_models(model = AP_models[i_bs], attack_name = 'BIM', eps_val = eps_val, testset = In_test, norm = np.inf) adv_inputs_pred = AP_models[i_bs].predict(adv_inputs) for j in range(adv_inputs_pred.shape[0]): tmp = mean_squared_error(Out_test[j,i_bs*num_beams:(i_bs+1)*num_beams], adv_inputs_pred[j,:]) bim_mse_malicious.append(tmp) bim_all_mse.append(tmp) bim_eps_mse.append(np.mean(bim_mse_malicious))0%| | 0/3 [00:00<?, ?it/s]
MIM (импульсный итерационный метод)
mim_eps_mse = [] mim_all_mse = [] for eps_val in tqdm(epsilon_vals): mim_mse_malicious = [] for i_bs in range(num_tot_TX): adv_inputs = util.attack_models(model = AP_models[i_bs], attack_name = 'MIM', eps_val = eps_val, testset = In_test, norm = np.inf) adv_inputs_pred = AP_models[i_bs].predict(adv_inputs) for j in range(adv_inputs_pred.shape[0]): tmp = mean_squared_error(Out_test[j,i_bs*num_beams:(i_bs+1)*num_beams], adv_inputs_pred[j,:]) mim_mse_malicious.append(tmp) mim_all_mse.append(tmp) mim_eps_mse.append(np.mean(mim_mse_malicious))0%| | 0/3 [00:00<?, ?it/s]df_avg_mse = pd.DataFrame({'epsilon_vals':epsilon_vals,'fgm_eps_mse':fgm_eps_mse, 'pgd_eps_mse':pgd_eps_mse,'bim_eps_mse':bim_eps_mse, 'mim_eps_mse':mim_eps_mse}) df_avg_mse.to_csv('df_avg_mse.csv', index=False) plt.figure(figsize=(10,3)) sns.lineplot(data=df_avg_mse, x='epsilon_vals', y='fgm_eps_mse', ls='--', lw=2) sns.lineplot(data=df_avg_mse, x='epsilon_vals', y='pgd_eps_mse', ls='-.', lw=2) sns.lineplot(data=df_avg_mse, x='epsilon_vals', y='bim_eps_mse', ls='-', lw=2) sns.lineplot(data=df_avg_mse, x='epsilon_vals', y='mim_eps_mse', ls='-.', lw=2) plt.ylabel('MSE', fontsize=20) plt.xlabel(r'$\epsilon$ values', fontsize=20) plt.xticks(fontsize=16) plt.yticks(fontsize=16) plt.grid(True) plt.legend(['FGSM','PGD','BIM','MIM'],shadow=True, ncol=2,fontsize=16) plt.show()
Распределения среднеквадратичной ошибки
Гистограмма распределения MSE для каждой атаки. Существует сильная отрицательная корреляция между $\epsilon$ и эффективностью прогнозирования модели глубокого обучения. Значение доверительного интервала корреляций (т. е. значение $p$) равно 0. Значение $p$ представляет собой вероятность, связанную с вероятностью получения результата корреляции.
df_fgsm_res = pd.DataFrame({'epsilon':fgsm_all_eps,
'FGSM':fgsm_all_mse,'PGD':pgd_all_mse,
'BIM':bim_all_mse,'MIM':mim_all_mse})
df_fgsm_res.to_csv('df_fgsm_res.csv', index=False)
color_codes = ['r','g','b']
attack_types = ['FGSM','PGD','BIM','MIM']
fig,ax = plt.subplots(1, 4, figsize=(20, 5), sharey=True)
ax_idx = 0
for attack_type in attack_types:
for tmp_eps_val, c_name in zip(epsilon_vals,color_codes):
df_fgsm_res_tmp = df_fgsm_res.query('epsilon == ' + str(tmp_eps_val) )
sns.histplot(data=df_fgsm_res_tmp, x=attack_type, element="poly", cumulative=False,
lw=2,stat='count',log_scale=(False,False),
ax=ax[ax_idx], color=c_name)
ax[ax_idx].set_xlabel(attack_type, fontsize=20)
ax[ax_idx].set_ylabel(r'Count', fontsize=20)
ax[ax_idx].legend(epsilon_vals,shadow=False,ncol=1,fontsize=14)
ax[ax_idx].grid()
ax_idx += 1
plt.show()
Оборонительная дистилляция
AP_distilled_models = util.train_distill(In_train, Out_train, In_test, Out_test, nb_epoch, batch_size,loss_fn=loss_fn, n_BS=num_tot_TX, n_beams=num_beams, teacher_multiplication=3.0,student_multiplication=0.1, distill_alpha=0.1, distill_temp=100, sc_name=SCENARIO_NAME)0%| | 0/4 [00:00<?, ?it/s]
Атака на дистиллированные модели
Мы проведем те же атаки для дистиллированных моделей. Из графиков легко увидеть, что дистиллированные модели более устойчивы к атакам.
epsilon_vals = [0.1, 0.2, 0.3] fgm_eps_mse = [] fgsm_all_mse = [] fgsm_all_eps = [] for eps_val in tqdm(epsilon_vals): fgsm_mse_malicious = [] for i_bs in range(num_tot_TX): adv_inputs = util.attack_models(model = AP_distilled_models[i_bs], attack_name = 'FGSM', eps_val = eps_val, testset = In_test, norm = np.inf) adv_inputs_pred = AP_distilled_models[i_bs].predict(adv_inputs) for j in range(adv_inputs_pred.shape[0]): tmp = mean_squared_error(Out_test[j,i_bs*num_beams:(i_bs+1)*num_beams], adv_inputs_pred[j,:]) fgsm_mse_malicious.append(tmp) fgsm_all_mse.append(tmp) fgsm_all_eps.append(eps_val) fgm_eps_mse.append(np.mean(fgsm_mse_malicious))0%| | 0/3 [00:00<?, ?it/s]pgd_eps_mse = [] pgd_all_mse = [] for eps_val in tqdm(epsilon_vals): pgd_mse_malicious = [] for i_bs in range(num_tot_TX): adv_inputs = util.attack_models(model = AP_distilled_models[i_bs], attack_name = 'PGD', eps_val = eps_val, testset = In_test, norm = np.inf) adv_inputs_pred = AP_distilled_models[i_bs].predict(adv_inputs) for j in range(adv_inputs_pred.shape[0]): tmp = mean_squared_error(Out_test[j,i_bs*num_beams:(i_bs+1)*num_beams], adv_inputs_pred[j,:]) pgd_mse_malicious.append(tmp) pgd_all_mse.append(tmp) pgd_eps_mse.append(np.mean(pgd_mse_malicious))0%| | 0/3 [00:00<?, ?it/s]bim_eps_mse = [] bim_all_mse = [] for eps_val in tqdm(epsilon_vals): bim_mse_malicious = [] for i_bs in range(num_tot_TX): adv_inputs = util.attack_models(model = AP_distilled_models[i_bs], attack_name = 'BIM', eps_val = eps_val, testset = In_test, norm = np.inf) adv_inputs_pred = AP_distilled_models[i_bs].predict(adv_inputs) for j in range(adv_inputs_pred.shape[0]): tmp = mean_squared_error(Out_test[j,i_bs*num_beams:(i_bs+1)*num_beams], adv_inputs_pred[j,:]) bim_mse_malicious.append(tmp) bim_all_mse.append(tmp) bim_eps_mse.append(np.mean(bim_mse_malicious))0%| | 0/3 [00:00<?, ?it/s]mim_eps_mse = [] mim_all_mse = [] for eps_val in tqdm(epsilon_vals): mim_mse_malicious = [] for i_bs in range(num_tot_TX): adv_inputs = util.attack_models(model = AP_distilled_models[i_bs], attack_name = 'MIM', eps_val = eps_val, testset = In_test, norm = np.inf) adv_inputs_pred = AP_distilled_models[i_bs].predict(adv_inputs) for j in range(adv_inputs_pred.shape[0]): tmp = mean_squared_error(Out_test[j,i_bs*num_beams:(i_bs+1)*num_beams], adv_inputs_pred[j,:]) mim_mse_malicious.append(tmp) mim_all_mse.append(tmp) mim_eps_mse.append(np.mean(mim_mse_malicious))0%| | 0/3 [00:00<?, ?it/s]df_avg_mse = pd.DataFrame({'epsilon_vals':epsilon_vals,'fgm_eps_mse':fgm_eps_mse, 'pgd_eps_mse':pgd_eps_mse,'bim_eps_mse':bim_eps_mse, 'mim_eps_mse':mim_eps_mse}) df_avg_mse.to_csv('df_avg_mse.csv', index=False) plt.figure(figsize=(10,3)) sns.lineplot(data=df_avg_mse, x='epsilon_vals', y='fgm_eps_mse', ls='--', lw=2) sns.lineplot(data=df_avg_mse, x='epsilon_vals', y='pgd_eps_mse', ls='-.', lw=2) sns.lineplot(data=df_avg_mse, x='epsilon_vals', y='bim_eps_mse', ls='-', lw=2) sns.lineplot(data=df_avg_mse, x='epsilon_vals', y='mim_eps_mse', ls='-.', lw=2) plt.ylabel('MSE', fontsize=20) plt.xlabel(r'$\epsilon$ values', fontsize=20) plt.xticks(fontsize=16) plt.yticks(fontsize=16) plt.grid(True) plt.legend(['FGSM','PGD','BIM','MIM'],shadow=True, ncol=2,fontsize=16) plt.show()
df_fgsm_res = pd.DataFrame({'epsilon':fgsm_all_eps,
'FGSM':fgsm_all_mse,'PGD':pgd_all_mse,
'BIM':bim_all_mse,'MIM':mim_all_mse})
df_fgsm_res.to_csv('df_fgsm_res.csv', index=False)
color_codes = ['r','g','b']
attack_types = ['FGSM','PGD','BIM','MIM']
fig,ax = plt.subplots(1, 4, figsize=(20, 5), sharey=True)
ax_idx = 0
for attack_type in attack_types:
for tmp_eps_val, c_name in zip(epsilon_vals,color_codes):
df_fgsm_res_tmp = df_fgsm_res.query('epsilon == ' + str(tmp_eps_val) )
sns.histplot(data=df_fgsm_res_tmp, x=attack_type, element="poly", cumulative=False,
lw=2,stat='count',log_scale=(False,False),
ax=ax[ax_idx], color=c_name)
ax[ax_idx].set_xlabel(attack_type, fontsize=20)
ax[ax_idx].set_ylabel(r'Count', fontsize=20)
ax[ax_idx].legend(epsilon_vals,shadow=False,ncol=1,fontsize=14)
ax[ax_idx].grid()
ax_idx += 1
plt.show()
4. Заключение
В этом блоге представлена схема безопасности для уязвимостей моделей прогнозирования формирования радиочастотного луча и методы их устранения. Для изучения этих вопросов были проведены эксперименты с выбранными сценариями DeepMIMO. Результаты подтверждают, что исходная модель формирования луча на основе DL значительно уязвима для атак FGSM, PGD, BIM и MIM. Значение MSE увеличивается во всех трех сценариях при сильной атаке со стороны BIM. С другой стороны, результаты показывают, что предложенные методы ослабления помех успешно повышают эффективность прогнозирования формирования РЧ-лучей.
