卷积神经网络-LENET

卷积神经网络-LENET

卷积

二维卷积

代码实现（输入数组X 核数组K 输出数组Y）

import torch
from torch import nn

class Corr2d(X, K):
    h, w = K.shape
    Y = torch.zeros((X.shape[0] - h + 1, X.shape[1] - w + 1))  # (n-k+2p)/s + 1
    for i in range(Y.shape[0]):
        for j in range(Y.shape[1]):
            Y[i, j] = (X[i: i + h, j: j + w] * K).sum()
    return Y

测试

X = torch.tensor([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
K = torch.tensor([[0, 1], [2, 3]])
corr2d(X, K)
print(Y)

pytorch 中的conv2d函数：

​ class torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1,
groups=1, bias=True)

例子：

#  m = nn.Conv2d(16, 33, 3, stride=2)
#  m = nn.Conv2d(16, 33, (3, 5), stride=(2, 1), padding=(4, 2))     竖直滑动步长为3，水平滑动步长为2
#  m = nn.Conv2d(16, 33, (3, 5), stride=(2, 1), padding=(4, 2), dilation=(3, 1))
input = torch.randn(20, 16, 50, 100) 
output = m(input)

池化层

二维最大池化层

平均池化层

​ 二维平均池化层与最大池化层类似，将最大运算符换成平均运算符

填充和步幅

填充

步幅

网络架构

import time
import torch
from torch import nn, optim
# import sys
# 	sys.path.append("..")
# import d2lzh_pytorch as d2l
	device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    
    
class LeNet(nn.Module):
	def __init__(self):
		super(LeNet, self).__init__()
		self.conv = nn.Sequential(
			nn.Conv2d(1, 6, 5), # in_channels, out_channels, kernel_size
			nn.Sigmoid(),
			nn.MaxPool2d(2, 2), # kernel_size, stride
			nn.Conv2d(6, 16, 5),
			nn.Sigmoid(),
			nn.MaxPool2d(2, 2)
		)
		self.fc = nn.Sequential(
			nn.Linear(16*4*4, 120),
			nn.Sigmoid(),
			nn.Linear(120, 84),
			nn.Sigmoid(),
			nn.Linear(84, 10)
		)
        
  def forward(self, img):
		feature = self.conv(img)
        output = self.fc(feature.view(img.shape[0], -1))
		return output

batch_size = 256
train_iter, test_iter =  d2l.load_data_fashion_mnist(batch_size=batch_size)

def evaluate_accuracy(data_iter, net,
	device = torch.device('cuda' if torch.cuda.is_available()
else 'cpu')):
	acc_sum, n = 0.0, 0
	with torch.no_grad():
		for X, y in data_iter:
			if isinstance(net, torch.nn.Module):
				net.eval() # 评估模式 会关闭dropout
				acc_sum += (net(X.to(device)).argmax(dim=1) == y.to(device)).float().sum().cpu().item()
				net.train() # 
			else: 
				if('is_training' in net.__code__.co_varnames): # 

				acc_sum += (net(X, is_training=False).argmax(dim=1) == y).float().sum().item()
				else:
					acc_sum += (net(X).argmax(dim=1) == y).float().sum().item()		
			n += y.shape[0]
	return acc_sum / n

def train_ch5(net, train_iter, test_iter, batch_size, optimizer, device, num_epochs):
	net = net.to(device)
	print("training on ", device)
	loss = torch.nn.CrossEntropyLoss()
	batch_count = 0
	for epoch in range(num_epochs):
		train_l_sum, train_acc_sum, n, start = 0.0, 0.0, 0, time.time()
	for X, y in train_iter:
		X = X.to(device)
		y = y.to(device)
		y_hat = net(X)
		l = loss(y_hat, y)
        optimizer.zero_grad()
        l.backward()
		optimizer.step()
		train_l_sum += l.cpu().item()
		train_acc_sum += (y_hat.argmax(dim=1) == y).sum().cpu().item()
		n += y.shape[0]
		batch_count += 1
	test_acc = evaluate_accuracy(test_iter, net)
	print('epoch %d, loss %.4f, train acc %.3f, test acc %.3f, time %.1f sec' % (epoch + 1, train_l_sum / batch_count, train_acc_sum / n, test_acc, time.time() - start))

lr, num_epochs = 0.001, 5
optimizer = torch.optim.Adam(net.parameters(), lr=lr)
train_ch5(net, train_iter, test_iter, batch_size, optimizer, device,
num_epochs)

lr, num_epochs = 0.001, 5
optimizer = torch.optim.Adam(net.parameters(), lr=lr)
train_ch5(net, train_iter, test_iter, batch_size, optimizer, device,
num_epochs)