使用Python实现深度学习模型：自监督学习与对抗性训练

import tensorflow as tf
from tensorflow.keras import layers, models, optimizers, losses
import numpy as np
import matplotlib.pyplot as plt

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

# 数据归一化
x_train = x_train / 255.0
x_test = x_test / 255.0

# 数据形状调整
x_train = np.expand_dims(x_train, axis=-1)
x_test = np.expand_dims(x_test, axis=-1)

def rotate_images(images):
    rotated_images = []
    rotated_labels = []
    for image in images:
        for angle, label in zip([0, 1, 2, 3], [0, 90, 180, 270]):
            rotated_image = tf.image.rot90(image, k=label // 90)
            rotated_images.append(rotated_image)
            rotated_labels.append(angle)
    return np.array(rotated_images), np.array(rotated_labels)

# 生成旋转后的图像和标签
x_train_rot, y_train_rot = rotate_images(x_train)
x_test_rot, y_test_rot = rotate_images(x_test)

def create_model():
    model = models.Sequential([
        layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
        layers.MaxPooling2D((2, 2)),
        layers.Conv2D(64, (3, 3), activation='relu'),
        layers.MaxPooling2D((2, 2)),
        layers.Conv2D(128, (3, 3), activation='relu'),
        layers.Flatten(),
        layers.Dense(128, activation='relu'),
        layers.Dense(4, activation='softmax')  # 4个类别对应旋转角度
    ])
    return model

model = create_model()
model.compile(optimizer=optimizers.Adam(), loss=losses.SparseCategoricalCrossentropy(), metrics=['accuracy'])

history = model.fit(x_train_rot, y_train_rot, epochs=10, validation_data=(x_test_rot, y_test_rot))

def fgsm(model, images, labels, epsilon):
    with tf.GradientTape() as tape:
        tape.watch(images)
        predictions = model(images)
        loss = losses.sparse_categorical_crossentropy(labels, predictions)
    gradient = tape.gradient(loss, images)
    signed_grad = tf.sign(gradient)
    adversarial_images = images + epsilon * signed_grad
    return adversarial_images

epsilon = 0.1
adv_x_train = fgsm(model, x_train[:1000], y_train[:1000], epsilon)
adv_x_test = fgsm(model, x_test[:200], y_test[:200], epsilon)

# 合并原始样本和对抗样本
x_train_combined = np.concatenate((x_train, adv_x_train))
y_train_combined = np.concatenate((y_train, y_train[:1000]))

# 重新训练模型
adv_model = create_model()
adv_model.compile(optimizer=optimizers.Adam(), loss=losses.SparseCategoricalCrossentropy(), metrics=['accuracy'])

history_adv = adv_model.fit(x_train_combined, y_train_combined, epochs=10, validation_data=(x_test, y_test))

# 评估自监督学习模型
loss, accuracy = model.evaluate(x_test_rot, y_test_rot)
print(f'Self-supervised Model - Loss: {loss}, Accuracy: {accuracy}')

# 评估对抗性训练模型
loss_adv, accuracy_adv = adv_model.evaluate(x_test, y_test)
print(f'Adversarially Trained Model - Loss: {loss_adv}, Accuracy: {accuracy_adv}')