卷积神经网络详解
在上一集中我们说到，黑白图像是单通道的，彩色图像是三通道的，这三通道分别是：Red、Green、Blue，也就是我们所说的RGB。对于这样一个彩色图像对应的图像张量，我们一般用C(通道数)* H(图像高度)*W(图像宽度)来刻画。
之前我们用全连接模型接softmax来做多分类，但在全联接模型里，直接把图像拼成一连串，会导致丧失了原有的空间信息。
而卷积可以保留图像的空间结构。
- 先从一个单通道图像入手
输入一个单通道，宽为5，高为5的图像(1 * 5 * 5)
我们用一个3 * 3的卷积核和做卷积。
这里的卷积是做数乘，不是矩阵乘法。每算完一个向右平移，最终得到：
- 3 input channels
对于一个三通道的图像张量：
我们只要把每个通道的张量和一个卷积核做卷积即可，最终得到3个3 * 3的张量，把这三个3 * 3的张量相加就能卷积结果。
对于这样一个(3,5,5)的图像张量，与(3,3,3)的卷积核卷积，得到(1,3,3)的张量。
进一步总结：
对于(n, w, h)的图像张量，如果拿一个k * k的卷积核做卷积，那么这个卷积核也一定是n通道的，即（n, k, k）,最终的卷积结果就是(1, w-k+1, w-k+1)
- 如果我们要得到一个多通道的输出结果呢？
用不同的卷积核把上面的过程重复m遍，得到m个(1, w-k+1, w-k+1)，把他们拼接起来就可以得到(m, w-k+1, w-k+1)了。
这样，为了更普遍化的表示卷积核，我们进一步定义卷积核为
(m, n, w, h)
其中，
m表示我们要的输出通道数
n表示输入的通道数
w表示卷积核宽
h表示卷积核长
写一个(5, 100, 100)的输入，卷积核(10, 5, 3, 3)。这就表示输入是5通道，长高均为100的图像张量，经过10次通道为5，大小为3 * 3的卷积核卷积，应该会得到一个(10, 98, 98)的输出。
import torch
in_channels, out_channels = 5, 10
width, height = 100, 100
kernel_size = 3
batch_size = 1
input = torch.randn(batch_size, in_channels, height, width)
conv_layer = torch.nn.Conv2d(in_channels, out_channels,
kernel_size = kernel_size)
output = conv_layer(input)
print(input.shape)
print(output.shape)
print(conv_layer.weight.shape)
torch.Size([1, 5, 100, 100])
torch.Size([1, 10, 98, 98])
torch.Size([10, 5, 3, 3])
这里面的batch_size也就是我们每次批量输入的图像数量，1就表示一次输入一张。
- 如果我们的图像是高5长5的，经过3 * 3卷积后是3 * 3的，但我们想要结果也是5 * 5的呢？
padding——给输入围圈0
input = [3,4,6,5,7,
2,4,6,8,2,
1,6,7,8,4,
9,7,4,6,2,
3,7,5,4,1]
input = torch.Tensor(input).view(1, 1, 5, 5)#B C W H
conv_layer = torch.nn.Conv2d(1, 1, kernel_size=3, padding=1, bias= False)#input_channel, output_channel, 3*3卷积核, 一维padding， 不加偏置
kernel = torch.Tensor([1,2,3,4,5,6,7,8,9]).view(1, 1, 3, 3)#input_channel, output_channel ,3*3
conv_layer.weight.data = kernel.data#赋给卷积权重
output = conv_layer(input)
print(output)
print(output.shape)
tensor([[[[ 91., 168., 224., 215., 127.],
[114., 211., 295., 262., 149.],
[192., 259., 282., 214., 122.],
[194., 251., 253., 169., 86.],
[ 96., 112., 110., 68., 31.]]]], grad_fn=<ConvolutionBackward0>)
torch.Size([1, 1, 5, 5])
- 如果我们想要输出长宽变小，更快实现压缩。我们可以加大卷积核扫描平移的步长。
默认情况下stride = 1. 这里我们设置stride = 2.
一个5 * 5的张量就会变成 2 * 2的了。
input = [3,4,6,5,7,
2,4,6,8,2,
1,6,7,8,4,
9,7,4,6,2,
3,7,5,4,1]
input = torch.Tensor(input).view(1, 1, 5, 5)#B C W H
conv_layer = torch.nn.Conv2d(1, 1, kernel_size=3, stride = 2, bias= False)#input_channel, output_channel, 3*3卷积核, 一维padding， 不加偏置
kernel = torch.Tensor([1,2,3,4,5,6,7,8,9]).view(1, 1, 3, 3)#input_channel, output_channel ,3*3
conv_layer.weight.data = kernel.data#赋给卷积权重
output = conv_layer(input)
print(output)
print(output.shape)
tensor([[[[211., 262.],
[251., 169.]]]], grad_fn=<ConvolutionBackward0>)
torch.Size([1, 1, 2, 2])
- MaxPooling layer——在每个块内找最大值即可，进行快速压缩
input = [3,4,6,5,
2,4,6,8,
1,6,7,8,
9,7,4,6
]
input = torch.Tensor(input).view(1,1,4,4)
maxpooling_layer = torch.nn.MaxPool2d(kernel_size = 2)
output = maxpooling_layer(input)
print(output)
print(output.shape)
tensor([[[[4., 8.],
[9., 8.]]]])
torch.Size([1, 1, 2, 2])
用卷积神经网络对mnist数据集进行多分类
输入(batch_size, 1, 28, 28)
->经过卷积层(1, 10, 5, 5)， 输出(batch_size, 10, 24, 24)
单通道变10通道，长高为28-5+1 = 24
->经过maxpooling下采样, 输出(bacth_size, 10, 12, 12)
->经过卷积层(10, 20, 5, 5), 输出(batch_size, 20, 8, 8)
10通道变20通道，长高为12-5+1 = 8
->经过maxpooling下采样, 输出(bacth_size, 20, 4, 4)
->展成(batch_size, 320)
->经过(320, 10)全连接层,输出(bacth_size, 10), 从而进行十分类
输出C * W * H，通道会变，高度和宽度也会变。
代码：
import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim
batch_size = 64
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
])
train_dataset = datasets.MNIST(root='../dataset/mnist/',
train=True,
download=False,
transform=transform)
train_loader = DataLoader(train_dataset,
shuffle=True,
batch_size=batch_size)
test_dataset = datasets.MNIST(root='../dataset/mnist',
train=False,
download=False,
transform=transform)
test_loader = DataLoader(test_dataset,
shuffle=False,
batch_size=batch_size)
class Net(torch.nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = torch.nn.Conv2d(1, 10, kernel_size = 5)
self.conv2 = torch.nn.Conv2d(10, 20, kernel_size = 5)
self.pooling = torch.nn.MaxPool2d(2)
self.fc = torch.nn.Linear(320, 10)
self.relu = torch.nn.ReLU()
def forward(self, x):
x = self.relu(self.pooling(self.conv1(x)))
x = self.relu(self.pooling(self.conv2(x)))
x = x.view(x.size(0), -1)
x = self.fc(x)
return x
model = Net()
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr = 0.01)
epoch_list = []
loss_list = []
loss_sum = 0
for epoch in range(10):
for index, data in enumerate(train_loader, 0):
inputs, labels = data
optimizer.zero_grad()
y_pred = model(inputs)
loss = criterion(y_pred, labels)
loss.backward()
optimizer.step()
loss_sum += loss.item()
batch = index
print('epoch = ', epoch, 'loss = ', loss_sum/batch)
epoch_list.append(epoch)
loss_list.append(loss_sum/batch)
loss_sum = 0
epoch = 0 loss = 0.5009269244937085
epoch = 1 loss = 0.14979709709896094
epoch = 2 loss = 0.10758499573546451
epoch = 3 loss = 0.08902853002658426
epoch = 4 loss = 0.07835054308028938
epoch = 5 loss = 0.06980127688564892
epoch = 6 loss = 0.06388871054082568
epoch = 7 loss = 0.059718344841408866
epoch = 8 loss = 0.055480038152317834
epoch = 9 loss = 0.05270801689137835
total = 0
correct = 0
with torch.no_grad():
for data in test_loader:
images, labels = data
outputs = model(images)
_,predicted = torch.max(outputs.data, dim = 1)
total +=labels.size(0)
correct += (predicted == labels).sum().item()
print( 'Accuracy on test set: %d %%' % (100 * correct / total))
Accuracy on test set: 98 %
比较
在上一篇文章当中，我们是用了全连接层来进行多分类处理的。
俩种模型对比：
全连接层的输出正确率是97%，卷积层输出正确率是98%。这也印证了前面所说的，在全联接模型里，直接把图像拼成一连串，会导致丧失了原有的空间信息。而卷积可以保留图像的空间结构，效果更好。
每天一个企业级理解~
1%正确率的提高
= 3%的错误率 -> 2%的错误率
= 提升了33%的性能
Great~
889
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
