任务CV之字符模型_cv之fc模型-CSDN博客

本文链接：https://blog.csdn.net/hello_fengfeng/article/details/106384788

任务CV之字符模型

1.经典神经网络初步介绍
2.在pytorch中搭建网络

1.经典神经网络初步介绍

1.1卷积神经网络

卷积神经网络是计算机视觉中最为常用的一种技术，也是目前最为有效的网络。
对于它的解释视频，论文，书籍，博客都很多，

这里就强调一下卷积神经网络为什么有效：
卷积神经网络在卷积的过程中，相比于全连接，参数明显减少，然后它还有检测物体边缘的作用
以人脸识别为例，在卷积过程中，每个卷积核学习人脸的特征，最后用分类器在把学习到的不同的部分特征图连接器，最后的出来的概率高则为识别出的类别

有位大刘在网站上用CNN解释器解释了卷积，论文地址

1.2常见的卷积网络有哪些

（网上都有很多的介绍，这里我用精简的话来进行说明）

发展网络

1.2.1 LeNet

卷积神经网络的开山之作，是非常经典的字符识别模型。两个卷积层，两个池化层，两个全连接层组成。卷积核都是5×5，stride=1，池化层使用最大池化
关于IMAGENET的分类
以此为例说明，图像分类最后是把一块块的像素映射到分类，经过误差的计算后方向传播，更新参数，使得学习到的参数在新的数据上任然有识别的能力，而用卷积神经更能检测到物体的边缘信息，能够更好的学习：
1.2.2 AlexNet
卷积核的大小由11X11变成5X5变成了3X3
论文地址
ALnet
AlexNet在ImageNet上取得的效果证明的卷积神经网络的正确性，从此打开新世界的大门

1.2.3 VGG16
VGG
这里的主要创新是去掉了了全连接，充分发挥了卷积的作用
论文

1.2.4 Google Inception

Inception
这里采用多个不同的卷积和，不同大小的卷积核都在卷积对同图片进行卷积，保持相同的特征图的输出，对于有选择卷积核纠结症的人是很好的福利，不用自己选择卷积核的大小，后面的连接都是同样的重复，在运用网络是可以在某一分支上连接softmax分类器进行输出。
论文地址

ResNet

这里我要单独拿出来
resnet

随着网络层数的增加，理论上因该误差损失率应该降低，可是由于参数’爆炸‘，使得参数不增反减，为了解决这个问题，引入resnet，使得网络层深度增加也能够提高准确率。
论文地址

resent的变种网络

像DenseNet

111
先是1X1的卷积5次，然后归一化，RELU再卷积，还把每一次的1X1卷积完后的结果加到下面全部1X1卷积完后的特征图中，大大减少了图片的丢失细节，是个不错的resnet变种网络
在pytorch中有进行封装
论文地址

2.在pytorch中搭建网络

class SVHN_Model1(nn.Module):
    def __init__(self):
        super(SVHN_Model1, self).__init__()

        model_conv = models.resnet18(pretrained=True)#用resnet18预训练模型
        model_conv.avgpool = nn.AdaptiveAvgPool2d(1)#平均池化层
        model_conv = nn.Sequential(*list(model_conv.children())[:-1])	#nn.sequential 
        self.cnn = model_conv

        self.fc1 = nn.Linear(512, 11)
        self.fc2 = nn.Linear(512, 11)
        self.fc3 = nn.Linear(512, 11)
        self.fc4 = nn.Linear(512, 11)
        self.fc5 = nn.Linear(512, 11)
        #这里是对5个字符进行分类

    def forward(self, img):
        feat = self.cnn(img)
        # print(feat.shape)
        feat = feat.view(feat.shape[0], -1)
        c1 = self.fc1(feat)
        c2 = self.fc2(feat)
        c3 = self.fc3(feat)
        c4 = self.fc4(feat)
        c5 = self.fc5(feat)
        return c1, c2, c3, c4, c5

操作流程：
首先，继承nn.Module；
其次，看__init__()函数，在__init__()中，定义了这些组件，self.pre，self.cnn, self.fc ；
最后，看forward()，分别用了在__init__()中定义的一系列组件，这个操作将网络连接起来
至此，网络定义完成。

torch.nn.Sequential其实就是Sequential容器，该容器将一系列操作按先后顺序给包起来，方便重复使用，
例如Resnet中有很多重复的block，就可以用Sequential容器把重复的地方包起来。

这里我稍微跑了一下
显示一下最后一轮

90%|█████████ | 212/235 [03:01<00:20, 1.14it/s]
91%|█████████ | 213/235 [03:01<00:18, 1.20it/s]
91%|█████████ | 214/235 [03:03<00:19, 1.10it/s]
91%|█████████▏| 215/235 [03:03<00:17, 1.13it/s]
92%|█████████▏| 216/235 [03:04<00:16, 1.16it/s]
92%|█████████▏| 217/235 [03:05<00:15, 1.17it/s]
93%|█████████▎| 218/235 [03:06<00:14, 1.18it/s]
93%|█████████▎| 219/235 [03:07<00:13, 1.19it/s]
94%|█████████▎| 220/235 [03:08<00:12, 1.20it/s]
94%|█████████▍| 221/235 [03:08<00:11, 1.20it/s]
94%|█████████▍| 222/235 [03:09<00:10, 1.19it/s]
95%|█████████▍| 223/235 [03:10<00:09, 1.21it/s]
95%|█████████▌| 224/235 [03:11<00:09, 1.16it/s]
96%|█████████▌| 225/235 [03:12<00:08, 1.13it/s]
96%|█████████▌| 226/235 [03:13<00:08, 1.11it/s]
97%|█████████▋| 227/235 [03:14<00:07, 1.09it/s]
97%|█████████▋| 228/235 [03:15<00:06, 1.07it/s]
97%|█████████▋| 229/235 [03:16<00:05, 1.07it/s]
98%|█████████▊| 230/235 [03:17<00:04, 1.06it/s]
98%|█████████▊| 231/235 [03:18<00:03, 1.06it/s]
99%|█████████▊| 232/235 [03:19<00:02, 1.06it/s]
99%|█████████▉| 233/235 [03:19<00:01, 1.06it/s]
100%|█████████▉| 234/235 [03:20<00:00, 1.07it/s]
100%|██████████| 235/235 [03:21<00:00, 1.17it/s]
99%|█████████▊| 78/79 [00:24<00:00, 3.31it/s]100%|██████████| 79/79 [00:24<00:00, 3.25it/s]
99%|█████████▊| 78/79 [00:27<00:00, 2.69it/s]100%|██████████| 79/79 [00:27<00:00, 2.92it/s]
Epoch: 9, Train loss: 0.8296829157687248 Val loss: 3.3279913497876517
Val Acc 0.454