我的电脑上的jupyter会输出一些不希望输出的东西，我用自己的电脑运行

# 定义超参数
image_size = 28 #图像尺寸大小
input_dim = 100 #输入给生成器的向量维度，维度越大可以增加生成器输出样本的多样性
num_channels = 1# 图像的通道数
num_features = 64 #生成器中间的卷积核数量
batch_size = 64 #批次大小

# 如果系统中存在着GPU，我们将用GPU来完成张量的计算
use_cuda = torch.cuda.is_available() #定义一个布尔型变量，标志当前的GPU是否可用

# 如果当前GPU可用，则将优先在GPU上进行张量计算
dtype = torch.cuda.FloatTensor if use_cuda else torch.FloatTensor
itype = torch.cuda.LongTensor if use_cuda else torch.LongTensor

# 加载MINIST数据，如果没有下载过，就会在当前路径下新建/data子目录，并把文件存放其中
# MNIST数据是属于torchvision包自带的数据，所以可以直接调用。
# 在调用自己的数据的时候，我们可以用torchvision.datasets.ImageFolder或者torch.utils.data.TensorDataset来加载
train_dataset = dsets.MNIST(root='./data',  #文件存放路径
                            train=True,   #提取训练集
                            transform=transforms.ToTensor(),  #将图像转化为Tensor，在加载数据的时候，就可以对图像做预处理
                            download=True) #当找不到文件的时候，自动下载

# 加载测试数据集
test_dataset = dsets.MNIST(root='./data', 
                           train=False, 
                           transform=transforms.ToTensor())

# 训练数据集的加载器，自动将数据分割成batch，顺序随机打乱
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, 
                                           batch_size=batch_size, 
                                           shuffle=True)

'''我们希望将测试数据分成两部分，一部分作为校验数据，一部分作为测试数据。
校验数据用于检测模型是否过拟合，并调整参数，测试数据检验整个模型的工作'''


# 首先，我们定义下标数组indices，它相当于对所有test_dataset中数据的编码
# 然后定义下标indices_val来表示校验集数据的那些下标，indices_test表示测试集的下标
indices = range(len(test_dataset))
indices_val = indices[:5000]
indices_test = indices[5000:]

# 根据这些下标，构造两个数据集的SubsetRandomSampler采样器，它会对下标进行采样
sampler_val = torch.utils.data.sampler.SubsetRandomSampler(indices_val)
sampler_test = torch.utils.data.sampler.SubsetRandomSampler(indices_test)

# 根据两个采样器来定义加载器，注意将sampler_val和sampler_test分别赋值给了validation_loader和test_loader
validation_loader = torch.utils.data.DataLoader(dataset =test_dataset,
                                                batch_size = batch_size,
                                                sampler = sampler_val
                                               )
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, 
                                          batch_size=batch_size, 
                                          sampler = sampler_test
                                         )

这段程序，三引号中的文字应该不输出，其他电脑的out也没有，而我的电脑会输出下面的结果

很诡异的是我换行之后，他把我换行当成“\n”符输出了

接下来就是pytorch部分的训练

#训练模型

print('Initialized!')

#定义生成器模型
net = ModelG()
net = net.cuda() if use_cuda else net

#目标函数采用最小均方误差
criterion = nn.MSELoss()
#定义优化器
optimizer = optim.SGD(net.parameters(), lr=0.0001, momentum=0.9)

# 随机选择生成0-9的数字，用于每个周期打印查看结果用
samples = np.random.choice(10, batch_size) 
samples = torch.from_numpy(samples).type(dtype)

