图像识别技术与应用

第一节课
这节课了解了这门专业的就业职位：工资是怎么样的岗位职责和任职要求
看到了人类工业文明的演变
了解了人工智能的研究、开发、模拟、延伸、理论、方法和技术
看到了生活方式的转变比如智能语音闹钟控制系统、自动驾驶和人脸识别考勤 智能购物、医疗
日常生活的智能比如 指纹、淘宝、抖音
还能用软件看到天气的好坏了解了典型训练和机器学习中的关键组件
机器学习中的关键组件包含：数据 模型 目标函数 优化算法
 

这节课学习了第一节剩下的部分和第二节课
一、了解机器学习
机器学习（machine learning，ML）是一类强大的可以从经验中学习的技术。通常采用观测数据或与环境交互的形式，机器学习算法会积累更多的经验，其性能也会逐步提高。
➢监督学习
监督学习（supervised learning）擅⻓在“给定输⼊特征”的情况下预测标签。每个“特征-标签”对都称为一个样本（example）。我们的目标是生成一个模型，能够将任何输⼊特征映射到标签（即预测）。
二、深度学习
深度学习的发展、深度学习的成功案例、深度学习的成功领域
三、图灵测试
人工智能的先驱：艾伦·麦席森·图灵
英国数学家、逻辑学家、计算机科学之父、人工智能之父
“一个人在不接触对方的情况下，通过一种特殊的方式，和对方进行一系列的问答。如果在相当长时间内，他无法根据这些问题判断对方是人还是计算机，那么就可以认为这个计算机是智能的”。
 
---Alan Turing [1950]
《Computing Machinery and Intelligence》
四、pytorch介绍
PyTorch是由Meta AI(Facebook)人工智能研究小组开发的一种基于Lua编写的Torch库的Python实现的深度学习库，目前被广泛应用于学术界和工业界，PyTorch在API的设计上更加简洁、优雅和易懂。因此本课程我们选择PyTorch来进行开源学习。
第二节课
线性回归和softmax回归
假设 1:影响房价的关键因素：卧室数目，卫浴数目和房子大小，分别用x_beds,x_baths,x_area表示
假设 2:销售价格是关键因素的加权总和：
price=w_beds x_beds+w_baths x_baths+w_area x_area+b
w称为权重，决定了每个特征对我们预测值的影响
b称为偏置
给予 n 维输入，x=[x_1,x_2,…,x_n ]^T
线性方法有 n 个权重和偏差：
w=[w_1,w_2,…,w_n ]^T,b
输出是输入的加权总和：
y┴̂=w_1 x_1+w_2 x_2+⋯+w_n x_n+b
点积形式：
矩阵-向量乘法表示：
矢量化版本：y┴̂=+b
衡量预估质量
损失函数能够量化目标的实际值与预测值之间的差距，例如房屋售价和估价。
回归问题最常用的损失函数是平方损失
l(y,y┴̂)=1∕2(y-y┴̂ )^2
y 作为真实值， y┴̂ 作为估计值

收集多个数据点以训练参数（如 在过去6个月内出售的房屋），这个叫做训练数据集 。
训练数据集越大越好
假设有 n 个房屋
X=[x_0,x_1,…,x_n ]^T，y=[y_0,y_1,…,y_n ]^T

