5：L对抗深度学习模型：蓝队的模型防御策略

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from art.attacks.evasion import FastGradientMethod
from art.estimators.classification import KerasClassifier

# 构建简单的分类模型
model = Sequential([
    Flatten(input_shape=(28, 28)),
    Dense(128, activation='relu'),
    Dense(10, activation='softmax')
])

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# 加载MNIST数据集
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

# 创建ART分类器
classifier = KerasClassifier(model=model, clip_values=(0, 1))

# 训练原始模型
classifier.fit(x_train, y_train, batch_size=32, nb_epochs=5)

# 创建FGSM攻击
attack = FastGradientMethod(estimator=classifier, eps=0.1)

# 生成对抗样本
x_test_adv = attack.generate(x_test)

# 评估原始模型在对抗样本上的性能
predictions = classifier.predict(x_test_adv)
accuracy = np.sum(np.argmax(predictions, axis=1) == y_test) / len(y_test)
print(f"原始模型在对抗样本上的准确率: {accuracy}")

# 进行对抗训练
classifier.fit(x_train, y_train, batch_size=32, nb_epochs=5, attacks=attack)

# 评估对抗训练后的模型在对抗样本上的性能
predictions = classifier.predict(x_test_adv)
accuracy = np.sum(np.argmax(predictions, axis=1) == y_test) / len(y_test)
print(f"对抗训练后模型在对抗样本上的准确率: {accuracy}")

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten

# 构建教师模型（大模型）
teacher_model = Sequential([
    Flatten(input_shape=(28, 28)),
    Dense(512, activation='relu'),
    Dense(256, activation='relu'),
    Dense(10, activation='softmax')
])

teacher_model.compile(optimizer='adam',
                     loss='sparse_categorical_crossentropy',
                     metrics=['accuracy'])

# 加载MNIST数据集
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

# 训练教师模型
teacher_model.fit(x_train, y_train, batch_size=32, epochs=10)

# 构建学生模型（小模型）
student_model = Sequential([
    Flatten(input_shape=(28, 28)),
    Dense(128, activation='relu'),
    Dense(10, activation='softmax')
])

# 蒸馏温度
temperature = 5

# 编译学生模型，使用蒸馏损失
student_model.compile(
    optimizer='adam',
    loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False)
)

# 生成教师模型的软标签
teacher_predictions = teacher_model.predict(x_train)
soft_labels = tf.nn.softmax(tf.math.log(teacher_predictions + 1e-10) / temperature)

# 训练学生模型
student_model.fit(x_train, soft_labels, batch_size=32, epochs=10)

# 评估学生模型
student_accuracy = student_model.evaluate(x_test, y_test)[1]
teacher_accuracy = teacher_model.evaluate(x_test, y_test)[1]
print(f"教师模型准确率: {teacher_accuracy}")
print(f"学生模型准确率: {student_accuracy}")

import numpy as np
from sklearn.neighbors import LocalOutlierFactor

class InputValidator:
    def __init__(self, contamination=0.1):
        self.contamination = contamination
        self.model = LocalOutlierFactor(contamination=contamination, novelty=True)
    
    def fit(self, X):
        """使用正常样本训练异常检测器"""
        self.model.fit(X)
    
    def validate(self, X):
        """验证输入是否异常"""
        # 预测异常分数
        scores = self.model.score_samples(X)
        # 预测是否为异常
        predictions = self.model.predict(X)
        # 返回异常分数和预测结果
        return scores, predictions

# 准备正常数据（假设我们有正常的网络流量数据）
np.random.seed(42)
normal_data = np.random.normal(0, 1, (1000, 10))

# 准备异常数据
anomaly_data = np.random.normal(5, 1, (100, 10))

# 创建并训练输入验证器
validator = InputValidator(contamination=0.1)
validator.fit(normal_data)

# 验证正常数据
normal_scores, normal_preds = validator.validate(normal_data)
print(f"正常数据被判定为异常的比例: {np.sum(normal_preds == -1) / len(normal_data)}")

# 验证异常数据
anomaly_scores, anomaly_preds = validator.validate(anomaly_data)
print(f"异常数据被判定为异常的比例: {np.sum(anomaly_preds == -1) / len(anomaly_data)}")