好像还挺好玩的GAN3——Keras搭建CGAN给生成结果贴上标签

最新推荐文章于 2024-10-09 17:21:21 发布
最新推荐文章于 2024-10-09 17:21:21 发布
阅读量8.6k 收藏 60
点赞数 8
分类专栏： 好像还挺好玩的GAN 文章标签： CGAN GAN Keras 标签学习 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44791964/article/details/103744620
版权

好像还挺好玩的GAN3——Keras搭建CGAN给生成结果贴上标签

学习前言

我又死了我又死了我又死了！
在这里插入图片描述

什么是CGAN

CGAN一种带条件约束的GAN，在生成模型（D）和判别模型（G）的建模中均引入条件变量y（conditional variable y）。

使用额外信息y对模型增加条件，可以指导数据生成过程。这些条件变量y可以基于多种信息，例如类别标签，用于图像修复的部分数据，来自不同模态（modality）的数据。

如果条件变量y是类别标签，可以看做CGAN是把纯无监督的 GAN 变成有监督的模型的一种改进。

这个简单直接的改进被证明非常有效。

简单来讲，普通的GAN输入的是一个N维的正态分布随机数，而CGAN会为这个随机数添上标签，其利用Embedding层将正整数（索引值）转换为固定尺寸的稠密向量，并将这个稠密向量与N维的正态分布随机数相乘，从而获得一个有标签的随机数。

神经网络构建

1、Generator

生成网络的输入是一个带标签的随机数，具体操作方式是生成一个N维的正态分布随机数，再利用Embedding层将正整数（索引值）转换为N维的稠密向量，并将这个稠密向量与N维的正态分布随机数相乘。

def build_generator(self):

    model = Sequential()

    model.add(Dense(256, input_dim=self.latent_dim))
    model.add(LeakyReLU(alpha=0.2))
    model.add(BatchNormalization(momentum=0.8))
    model.add(Dense(512))
    model.add(LeakyReLU(alpha=0.2))
    model.add(BatchNormalization(momentum=0.8))
    model.add(Dense(1024))
    model.add(LeakyReLU(alpha=0.2))
    model.add(BatchNormalization(momentum=0.8))
    model.add(Dense(np.prod(self.img_shape), activation='tanh'))
    model.add(Reshape(self.img_shape))

    # 输入一个数字，将其转换为固定尺寸的稠密向量
    # 输出维度是self.latent_dim
    label = Input(shape=(1,), dtype='int32')
    label_embedding = Flatten()(Embedding(self.num_classes, self.latent_dim)(label))

    # 将正态分布和索引对应的稠密向量相乘
    noise = Input(shape=(self.latent_dim,))
    model_input = multiply([noise, label_embedding])
    img = model(model_input)

    return Model([noise, label], img)

2、Discriminator

普通GAN的判别模型的目的是根据输入的图片判断出真伪。
在CGAN中，其不仅要判断出真伪，还要判断出种类。
因此它的输入一个28,28,1维的图片，输出有两个：
一个是0到1之间的数，1代表判断这个图片是真的，0代表判断这个图片是假的。与普通GAN不同的是，它使用的是卷积神经网络。
另一个是一个向量，用于判断这张图片属于什么类。

def build_discriminator(self):

    model = Sequential()
    model.add(Flatten(input_shape=self.img_shape))
    model.add(Dense(512))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dense(512))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.4))
    model.add(Dense(512))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dropout(0.4))
    model.summary()

    label = Input(shape=(1,), dtype='int32')
    img = Input(shape=self.img_shape)

    features = model(img)
	# 一个是真伪，一个是类别向量
    validity = Dense(1, activation="sigmoid")(features)
    label = Dense(self.num_classes, activation="softmax")(features)

    return Model(img, [validity, label])

训练思路

CGAN的训练和GAN不太一样，分为如下几个步骤：
1、随机选取batch_size个真实的图片和它的标签。
2、随机生成batch_size个N维向量和其对应的标签label，利用Embedding层进行组合，传入到Generator中生成batch_size个虚假图片。
3、Discriminator的loss函数由两部分组成，一部分是真伪的判断结果与真实情况的对比，一部分是图片所属标签的判断结果。
4、Generator的loss函数也由两部分组成，一部分是生成的图片是否被Discriminator判断为1，另一部分是生成的图片是否被分成了正确的类。

实现全部代码

from __future__ import print_function, division

