[生成对抗网络GAN入门指南]（3）GAN的工程实践及基础代码

最新推荐文章于 2023-02-28 16:44:21 发布

置顶 gdtop818

最新推荐文章于 2023-02-28 16:44:21 发布

阅读量1.4k

点赞数 2

本文链接：https://blog.csdn.net/weixin_37993251/article/details/87075492

版权

深度学习paper 同时被 3 个专栏收录

21 篇文章 6 订阅

订阅专栏

GAN

17 篇文章 11 订阅

订阅专栏

paper_GAN

17 篇文章 11 订阅

订阅专栏

1、导入相关包，设置随机参数

2、设置真实数据的分布、生成器的初始化分布

3、设置线性运算：并用于生成器和判别器

4、设置优化器，使用学习率衰减的梯度下降方法

5、搭建GAN模型

6、运行主程序

完整代码请直接链接到最后面

从上一章[生成对抗网络GAN入门指南]（2）理解生成对抗网络最后，我们需要做的优化是以下这个式子：

$V=E_{x \sim P_{data}}logD(x)+E_{x \sim P_{z}}log(1-D(G(z)))$

上式中期望可以等价于计算真实分布和生成数据分布的积分，在上一章已经完整证明过。

现在我们在前置的随机分布 $p_g(z)$ 中取出m个随机数，然后从真实数据 $p_{data}(x)$ 中取出m个真实样本，然后使用平均数代替上面的期望。公式改写如下：

$V=\frac{1}{m} \sum ^m_{i=1}[logD(x^{(i)})+log(1-D(G(z^{(i)})))]$

伪代码如下:

for训练的迭代次数do

for重复k次do

从生成器的前置随机分布 $p_g(z)$ 中取出m个小批次样本；

从真实数据分布 $p_{data}(x)$ 中取出m个小批次样本；

使用随机梯度下降参数：

$\triangledown _ {\theta,d} \ \frac{1}{m} \sum ^m_{i=1}[logD(x^{(i)})+log(1-D(G(z^{(i)})))]$

end for

从生成器前置随机分布 $p_g(z)$ 取出m个小批次样本；

使用随机梯度下降更新参数；

$\triangledown _ {\theta} \ \frac{1}{m} \sum ^m_{i=1}log(1-D(G(z^{(i)})))$

end for

下面为随机生成的真实高斯分布数据，并用GAN来生成数据。

1、导入相关包，设置随机参数

import argparse
import numpy as np
from scipy.stats import norm
import tensorflow as tf
import matplotlib.pyplot as plt
from matplotlib import animation
import seaborn as sns

sns.set(color_codes=True)  

seed = 42
np.random.seed(seed)
tf.set_random_seed(seed)

2、设置真实数据的分布、生成器的初始化分布

# 均值为3，方差为0.5的高斯分布
class DataDistribution(object):
    def __init__(self):
        self.mu = 3
        self.sigma = 0.5

    def sample(self, N):
        samples = np.random.normal(self.mu, self.sigma, N)
        samples.sort()
        return samples

# 生成器初始分布为平均分布
class GeneratorDistribution(object):
    def __init__(self, range):
        self.range = range

    def sample(self, N):
        return np.linspace(-self.range, self.range, N) + \
            np.random.random(N) * 0.01

3、设置线性运算：并用于生成器和判别器

def linear(input, output_dim, scope=None, stddev=1.0):
    norm = tf.random_normal_initializer(stddev=stddev)
    const = tf.constant_initializer(0.0)
    with tf.variable_scope(scope or 'linear'):
        w = tf.get_variable('w', [input.get_shape()[1], output_dim], initializer=norm)
        b = tf.get_variable('b', [output_dim], initializer=const)
        return tf.matmul(input, w) + b


def generator(input, h_dim):
    h0 = tf.nn.softplus(linear(input, h_dim, 'g0'))
    h1 = linear(h0, 1, 'g1')
    return h1


def discriminator(input, h_dim):
    h0 = tf.tanh(linear(input, h_dim * 2, 'd0'))
    h1 = tf.tanh(linear(h0, h_dim * 2, 'd1'))   
    h2 = tf.tanh(linear(h1, h_dim * 2, 'd2'))
    h3 = tf.sigmoid(linear(h2, 1, 'd3'))
    return h3

4、设置优化器，使用学习率衰减的梯度下降方法

