当前位置：首页 > article >正文

深度学习——生成对抗网络（GAN）

article 2024/10/8 19:50:10

在这里插入图片描述

✅作者简介：2022年博客新星第八。热爱国学的Java后端开发者，修心和技术同步精进。
🍎个人主页：Java Fans的博客
🍊个人信条：不迁怒，不贰过。小知识，大智慧。
💞当前专栏：Java案例分享专栏
✨特色专栏：国学周更-心性养成之路
🥭本文内容：深度学习——生成对抗网络（GAN）

文章目录

- 生成图像
- - 步骤1: 随机游走生成边
  - 步骤2: 构建图生成器（Generator）和判别器（Discriminator）
  - 步骤3: GAN训练循环

生成图像

生成对抗网络（GAN）是一种基于模拟深度学习模型的机器学习方法，它使用两个具有不同特征的网络来训练生成图像。生成图像可以通过以下步骤实现：

生成原始图像。
将生成的图像与真实图像进行对比，以检测差异并调整参数以提高质量。
训练一个新图像生成器，用于生成新的图像。

PYTHON代码示例

IMPORT NUMPY AS NP
FROM KERAS.MODELS IMPORT SEQUENTIAL
FROM KERAS.LAYERS IMPORT DENSE, FLATTEN, CONV2D, MAXPOOLING2D
FROM KERAS.OPTIMIZERS IMPORT ADAM
FROM KERAS.PREPROCESSING.IMAGE IMPORT IMAGEDATAGENERATOR
 
# 定义模型结构
MODEL = SEQUENTIAL()
 
# 输入层
MODEL.ADD(CONV2D(64, (5, 5), ACTIVATION='RELU', INPUT_SHAPE=(64, 64, 3)))
MODEL.ADD(MAXPOOLING2D(POOL_SIZE=(2, 2)))
 
# 全连接层
MODEL.ADD(FLATTEN())
MODEL.ADD(DENSE(1024, ACTIVATION='RELU'))
MODEL.ADD(DROPOUT(0.5))
MODEL.ADD(DENSE(1, ACTIVATION='SIGMOID'))
 
# 编译模型
MODEL.COMPILE(OPTIMIZER=ADAM(), LOSS='BINARY_CROSSENTROPY')
 
# 加载数据集和预处理函数
TRAIN_DATAGEN = IMAGEDATAGENERATOR(RESCALE=1./255,
                                   SHEAR_RANGE=0.2,
                                   ZOOM_RANGE=0.2,
                                   HORIZONTAL_FLIP=TRUE)
 
TEST_DATAGEN = IMAGEDATAGENERATOR(RESCALE=1./255)
 
TRAINING_SET = TRAIN_DATAGEN.FLOW_FROM_DIRECTORY('DATA/TRAIN',
                                                 TARGET_SIZE=(64, 64),
                                                 BATCH_SIZE=32,
                                                 CLASS_MODE='BINARY')
 
VALIDATION_SET = TEST_DATAGEN.FLOW_FROM_DIRECTORY('DATA/VALIDATION',
                                                  TARGET_SIZE=(64, 64),
                                                  BATCH_SIZE=32,
                                                  CLASS_MODE='BINARY')
 
# 训练模型
MODEL.FIT_GENERATOR(TRAINING_SET,
                    STEPS_PER_EPOCH=64,
                    EPOCHS=10,
                    VALIDATION_DATA=VALIDATION_SET,
                    VALIDATION_STEPS=64)
 
# 预测
IMAGE = NP.RANDOM.RAND(64, 64, 3)
PREDICTED_IMAGE = MODEL.PREDICT(IMAGE)
 
PRINT(PREDICTED_IMAGE[0])

这段代码首先导入了必要的库，定义了一个模型结构，并编译模型。然后加载数据集，对数据进行预处理，接着训练模型。最后预测一个新的图像，并打印出预测结果。