还学习了基础优化算法
梯度法
神经网络在学习时找到最优的参数（权重和偏置）——指损失函数取最小值时的参数。我们不知道他在何处能取得最小值，所以使用梯度来寻找函数的最小值的方法就是梯度法。
严格的讲，梯度指示的反向是各点处的函数值减小最多的方向
像              这样的由全部变量的偏导数汇总而成的向量称为梯度（gradient）。
我们发现梯度指向函数的“最低处”（最小值），就像指南针一样，所有的箭头都指向同一点。其次，我们发现离“最低处”越远，箭头越大。
!!!  梯度指示的反向是各点处的函数值减小最多的方向,所以无法保证梯度所指的方向就是函数的最小值或者真正应该前进的方向。
但沿着它的方向能最大限度的减小函数的值。所以在寻找函数的最小值的位置任务中，以梯度的信息为线索，决定前进的方向。
流程：在梯度法中，函数的取值从当前位置沿着梯度方向前进一定的距离，然后在新的方向重新求梯度，再沿着新梯度的方向前进，如此反复，不断的沿梯度方向前进。
 
 
小批量随梯度下降
计算整个训练数据的梯度太昂贵了，一个深度神经网络模型需要几分钟到几小时
解决方案： 随机抽样b个样本i_1,i_2,…,i_b来估算损失
1/b ∑┬(i∈I_b ) l(x_i,y_i,w）
b是批量大小，另一个重要的超参数

选择批量
批量值不能太小：批量值太小，难以充分利用计算资源
批量值不能太大：批量值太大，浪费计算资源；
    问题： 估计一个真正的值
    模型：y=⟨w,x⟩+b
    损失： 平方损失   l(y,y┴̂)=(y-y┴̂ )^2
    小批量随机梯度（mini-batch SGD）学习
    选择一个起点
    重复
    计算梯度
    更新参数

总结
梯度下降通过不断的沿着反梯度方向更新参数求解
小批量随机梯度下降是深度学习默认的求解算法
两个重要的超参数是批量大小和学习率
归回和分类
回归估计一个连续值
分类预测一个离散类别
回归
单个连续数值输出
自然区间
与真实值的区别作为损失
分类
通常多个输出
输出的i表示预测为第i类的置信度
输出层的神经元数量需要根据待解决的问题来决定。对于分类问题，输
出层的神经元数量一般设定为类别的数量。
Softmax回归
Softmax回归是一个多类分类模型
使用Softmax操作得到每个类的预测置信度
Huber 损失
l(y,y^')=1/2(y-y^' )^2
损失函数
l(y,y^')=|y-y^' |
交叉熵损失
H(y,y┴̂)=-(∑┬(i=1))┴n y_i log(y┴̂_i)=-log(y┴̂_i)

多层感知机
1.感知机
美国学者Frank Rosenblatt在1957年提出来的。
给予输入x， 权重 w 和偏差b；感知机输出
二分类 (0 或 1) 
Vs. 回归：输出实数
Vs. Softmax：输出的概率，多个分类
w称为权重：控制输入信号的重要性的参数
b称为偏置：偏置是调整神经元被激活的容易程度参数
与门、与非门、或门、异或门
2.感知局限性
感知机的局限性:感知机的局限性就是只能表示由一条直线分割的空间。
面对这种线性不可分的情况该怎么办呢？
用非线性的曲线划分出非线性空间
——多层感知机：最简单的深度神经网络
多层感知机、单隐藏层、单隐藏层-单分
3.激活函数
激活函数：刚才登场的h（x）函数会将输入信号的总和转换为输出信号，这种函数一般称为激活函数（activation function）。
如“激活”一词所示，激活函数的作用在于决定如何来激活输入信号的总和。
激活函数在神经元中非常重要的。为了增强网络的表示能力和学习能力，激活函数需要具备以下几点性质：
（1） 连续并可导（允许少数点上不可导）的非线性函数。
（2） 激活函数及其导函数要尽可能的简单，有利于提高网络计算效率。
（3） 激活函数的导函数的值域要在一个合适的区间内，不能太大也不能太小，否则会影响训练的效率和稳定性。
阶跃函数
以0为界，一旦输入超过0，就切换输出1，
否则输出0
可以说感知机使用了阶跃函数作为激活函数。
4.训练误差和泛化误差
训练误差：模型在训练数据集上的误差
泛化误差: 模型在新数据集上的误差
示例：使用历年试真题准备将来的考试
再历年考试真题取得好成绩（训练误差）并不能保证未来考试成绩更好（泛化误差）
学生A 通过死记硬背学习在历年真题考试中取得好成绩
学生B理解并给出答案的解释
5.验证数据集和测试数据集
如何计算训练误差和泛化误差呢？
•验证数据集：一个用来评估模型好坏的数据集
例如拿出50%的训练数据
不要跟训练数据集混在一起（常犯错误）
•测试数据集：评估最终模型的性能
理论上严格的讲，是只用一次的数据集
例如高考
6.k-折交叉验
 
在没有足够的数据时非常有用
算法：
将训练数据划分为 K 个部分
对于 i = 1，...，K
使用第 i 部分作为验证集，其余部分用于训练
报告 K 个部分在验证时的平均误差
常见 K 值选择：K=5或10
7.过拟合和欠拟合
当学习器把训练样本学得"太
好"了的时候，很可能已经把训练样本自身的一些特点当作了所有潜在样本都会具有的一般性质——过拟合；
对训练样本的一般性质尚未学好——欠拟合
8.数据复杂度影响
多种因素很重要：
样本数量
每个样本中的特征数量
时间、空间结构
多样性

四、卷神经网络
1.重新思考-全连接层
多层感知机十分适合处理表格数据，行对应样本，列对应特征。
通过将图像数据展平成一维向量而忽略了每张图像的空间结构信息。
2.猫狗分类
使用一个还不错的相机采集RGB图片（3600万个像素）
使用 100 个神经元单隐含层的 MLP ，模型有 36 亿个参数
远超过地球上的狗和猫的数量
100个神经元
3600万个特征
参数：100×3600万=36亿
使用卷积神经网络可大大降低参数量：共享参数机制、多种池化方法
3.沃尔多游戏
4.两个原则
平移不变性
不管检测对象出现在图像中的哪个位置，神经网络的前面几层都应该对相同的图像区域具有相似的反应。
➢局部性
神经网络的前面几层应该只探索输入图像中的局部区域，而不过度在意图像中相隔较远的区域的关系。
5.图像卷积
 
6.卷积层
 
7.多通道的卷积层
8.填充和步幅
填充和步幅可以改变输出的高度和宽度
填充在输入周围添加额外的行/列，增加输出的高度和宽度
步幅是每次滑动核窗口时的行/列的步长，可以成倍的减少输出形状
填充和步幅可用于有效地调整数据的维度
9.多个输入和输出通道
彩色图像可能有 RGB 三个通道
转换为灰度会丢失信息
10.池化层
平均池化层：
将最大池化层中的“最大”操作替换为“平均”
11.数据复杂度
居中和缩放
50000个训练数据
10,000 个测试数据
图像大小28*28 
10 类
12.LeNet
总体来看，LeNet（LeNet-5）由两个部分组成：
• 卷积编码器：由两个卷积层组成；
• 全连接层密集块：由三个全连接层组成；
每个卷积层使⽤5×5卷积核和一个sigmoid激活函数。
13.学习表征
浅层学习：不涉及特征学习，其特征主要靠人工经验或特征转换方法来抽取
表示学习：如果有一种算法可以自动地学习出有效的特征，并提高最终机器学习模型的性能，那么这种学习就可以叫作表示学习
通常需要从底层特征开始，经过多步非线性转换才能得到。
通过构建具有一定“深度”的模型，可以让模型来自动学习好的特征表示（从底层特征，到中层特征，再到高层特征），从而最终提升预测或识别的准确性。
14.视觉分层理论
视觉分层理论，从底层到高层的不断抽象。
浅层卷积核提取：边缘、颜色、斑块等底层像素特征。
 中层卷积核提取：条纹、纹路、形状等中层纹理特征。
高层卷积核提取：眼睛、轮胎、文字等高层语义特征。
15.AlexNet架构
AlexNet 在 2012 年赢得了ImageNet 竞赛
•更深更大的 LeNet
•主要修改
丢弃法（防止过拟合）
ReLu 激活函数（训练）
最大池化法
•计算机视觉的范式转变
1. AlexNet比相对较小的LeNet5要深得多。AlexNet由⼋层组成：五个卷积层、两个全连接隐藏层和一个全连接输出层。
2. AlexNet使⽤ReLU⽽不是sigmoid作为其激活函数。
！总结
AlexNet的架构与LeNet相似，但使⽤了更多的卷积层和更多的参数来拟合大规模的ImageNet数据集。
• 今天，AlexNet已经被更有效的架构所超越，但它是从浅层⽹络到深层网络的关键一步。
• 新加入了Dropout、ReLU、最大池化层和数据增强
16.VGG网络
VGG19共有16个卷积层和3个全连接层。
此外，还有5个最大池化层分布在不同的卷积层之下。
AlexNet比LeNet更深入更大，以获得更强性能
•能不能更大更深？
•选项
•更多稠密层(开销太大) 
•更多的卷积层
•将卷积层组合成块
VGG 块
•3x3 卷积（填充=1）（n层，m个通道）
•2x2 最大池化层  （步幅=2）
•更深还是更宽？
•5x5 卷积
•3x3 卷积（更多）
•更深和更窄更好
多个VGG块后加全连接层
•VGG使用可重复使用的卷积块来构建深度卷积神经网络
不同次数的重复VGG块，可获得不同的架构，例如VGG-16，VGG-19，......
！发展
LeNet(1995)
•2卷积层+池化层 
•2隐含层
•AlexNet
•更大更深的LeNet
•ReLu激活,丢弃法,预处理
•VGG
•更大更深的AlexNet(重复的VGG块

五.Pytorch神经网络工具箱
1.核心组件
层：神经网络的基本结构，将输入张量转换为输出张量
模型：层构成的网络
损失函数：参数学习的目标函数，通过最小化损失函数来学习各种参数
优化器：
如何是损失函数最小，这就涉及到优化器。
2.主要工具
nn.Module
①继承自Module类，可自动提取可学习的参数。
②适用于卷积层、全连接层、dropout层。
 
➢nn.functional
①更像是纯函数。
②适用于激活函数、池化层

nn.Module，写法一般为nn.Xxx，如nn.Linear、nn.Conv2d、nn.CrossEntropyLoss等。
 
➢nn.functional中的函数，写法一般为nn.funtional.xxx，如nn.funtional.linear、nn.funtional.conv2d、nn.funtional.cross_entropy等。
者的主要区别如下。
➢nn.Xxx继承于nn.Module，nn.Xxx 需要先实例化并传入参数，然后以函数调用的方式调用实例化的对象并传入输入数据。它能够很好的与nn.Sequential结合使用，而nn.functional.xxx无法与nn.Sequential结合使用。
➢nn.Xxx不需要自己定义和管理weight、bias参数；而nn.functional.xxx需要你自己定义weight、bias，每次调用的时候都需要手动传入weight、bias等参数, 不利于代码复用。
➢dropout操作在训练和测试阶段是有区别的，使用nn.Xxx方式
3.构建模型
继承nn.Module基类构建模型。
➢使用nn.Sequential按层顺序构建模型。
➢继承nn.Module基类构建模型，又使用相关模型容器
import torch
from torch import nn
import torch. nn. functional as F
class Model_Seq(nn. Module) :
通过继承基类mn.Module来构建模型
definit_(self, in_dim, n_hidden_1, n_hidden_2, out_dim) :
super (Model_Seq, self). _init_ (
self. flatten = nn. Flatten self. linear1= nn. Linear (in_din, n_hidden_1)
self. bn1=nn. BatchNormid(n hidden 1)
self. linear2= nn. Linear (n_hidden_1, n_hidden_2)
self. bn2 = n. BatchNornid (n_hidden_2)
self. out = nn. Linear (n_hidden_2, out_dim)
forward (self, x) : x=self. flatten (x)
x=self. linear1 (x)
x=self. bn1(x)
x = F. relu(x)
x=self. linear2 (x)
x=self. bn2 (x)
x = F.relu(x)
x=self. out (x)
x = F. sof tmax (x, dim=1)|
return x in_dim, n_hidden_1, n_hidden_2, out_dim=28 * 28, 300, 100, 10
model_seq= Model_Seq(in_dim, n_hidden_1, n_hidden_2, out_dim)
print (model_seq)
运行结果：Model Seq(
(flatten) : Flatten(start_dim=1, end_dim=-1)
(linear1) : Linear (in_features=784, out_features=300, bias=True)
(bnl): BatchNormld (300, eps=1-05, momentun=0.1, affine=True, track_running_stats=True)
(linear2) : Linear (in_features=300, out_features=100, bias=True)
(bn2) : BatchNormld (100, eps=1-05, momentun=0.1, affine=True, track_running_stats=True)
(out) : Linear (in_features=100, out_features=10, bias=True)
4.使用nn.Sequential按层顺序构建模型
Seqarg = nn. Sequential (
nn. Flatten, nn. Linear (in_dim, n_hidden_1),
mn. BatchNormid(n_hidden_1),
nn. ReLUO, nn. Linear (n hidden_1, n hidden_2) ,
nn. BatchMormid (n_hidden_2) ,
nn. ReLUO, nn. Linear (n_hidden_2, out_dim),
nh. Sof tmax (din=1)
) in_dim, n_ hidden_1, n _hidden_2, out_dim=28 * 28, 300, 100, 10
print (Sequarg)
(0): Flatten(start_dim=1, end_dim=-1)
(1): Linear (in_features=784, out_features=300, bias=True) (2): BatchNorm1d(300, BatchNorm1d(300, eps=1e-05, momentun=0.1, affine=True,
track_running_stats=True)
(3) : ReLU(
(4): Linear (in_features=300, out_features=100, bias=True)
(5) : BatchNorm1d(100, eps=1e-05, momentun=0.1, affine=True, track_running_stats=True)
(6) : ReLUO
(7): Linear (in_features=100, out_features=10, bias=True)
该方法构建时不能给每个层指定名称,如果需要给每个层指定名称，可使用add_module方法或OrderedDict方法。
Sequential (
Seq module. add_module("flatten", an. Flatten 0)
Seq_module. add_module ("linearl", nn. Linear (in_dim, n _hidden_1))
Seq module. add_module ("bnl", nn. BateShNorm1d(n_hidden_1))
Seq module. add_module ("relul", nn. ReLU)
Seq module. add module ("linear2", nn. Linear (n hidden_ 1, n hidden_ 2))
Seq module. add_module ("bn2", nn. BatchNormid (n_hidden_2))
Seq module. add_module ("relu2", an. ReLUO)
Seg module. add_module ("out", nn. Linear (n _hidden_2, out_dim))
Seq_module. add_module ("softmax", nn. Sof tmax (dim=1)) in_dim, n_hidden_1, n_hidden_2, out_din=28 * 28, 300, 100, 10
print (Seq_module)
Sequential (
(flatten) : Flatten(start_dim=1, end_dim=-1)
(linearl): Linear (in_features=184, out_features=300, bias=True)
(bnl): BatchNormld(300, eps=1e-05, momentum=0.1, affine-True, track_running_stats=True)
(relul) : ReLUO
(linear2) : Linear (in_features=300, out_features=100, bias=True)
(bn2) : BatchWormld (100, eps=1e-05, momentun=0.1, affine=True, track_running_stats=True,
(relu2) : ReLUQ
(out) : Linear (in_features=100, out_features=10, bias=True)
(softmax) : Sof tmax (dim=1)
import torch from torch import nn
from collections import OrderedDict
Seg dict = n. Sequential (OrderedDict ([
("flatten", nn. Flatten), ("linearl", nn. Linear (in_dim, n _hidden_1)),
("bn1", nn. BatchNorm1d(n_hidden_1)),
("relul", nn. ReLUO),
("lineax2", nn. Linear (n_hidden_1, n_hidden_2)),
("bn2", nn. BatchNorm1d(n_hidden_2)),
("relu2", nn. ReLUO), ("out", nn. Linear (n_hidden_2, out_dim)),
("softmax", nn. Softmax (dim=1) )])) in_dim, n_hidden_1, n_hidden_2, out_dim=28 * 28, 300, 100, 10
print (Seq dict)
(flatten) : Flatten (start_dim=1, end_din=-1)
(linearl): Linear (in_features=784, out_features=300, bias=True)
(bnl): BatchNormld BatchNormld(300, eps=1e-05, monentun=0.1, affine=True, track_running_stats=True)
(relul): ReLUO
(linear2) : Linear (in_features=300, out_features=100, bias=True)
(bn2) : BatchNormld (100, eps=le-05, momentun=0.1, affine-True, track_running_stats=True)
(relu2) : ReLU(
(out) : Linear (in_features=100, out_features=10, bias=True)
(softmax) : Softmax (dim=1)
5.继承nn.Module基类并应用模型容器构建模型

 

 

Model_dict (
(layers_dict) : ModuleDict (
(flatten) : Flatten(start_dim=1, end_din=-1)
(linear1) : Linear (in_features=784, out_features=300, bias=True)
(bl): BatchNormld(300, eps=1e-05, momentun=0.1, affine=True, track_running_stats=True)
(relu) : ReLUO
(linear2) : Linear (in_features=300, out_features=100, bias=True)
(bn2) : BatchNormid(100, eps=1e-05, momentun=0.1, affine=True, track_running_stats=True)
(out) : Linear (in_features=100, out_features=10, bias=True)
(softmax)
7.自定义网络模块
·残差块有两种，一种是正常的模块方式，将输入与输出相加，然后应用激活函数ReLU。

Pytorch神经网络工具箱
1.使用nn.Sequential按层顺序构建模型
Seqarg = nn. Sequential (
nn. Flatten, nn. Linear (in_dim, n_hidden_1),
mn. BatchNormid(n_hidden_1),
nn. ReLUO, nn. Linear (n hidden_1, n hidden_2) ,
nn. BatchMormid (n_hidden_2) ,
nn. ReLUO, nn. Linear (n_hidden_2, out_dim),
nh. Sof tmax (din=1)
) in_dim, n_ hidden_1, n _hidden_2, out_dim=28 * 28, 300, 100, 10
print (Sequarg)
(0): Flatten(start_dim=1, end_dim=-1)
(1): Linear (in_features=784, out_features=300, bias=True) (2): BatchNorm1d(300, BatchNorm1d(300, eps=1e-05, momentun=0.1, affine=True,
track_running_stats=True)
(3) : ReLU(
(4): Linear (in_features=300, out_features=100, bias=True)
(5) : BatchNorm1d(100, eps=1e-05, momentun=0.1, affine=True, track_running_stats=True)
(6) : ReLUO
(7): Linear (in_features=100, out_features=10, bias=True)
该方法构建时不能给每个层指定名称,如果需要给每个层指定名称，可使用add_module方法或OrderedDict方法。
Sequential (
Seq module. add_module("flatten", an. Flatten 0)
Seq_module. add_module ("linearl", nn. Linear (in_dim, n _hidden_1))
Seq module. add_module ("bnl", nn. BateShNorm1d(n_hidden_1))
Seq module. add_module ("relul", nn. ReLU)
Seq module. add module ("linear2", nn. Linear (n hidden_ 1, n hidden_ 2))
Seq module. add_module ("bn2", nn. BatchNormid (n_hidden_2))
Seq module. add_module ("relu2", an. ReLUO)
Seg module. add_module ("out", nn. Linear (n _hidden_2, out_dim))
Seq_module. add_module ("softmax", nn. Sof tmax (dim=1)) in_dim, n_hidden_1, n_hidden_2, out_din=28 * 28, 300, 100, 10
print (Seq_module)
Sequential (
(flatten) : Flatten(start_dim=1, end_dim=-1)
(linearl): Linear (in_features=184, out_features=300, bias=True)
(bnl): BatchNormld(300, eps=1e-05, momentum=0.1, affine-True, track_running_stats=True)
(relul) : ReLUO
(linear2) : Linear (in_features=300, out_features=100, bias=True)
(bn2) : BatchWormld (100, eps=1e-05, momentun=0.1, affine=True, track_running_stats=True,
(relu2) : ReLUQ
(out) : Linear (in_features=100, out_features=10, bias=True)
(softmax) : Sof tmax (dim=1)
import torch from torch import nn
from collections import OrderedDict
Seg dict = n. Sequential (OrderedDict ([
("flatten", nn. Flatten), ("linearl", nn. Linear (in_dim, n _hidden_1)),
("bn1", nn. BatchNorm1d(n_hidden_1)),
("relul", nn. ReLUO),
("lineax2", nn. Linear (n_hidden_1, n_hidden_2)),
("bn2", nn. BatchNorm1d(n_hidden_2)),
("relu2", nn. ReLUO), ("out", nn. Linear (n_hidden_2, out_dim)),
("softmax", nn. Softmax (dim=1) )])) in_dim, n_hidden_1, n_hidden_2, out_dim=28 * 28, 300, 100, 10
print (Seq dict)
(flatten) : Flatten (start_dim=1, end_din=-1)
(linearl): Linear (in_features=784, out_features=300, bias=True)
(bnl): BatchNormld BatchNormld(300, eps=1e-05, monentun=0.1, affine=True, track_running_stats=True)
(relul): ReLUO
(linear2) : Linear (in_features=300, out_features=100, bias=True)
(bn2) : BatchNormld (100, eps=le-05, momentun=0.1, affine-True, track_running_stats=True)
(relu2) : ReLU(
(out) : Linear (in_features=100, out_features=10, bias=True)
(softmax) : Softmax (dim=1)
2.继承nn.Module基类并应用模型容器构建模型
 
 
Model_dict (
(layers_dict) : ModuleDict (
(flatten) : Flatten(start_dim=1, end_din=-1)
(linear1) : Linear (in_features=784, out_features=300, bias=True)
(bl): BatchNormld(300, eps=1e-05, momentun=0.1, affine=True, track_running_stats=True)
(relu) : ReLUO
(linear2) : Linear (in_features=300, out_features=100, bias=True)
(bn2) : BatchNormid(100, eps=1e-05, momentun=0.1, affine=True, track_running_stats=True)
(out) : Linear (in_features=100, out_features=10, bias=True)
(softmax)
3.自定义网络模块
·残差块有两种，一种是正常的模块方式，将输入与输出相加，然后应用激活函数ReLU。

Pytorch数据处理工具箱
数据处理工具箱概述
utils.data
·_getitem_一次只能获取一个样本
utils.data
2.DataLoader：可以批量处理。
 语法结构如右所示。
 
data.DataLoader(
   dataset,
   batch_size=1,
   shuffle=False,
   sampler=None,
   batch_sampler=None,
   num_workers=0,
   collate_fn=,
   pin_memory=False,
   drop_last=False,
   timeout=0,
   worker_init_fn=None,
2.DataLoader：可以批量处理。相关参数介绍如下所示。
dataset​加载的数据集。
batch_size​批大小。
shuffle​是否将数据打乱。
sampler​样本抽样。
num_workers​使用多进程加载的进程数，0代表不使用多进程。
collate_fn​如何将多个样本数据拼接成一个batch，一般使用默认的拼接方式即可。
pin_memory​是否将数据保存在锁页内存（pin memory区），其中的数据转到GPU会快一些。
pin_memory​是否将数据保存在锁页内存（pin memory区），其中的数据转到GPU会快一些。
drop_last​dataset 中的数据个数可能不是 batch_size的整数倍，drop_last为True会将多出来不足一个batch的数据丢弃。
2.DataLoader：可以批量处理
但是DataLoader并不是迭代器，
可以通过“iter”命令转换成迭代器。
但是！数据处在不同目录之下时会不方便！
 
 
 
transforms
 
transforms提供了对PIL Image对象和Tensor对象的常用操作。 
1） 对PIL Image的常见操作如下。
2） Scale/Resize​调整尺寸，长宽比保持不变。
3） CenterCrop、RandomCrop、RandomSizedCrop​裁剪图像。
4） Pad​填充。
5） ToTensor​把一个取值范围是[0,255]的PIL.Image转换成Tensor。
6） RandomHorizontalFlip​图像随机水平翻转
7） RandomVerticalFlip​图像随机垂直翻转。
8） ColorJitter​修改亮度、对比度和饱和度。
9） transforms提供了对PIL Image对象和Tensor对象的常用操作。 
 
对Tensor的常见操作如下。
·如果要对数据集进行多个操作，可通过Compose将这些操作像管道一样拼接起来，类似于nn.Sequential。
transforms提供了对PIL Image对象和Tensor对象的常用操作。 
ImageFolder可以读取不同目录下的图像数据、
ImageFolder可以读取不同目录下的图像数据
使用TensorBoard的一般步骤如下。
2）调用相应的API接口，接口一般格式为：
add_xxx(tag-name, object, iteration-number)
#即add_xxx(标签，记录的对象，迭代次数)
其中，xxx指的是各种可视化方法。
各种可视化方法如下表所示。
Scalar​用于可视化单一数值，例如损失值、准确率等随训练过程的变化。
Image​用于可视化图像数据。
Figure​用于可视化图形或复杂的图表。
Histogram​用于可视化数据的分布。
Audio​用于可视化音频数据。
Text​用于可视化文本数据，例如模型生成的文本或训练日志。
 
·各种可视化方法如下表所示。
Graph​用于可视化计算图结构。
ONNX Graph​用于可视化 ONNX 模型的计算图结构。ONNX 是开放神经网络交换格式。
Embedding​用于可视化高维数据的低维表示。例如，t-SNE 或 PCA 降维后的词向量或特征。
PR Curve​用于可视化精确度-召回率曲线
Video Summaries​用于可视化视频数据
使用TensorBoard的一般步骤如下。
3）启动tensorboard服务。cd到logs目录所在的同级目录，在命令行输入如下命令，logdir等式右边可以是相对路径或绝对路径。
tensorboard --logdir=logs --port 6006   
#如果是windows环境，要注意路径解析，如
#tensorboard --logdir=r'D:\myboard\test\logs' --port 6006
4）Web展示。在浏览器输入：
http://服务器IP或名称:6006  #如果是本机，服务器名称可以使用localhost
用TensorBoard可视化神经网络

图像分类项目
1.图像分类
· 将不同的图像，划分到不同的类别标签，实现最小的分类误差。
2.图像分类的三层境界
通用的多类别图像分类
子类细粒度图像分类
实例级图片分类
3.图像分类评估指标之混淆矩阵
TP（True positive,真正例）——将正类预测为正类数。
FP（False postive,假正例）——将反类预测为正类数。
TN（True negative,真反例）——将反类预测为反类数。
FN（False negative,假反例）——将正类预测为反类数。
4.图像分类评估指标
精确率(Accuracy)：精确率是最常用的分类性能指标。可以用来表示模型的精度，即模型识别正确的个数/样本的总个数。一般情况下，模型的精度越高，说明模型的效果越好。

准确率(Precision)：又称为查准率，表示在模型识别为正类的样本中，真正为正类的样本所占的比例。

召回率(Recall)：又称为查全率，表示模型正确识别出为正类的样本的数量占总的正类样本数量的比值。

F1_Score：它被定义为正确率和召回率的调和平均数。

P-R曲线：
 
·召回率增加，精度下降。
 
·曲线和坐标轴面积越大，模型越好。
 
·对正负样本不均衡敏感。
横坐标falsepositiverate（FPR）：
FPR=FP/(FP+ TN)
正类中实际负实例占所有负实例的比例。
纵坐标truepositiverate（TPR）：
TPR=TP/(TP+ FN)
正类中实际正实例占所有正实例的比例。 正负样本的分布变化，ROC曲线保持不变，
对正负样本不均衡问题不敏感。
多类别分类模型各个类别之间的分类情况
对于k分类问题，混淆矩阵为k*k的矩阵，元素Cij表示第i类样本被分类器判定为第j类的数量。
主对角线的元素之和为正确分类的样本数，其余元素之和为错误分类的样本数。对角线的值越大，分类器准确率越高。
5.模型基本概念-网络的深度
深度学习最重要的属性，计算最长路径的卷积层+全连接层数量。LeNet网络，C1+C3+C5+F6+Output共5
6.模型基本概念-网络的宽度
每一个网络层的通道数，以卷积网络层计算。
 LeNet网络，C1(6),C3(16)。
7.图像分类中样本量过少的问题
样本量极少：样本获取较难导致总体样本量过少。
8.样本量过少的解决方案1
迁移学习：使用预训练模型。
 ImageNet数据集具有通用性，使用它进行预训练可加速模型收敛
9.样本量过少的解决方案2
数据增强(有监督方法与无监督方法)
有监督方法：平移、翻转、亮度、对比度、裁剪、缩放等。
无监督方法：通过GAN网络生成所需样本，然后再进行训练。

The CIFAR-10 and CIFAR-100 datasets are labeled subsets of the 80 million tiny images dataset. CIFAR-10 and CIFAR-100 were created by Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. (Sadly, the 80 million tiny images dataset has been thrown into the memory hole by its authors. Spotting the doublethink which was used to justify its erasure is left as an exercise for the reader.)
The CIFAR-10 dataset
The CIFAR-10 dataset consists of 60000 32x32 colour images in 10 classes, with 6000 images per class. There are 50000 training images and 10000 test images.
The dataset is divided into five training batches and one test batch, each with 10000 images. The test batch contains exactly 1000 randomly-selected images from each class. The training batches contain the remaining images in random order, but some training batches may contain more images from one class than another. Between them, the training batches contain exactly 5000 images from each class.
Here are the classes in the dataset, as well as 10 random images from each:
airplane                                        
automobile                                        
bird                                        
cat                                        
deer                                        
dog                                        
frog                                        
horse                                        
ship                                        
truck                                        
The classes are completely mutually exclusive. There is no overlap between automobiles and trucks. "Automobile" includes sedans, SUVs, things of that sort. "Truck" includes only big trucks. Neither includes pickup trucks.
Download
If you're going to use this dataset, please cite the tech report at the bottom of this page.
Version    Size    md5sum
CIFAR-10 python version    163 MB    c58f30108f718f92721af3b95e74349a
CIFAR-10 Matlab version    175 MB    70270af85842c9e89bb428ec9976c926
CIFAR-10 binary version (suitable for C programs)    162 MB    c32a1d4ab5d03f1284b67883e8d87530
Baseline results
You can find some baseline replicable results on this dataset on the project page for cuda-convnet. These results were obtained with a convolutional neural network. Briefly, they are 18% test error without data augmentation and 11% with. Additi

class correct =list(0. for i in range(10))class total=list(0.for i in range(10))with torch.no grad():for data in testloader:
images, labels= data
images, labels=images.to(device),labels.to(device
outputs =net(images),predicted=torch.max(outputs,1)c=(predicted == labels).squeeze()for i in range(4):label = labels[i]class correct[label]+= c[i].item()class total[label]+=1
for i in range(10):
of %5s :%2d %%’%(print( Accuracyclasseslil.100 * class correctli]/class total[i]))
correct=0
total=0
with torch.no grad():for data in testloader:
images, labels=data
images, labels=images.to(device), labels.to(device
outputs =net(images)
，predicted=torch.max(outputs.data, 1)total += labels.size(0)correct +=(predicted == labels).sum().item()
print( Accuracy of the network on the 10000 test images: %d %%100 * correct / total))
Accuracy of the network on the 10000 test images: 66 %
1mages,outputs =net(images)，predicted =torch.max(outputs, 1)print( Predicted:.join('%5s’% classeslpredicted[j]lfor j in range(4)))
Predicted:frog dog deer horse
print( net gvp have if paramerters in total",format(sum(x,numel() for x in net,parameters()))
net gvp have 16022 paramerters in total
for epoch in range(10):
rumming 1oss =0.0for i,data in enuerate(trainloader,0):黄获取训练数据
inputs,labels= data
inputs,labels= inputs.to(device),labels.to(device
#根重爹数梯皮清零
optimizer.zero grad()
黄正向延区向传播
outputs =net(inputs)
1oss =criterion(outputs,labels)
loss.backward()
optimizer.step(
#显示损失值
rumning loss += loss.item()
if i % 2000 == 1999:# print every 2000 mini-batchesprint( [%d,%5d]1oss:%.3f’%(epoch+ 1,i+ 1, rumning loss / 2000))rumming 1oss =0.0
print( Finished Training

1.集成算法的简介
对于一个复杂任务来说，将多个专家的判断进行适当的综合所得出的判断，要比其中任何一个专家单独的判断好。
集成学习(ensemble learning)通过构建并结合多个学习器来完成学习任务等。
·结合策略
①简单平均法

②加权平均法
集成学习的结果通过投票法产生?即“少数服从多数”
2.集成算法的分类
·根据个体学习器的生成方式，目前的集成学习方法大致可以分为两类：
①Bagging：个体学习器间不存在强依赖关系、可同时生成的并行化方法，代表为随机森林。
②Boosting：个体学习器间存在强依赖关系、必须串行生成的序列化方法，如Adaboost。
③Stacking：聚合多个分类或回归模型（可以分阶段来做）
3. 集成算法 · Bagging
Bagging：训练多个分类器取平均。

全称：bootstrap aggregation（说白了就是并行训练一堆分类器）
    
预测输出时，通常对分类任务使用简单投票法，对回归任务使用简单平均法。
·随机森林：
随机：数据采样随机，特征选择随机。
森林：很多个决策树并行放在一起。
·构造树模型：由于二重随机性，使得每个树基本上都不会一样，最终的结果也会不一样。
随机森林优势：
①它能够处理很高维度（feature很多）的数据，并且不用做特征选择
②在训练完后，它能够给出哪些feature比较重要
③容易做成并行化方法，速度比较快
④可以进行可视化展示，便于分析
RandomForestClassifier()：随机森林分类算法
RandomForestRegressor()：随机森林回归算法
n_estimators    树的数量，默认100
oob_score    是否采用Out of Bag评估方式，默认False。=True时，等同于使用交叉验证评估模型。
bootstrap    是否采用有放回的采样方式，默认True
max_samples    训练树的最大样本量，默认为None。
rom sklearn.datasets import load_wine
4.集成算法 · Boosting
用随机森林实现葡萄酒分类。
·Boosting：从弱学习器开始加强，通过加权来进行训练。
典型代表：AdaBoost
Adaboost会根据前一次的分类效果调整数据权重
解释：如果某一个数据在这次分错了，那么在下一次我就会给它更大的权重
最终的结果：每个分类器根据自身的准确性来确定各自的权重，再合体
1. 初始化训练样本的权值分布，每个样本具有相同权重；
2. 训练弱分类器，如果样本分类正确，则在构造下一个训练集中，它的权值就会被降低；反之提高。
3. 用更新过的样本集去训练下一个分类器；
4. 将所有弱分类组合成强分类器，各个弱分类器的训练过程结束后，加大分类误差率小的弱分类器的权重，降低分类误差率大的弱分类器的权重。
5. 集成算法 · Stacking
·堆叠：很暴力，拿来一堆直接上（各种分类器都来了）
·可以堆叠各种各样的分类器（KNN,SVM,RF等等）
·分阶段：第一阶段得出各自结果，第二阶段再用前一阶段结果训练