生成对抗网络(GAN)生成MNIST数据

GAN是一种基于博弈论的生成式网络，它是2014年有 Ian Goodfellow提出，主要解决的是如何从训练样本中学习出新的样本。

其中GAN既不依赖标签来优化，也不是根据奖惩来调整参数，它是根据生成器和判别器之间的博弈来不断优化。

GAN的直观理解，可以想象一个名画伪造者想要伪造一副达芬奇的画作，开始时，伪造者的技术不精，但他将自己的一些赝品和达芬奇的作品混合在一起，请一个艺术商人对每一幅画的真实性进行评估，并向伪造者反馈，告诉他哪些看起来想真迹，哪些看起来不像真迹。
伪造者根据这些反馈，改进自己的赝品。随着时间的推移，伪造者的技术越来越高，艺术商人也越来越擅长找出赝品。最后，他们手上就由拥有了一些非常逼真的赝品

这就是GAN的基本原理，这里有两个角色，一个是伪造者，一个是技术鉴赏者，他们的目的都是打败对方

因此，GAN主要由两部分组成：
1）生成器网络：有一个潜在空间的随机向量作为输入，并将其解码为一幅图像题
2）判别器网络：以一张图像（可以是真的，可以是生成的）作为输入，并预测其来自于训练集还是生成器合成的

其结构图如下所示：

我们使用的pytorch框架，对判别器与生成器进行训练，代码如下：

import torch
import torchvision
import os
from torch import nn
from torchvision import datasets
from torch.utils.data import DataLoader
from torchvision import transforms
from torch import optim
from torchvision.utils import save_image

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

image_dir = "gan_images"
if not os.path.exists(image_dir):
    os.makedirs(image_dir)

#hyperparameter
image_size = 28 * 28
hidden_size = 400
latent_size = 100
batch_size = 100
epoch_num = 100

transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize(0.5,0.5)])
data = datasets.MNIST(root='data', train=True, download=True, transform=transform)
data_loader = DataLoader(dataset=data, shuffle=True, batch_size=batch_size)


D = nn.Sequential(
    nn.Linear(image_size, hidden_size),
    nn.ReLU(),
    nn.Linear(hidden_size, hidden_size),
    nn.ReLU(),
    nn.Linear(hidden_size,1),
    nn.Sigmoid()
)

G = nn.Sequential(

    nn.Linear(latent_size, hidden_size),
    nn.ReLU(),
    nn.Linear(hidden_size, hidden_size),
    nn.ReLU(),
    nn.Linear(hidden_size, image_size),
    nn.Tanh()
)

criteria = nn.BCELoss()
d_optimizer = optim.Adam(params=D.parameters(), lr=0.0001)
g_optimizer = optim.Adam(params=G.parameters(), lr=0.0001)

D = D.to(device)
G = G.to(device)

total_step = len(data_loader)
for epoch in range(epoch_num):
    for i, (images, _) in enumerate(data_loader, 0):

        images = images.reshape(batch_size, -1).to(device)

        #训练判别器
        real_labels = torch.ones(batch_size, 1).to(device)
        fake_labels = torch.zeros(batch_size, 1).to(device)

        outputs = D(images)
        d_loss_real = criteria(outputs, real_labels)

        z = torch.randn(batch_size, latent_size).to(device)
        outputs = D(G(z))
        d_loss_fake = criteria(outputs, fake_labels)

        d_loss = d_loss_real + d_loss_fake

        d_optimizer.zero_grad()
        d_loss.backward()
        d_optimizer.step()


        #训练生成器
        z = torch.randn(batch_size, latent_size).to(device)
        fake_images = G(z)
        outputs = D(fake_images)
        g_loss = criteria(outputs, real_labels)

        g_optimizer.zero_grad()
        g_loss.backward()
        g_optimizer.step()

        if i % 200 == 0:
            print("Epoch [{} / {}],Step [{} / {}] d_loss = {:.4f}, g_loss = {:.4f}".format(epoch + 1, epoch_num,i, total_step, d_loss.item(), g_loss.item()))

    fake_images = fake_images.reshape(batch_size, 1, 28, 28)
    save_image(fake_images, os.path.join(image_dir, "gan_images-{}.png".format(epoch + 1)))


torch.save(G.state_dict(), "Generator.pth")
torch.save(D.state_dict(), "Discriminator.pth")

