动手学习深度学习-相关数学知识

1、线性代数

1.1、标量

标量是只有一个元素的张量，仅包含一个数值。

python 复制代码

# 标量由只有一个元素的张量表示
import torch

x = torch.tensor([3.0])
y = torch.tensor([2.0])

x + y, x * y, x ** y, x / y

python 复制代码

(tensor([5.]), tensor([6.]), tensor([9.]), tensor([1.5000]))

1.2、向量

具体应用

通过⼀维张量处理向量：

python 复制代码

x = torch.arange(4)
x

python 复制代码

tensor([0, 1, 2, 3])

通过索引访问元素：

python 复制代码

x[3]

python 复制代码

tensor(3)

通过len()访问张量的长度：

python 复制代码

len(x)

python 复制代码

(4,)

形状（shape）是⼀个元素组，列出了张量沿每个轴的⻓度（维数）。当⽤张量表示⼀个向量（只有⼀个轴）时，通过.shape属性访问向量的⻓度：

python 复制代码

x.shape

python 复制代码

(4,)

当向量存在多个轴时，.shape为每个轴上的长度

python 复制代码

four_d_array = np.random.rand(4, 3, 2, 5)
four_d_array.shape

python 复制代码

(4, 3, 2, 5)

1.3、矩阵

在代码中表示为具有两个轴的张量，通过指定两个分量m 和n 创建形状为m × n的矩阵：

python 复制代码

A = np.arange(20).reshape(5, 4)
A

python 复制代码

array([[ 0.,  1.,  2.,  3.],
       [ 4.,  5.,  6.,  7.],
       [ 8.,  9., 10., 11.],
       [12., 13., 14., 15.],
       [16., 17., 18., 19.]])

访问矩阵的转置：

python 复制代码

A.T

python 复制代码

tensor([[ 0, 4, 8, 12, 16],
        [ 1, 5, 9, 13, 17],
        [ 2, 6, 10, 14, 18],
        [ 3, 7, 11, 15, 19]])

1.4、张量

张量概述：

张量描述具有任意数量轴的n维数组。高阶张量例如处理图像时，图像以n维数组形式出现，其中3个轴对应于⾼度、宽度，以及⼀个通道（channel）轴，⽤于表⽰颜⾊通道（红⾊、绿⾊和蓝⾊）。

0维张量：标量，一个数字

1维张量：向量

2维向量：矩阵

3维向量：矩阵数组

张量的属性：

秩=维度数：标量的秩为0，向量为1，矩阵为2

形状：每个维度中元素的数量

数据类型：元素的类型，如int，float

python 复制代码

X = np.arange(24).reshape(2, 3, 4)
X

python 复制代码

array([[[ 0.,  1.,  2.,  3.],
        [ 4.,  5.,  6.,  7.],
        [ 8.,  9., 10., 11.]],

       [[12., 13., 14., 15.],
        [16., 17., 18., 19.],
        [20., 21., 22., 23.]]])

torch.tensor和torch.Tensor区别:

torch.tensor为函数，torch.Tensor为一个类

通过requires_grad=True设置自动求导

1.5、张量的算法(二元运算--形状相同)

加法：

矩阵A+矩阵B，A,B形状相同，各位置元素相加

矩阵A+标量B，A各元素加B

python 复制代码

A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
B = A.clone() # 通过分配新内存，将A的⼀个副本分配给B
A, A + B

python 复制代码

(tensor([[ 0., 1., 2., 3.],
         [ 4., 5., 6., 7.],
         [ 8., 9., 10., 11.],
         [12., 13., 14., 15.],
         [16., 17., 18., 19.]]),
 tensor([[ 0., 2., 4., 6.],
         [ 8., 10., 12., 14.],
         [16., 18., 20., 22.],
         [24., 26., 28., 30.],
         [32., 34., 36., 38.]]))

矩阵点积：

python 复制代码

A * B

python 复制代码

tensor([[ 0., 1., 4., 9.],
        [ 16., 25., 36., 49.],
        [ 64., 81., 100., 121.],
        [144., 169., 196., 225.],
        [256., 289., 324., 361.]])