from keras.datasets import mnist
from keras.layers import Input, Dense, Reshape, Flatten, Dropout, multiply
from keras.layers import BatchNormalization, Activation, Embedding, ZeroPadding2D
from keras.layers.advanced_activations import LeakyReLU
from keras.layers.convolutional import UpSampling2D, Conv2D
from keras.models import Sequential, Model
from keras.optimizers import Adam

import matplotlib.pyplot as plt
import os
import numpy as np

class CGAN():
    def __init__(self):
        # 输入shape
        self.img_rows = 28
        self.img_cols = 28
        self.channels = 1
        self.img_shape = (self.img_rows, self.img_cols, self.channels)
        # 分十类
        self.num_classes = 10
        self.latent_dim = 100
        # adam优化器
        optimizer = Adam(0.0002, 0.5)
        # 判别模型
        losses = ['binary_crossentropy', 'sparse_categorical_crossentropy']
        self.discriminator = self.build_discriminator()
        self.discriminator.compile(loss=losses,
            optimizer=optimizer,
            metrics=['accuracy'])

        # 生成模型
        self.generator = self.build_generator()

        # conbine是生成模型和判别模型的结合
        # 判别模型的trainable为False
        # 用于训练生成模型
        noise = Input(shape=(self.latent_dim,))
        label = Input(shape=(1,))
        img = self.generator([noise, label])
        self.discriminator.trainable = False
        valid, target_label = self.discriminator(img)

        self.combined = Model([noise, label], [valid, target_label])
        self.combined.compile(loss=losses,
            optimizer=optimizer)

    def build_generator(self):

        model = Sequential()

        model.add(Dense(256, input_dim=self.latent_dim))
        model.add(LeakyReLU(alpha=0.2))
        model.add(BatchNormalization(momentum=0.8))
        model.add(Dense(512))
        model.add(LeakyReLU(alpha=0.2))
        model.add(BatchNormalization(momentum=0.8))
        model.add(Dense(1024))
        model.add(LeakyReLU(alpha=0.2))
        model.add(BatchNormalization(momentum=0.8))
        model.add(Dense(np.prod(self.img_shape), activation='tanh'))
        model.add(Reshape(self.img_shape))

        # 输入一个数字，将其转换为固定尺寸的稠密向量
        # 输出维度是self.latent_dim
        label = Input(shape=(1,), dtype='int32')
        label_embedding = Flatten()(Embedding(self.num_classes, self.latent_dim)(label))

        # 将正态分布和索引对应的稠密向量相乘
        noise = Input(shape=(self.latent_dim,))
        model_input = multiply([noise, label_embedding])
        img = model(model_input)

        return Model([noise, label], img)

    def build_discriminator(self):

        model = Sequential()
        model.add(Flatten(input_shape=self.img_shape))
        model.add(Dense(512))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dense(512))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dropout(0.4))
        model.add(Dense(512))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dropout(0.4))

        label = Input(shape=(1,), dtype='int32')
        img = Input(shape=self.img_shape)

        features = model(img)
        # 一个是真伪，一个是类别向量
        validity = Dense(1, activation="sigmoid")(features)
        label = Dense(self.num_classes, activation="softmax")(features)

        return Model(img, [validity, label])
        
    def train(self, epochs, batch_size=128, sample_interval=50):

        # 载入数据库
        (X_train, y_train), (_,  _) = mnist.load_data()

        # 归一化
        X_train = (X_train.astype(np.float32) - 127.5) / 127.5
        X_train = np.expand_dims(X_train, axis=3)
        y_train = y_train.reshape(-1, 1)

        valid = np.ones((batch_size, 1))
        fake = np.zeros((batch_size, 1))

        for epoch in range(epochs):

            # --------------------- #
            #  训练鉴别模型
            # --------------------- #
            idx = np.random.randint(0, X_train.shape[0], batch_size)
            imgs, labels = X_train[idx], y_train[idx]

            # ---------------------- # 
            #   生成正态分布的输入
            # ---------------------- #
            noise = np.random.normal(0, 1, (batch_size, self.latent_dim))
            sampled_labels = np.random.randint(0, 10, (batch_size, 1))
            gen_imgs = self.generator.predict([noise, sampled_labels])

            d_loss_real = self.discriminator.train_on_batch(imgs, [valid, labels])
            d_loss_fake = self.discriminator.train_on_batch(gen_imgs, [fake, sampled_labels])
            d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)

            # --------------------- #
            #  训练生成模型
            # --------------------- #
            g_loss = self.combined.train_on_batch([noise, sampled_labels], [valid, sampled_labels])

            print ("%d [D loss: %f, acc.: %.2f%%, op_acc: %.2f%%] [G loss: %f]" % (epoch, d_loss[0], 100*d_loss[3], 100*d_loss[4], g_loss[0]))

            if epoch % sample_interval == 0:
                self.sample_images(epoch)

    def sample_images(self, epoch):
        r, c = 2, 5
        noise = np.random.normal(0, 1, (r * c, 100))
        sampled_labels = np.arange(0, 10).reshape(-1, 1)

        gen_imgs = self.generator.predict([noise, sampled_labels])
        gen_imgs = 0.5 * gen_imgs + 0.5

        fig, axs = plt.subplots(r, c)
        cnt = 0
        for i in range(r):
            for j in range(c):
                axs[i,j].imshow(gen_imgs[cnt,:,:,0], cmap='gray')
                axs[i,j].set_title("Digit: %d" % sampled_labels[cnt])
                axs[i,j].axis('off')
                cnt += 1
        fig.savefig("images/%d.png" % epoch)
        plt.close()