生成的图像会放置在gan_images文件夹下，训练过程的输出如下所示：
Epoch [1 / 100], d_loss = 1.4005, g_loss = 0.6798
Epoch [1 / 100], d_loss = 0.0621, g_loss = 3.5801
Epoch [1 / 100], d_loss = 0.2698, g_loss = 3.5682
Epoch [2 / 100], d_loss = 0.1811, g_loss = 3.5154
Epoch [2 / 100], d_loss = 0.3187, g_loss = 3.1001
Epoch [2 / 100], d_loss = 0.3439, g_loss = 2.7816
Epoch [3 / 100], d_loss = 1.3116, g_loss = 1.6221
Epoch [3 / 100], d_loss = 0.0951, g_loss = 4.1097
Epoch [3 / 100], d_loss = 0.2743, g_loss = 3.0359
Epoch [4 / 100], d_loss = 0.3159, g_loss = 2.6536
Epoch [4 / 100], d_loss = 0.0741, g_loss = 3.8504
Epoch [4 / 100], d_loss = 0.2342, g_loss = 3.4751
Epoch [5 / 100], d_loss = 0.1974, g_loss = 3.5920
Epoch [5 / 100], d_loss = 0.2368, g_loss = 3.2966
Epoch [5 / 100], d_loss = 0.1879, g_loss = 3.7705
Epoch [6 / 100], d_loss = 0.3655, g_loss = 3.9668
Epoch [6 / 100], d_loss = 0.2644, g_loss = 3.5875
Epoch [6 / 100], d_loss = 0.1215, g_loss = 3.8600
Epoch [7 / 100], d_loss = 0.1748, g_loss = 3.5253
Epoch [7 / 100], d_loss = 0.1105, g_loss = 3.8256
Epoch [7 / 100], d_loss = 0.0883, g_loss = 4.8804
Epoch [8 / 100], d_loss = 0.0891, g_loss = 6.2839
Epoch [8 / 100], d_loss = 0.0507, g_loss = 4.4470
Epoch [8 / 100], d_loss = 0.2816, g_loss = 4.0533
Epoch [9 / 100], d_loss = 0.2605, g_loss = 5.1191
Epoch [9 / 100], d_loss = 0.2144, g_loss = 3.8165
Epoch [9 / 100], d_loss = 0.2019, g_loss = 4.5753
Epoch [10 / 100], d_loss = 0.3241, g_loss = 3.3218
Epoch [10 / 100], d_loss = 0.3779, g_loss = 4.1461
Epoch [10 / 100], d_loss = 0.2594, g_loss = 3.6480
Epoch [11 / 100], d_loss = 0.3161, g_loss = 3.1858
Epoch [11 / 100], d_loss = 0.2094, g_loss = 3.6961
Epoch [11 / 100], d_loss = 0.2777, g_loss = 5.4229
Epoch [12 / 100], d_loss = 0.1255, g_loss = 4.2613
Epoch [12 / 100], d_loss = 0.4155, g_loss = 3.6585
Epoch [12 / 100], d_loss = 0.1338, g_loss = 5.9054
Epoch [13 / 100], d_loss = 0.3724, g_loss = 4.3520
Epoch [13 / 100], d_loss = 0.2869, g_loss = 3.2829
Epoch [13 / 100], d_loss = 0.2133, g_loss = 4.1905
Epoch [14 / 100], d_loss = 0.2999, g_loss = 2.7607
Epoch [14 / 100], d_loss = 0.3578, g_loss = 4.3012
Epoch [14 / 100], d_loss = 0.1794, g_loss = 4.8473
Epoch [15 / 100], d_loss = 0.3180, g_loss = 3.7902
Epoch [15 / 100], d_loss = 0.1475, g_loss = 5.3947
Epoch [15 / 100], d_loss = 0.1403, g_loss = 3.6762
Epoch [16 / 100], d_loss = 0.2932, g_loss = 3.4348
Epoch [16 / 100], d_loss = 0.1673, g_loss = 4.8111
Epoch [16 / 100], d_loss = 0.2986, g_loss = 4.8031
Epoch [17 / 100], d_loss = 0.2396, g_loss = 4.7224
Epoch [17 / 100], d_loss = 0.2053, g_loss = 4.3120
Epoch [17 / 100], d_loss = 0.1204, g_loss = 4.5077
Epoch [18 / 100], d_loss = 0.2661, g_loss = 5.1059
Epoch [18 / 100], d_loss = 0.2851, g_loss = 4.5754
Epoch [18 / 100], d_loss = 0.2176, g_loss = 5.4797
Epoch [19 / 100], d_loss = 0.1762, g_loss = 5.0284
Epoch [19 / 100], d_loss = 0.1988, g_loss = 4.0182
Epoch [19 / 100], d_loss = 0.1350, g_loss = 5.8161
Epoch [20 / 100], d_loss = 0.2850, g_loss = 5.0353
Epoch [20 / 100], d_loss = 0.3551, g_loss = 2.9458
Epoch [20 / 100], d_loss = 0.1139, g_loss = 4.3131
Epoch [21 / 100], d_loss = 0.1293, g_loss = 5.3033
Epoch [21 / 100], d_loss = 0.0710, g_loss = 5.8201
Epoch [21 / 100], d_loss = 0.1737, g_loss = 4.3040
Epoch [22 / 100], d_loss = 0.1824, g_loss = 3.8893
Epoch [22 / 100], d_loss = 0.1078, g_loss = 4.6621
Epoch [22 / 100], d_loss = 0.1687, g_loss = 4.8674
Epoch [23 / 100], d_loss = 0.1675, g_loss = 5.4555
Epoch [23 / 100], d_loss = 0.2172, g_loss = 4.6650
Epoch [23 / 100], d_loss = 0.2184, g_loss = 4.7891
Epoch [24 / 100], d_loss = 0.1516, g_loss = 6.1614
Epoch [24 / 100], d_loss = 0.1665, g_loss = 4.0922
Epoch [24 / 100], d_loss = 0.0997, g_loss = 5.2850
Epoch [25 / 100], d_loss = 0.3317, g_loss = 4.0964
Epoch [25 / 100], d_loss = 0.3065, g_loss = 4.0313
Epoch [25 / 100], d_loss = 0.2348, g_loss = 3.9021
Epoch [26 / 100], d_loss = 0.3027, g_loss = 4.8271
Epoch [26 / 100], d_loss = 0.2931, g_loss = 3.4956
Epoch [26 / 100], d_loss = 0.3160, g_loss = 6.4097
Epoch [27 / 100], d_loss = 0.3170, g_loss = 4.9517
Epoch [27 / 100], d_loss = 0.3300, g_loss = 5.1625
Epoch [27 / 100], d_loss = 0.2237, g_loss = 3.8433
Epoch [28 / 100], d_loss = 0.2623, g_loss = 3.8917
Epoch [28 / 100], d_loss = 0.2885, g_loss = 6.3781
Epoch [28 / 100], d_loss = 0.1820, g_loss = 4.7686
Epoch [29 / 100], d_loss = 0.1731, g_loss = 5.4061
Epoch [29 / 100], d_loss = 0.1728, g_loss = 6.1285
Epoch [29 / 100], d_loss = 0.4072, g_loss = 4.6868
Epoch [30 / 100], d_loss = 0.1897, g_loss = 4.2557
Epoch [30 / 100], d_loss = 0.2685, g_loss = 3.9201
Epoch [30 / 100], d_loss = 0.1200, g_loss = 5.9766
Epoch [31 / 100], d_loss = 0.2807, g_loss = 4.2405
Epoch [31 / 100], d_loss = 0.3687, g_loss = 3.5048
Epoch [31 / 100], d_loss = 0.1658, g_loss = 4.2518
Epoch [32 / 100], d_loss = 0.2290, g_loss = 5.4087
Epoch [32 / 100], d_loss = 0.2649, g_loss = 4.3162
Epoch [32 / 100], d_loss = 0.2490, g_loss = 5.2993
Epoch [33 / 100], d_loss = 0.2252, g_loss = 4.2555
Epoch [33 / 100], d_loss = 0.2828, g_loss = 4.4996
Epoch [33 / 100], d_loss = 0.2613, g_loss = 3.8531
Epoch [34 / 100], d_loss = 0.2915, g_loss = 5.0766
Epoch [34 / 100], d_loss = 0.2113, g_loss = 4.2702
Epoch [34 / 100], d_loss = 0.3235, g_loss = 3.2965
Epoch [35 / 100], d_loss = 0.2930, g_loss = 3.7018
Epoch [35 / 100], d_loss = 0.4591, g_loss = 3.6850
Epoch [35 / 100], d_loss = 0.4780, g_loss = 3.0125
Epoch [36 / 100], d_loss = 0.2119, g_loss = 3.7448
Epoch [36 / 100], d_loss = 0.3707, g_loss = 4.0800
Epoch [36 / 100], d_loss = 0.3892, g_loss = 3.2267
Epoch [37 / 100], d_loss = 0.3581, g_loss = 3.3309
Epoch [37 / 100], d_loss = 0.3379, g_loss = 3.7177
Epoch [37 / 100], d_loss = 0.4734, g_loss = 2.6390
Epoch [38 / 100], d_loss = 0.2984, g_loss = 2.9607
Epoch [38 / 100], d_loss = 0.4436, g_loss = 3.1230
Epoch [38 / 100], d_loss = 0.2265, g_loss = 3.7585
Epoch [39 / 100], d_loss = 0.4792, g_loss = 3.1574
Epoch [39 / 100], d_loss = 0.3267, g_loss = 3.8206
Epoch [39 / 100], d_loss = 0.3506, g_loss = 3.2502
Epoch [40 / 100], d_loss = 0.3300, g_loss = 4.0757
Epoch [40 / 100], d_loss = 0.3422, g_loss = 3.9873
Epoch [40 / 100], d_loss = 0.3272, g_loss = 3.8506
Epoch [41 / 100], d_loss = 0.4380, g_loss = 3.2595
Epoch [41 / 100], d_loss = 0.3456, g_loss = 3.1325
Epoch [41 / 100], d_loss = 0.4930, g_loss = 2.5089
Epoch [42 / 100], d_loss = 0.4362, g_loss = 3.1982
Epoch [42 / 100], d_loss = 0.3139, g_loss = 3.2215
Epoch [42 / 100], d_loss = 0.3479, g_loss = 2.4273
Epoch [43 / 100], d_loss = 0.3033, g_loss = 3.5534
Epoch [43 / 100], d_loss = 0.3428, g_loss = 3.2007
Epoch [43 / 100], d_loss = 0.4883, g_loss = 3.9243
Epoch [44 / 100], d_loss = 0.4175, g_loss = 3.3569
Epoch [44 / 100], d_loss = 0.5574, g_loss = 3.3162
Epoch [44 / 100], d_loss = 0.5981, g_loss = 2.5613
Epoch [45 / 100], d_loss = 0.4480, g_loss = 3.5681
Epoch [45 / 100], d_loss = 0.6369, g_loss = 3.0833
Epoch [45 / 100], d_loss = 0.4301, g_loss = 3.7558
Epoch [46 / 100], d_loss = 0.5784, g_loss = 2.2023
Epoch [46 / 100], d_loss = 0.4192, g_loss = 2.9009
Epoch [46 / 100], d_loss = 0.4688, g_loss = 2.1012
Epoch [47 / 100], d_loss = 0.4303, g_loss = 2.4235
Epoch [47 / 100], d_loss = 0.5326, g_loss = 2.5725
Epoch [47 / 100], d_loss = 0.5327, g_loss = 2.7579
Epoch [48 / 100], d_loss = 0.2568, g_loss = 3.3153
Epoch [48 / 100], d_loss = 0.5148, g_loss = 2.9677
Epoch [48 / 100], d_loss = 0.4422, g_loss = 2.4869
Epoch [49 / 100], d_loss = 0.5628, g_loss = 2.7539
Epoch [49 / 100], d_loss = 0.4655, g_loss = 2.4238
Epoch [49 / 100], d_loss = 0.5316, g_loss = 3.2095
Epoch [50 / 100], d_loss = 0.4632, g_loss = 3.4854
Epoch [50 / 100], d_loss = 0.4265, g_loss = 2.5565
Epoch [50 / 100], d_loss = 0.3153, g_loss = 3.5203
Epoch [51 / 100], d_loss = 0.6447, g_loss = 2.3761
Epoch [51 / 100], d_loss = 0.6159, g_loss = 2.5303
Epoch [51 / 100], d_loss = 0.5911, g_loss = 2.6402
Epoch [52 / 100], d_loss = 0.6623, g_loss = 2.7971
Epoch [52 / 100], d_loss = 0.6024, g_loss = 2.1936
Epoch [52 / 100], d_loss = 0.7278, g_loss = 2.6819
Epoch [53 / 100], d_loss = 0.5315, g_loss = 2.4350
Epoch [53 / 100], d_loss = 0.6086, g_loss = 2.1015
Epoch [53 / 100], d_loss = 0.6430, g_loss = 1.9207
Epoch [54 / 100], d_loss = 0.6781, g_loss = 2.5795
Epoch [54 / 100], d_loss = 0.5939, g_loss = 2.1577
Epoch [54 / 100], d_loss = 0.6015, g_loss = 2.1501
Epoch [55 / 100], d_loss = 0.6770, g_loss = 2.2563
Epoch [55 / 100], d_loss = 0.3797, g_loss = 2.9337
Epoch [55 / 100], d_loss = 0.6671, g_loss = 2.2520
Epoch [56 / 100], d_loss = 0.4809, g_loss = 1.9355
Epoch [56 / 100], d_loss = 0.6161, g_loss = 1.8455
Epoch [56 / 100], d_loss = 0.4937, g_loss = 2.6282
Epoch [57 / 100], d_loss = 0.6174, g_loss = 1.8371
Epoch [57 / 100], d_loss = 0.6436, g_loss = 2.5613
Epoch [57 / 100], d_loss = 0.7414, g_loss = 2.4130
Epoch [58 / 100], d_loss = 0.5596, g_loss = 2.3446
Epoch [58 / 100], d_loss = 0.4977, g_loss = 2.6491
Epoch [58 / 100], d_loss = 0.3481, g_loss = 2.7025
Epoch [59 / 100], d_loss = 0.6528, g_loss = 2.1182
Epoch [59 / 100], d_loss = 0.5975, g_loss = 2.1660
Epoch [59 / 100], d_loss = 0.4634, g_loss = 2.7633
Epoch [60 / 100], d_loss = 0.6411, g_loss = 2.2056
Epoch [60 / 100], d_loss = 0.7455, g_loss = 2.1277
Epoch [60 / 100], d_loss = 0.5846, g_loss = 2.3214
Epoch [61 / 100], d_loss = 0.4130, g_loss = 2.6413
Epoch [61 / 100], d_loss = 0.5043, g_loss = 2.7461
Epoch [61 / 100], d_loss = 0.5027, g_loss = 2.7873
Epoch [62 / 100], d_loss = 0.5225, g_loss = 2.8119
Epoch [62 / 100], d_loss = 0.5937, g_loss = 2.2405
Epoch [62 / 100], d_loss = 0.6624, g_loss = 2.0931
Epoch [63 / 100], d_loss = 0.5260, g_loss = 2.0877
Epoch [63 / 100], d_loss = 0.4278, g_loss = 2.4840
Epoch [63 / 100], d_loss = 0.7284, g_loss = 1.8716
Epoch [64 / 100], d_loss = 0.4951, g_loss = 1.9208
Epoch [64 / 100], d_loss = 0.5356, g_loss = 1.8108
Epoch [64 / 100], d_loss = 0.5486, g_loss = 2.5334
Epoch [65 / 100], d_loss = 0.6209, g_loss = 2.4244
Epoch [65 / 100], d_loss = 0.5548, g_loss = 2.1217
Epoch [65 / 100], d_loss = 0.7993, g_loss = 1.9576
Epoch [66 / 100], d_loss = 0.6239, g_loss = 2.3424
Epoch [66 / 100], d_loss = 0.7308, g_loss = 1.9419
Epoch [66 / 100], d_loss = 0.4720, g_loss = 2.6218
Epoch [67 / 100], d_loss = 0.7112, g_loss = 2.3217
Epoch [67 / 100], d_loss = 0.6114, g_loss = 2.4066
Epoch [67 / 100], d_loss = 0.7292, g_loss = 1.8385
Epoch [68 / 100], d_loss = 0.6430, g_loss = 2.1762
Epoch [68 / 100], d_loss = 0.6845, g_loss = 2.2916
Epoch [68 / 100], d_loss = 0.7470, g_loss = 1.6900
Epoch [69 / 100], d_loss = 0.8242, g_loss = 1.5990
Epoch [69 / 100], d_loss = 0.6194, g_loss = 2.1995
Epoch [69 / 100], d_loss = 0.7138, g_loss = 2.2843
Epoch [70 / 100], d_loss = 0.7451, g_loss = 1.7273
Epoch [70 / 100], d_loss = 0.6697, g_loss = 2.6672
Epoch [70 / 100], d_loss = 0.5215, g_loss = 2.3656
Epoch [71 / 100], d_loss = 0.7273, g_loss = 1.7724
Epoch [71 / 100], d_loss = 0.7882, g_loss = 2.0707
Epoch [71 / 100], d_loss = 0.8792, g_loss = 2.1253
Epoch [72 / 100], d_loss = 0.6391, g_loss = 1.8659
Epoch [72 / 100], d_loss = 0.5978, g_loss = 2.3649
Epoch [72 / 100], d_loss = 0.4909, g_loss = 2.1047
Epoch [73 / 100], d_loss = 0.6429, g_loss = 2.7016
Epoch [73 / 100], d_loss = 0.6738, g_loss = 2.3777
Epoch [73 / 100], d_loss = 0.6250, g_loss = 1.8886
Epoch [74 / 100], d_loss = 0.7762, g_loss = 1.9123
Epoch [74 / 100], d_loss = 0.6819, g_loss = 1.9295
Epoch [74 / 100], d_loss = 0.7057, g_loss = 2.3590
Epoch [75 / 100], d_loss = 0.7284, g_loss = 1.9105
Epoch [75 / 100], d_loss = 0.6256, g_loss = 1.8463
Epoch [75 / 100], d_loss = 0.5224, g_loss = 1.5472
Epoch [76 / 100], d_loss = 0.6944, g_loss = 1.8389
Epoch [76 / 100], d_loss = 0.6051, g_loss = 2.2255
Epoch [76 / 100], d_loss = 0.7042, g_loss = 1.4677
Epoch [77 / 100], d_loss = 0.6009, g_loss = 1.6764
Epoch [77 / 100], d_loss = 0.5430, g_loss = 2.2582
Epoch [77 / 100], d_loss = 0.5698, g_loss = 1.9660
Epoch [78 / 100], d_loss = 0.5518, g_loss = 2.4821
Epoch [78 / 100], d_loss = 0.7566, g_loss = 2.3749
Epoch [78 / 100], d_loss = 0.5386, g_loss = 2.1131
Epoch [79 / 100], d_loss = 0.6013, g_loss = 2.0279
Epoch [79 / 100], d_loss = 0.7488, g_loss = 1.7669
Epoch [79 / 100], d_loss = 0.6356, g_loss = 1.4959
Epoch [80 / 100], d_loss = 0.7612, g_loss = 1.6782
Epoch [80 / 100], d_loss = 0.6220, g_loss = 2.1223
Epoch [80 / 100], d_loss = 0.9306, g_loss = 1.9309
Epoch [81 / 100], d_loss = 0.5956, g_loss = 2.0545
Epoch [81 / 100], d_loss = 0.6892, g_loss = 1.6276
Epoch [81 / 100], d_loss = 0.7528, g_loss = 1.8048
Epoch [82 / 100], d_loss = 0.6198, g_loss = 1.7642
Epoch [82 / 100], d_loss = 0.7554, g_loss = 1.8449
Epoch [82 / 100], d_loss = 0.5543, g_loss = 1.7551
Epoch [83 / 100], d_loss = 0.7482, g_loss = 1.7634
Epoch [83 / 100], d_loss = 0.5848, g_loss = 2.4618
Epoch [83 / 100], d_loss = 0.6526, g_loss = 1.8014
Epoch [84 / 100], d_loss = 0.7416, g_loss = 2.2330
Epoch [84 / 100], d_loss = 0.7117, g_loss = 2.1474
Epoch [84 / 100], d_loss = 0.6715, g_loss = 1.5732
Epoch [85 / 100], d_loss = 0.6500, g_loss = 2.1351
Epoch [85 / 100], d_loss = 0.6907, g_loss = 1.5845
Epoch [85 / 100], d_loss = 0.6423, g_loss = 1.9624
Epoch [86 / 100], d_loss = 0.6468, g_loss = 2.2248
Epoch [86 / 100], d_loss = 0.7964, g_loss = 1.7578
Epoch [86 / 100], d_loss = 0.8308, g_loss = 2.1643
Epoch [87 / 100], d_loss = 0.8049, g_loss = 1.9290
Epoch [87 / 100], d_loss = 0.7781, g_loss = 1.7725
Epoch [87 / 100], d_loss = 0.6872, g_loss = 1.8172
Epoch [88 / 100], d_loss = 0.7625, g_loss = 1.6974
Epoch [88 / 100], d_loss = 0.7031, g_loss = 2.0148
Epoch [88 / 100], d_loss = 0.8161, g_loss = 2.3086
Epoch [89 / 100], d_loss = 0.5941, g_loss = 1.6677
Epoch [89 / 100], d_loss = 0.6878, g_loss = 1.6104
Epoch [89 / 100], d_loss = 0.5485, g_loss = 2.0137
Epoch [90 / 100], d_loss = 0.8351, g_loss = 1.6406
Epoch [90 / 100], d_loss = 0.7346, g_loss = 2.1254
Epoch [90 / 100], d_loss = 0.7062, g_loss = 2.0978
Epoch [91 / 100], d_loss = 0.8811, g_loss = 2.2355
Epoch [91 / 100], d_loss = 0.6416, g_loss = 2.0354
Epoch [91 / 100], d_loss = 0.6701, g_loss = 2.2361
Epoch [92 / 100], d_loss = 0.8181, g_loss = 1.5149
Epoch [92 / 100], d_loss = 0.6995, g_loss = 1.7809
Epoch [92 / 100], d_loss = 0.9302, g_loss = 1.6532
Epoch [93 / 100], d_loss = 0.7537, g_loss = 2.2442
Epoch [93 / 100], d_loss = 0.7595, g_loss = 1.5303
Epoch [93 / 100], d_loss = 0.6609, g_loss = 2.1224
Epoch [94 / 100], d_loss = 0.7008, g_loss = 1.6132
Epoch [94 / 100], d_loss = 0.8136, g_loss = 2.3829
Epoch [94 / 100], d_loss = 0.6874, g_loss = 1.7750
Epoch [95 / 100], d_loss = 0.7074, g_loss = 1.3372
Epoch [95 / 100], d_loss = 0.6983, g_loss = 1.7831
Epoch [95 / 100], d_loss = 0.6664, g_loss = 2.4457
Epoch [96 / 100], d_loss = 0.6281, g_loss = 2.2233
Epoch [96 / 100], d_loss = 0.6056, g_loss = 1.6816
Epoch [96 / 100], d_loss = 0.6814, g_loss = 1.8850
Epoch [97 / 100], d_loss = 0.6050, g_loss = 1.9024
Epoch [97 / 100], d_loss = 0.7528, g_loss = 1.6076
Epoch [97 / 100], d_loss = 0.6339, g_loss = 2.4748
Epoch [98 / 100], d_loss = 0.6732, g_loss = 2.0769
Epoch [98 / 100], d_loss = 0.6004, g_loss = 2.0239
Epoch [98 / 100], d_loss = 0.8085, g_loss = 1.9665
Epoch [99 / 100], d_loss = 0.7437, g_loss = 1.9152
Epoch [99 / 100], d_loss = 0.6655, g_loss = 1.8907
Epoch [99 / 100], d_loss = 0.6616, g_loss = 1.7388
Epoch [100 / 100], d_loss = 0.8149, g_loss = 1.6021
Epoch [100 / 100], d_loss = 0.8716, g_loss = 1.8420
Epoch [100 / 100], d_loss = 0.8323, g_loss = 1.6049