矩阵乘法：

行向量表⽰矩阵A 的第i ⾏，并让列向量作为矩阵B 的第j列：

做点积：

python 复制代码

B = torch.ones(4, 3)
torch.mm(A, B)

python 复制代码

tensor([[ 6., 6., 6.],
        [22., 22., 22.],
        [38., 38., 38.],
        [54., 54., 54.],
        [70., 70., 70.]])

降维：

python 复制代码

  x.sum()

python 复制代码

  x.sum(axis=0) #让矩阵沿0轴（行）降维以生成输出向量

python 复制代码

  x.sum(axis=1) #让矩阵沿1轴（列）降维以生成输出向量

python 复制代码

  x.sum(axis=[0, 1]) = x.sum()

求平均：

python 复制代码

  x.mean(axis=0) = x.sum()/x.size # 按行求平均=将总和除以元素总数

非降维求和：

sum()函数：sum_A = A.sum(axis=1, keepdims=True)，保持原有轴数：

python 复制代码

sum_A = A.sum(axis=1, keepdims=True)
sum_A

python 复制代码

tensor([[ 6.],
[22.],
[38.],
[54.],
[70.]])

其中keepdims=True, 它的作用是保持原始数组的维度不变，即使在进行操作后，结果也会保留原始数组的形状（或者说是维度），只不过在某些维度上会被压缩（比如求和后的维度会变成1）。例子如下：

如果有个shape为[5,4]的张量，axis=0和1分别为按行、列求sum

若axis=0，则sum后的shape为[4]

若axis=1，则sum后的shape为[5]

如果有一个shape为[2,5,4]的张量

若axis=1,则 [2,4]

若axis=2, 则[2,5]

若axis=[1,2], 则 [4]

cumsum()函数：沿某个轴计算A元素的累积总和：

python 复制代码

  A.cumsum(axis=0)# 按行
  
  output: tensor([[ 0.,  1.,  2.,  3.],
                  [ 4.,  6.,  8., 10.],
                  [12., 15., 18., 21.],
                  [24., 28., 32., 36.],
                  [40., 45., 50., 55.]])
  # 第2行为第1行+第2行，第3行为1、2、3行相加

1.6、范数

向量的范数：向量范数是将向量映射到标量的函数f。即表示一个向量有多大（分量大小）

范数性质：

按常数因⼦α缩放向量的所有元素，其范数也会按相同常数因⼦的绝对值缩放：

满足三角不等式：

范数必须是⾮负的：

当且仅当向量全由0组成时，范数为0：

L2范数：

L2范数是指向量中各个元素的平方和的平方根。

几何意义：L2范数表示从原点到向量终点的直线距离，即向量在欧几里得空间中的长度。

应用：

距离计算：L2范数常用于计算两点之间的欧几里得距离。

正则化：在机器学习中，L2正则化（Ridge回归）通过惩罚模型参数的大值，有助于控制模型的复杂度，防止过拟合。

信号处理：L2范数用于衡量信号的能量或误差大小。

优化问题：L2范数常用于求解最小二乘问题。

计算向量的L2范数：

python 复制代码

u = torch.tensor([3.0, -4.0])
torch.norm(u)

python 复制代码

tensor(5.)

L1范数：

L1范数是指向量中各个元素绝对值之和。

几何意义：L1范数在几何上表示在坐标轴上移动到向量端点所需的最小步伐数，也称为曼哈顿距离。

应用：

特征选择：L1范数倾向于产生稀疏解，即解中的许多元素为零。这在特征选择中非常有用，可以帮助去除不重要的特征。

正则化：在机器学习中，L1正则化（Lasso回归）通过惩罚较大的系数来促进特征选择和稀疏解。

优化问题：L1范数常用于求解线性规划问题。

向量元素的绝对值之和：

python 复制代码

torch.abs(u).sum()

python 复制代码

tensor(7.)

L1与L2主要区别：

对大值的敏感性：L1范数对大值不敏感，而L2范数对大值比较敏感。因此，在求解稀疏优化问题时，L1范数通常比L2范数更有效。

解的稀疏性：L1范数倾向于产生稀疏解，即解中的许多元素为零；而L2范数通常会产生更平滑的解。

