第一周学习：深度学习与pytorch基础代码实战
目录
part1：理论视频学习
一.人工智能和深度学习概述
1.人工智能定义及其三个层面
2.机器学习
2.1 机器学习定义
2.2 机器学习过程
2.2.1 模型分类
二 .深度学习概述
1.人工智能、机器学习、深度学习之间的关系
2.深度学习的不能
3.浅层神经网络
3.1激活函数
3.2万有逼近定理与神经网络
3.3更宽or更深
3.4反向传播误差
3.5梯度消失
part2：代码练习
一.pytorch基础练习
1.定义数据
2.定义操作
二.螺旋曲线分类
2.2构建线性模型分类
2.3两层神经网络分类
小结
part1：理论视频学习
一.人工智能和深度学习概述
1.人工智能定义及其三个层面
人工智能(Artificial Intelligence) 使一部机器像人一样进行感知、认知、决策、执行的人工程序或系统。
计算智能：能进行存储和计算
感知智能：具备类似于人的视觉、听觉、触觉等感知能力，能听会说，能看会认
认知智能：实现类似于人的认知能力，能理解、会思考、能产生对策，概念、意识、观念都是认知智能的表现
2.机器学习
2.1 机器学习定义
最常用定义：计算机系统能够利用经验提高自身的性能
可操作定义：机器学习本质是一个基于经验数据的函数估计问题
统计学定义：提取重要模式、趋势，并理解数据，即从数据中学习
总之，机器学习就是从数据中自动提取知识的过程
2.2 机器学习过程
2.2.1 模型分类
数据标记：监督学习模型、非监督学习模型
数据分布：参数模型、非参数模型
建模对象：判别模型、生成模型
数据标记
无监督学习：样本没有标记。无监督学习从数据中学习模式，适用于描述数据，目的在于发现数据中模式/有意义信息。
监督学习：样本具有标记(输出目标)。监督学习从数据中学习标记分界面 (输入-输出的映射函数)，适用于预测数据标记。
半监督学习：部分数据标记已知，是监督学习和无监督学习的混合。
强化学习：数据标记未知，但 知道与输出目标相关的反馈，适用决策类问题。
数据分布
参数模型： 对数据分布进行假设，待求解的数据模式/映射可以用一组有限且固定数目 的参数进行刻画 。
非参数模型： 不对数据分布进行假设，数据的所有统计特性都来源于数据本身。
| 参数模型 | 非参数模型 | |
| 优点 | 数据需求少、训练快速 | 对数据适应性强，可拟合不同的函数形式 |
| 缺点 | 模型复杂度有限，与真实目标函数拟合度小 | 数据需求大、容易过拟合 |
建模对象
生成模型： 对输入和输出的联合分布(, )建模
判别模型： 对已知输入条件下输出Y的条件分布(|) 建模
| 生成模型 | |
| 优点 | 提供更多信息（建模边缘分布-->采样生成样本） 样本量大时，更快收敛到真实分布 支持复杂训练情况（无监督训练、存在隐变量时） |
| 缺点 | 数据需求大 预测类问题准确率通常不如判别模 |
二 .深度学习概述
1.人工智能、机器学习、深度学习之间的关系
人工智能>机器学习>深度学习
2.深度学习的不能
1.算法输出不稳定，容易被“攻击”（对抗样本，单像素攻击）
2.模型复杂度高，难以纠错和调试
3.模型层级复合程度高，参数不透明
4.端到端训练方式对数据依赖性强，模型增量性差（小样本问题）
5.专注直观感知类问题，对开放性推理问题无能为力
6.人类知识无法有效引入进行监督，机器偏见难以避免
3.浅层神经网络
3.1激活函数
激活函数 ： 神经元继续传递信息、产生 新连接的概率（超过阈值被 激活，但不一定传递）
没有激活函数相当于矩阵相乘 ，通过激活函数可以实现非线性拟合。
常见激活函数 ：
3.2万有逼近定理与神经网络
万有逼近定理：如果一个隐层包含足够多的神经元，三层前馈神经网络（输入-隐层 -输出）能以任意精度逼近任意预定的连续函数。
神经网络每一层的数学公式
神经网络学习如何利用矩阵的线性变换加激活函数的非线性变换， 将原始输入空间投影到线性可分的空间去分类/回归。
增加节点数：增加维度，即增加线性转换能力。
增加层数：增加激活函数的次数，即增加非线性转换次数
3.3更宽or更深
在神经元总数相当的情况下，增加网络深度可以比增加宽度带来更强的网络表示能力：产生更多的线性区域。
深度和宽度对函数复杂度的贡献是不同的，深度的贡献是指数增长的，而宽度的贡献是线性的.
3.4反向传播误差
3.5梯度消失
由于误差通过梯度传播，当梯度变得接近于0时，由于反向传播将与梯度相乘，得到的新梯度也接近为0，会使得梯度消失，误差无法传播，使数据得不到及时更新。
part2：代码练习
一.pytorch基础练习
1.定义数据
一般定义数据使用torch.Tensor ， tensor的意思是张量，是数字各种形式的总称
import torch
# tensor(data: Any, dtype: Optional[_dtype]=None, ... , requires_grad: _bool=False)
# 可以看出，data是任意数据，可以为一个数，一个list,二维数组等等
x = torch.tensor(666) # 标量
print(x) # tensor(666)
x = torch.tensor([2, 2], dtype=float) # 一维张量
print(x) # tensor([2., 2.], dtype=torch.float64)
x = torch.tensor([[2, 3], [4, 5]]) # 二维数组
print(x)
# tensor([[2, 3],
# [4, 5]])# torch.ones()函数可以生成多维矩阵，矩阵元素初始化全为1
x = torch.ones(2, 3) # 二维数组
print(x)
x = torch.ones(5) #一维
print(x)
x = torch.ones(2, 3, 4) # 三维
print(x)
# tensor([[1., 1., 1.],
# [1., 1., 1.]])
# tensor([1., 1., 1., 1., 1.])
# tensor([[[1., 1., 1., 1.],
# [1., 1., 1., 1.],
# [1., 1., 1., 1.]],
# [[1., 1., 1., 1.],
# [1., 1., 1., 1.],
# [1., 1., 1., 1.]]])# torch.empty() 创建空矩阵，内容未进行初始化，使用时要进行数据初始化
x = torch.empty(2, 3) # 2*3矩阵
print(x)
# tensor([[1.6209e-19, 1.8319e+25, 5.9423e-02],
# [7.0374e+22, 1.6907e-01, 1.7743e+28]])
#torch.zeros() 与torch.ones()类似，区别是内容初始化为0
x = torch.zeros(1, 3, 3, dtype=torch.long) # 创建1*3*3的三维向量
print(x)
# tensor([[[0, 0, 0],
# [0, 0, 0],
# [0, 0, 0]]])
x1 = torch.rand(2, 4) # 2*4的随机数(0--1随机)
print(x)
x2 = torch.randn(2, 5)# 2*5符合正态分布的随机数
print(x)
# tensor([[0.8069, 0.9762, 0.6335, 0.5133],
# [0.4084, 0.9876, 0.6013, 0.4617]])
# tensor([[-1.4031, 0.2296, 0.6661, 0.6075, -0.0034],
# [-0.1969, 1.7592, -0.1239, -1.6503, -0.9498]])# 利用原有的tensor创建新tensor，可以利用dtype，device，size等属性信息
x = torch.zeros(2, 3, dtype=int)
print("x:{}".format(x))
y = x.new_ones(2, 3)
print("y:{}".format(y))
# x:tensor([[0, 0, 0],
# [0, 0, 0]])
# y:tensor([[1, 1, 1],
# [1, 1, 1]])
# 利用之前tensor的大小，重新定义dtype
z = torch.randn_like(x, dtype=torch.float)
print("z:{}".format(z))
# z:tensor([[-0.8123, 0.0407, 0.4976],
# [1.7102, 2.0772, 0.4945]])
2.定义操作
凡是用Tensor进行各种运算的，都是Function
最终，还是需要用Tensor来进行计算的，计算无非是
- 基本运算，加减乘除，求幂求余
- 布尔运算，大于小于，最大最小
- 线性运算，矩阵乘法，求模，求行列式
基本运算包括： abs/sqrt/div/exp/fmod/pow ，及一些三角函数 cos/ sin/ asin/ atan2/ cosh，及 ceil/round/floor/trunc 等具体在使用的时候可以百度一下
布尔运算包括： gt/lt/ge/le/eq/ne，topk, sort, max/min
线性计算包括： trace, diag, mm/bmm，t，dot/cross，inverse，svd 等
import torch
s = torch.tensor([[1, 3, 5, 7], [2, 4, 6, 8]])
print(s.size(0), s.size(1), s.size(), sep="---")
# 2---4---torch.Size([2, 4])
print(s.numel()) # s中元素个数
# 8
print(s[0][2]) # s的第0行第2列元素（从0开始）
# tensor(5)
print(s[:, 1]) # s第一列所有元素
# tensor([3, 4])
print(s[1, :]) # s第一行所有元素
# tensor([2, 4, 6, 8])
t = torch.arange(1, 5) # 生成2从1——5不包括5公差为1的序列
print(t)
# tensor([1, 2, 3, 4])
print(s @ t) # 两矩阵叉乘
# tensor([50, 60])
print(s[0, :] * t) # *表示对应两两相乘
# tensor([ 1, 6, 15, 28])
print(s[0, :] @ t) # @表示矩阵叉乘
# tensor(50)
print(s + torch.rand(2, 4)) # s矩阵加上一个2*4随机矩阵
# tensor([[1.5769, 3.6351, 5.5506, 7.0818],
# [2.9022, 4.8702, 6.7515, 8.1953]])
print(s.t()) # 矩阵转置
# tensor([[1, 2],
# [3, 4],
# [5, 6],
# [7, 8]])
print(s.transpose(0, 1)) # transpose函数内参数为带转置的两个维度
# tensor([[1, 2],
# [3, 4],
# [5, 6],
# [7, 8]])
# 从3到8生成20个符合等差数列的数 start:3，end:8，step:20
r = torch.linspace(3, 8, 20)
print(r)
# tensor([3.0000, 3.2632, 3.5263, 3.7895, 4.0526, 4.3158, 4.5789, 4.8421, 5.1053,
# 5.3684, 5.6316, 5.8947, 6.1579, 6.4211, 6.6842, 6.9474, 7.2105, 7.4737,
# 7.7368, 8.0000])
# 创建两个1*4的tensor
a = torch.tensor([[1, 2, 3, 4]])
b = torch.tensor([[4, 3, 2, 1]])
print(torch.cat((a, b), 0)) # 从第0维上拼接
# tensor([[1, 2, 3, 4],
# [4, 3, 2, 1]])
print(torch.cat((a, b), 1)) # 从第1维上拼接
# tensor([[1, 2, 3, 4, 4, 3, 2, 1]])
from matplotlib import pyplot as plt
# matlabplotlib 只能显示numpy类型的数据，下面展示了转换数据类型，然后显示
# 注意 randn 是生成均值为 0， 方差为 1 的随机数
# 下面是生成 1000 个随机数，并按照 100 个 bin 统计直方图
plt.hist(torch.randn(1000).numpy(), 100, color='k')
plt.show() 
# 当数据非常非常多的时候，正态分布会体现的非常明显
plt.hist(torch.randn(10**6).numpy(), 100,color='k')
plt.show()
二.螺旋曲线分类
引入基本的库，然后定义参数
初始化 X 和 Y。 X 可以理解为特征矩阵，Y可以理解为样本标签。 结合代码可以看到，X的为一个 NxC 行， D 列的矩阵。C 类样本，每类样本是 N个，所以是 N*C 行。每个样本的特征维度是2，所以是 2列。
在 python 中，调用 zeros 类似的函数，第一个参数是 y方向的，即矩阵的行；第二个参数是 x方向的，即矩阵的列，大家得注意下，不要搞反了。下面结合代码看看 3000个样本的特征是如何初始化的。
X = torch.zeros(N * C, D).to(device)
Y = torch.zeros(N * C, dtype=torch.long).to(device)
for c in range(C):#C与c不同
index = 0
t = torch.linspace(0, 1, N) # 在[0，1]间均匀的取1000个数，赋给t
# 根据公式计算出三类样本（可以构成螺旋形）
# torch.randn(N) 是得到 N 个均值为0，方差为 1 的一组随机数，注意要和 rand 区分开
inner_var = torch.linspace( (2*math.pi/C)*c, (2*math.pi/C)*(2+c), N) + torch.randn(N) * 0.2
# 每个样本的(x,y)坐标都保存在 X 里
# Y 里存储的是样本的类别，分别为 [0, 1, 2]
for ix in range(N * c, N * (c + 1)):
X[ix] = t[index] * torch.FloatTensor((math.sin(inner_var[index]), math.cos(inner_var[index])))
Y[ix] = c
index += 1
print("Shapes:")
print("X:", X.size())
print("Y:", Y.size())显示图像
2.2构建线性模型分类
learning_rate = 1e-3
lambda_l2 = 1e-5
# nn 包用来创建线性模型
# 每一个线性模型都包含 weight 和 bias
model = nn.Sequential(
nn.Linear(D, H),
nn.Linear(H, C)
)
model.to(device) # 把模型放到GPU上
# nn 包含多种不同的损失函数，这里使用的是交叉熵（cross entropy loss）损失函数
criterion = torch.nn.CrossEntropyLoss()
# 这里使用 optim 包进行随机梯度下降(stochastic gradient descent)优化
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, weight_decay=lambda_l2)
# 开始训练
for t in range(1000):
# 把数据输入模型，得到预测结果
y_pred = model(X)
# 计算损失和准确率
loss = criterion(y_pred, Y)
score, predicted = torch.max(y_pred, 1)
acc = (Y == predicted).sum().float() / len(Y)
print('[EPOCH]: %i, [LOSS]: %.6f, [ACCURACY]: %.3f' % (t, loss.item(), acc))
display.clear_output(wait=True)
# 反向传播前把梯度置 0
optimizer.zero_grad()
# 反向传播优化
loss.backward()
# 更新全部参数
optimizer.step()
精确度只有50%左右
print(y_pred.shape)
print(y_pred[10, :])
print(score[10])
print(predicted[10]) 
# Plot trained model
print(model)
plot_model(X, Y, model)
2.3两层神经网络分类
ReLu函数作为激活函数
learning_rate = 1e-3
lambda_l2 = 1e-5
# 这里可以看到，和上面模型不同的是，在两层之间加入了一个 ReLU 激活函数
model = nn.Sequential(
nn.Linear(D, H),
nn.ReLU(),
nn.Linear(H, C)
)
model.to(device)
# 下面的代码和之前是完全一样的，这里不过多叙述
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=lambda_l2) # built-in L2
# 训练模型，和之前的代码是完全一样的
for t in range(1000):
y_pred = model(X)
loss = criterion(y_pred, Y)
score, predicted = torch.max(y_pred, 1)
acc = ((Y == predicted).sum().float() / len(Y))
print("[EPOCH]: %i, [LOSS]: %.6f, [ACCURACY]: %.3f" % (t, loss.item(), acc))
display.clear_output(wait=True)
# zero the gradients before running the backward pass.
optimizer.zero_grad()
# Backward pass to compute the gradient
loss.backward()
# Update params
optimizer.step()
使用ReLu作为激活函数，精确度达到了95.8%
如果使用sigmoid（）作为激活函数
model = nn.Sequential(
nn.Linear(D, H),
nn.Sigmoid(),
nn.Linear(H, C)
)
model.to(device)
可以看出，精确度与ReLu函数相比，Sigmoid函数精确度只有50.3%
LeakyRelu()作为激活函数
model = nn.Sequential(
nn.Linear(D, H),
nn.LeakyReLU(),
nn.Linear(H, C)
)
model.to(device) 
LeakyReLu函数的精确度为94.4%
tanh()作为激活函数
model = nn.Sequential(
nn.Linear(D, H),
nn.Tanh(),
nn.Linear(H, C)
)
model.to(device)
Tanh激活函数的精确度为83.6%
增加隐层使用两层sigmoid（）函数
model = nn.Sequential(
nn.Linear(D, H),
nn.Sigmoid(),
nn.Linear(H, 60),
nn.Sigmoid(),
nn.Linear(60, C)
)
增加隐层多用一次Sigmoid函数的精确度为97.0%
不同的激活函数对比:
| Loss | Accuracy | |
| 无激活函数 | 0.869014 | 0.494 |
| ReLu | 0.161963 | 0.958 |
| Simoid | 0.763233 | 0.503 |
| LeakyReLu | 0.181599 | 0.944 |
| Tanh | 0.317361 | 0.836 |
| 两层Sigmoid | 0.131681 | 0.970 |
小结
Sigmoid（）函数作为激活函数如果只嵌套一层相比于ReLu等其他的激活函数则其精确度较弱，但如果增加隐层再次使用Sigmoid函数，那么其精确度会大幅度上升，不同的激活函数会有不同的精准度，使用时应该多尝试，哪个效果好用哪个。