要生成一个图结构数据的生成网络（GAN），我们可以基于随机游走的方法来生成节点间的边，并使用神经网络来优化这个过程，确保生成的图具有我们期望的特性。下面是一个简化版的示例代码，它包括了随机游走生成边的逻辑以及一个基本的生成对抗网络框架来学习生成更真实的图结构。注意，这个例子主要用于教学目的，实际应用中可能需要根据具体需求调整模型结构、损失函数等。

步骤1: 随机游走生成边

首先，我们需要一个简单的函数来执行随机游走并返回边的提议集。

import numpy as np
 
def random_walks(start_nodes, num_walks, walk_length):
    """
    执行随机游走并收集边提议。
    
    参数:
    - start_nodes: 起始节点列表
    - num_walks: 每个节点进行的随机游走次数
    - walk_length: 随机游走的长度
    
    返回:
    - edges_proposal: 边的提议集
    """
    nodes = set(range(1, 2709))  # 假设节点编号从1到2708
    edges_proposal = []
    
    for _ in range(num_walks):
        for node in start_nodes:
            walk = [node]
            for _ in range(walk_length-1):
                neighbors = list(nodes.difference(set(walk)))
                if not neighbors: break  # 如果没有未访问的邻居，则停止
                next_node = np.random.choice(neighbors)
                walk.append(next_node)
                edges_proposal.append((walk[-2], walk[-1]))  # 记录边
            
    return edges_proposal

步骤2: 构建图生成器（Generator）和判别器（Discriminator）

接下来，我们将构建一个简单的图生成器（使用全连接层作为示例），它将节点特征作为输入，尝试预测生成的邻接矩阵元素的概率。同时，构建一个判别器来区分真实图的邻接矩阵与生成的邻接矩阵。

这里简化处理，不直接实现复杂图结构的生成器，而是通过生成边概率矩阵的方式来示意如何构建GAN。实际中，你可能需要设计更复杂的模型来直接生成邻接矩阵或其变种表示。

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Reshape
from tensorflow.keras.optimizers import Adam
 
def build_generator(input_dim, output_dim):
    model = Sequential([
        Dense(128, input_shape=(input_dim,), activation='relu'),
        Dense(output_dim, activation='sigmoid')
    ])
    return model
 
def build_discriminator(input_dim):
    model = Sequential([
        Dense(128, input_shape=(input_dim,), activation='relu'),
        Dense(1, activation='sigmoid')
    ])
    return model
 
# 假设每个节点有10维特征
node_features_dim = 10
num_nodes = 2708
adj_matrix_dim = num_nodes * num_nodes  # 邻接矩阵展平后的维度
 
generator = build_generator(node_features_dim, adj_matrix_dim)
discriminator = build_discriminator(adj_matrix_dim)
 
# 编译模型
generator_optimizer = Adam(learning_rate=0.0002)
discriminator_optimizer = Adam(learning_rate=0.0002)
 
discriminator.compile(optimizer=discriminator_optimizer, loss='binary_crossentropy', metrics=['accuracy'])

步骤3: GAN训练循环

接下来是GAN的训练循环，这包括交替训练生成器和判别器。这里我们简化处理，仅展示基本流程框架。

import tensorflow as tf
 
# 假设我们已经有了真实图的邻接矩阵表示
real_adj_matrix_flattened = ...  # 你需要提供真实图的邻接矩阵并展平
 
epochs = 100
batch_size = 32
 
for epoch in range(epochs):
    # 训练判别器
    noise = tf.random.normal(shape=(batch_size, node_features_dim))
    generated_adj = generator(noise)
    real_labels = tf.ones((batch_size, 1))
    fake_labels = tf.zeros((batch_size, 1))
 
    d_loss_real = discriminator.train_on_batch(real_adj_matrix_flattened, real_labels)
    d_loss_fake = discriminator.train_on_batch(generated_adj, fake_labels)
    d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
 
    # 训练生成器
    noise = tf.random.normal(shape=(batch_size, node_features_dim))
    valid_y = tf.ones((batch_size, 1))
    g_loss = discriminator.train_on_batch(generator(noise), valid_y)
 
    print(f"Epoch {epoch}, D Loss: {d_loss[0]}, G Loss: {g_loss}")
 
print("Training completed.")