2、微积分（无限逼近）

深度学习优化算法会涉及关键步骤，如梯度下降算法、损失函数。

2.1、导数

导数f ′ (x )为f (x )相对于x 的瞬时变化率，如果f在⼀个区间内的每个数上都是可微的，则此函数在此区间中是可微的。

求u = f (x ) = 3x^ 2 − 4x在h趋近于0，x = 1时的导数值：

python 复制代码

import numpy as np
from matplotlib_inline import backend_inline
from matplotlib import pyplot as plt
from d2l import torch as d2l

def f(x):
    return 3 * x ** 2 - 4 * x

def numerical_lim(f, x, h):
    return (f(x + h) - f(x)) / h

h = 0.1
for i in range(5):
    print(f'h={h:.5f}, numerical limit={numerical_lim(f, 1, h):.5f}')
    h *= 0.1

求x = 1处的切线斜率

python 复制代码

import numpy as np
from matplotlib_inline import backend_inline
from matplotlib import pyplot as plt
from d2l import torch as d2l

def f(x):
    return 3 * x ** 2 - 4 * x

def numerical_lim(f, x, h):
    return (f(x + h) - f(x)) / h

# use_svg_display函数指定matplotlib软件包输出svg图表以获得更清晰的图像
# 注释#@save会将对应的函数、类或语句保存在d2l包中，以后无须重新定义就可以直接调⽤它们
def use_svg_display(): #@save
    """使⽤svg格式在Jupyter中显⽰绘图"""
    backend_inline.set_matplotlib_formats('svg')

# 定义set_figsize函数来设置图表⼤⼩
def set_figsize(figsize=(3.5, 2.5)): #@save
    """设置matplotlib的图表⼤⼩"""
    use_svg_display()
    d2l.plt.rcParams['figure.figsize'] = figsize

# set_axes函数⽤于设置由matplotlib⽣成图表的轴的属性
#@save
def set_axes(axes, xlabel, ylabel, xlim, ylim, xscale, yscale, legend):
    """设置matplotlib的轴"""
    axes.set_xlabel(xlabel)
    axes.set_ylabel(ylabel)
    axes.set_xscale(xscale)
    axes.set_yscale(yscale)
    axes.set_xlim(xlim)
    axes.set_ylim(ylim)
    if legend:
        axes.legend(legend)
    axes.grid()

#@save
def plot(X, Y=None, xlabel=None, ylabel=None, legend=None, xlim=None,ylim=None, xscale='linear', yscale='linear',fmts=('-', 'm--', 'g-.', 'r:'), figsize=(3.5, 2.5), axes=None):
    """绘制数据点"""
    if legend is None:
        legend = []

    set_figsize(figsize)
    axes = axes if axes else d2l.plt.gca()

    # 如果X有⼀个轴，输出True
    def has_one_axis(X):
        return (hasattr(X, "ndim") and X.ndim == 1 or isinstance(X, list)
                and not hasattr(X[0], "__len__"))

    if has_one_axis(X):
        X = [X]
    if Y is None:
        X, Y = [[]] * len(X), X
    elif has_one_axis(Y):
        Y = [Y]
    if len(X) != len(Y):
        X = X * len(Y)
    axes.cla()
    for x, y, fmt in zip(X, Y, fmts):
        if len(x):
            axes.plot(x, y, fmt)
        else:
            axes.plot(y, fmt)
    set_axes(axes, xlabel, ylabel, xlim, ylim, xscale, yscale, legend)

x = np.arange(0, 3, 0.1)
plot(x, [f(x), 2 * x - 3], 'x', 'f(x)', legend=['f(x)', 'Tangent line (x=1)'])
plt.show()

运行结果：

2.2、偏导数

描述多元函数在某个特定变量方向上的变化率

等价于

2.3、梯度

梯度的本意是一个向量（矢量），表示某一函数在该点处的方向导数沿着该方向取得最大值，即函数在该点处沿着该方向（此梯度的方向）变化最快，变化率最大（为该梯度的模）。

在后续模型中更新参数时，需要寻找loss值越小越好的参数。

