本文档深入介绍了PyTorch中的线性代数和微积分基础知识。从标量、向量、张量的定义与运算，到张量算法的基本性质、降维操作、点积、矩阵向量积和范数的概念，文章全面阐述了PyTorch在处理数值计算方面的能力。此外，文档还简要介绍了导数、微分、梯度和链式法则等微积分核心概念，并通过代码示例展示了如何使用PyTorch进行数值计算和绘图，为读者提供了实践操作的指导，有助于深入理解PyTorch在深度学习中的应用。

🧱标量是单个数值，向量是数值的有序集合，张量是多维数组。PyTorch使用`torch.tensor()`创建张量，`len()`获取张量第一个维度的大小，`shape`属性显示张量的形状，`numel()`计算张量中元素的总数。

➕张量的基本运算包括加法、乘法、除法和幂运算。PyTorch中，`*`表示按元素乘法（Hadamard积），矩阵乘法使用`@`。`clone()`用于创建张量的副本，`sum()`用于求和，`keepdims=True`保持维度不变，方便广播机制。

📐点积是对应元素相乘后求和，`torch.dot()`或`torch.sum(X*Y)`实现。矩阵向量积使用`torch.mv()`，矩阵矩阵乘法使用`torch.mm()`。范数衡量向量的大小，L1范数是绝对值之和，L2范数（欧几里得距离）用`torch.norm()`计算。

📈微积分概念包括导数、微分、梯度和链式法则。通过数值方法计算导数，`numerical_lim()`函数用于近似计算导数。`plot()`函数用于绘制函数及其切线，便于理解导数和切线的关系。

2.3 线性代数

2.3.1 标量

import torchx = torch.tensor(2.0)y = torch.tensor(3.0)x + y, x * y, x / y, x ** y

2.3.2 向量

''' 只有一个值称为标量，多个标量组合在一起称为向量。'''x = torch.arange(4)x[2]

''' len(x)输出元素个数，x.shape输出张量的形状'''print(len(x))print(x.shape)

''' len(y)输出的是第一个维度的大小y.numel()输出的才是所有元素个数'''y = torch.ones(3, 4)y, len(y), y.numel(), y.shape

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

''' assert只能对单值进行判断，直接 B == B.T可以对多个位置进行判断'''B = torch.tensor([[1, 2, 3], [2, 0, 4], [3, 4, 5]])B == B.T

2.3.4 张量

X = torch.arange(36).reshape(4, 3, 3)X

2.3.5 张量算法的基本性质

''' 注意 B = A 和 B = A.clone()之间的区别B = A 则B和A指向同一块内存空间B = A.clone() 则是新分配一块内存给B，内容和A一样'''A = torch.arange(20, dtype = torch.float32).reshape(5, 4)B = A.clone()A, B, A + B

''' 重大发现：PyTorch和Numpy中，*是按照元素相乘，也就是Hadamard积如果非得使用矩阵成大，那就得用@'''A = torch.arange(4).reshape(2, 2)B = torch.arange(4).reshape(2, 2)A * B, A @ B

2.3.6 降维

''' sum()可以对张量中所有元素求和利用dtype指定元素类型的时候还不能直接用float32，还得指定为torch.float32使用sum()跟张量的形状无关，无论张量是几维的，都可以对所有元素求和。'''import torch X = torch.arange(10, dtype = torch.float32).reshape(2, 5)X, X.sum()

''' axis  = 0 纵向操作axis = 1 横向操作'''A = torch.arange(12, dtype = torch.int32).reshape(3, 4)A_sum_axis0 = A.sum(axis = 0)A, A_sum_axis0

非降维求和

''' 如果在计算sum的时候不适用keepdims = True, 那么默认降维；使用keepdims = True，那就是非降维求和。非降维求和的好处是有利于广播。什么是广播？回忆一下：是否适用广播机制是由从右到左逐一比较维度决定的。1. 相等2. 二选一为13. 不存在非降维求和可以让二维的还是保持二维，只不过把其中一维压缩为1，适用广播机制。'''import torchA = torch.arange(20, dtype = torch.float32).reshape(4, 5)A_hengxiang_junzhi = A.sum(axis = 1, keepdims = True)A, A.shape, A_hengxiang_junzhi, A_hengxiang_junzhi.shape

