pytorch（2）手写数字识别引入&Pytorch 数据类型

一、系列文章目录

（1）梯度下降
（2）手写数字识别引入&Pytorch 数据类型
（3）创建Tensor
（4）Broadcasting
（5）Tensor
（6）Tensor统计
（7）Where和Gather
（8）函数的梯度
（9）loss函数；自动求导

---

---

二、手写数字识别

1.MNIST数据集

10种数字0~9，每种数字有7000张图片，70k张图，每张图尺寸为28x28
train/test splitting ：把这些图分为60k训练集和10k测试集。

把一张灰度图表示为一个28x28的矩阵，元素为像素值，范围0~1。打平成一维，是28x28=784个元素的向量。
类比简单线性问题y=wx+b，在手写数字识别问题中，x是[784]向量，y是0~9这些数字，但是不能用数字表示，因为这样数字间会存在大小关系,用one hot 编码。

2.one hot 编码

1 → [0,1,0,0,0,0,0,0,0,0]
2 → [0,0,2,0,0,0,0,0,0,0]
……
9 →[0,0,0,0,0,0,0,0,0,9]

嵌套模板

X = [v1，v2，……，v784]	X是1行，784列
H1 = XW1 T+ b1	W1是d1行，784列	H1是1行，d1列
H2 = H1W2 T+ b2	W2是d2行，d1列	H2是1行，d2列
H3 =H2 W3 T+ b3	W3是d3行，d2列	H3是1行，d3列

在这里H₃ 是1行10列

怎么计算loss呢？
假设得到一个H₃^’=[0.1，0.8，0.01，……，0]（意思是，识别的这个数字是0的概率为0.1，即P(X=0|X) = 0.1，是1 的概率为0.8，……，是9的概率为0）

而真实值是H₃=[0，1，……，0] （该数字是1）
计算欧氏距离的平方作为loss，方法同二维一样

Non-linear Factor
虽然加了嵌套，但线性模型还是不能很好的完成识别任务，因此要加一个非线性部分。包括著名的relu函数、sigmoid函数

Relu函数：比0小的值都记为0

这样H₁ = Relu（XW₁ ^T+ b₁ ）

pred = H₃ = [(XW₁ ^T+ b₁ )W₂ ^T+ b₂]W₃ ^T+ b₃
(每层都有Relu函数，没写出来)

怎么得到预测值

假设得到 H₃^’=[0.1，0.8，0.01，……，0]

max(pred) = 0.8 ； argmax(pred) = 1（得到其索引号)

3.pytorch数据类型

张量 Tensor
python中的string，在pytorch中内部没有自带的表示方法。于是用 One-hot 或 Embedding
所谓One-hot 就是用一组数字表示string，处理字母还不错
但是处理一句话这种复杂问题，用onehot会出现很多0，编码特别系稀疏，而且不能很好的区分Ilike和Ilove这类相关性的语义，这就用到了Embedding，包括Word2vec和glove。（没有讲具体怎么用，just科普。。）

pytorch中同一个数据放在不同位置类型可能不同，例如CPU中是torch.DoubleTensor，而GPU中是torch.cuda.DoubleTensor

类型推断

>>> import torch
>>> a = torch.randn(2,3)   #初始化一个2行3列的Tensor，随即正态分布，N(0，1)
>>> a.type()
'torch.FloatTensor'
>>> type(a)
<class 'torch.Tensor'>
>>> isinstance(a, torch.FloatTensor) #注意大小写哦
True

Dimension为0——标量(在pytorch0.3以前这种标量不存在，会用长度为1的向量来表示)

例 ：loss

>>> torch.tensor(1.)
tensor(1.)
>>> torch.tensor(1.3)
tensor(1.3000)

Dimension为1——向量

例 ：Bias & Linear Input

>>> torch.tensor([1.1]) #.tensor 指定具体数据
tensor([1.1000])
>>> torch.tensor([1.1,2.2])
tensor([1.1000, 2.2000])
>>> torch.FloatTensor(1)#.FloatTensor 指定长度即可
tensor([1.4013e-45])

用numpy生成向量

>>> import numpy as np
>>> data = np.ones(2)  #长度为2
>>> data
array([1., 1.])
>>> torch.from_numpy(data)
tensor([1., 1.], dtype=torch.float64)

Dimension为2

例 : linear input batch

 a = torch.randn(2,3) #两个向量，每个向量三个元素
>>> a
tensor([[ 0.1278, -0.0195, -0.6048],
        [ 1.9171, -1.5575, -0.7346]])

• .shape
• .size （）
• .dtype 每个元素的数据类型

>>> a.size()  #几行几列
torch.Size([2, 3])
>>> a.size(0) #行数
2
>>> a.size(1)#列数
3

Dimension为3

例 ：RNN Input Batch
10个词，每个词用100维向量onehot编码。一次送入20句话。[10,20,100]

>>> a = torch.rand(1,2,3)  # 均匀分布  1个二维，2行3列
>>> a
tensor([[[0.4427, 0.4094, 0.5362],
         [0.8530, 0.9553, 0.8837]]])

>>> b = torch.rand(2,3,4)  #  2个二维，3行4列
>>> b
tensor([
		[[0.8693, 0.4930, 0.1753, 0.0178],
         	[0.1094, 0.0488, 0.6811, 0.1096],
         	[0.6810, 0.0232, 0.4389, 0.2236]],
         
		 [[0.1498, 0.3657, 0.7056, 0.3712],
        	 [0.8516, 0.6231, 0.6993, 0.9023],
        	 [0.1346, 0.4388, 0.3456, 0.4780]]
         						])

Dimension为3

例 ：CNN Input [b,c,h,w]

>>> c = torch.rand(2,3,4,5)  #  2个 3个二维的，4行5列
>>> c
tensor([
	      [
		[[0.5392, 0.1227, 0.4322, 0.6111, 0.0510],
        	 [0.2036, 0.3861, 0.5874, 0.8121, 0.2122],
          	 [0.4505, 0.6176, 0.4609, 0.5874, 0.8680],
         	 [0.2151, 0.2715, 0.1207, 0.5023, 0.6157]],
          
	         [[0.4368, 0.8560, 0.8352, 0.5122, 0.2710],
                  [0.4357, 0.6816, 0.5046, 0.8598, 0.9712],
                  [0.6830, 0.8281, 0.0184, 0.0172, 0.7933],
                  [0.9043, 0.5431, 0.7087, 0.3712, 0.7319]],
          
	        [[0.8600, 0.5627, 0.7063, 0.1658, 0.3914],
                [0.1920, 0.6904, 0.2216, 0.4201, 0.0345],
                [0.3745, 0.4559, 0.5951, 0.5464, 0.9667],
                [0.8550, 0.7814, 0.1153, 0.0309, 0.6290]]
                                                            ],
                   …………
      								])