2.4、链式法则

在深度学习中，多元函数通常是复合的，难以应用上述规则来微分，故运用链式法则

上述解释：深度学习中的多元函数通常是复合函数，这意味着一个函数的输出可能是另一个函数的输入，从而形成了复杂的函数链。这种复合性质使得传统的导数规则（如相加规则、乘积规则等）难以直接应用，因为它们通常适用于较简单的函数组合形式。

简单复合函数

推广到一般复合函数

向量链式法则

3、自动微分

自动高效地计算复杂函数的导数，从而加速神经网络训练过程。实际中，根据我们设计的模型，系统会构建⼀个计算图，来跟踪计算是哪些数据通过哪些操作组合起来产⽣输出。⾃动微分使系统能够随后反向传播梯度。这⾥，反向传播意味着跟踪整个计算图，填充关于每个参数的偏导数。

3.1、计算图

将代码分解成操作子

将计算表示成一个无环图

3.2、正向、反向积累

正向积累：表示的是从最里层（树状最底部）进行求导，内存复杂度小（O(1)）；需要对每一层计算梯度

反向积累：表示的是从最外层（树状起始）进行求导，计算需要储存正向的所有中间结果，内存复杂度大（O(n)）

3.3、正向、反向传播

正向传播（forward）：神经网络沿着输入层到输出层的顺序，依次计算并存储模型的中间变量(包括输出)

反向传播（backward）：依据微积分中的链式法则，沿着从输出层到输入层的顺序，依次计算并存储在有关神经网络各层的中间变量以及参数的梯度

3.4、正向传播和反向传播相互依赖

一方面，正向传播的梯度计算可能依赖于各变量的当前值，而这些变量的当前值都是通过反向传播的梯度计算之后通过优化算法迭代的。比如加入正则化的目标函数的当前值是根据反向传播算出梯度迭代后得到的；

另一方面，反向传播的梯度计算可能依赖于各变量的当前值，而这些变量的当前值都是正向传播计算得到的。计算参数梯度的需要某系变量的当前值，而这些当前值是通过正向传播计算并存储得到。

在模型参数初始化完成后，我们交替的进行正向和反向传播，并根据反向传播的梯度迭代模型参数。在训练过程中，正向传播和反向传播的中的各个中间变量和梯度计算值都需要占用内存，而在预测过程中，没有反向传播计算梯度的过程，因此预测过程中内存的占用较小。

训练过程中的质检变量的个数大体上跟网络层数线性相关，每个变量的大小跟批量大小和输入个数也是线性相关的，它们是导致较深的神经网络使用较大批量训练是更容易超内存的主要原因。

3.5、使用-标量变量的反向传播

python 复制代码

# 对函数y = 2x⊤x关于列向量x求导
import torch

x = torch.arange(4.0) #创建变量x并为其分配⼀个初始值

# 存储梯度
x.requires_grad_(True) #等价于x=torch.arange(4.0,requires_grad=True)
x.grad

y = 2 * torch.dot(x, x) # 计算y

y.backward() #通过调⽤反向传播函数来⾃动计算y关于x每个分量的梯度

print(x.grad == 4 * x)  #验证这个梯度是否计算正确

3.6、使用-非标量变量的反向传播

python 复制代码

# 对⾮标量调⽤backward需要传⼊⼀个gradient参数，该参数指定微分函数关于self的梯度。
# 在我们的例⼦中，我们只想求偏导数的和，所以传递⼀个1的梯度是合适的
x.grad.zero_()
y = x * x
# 等价于y.backward(torch.ones(len(x)))
y.sum().backward()

4、数据操作

4.1、基本知识

arange(array+range)创建行向量

python 复制代码

x = torch.arange(12)
x

python 复制代码

tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

shape访问张量（沿每个轴的长度）形状

python 复制代码

x.shape
x

python 复制代码

torch.Size([12])

python 复制代码

x=torch.tensor([[0,1,2,3,4,5],[6,7,8,9,10,11]])
x

python 复制代码

torch.Size([2,6])

numel（numberelement）查看所有元素的数量

python 复制代码

x.numel()

python 复制代码

