跟着李沐老师学习深度学习（一）

    conda create --name d2l python=3.9 -y

    conda activate d2l

    pip install torch==1.12.0
    pip install torchvision==0.13.0
    pip install d2l==0.17.6

    d:
    cd D:\code\d2l

    mkdir d2l-zh && cd d2l-zh
    curl https://zh-v2.d2l.ai/d2l-zh-2.0.0.zip -o d2l-zh.zip

    jupyter notebook

    pip install rise

* 例如 `x = torch.arange(12)` 创建了一个包含 0 到 11 的一维张量。

* 例如 `torch.zeros((2, 3, 4))` 创建一个形状为 (2, 3, 4) 的全零张量。

* 例如 `torch.ones((2, 3, 4))` 创建一个形状为 (2, 3, 4) 的全一张量。

* 例如 z = torch.tensor([[2, 1, 3, 4], [1, 2, 3, 4], [4, 3, 1, 2]])。

    import torch
    
    # 张量表示一个数值组成的数组，这个数组可能有多个维度
    x = torch.arange(12)
    x
    
    # 可以通过张量的shape属性来访问张量的 形状 和 张量中的元素的总数
    x.shape
    
    x.numel() # 元素的总数：永远是个标量，这里是12
    
    # 要改变一个张量的形状而不改变元素数量和元素值，可以调用reshape函数
    X = x.reshape(3, 4)
    X
    
    # 使用全0、全1、其他常量或者从特定分布中随机采样的数字
    torch.zeros((2, 3, 4))
    
    torch.ones((2, 3, 4))
    
    # 通过提供包含数值的python列表（或嵌套列表）来为所需张量中的每个元素赋予确定值
    z = torch.tensor([[2, 1, 3, 4], [1, 2, 3, 4], [4, 3, 1, 2]])
    z.shape
    
    # 常见的标准算术运算符（+、-、*、/和**）都可以被升级为按元素运算
    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 # ** 是求幂运算
    
    # 按元素方式应用更多的计算
    torch.exp(x)
    
    # 可以把多个张量连结在一起
    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) # 在第0维合并
    torch.cat((x, y), dim=1) # 
    
    x == y
    
    # 对张量中的所有元素进行求和会产生一个只有一个元素的张量
    x.sum()
    
    # 即使形状不同，可以通过调用 广播机制（broadcasting mechanism）来执行按元素操作
    a = torch.arange(3).reshape((3, 1))
    b = torch.arange(2).reshape((1, 2))
    a, b
    
    a + b
    
    # 可以用-1 选择最后一个元素，可以用[1:3]选择第二个和第三个元素
    x[-1], x[1:3] #  x[-1]: 最后一行； x[1:3]：第一行和第二行
    
    # 除了读取之外，还可以通过指定索引来将元素写入矩阵
    x[1, 2] = 9
    x
    
    # 为多个元素赋值相同的值，只需要索引所有元素，然后为它们赋值
    x[0:2, :] = 12
    x
    
    x[0:2, 1:3] = 88
    x
    
    # 运行一些操作可能会导致为新结果分配内存
    before = id(y) # 将y的id存起来
    y = y + x
    id(y) == before
    
    # 执行原地操作
    z = torch.zeros_like(y)
    print('id(z):', id(z))
    z[:] = x + y
    print('id(z):', id(z))
    
    # 如果在后续计算中没有重复使用x，也可以使用x[:] = x + y 或 x += y 来减少操作的内存开销
    before = id(x)
    x += y
    id(x) == before
    
    # 转为numpy张量
    A = x.numpy()
    B = torch.tensor(A)
    type(A), type(B)
    
    # 将大小为1 的张量转换为python标量
    a = torch.tensor([5.3])
    a, a.item(), float(a), int(a)

* 例如 `os.makedirs(os.path.join('..', 'data'), exist_ok=True)` 创建 `../data` 目录。

* 例如 `with open(data_file, 'w') as f` 以写入模式打开文件。

* 例如 `f.write('NumRooms,Alley,Price\n')` 向文件中写入列名和数据样本。