def optimizer(loss, var_list, initial_learning_rate):
    decay = 0.95
    num_decay_steps = 150
    batch = tf.Variable(0)
    learning_rate = tf.train.exponential_decay(
        initial_learning_rate,
        batch,
        num_decay_steps,
        decay,
        staircase=True
    )
    optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(
        loss,
        global_step=batch,
        var_list=var_list
    )
    return optimizer

5、搭建GAN模型

class GAN(object):
    def __init__(self, data, gen, num_steps, batch_size, log_every):
        self.data = data
        self.gen = gen
        self.num_steps = num_steps
        self.batch_size = batch_size
        self.log_every = log_every
        self.mlp_hidden_size = 4
        self.learning_rate = 0.03
        self._create_model()

    def _create_model(self):
        ......

    def train(self):
        ......

①创建模型：创建预训练判别器D_pre、生成器Generator和判别器Discriminator

创建预训练判别器D_pre

    def _create_model(self):

        with tf.variable_scope('D_pre'):
            self.pre_input = tf.placeholder(tf.float32, shape=(self.batch_size, 1))
            self.pre_labels = tf.placeholder(tf.float32, shape=(self.batch_size, 1))
            D_pre = discriminator(self.pre_input, self.mlp_hidden_size)
            self.pre_loss = tf.reduce_mean(tf.square(D_pre - self.pre_labels))
            self.pre_opt = optimizer(self.pre_loss, None, self.learning_rate)

创建生成器Generator

        # This defines the generator network - it takes samples from a noise
        # distribution as input, and passes them through an MLP.
        with tf.variable_scope('Generator'):
            self.z = tf.placeholder(tf.float32, shape=(self.batch_size, 1))
            self.G = generator(self.z, self.mlp_hidden_size)

创建判别器Discriminator

        # The discriminator tries to tell the difference between samples from the
        # true data distribution (self.x) and the generated samples (self.z).
        #
        # Here we create two copies of the discriminator network (that share parameters),
        # as you cannot use the same network with different inputs in TensorFlow.
        with tf.variable_scope('Discriminator') as scope:
            self.x = tf.placeholder(tf.float32, shape=(self.batch_size, 1))
            self.D1 = discriminator(self.x, self.mlp_hidden_size)
            scope.reuse_variables()
            self.D2 = discriminator(self.G, self.mlp_hidden_size)

分别计算生成器和判别器的损失loss_g和loss_d，并进行优化

        # Define the loss for discriminator and generator networks (see the original
        # paper for details), and create optimizers for both
        self.loss_d = tf.reduce_mean(-tf.log(self.D1) - tf.log(1 - self.D2))
        self.loss_g = tf.reduce_mean(-tf.log(self.D2))

        self.d_pre_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='D_pre')
        self.d_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Discriminator')
        self.g_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Generator')

        self.opt_d = optimizer(self.loss_d, self.d_params, self.learning_rate)
        self.opt_g = optimizer(self.loss_g, self.g_params, self.learning_rate)

②进行训练：预训练判别器D_pre，然后将训练后的参数共享给判别器Discriminator

预训练判别器D_pre

    def train(self):
        with tf.Session() as session:
            tf.global_variables_initializer().run()

            # pretraining discriminator
            num_pretrain_steps = 1000
            for step in range(num_pretrain_steps):
                d = (np.random.random(self.batch_size) - 0.5) * 10.0
                labels = norm.pdf(d, loc=self.data.mu, scale=self.data.sigma)
                pretrain_loss, _ = session.run([self.pre_loss, self.pre_opt], {
                    self.pre_input: np.reshape(d, (self.batch_size, 1)),
                    self.pre_labels: np.reshape(labels, (self.batch_size, 1))
                })
            self.weightsD = session.run(self.d_pre_params)
            # copy weights from pre-training over to new D network
            for i, v in enumerate(self.d_params):
                session.run(v.assign(self.weightsD[i]))

            for step in range(self.num_steps):
                # update discriminator
                x = self.data.sample(self.batch_size)
                z = self.gen.sample(self.batch_size)
                loss_d, _ = session.run([self.loss_d, self.opt_d], {
                    self.x: np.reshape(x, (self.batch_size, 1)),
                    self.z: np.reshape(z, (self.batch_size, 1))
                })