reshape来改变张量的形状而不改变元素数量和元素值，自动计算维度：用x.reshape(-1,4)或x.reshape(3,-1)来取代x.reshape(3,4)

python 复制代码

X = x.reshape(3, 4)
X

python 复制代码

tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])

zeros、ones创建全0、全1的数组

python 复制代码

torch.zeros((2, 3, 4))
torch.ones((2, 3, 4))

python 复制代码

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.]]])

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.]]])

创建一个形状为（3,4）的张量。其中的每个元素都从均值为0、标准差为1的标准高斯分布（正态分布）中随机采样。其中np为numpy，random是生成随机数模块，提供了多种生成随机数的方法，包括均匀分布、正态分布等。normal是random模块中的一个函数，用于生成符合正态（高斯）分布的随机数，0是均值，1是标准差。

python 复制代码

np.random.normal(0,1,size=(3,4))

python 复制代码

array([[ 2.2122064,  1.1630787 ,  0.7740038 ,  0.4838046  ],
       [ 1.0434403,  0.29956347,  1.1839255 ,  0.153025461],
       [ 1.8917114,  -1.1688148,  -1.2347414,  1.5580711  ]])

创建数组

python 复制代码

torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])

python 复制代码

tensor([[2, 1, 4, 3],
        [1, 2, 3, 4],
        [4, 3, 2, 1]])

4.2、运算符

有两个形状一样的向量u和v，还有一个可以进行两个数之间运算的二元运算符f（比如加法、乘法等）。现在用这个运算符f和这两个向量u、v来生成一个新的向量c。用运算符f把ui和vi运算一下，得到的结果就是新向量c的第一个元素ci；对u和v里的每一个元素都这么做，用f运算后得到的结果就组成了新的向量c。F:Rd,Rd->Rd：F是一个函数，它接受两个d维的向量（Rd表示d维的向量空间），然后输出一个也是d维的向量。

对于任意具有相同形状的张量，常见的标准算术运算符（+、-、、/和*）都可以被升级为按元素运算

python 复制代码

x = torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y  # **运算符是求幂运算

python 复制代码

(tensor([ 3.,  4.,  6., 10.]),
 tensor([-1.,  0.,  2.,  6.]),
 tensor([ 2.,  4.,  8., 16.]),
 tensor([0.5000, 1.0000, 2.0000, 4.0000]),
 tensor([ 1.,  4., 16., 64.]))

对元素进行指数运算

python 复制代码

torch.exp(x)

python 复制代码

tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])

pytorch的Cat合并，dim=n，n为维度，一般dim=0意思是按行合并,dim=1为按列合并

python 复制代码

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]])
torch.cat((X, Y), dim=0), torch.cat((X, Y), dim=1)

python 复制代码

(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.]]))

用逻辑运算符构建二元张量

python 复制代码

X == Y

python 复制代码

tensor([[False,  True, False,  True],
        [False, False, False, False],
        [False, False, False, False]])

4.3、广播机制

张量形状不同，维度相同时的广播机制：

python 复制代码

a = torch.arange(3).reshape((3, 1))
b = torch.arange(2).reshape((1, 2))
a, b

python 复制代码

(tensor([[0],
         [1],
         [2]]),
 tensor([[0, 1]]))

a,b先广播为一个更大的矩阵，矩阵a将复制列，矩阵b将复制行，a变成[[0,0]，[1,1]，[2,2]]，b变成[[0,1]，[0,1]，[0,1]]，然后再按元素相加，线性代数相加

python 复制代码

a + b

python 复制代码

tensor([[0, 1],
        [1, 2],
        [2, 3]])

4.4、索引和切片

