2.预备知识-3GPT版
#pic_center
R 1 R_1 R1
R 2 R^2 R2
目录
- 知识框架
- No.1 数据操作数据预处理
-
- 一、N维数组样例
- 二、创建数组
- 三、访问元素
- 四、数据操作D2L注意点
- 五、数据预处理D2L注意点
- 六、QA
- No.2 线性代数
-
- 一、标量
- 二、向量
-
- 1、基本操作
- 2、空间表示
- 3、乘法
- 三、矩阵
-
- 1、基本操作
- 2、乘法
- 3、空间表示
- 4、乘法
- 5、范数
- 6、特殊矩阵
- 7、特征向量
- 四、D2L注意点：
-
- 1、矩阵克隆
- 2、矩阵降维
- 五、QA
- No.3 矩阵计算
-
- 一、标量导数
- 二、亚导数
- 三、梯度
-
- 1、y是标量，x是向量
- 2、y是向量，x是标量
- 3、y和x均是向量
- 4、y和x均是矩阵
- 四、QA
-
- 1、导数作用
- 2、自动微分和计算图
- No.4 自动求导
-
- 一、向量链式法则
- 二、自动求导
- 三、计算图
- 四、自动求导的两种模式
- 五、反向累积
- 六、D2L注意点
-
- 1、梯度存储问题
- 2、求导问题
- 七、QA
知识框架
No.1 数据操作数据预处理
一、N维数组样例
- 最基础的数据结构
- 从基础开始数据操作;机器学习用的最多的数据结构是n维数组;这是所有的机器学习,神经网络;以及深度学习用的主要的数据结构;
- 最简单是一个0位的数字叫做标量;比如说最简单就是一个1.0;一个浮点运算;它可能表示一个物体的类别;
- 一维的数组叫做向量;比如说这有三个数字;它是一个特征;比如说一个特征向量就是一个样本;把它抽象成一行数字;
- 2D就是一个矩阵;这里有3行3列;就说可以是一个样本的特征矩阵;要是三个样本;每一行表示一个样本;每一列就表示它不同的特征;
- 高纬度数组样例
- 3D就是一张图片;RGB的图片是一个三维的数组;因为它有宽度;宽其实是列的个数；高就是你的有多少行;还有r g b三个通道;所以它是一个三维的一个数组;
- 四维就是;n个三维的数组放在一起;比如说一个RGB图片的批量;在深度学习的训练的时候;通常不是一张一张图片去读;通常是比如说每次读128张图片;那就是一个batch(一个批量);
- 数组可以做到五维;现在用的会比较少;比如说一个视频的批量;做视频其实是说很多图片;但是还有个时间的维度;所以是一个批量大小✖时间✖宽高和通道的一个5D的数字;
二、创建数组
- 创建数组需要给三个东西
- 一个是什么样的形状;比如说一个3*4的一个矩阵;
- 要指定每一个元素的数据类型;比如说一个32位的浮点运算;32位的浮点数;
- 然后要告诉每个元素的值;比如说可以全是0;或者可以全是一个随机数;
- 下面这两张图表示;左边是说;所有的元素的值;是按照一个正态分布表示的;右边是一个按照均匀分布;就是在0-1之间均匀可以给我出一些值;
三、访问元素
- 几个例子
- 第一个是访问第一行：行是从0开始的;1就是第二行; 比如 [1,2] 访问的数据就是7；
- 访问一行;第一行就是通过冒号表示;把这一行所有的列元素访问出来; [ 1,: ]
- 访问一列;就是访问第一列;把所有的行这一块;要把这一列拿出来;：[: ,1 ]
- 拿一个子域;访问是:这是行从第一行开始到;第三行的开区间结束;是拿到的1和2两行;虽然它是3结尾但是它是个开区间;所以是拿到第一行和第二行;然后就是从第一列开始拿到所有的一列;
- 最后一个例子是说要跳的访问;说从第0行到最后一行;但是每3行一跳;就说把第0行拿出来，把第3行拿出来;列的话是每两列一跳;就是把第0列和第2列拿出来;这就是访问一个带跳转的一个子区;
四、数据操作D2L注意点
"""
首先，导入torch。请注意，虽然它被称为PyTorch，但应该导入torch而不是pytorch
要import Pytorch;就是我们叫做Pytorch;但实际上导入的是torch就是Python;
安装的时候也要去安装torch;不要去安装Pytorch在import的时候也要import torch;
"""
import torch
"""
张量表示一个数值组成的数组，这个数组可能有多个维度
举个例子;就是说在torch里面;生成arrange就是从0到12;
把所有的0到12之间从0开始到12前的11结束的所有的东西拿出来;它是一个向量;
就是复制给x然后把x print出来;可以运行一下;
tensor([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
"""
x = torch.arange(12)
print(x)
"""
可以通过它的shape来访问这个张量的形状;就是x.shape;看到它是一个向量它就是一个维度;
就是说这个维度的长为12;它是一个以维数元素为1的一个数组;
然后它的;number of elements(缩写numel)就是说你里面元素的总数;它永远是个标量就是12;
"""
print(x.shape)
print(x.numel())
"""
如果想改变一个数组或者一个张量的形状;但不改变元素的数量和元素值的话;
可以用reshape;这个函数;刚刚是以12个元素对吧;长为12的向量;
然后可以把它reshape成是有3行和4列;看到它是元素是说它在每一行是连续的;然后把它掐成三行;
这样子我们就是说在0123;然后这样子一个3*4的一个矩阵;
tensor([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
torch.Size([3, 4])
12
"""
X = x.reshape(3, 4)
print(X)
print(X.shape)
print(X.numel())
"""
可以创建一些全0的一些函数;就是给形状是234;元素为全0;
然后当然是我们可以元素为全1对吧;可以看到元素为全1;就是形状是234;
tensor([[[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]],
[[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]]])
"""
Y = torch.zeros((2, 3, 4))
print(Y)
Y = torch.ones((2, 3, 4))
print(Y)
"""
要特定的一些值;也可以通过一个Python的列表来复制;我们这里再创建一个二维的一个数组;
这个告诉你是第一行的元素是2143;第二行的元素是1234;然后第三行的元素是啊4321;
然后这是一个列表;然后列表嵌套列表就是一个;list of list单子;我会创建一个二倍的东西出来;
这是一个二维的数字;当然我可以创造一个三维对吧;我再打一个框;放括号就会变成一个三维的数字;
你看到这是一个啊;你可以可以有两个框在这里对吧;如果我要打印它的shape的话;看到是说是一个三维的是134;
"""
print(torch.tensor([[2, 1, 4, 3],
[1, 2, 3, 4],
[4, 3, 2, 1]]))
"""
创建数组后;可以做一些比较常见的标准算数运算;加减乘除和指数;
所有的这些运算都是按元素进行的;所以先从比如说我们创建一个;
我们特别给了一个1.0;就是说这样子;我们创建的是一个浮点运算;就是如果你不你把这个0.1去掉的话;它变成整数了;
其实然后呢我做x加y;他就会按元素全部加起来;你可以认为是3460;
然后做减法按元素做减法;
按元素做乘法;
按元素做除法;
然后按元素求幂;就是对每一个x元素求二次方;
当然是说我还可以做更多计算了;就说我可以做指数对吧;就说按元素来;每个元素做一些指数的运算;
tensor([ 3., 4., 6., 10.])
tensor([-1., 0., 2., 6.])
tensor([ 2., 4., 8., 16.])
tensor([ 1., 4., 16., 64.])
tensor([0.5000, 1.0000, 2.0000, 4.0000])
tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])
"""
x = torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2, 2, 2, 2])
print(x + y)
print(x - y)
print(x * y)
print(x ** y)
print(x / y)
print(torch.exp(x))
"""
我们要把可以做一些张量之间的;或多元数组之间的一些操作;
比如说我们用一个;我们还是一样的生成一个;跟之前一样;
就说生成一个从0到11的元素;长为12的向量;把它reshape到3和4;
这里我们特别指定说你用float 32;就不要给我生成一个integer了
然后呢y也是一个啊;跟刚刚是一样的;是一个3*4的一个运算啊;他们两个的形状是一样的;
然后我们用cat;就是说我把这两个元素合并在一起;然后在第0维合并;就是在行就是你可以认为是在堆起来;
那这看到是说这个;就是说这是我们的第一个生成x;这是我们生成的y;然后我们是在按行上面合并起来;
然后我们可以说dimension等于1;就是按列;
tensor([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.],
[ 2., 1., 4., 3.],
[ 1., 2., 3., 4.],
[ 4., 3., 2., 1.]])
tensor([[ 0., 1., 2., 3., 2., 1., 4., 3.],
[ 4., 5., 6., 7., 1., 2., 3., 4.],
[ 8., 9., 10., 11., 4., 3., 2., 1.]])
"""
X = torch.arange(12, dtype=torch.float32).reshape((3, 4))
Y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
print(torch.cat((X, Y), dim=0))
print(torch.cat((X, Y), dim=1))
"""
然后我们可以通过说;逻辑运算符来构建一个二维的张量;
就说我判一下y是不是等于x;
它就是按元素所谓的按元素值进行判;就说啊就这一个元素;
这两个元素是相等的;别的元素等于是都不相等;
tensor([[False, True, False, True],
[False, False, False, False],
[False, False, False, False]])
"""
print(X == Y)
"""
tensor(66.)
"""
print(X.sum())
"""
从numpy过来的;就是说一个叫广播机制;
这也是最容易出错的一个地方;就说如果你代码没写好啊;
看上去一切都在运行;实际上可能不是你想象那样子;
比如说;创建一个a;它是一个二维的数组;但是它是一个向量其实它是有三行;它有一列;
然后我创建一个b;它有一行两列你可以打印下去找;这样子对吧;这是a这是b;
我在做a加b;按照我们刚刚的定义;我们是按;a的每个元素和b的每个元素相加;
但它形状不一样啊;不一样怎么加呢;就是说在这个情况下;他有一个特殊的机制来帮你+;
就是说如果当我看到两个张量;有两个多元数组;就我们;其实张量和多元数组是混着用的;
好这两个张量形状不一样;但是呢;我可以有办法把它变成形状一样;为什么呢;
是因为你这里;首先我们的尾数是一样的啊;都是一个纬度等于2都是一个数组;如果你维度不一样就没戏了;因为纬度一样;然后呢第一个纬度我是3但你是一啊;第二个纬度虽然我们不一样;但是我是2你是一;所以的一个半是说;一个办法师说;我可以把我这个一的这一维度;复制一下;复制成两个;然后把我这个跟你不一样的地方;因为我是一嘛;我就可以把我复制成3下;这样子就会把;a复制成一个3*2的一个矩针;把b复制成一个啊3*2的矩针;然后再它相加;这样你可以看到是说;而我们加出来就是一个3*2的矩阵;了这就是一个广播机制;所以是说;很多时候;你如果可能没有想到说我要做广播;就说我就想把两个项链一加;但是你没想到一个项链没弄好;就是加了一个不小心;加了一个纬度和加了一个纬度;它就变成一个矩阵;相加就变成一个矩阵出来了;就不是你想象的那样子;所以这一块就是虽然它很方便;但是大家一定要注意说;有这个机制的存在啊;导致如果有问题的话;大家可能会;去想;这个事情是不是因为广播机制造成的;
tensor([[0],
[1],
[2]])
tensor([[0, 1]])
tensor([[0, 1],
[1, 2],
[2, 3]])
"""
a = torch.arange(3).reshape((3, 1))
b = torch.arange(2).reshape((1, 2))
print(a)
print(b)
print(a + b)
"""
然后我们来做一下元素的访问;我们之前有说过说;元素可以做哪些访问啊;
最简单X[-1] 就说把最后一行访问出来;;X[1:3]就是说啊把第一行和啊第二行给拿出来就是X[1:3];
然后我们当然可以是说我要写值;我怎么写呢;我把第一行;就是它其实行还是从0开始啊;
所以第一行其实是说这个是第一行;然后第二列列是从0开始;所以你是写的是这个;是;你把这个元素的值写成9;
然后把x打印出来;你会发现啊别的值呢都没有变;就9就变化了;
tensor([ 8., 9., 10., 11.])
tensor([[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]])
"""
print(X[-1])
print(X[1:3])
"""
最后大概就是说;Python里面最常见的其实既不是pytorch;也不是Tensorflow;其实是numpy;
多元数组的运算框架;就是说;可能大家如果学Python数据编程的话;可能是从numpy学起的;
所以呢当然是所有的;不管是所有的框架;它都能够很方便的从numpy进行转换;
比如说x等于numpy;它会得到一个numpy的一个多元数组;当然你可以torch Tensor;
从一个numpy a拿回来;可以构建一个pytorch的一个Tensor;
你可以看到是说a的type;就是它的类型;它是一个numpy NDRA;
然后它的b是从numpy构建的;所以它是一个torch的一个Tensor;
所以这个是numpy 数据类型;这个是torch的数据类型;
当然如果你是大小唯一的张量的话;我可以变成一个Python的标量;
就是创建一个大小唯一的啊torch的Tensor啊;a当然它就是一个torch的Tensor啦;
OK把a点item拿出来它就是一个啊;number;的一个辅点数啊;当我可以说float a;也是变成一个Python的辅点数
int a;它就变成一个integer就是也是Python的;这就是转变;
tensor([3.5000])
3.5
3.5
3
"""
A = X.numpy()
B = torch.tensor(A)
print(type(A))
print(type(B))
a = torch.tensor([3.5])
print(a)
print(a.item())
print(float(a))
print(int(a))
五、数据预处理D2L注意点
"""
数据预处理是说;如果有一个原始数据;我怎么样把它读取进来;
使得我们通过;机器学习的方法能够处理;
这里给一个;几个非常简单的预处理;当之后我们随着课程的加深;我们会介绍更多的一些课程的处理;
首先我们创建一个人工的数据集;存在一个CSV文件里面;这是一个很小很小的文件;
然后呢;接下来就是说;我们把它存在一个CSV文件里面的话;
"""
import os
os.makedirs(os.path.join('..', 'data'), exist_ok=True)
data_file = os.path.join('..', 'data', 'house_tiny.csv')
with open(data_file, 'w') as f:
f.write('NumRooms,Alley,Price\n') # 列名
f.write('NA,Pave,127500\n') # 每⾏表⽰⼀个数据样本
f.write('2,NA,106000\n')
f.write('4,NA,178100\n')
f.write('NA,NA,140000\n')
"""
我们可以把它读取进来;一般读取CSV文件的话;一般用的是叫做pandas;
这个库也是说啊;作为数据科学家最常使用的一个库;可能它的;使用频率在跟numpy是差不多的频率;
OK我们如果你没有装pandas的话;是一个很小的Python的包;
然后我们import pandas;然后pandas的话;它提供了一个很简单的函数;叫做read CSV;
我们就把刚刚我们读取的文件读取进来;我们就可以打印在print在这个地方;
你会发现这里给你的你的第一行就是你每一个列的名字;接下来是说这有4行;我们运行一下;然后你当然可以print;
NumRooms Alley Price
0 NaN Pave 127500
1 2.0 NaN 106000
2 4.0 NaN 178100
3 NaN NaN 140000
"""
import pandas as pd
data = pd.read_csv(data_file)
print(data)
"""
接下来是说;注意到我们有一些数据是缺失的;
所以对于数据科学家来说;最重要的一件事情是说;怎么样处理缺失的数据;
或者说整个机器学习就是处理;缺失数据;就是你要预测未来;未来是什么样子;
我们不知道这是一个缺失的数据;当然这这里的话我们先不做预测;我们先说用很简单的方法;
我们把一些缺失的数据补起来啊;补的方法有很多种;最常见的包括如果有一个数据是缺失的话我们就把它丢掉;
把整个这一行丢掉;这是一个最常用的方法;当然很多时候我们说我们丢掉也太可惜了;
然后呢最常用的;这也是一个叫插值的方法;比如说我们这里怎么样进行插值;
首先呢我们数据我们先把它分成一个;输入的特征和输出;但我们现在没有讲;输入特征和输出是什么样子;
那没关系;我们就是说啊对一个data;它是一个;刚刚我们注意到是一个;4乘以3的一个表;
然后我们通过iloc就是index location;来把第一个的第0和第一列;和所有的行拿出来放在input里面;然后把最后一列拿出来放在output里面;
"""
inputs, outputs = data.iloc[:, 0:2], data.iloc[:, 2]
inputs = inputs.fillna(inputs.mean())
"""
好那么接下来就是说;因为我们先把所有的缺失的值和所有的字符串全部变成了一个数值;
那么我们就可以变成一个;pytorch的Tensor了;然后我们input torch;
然后;到Tensor我们就把input values放进来;output values放进来;大家可以看到是说OK;
现在我们把一个CSV文件;转成了一个纯的;我们昨天提到过的一个张量了;
注意到这里是float 64;这个传统的Python一般会;默认浮点数会用float 64;但是64为浮点数啊一般计算比较慢;
对深度学习来讲;我们通常用32为浮点数;在这个就是一个非常简单的一个样例;
教大家怎么样把一个;CSV文件读取进来;做一定的特征预处理;然后变成一个pytorch的用的一个Tensor;
(tensor([[3., 1., 0.],
[2., 0., 1.],
[4., 0., 1.],
[3., 0., 1.]], dtype=torch.float64),
tensor([127500, 106000, 178100, 140000]))
"""
import torch
X, y = torch.tensor(inputs.values), torch.tensor(outputs.values)
print(X,y)
六、QA
import torch
a = torch.arange(12)
b = a.reshape((3,4))
b[:] = 2
print(a)
"""
tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])
"""
No.2 线性代数
一、标量
- 标量的简单操作
- c=a+b; 然后c=a*b; 然后取个sin;
- 长度的话标量有长度; 就是它绝对值; 如果大于0的话是a; 如果小于0的话就是-a;
- 长度有一些公式; a加b的绝对值小于等于a的绝对值加b的绝对值; a乘以b的绝对值; 等于a的绝对值乘b的绝对值; 这是标量的长度;
二、向量
1、基本操作
-
标量拓展到向量
-
标量就是一个数值; 向量就是刚刚提到的就是一行值; 可以既是行向量也是列向量; 但数学上并不太区分行和列;
-
这里a和b都是向量里面很多元素; c=a+b; 是说c的第 i个元素=a的第i个元素加上b的第i个元素;
-
α是标量; b是向量的话那就α*b; 就是说; c的每一个元素等于α乘以bi; 如果做Sin的话也是每个元素做Sin;
-
向量的长度
-
就是向量的长度; 就是向量的每个元素的平方求和; 再开根号;
-
就说a的长度是大于等于0的;
-
两个向量的长度小于等于a的长度加上b的长度; 就是三角定比;
-
a乘以b; 就是说它等于如果a是一个标量的话; 那么它等于a的绝对值乘以b的向量的长度;
2、空间表示
- 图示
- 向量可以给一个直观上理解; 蓝色的是a的话; 黄色是b的话; a+b; 就是把这个两个向量接起来就是c; 就绿色c等于a加b;
- 如果a还是这个蓝色的；α是一个长度是个标量的话; 那就是说可以把它拉长;
3、乘法
-
====
-
就a的转置*b就=把a的i元素乘以b的i的元素; 然后求和;
-
如果这两个向量是正交的话; 就是垂直的话; 那么他的求和是等于0的; 这是他这是正交向量
三、矩阵
1、基本操作
-
看到矩阵; 就说n行与n列
-
c等于a加b; 那就是每个元素相加;
-
α标量乘以矩阵那就每个元素相乘α;
-
sin也是每个元素求sin; 这是一样的;
2、乘法
- 矩阵乘法略有不同
- 矩阵a乘以b就是a是一个矩阵; b是一个向量; 就是说对 a的每一行*b；做一个列向量; 就是每一行和这个列向量做内积;
- 就是每一个元素; 乘起来然后求和; 写到第一行; 这一行第二行再跟他列向量做内积; 写到第二行; 第三行跟列向量做内积写到第三行; 这是矩阵的乘法; 因为之后的机器学习所有的模型; 矩阵乘法是最基础的;
3、空间表示
-
矩阵乘法从直观上来说; 它是一个扭曲空间
-
可以认为是说一个向量; 通过一个矩阵乘法; 变成了另外一个向量;
-
就是这个矩阵; 其实是把一个空间进行了扭曲; 比如说这个是原始的两个向量; 通过矩阵乘法之后这个向量蓝向量变成这个蓝向量; 这个绿向量变成这个绿向量; 就说这个矩阵; 就是把整个空间进行到一个扭曲; 这是线形代数里面要讲的事情;
4、乘法
简单的矩阵乘法！
5、范数
- 矩阵范数
- [向量范数与矩阵范数](矩阵基础 | 向量范数与矩阵范数 - 知乎 (zhihu.com))
- 矩阵一样的; 要长度叫做范数; 因为c和b都是向量的话; 因为c等于a乘以b; c的长度就向量的长度; 根据刚刚的定义一定会小于等于a的范数乘以b的范数;
- 然后这个取决于怎么衡量b和c的长度了; 就说常见的范数有矩阵范数; 就说最小的满足上面公式的值; 就说对于a的矩阵;
- F范数的话; 把这个矩阵拉成一条向量; 然后做一个向量的范数；就说把a的所有的元素乘平方全部加起来; 然后开根号就是f范数; 因为它f范数比较简单; 所以一般会用f范数; 就矩阵范数会算起来会比较麻烦一点;
6、特殊矩阵
- ====
- 对称的; 和反对称; 就是说对称矩阵是以这条线; 它在这条线上; 是一个对称的; 就说这两个元素是一样的; 这两个绿色是元素的是一样的; 就是Aij等于Aji;
- 反对称就说Aij等于负的Aji;
- 另外一个说正定; 正定是说如果一个矩阵是正定的话; 那就是说它这个矩阵乘任何一个行 一个列向量和一个横向量; 它都大于等于0; 就是它是一个正定矩阵;
7、特征向量
- 特征向量和特征值
- 特征向量; 是不被矩阵改变方向的向量; 矩阵就是把一个空间进行一个扭曲; 但有一些特殊的一些向量不被这个矩阵作用之后它不会改变;
- 这个红色和一个蓝色的向量; 被a作用之后; 做到这里; 红色被改变了; 但绿色没有被改变; 就绿色的方向没有变; 但是大小变了没关系; 那么这个绿色就是特征向量; 这个就是一个直观上的理解啊; 对称矩阵总是能找到特征向量; 但不是每个矩阵都有特征向量;
四、D2L注意点：
1、矩阵克隆
在这里使用克隆的话；更改B的数值并不会影响到A的数值；如果使用B = A；这样只是给的索引；
A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
B = A.clone() # 通过分配新内存，将A的一个副本分配给B
A, A + B
2、矩阵降维
关于2.3线性代数中的6降维需要重点理解；如何按照特定的轴做sum
举个例子；假设我们有个矩阵：5行4列；那么它的shape是[5,4]的list；它的维度就是2；并且它的axis：即它的轴；第一个轴是0；第二个轴是1；就是你的shape是一个list，那么第0轴就是第一个元素；2轴就是第二个元素；那么按照行就是轴为0；按照列就是轴为1；
如果按照axis=0来做sum的话，那么步骤就是按照第一列求sum；然后第二列求sum；以此类推得到的是一个长为4的行向量；
如果按照axis=1来做sum的话，同理；
如果是三维的话， shape[2,5,4] ；
如果按照axis=1来做sum的话，
五、QA
很多的东西啊~
No.3 矩阵计算
矩阵计算;其实是讲矩阵怎么求导数;因为对于机器学习;或者是说对于深度学习来讲;要知道怎么求导数;因为你的所有的优化模型的求解;都是通过求导数来进行的;
一、标量导数
-
高中数学标量的导数：y是一个函数;对函数y在x上求导
-
a不是x函数的话;那么它对于x的导数;是0;
-
如果y是x的n次方的话;那么它的导数;那就是n乘以x的n减一次方;
-
如果y是x的指数的话;那么它的导数不变;
-
如果它是log的话;它会变成了x分之一;sin变成cos
-
导数就是切线的斜率
-
比如说我有一个函数;y等于x的平方;那么画出来就是个黄线;那么这个它的导数那就是2 x;
-
然后在x等于1的导数;那么把x等于1代进去那么它就是2;那么在x等于1这个点;可以画一个切线;那么切线这个斜率它就是2;就是导数的意义;
-
导数的一些基本的运算规则
-
如果y是一个;u函数加上一个v函数的话;那么对x求导的话;那就是分别对u求导和对v求导;
-
如果y是u乘以v的话;那么就是说对u求导;然后乘以v加上对v求导乘以u;
-
对于y如果是一个u的函数;u是一个x的函数的话;那么y对x求导就是先对;y是u的函数先对u求到;然后对u对x求导;它可以做一个分解就是一个链式法则;
二、亚导数
- 不一定存在导数的话会怎么办将导数拓展到不可微的导数的情况下;怎么办？
- 举个简单例子;y是x的绝对值;那黄线就是这样子;在0点的时候它的切线不为1;就说你可以斜率等于0.5也行;等于-0.3也行;它都在这个线在这个函数的下面;
- 那么就是说;可以通过一个叫亚导数;就是它的数学符号就是一个；那就说x大于0的话它是一;x小于0的话它是-1;但是在x等于0的时候;它可以在-1和一之间取任意的值;
三、梯度
-
导数拓展到向量;通常我们叫梯度
-
就是说这里画了一张图;就是说最关键的是说要搞得清形状;当拓展到向量矩阵的时候;要把形状搞对；形状搞对了的话通常也就对了;
-
就是说当y是x的函数;y是标量;x是标量的话;它的求导当然是一个标量;
-
当你如果是y是一个向量;x是标量的话它会变成一个向量;同样的话你y是一个标量;你x是向量的话;它也是一个向量;那如果两个都是向量的话;它会变成一个矩阵;
1、y是标量，x是向量
-
y是一个标量;x是一个向量;
-
X这是一个列向量;那么它的导数关于列向量的导数;它是一个行向量;
-
就是理解一下：就列会变行;它的第i个元素;那就是y是一个标量;关于x的第i个元素的导数;
-
举个例子;那就是说x是一个长为2的一个向量;y就是定义为第一个元素的平方加上2乘以第二个元素的平方;
-
那么就是说它的导数就是一个;首先我们第一个元素那就是说X1;它要求导那就是2乘X1;第二个元素就是对X2求导;那就是4倍乘X2;这就它的导数它是一个行向量;
-
理解
-
怎么理解这个东西呢;关键是一个理解;因为就是说可以不知道导数怎么求;但是一定要需要是怎么理解的;
-
理解上来说就是说;这个东西可以画成一个等高线;就是说这个函数X1的平方加上二乘以X2的平方;可以做等高线;就是一个一个这样子椭圆的形状;(好像是椭圆方程式)
-
那么对于X1和X2等于1和1这个点;我可以做等高线做切线;然后它的做一个正交方向出来;这个方向的值是一个2和4;它就跟你的梯度是一样的;你把X1和X2带值进去的话就变成2 4;就是说你的梯度就是跟你的等高线是正交的;
-
意味着是说你的梯度指向;是你的值变化最大的那个方向;这是一个核心的概念;就是说梯度一定指向你那一个值变化的最大的方向;通常是往大的直走;这个也是今后所有的机器学习求解的一个核心思想;
-
对上面的情况进行举例子
-
首先y是一个标量;x是一个向量;当标量是一个跟x无关的函数的话;那么它是一个全零的一个向量;它是一个行向量;就是我们要转置来表示;
-
如果是a乘以u的话;那么就是说你把a拿出来;然后对u对x求导;如果是求和的话;对x求和的话;那么就会变成一个全1的一个向量;
-
同样的话之前如果是u加v的话;那么同样的话;先对u就求导数和对v求导数;然后加起来;
-
乘法的话是一样;就是说;关于u关于x的导数乘以v加上v;关于x的导数;再乘以u;如何累计的话;首先是u的转置乘以它关于v的;关于x的导数就说两个向量;关于向量的导数它是一个矩阵;就是一个;行向量乘一个矩阵;再加上另外一个横向量乘一个矩阵;这就是一个;所以它的导数出来也是一个行向量;
2、y是向量，x是标量
-
上面的函数是一个向量;下面的是一个标量的话
-
假设y是一个列向量;那么关于列向量关于标量的导数;它也是一个列向量;就说刚刚是要会变现在是不变了;
-
所以可以看到这个图;所以是说当x是一个列向量;y是一个标量;那么它的导数是一个很怪的行向量;如果y是一个列向量;x是标量的话;那么它是一个跟它一样长的一个列向量;
-
所以说这个被称之为分子;分子布局符号你可以反过来;你可以把它就是说它们行列可以交换;那就叫分母布局;就说你有哪个布局的没关系;只是说你必须要用一个布局;这样子你的形状是能对上的;所以这里一般是用分子布局方法;
3、y和x均是向量
-
向量关于向量是一个矩阵
-
就是说;y是一个向量;x是一个向量;那么因为y是一个向量;先把它拆解成一个列的向量;然后每一列的那一个元素;第i个元素就是y的第i个元素;关于x的一个导数;它是一个横向量;那最后会变成一个矩阵;
-
上面的例子举例
-
同样的话;a是一个跟x无关的一个向量的话;那么它的输出是一个全0的一个向量;
-
不然的话如果是本身的话;那他就会变成一个对角;
-
如果是A乘以x的话;y等于x乘以x的话;它的导数是a这个矩限的本身;
-
如果你是反过来的话;你是一个x导啊转制成a的话;那么它导数就是a的转制的本身;这两个是非常有用的;之后可能会讲到的一个东西;然后同样的道理是说;如果是标量乘以u的话;那么呢就是标量可以拎出来;如果是矩阵乘以u的话;矩阵而且是跟x无关的话;那么可以把a拿出来;啊如果是u加上v的话;分别对u和对v求了;
4、y和x均是矩阵
这里基本不会；
输入拓展到矩阵;就是大家不要求全部能弄懂是怎么回事啊;首先说我们当你的y是一个标量;这是一个矩阵的话;刚刚记得吗;我们如果是向量的话;我们就把它其实转置了一下;我们可以把一个通过一个刚刚提到过;可以通过用一个二维的数组来区分行向量和列向量;如果你的项量是在下面的话;那么它的结果会要转一下;如果你矩阵的话;你会被和k和n会转至一下;同样的话;如果你矩阵在上面的话;你其实不会变化的;就是m乘l是不会变化的;当这里比较好玩的是说;当你的y是一个矩阵;你x是一;个向量的话;那等于是说你要把n放到后面;然后拎到最后这个地方;如果你的y和x都是一个矩阵的话;那就是更好玩了;就是说我们绕开一点啊;就是说前面两项是来自于y的m乘以l;但是呢后面两项是来自于x;但是你要把x给翻过来;就是k要放到这里然后n要放到最后;它就会变成一个四维的一个丈量啊;就是说你当然可以做到更高位的情况;就是说以此类推;可以做到更高位的情况;这就是我们的矩阵的技巧;
四、QA
1、导数作用
导数的作用主要是进行梯度下降;但容易陷入局部最优解;请问是不是可以通过Leap PROF函数;或者其他方法来使得下降得到全局最优解;这个问题就是说;如果你是凸函数的话你可以拿到最优;如果你不是突函数的话;其实你不管用;几乎是拿不到最优解的;就说当然你可以;理论上你数学是可以但从计算上来说;几乎是拿不到最优解的;这个真的是;啊一个不幸的消息啊;
而且机器学习几乎是不会处理凸函数就是说;如果你这个问题能得到最优解的话;那就是一个P的问题;我们机器学习不关心P问题;我们只关心NP的问题;所以大家不要去纠结最优解这个事情;
2、自动微分和计算图
pytorch和M开头的;采用的是自动微分和计算图;对的;我们马上就会讲自动微分和计算图;就说不会让你自己去求导;大家能够知道;导数大概是怎么算的;至少你的形状能够搞清楚;就说你必须要知道整个是怎么算出来的;但是你能大概理解导数的形状跟你的input的形状是;什么样一个变化的关系;我觉得这个比较重要;
No.4 自动求导
一、向量链式法则
-
标量的链式法则
-
y是一个u的一个函数；u是关于x的一个函数；那么y对x求导的话；那就是说先把y；把u做成一个变量进来求导；
-
然后把u做成一个函数关于x的导数；要拓展到向量；最大的问题说要把形状搞对；就说y是一个标量；x是一个向量；那么首先u也是一个标量；这个当然是个标量；u关于x；它就是一个1乘以n的一个东西；那么1乘它就变成1乘n；就是这个形状不发生变化；
-
那假设u是一个向量那怎么办呢；那就y关于u；那还是一个一乘k；假设u是一个k尾的一个向量；那是一乘k；u关于x它是一个k乘n的一个矩阵；那么它一乘还会变成一乘n；然后你的y是一个向量；x是一个向量u也是一个向量；
-
同样的道理；假设你的是一个m乘n的话；那么它就是u是一个长为k的话；那么它是一个m乘k；然后它是一个k乘n这样子矩阵；两个矩阵一乘；它还是变成一个m乘n的一个矩阵
-
举两个例子
-
这就是一个之后线性回归的一个例子；首先；假设x和w它都是一个长n的向量；y是一个标量；那么函数z是说x和w做内积；减去y然后做平方；
-
要计算z关于w的一个导数；那我们怎么做呢；就是先分解吧；先把它写开；首先说我记一个a中间变量a；它是x和w的内积；b是a减去y；然后z是等于b的平方；这样子我们把它分解成三个步骤；然后我们用链式法则；
-
那z关于w的导数那就是说；z关于b的导数；b关于a的导数a关于w的导数；然后把这个z b a的定义展开；那就b的平方关于b；a减y关于a；x和w的内积关于w；那么第一项我们知道就是2b对吧；那么这一块就是因为它是一个；就是一；它就是x的转置；那么再把b的定义拆开；就b是怎么定义的；然后它长成这个样子；
-
那么就会得到说z关于w的导数；那就是；w和x的内积减去y然后乘以x的转置；这是一个标量；所以它是说因为它是一个；它的向量在下面；所以它出来的是一个转置的一个向量；
-
涉及到矩阵了
-
x是一个m乘以n的一个矩阵；乘以w；一个向量减去另外一个向量；同样的道理它是一个标量对吧；
-
所以我要对标量对于向量求导；其实这个跟之前是一样的；首先就运用中间变量；a是一个向量等于x乘以w；b等于a减去y；z就等于b的||；用这个展开；那么就说它的本身是一个2的；b的转质；乘以它是一个ident；那就是说一个identity Matrix；它就是x的本身；那么最后的把b展开的话那就是；x乘以w减去y的转值乘以x然后乘2；
二、自动求导
- 目前，我们有能力执行自动求导。如果你提供一个函数，我可以使用链式法则和基本的导数规则，将其展开为一个导数链。然而，最大的问题在于，神经网络通常包含数百层，手动进行导数计算几乎是不可行的。因此，我们需要自动求导的能力，即在指定点计算函数的导数。
- 自动求导实际上有两种不同的定义：符号求导和数值求导。符号求导可以在给定一个函数时，明确地计算出其导数。如果你曾使用过类似Mathematica的软件，你可能已经体验过这种功能。另一种方法是数值求导，它允许我们在不知道函数的具体形式的情况下，通过数值逼近来计算导数。这可以通过微小的变化h来实现，即通过计算 (f(x+h) - f(x)) / h 来逼近导数值。
- 现在，让我们来掆自动求导是如何实现的。这涉及到一个称为计算图的概念。虽然我们在使用PyTorch等深度学习框架时不需要深入理解计算图的内部工作原理，但了解计算图的概念对于理解自动求导的基本原理是有帮助的。如果你之前使用过TensorFlow或其他深度学习框架，你可能已经对计算图有所了解。
三、计算图
- 关于计算图，实际上本质上是链式法则的一个求导过程。首先，我们将代码拆分成操作子，逐步展开。然后，我们将计算表示成一个无环图。让我们继续使用之前的示例，其中z等于x与w的内积减去y，然后再求平方。我们按照类似的方法，引入两个中间变量a和b，将每一步的计算都表示为基本的计算单元。因此，每个节点表示一个操作，也可以表示一个输入值。
- 例如，一个节点表示w，另一个节点表示x，还有一个节点表示a，它在这里执行计算。将a和y输入后，我们得到b。最后，将b输入后得到z。这就是计算图的构建过程，它是一个无环图的表示。
这个~~~
四、自动求导的两种模式
- 有两种自动求导的方法。让我们再回顾一下链式法则。假设我有一个函数y，它是关于x的函数。在计算整个导数过程时，我有两种方法：一种是正向计算，另一种是反向计算。
- 正向计算意味着我从x开始，首先计算关于x的导数U1，然后计算关于X1的导数U2，然后将它们相乘，一直向下传递，直到最后计算出目标导数。
- 反向计算是另一种方法。在这种方法中，首先计算y作为最终函数关于中间变量的导数，然后乘以倒数第二个中间变量的导数，依此类推，一直向前计算，直到最前面的导数。这个方法也被称为反向传播。
- 自动求导是计算机科学领域一个历史悠久的领域，它在人工智能中占有重要地位。其中一个著名的方法叫做反向传播。
五、反向累积
- 那么，反向传播究竟是如何计算的呢？首先，我们先回顾正向传播，因为我们已经讨论了正向传播的过程。现在，让我们来看看反向传播。
- 在反向传播中，我们首先计算z关于b的导数。这个导数等于2乘以b，根据之前的计算结果得到。因此，我们需要在计算z关于b的导数时，访问之前计算的b的值，将其存储在某个地方，然后将其检索出来。我们需要访问之前的计算结果。
- 同样地，我们可以计算z关于a的导数，这个导数也依赖于之前的计算结果。最后，我们计算z关于w的导数，这需要知道w的值和a的值，所以我们需要同时知道这两个值。因此，在反向传播中，我们需要存储所有中间计算的值，以便在反向计算时使用。
- 反向传播是一种累积的过程，与正向计算相反。在正向计算时，我们需要将所有中间计算的值存储下来。但在反向传播时，我们按相反的方向进行计算，如果某些导数不需要的话，我们可以选择不计算它们，但是我们需要保留中间结果，以便在后续的计算中使用。
- 那么，让我们来讨论一下计算复杂度。假设我有n个操作子，比如我的神经网络有n层。在正向传播和反向传播中，实际上代价差不多，即你需要运行正向传播和反向传播一次。换句话说，对于神经网络的前向传播和后向传播，计算复杂度是相近的。
- 然而，更加重要的是内存复杂度。它是O(n)，这意味着你需要存储所有的中间计算结果。这对于深度神经网络来说需要大量的GPU资源，因为在求梯度的过程中，需要保留前面的计算结果。
- 另一个值得注意的概念是正向累积。正向累积的好处在于内存复杂度是O(n)，无论网络有多深，都无需存储任何结果。然而，它的问题在于，计算一个梯度需要遍历整个网络两次。因此，正向累积通常在神经网络中不被使用，因为它的计算复杂度太高。
六、D2L注意点
1、梯度存储问题
在计算梯度之前，需要一个地方来存储梯度，
x.requires_grad_(True) # 等价于x=torch.arange(4.0,requires_grad=True)
x.grad #通过这个就可以以后访问梯度了；即y关于x的导数是放在了这个地方的；
2、求导问题
其实深度学习中大部分y都是标量；即之前学的向量对向量的求导在深度学习中是用的很少的