将训练后的参数共享给判别器Discriminator

                # update generator
                z = self.gen.sample(self.batch_size)
                loss_g, _ = session.run([self.loss_g, self.opt_g], {
                    self.z: np.reshape(z, (self.batch_size, 1))
                })

                if step % self.log_every == 0:
                    print('{}: {}\t{}'.format(step, loss_d, loss_g))                
                if step % 100 == 0 or step==0 or step == self.num_steps -1 :
                    self._plot_distributions(session)

③可视化：使用采样展示生成数据和真实数据的分布

采样

    def _samples(self, session, num_points=10000, num_bins=100):
        xs = np.linspace(-self.gen.range, self.gen.range, num_points)
        bins = np.linspace(-self.gen.range, self.gen.range, num_bins)

        # data distribution
        d = self.data.sample(num_points)
        pd, _ = np.histogram(d, bins=bins, density=True)

        # generated samples
        zs = np.linspace(-self.gen.range, self.gen.range, num_points)
        g = np.zeros((num_points, 1))
        for i in range(num_points // self.batch_size):
            g[self.batch_size * i:self.batch_size * (i + 1)] = session.run(self.G, {
                self.z: np.reshape(
                    zs[self.batch_size * i:self.batch_size * (i + 1)],
                    (self.batch_size, 1)
                )
            })
        pg, _ = np.histogram(g, bins=bins, density=True)

        return pd, pg

可视化

    def _plot_distributions(self, session):
        pd, pg = self._samples(session)
        p_x = np.linspace(-self.gen.range, self.gen.range, len(pd))
        f, ax = plt.subplots(1)
        ax.set_ylim(0, 1)
        plt.plot(p_x, pd, label='Real Data')
        plt.plot(p_x, pg, label='Generated Data')
        plt.title('GAN Visualization')
        plt.xlabel('Value')
        plt.ylabel('Probability Density')
        plt.legend()
        plt.show()

6、运行主程序

def main(args):
    model = GAN(
        DataDistribution(),
        GeneratorDistribution(range=8),
        args.num_steps,
        args.batch_size,
        args.log_every,
    )
    model.train()


def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument('--num-steps', type=int, default=1200,
                        help='the number of training steps to take')
    parser.add_argument('--batch-size', type=int, default=12,
                        help='the batch size')
    parser.add_argument('--log-every', type=int, default=10,
                        help='print loss after this many steps')
    parses = parser.parse_args(args=[])#添加args=[]
    return parses

注意这里parses = parser.parse_args(args=[])#添加args=[]

如果不加args=[]会报错An exception has occurred, use %tb to see the full traceback.

if __name__ == '__main__':
    main(parse_args())

结果如下：

0: 0.9058498740196228	3.017925262451172

10: 0.3661727011203766	2.4829494953155518
20: 0.2567436695098877	2.527153730392456
30: 0.23893599212169647	2.646153688430786
40: 0.21188394725322723	2.755629301071167
50: 0.24596953392028809	2.7865734100341797
60: 0.27803653478622437	2.819697618484497
70: 0.20561213791370392	3.014293670654297
80: 0.20861400663852692	3.093595266342163
90: 0.1999121755361557	3.1188929080963135
100: 0.8676349520683289	3.1559784412384033

110: 0.2710826098918915	3.0497334003448486
120: 0.2979937791824341	3.3270256519317627
130: 0.35235917568206787	3.153003454208374
140: 0.3312816917896271	3.266500234603882
150: 0.44445013999938965	3.2211639881134033
160: 0.830064594745636	2.5850722789764404
170: 1.0792583227157593	2.844705581665039
180: 1.1153842210769653	2.539602279663086
190: 0.9280094504356384	2.582491636276245
200: 0.8895644545555115	2.544771909713745

210: 0.8804630637168884	2.5786397457122803
220: 0.9524447321891785	2.5626392364501953
230: 1.0161170959472656	2.6068341732025146
240: 0.9398650527000427	2.61761474609375
250: 0.9690361022949219	2.6562836170196533
260: 0.9535879492759705	2.702772855758667
270: 0.9497044682502747	2.729496955871582
280: 0.9505455493927002	2.7817916870117188
290: 0.9766985774040222	2.822368860244751
300: 0.9790706634521484	2.848435640335083

310: 0.9584127068519592	2.831235885620117
320: 0.9558747410774231	2.838682174682617
330: 0.9572162628173828	2.843243360519409
340: 0.9545037150382996	2.8567473888397217
350: 0.9616591930389404	2.8660755157470703
360: 0.9513992667198181	2.8865842819213867
370: 0.9513044953346252	2.8945209980010986
380: 0.9510054588317871	2.9008471965789795
390: 0.9619631767272949	2.911766767501831
400: 0.9593977332115173	2.9199936389923096

410: 0.9573793411254883	2.925779104232788
420: 0.9600151181221008	2.9308977127075195
430: 0.9554762840270996	2.9343574047088623
440: 0.9505661129951477	2.9468088150024414
450: 0.9538960456848145	2.9457263946533203
460: 0.9585859179496765	2.964500665664673
470: 0.9657346606254578	2.969087600708008
480: 0.9562466740608215	2.97055721282959
490: 0.9631298184394836	2.9682061672210693
500: 0.9579052925109863	2.98766827583313

510: 0.9529304504394531	2.9976375102996826
520: 0.9577788710594177	2.9855854511260986
530: 0.9556493759155273	2.9906623363494873
540: 0.963697612285614	3.0012834072113037
550: 0.9546659588813782	3.0135772228240967
560: 0.954541027545929	3.000689744949341
570: 0.9527294635772705	3.018080949783325
580: 0.9562703967094421	3.0316765308380127
590: 0.9562308192253113	3.033099889755249
600: 0.9676775932312012	3.0354459285736084

610: 0.9556455612182617	3.026475667953491
620: 0.9621879458427429	3.0372326374053955
630: 0.9544457793235779	3.041356325149536
640: 0.9505367279052734	3.058652877807617
650: 0.9726033210754395	3.0442416667938232
660: 0.960233747959137	3.048086166381836
670: 0.9602031111717224	3.0599300861358643
680: 0.9553996920585632	3.0656583309173584
690: 0.95340496301651	3.061668634414673
700: 0.9558480381965637	3.0625126361846924

710: 0.9548101425170898	3.0637643337249756
720: 0.9591142535209656	3.0792343616485596
730: 0.9580585360527039	3.076420545578003
740: 0.9542174339294434	3.084198236465454
750: 0.9520791172981262	3.0760724544525146
760: 0.9857081770896912	3.0916473865509033
770: 0.954762876033783	3.098372220993042
780: 0.956782341003418	3.101635694503784
790: 0.9556240439414978	3.0913455486297607
800: 0.9452716708183289	3.0873405933380127

810: 0.9598703384399414	3.0957539081573486
820: 0.9495179057121277	3.1218841075897217
830: 0.9676353335380554	3.1136913299560547
840: 0.9608518481254578	3.0985374450683594
850: 0.9497320055961609	3.1004221439361572
860: 0.9583330750465393	3.10925030708313
870: 0.9575583338737488	3.115415573120117
880: 0.9481444954872131	3.142063856124878
890: 0.9595341086387634	3.1321611404418945
900: 0.9526324272155762	3.115969657897949

910: 0.957833468914032	3.1158668994903564
920: 0.9581219553947449	3.13159441947937
930: 0.9586291313171387	3.1408939361572266
940: 0.9535805583000183	3.152231454849243
950: 0.9539173245429993	3.1291332244873047
960: 0.9537625312805176	3.130748748779297
970: 0.9528759121894836	3.1425857543945312
980: 0.9532210230827332	3.150545835494995
990: 0.9515659213066101	3.157489776611328
1000: 0.9518685936927795	3.140913724899292

1010: 0.9496883749961853	3.143315315246582
1020: 0.9560754895210266	3.156165361404419
1030: 0.9554839134216309	3.1636600494384766
1040: 0.9747700095176697	3.1666743755340576
1050: 0.9559829235076904	3.1536171436309814
1060: 0.9466338753700256	3.153604507446289
1070: 0.9512701034545898	3.1573095321655273
1080: 0.9531095623970032	3.1709377765655518
1090: 0.9690462946891785	3.1741015911102295
1100: 0.9565709233283997	3.173053026199341

1110: 0.9528694748878479	3.1647026538848877
1120: 0.9897692799568176	3.173391342163086
1130: 0.9538822770118713	3.1752426624298096
1140: 0.9539585709571838	3.1887900829315186
1150: 0.9726629257202148	3.1818549633026123
1160: 0.9535603523254395	3.177844285964966
1170: 0.9504902958869934	3.1759109497070312
1180: 0.9564926028251648	3.1849753856658936
1190: 0.9527941346168518	3.2040793895721436

完整代码

import argparse
import numpy as np
from scipy.stats import norm
import tensorflow as tf
import matplotlib.pyplot as plt
from matplotlib import animation
import seaborn as sns

sns.set(color_codes=True)  

seed = 42
np.random.seed(seed)
tf.set_random_seed(seed)


class DataDistribution(object):
    def __init__(self):
        self.mu = 3
        self.sigma = 0.5

    def sample(self, N):
        samples = np.random.normal(self.mu, self.sigma, N)
        samples.sort()
        return samples


class GeneratorDistribution(object):
    def __init__(self, range):
        self.range = range

    def sample(self, N):
        return np.linspace(-self.range, self.range, N) + \
            np.random.random(N) * 0.01


def linear(input, output_dim, scope=None, stddev=1.0):
    norm = tf.random_normal_initializer(stddev=stddev)
    const = tf.constant_initializer(0.0)
    with tf.variable_scope(scope or 'linear'):
        w = tf.get_variable('w', [input.get_shape()[1], output_dim], initializer=norm)
        b = tf.get_variable('b', [output_dim], initializer=const)
        return tf.matmul(input, w) + b


def generator(input, h_dim):
    h0 = tf.nn.softplus(linear(input, h_dim, 'g0'))
    h1 = linear(h0, 1, 'g1')
    return h1


def discriminator(input, h_dim):
    h0 = tf.tanh(linear(input, h_dim * 2, 'd0'))
    h1 = tf.tanh(linear(h0, h_dim * 2, 'd1'))   
    h2 = tf.tanh(linear(h1, h_dim * 2, 'd2'))
    h3 = tf.sigmoid(linear(h2, 1, 'd3'))
    return h3

def optimizer(loss, var_list, initial_learning_rate):
    decay = 0.95
    num_decay_steps = 150
    batch = tf.Variable(0)
    learning_rate = tf.train.exponential_decay(
        initial_learning_rate,
        batch,
        num_decay_steps,
        decay,
        staircase=True
    )
    optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(
        loss,
        global_step=batch,
        var_list=var_list
    )
    return optimizer


class GAN(object):
    def __init__(self, data, gen, num_steps, batch_size, log_every):
        self.data = data
        self.gen = gen
        self.num_steps = num_steps
        self.batch_size = batch_size
        self.log_every = log_every
        self.mlp_hidden_size = 4
        self.learning_rate = 0.03
        self._create_model()

    def _create_model(self):

        with tf.variable_scope('D_pre'):
            self.pre_input = tf.placeholder(tf.float32, shape=(self.batch_size, 1))
            self.pre_labels = tf.placeholder(tf.float32, shape=(self.batch_size, 1))
            D_pre = discriminator(self.pre_input, self.mlp_hidden_size)
            self.pre_loss = tf.reduce_mean(tf.square(D_pre - self.pre_labels))
            self.pre_opt = optimizer(self.pre_loss, None, self.learning_rate)

        # This defines the generator network - it takes samples from a noise
        # distribution as input, and passes them through an MLP.
        with tf.variable_scope('Generator'):
            self.z = tf.placeholder(tf.float32, shape=(self.batch_size, 1))
            self.G = generator(self.z, self.mlp_hidden_size)

        # The discriminator tries to tell the difference between samples from the
        # true data distribution (self.x) and the generated samples (self.z).
        #
        # Here we create two copies of the discriminator network (that share parameters),
        # as you cannot use the same network with different inputs in TensorFlow.
        with tf.variable_scope('Discriminator') as scope:
            self.x = tf.placeholder(tf.float32, shape=(self.batch_size, 1))
            self.D1 = discriminator(self.x, self.mlp_hidden_size)
            scope.reuse_variables()
            self.D2 = discriminator(self.G, self.mlp_hidden_size)

        # Define the loss for discriminator and generator networks (see the original
        # paper for details), and create optimizers for both
        self.loss_d = tf.reduce_mean(-tf.log(self.D1) - tf.log(1 - self.D2))
        self.loss_g = tf.reduce_mean(-tf.log(self.D2))

        self.d_pre_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='D_pre')
        self.d_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Discriminator')
        self.g_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Generator')

        self.opt_d = optimizer(self.loss_d, self.d_params, self.learning_rate)
        self.opt_g = optimizer(self.loss_g, self.g_params, self.learning_rate)

    def train(self):
        with tf.Session() as session:
            tf.global_variables_initializer().run()

            # pretraining discriminator
            num_pretrain_steps = 1000
            for step in range(num_pretrain_steps):
                d = (np.random.random(self.batch_size) - 0.5) * 10.0
                labels = norm.pdf(d, loc=self.data.mu, scale=self.data.sigma)
                pretrain_loss, _ = session.run([self.pre_loss, self.pre_opt], {
                    self.pre_input: np.reshape(d, (self.batch_size, 1)),
                    self.pre_labels: np.reshape(labels, (self.batch_size, 1))
                })
            self.weightsD = session.run(self.d_pre_params)
            # copy weights from pre-training over to new D network
            for i, v in enumerate(self.d_params):
                session.run(v.assign(self.weightsD[i]))

            for step in range(self.num_steps):
                # update discriminator
                x = self.data.sample(self.batch_size)
                z = self.gen.sample(self.batch_size)
                loss_d, _ = session.run([self.loss_d, self.opt_d], {
                    self.x: np.reshape(x, (self.batch_size, 1)),
                    self.z: np.reshape(z, (self.batch_size, 1))
                })

                # update generator
                z = self.gen.sample(self.batch_size)
                loss_g, _ = session.run([self.loss_g, self.opt_g], {
                    self.z: np.reshape(z, (self.batch_size, 1))
                })

                if step % self.log_every == 0:
                    print('{}: {}\t{}'.format(step, loss_d, loss_g))                
                if step % 100 == 0 or step==0 or step == self.num_steps -1 :
                    self._plot_distributions(session)

    def _samples(self, session, num_points=10000, num_bins=100):
        xs = np.linspace(-self.gen.range, self.gen.range, num_points)
        bins = np.linspace(-self.gen.range, self.gen.range, num_bins)

        # data distribution
        d = self.data.sample(num_points)
        pd, _ = np.histogram(d, bins=bins, density=True)

        # generated samples
        zs = np.linspace(-self.gen.range, self.gen.range, num_points)
        g = np.zeros((num_points, 1))
        for i in range(num_points // self.batch_size):
            g[self.batch_size * i:self.batch_size * (i + 1)] = session.run(self.G, {
                self.z: np.reshape(
                    zs[self.batch_size * i:self.batch_size * (i + 1)],
                    (self.batch_size, 1)
                )
            })
        pg, _ = np.histogram(g, bins=bins, density=True)

        return pd, pg

    def _plot_distributions(self, session):
        pd, pg = self._samples(session)
        p_x = np.linspace(-self.gen.range, self.gen.range, len(pd))
        f, ax = plt.subplots(1)
        ax.set_ylim(0, 1)
        plt.plot(p_x, pd, label='Real Data')
        plt.plot(p_x, pg, label='Generated Data')
        plt.title('GAN Visualization')
        plt.xlabel('Value')
        plt.ylabel('Probability Density')
        plt.legend()
        plt.show()

def main(args):
    model = GAN(
        DataDistribution(),
        GeneratorDistribution(range=8),
        args.num_steps,
        args.batch_size,
        args.log_every,
    )
    model.train()


def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument('--num-steps', type=int, default=1200,
                        help='the number of training steps to take')
    parser.add_argument('--batch-size', type=int, default=12,
                        help='the batch size')
    parser.add_argument('--log-every', type=int, default=10,
                        help='print loss after this many steps')
    parses = parser.parse_args(args=[])#添加args=[]
    return parses

if __name__ == '__main__':
    main(parse_args())

gdtop818

关注

2
点赞
踩
13

收藏

觉得还不错? 一键收藏
1
评论
[生成对抗网络GAN入门指南]（3）GAN的工程实践及基础代码

1、导入相关包，设置随机参数2、设置真实数据的分布、生成器的初始化分布3、设置线性运算：并用于生成器和判别器4、设置优化器，使用学习率衰减的梯度下降方法5、搭建GAN模型6、运行主程序完整代码请直接链接到最后面从上一章[生成对抗网络GAN入门指南]（2）理解生成对抗网络最后，我们需要做的优化是以下这个式子： ...
复制链接

扫一扫