第一个元素的索引是0，最后一个元素索引是-1，[-1]选择最后一个元素，[1:3]选择第二个和第三个元素，即[1,3）

python 复制代码

X[-1], X[1:3]

python 复制代码

(tensor([ 8.,  9., 10., 11.]),
 tensor([[ 4.,  5.,  6.,  7.],
         [ 8.,  9., 10., 11.]]))

通过指定索引写入元素

python 复制代码

X[1, 2] = 9
X

python 复制代码

tensor([[ 0.,  1.,  2.,  3.],
        [ 4.,  5.,  9.,  7.],
        [ 8.,  9., 10., 11.]])

为多个元素赋值：索引元素后赋值

python 复制代码

X[0:2, :] = 12
X

python 复制代码

tensor([[12., 12., 12., 12.],
        [12., 12., 12., 12.],
        [ 8.,  9., 10., 11.]])

4.5、节省内存

Python的ID类似C++的指针：存Y的id，把Y加上X然后为新Y，而不是原来的，原本的内存被析构掉了

python 复制代码

before = id(Y)
Y = Y + X
id(Y) == before

python 复制代码

False

原地操作：

python 复制代码

Z = torch.zeros_like(Y)
print('id(Z):', id(Z))
Z[:] = X + Y
print('id(Z):', id(Z))

python 复制代码

id(Z): 140327634811696
id(Z): 140327634811696

如果后续计算没有重复使用X，可以通过X+=Y或X[:]=X+Y来减少操作的内存开销，对于可变对象来说，不会改变内存地址：

python 复制代码

before = id(X)
X += Y
id(X) == before

python 复制代码

True

4.6、转换为其他python对象

numpy数组转化为torch张量

python 复制代码

A = X.numpy()
B = torch.tensor(A)
type(A), type(B)

python 复制代码

(numpy.ndarray, torch.Tensor)

将大小为1的张量转换为python标量

python 复制代码

a = torch.tensor([3.5])
a, a.item(), float(a), int(a)

python 复制代码

(tensor([3.5000]), 3.5, 3.5, 3)

.item()从只包含单个元素的数组中提取这个元素的值，并将其作为Python的标准类型（比如整数、浮点数）返回，即item函数或Python的内置函数将大小为1的张量转换为Python标量

5、数据预处理

意义：存在不合理的数据或缺失

5.1、数据预处理步骤

数据清洗（Data Cleaning）：填写缺失的值（data normalization），光滑噪声数据（noise identification），识别或删除离群点，并解决不一致性来"清理数据"；缺失值插补（Missing values imputation）

数据集成（Data Integration）：使用多个数据库，数据立方体或文件；

数据归约（数据规范化data normalization）：用替代的，较小的数据表示形式替换元数据，得到信息内容的损失最小化，方法包括维规约，数量规约和数据压缩；

数据变换（Data tansformation）：将数据变换成使用挖掘的形式。

为什么我们需要数据预处理？-CSDN博客

5.2、缺失值处理

缺失值处理，data.isnull().sum()获取缺失信息

删除（数据量小不建议）

填充：计算特征的均值，中值或众数，将其替换为缺失值

KNN：利用knn算法填充，其实是把目标列当做目标标量，利用非缺失的数据进行knn算法拟合，最后对目标列缺失进行预测。（对于连续特征一般是加权平均，对于离散特征一般是加权投票）

随机森林填充：利用已有数据拟合模型，对缺失变量进行预测

原则：具体问题具体分析，处理缺失值是需要研究数据规律与缺失情况来进行处理的

动手学习深度学习-相关数学知识

1、线性代数

1.1、标量

1.2、向量

相关概念

具体应用

1.3、矩阵

1.4、张量

张量概述：

张量的属性：

torch.tensor和torch.Tensor区别:

1.5、张量的算法(二元运算--形状相同)

加法：

矩阵点积：

矩阵乘法：

降维：

求平均：

非降维求和：

1.6、范数

范数性质：

L2范数：

L1范数：

L1与L2主要区别：

2、微积分（无限逼近）

2.1、导数

2.2、偏导数

2.3、梯度

2.4、链式法则

3、自动微分

3.1、计算图

3.2、正向、反向积累

3.3、正向、反向传播

3.4、正向传播和反向传播相互依赖

3.5、使用-标量变量的反向传播

3.6、使用-非标量变量的反向传播

4、数据操作

4.1、基本知识

4.2、运算符

4.3、广播机制

4.4、索引和切片

4.5、节省内存

4.6、转换为其他python对象

5、数据预处理

5.1、数据预处理步骤

5.2、缺失值处理