生成对抗网络matlab代码

下面是一个生成对抗网络（GAN）的MATLAB代码示例：

生成器网络的代码：

function G = generator(Z)
    hidden_size = 128;
    output_size = 784;
    
    W1 = randn(hidden_size, size(Z, 2));
    b1 = zeros(hidden_size, 1);
    W2 = randn(output_size, hidden_size);
    b2 = zeros(output_size, 1);
    
    G = sigmoid(W2 * sigmoid(W1 * Z' + b1) + b2);
end

function sig = sigmoid(x)
    sig = 1 ./ (1 + exp(-x));
end

判别器网络的代码：

function D = discriminator(X)
    hidden_size = 128;
    output_size = 1;
    
    W1 = randn(hidden_size, size(X, 2));
    b1 = zeros(hidden_size, 1);
    W2 = randn(output_size, hidden_size);
    b2 = zeros(output_size, 1);
    
    D = sigmoid(W2 * sigmoid(W1 * X' + b1) + b2);
end

function sig = sigmoid(x)
    sig = 1 ./ (1 + exp(-x));
end

训练过程的代码：

% 设置训练参数
num_epochs = 1000;
batch_size = 100;
learning_rate = 0.01;

% 加载数据集（假设为MNIST）
load mnist.mat;

% 初始化生成器和判别器的参数
_dim = 100;
G_params = initialize_params();
D_params = initialize_params();

% 训练循环
for epoch = 1:num_epochs
    % 随机打乱数据集
    perm = randperm(size(X_train, 2));
    X_train = X_train(:, perm);
    
    % 迭代每个batch
    for batch = 1:size(X_train, 2)/batch_size
        % 从真实数据中随机采样
        X_batch = X_train(:, (batch-1)*batch_size+1:batch*batch_size);
        
        % 生成随机噪声
        Z = randn(Z_dim, batch_size);
        
        % 前向传播和反向传播
        [G_loss, G_grads] = generator_loss_and_grads(G_params, Z, D_params);
        [D_loss, D_grads] = discriminator_loss_and_grads(D_params, X_batch, G_params);
        
        % 更新参数
        G_params = update_params(G_params, G_grads, learning_rate);
        D_params = update_params(D_params, D_grads, learning_rate);
    end
    
    % 打印训练过程中的损失
    fprintf('Epoch %d: G_loss = %.4f, D_loss = %.4f\n', epoch, G_loss, D_loss);
end

% 生成器损失和梯度的计算
function [G_loss, G_grads] = generator_loss_and_grads(G_params, Z, D_params)
    G = generator(Z);
    D_fake = discriminator(G);
    
    G_loss = mean(log(1 - D_fake));
    
    dD_fake = -1 ./ (1 - D_fake);
    dG_fake = dD_fake .* sigmoid_derivative(G)';

    G_grads.W2 = dG_fake * sigmoid(G)' / size(Z, 2);
    G_grads.b2 = mean(dG_fake, 2);
    G_grads.W1 = (D_params.W2' * dG_fake) .* sigmoid_derivative(G);
    G_grads.b1 = mean((D_params.W2' * dG_fake) .* sigmoid_derivative(G), 2);
end

% 判别器损失和梯度的计算
function [D_loss, D_grads] = discriminator_loss_and_grads(D_params, X, G_params)
    D_real = discriminator(X);
    D_fake = discriminator(generator(randn(size(X, 1), size(X, 2))), G_params);
    
    D_loss = mean(-log(D_real) - log(1 - D_fake));
    
    dD_real = -1 ./ D_real;
    dD_fake = 1 ./ (1 - D_fake);
    
    dX_real = D_params.W2' * dD_real;
    dX_fake = G_params