神经网络中Batch Size的理解

直观的理解:
Batch Size定义:一次训练所选取的样本数。
Batch Size的大小影响模型的优化程度和速度。同时其直接影响到GPU内存的使用情况,假如你GPU内存不大,该数值最好设置小一点。


为什么要提出Batch Size?
在没有使用Batch Size之前,这意味着网络在训练时,是一次把所有的数据(整个数据库)输入网络中,然后计算它们的梯度进行反向传播,由于在计算梯度时使用了整个数据库,所以计算得到的梯度方向更为准确。但在这情况下,计算得到不同梯度值差别巨大,难以使用一个全局的学习率,所以这时一般使用Rprop这种基于梯度符号的训练算法,单独进行梯度更新。
在小样本数的数据库中,不使用Batch Size是可行的,而且效果也很好。但是一旦是大型的数据库,一次性把所有数据输进网络,肯定会引起内存的爆炸。所以就提出Batch Size的概念。


Batch Size设置合适时的优点:
1、通过并行化提高内存的利用率。就是尽量让你的GPU满载运行,提高训练速度。
2、单个epoch的迭代次数减少了,参数的调整也慢了,假如要达到相同的识别精度,需要更多的epoch。
3、适当Batch Size使得梯度下降方向更加准确。


Batch Size从小到大的变化对网络影响
1、没有Batch Size,梯度准确,只适用于小样本数据库
2、Batch Size=1,梯度变来变去,非常不准确,网络很难收敛。
3、Batch Size增大,梯度变准确,
4、Batch Size增大,梯度已经非常准确,再增加Batch Size也没有用

注意:Batch Size增大了,要到达相同的准确度,必须要增大epoch。


GD(Gradient Descent):就是没有利用Batch Size,用基于整个数据库得到梯度,梯度准确,但数据量大时,计算非常耗时,同时神经网络常是非凸的,网络最终可能收敛到初始点附近的局部最优点。

SGD(Stochastic Gradient Descent):就是Batch Size=1,每次计算一个样本,梯度不准确,所以学习率要降低。

mini-batch SGD:就是选着合适Batch Size的SGD算法,mini-batch利用噪声梯度,一定程度上缓解了GD算法直接掉进初始点附近的局部最优值。同时梯度准确了,学习率要加大。
对于mini-batch SGD:

loss:    L=1mi=1mL(xi,yi) l o s s 值 :         L = 1 m ∑ i = 1 m L ( x i , y i )
gradient:    g=1mi=1mg(xi,yi) g r a d i e n t 值 :         g = 1 m ∑ i = 1 m g ( x i , y i )


为什么说Batch size的增大能使网络的梯度更准确?
梯度的方差表示:
Var(g)=Var(1mmi=1g(xi,yi))=1m2Var(g(x1,y1)+g(x2,y2)++g(xm,ym)) V a r ( g ) = V a r ( 1 m ∑ i = 1 m g ( x i , y i ) ) = 1 m 2 V a r ( g ( x 1 , y 1 ) + g ( x 2 , y 2 ) + · · · + g ( x m , y m ) )
由于样本是随机选取的,满足独立同分布,所以所有样本具有相同的方差 Var(g(xi,yi)) V a r ( g ( x i , y i ) )
所以上式可以简化成 Var(g)=1mVar(g(xi,yi)) V a r ( g ) = 1 m V a r ( g ( x i , y i ) )
可以看出当Batch size为m时,样本的方差减少m倍,梯度就更准确了。

假如想要保持原来数据的梯度方差,可以增大学习率 lr l r
1mVar(lrg(xi,yi)) 1 m V a r ( l r ∗ g ( x i , y i ) ) ,只要 lr l r m m ,上式就变成 Var(g(xi,yi)) V a r ( g ( x i , y i ) )
这也说明batch size设置较大时,一般学习率要增大。但是 lr l r 的增大不是一开始就设置的很大,而是在训练过程中慢慢变大。