在迭代了100个Epoch后，生成的图像如下图所示：

我们输出一张真实的图像来对比一下：

可以看到生成的图像还是会有较多的噪声，但是可以看到里面的数字了

在完成了100个Epoch之后，我们使用torch.save()函数将网络保存了下来，后面可以直接使用该网络，
我们加载进生成器的参数，并给它一个随机变量，看它生成的结果是什么，代码如下所示：

from torch import nn
from torchvision.utils import  save_image
import torch
import os

image_size = 28 * 28
hidden_size = 400
latent_size = 100

image_dir = "fake_images"
if not os.path.exists(image_dir):
    os.makedirs(image_dir)

G = nn.Sequential(

    nn.Linear(latent_size, hidden_size),
    nn.ReLU(),
    nn.Linear(hidden_size, hidden_size),
    nn.ReLU(),
    nn.Linear(hidden_size, image_size),
    nn.Tanh()
)

G.load_state_dict(torch.load("Generator.pth"))
z = torch.randn(1, latent_size)
fake_image = G(z)

fake_image = fake_image.reshape(1, 1, 28,28)
save_image(fake_image, os.path.join(image_dir, "fake_image.png"))

这里我们的生成器的输入只是一个隐变量，所以它只会生成一张图像，生成后保存在fake_images的文件夹下，生成的图像如下图所示：