if __name__ == '__main__':
    if not os.path.exists("./images"):
        os.makedirs("./images")
    cgan = CGAN()
    cgan.train(epochs=20000, batch_size=256, sample_interval=200)

实现效果为：
在这里插入图片描述

Bubbliiiing
关注
专栏目录
基于Keras的生成对抗网络（4）——利用Keras搭建ACGAN生成手写体数字并贴上标签
Wendy的博客
04-23 874
0、前言 上两篇文章分别介绍了DCGAN 和CGAN的基本原理和代码示例，同时也反映出二者的一些缺点，比如DCGAN无法为图像添加标签进行分类，CGAN生成图像效果不好等。这一篇就来一下DCGAN与CGAN的综合版本——ACGAN。 一、ACGAN介绍及其结构 1.1 ACGAN介绍 ACGAN全称Auxiliary Classifier GAN，是在CGAN基础上的扩展，通过对判别器进行改进实现了图像分类的功能，论文链接：https://arxiv.org/abs/1610.09585 原始GAN网络的功
基于Keras的生成对抗网络（3）——利用Keras搭建CGAN生成手写体数字并贴上标签
Wendy的博客
03-31 664
目录0、前言一、CGAN介绍及其结构1.1 CGAN介绍1.2 CGAN结构二、函数代码2.1 生成器Generator2.2 判别器Discriminator2.3 train函数三、结果演示四、完整代码 0、前言 由于很多时候我们不仅想要数据，更想获取数据的标签，因此CGAN应运而生。 一、CGAN介绍及其结构 1.1 CGAN介绍 CGAN全称Conditional Generative Adversarial Nets，论文链接：https://arxiv.org/abs/1411.1784。 CG
TFM_CGAN：在Keras上建立一个生成对抗网络
02-22
TFM_CGAN 在Keras上建立一个生成对抗网络。
Keras-GAN:使用Keras实现各种生成对抗网络
最新发布
2401_87458718的博客
10-09 789
Keras-GAN项目为我们提供了丰富的GAN参考实现,是学习和实践GAN的绝佳资源。通过阅读和运行这些代码,我们可以深入理解各种GAN的工作原理,为自己的GAN应用开发打下坚实基础。
好像还挺好玩的GAN重制版4——Pytorch搭建SRGAN平台进行图片超分辨率提升
热门推荐
Bubbliiiing的学习小课堂
11-30 1万+
好像还挺好玩的GAN重制版4——Pytorch搭建SRGAN平台进行图片超分辨率提升学习前言源码下载地址什么是SRGAN生成网络的构建判别网络的构建训练思路判别器的训练生成器的训练利用SRGAN生成图片 学习前言 我又死了我又死了我又死了！ 源码下载地址 https://github.com/bubbliiiing/srgan-pytorch 喜欢的可以点个star噢。 什么是SRGAN SRGAN出自论文Photo-Realistic Single Image Super-Resolution Usin
cgan-denoiser:TensorflowKeras条件生成对抗网络（CGAN）模型的实现，可用于图像去噪或伪像去除
05-12
有条件的GAN去噪器 条件生成对抗网络（CGAN）模型的Tensorflow / Keras实现，可用于图像去噪或伪像去除。 CGAN由一个生成器网络和一个鉴别器网络组成。 生成器将嘈杂/伪像图像作为输入，目的是尽可能接近真实图像。 鉴别器模型将真实图像或生成的图像作为输入，目的是尽可能准确地区分两者。 因此，网络参与了至高无上的激烈竞争... 发电机网络模型基于[1]中的U-Net。 GalaxyGAN模型帮助了结构和模型体系结构的一些选择： ，[2]。 安装 旨在与Python 2.7或3.4或更高版本兼容，但仅在2.7.13和3.6.7上进行了测试。 您将需要 ，为您的机器进行适当设置。 您可以在environment.yml看到所需的Python软件包。 如果使用Anaconda，则可以使用此文件安装作者的环境（请注意，使用tensorflow-gpu ，它需要GPU）：
tensorflow keras 关于CIFAR10数据集 CGAN的研究经验总结
qq_44930937的博客
04-01 1371
前言 目前发现本人的网络可以在传统的MNIST手写数据集上有良好的表现，但是将其应用于CIFAR10数据集的时候，出现了非常严重的图像模糊行为，在实验了多种传统GAN的结构后，我的结论是传统的GAN对于图片的细节这些高频信息生成的能力非常欠缺的，现在我总结一下前期的工作，鉴于网上的代码比较少，我自己写了一个。 实验的结构 使用了类似于语义分割的结构进行实验，总之效果非常不好，虽然可以看出个大概的形...
基于Keras实现CGAN用于手写数字生成
weixin_43327191的博客
04-06 1950
"""条件GAN的实现: 基于MNIST数据集""" import os os.environ["TF_CPP_MIN_LOG_LEVEL"]="2" import matplotlib.pyplot as plt import numpy as np import tensorflow as tf from tensorflow.keras.datasets import mnist from tensorflow.keras.layers import Activation,BatchNormaliza
GAN3——Keras搭建CGAN给生成结果贴上标签
Mo181111的博客
07-04 1179
参考：https://blog.csdn.net/weixin_44791964/article/details/103744620 b站视频：https://www.bilibili.com/video/BV13J41187Fo 学习前言 什么是CGAN CGAN一种带条件约束的GAN，在生成模型（D）和判别模型（G）的建模中均引入条件变量y（conditional variable y）。 使用额外信息y对模型增加条件，可以指导数据生成过程。这些条件变量y可以基于多种信息，例如类别标签，用于图
GAN1——Keras搭建简单GAN生成MNIST手写体
Mo181111的博客
07-04 1709
参考:https://blog.csdn.net/weixin_44791964/article/details/103729797 b站视频：https://www.bilibili.com/video/BV13J41187Fo 目录 学习前言 什么是GAN 神经网络构建 1、Generator 2、Discriminator 训练思路 实现全部代码： 实现效果为： 学习前言 周一要汇报，纠结在讲循环神经网络，还是生成对抗网络？？最后还是生成对抗网络。 什么是GAN 生成式对抗
GAN2——Keras搭建DCGAN利用深度卷积神经网络实现图片生成
Mo181111的博客
07-04 1727
参考：https://blog.csdn.net/weixin_44791964/article/details/103743038 b站视频：https://www.bilibili.com/video/BV13J41187Fo 目录 学习前言 什么是DCGAN 神经网络构建 1、Generator 2、Discriminator 训练思路 实现全部代码 实现效果为： 学习前言 什么是DCGAN DCGAN的全称是Deep Convolutional Generative A
cgan1_keras.py
11-06
Keras CGAN-MNIST 代码，基于简单的dcgan结构，能跑通
CGAN中的label_embedding = Flatten()(Embedding(10, 100)(label))行代码解释
plus_left的博客
04-04 924
在看CGAN代码是对该行产生困惑 label_embedding = Flatten()(Embedding(10, 100)(label)) 经查询和测试两个函数Flatten()和Embedding() 得出以下结论，以便后续复习使用。 1.测试内容1 from tensorflow.keras.layers import Flatten, Embedding, Input label = Input(shape=(1,), dtype='int32') # label = np.random.ran
CGAN minist上的简单实现
Evanxxxnnn的博客
10-09 2662
CGAN的超简单实现，基于pytorch 0.4。 刚开始搭建了一个原始GAN网络，没多久就遇到模型崩溃的问题，生成的样本丰富性很少，所以索性直接改成CGAN ，整个原理还是很简单的，改起来很快，主要是参数调整真的让人头大。 GAN 训练了35个epoch的效果，几乎只生成3和5的样本。 #CGAN训练效果，第8个epoch , 可以看到生成样本丰富性很高，而且质量很不错。 代码 代码有点点乱...
CGAN--条件生成对抗神经网络（文末留言免费赠书）
weixin_40920183的博客
06-24 1624
CGAN概述 原始的GAN在生成高维度数据时，只能随机生成，无法生成我们给定条件的数据。这极大的限制了GAN的应用范围，因为，对于我们来说，仅仅生成足够真实的数据（如图片）没有太大...
[GAN学习系列] 初识GAN
weixin_34203832的博客
10-24 454
本文大约 3800 字，阅读大约需要 8 分钟 要说最近几年在深度学习领域最火的莫过于生成对抗网络，即 Generative Adversarial Networks(GANs)了。它是 Ian Goodfellow 在 2014 年发表的，也是这四年来出现的各种 GAN 的变种的开山鼻祖了，下图表示这四年来有关 GAN 的论文的每个月发表数量，可以看出在 2014 年提出后到 2016 年相...
【论文精读】AGCRN-自适应图卷积循环神经网络
打酱油的葫芦娃
06-12 570
该论文提出了一种新型的自适应图卷积循环网络（AGCRN），用于预测城市交通流量和速度。AGCRN通过节点自适应参数学习和数据自适应图生成模块，自动捕捉交通序列中的时空相关性，无需预定义的图结构。实验结果表明，AGCRN在两个真实世界的交通数据集上显著优于现有技术。
GAN中G同时生成两张图之GAN for Medical Imaging: Generating Images and Annotations
风一样的自由，色彩斑斓的雨季
02-22 811
原文链接：GAN for Medical Imaging: Generating Images and Annotations （需要翻墙） 在这篇文章中，我们将展示一种使用生成对抗网络(GANs)同时生成医学图像和相应注释的方法。我们使用心脏MR图像进行实验。对于模型开发，我们使用Keras和theano后端。 介绍： 器官的自动检测和分割在医学成像应用中有着巨大的作用。例如在心脏分析中，...
小白的GAN网络学习（四）- ACGAN
summer_bugs的博客
04-25 1617
ACGAN 文章目录ACGANACGAN & CGANACGAN的损失函数基于mnist数据集的ACGAN实现 ACGAN & CGAN CGAN通过在生成器和判别器中均使用标签信息进行训练，仅能产生特定标签的数据 ACGAN是CGAN的另一种实现，既使用标签信息进行训练，同时也重建标签信息 生成器的输入包括class 和 noise 两部分，其中class为训练数据的标签（ba...
python keras使用CGAN网络生成不同类型的时间序列并保存代码
05-25
下面是一个使用CGAN网络生成不同类型时间序列的示例代码，包括保存模型和生成的时间序列。 首先，我们需要导入必要的库： ```python from keras.layers import Input, Dense, Reshape, Flatten, Dropout, Embedding, multiply from keras.layers import BatchNormalization, Activation, ZeroPadding2D, Concatenate, Conv2DTranspose from keras.layers.advanced_activations import LeakyReLU from keras.layers.convolutional import UpSampling2D, Conv2D from keras.models import Sequential, Model from keras.optimizers import Adam from keras.utils import to_categorical import numpy as np import pandas as pd import matplotlib.pyplot as plt ``` 然后定义一些超参数： ```python img_rows = 28 img_cols = 28 channels = 1 img_shape = (img_rows, img_cols, channels) latent_dim = 100 num_classes = 10 ``` 接下来，我们定义生成器和判别器模型： ```python def build_generator(): model = Sequential() model.add(Dense(256, input_dim=latent_dim)) model.add(LeakyReLU(alpha=0.2)) model.add(BatchNormalization(momentum=0.8)) model.add(Dense(512)) model.add(LeakyReLU(alpha=0.2)) model.add(BatchNormalization(momentum=0.8)) model.add(Dense(1024)) model.add(LeakyReLU(alpha=0.2)) model.add(BatchNormalization(momentum=0.8)) model.add(Dense(np.prod(img_shape), activation='tanh')) model.add(Reshape(img_shape)) noise = Input(shape=(latent_dim,)) label = Input(shape=(1,), dtype='int32') label_embedding = Flatten()(Embedding(num_classes, latent_dim)(label)) model_input = multiply([noise, label_embedding]) img = model(model_input) return Model([noise, label], img) def build_discriminator(): model = Sequential() model.add(Dense(512, input_dim=np.prod(img_shape))) model.add(LeakyReLU(alpha=0.2)) model.add(Dense(512)) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.4)) model.add(Dense(512)) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.4)) model.add(Dense(1, activation='sigmoid')) img = Input(shape=img_shape) label = Input(shape=(1,), dtype='int32') label_embedding = Flatten()(Embedding(num_classes, np.prod(img_shape))(label)) flat_img = Flatten()(img) model_input = multiply([flat_img, label_embedding]) validity = model(model_input) return Model([img, label], validity) ``` 然后，我们构建CGAN模型： ```python optimizer = Adam(0.0002, 0.5) # Build and compile the discriminator discriminator = build_discriminator() discriminator.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy']) # Build the generator generator = build_generator() # The generator takes noise and the target label as input # and generates the corresponding digit of that label noise = Input(shape=(latent_dim,)) label = Input(shape=(1,)) img = generator([noise, label]) # For the combined model we will only train the generator discriminator.trainable = False # The discriminator takes generated image and the target label as input # and determines if the generated image is real or fake valid = discriminator([img, label]) # The combined model (stacked generator and discriminator) # Trains the generator to fool the discriminator combined = Model([noise, label], valid) combined.compile(loss='binary_crossentropy', optimizer=optimizer) ``` 接下来，我们加载数据集： ```python (X_train, y_train), (_, _) = mnist.load_data() # Rescale -1 to 1 X_train = X_train / 127.5 - 1. X_train = np.expand_dims(X_train, axis=3) # Convert labels to one-hot encoding y_train = to_categorical(y_train, num_classes=num_classes) ``` 现在，我们定义一些辅助函数来保存模型和生成的时间序列： ```python def save_models(epoch): generator.save('cgan_generator_epoch_%d.h5' % epoch) discriminator.save('cgan_discriminator_epoch_%d.h5' % epoch) def generate_and_save_images(generator, epoch, noise): # Generate images from noise labels = np.arange(0, num_classes).reshape(-1, 1) gen_imgs = generator.predict([noise, labels]) # Rescale images to 0-1 gen_imgs = 0.5 * gen_imgs + 0.5 # Plot images fig, axs = plt.subplots(num_classes, 1, figsize=(10, 10)) cnt = 0 for i in range(num_classes): axs[i].imshow(gen_imgs[cnt, :, :, 0], cmap='gray') axs[i].set_title("Digit: %d" % cnt) axs[i].axis('off') cnt += 1 fig.savefig("cgan_generated_image_epoch_%d.png" % epoch) plt.close() ``` 最后，我们训练CGAN模型并保存生成的时间序列： ```python epochs = 10000 batch_size = 32 save_interval = 1000 # Adversarial ground truths valid = np.ones((batch_size, 1)) fake = np.zeros((batch_size, 1)) for epoch in range(epochs): # --------------------- # Train Discriminator # --------------------- # Select a random batch of images and labels idx = np.random.randint(0, X_train.shape[0], batch_size) imgs, labels = X_train[idx], y_train[idx] # Generate a batch of fake images noise = np.random.normal(0, 1, (batch_size, latent_dim)) gen_imgs = generator.predict([noise, labels]) # Train the discriminator d_loss_real = discriminator.train_on_batch([imgs, labels], valid) d_loss_fake = discriminator.train_on_batch([gen_imgs, labels], fake) d_loss = 0.5 * np.add(d_loss_real, d_loss_fake) # --------------------- # Train Generator # --------------------- # Generate a batch of noise noise = np.random.normal(0, 1, (batch_size, latent_dim)) # Train the generator (to have the discriminator label samples as valid) g_loss = combined.train_on_batch([noise, labels], valid) # Plot the progress print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (epoch, d_loss[0], 100 * d_loss[1], g_loss)) # Save generated images and models at save intervals if epoch % save_interval == 0: save_models(epoch) generate_and_save_images(generator, epoch, noise) ``` 这样，我们就可以生成多个数字类型的时间序列，并将模型和生成的时间序列保存在本地。
评论 41
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Bubbliiiing

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值