深度学习的前沿主题：GANs、自监督学习和Transformer模型

# 导入必要的库
import tensorflow as tf
from tensorflow.keras.layers import Dense, Reshape, Flatten
from tensorflow.keras.models import Sequential
from tensorflow.keras.optimizers import Adam
import numpy as np

# 定义生成器模型
def build_generator(latent_dim):
    model = Sequential()
    model.add(Dense(128, input_dim=latent_dim, activation='relu'))
    model.add(Dense(784, activation='sigmoid'))
    model.add(Reshape((28, 28)))
    return model

# 定义判别器模型
def build_discriminator(input_shape):
    model = Sequential()
    model.add(Flatten(input_shape=input_shape))
    model.add(Dense(128, activation='relu'))
    model.add(Dense(1, activation='sigmoid'))
    return model

# 定义GAN模型
def build_gan(generator, discriminator):
    discriminator.trainable = False
    model = Sequential()
    model.add(generator)
    model.add(discriminator)
    model.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0002, beta_1=0.5))
    return model

# 训练GAN模型
def train_gan(generator, discriminator, gan, epochs, batch_size, latent_dim, data):
    for epoch in range(epochs):
        # 生成随机的噪声输入
        noise = np.random.normal(0, 1, (batch_size, latent_dim))
        # 使用生成器生成假数据
        generated_data = generator.predict(noise)
        # 从真实数据中随机抽取样本
        idx = np.random.randint(0, data.shape[0], batch_size)
        real_data = data[idx]

        # 训练判别器
        d_loss_real = discriminator.train_on_batch(real_data, np.ones((batch_size, 1)))
        d_loss_fake = discriminator.train_on_batch(generated_data, np.zeros((batch_size, 1)))
        d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)

        # 训练生成器
        noise = np.random.normal(0, 1, (batch_size, latent_dim))
        g_loss = gan.train_on_batch(noise, np.ones((batch_size, 1)))

        # 打印训练进度
        print(f"Epoch {epoch}, Discriminator Loss: {d_loss}, Generator Loss: {g_loss}")

# 主函数，加载数据并训练GAN模型
def main():
    # 加载MNIST数据集作为示例
    (X_train, _), (_, _) = tf.keras.datasets.mnist.load_data()
    X_train = X_train / 255.0  # 归一化到 [0, 1] 区间
    X_train = np.expand_dims(X_train, axis=-1)  # 扩展维度以适应模型输入

    # 定义参数
    latent_dim = 100
    epochs = 20000
    batch_size = 128

    # 创建生成器和判别器
    generator = build_generator(latent_dim)
    discriminator = build_discriminator(X_train.shape[1:])
    gan = build_gan(generator, discriminator)

    # 训练GAN模型
    train_gan(generator, discriminator, gan, epochs, batch_size, latent_dim, X_train)

if __name__ == '__main__':
    main()

# 导入必要的库
import tensorflow as tf
from tensorflow.keras.layers import Input, Dense
from tensorflow.keras.models import Model

# 构建自编码器模型
def build_autoencoder(input_shape, encoding_dim):
    # 编码器
    input_img = Input(shape=input_shape)
    encoded = Dense(encoding_dim, activation='relu')(input_img)

    # 解码器
    decoded = Dense(input_shape[0], activation='sigmoid')(encoded)

    # 构建自编码器模型
    autoencoder = Model(input_img, decoded)
    autoencoder.compile(optimizer='adam', loss='binary_crossentropy')
    return autoencoder

# 主函数，加载数据并训练自编码器模型
def main():
    # 加载MNIST数据集作为示例
    (X_train, _), (X_test, _) = tf.keras.datasets.mnist.load_data()
    X_train = X_train / 255.0  # 归一化到 [0, 1] 区间
    X_test = X_test / 255.0  # 归一化到 [0, 1] 区间
    X_train = X_train.reshape((len(X_train), np.prod(X_train.shape[1:])))
    X_test = X_test.reshape((len(X_test), np.prod(X_test.shape[1:])))

    # 定义输入形状和编码维度
    input_shape = (784,)
    encoding_dim = 32

    # 创建自编码器
    autoencoder = build_autoencoder(input_shape, encoding_dim)

    # 训练自编码器模型
    autoencoder.fit
    autoencoder.fit(X_train, X_train, epochs=50, batch_size=256, shuffle=True,                         
    validation_data=(X_test, X_test))

    # 编码器模型
    encoder = Model(autoencoder.input, autoencoder.layers[1].output)

    # 测试编码器和解码器
    encoded_imgs = encoder.predict(X_test)
    decoded_imgs = autoencoder.predict(X_test)

    # 可视化结果
    import matplotlib.pyplot as plt

    n = 10  # 展示10个样本
    plt.figure(figsize=(20, 4))
    for i in range(n):
        # 显示原始图像
        ax = plt.subplot(2, n, i + 1)
        plt.imshow(X_test[i].reshape(28, 28))
        plt.gray()
        ax.axis('off')

        # 显示重构图像
        ax = plt.subplot(2, n, i + 1 + n)
        plt.imshow(decoded_imgs[i].reshape(28, 28))
        plt.gray()
        ax.axis('off')

    plt.show()

if __name__ == '__main__':
    main()

# 导入必要的库
import tensorflow as tf
from transformers import BertTokenizer, TFBertForSequenceClassification
from tensorflow.keras.optimizers import Adam

# 加载BERT预训练模型和tokenizer
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = TFBertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2)

# 定义输入文本和标签
texts = ["I love programming.", "I hate bugs."]
labels = [1, 0]

# 将文本转换为BERT的输入格式
inputs = tokenizer(texts, return_tensors="tf", padding=True, truncation=True)

# 编译模型
optimizer = Adam(learning_rate=5e-5)
model.compile(optimizer=optimizer, loss=model.compute_loss, metrics=['accuracy'])

# 训练模型
model.fit(inputs.data, tf.constant(labels), epochs=3, batch_size=2)

# 测试模型
predictions = model.predict(inputs.data).logits
predicted_labels = tf.argmax(predictions, axis=1)
print(predicted_labels)