''' 广播机制加减乘除都能用，并不仅仅局限于加法这么看我前面"2.1数据操作"中对于广播机制应用场景很少的观点确实有问题。广播机制是一种很优秀的，效率很高的方法，能对数据进行很快速的，方便的，简洁的运算而且加减乘除都能用'''print(f"{A + A_hengxiang_junzhi},\n\n{A - A_hengxiang_junzhi}, \n\n{A * A_hengxiang_junzhi}, \n\n{A / A_hengxiang_junzhi}")

2.3.7 点积

''' 点积：逐元素相乘再相加'''import torchX = torch.tensor([1, 2, 3])Y = torch.tensor([1, 2, 3])torch.dot(X, Y)

''' 计算两个向量的点积有两种方法：torch.dot(X, Y)另一种是：torch.sum(X*Y)由于float32, int32, double64, sum() 等等都是来自torch里面的所以在用的时候基本上都得指定torch.balabala'''torch.sum(X*Y)

2.3.8 矩阵向量积

''' torch.mv(A, X) 本质上就是在计算 A @ X问一下：arange是什么缩写？'''A = torch.arange(12).reshape(3, 4)X = torch.ones(4, dtype = torch.long)torch.mv(A, X)

2.3.9 矩阵矩阵乘法

''' mv = matrix * vectormm = matrix * matrix我觉得了解一下函数的缩写是很有必要的，这能帮助你更好得理解函数的用法A @ B'''A = torch.arange(12).reshape(3, 4)B = torch.arange(12).reshape(4, 3)torch.mm(A, B)

2.3.10 范数

''' L1范数是绝对值之和，L2范数是欧几里得距离（勾股定理）直接取norm()那就是L2范数，也就是欧几里得距离tensor，张量的默认数据类型是longnorm()计算的是欧几里得距离，涉及到开根号，整数开根号除了一些特殊的，比如3， 4， 5， 还有， 8， 10这种开出来就是是整数，但是大部分常见情况下都是复数或者小数，所以数据类型要么是complex，要么是floattorch默认的数据类型是int64, 也就是long'''x = torch.tensor([6, 8], dtype = torch.float)torch.norm(x)

''' 直接用norm()是L2范数，如果想要计算L1范数，也就是绝对值之和，那就是abs和sum搭配使用直接用torch.tensor()去定义向量的话，记住小括号里面还得加中括号'''x = torch.tensor([3, -4, -5])L1_norm = torch.abs(x).sum()L1_norm

''' L2范数针对向量，Frobenius范数针对矩阵，但是它们的计算并没有本质区别'''X = torch.ones(49).reshape(7, 7)torch.norm(X)

练习

1. 证明A转置的转置还是A

A = torch.arange(12).reshape(3, 4)B = A.T.TA == B

2. 证明A转+B转 = A+B的转

A = torch.arange(12).reshape(3, 4)B = torch.ones(12).reshape(3, 4)(A.T + B.T) == (A + B).T 

3. 给定任意方阵A，A + A转一定是对称矩阵吗

回答是肯定的。因为被主对角线切成的两部分，在经过A + A转以后两部分都是原上 + 原下，所以结果是一样的。

A = torch.arange(16).reshape(4, 4)B = A + A.T B == B.T

4. (2, 3, 4)的X，len(x)是什么

回答是2
验证一下

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

5. 对于任意形状的张量X,len(X)是否总是对应于X特定轴的长度?这个轴是什么?

len(x)输出的一定是第一个维度的值

6. 运行A/A.sum(axis=1)，看看会发生什么。请分析一下原因？

会报错。
因为当你不设置keepdim = True, 那么A.sum(axis = 1)算出来就被降维了。降维以后从右往左看，第一个维度分别是4和3，对不齐，用不了广播机制，报错。

A = torch.arange(12).reshape(3, 4)A.sum(axis = 1).shape, A.sum(axis = 1, keepdims = True).shape

7. (2, 3, 4)三个维度求和分别是什么形状？

''' 以哪个轴就是把哪个轴给噶掉，剩下的是什么轴就是什么形状。'''A = torch.arange(24).reshape(2, 3, 4)A.sum(axis = 0), A.sum(axis = 1), A.sum(axis = 2)

8. 为linalg.norm函数提供3个或更多轴的张量，并观察其输出。对于任意形状的张量这个函数计算得到什么?