#开始训练
step = 0 #计数经历了多少时间步
num_epochs = 100 #总的训练周期
record = []
for epoch in range(num_epochs):
    train_loss = []
    
    # 加载数据批次
    for batch_idx, (data, target) in enumerate(train_loader):
        # 注意数据中的data转化为了要预测的target，数据中的target则转化成了输入给网络的标签
        target, data = data.clone().detach().requires_grad_(True), target.clone().detach() #data为一批图像，target为一批标签
        # 将数据加载到GPU中
        if use_cuda:
            target, data = target.cuda(), data.cuda()
        #将输入的数字标签转化为生成器net能够接受的(batch_size, input_dim, 1, 1)维张量
        data = data.type(dtype)
        data = data.resize(data.size()[0], 1, 1, 1)
        data = data.expand(data.size()[0], input_dim, 1, 1)

        net.train() # 给网络模型做标记，标志说模型正在训练集上训练，
                    #这种区分主要是为了打开关闭net的training标志
        output = net(data) #神经网络完成一次前馈的计算过程，得到预测输出output
        loss = criterion(output, target) #将output与标签target比较，计算误差
        optimizer.zero_grad() #清空梯度
        loss.backward() #反向传播
        optimizer.step() #一步随机梯度下降算法
        step += 1
        # 记载损失函数值
        if use_cuda:
            loss = loss.cpu()
        train_loss.append(loss.data.numpy())
        
        
        if step % 100 == 0: #每间隔100个batch执行一次打印等操作    
            net.eval() # 给网络模型做标记，标志说模型在校验集上运行
            val_loss = [] #记录校验数据集准确率的容器
            
            '''开始在校验数据集上做循环，计算校验集上面的准确度'''
            idx = 0
            for (data, target) in validation_loader:
                target, data = data.clone().detach().requires_grad_(True), target.clone().detach()
                idx += 1
                if use_cuda:
                    target, data = target.cuda(), data.cuda()
                data = data.type(dtype)
                data = data.resize(data.size()[0], 1, 1, 1)
                data = data.expand(data.size()[0], input_dim, 1, 1)
                output = net(data) #完成一次前馈计算过程，得到目前训练得到的模型net在校验数据集上的表现
                loss = criterion(output, target) #将output与标签target比较，计算误差
                if use_cuda:
                    loss = loss.cpu()
                val_loss.append(loss.data.numpy())
                #打印误差等数值，其中正确率为本训练周期Epoch开始后到目前撮的正确率的平均值
            print('训练周期: {} [{}/{} ({:.0f}%)]\t训练数据Loss: {:.6f}\t校验数据Loss: {:.6f}'.format(
                epoch, batch_idx * batch_size, len(train_loader.dataset),
                100. * batch_idx / len(train_loader), np.mean(train_loss), np.mean(val_loss)))
            record.append([np.mean(train_loss), np.mean(val_loss)])
        
    
    # 产生一组图像保存到temp1文件夹下（需要事先建立好该文件夹），检测生成器当前的效果
    # 改变输入数字的尺寸，适应于生成器网络
    with torch.no_grad():
        samples.resize_(batch_size,1,1,1)
    samples = samples.data.expand(batch_size, input_dim, 1, 1)
    samples = samples.cuda() if use_cuda else samples #加载到GPU
    fake_u=net(samples) #用原始网络作为输入，得到伪造的图像数据
    fake_u = fake_u.cpu() if use_cuda else fake_uy
    img = make_show(fake_u) #将张量转化成可绘制的图像
    os.makedirs('temp1',exist_ok=True)
    vutil.save_image(img,'temp1/fake%s.png'% (epoch)) #保存生成的图像

这段代码，本应该输出

