LeNet的网络结构图是：
import torch
from torch.utils.data import DataLoader
from torchvision.datasets import MNIST
from torchvision import transforms
from torch import optim
import torch.nn as nn
#Load data
def loadMNIST(batch_size): #MNIST图片的大小是28*28
trans_img=transforms.Compose([transforms.ToTensor()])
trainset=MNIST('./data',train=True,transform=trans_img,download=True)
testset=MNIST('./data',train=False,transform=trans_img,download=True)
# device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
trainloader=DataLoader(trainset,batch_size=batch_size,shuffle=True,num_workers=10)
testloader = DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=10)
return trainset,testset,trainloader,testloader
#build network
class LeNet(nn.Module):
def __init__(self):
super(LeNet, self).__init__() #调用基类的__init__()函数
'''torch.nn.Conv2d(in_channels, out_channels, kernel_size,
stride=1, padding=0, dilation=1, groups=1, bias=True)'''
'''torch.nn.MaxPool2d(kernel_size, stride=None,
padding=0, dilation=1, return_indices=False, ceil_mode=False)
stride – the stride of the window. Default value is kernel_size'''
self.conv=nn.Sequential( #顺序网络结构
nn.Conv2d(1,6,5,stride=1,padding=2), #卷积层 输入1通道，输出6通道，kernel_size=5*5
nn.ReLU(), #激活函数
nn.MaxPool2d(2,2), #最大池化，kernel_size=2*2，stride=2*2
#输出大小为14*14
nn.Conv2d(6,16,5,stride=1,padding=2), #卷积层 输入6通道，输出16通道，kernel_size=5*5
nn.ReLU(),
nn.MaxPool2d(2,2),
# 输出大小为7*7
nn.Conv2d(16,120,5,stride=1,padding=2), #卷积层 输入16通道，输出120通道，kernel_size=5*5
nn.ReLU(),
)
self.fc=nn.Sequential( #全连接层
nn.Linear(7*7*120,120),
nn.ReLU(),
nn.Linear(120, 84),
nn.ReLU(),
nn.Linear(84,10),
nn.Sigmoid(),
)
def forward(self, x): #前向传播
out=self.conv(x)
out=out.view(out.size(0),-1) #展平数据为7*7=49的一维向量
out=self.fc(out)
return out
learning_rate=1e-3
batch_size=100
epoches=50
lenet=Lenet()#network
trainset,testset,trainloader,testloader=loadMNIST(batch_size)#data
criterian=nn.CrossEntropyLoss(size_average=False) #loss
optimizer=optim.SGD(lenet.parameters(),lr=learning_rate) #optimizer
lenet.to("cpu")
#training
for i in range(epoches):
running_loss=0.
running_acc=0.
for (img,label) in trainloader:
optimizer.zero_grad() #求梯度之前对梯度清零以防梯度累加
output=lenet(img) #前向计算网络输出值
loss=criterian(output) #计算loss值
loss.backward() #loss反传存到相应的变量结构当中
optimizer.step() #使用计算好的梯度对参数进行更新
running_loss+=loss.item()
print(output)
_,predict=torch.max(output,1)
correct_num=(predict==label).sum()
running_acc+=correct_num.item()
running_loss/=len(trainset)
running_acc/=len(trainset)
print("[%d/%d] Loss: %.5f, Acc: %.2f"%(i+1,epoches,running_loss,
100*running_acc))
在运行过程中出现这样的问题，fork函数是Unix系统特有的，Windows系统没有，根据提示加上
if __name__ == '__main__':就可以
RuntimeError:
An attempt has been made to start a new process before the
current process has finished its bootstrapping phase.This probably means that you are not using fork to start your
child processes and you have forgotten to use the proper idiom
in the main module:if __name__ == '__main__':
freeze_support()
...The "freeze_support()" line can be omitted if the program
is not going to be frozen to produce an executable.
正确的程序代码只是多加 if __name__ == '__main__':
import torch
from torch.utils.data import DataLoader
from torchvision.datasets import MNIST
from torchvision import transforms
from torch import optim
import torch.nn as nn
#Load data
def loadMNIST(batch_size): #MNIST图片的大小是28*28
trans_img=transforms.Compose([transforms.ToTensor()])
trainset=MNIST('./data',train=True,transform=trans_img,download=True)
testset=MNIST('./data',train=False,transform=trans_img,download=True)
# device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
trainloader=DataLoader(trainset,batch_size=batch_size,shuffle=True,num_workers=10)
testloader = DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=10)
return trainset,testset,trainloader,testloader
#build network
class LeNet(nn.Module):
def __init__(self):
super(LeNet, self).__init__() #调用基类的__init__()函数
'''torch.nn.Conv2d(in_channels, out_channels, kernel_size,
stride=1, padding=0, dilation=1, groups=1, bias=True)'''
'''torch.nn.MaxPool2d(kernel_size, stride=None,
padding=0, dilation=1, return_indices=False, ceil_mode=False)
stride – the stride of the window. Default value is kernel_size'''
self.conv=nn.Sequential( #顺序网络结构
nn.Conv2d(1,6,5,stride=1,padding=2), #卷积层 输入1通道，输出6通道，kernel_size=5*5
nn.ReLU(), #激活函数
nn.MaxPool2d(2,2), #最大池化，kernel_size=2*2，stride=2*2
#输出大小为14*14
nn.Conv2d(6,16,5,stride=1,padding=2), #卷积层 输入6通道，输出16通道，kernel_size=5*5
nn.ReLU(),
nn.MaxPool2d(2,2),
# 输出大小为7*7
nn.Conv2d(16,120,5,stride=1,padding=2), #卷积层 输入16通道，输出120通道，kernel_size=5*5
nn.ReLU(),
)
self.fc=nn.Sequential( #全连接层
nn.Linear(7*7*120,120),
nn.ReLU(),
nn.Linear(120, 84),
nn.ReLU(),
nn.Linear(84,10),
nn.Sigmoid(),
)
def forward(self, x): #前向传播
out=self.conv(x)
out=out.view(out.size(0),-1) #展平数据为7*7=49的一维向量
out=self.fc(out)
return out
#training
if __name__ == '__main__':
learning_rate = 1e-2
batch_size = 199
epoches = 50
lenet = LeNet() # network
trainset, testset, trainloader, testloader = loadMNIST(batch_size) # data
criterian = nn.CrossEntropyLoss(reduction='sum') # 求和的方式计算loss
optimizer = optim.SGD(lenet.parameters(), lr=learning_rate) # optimizer
for i in range(epoches):
running_loss=0.
running_acc=0.
for (img,label) in trainloader:
optimizer.zero_grad() #求梯度之前对梯度清零以防梯度累加
output=lenet(img) #前向计算网络输出值
loss=criterian(output,label) #计算loss值
loss.backward() #loss反传存到相应的变量结构当中
optimizer.step() #使用计算好的梯度对参数进行更新
running_loss+=loss.item()
# 1的意思是按列求最大值，output的shape=torch.Size([100, 10])
#其中torch.max()返回两个值，第一个是最大值，第二个是最大值的下标
valu,predict=torch.max(output,1)
correct_num=(predict==label).sum()
running_acc+=correct_num.item()
running_loss/=len(trainset)
running_acc/=len(trainset)
print("[%d/%d] Loss: %.5f, Acc: %.2f"%(i+1,epoches,running_loss,
100*running_acc))运行的结果是：
[1/50] Loss: 1.66764, Acc: 76.20
[2/50] Loss: 1.48704, Acc: 96.65
[3/50] Loss: 1.47988, Acc: 97.56
[4/50] Loss: 1.47562, Acc: 98.08
[5/50] Loss: 1.47277, Acc: 98.48
[6/50] Loss: 1.47142, Acc: 98.55
[7/50] Loss: 1.47108, Acc: 98.71
[8/50] Loss: 1.46989, Acc: 98.83
[9/50] Loss: 1.46912, Acc: 98.96
[10/50] Loss: 1.46844, Acc: 99.02
[11/50] Loss: 1.46789, Acc: 99.10
[12/50] Loss: 1.46728, Acc: 99.17
[13/50] Loss: 1.46731, Acc: 99.17
[14/50] Loss: 1.46662, Acc: 99.27
[15/50] Loss: 1.46540, Acc: 99.46
Relu激活函数这里是收敛的挺快的，如果将Relu函数修改为sigmoid函数，这里的情况就有些不同
将class LeNet修改为：
#build network
class LeNet(nn.Module):
def __init__(self):
super(LeNet, self).__init__() #调用基类的__init__()函数
'''torch.nn.Conv2d(in_channels, out_channels, kernel_size,
stride=1, padding=0, dilation=1, groups=1, bias=True)'''
'''torch.nn.MaxPool2d(kernel_size, stride=None,
padding=0, dilation=1, return_indices=False, ceil_mode=False)
stride – the stride of the window. Default value is kernel_size'''
self.conv=nn.Sequential( #顺序网络结构
nn.Conv2d(1,6,5,stride=1,padding=2), #卷积层 输入1通道，输出6通道，kernel_size=5*5
nn.Sigmoid(), #激活函数
nn.MaxPool2d(2,2), #最大池化，kernel_size=2*2，stride=2*2
#输出大小为14*14
nn.Conv2d(6,16,5,stride=1,padding=2), #卷积层 输入6通道，输出16通道，kernel_size=5*5
nn.Sigmoid(),
nn.MaxPool2d(2,2),
# 输出大小为7*7
nn.Conv2d(16,120,5,stride=1,padding=2), #卷积层 输入16通道，输出120通道，kernel_size=5*5
nn.Sigmoid(),
)
self.fc=nn.Sequential( #全连接层
nn.Linear(7*7*120,120),
nn.Sigmoid(),
nn.Linear(120, 84),
nn.Sigmoid(),
nn.Linear(84,10),
nn.Sigmoid(),
)
def forward(self, x): #前向传播
out=self.conv(x)
out=out.view(out.size(0),-1) #展平数据为7*7=49的一维向量
out=self.fc(out)
return out运行的结果是：收敛的很慢，可能不能使用
[1/100] Loss: 2.30338, Acc: 10.81
[2/100] Loss: 2.30207, Acc: 11.10
[3/100] Loss: 2.30171, Acc: 11.13
[4/100] Loss: 2.30163, Acc: 11.19
[5/100] Loss: 2.30157, Acc: 11.23
[6/100] Loss: 2.30153, Acc: 11.24
[7/100] Loss: 2.30146, Acc: 11.24
[8/100] Loss: 2.30152, Acc: 11.24
[9/100] Loss: 2.30139, Acc: 11.24
[10/100] Loss: 2.30147, Acc: 11.24