* 例如 `data = pd.read_csv(data_file)` 从 CSV 文件 data_file 读取数据。

    # 数据预处理
    # 创建一个人工数据集，并存储在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 文件中加载原始数据集
    
    import pandas as pd
    
    data = pd.read_csv(data_file)
    print(data)
    
    data
    
    # 为了处理缺失的数据，典型的方法是 插值、删除，这里，将考虑前者
    
    inputs, outputs = data.iloc[:, 0:2], data.iloc[:, 2] # 将前三列放在inputs里面，将最后一列放在outputs里面
    inputs = inputs.fillna(inputs.mean())
    inputs
    
    # 对于inputs中的类别值或离散值，将“NaN”视为一个类别
    
    inputs = pd.get_dummies(inputs, dummy_na=True)
    print(inputs)
    
    # 现在inputs和outputs中的所有条目都是数值类型，它们可以转换为张量格式,深度学习一般使用float32的类型进行数据处理
    import torch
    
    X,Y = torch.tensor(inputs.values), torch.tensor(outputs.values)
    X,Y

    # 线性代数
    
    # 标量由只有一个元素的张量表示
    
    import torch
    
    x = torch.tensor([3.0])
    y = torch.tensor([2.0])
    
    x + y, x * y, x / y, x ** y
    
    # 向量： 可以看作由标量组成的列表
    
    x = torch.arange(4)
    x
    
    # 通过张量的索引来访问任一元素
    
    x[2], x[3]
    
    # 访问张量的长度
    
    len(x)
    
    # 只有一个轴的张量，形状只有一个元素
    
    x.shape
    
    #通过指定两个分量m 和 n 来创建一个形状为m * n的矩阵
    
    A = torch.arange(20).reshape(5, 4)
    A
    
    # 矩阵的转置
    A.T
    # 对称矩阵（symmetric matrix） A 等于其转置：A = A^T
    
    B = torch.tensor([[1, 2, 3], [2, 0, 4], [3, 4, 5]])
    B
    
    B == B.T
    
    # 就像是 向量是标量的推广， 矩阵是向量的推广一样，我们可以构建具有更多轴的数据结构
    
    x = torch.arange(24).reshape(2, 3, 4)
    x
    
    x = torch.arange(24).reshape(4, 3, 2)
    x
    
    # 给定具有相同形状的任何两个张量，任何按元素二元运算的结果都将是相同形状的张量
    
    A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
    B = A.clone() # 通过分配新内存，将A的一个副本分配给B
    A, A + B
    
    # 两个矩阵的按元素乘法称为：哈达玛积（hadamard product）
    
    A * B
    
    a = 2
    X = torch.arange(24).reshape(2, 3, 4)
    a + X, (a * X).shape
    
    # 计算其元素的和
    
    x = torch.arange(4, dtype=torch.float32)
    x, x.sum()
    
    # 表示任意形状张量的元素和
    
    A = torch.arange(20).reshape(5, 4)
    A.shape, A.sum()
    
    A = torch.arange(20 * 2, dtype=torch.float32).reshape(2, 5, 4)
    A, A.shape, A.sum()
    
    # 指定求和汇总张量的轴
    
    A_sum_axis0 = A.sum(axis=0)
    A_sum_axis0, A_sum_axis0.shape
    
    A_sum_axis1 = A.sum(axis=1)
    A_sum_axis1, A_sum_axis1.shape
    
    A.sum(axis=[0, 1]) # 和A.sum()类似
    
    A.sum(axis=[0, 1]).shape
    
    # 一个与求和相关的量是 **平均值** （mean或average）
    
    A.mean(), A.sum() / A.numel()
    
    A.mean(axis=0), A.sum(axis=0)/A.shape[0]
    
    # 计算总和或均值时保持轴数不变
    
    sum_A = A.sum(axis=1, keepdims=True)
    A, sum_A
    
    # 通过广播将A 除以sum_A (使用广播的前提：两个维度必须一致)
    
    A / sum_A
    
    # 某个轴计算A元素的累积总和
    
    A.cumsum(axis=0)
    
    # 点积是相同位置的按元素乘积的和
    
    y = torch.ones(4, dtype=torch.float32)
    x, y, torch.dot(x, y)
    
    # 可以通过执行按元素乘法，然后进行求和来表示两个向量的点积
    
    torch.sum(x * y)
    
    # 矩阵向量积Ax是一个长度为m的列向量，其第i个元素是点积(ai)^T x
    
    A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
    A.shape, x.shape, torch.mv(A, x)
    
    #可以将矩阵-矩阵乘法AB看作是简单地执行m次矩阵-向量积，并将结果拼接在一起，形成了一个n * m 矩阵
    
    B = torch.ones(4, 3)
    torch.mm(A, B)
    
    # L2范数是向量元素平方和的平方根
    
    u = torch.tensor([3.0, -4.0])
    torch.norm(u)
    
    # L1 范数：表示为向量元素的绝对值之和
    
    torch.abs(u).sum()
    
    # 矩阵的F 范数：是矩阵元素的平方和的平方根
    
    torch.ones((4, 9)), torch.norm(torch.ones((4, 9)))
    
    # 关于sum的补充
    
    import torch
    a = torch.arange(20*2, dtype=torch.float32).reshape((2, 5, 4))
    
    a.sum(axis=1), a.sum(axis=1).shape # [2, 4]
    a.sum(axis=0), a.sum(axis=0).shape # [5, 4]
    
    a.sum(axis=[0, 2]), a.sum(axis=[0, 2]).shape # [5]
    
    a.sum(axis=1, keepdims=True), a.sum(axis=1, keepdims=True).shape # [2, 1, 4]
    
    a.sum(axis=[0, 2], keepdims=True), a.sum(axis=[0, 2], keepdims=True).shape # [1, 5, 1]

* 将代码分解成操作子
* 将计算表示成一个无环图  

* 计算复杂度：O（n）， n是操作子个数 
  * 通常正向和反向的代价类似

    import torch
    x = torch.arange(4.0)

    x.requires_grad_(True) # 等价于 x = torch.arange(4.0, requires_gard=True)
    x.grad # 默认值是None

    y = 2 * torch.dot(x, x)

    y.backward() # 求导
    x.grad # 访问导数
    
    x.grad == 4 * x

    x.grad.zero_() # 将所有梯度清零
    y = x.sum() 
    y.backward()
    x.grad

    x.grad.zero_() # 将所有梯度清零
    y = x * x # 当y也是一个向量的时候，在数学中，得到的是一个矩阵，但在深度学习中，会先将y进行求和在调用backward
    
    # 等价于y.backward(torch.ones(len(x)))
    y.sum().backward()
    x.grad

    x.grad.zero_()
    y = x * x
    u = y.detach() # 常数，不计算梯度
    z = u * x 
    z.sum().backward()
    x.grad == u, u
    
    x.grad.zero_()
    y.sum().backward()
    x.grad == 2 * x

    def f(a):
    b = a 
    while b.norm() < 1000:
        b = b 
    if b.sum() > 0:
        c = b
    else:
        c = 100 * b
    return c
    # 分析f(a)，对于任何a，存在某个常量标量k，使得f(a)=k*a，其中k的值取决于输入a，因此可以用d/a验证梯度是否正确。
    a = torch.randn(size=(), requires_grad=True) # 创建一个形状为空的张量 a，并且将其设为需要计算梯度
    d = f(a)
    d.backward()
    
    a.grad == d / a