一个具体例子分析:
在分布式训练中,Batch size随着数据并行的workers增加而增大,假如baseline的Batch Size为 B B ,而学习率为lr,训练epoch为 N N 。假如保持baseline的lr,一般达不到很好的收敛速度和精度。
原因:对于收敛速度,假如有 K K 个workers,则每个批次为KB,因此一个epoch迭代的次数为baseline的 1k 1 k ,而学习率 lr l r 不变,所以要达到与baseline相同的收敛情况,epoch要增大。而根据上面公式,epoch最大需要增大 KN K N 个epoch,但一般情况下不需要增大那么多。
对于收敛精度,由于Batch size的使用使梯度更准确,噪声减少,所以更容易收敛。

  • 267
    点赞
  • 1162
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
好的,我可以帮你解答这个问题。 首先,对抗神经网络(GAN)是一种非监督学习方法,它由生成器和判别器两个部分组成。在波士顿房价预测问题,可以将生成器看作是一个生成房价的模型,判别器则是一个用于判断输入数据是否为真实房价的模型。两个模型通过对抗训练的方式来提高性能。 接下来,我们需要准备数据。波士顿房价数据集可以通过PyTorch内置的数据集`torchvision.datasets`来获取。我们可以使用`torch.utils.data.DataLoader`类来创建数据加载器,并将数据分为训练集和测试集。 ```python import torch from torchvision.datasets import BostonHousing from torch.utils.data import DataLoader, random_split # 加载数据集 dataset = BostonHousing(root='.', download=True) # 将数据集分为训练集和测试集 train_dataset, test_dataset = random_split(dataset, [400, 106]) # 创建数据加载器 train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True) test_loader = DataLoader(test_dataset, batch_size=128, shuffle=True) ``` 接下来,我们可以定义生成器和判别器模型。在这里,我们可以使用多层感知器(MLP)来作为生成器和判别器的基本模型。生成器的输入为随机噪声,输出为生成的房价数据。判别器的输入为真实房价或生成的房价数据,输出为0或1,表示输入数据的真假。 ```python import torch.nn as nn class Generator(nn.Module): def __init__(self, input_dim=100, output_dim=13*3): super(Generator, self).__init__() self.fc1 = nn.Linear(input_dim, 128) self.fc2 = nn.Linear(128, 256) self.fc3 = nn.Linear(256, output_dim) self.relu = nn.ReLU() self.tanh = nn.Tanh() def forward(self, z): out = self.fc1(z) out = self.relu(out) out = self.fc2(out) out = self.relu(out) out = self.fc3(out) out = self.tanh(out) return out class Discriminator(nn.Module): def __init__(self, input_dim=13*3): super(Discriminator, self).__init__() self.fc1 = nn.Linear(input_dim, 256) self.fc2 = nn.Linear(256, 128) self.fc3 = nn.Linear(128, 1) self.relu = nn.ReLU() self.sigmoid = nn.Sigmoid() def forward(self, x): out = self.fc1(x) out = self.relu(out) out = self.fc2(out) out = self.relu(out) out = self.fc3(out) out = self.sigmoid(out) return out ``` 接下来,我们可以定义训练过程。在每个epoch,我们会先更新判别器的参数,然后再更新生成器的参数。对于判别器的loss,我们使用二元交叉熵损失函数。对于生成器的loss,我们使用判别器的输出作为目标值,使用均方误差损失函数。 ```python import torch.optim as optim # 定义模型 generator = Generator() discriminator = Discriminator() # 定义优化器 g_optimizer = optim.Adam(generator.parameters(), lr=0.0002) d_optimizer = optim.Adam(discriminator.parameters(), lr=0.0002) # 定义损失函数 criterion = nn.BCELoss() # 训练过程 num_epochs = 100 for epoch in range(num_epochs): for i, (real_data, _) in enumerate(train_loader): batch_size = real_data.size(0) # 训练判别器 discriminator.zero_grad() # 真实数据 real_data = real_data.view(batch_size, -1) real_label = torch.ones(batch_size, 1) real_prob = discriminator(real_data) real_loss = criterion(real_prob, real_label) # 生成数据 noise = torch.randn(batch_size, 100) fake_data = generator(noise) fake_label = torch.zeros(batch_size, 1) fake_prob = discriminator(fake_data.detach()) fake_loss = criterion(fake_prob, fake_label) # 总loss d_loss = real_loss + fake_loss d_loss.backward() d_optimizer.step() # 训练生成器 generator.zero_grad() noise = torch.randn(batch_size, 100) fake_data = generator(noise) fake_label = torch.ones(batch_size, 1) fake_prob = discriminator(fake_data) g_loss = criterion(fake_prob, fake_label) g_loss.backward() g_optimizer.step() # 打印loss print("Epoch [{}/{}], d_loss: {:.4f}, g_loss: {:.4f}" .format(epoch+1, num_epochs, d_loss.item(), g_loss.item())) ``` 最后,在测试集上评估模型的性能。我们可以使用均方误差(MSE)来评估生成器生成的房价数据与真实房价数据的差距。 ```python # 测试过程 mse = nn.MSELoss() with torch.no_grad(): for test_data, _ in test_loader: batch_size = test_data.size(0) real_data = test_data.view(batch_size, -1) noise = torch.randn(batch_size, 100) fake_data = generator(noise) mse_loss = mse(fake_data, real_data) print("MSE loss on test set: {:.4f}".format(mse_loss.item())) ``` 希望这个代码示例能够帮助你更好地理解如何使用PyTorch实现对抗神经网络

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 9
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值