''' linalg = linear + algbraord = order直接使用torch.norm()出来的就是L2范数但是linalg.norm()更加通用，通过ord参数指定范数的类型。'''X = torch.ones(49).reshape(7, 7)torch.linalg.norm(X, ord = "fro", keepdim = True), torch.linalg.norm(X, ord = "fro")

2.4 微积分

2.4.1 导数和微分

''' % matplotlib inline 作用是让matplotlib绘制的图像出现在Jupyter的单元格中，而不是出现在新弹出的窗口中。matplotlib_inline 用于控制内联图像的行为backend_inline 用来设置内联图像的属性from d2l import torch as d2l  相较于直接import torch，d2l里面实现的torch封装了更多函数，可以直接调用。'''%matplotlib inline import numpy as np from matplotlib_inline import backend_inline from d2l import torch as d2l def f(x):    return 3*x**2 - 4*x

''' h从0.1开始不断缩小，每次变为原来的十分之一，h变得越来越小，求出来的导数（或者说斜率）就越来越精确两个注意点：1. number, numerical 单词别写错了  2. 函数本身作为另一个函数的参数时，不需要带上自己的参数'''def numerical_lim(f, x, h):    return (f(x+h) - f(x)) / h h = 0.1x = 1for _ in range(5):    print(f"当h为{h: .5f}时，f(x)在x = {x}处的值为{numerical_lim(f, x, h): .5f}")    h = h * 0.1

def use_svg_display(): #@save    backend_inline.set_matplotlib_formats("svg")''' d2l.plt 这里的plt本质上就是 import matplotlib.pyplot as plt，只不过d2l包里面把这行代码已经写过了，因此可以通过d2l.plt直接用rcParams是全局配置字典，会影响后续所有图像的设置。'''def set_figsize(figsize = (6.5, 5.5)): #@save    use_svg_display()    d2l.plt.rcParams['figure.figsize'] = figsize     

''' legend用于给图中的线添加文字'''#@savedef set_axes(axes, xlabel, ylabel, xlim, ylim, xscale, yscale, legend):    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()

''' 代码挺多的，但是我依然认为需要自己敲一遍，不应该直接复制粘贴。哪怕是照着抄，也得自己写，因为后面的要求是要靠自己写出来。这一节主要是在定义一个plot函数，后面就可以直接用它绘图。如果调用同一个函数多次，那么形参的默认值只会在第一次调用时设置，后面再调用的时候使用的是同一个参数值，因此legend不能在形参处就设置为[], 只能先设置成None, 然后在plot()函数体内部更改legend的值，因为函数体内部每次调用都会被重新执行。d2l里面的很多函数其实就只是搬运工，只不过是把matplotlib.pyplot里面的东西换个位置搬出来。d2l本质上是d2l.torch, 当我想使用gca() get current axes时，不能直接d2l.gca()，因为d2l.torch里面没有gca()gca()存在于plt中，也就是调用的时候的得用d2l.plt.gca()'''#@savedef plot(X, Y = None, xlabel = None, ylabel = None, legend = None, xlim = None, ylim = None,          xscale = "linear", yscale = "linear", fmts = ("-", "m--", "g-.", "r:"), figsize = (6.5, 5.5), axes = None):    if legend == None:         legend = []        set_figsize(figsize)    axes = axes if axes else d2l.plt.gca()        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 == None:        X, Y = [[]]* len(X), X    elif has_one_axis(Y):        Y = [Y]         '''     直接对列表乘以2，是对列表内部元素的复制    '''    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)"])

2.4.2 偏导数 略

2.4.3 梯度

一个多元函数，对所有变量的偏导组合在一起就构成了梯度。

2.4.4 链式法则

链式法则本质上就是对复合函数求导。

练习

意外发现，原来Jupyter Notebook里面的Markdown单元格也是可以粘贴图像的

切线方程：y = 4*x - 4

一张图上画两条线，一条是f(x)，另一条是它在x=1处的切线

X = np.arange(0, 3, 0.1)plot(X, [x**3-x**(-1), 4*x-4], "x", "f(x)", legend = ["f(x)", "Tangent line: x = 1"])

两条杠，右下角写个2，这指的是L2范数
具体的计算方法应该是x1 ** 2 + x2 ** 2 + ... + xn ** 2 再开根号