一个简单的卷积神经网络
一、图像成像原理
区域经过透镜，形成了一个锥型区域，该光线被光敏电阻所感知。多个光敏电阻并列即可呈现图像。一个光敏电阻一个像素，如下就可形成2像素的图片。
对彩色图像而言，需对传感器器件进行改进，如绿色、红色、蓝色的传感器合成一组，最终像素值来自于三种不同的光敏器件。
二、卷积
单通道进行卷积
多通道进行卷积，以3通道为例
卷积核的输入通道数、输出通道数、宽度和高度，确定了一个卷积核。
其中：输出通道数：等于卷积核的个数；输入通过数：等于上一层的通道数。
代码示例：
import torch
in_chanels,outchuaels=5,10
width,height=100,100
kernel_size=3
batch_size=1
#batch为1 小批量第几个，输入通道为5，宽和高为100*100的图片
input=torch.randn(batch_size,in_chanels,width,height)
conv_layer=torch.nn.Conv2d(in_chanels,outchuaels,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])
1为样本数量，卷积核：输出通道为10，输入通道为5，大小为3*3
三、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]
#转化成(B,C,W,H)，批量维度，通道，宽，高
input=torch.Tensor(input).view(1,1,5,5)
conv_layer=torch.nn.Conv2d(1,1,kernel_size=3,padding=1,bias=False)
kennel=torch.Tensor([1,2,3,4,5,6,7,8,9]).view(1,1,3,3)
conv_layer.weight.data=kennel.data
output=conv_layer(input)
print(output)
四、最大池化层
- 一个简单的卷积神经网络
样本数量、通道数、宽度、高度确立了一个卷积层。
（batch，20,4,4）展开为1为一行，进行变换得到10*1的结果。
利用卷积神经网络做手写数字的识别：
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
#利用transforms 转换为tensor 类型的图片，
transform =transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307,),(0.3081,))
])
train_dataset=datasets.MNIST(root='../data/mnist',train=True,download=True,transform=transform)
train_loader= DataLoader(train_dataset,shuffle=True,batch_size=batch_size)
test_dataset=datasets.MNIST(root='../data/mnist',train=False,download=True,transform=transform)
test_loader=DataLoader(train_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(20)
self.fc=torch.nn.Linear(320,10)
def forward(self,x):
batch_size=x.size(0)
x=F.relu(self.pooling(self.conv1(x)))
x=F.relu(self.pooling(self.conv2(x)))
x=x.view(batch_size,-1) #变成全连接网络需要的输入
x=self.fc(x)
return x
model=Net()
crierion=torch.nn.CrossEntropyLoss()
optimizer=optim.SGD(model.parameters(),lr=0.01,momentum=0.5)
def train(epoch):
running_loss=0.0
for batch_idx,data in enumerate(train_loader,0):
inputs,target=data
optimizer.zero_grad()
#forward +backward+update
outputs=model(inputs)
loss=crierion(outputs,target)
loss.backward()
optimizer.step()
running_loss+=loss.item()
if batch_idx%300==299:
print('[%d,%5d] loss:%.3f' %(epoch+1,batch_idx+1,running_loss/300))
running_loss==0.0
def test():
correct=0
total=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('Accuacy on test set：%d %%'%(100*correct/total))
if __name__=='__main__':
for epoch in range(10):
train(epoch)
test()