Initialized!
训练周期: 0 [6336/60000 (11%)]	训练数据Loss: 0.274138	校验数据Loss: 0.257729
训练周期: 0 [12736/60000 (21%)]	训练数据Loss: 0.257771	校验数据Loss: 0.229667
训练周期: 0 [19136/60000 (32%)]	训练数据Loss: 0.244582	校验数据Loss: 0.209952
训练周期: 0 [25536/60000 (43%)]	训练数据Loss: 0.233694	校验数据Loss: 0.194632
训练周期: 0 [31936/60000 (53%)]	训练数据Loss: 0.224443	校验数据Loss: 0.180734
训练周期: 0 [38336/60000 (64%)]	训练数据Loss: 0.216324	校验数据Loss: 0.170840
训练周期: 0 [44736/60000 (75%)]	训练数据Loss: 0.209207	校验数据Loss: 0.162397
训练周期: 0 [51136/60000 (85%)]	训练数据Loss: 0.202839	校验数据Loss: 0.153903
训练周期: 0 [57536/60000 (96%)]	训练数据Loss: 0.197156	校验数据Loss: 0.147288
训练周期: 1 [3904/60000 (7%)]	训练数据Loss: 0.144534	校验数据Loss: 0.142331
训练周期: 1 [10304/60000 (17%)]	训练数据Loss: 0.141801	校验数据Loss: 0.137103
训练周期: 1 [16704/60000 (28%)]	训练数据Loss: 0.139483	校验数据Loss: 0.132225
训练周期: 1 [23104/60000 (38%)]	训练数据Loss: 0.137321	校验数据Loss: 0.129141
训练周期: 1 [29504/60000 (49%)]	训练数据Loss: 0.135231	校验数据Loss: 0.124055
训练周期: 1 [35904/60000 (60%)]	训练数据Loss: 0.133316	校验数据Loss: 0.121777
训练周期: 1 [42304/60000 (70%)]	训练数据Loss: 0.131552	校验数据Loss: 0.118685
训练周期: 1 [48704/60000 (81%)]	训练数据Loss: 0.129862	校验数据Loss: 0.116584
训练周期: 1 [55104/60000 (92%)]	训练数据Loss: 0.128287	校验数据Loss: 0.114115
训练周期: 2 [1472/60000 (2%)]	训练数据Loss: 0.113260	校验数据Loss: 0.111495
训练周期: 2 [7872/60000 (13%)]	训练数据Loss: 0.112303	校验数据Loss: 0.109011
训练周期: 2 [14272/60000 (24%)]	训练数据Loss: 0.111242	校验数据Loss: 0.107972
训练周期: 2 [20672/60000 (34%)]	训练数据Loss: 0.110386	校验数据Loss: 0.105655
训练周期: 2 [27072/60000 (45%)]	训练数据Loss: 0.109434	校验数据Loss: 0.104143
训练周期: 2 [33472/60000 (56%)]	训练数据Loss: 0.108610	校验数据Loss: 0.102904
训练周期: 2 [39872/60000 (66%)]	训练数据Loss: 0.107835	校验数据Loss: 0.101585
训练周期: 2 [46272/60000 (77%)]	训练数据Loss: 0.107083	校验数据Loss: 0.100152
训练周期: 2 [52672/60000 (88%)]	训练数据Loss: 0.106421	校验数据Loss: 0.099607
训练周期: 2 [59072/60000 (98%)]	训练数据Loss: 0.105731	校验数据Loss: 0.097762
训练周期: 3 [5440/60000 (9%)]	训练数据Loss: 0.098701	校验数据Loss: 0.097193
训练周期: 3 [11840/60000 (20%)]	训练数据Loss: 0.098221	校验数据Loss: 0.095329
训练周期: 3 [18240/60000 (30%)]	训练数据Loss: 0.097732	校验数据Loss: 0.094617
训练周期: 3 [24640/60000 (41%)]	训练数据Loss: 0.097345	校验数据Loss: 0.094209
训练周期: 3 [31040/60000 (52%)]	训练数据Loss: 0.096794	校验数据Loss: 0.092226
训练周期: 3 [37440/60000 (62%)]	训练数据Loss: 0.096305	校验数据Loss: 0.091785
训练周期: 3 [43840/60000 (73%)]	训练数据Loss: 0.095839	校验数据Loss: 0.090821
训练周期: 3 [50240/60000 (84%)]	训练数据Loss: 0.095324	校验数据Loss: 0.089676
训练周期: 3 [56640/60000 (94%)]	训练数据Loss: 0.094907	校验数据Loss: 0.089277
训练周期: 4 [3008/60000 (5%)]	训练数据Loss: 0.090446	校验数据Loss: 0.088395
训练周期: 4 [9408/60000 (16%)]	训练数据Loss: 0.090097	校验数据Loss: 0.087829
训练周期: 4 [15808/60000 (26%)]	训练数据Loss: 0.089681	校验数据Loss: 0.087052
训练周期: 4 [22208/60000 (37%)]	训练数据Loss: 0.089323	校验数据Loss: 0.086451
训练周期: 4 [28608/60000 (48%)]	训练数据Loss: 0.088955	校验数据Loss: 0.085523
训练周期: 4 [35008/60000 (58%)]	训练数据Loss: 0.088619	校验数据Loss: 0.084939
训练周期: 4 [41408/60000 (69%)]	训练数据Loss: 0.088266	校验数据Loss: 0.083808
训练周期: 4 [47808/60000 (80%)]	训练数据Loss: 0.087919	校验数据Loss: 0.083542
训练周期: 4 [54208/60000 (90%)]	训练数据Loss: 0.087605	校验数据Loss: 0.082497
训练周期: 5 [576/60000 (1%)]	训练数据Loss: 0.083468	校验数据Loss: 0.082213
训练周期: 5 [6976/60000 (12%)]	训练数据Loss: 0.083796	校验数据Loss: 0.081482
训练周期: 5 [13376/60000 (22%)]	训练数据Loss: 0.083517	校验数据Loss: 0.081029
训练周期: 5 [19776/60000 (33%)]	训练数据Loss: 0.083284	校验数据Loss: 0.080693
训练周期: 5 [26176/60000 (44%)]	训练数据Loss: 0.083040	校验数据Loss: 0.079685
训练周期: 5 [32576/60000 (54%)]	训练数据Loss: 0.082799	校验数据Loss: 0.079922
训练周期: 5 [38976/60000 (65%)]	训练数据Loss: 0.082558	校验数据Loss: 0.079071
训练周期: 5 [45376/60000 (76%)]	训练数据Loss: 0.082310	校验数据Loss: 0.078887
训练周期: 5 [51776/60000 (86%)]	训练数据Loss: 0.082046	校验数据Loss: 0.078272
训练周期: 5 [58176/60000 (97%)]	训练数据Loss: 0.081802	校验数据Loss: 0.077731
训练周期: 6 [4544/60000 (8%)]	训练数据Loss: 0.079592	校验数据Loss: 0.077547
训练周期: 6 [10944/60000 (18%)]	训练数据Loss: 0.079346	校验数据Loss: 0.076777
训练周期: 6 [17344/60000 (29%)]	训练数据Loss: 0.079212	校验数据Loss: 0.076745
训练周期: 6 [23744/60000 (40%)]	训练数据Loss: 0.079108	校验数据Loss: 0.076385
训练周期: 6 [30144/60000 (50%)]	训练数据Loss: 0.078876	校验数据Loss: 0.075840
训练周期: 6 [36544/60000 (61%)]	训练数据Loss: 0.078692	校验数据Loss: 0.075625
训练周期: 6 [42944/60000 (72%)]	训练数据Loss: 0.078467	校验数据Loss: 0.075410
训练周期: 6 [49344/60000 (82%)]	训练数据Loss: 0.078349	校验数据Loss: 0.074693
训练周期: 6 [55744/60000 (93%)]	训练数据Loss: 0.078175	校验数据Loss: 0.074697
训练周期: 7 [2112/60000 (4%)]	训练数据Loss: 0.076694	校验数据Loss: 0.074478
训练周期: 7 [8512/60000 (14%)]	训练数据Loss: 0.076261	校验数据Loss: 0.073974
训练周期: 7 [14912/60000 (25%)]	训练数据Loss: 0.076346	校验数据Loss: 0.073728
训练周期: 7 [21312/60000 (36%)]	训练数据Loss: 0.076123	校验数据Loss: 0.073552
训练周期: 7 [27712/60000 (46%)]	训练数据Loss: 0.075983	校验数据Loss: 0.073348
训练周期: 7 [34112/60000 (57%)]	训练数据Loss: 0.075901	校验数据Loss: 0.073035
训练周期: 7 [40512/60000 (67%)]	训练数据Loss: 0.075800	校验数据Loss: 0.072847
训练周期: 7 [46912/60000 (78%)]	训练数据Loss: 0.075683	校验数据Loss: 0.072889
训练周期: 7 [53312/60000 (89%)]	训练数据Loss: 0.075598	校验数据Loss: 0.072618
训练周期: 7 [59712/60000 (99%)]	训练数据Loss: 0.075470	校验数据Loss: 0.072415
训练周期: 8 [6080/60000 (10%)]	训练数据Loss: 0.074718	校验数据Loss: 0.072170
训练周期: 8 [12480/60000 (21%)]	训练数据Loss: 0.074332	校验数据Loss: 0.071833
训练周期: 8 [18880/60000 (31%)]	训练数据Loss: 0.074254	校验数据Loss: 0.071984
训练周期: 8 [25280/60000 (42%)]	训练数据Loss: 0.074173	校验数据Loss: 0.071379
训练周期: 8 [31680/60000 (53%)]	训练数据Loss: 0.074094	校验数据Loss: 0.071342
训练周期: 8 [38080/60000 (63%)]	训练数据Loss: 0.073996	校验数据Loss: 0.071041
训练周期: 8 [44480/60000 (74%)]	训练数据Loss: 0.073866	校验数据Loss: 0.071151
训练周期: 8 [50880/60000 (85%)]	训练数据Loss: 0.073792	校验数据Loss: 0.070839
训练周期: 8 [57280/60000 (95%)]	训练数据Loss: 0.073697	校验数据Loss: 0.070720
训练周期: 9 [3648/60000 (6%)]	训练数据Loss: 0.073150	校验数据Loss: 0.070549