可以看到在我们完成了生成其的训练之后，只要给它一个满足分布的随机变量，就可以生成一张我们想要的图像，是不是感觉非常的神奇。但是它有一个比较大的缺点就是我们自己无法控制生成的图像是什么。以MNIST数据集为例，当我们给它一个随机变量的时候，它生成的结果是随机的，也就是我们无法控制生成的数据是多少，如果我们想要控制生成的数字，可以使用GAN的变体，CGAN来生成图像)

当然这只是最基本的一个GAN模型，后面还有大量的GAN模型的变体来提升GAN的性能

【Python】一文详细介绍 py格式文件高斯小哥 Python基础【高质量合集】python 新手入门学习
【Python】一文详细介绍py格式文件个人主页：高斯小哥高质量专栏：Matplotlib之旅：零基础精通数据可视化、Python基础【高质量合集】、PyTorch零基础入门教程希望得到您的订阅和支持~创作高质量博文(平均质量分92+)，分享更多关于深度学习、PyTorch、Python领域的优质内容！（希望得到您的关注~）文章目录一、py格式文件简介二、如何创建和编辑py格式文件三、如何运行py
python抓包与解包_Python—网络抓包与解包（pcap、dpkt） weixin_39691055 python抓包与解包
pcap安装[root@localhost~]#pipinstallpypcap抓包与解包#-*-coding:utf-8-*-importpcap,dpktimportre,threading,requests__black_ip=['103.224.249.123','203.66.1.212']#抓包：param1eth_name网卡名，如：eth0,eth3。param2p_type日志捕
华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++）华为OD题库华为od 链表 java
须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
python 推导式(派生、衍生) sanduo112 人工智能 python windows 开发语言
python推导式一、推导式(派生、衍生)1.Python推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。2.列表(list)推导式3.字典(dict)推导式4.集合(set)推导式5.元组(tuple)推导式二、代码概述一、推导式(派生、衍生)1.Python推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。Python支持各种数
数据挖掘|数据预处理|基于Python的数据标准化方法皖山文武数据挖掘数据建模与分析 python 数据挖掘开发语言
基于Python的数据标准化方法1.z-score方法2.极差标准化方法3.最大绝对值标准化方法在数据分析之前，通常需要先将数据标准化（Standardization），利用标准化后的数据进行数据分析，以避免属性之间不同度量和取值范围差异造成数据对分析结果的影响。1.z-score方法Z-score方法是基于原始数据的均值和标准差来进行数据标准化的，处理后的数据均值为0，方差为1，符合标准正态分布
CSV指南：Python程序获取大型CSV文件行数孤独打铁匠Julian 笔记经验分享 python
本指南提供了几种使用Python来获取大型CSV文件行数的方法，并解释了每种方法的适用场景。方法1:使用csv.reader处理复杂CSV文件当你的CSV文件中包含多行字段（即某些字段的值中包含换行符）时，使用csv.reader是一个可靠的选择，因为它能够正确处理这些复杂情况。这个方法适用于大多数大小的CSV文件，但是对于非常大的文件，读取整个文件可能会占用较多的时间和内存。对于极大的文件，考虑
谷歌浏览器驱动Chromedriver（114-120版本）文件以及驱动下载教程 pigerr杨 Python python chrome drivers
ChromeDriver官方网站GitHub||GoogleChromeLabs/chrome-for-testingChromeDriver113-125_JSONChromeforTestingavailability123-125zip白月黑羽Python基础|进阶|Qt图形界面|Django|自动化测试|性能测试|JS语言|JS前端|原理与安装
大创项目推荐深度学习 opencv python 公式识别(图像识别机器视觉) laafeer python
文章目录0前言1课题说明2效果展示3具体实现4关键代码实现5算法综合效果6最后0前言优质竞赛项目系列，今天要分享的是基于深度学习的数学公式识别算法实现该项目较为新颖，适合作为竞赛课题方向，学长非常推荐！学长这里给一个题目综合评分(每项满分5分)难度系数：3分工作量：4分创新点：4分更多资料,项目分享：https://gitee.com/dancheng-senior/postgraduate1课题
ES-LTR粗排模块 poins jenkins 运维
ES-LTR粗排模块官方资源：https://github.com/HeiBoWang/elasticsearch-learning-to-rankElasticsearch学习排名插件使用机器学习提高搜索相关性排名。它为维基媒体基金会和Snagajob等地方的搜索提供了动力！这个插件有什么功能此插件：允许您在Elasticsearch中存储特征（Elasticsearch查询模板）记录特征得分（
python转码 Desamond python 开发语言
转码在许多场景中都有应用，以下是一些常见的场景：网页开发：当用户在网页上输入文本时，可能需要将特殊字符（如空格、引号、特殊符号等）进行转码，以防止这些字符对URL或HTML代码产生干扰。文件名处理：在处理文件名时，可能需要将特殊字符进行转码，以避免文件名被错误地解析或显示。数据传输：在数据传输过程中，为了确保数据的完整性和正确性，可能需要将数据中的特殊字符进行转码。数据存储：在数据库或数据存储中，
排序算法太多？常用排序都在这了，一篇文章总结和实现所有面试会考的排序算法（基于Python实现）宇宙之一粟不归路之Python #IT面试题收集与总结数据结构与算法算法数据结构排序算法 python java
文章目录排序算法1.常见的排序算法1.1选择排序1.1.1思想1.1.2实现**1.1.3选择排序分析**1.2冒泡排序**1.2.1思想****1.2.2实现****1.2.3冒泡排序分析**1.3插入排序**1.3.1思想****1.3.2实现****1.3.3插入排序分析**1.4归并排序☆☆★**1.4.1思想****1.4.2实现****1.4.3归并排序分析**1.5快速排序☆★★**
27.Python从入门到精通—Python异常处理抛出异常用户自定义异常定义清理行为预定义的清理行为以山河作礼。 #Python基础入门—详解版 python java 服务器
27.从入门到精通：Python异常处理抛出异常用户自定义异常定义清理行为预定义的清理行为异常处理抛出异常用户自定义异常定义清理行为预定义的清理行为异常处理在Python中，异常处理是一种处理程序在执行期间可能遇到的错误的方法。当Python解释器遇到错误时，它会引发异常。异常是一种Python对象，它包含有关错误的信息，例如错误类型和错误位置。为了处理异常，您可以使用try-except语句。在
python清华大学出版社答案_Python机器学习及实践 weixin_39805119 python清华大学出版社答案
第1章机器学习的基础知识1.1何谓机器学习1.1.1传感器和海量数据1.1.2机器学习的重要性1.1.3机器学习的表现1.1.4机器学习的主要任务1.1.5选择合适的算法1.1.6机器学习程序的步骤1.2综合分类1.3推荐系统和深度学习1.3.1推荐系统1.3.2深度学习1.4何为Python1.4.1使用Python软件的由来1.4.2为什么使用Python1.4.3Python设计定位1.4.
Python | Redis工具类 -拟墨画扇- Python redis 数据库缓存 python
一、需求自动连接Redis数据库，通过连接池处理数据对输出结果进行Log打印并保存到文件二、代码Utils.redisUtils.py#!/usr/bin/envpython#-*-coding:utf-8-*-importredisfromUtils.loggerimportlog"""Redis数据格式(1)字符串|存储形式:key-value:str-存储二进制数据:可以存储任意类型的数据，
Python dict字符串转json对象，小数精度丢失问题朝如青丝暮成雪 json python
一前言JSON(JavaScriptObjectNotation)是一种轻量级的数据交换格式，dict是Python的一种数据格式。本篇介绍一个float数据转换时精度丢失的案例。二问题描述importjsontest_str1='{"π":3.1415926535897932384626433832795028841971}'test_str2='{"value":10.00000}'print
UNDERSTANDING HTML WITH LARGE LANGUAGE MODELS liferecords LLM 语言模型人工智能自然语言处理
UNDERSTANDINGHTMLWITHLARGELANGUAGEMODELS相关链接：arXiv关键字：大型语言模型、HTML理解、Web自动化、自然语言处理、机器学习摘要大型语言模型（LLMs）在各种自然语言任务上表现出色。然而，它们在HTML理解方面的能力——即解析网页的原始HTML，对于自动化基于Web的任务、爬取和浏览器辅助检索等应用——尚未被充分探索。我们为HTML理解模型（经过微调
Python+Requests模拟发送GET请求爱学习的执念自动化测试软件测试技术分享 python 开发语言
模拟发送GET请求前置条件：导入requests库一、发送不带参数的get请求代码如下：以百度首页为例importrequests#发送get请求response=requests.get(url="http://www.baidu.com")print(response.content.decode("utf-8"))#以utf-8的编码输出内容二、发送带参数的get请求发送带参数的get请求有
Python极速入门：五分钟开启实战之旅！知白守黑V Python 编程语言系统运维 python 编程语言 python开发 python学习 python入门 python数据分析
1.Python基础语法和结构：了解Python的基本语法，包括变量、数据类型、运算符、注释等。控制流：掌握条件语句（if-elif-else）、循环（for和while）及其控制（break和continue）。函数：学习如何定义和使用函数，包括参数传递、返回值、作用域和闭包。模块和包：理解如何导入和使用模块，以及如何创建和使用自己的包。2.数据处理列表、元组和集合：学习这些序列类型的操作和方法
Python Flask 使用数据库安果移不动 python flask 开发语言
pipinstallflask_sqlalchemy官方文档：Flask-SQLAlchemy—Flask-SQLAlchemyDocumentation(3.1.x)为了不报错也需要导入另外两个库#pipinstallflask_sqlalchemy#pipinstallmysqlclient完整代码importosfromflaskimportFlaskfromflask_sqlalchemy
深度学习项目-基于深度学习的股票价格预测研究雅致教育计算机毕业设计深度学习人工智能
概要随着经济的发展，中国股票市场的规模持续扩大，早已成为金融投资的重要部分，掌握股票市场的变化规律无论是对监管者还是投资者都具有极其重要的意义。正因如此，人们不断探索着股票市场的变化规律，其中使用深度学习预测股价是当前国内国际研究与应用的热点。本文首先从有效市场假说和分形市场假说两个角度讨论了中国股票市场的有效性，说明股票市场具有复杂的非线性特征。其次，结合股票市场特征对比了当前的预测方法
PaperWeekly sapienst Papers PaperwithCode General ML
1.Python软件包解决DL在未见过的数据分布下性能差的问题：（1）神经网络和损失分离的模块化设计（2）强大便捷的基准测试能力（3）易于使用但难以修改（4）github:https://github.com/marrlab/domainlabTrainer和Models之间是什么关系Trainer和Models是DomainLab中的两个核心概念。Trainer是一个用于指导数据流向模型并计算S
使用Python读取Excel文件并计算平均分嘻嘻爱编码 Python从入门到放弃 python excel 开发语言
在这篇博客中，我们将探讨如何使用Python的pandas库来读取Excel文件，并计算其中数据的平均分。pandas是一个强大的数据分析工具，它允许我们以简单直观的方式处理表格数据。安装必要的库在开始之前，确保你的环境中安装了pandas和openpyxl库。可以使用以下命令进行安装：pipinstallpandasopenpyxl读取Excel文件首先，我们需要读取Excel文件。假设我们有一
python项目练习——7.网站访问日志分析器 F—— python项目练习 python 信息可视化数据分析数据挖掘开发语言学习
项目功能分析：这个项目可以读取网站的访问日志文件，统计访问量、独立访客数、访问来源等信息，并以图表或表格的形式展示出来。这个项目涉及到文件操作、数据处理、数据可视化等方面的技术。示例代码：importrefromcollectionsimportCounterimportmatplotlib.pyplotaspltdefparse_log_file(log_file):#读取日志文件内容witho
python的while双重循环九九乘法表 Jinm_R python 开发语言
a=1whilea<=9:b=1#乘数每次需要从1开始whileb<=a:print(f"{a}*{b}={a*b}\t",end='')#\t为制表符使乘法表整齐end=''代表用空格代替换行b+=1a+=1print()#乘数每加一换行
ChatGPT技巧大揭秘：AI写代码新境界 2401_83550420 chatgpt4.0 chatgpt chatgpt 人工智能 AI写作
ChatGPT无限次数:点击直达ChatGPT技巧大揭秘：AI写代码新境界随着人工智能技术的不断进步，开发人员现在有了更多有趣的工具来提高他们的工作效率。其中，ChatGPT作为一种基于深度学习的自然语言处理模型，已经成为许多开发者的新宠。在本文中，我们将揭秘使用ChatGPT来帮助编写代码的技巧，探索AI在编程领域的新境界。ChatGPT简介ChatGPT是一种基于大型神经网络的对话生成模型，它
AI大模型学习：开启智能时代的新篇章游向大厂的咸鱼人工智能学习
随着人工智能技术的不断发展，AI大模型已经成为当今领先的技术之一，引领着智能时代的发展。这些大型神经网络模型，如OpenAI的GPT系列、Google的BERT等，在自然语言处理、图像识别、智能推荐等领域展现出了令人瞩目的能力。然而，这些模型的背后是一系列复杂的学习过程，深度学习技术的不断演进推动了AI大模型学习的发展。首先，AI大模型学习的基础是深度学习技术。深度学习是一种模仿人类大脑结构的机器
【Python】成功解决ModuleNotFoundError: No module named ‘torchinfo‘ 高斯小哥 BUG解决方案合集 python pytorch 新手入门学习 debug
【Python】成功解决ModuleNotFoundError:Nomodulenamed‘torchinfo’个人主页：高斯小哥高质量专栏：Matplotlib之旅：零基础精通数据可视化、Python基础【高质量合集】、PyTorch零基础入门教程希望得到您的订阅和支持~创作高质量博文(平均质量分92+)，分享更多关于深度学习、PyTorch、Python领域的优质内容！（希望得到您的关注~）文
OpenCV（一个C++人工智能领域重要开源基础库）简介愚梦者 OpenCV 人工智能人工智能 opencv c++图像处理计算机视觉开源
返回：OpenCV系列文章目录（持续更新中......）上一篇：OpenCV4.9.0配置选项参考下一篇：OpenCV4.9.0开源计算机视觉库安装概述引言：OpenCV（全称OpenSourceComputerVisionLibrary）是一个基于开放源代码发行的跨平台计算机视觉库，可以用来进行图像处理、计算机视觉和机器学习等领域的开发。该库由英特尔公司于1999年开始开发，最初是为了加速处理器
Python自动化测试web常见框架汇总自动化测试薰儿软件测试技术分享 python 前端开发语言
1、前言目前，有非常多的Python框架，用来帮助你更轻松的创建web应用。这些框架把相应的模块组织起来，使得构建应用的时候可以更快捷，也不用去关注一些细节（例如socket和协议），所以需要的都在框架里了。接下来我们会介绍不同的选项。经过初期的不起眼，Python已经成为互联网最流行的服务端编程语言之一。根据W3Techs的统计，它被用于很多的大流量的站点很多的大流量的站点很多的大流量的站点，超
零基础机器学习(5)之线性回归模型的性能评估一只特立独行猪机器学习机器学习线性回归人工智能
文章目录线性回归模型的性能评估1.举例1-单一特征2.举例2-多特征线性回归模型的性能评估评估线性回归模型时，首先要建立评估的测试数据集（测试集不能与训练集相同），然后选择合适的评估方法，实现对线性回归模型的评估。回归任务中最常用的评估方法有均方误差、均方根误差和预测准确率（确定系数）。1.举例1-单一特征分别对两个模型进行评估，输入的测试集如表所示。面积/（m2）售价/（万元）面积/（m2）售价
windows下源码安装golang 616050468 golang安装 golang环境 windows
系统： 64位win7，开发环境：sublime text 2， go版本： 1.4.1 1. 安装前准备(gcc, gdb, git) golang在64位系
redis批量删除带空格的key bylijinnan redis
redis批量删除的通常做法： redis-cli keys "blacklist*" | xargs redis-cli del 上面的命令在key的前后没有空格时是可以的，但有空格就不行了： $redis-cli keys "blacklist*" 1) "blacklist:12: [email protected]
oracle正则表达式的用法 0624chenhong oracle 正则表达式
方括号表达示方括号表达式描述 [[:alnum:]] 字母和数字混合的字符 [[:alpha:]] 字母字符 [[:cntrl:]] 控制字符 [[:digit:]] 数字字符 [[:graph:]] 图像字符 [[:lower:]] 小写字母字符 [[:print:]] 打印字符 [[:punct：]] 标点符号字符 [[:space:]]
2048源码(核心算法有，缺少几个anctionbar，以后补上) 不懂事的小屁孩 2048
2048游戏基本上有四部分组成， 1：主activity，包含游戏块的16个方格，上面统计分数的模块 2：底下的gridview，监听上下左右的滑动，进行事件处理， 3：每一个卡片，里面的内容很简单，只有一个text，记录显示的数字 4：Actionbar，是游戏用重新开始，设置等功能(这个在底下可以下载的代码里面还没有实现) 写代码的流程 1：设计游戏的布局，基本是两块，上面是分
jquery内部链式调用机理换个号韩国红果果 JavaScript jquery
只需要在调用该对象合适(比如下列的setStyles)的方法后让该方法返回该对象（通过this 因为一旦一个函数称为一个对象方法的话那么在这个方法内部this（结合下面的setStyles）指向这个对象） function create(type){ var element=document.createElement(type); //this=element;
你订酒店时的每一次点击背后都是NoSQL和云计算蓝儿唯美 NoSQL
全球最大的在线旅游公司Expedia旗下的酒店预订公司，它运营着89个网站，跨越68个国家，三年前开始实验公有云，以求让客户在预订网站上查询假期酒店时得到更快的信息获取体验。云端本身是用于驱动网站的部分小功能的，如搜索框的自动推荐功能，还能保证处理Hotels.com服务的季节性需求高峰整体储能。 Hotels.com的首席技术官Thierry Bedos上个月在伦敦参加“2015 Clou
java笔记1 a-john java
1，面向对象程序设计（Object-oriented Propramming，OOP）：java就是一种面向对象程序设计。 2，对象：我们将问题空间中的元素及其在解空间中的表示称为“对象”。简单来说，对象是某个类型的实例。比如狗是一个类型，哈士奇可以是狗的一个实例，也就是对象。 3，面向对象程序设计方式的特性： 3.1 万物皆为对象。
C语言 sizeof和strlen之间的那些事 C/C++软件开发求职面试题必备考点（一） aijuans C/C++求职面试必备考点
找工作在即，以后决定每天至少写一个知识点，主要是记录，逼迫自己动手、总结加深印象。当然如果能有一言半语让他人收益，后学幸运之至也。如有错误，还希望大家帮忙指出来。感激不尽。后学保证每个写出来的结果都是自己在电脑上亲自跑过的，咱人笨，以前学的也半吊子。很多时候只能靠运行出来的结果再反过来
程序员写代码时就不要管需求了吗？ asia007 程序员不能一味跟需求走
编程也有2年了，刚开始不懂的什么都跟需求走，需求是怎样就用代码实现就行，也不管这个需求是否合理，是否为较好的用户体验。当然刚开始编程都会这样，但是如果有了2年以上的工作经验的程序员只知道一味写代码，而不在写的过程中思考一下这个需求是否合理，那么，我想这个程序员就只能一辈写敲敲代码了。我的技术不是很好，但是就不代
Activity的四种启动模式百合不是茶 android 栈模式启动 Activity的标准模式启动栈顶模式启动单例模式启动
android界面的操作就是很多个activity之间的切换,启动模式决定启动的activity的生命周期 ; 启动模式xml中配置 <activity android:name=".MainActivity" android:launchMode="standard&quo
Spring中@Autowired标签与@Resource标签的区别 bijian1013 java spring @Resource @Autowired @Qualifier
Spring不但支持自己定义的@Autowired注解，还支持由JSR-250规范定义的几个注解，如：@Resource、 @PostConstruct及@PreDestroy。 1. @Autowired @Autowired是Spring 提供的，需导入 Package:org.springframewo
Changes Between SOAP 1.1 and SOAP 1.2 sunjing Changes Enable SOAP 1.1 SOAP 1.2
JAX-WS SOAP Version 1.2 Part 0: Primer (Second Edition) SOAP Version 1.2 Part 1: Messaging Framework (Second Edition) SOAP Version 1.2 Part 2: Adjuncts (Second Edition) Which style of WSDL
【Hadoop二】Hadoop常用命令 bit1129 hadoop
以Hadoop运行Hadoop自带的wordcount为例， hadoop脚本位于/home/hadoop/hadoop-2.5.2/bin/hadoop，需要说明的是，这些命令的使用必须在Hadoop已经运行的情况下才能执行 Hadoop HDFS相关命令 hadoop fs -ls 列出HDFS文件系统的第一级文件和第一级
java异常处理（初级）白糖_ java DAO spring 虚拟机 Ajax
从学习到现在从事java开发一年多了，个人觉得对java只了解皮毛，很多东西都是用到再去慢慢学习，编程真的是一项艺术，要完成一段好的代码，需要懂得很多。最近项目经理让我负责一个组件开发，框架都由自己搭建，最让我头疼的是异常处理，我看了一些网上的源码，发现他们对异常的处理不是很重视，研究了很久都没有找到很好的解决方案。后来有幸看到一个200W美元的项目部分源码，通过他们对异常处理的解决方案，我终
记录整理-工作问题 braveCS 工作
1）那位同学还是CSV文件默认Excel打开看不到全部结果。以为是没写进去。同学甲说文件应该不分大小。后来log一下原来是有写进去。只是Excel有行数限制。那位同学进步好快啊。 2）今天同学说写文件的时候提示jvm的内存溢出。我马上反应说那就改一下jvm的内存大小。同学说改用分批处理了。果然想问题还是有局限性。改jvm内存大小只能暂时地解决问题，以后要是写更大的文件还是得改内存。想问题要长远啊
org.apache.tools.zip实现文件的压缩和解压，支持中文 bylijinnan apache
刚开始用java.util.Zip，发现不支持中文（网上有修改的方法，但比较麻烦）后改用org.apache.tools.zip org.apache.tools.zip的使用网上有更简单的例子下面的程序根据实际需求，实现了压缩指定目录下指定文件的方法 import java.io.BufferedReader; import java.io.BufferedWrit
读书笔记-4 chengxuyuancsdn 读书笔记
1、JSTL 核心标签库标签 2、避免SQL注入 3、字符串逆转方法 4、字符串比较compareTo 5、字符串替换replace 6、分拆字符串 1、JSTL 核心标签库标签共有13个，学习资料：http://www.cnblogs.com/lihuiyy/archive/2012/02/24/2366806.html 功能上分为4类： (1)表达式控制标签：out
[物理与电子]半导体教材的一个小问题 comsci 问题
各种模拟电子和数字电子教材中都有这个词汇-空穴书中对这个词汇的解释是; 当电子脱离共价键的束缚成为自由电子之后,共价键中就留下一个空位,这个空位叫做空穴我现在回过头翻大学时候的教材,觉得这个
Flashback Database --闪回数据库 daizj oracle 闪回数据库
Flashback 技术是以Undo segment中的内容为基础的，因此受限于UNDO_RETENTON参数。要使用flashback 的特性，必须启用自动撤销管理表空间。在Oracle 10g中， Flash back家族分为以下成员： Flashback Database， Flashback Drop，Flashback Query(分Flashback Query,Flashbac
简单排序:插入排序 dieslrae 插入排序
public void insertSort(int[] array){ int temp; for(int i=1;i<array.length;i++){ temp = array[i]; for(int k=i-1;k>=0;k--)
C语言学习六指针小示例、一维数组名含义，定义一个函数输出数组的内容 dcj3sjt126com c
# include <stdio.h> int main(void) { int * p; //等价于 int *p 也等价于 int* p; int i = 5; char ch = 'A'; //p = 5; //error //p = &ch; //error //p = ch; //error p = &i; //
centos下php redis扩展的安装配置3种方法 dcj3sjt126com redis
方法一 1.下载php redis扩展包代码如下复制代码 #wget http://redis.googlecode.com/files/redis-2.4.4.tar.gz 2 tar -zxvf 解压压缩包，cd /扩展包（进入扩展包然后运行phpize 一下是我环境中phpize的目录，/usr/local/php/bin/phpize (一定要
线程池(Executors) shuizhaosi888 线程池
在java类库中，任务执行的主要抽象不是Thread，而是Executor，将任务的提交过程和执行过程解耦 public interface Executor { void execute(Runnable command); } public class RunMain implements Executor{ @Override pub
openstack 快速安装笔记 haoningabc openstack
前提是要配置好yum源版本icehouse，操作系统redhat6.5 最简化安装，不要cinder和swift 三个节点 172 control节点keystone glance horizon 173 compute节点nova 173 network节点neutron control /etc/sysctl.conf net.ipv4.ip_forward =
从c面向对象的实现理解c++的对象（二） jimmee C++面向对象虚函数
1. 类就可以看作一个struct，类的方法，可以理解为通过函数指针的方式实现的，类对象分配内存时，只分配成员变量的，函数指针并不需要分配额外的内存保存地址。 2. c++中类的构造函数，就是进行内存分配(malloc)，调用构造函数 3. c++中类的析构函数，就时回收内存(free) 4. c++是基于栈和全局数据分配内存的，如果是一个方法内创建的对象，就直接在栈上分配内存了。专门在
如何让那个一个div可以拖动 lingfeng520240 html
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml
第10章高级事件（中） onestopweb 事件
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
计算两个经纬度之间的距离 roadrunners 计算纬度 LBS 经度距离
要解决这个问题的时候，到网上查了很多方案，最后计算出来的都与百度计算出来的有出入。下面这个公式计算出来的距离和百度计算出来的距离是一致的。 /** * * @param longitudeA * 经度A点 * @param latitudeA * 纬度A点 * @param longitudeB *
最具争议的10个Java话题 tomcat_oracle java
1、Java8已经到来。什么！？ Java8 支持lambda。哇哦，RIP Scala！　　随着Java8 的发布，出现很多关于新发布的Java8是否有潜力干掉Scala的争论，最终的结论是远远没有那么简单。Java8可能已经在Scala的lambda的包围中突围，但Java并非是函数式编程王位的真正觊觎者。　　2、Java 9 即将到来　　 Oracle早在8月份就发布
zoj 3826 Hierarchical Notation(模拟) 阿尔萨斯 rar
题目链接：zoj 3826 Hierarchical Notation 题目大意：给定一些结构体，结构体有value值和key值，Q次询问，输出每个key值对应的value值。解题思路：思路很简单，写个类词法的递归函数，每次将key值映射成一个hash值，用map映射每个key的value起始终止位置，预处理完了查询就很简单了。这题是最后10分钟出的，因为没有考虑value为{}的情

生成对抗网络(GAN)生成MNIST数据

你可能感兴趣的:(机器学习,python,计算机视觉,机器学习,深度学习)