可我输出的确是

ModelG(
  (model): Sequential(
    (deconv1): ConvTranspose2d(100, 128, kernel_size=(5, 5), stride=(2, 2), bias=False)
    (bnorm1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu1): ReLU(inplace=True)
    (deconv2): ConvTranspose2d(128, 64, kernel_size=(5, 5), stride=(2, 2), bias=False)
    (bnorm2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu2): ReLU(inplace=True)
    (deconv3): ConvTranspose2d(64, 1, kernel_size=(4, 4), stride=(2, 2), bias=False)
    (sigmoid): Sigmoid()
  )
)
ModelG(
  (model): Sequential(
    (deconv1): ConvTranspose2d(100, 128, kernel_size=(5, 5), stride=(2, 2), bias=False)
    (bnorm1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu1): ReLU(inplace=True)
    (deconv2): ConvTranspose2d(128, 64, kernel_size=(5, 5), stride=(2, 2), bias=False)
    (bnorm2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu2): ReLU(inplace=True)
    (deconv3): ConvTranspose2d(64, 1, kernel_size=(4, 4), stride=(2, 2), bias=False)
    (sigmoid): Sigmoid()
  )
)
ModelG(
  (model): Sequential(
    (deconv1): ConvTranspose2d(100, 128, kernel_size=(5, 5), stride=(2, 2), bias=False)
    (bnorm1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu1): ReLU(inplace=True)
    (deconv2): ConvTranspose2d(128, 64, kernel_size=(5, 5), stride=(2, 2), bias=False)
    (bnorm2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu2): ReLU(inplace=True)
    (deconv3): ConvTranspose2d(64, 1, kernel_size=(4, 4), stride=(2, 2), bias=False)
    (sigmoid): Sigmoid()
  )
)


····这样重复然后再来几行
训练周期: 0 [6336/60000 (11%)]	训练数据Loss: 0.274138	校验数据Loss: 0.257729

            '''开始在校验数据集上做循环，计算校验集上面的准确度'''

我已经重装anaconda两次了，换了浏览器试也是这样，同样的环境在自己的pycharm里面输出就不会出事就是正常循环输出，已经被折磨很久了，希望有大神可以帮解决

zookeeper和spring整合开发

就是辣么6

1个回复