环境准备

Anaconda

下载

Anaconda官网：https://www.anaconda.com/products/distribution

wget https://repo.anaconda.com/archive/Anaconda3-2022.10-Linux-x86_64.sh

安装

sh Anaconda3-2022.10-Linux-x86_64.sh

跟着屏幕提示输入需要信息即可，安装完成后重新加载一下环境变量

source ~/.bashrc

更换conda源

vim ~/.condarc

内容如下：

default_channels:
  - https://mirror.sjtu.edu.cn/anaconda/pkgs/r
  - https://mirror.sjtu.edu.cn/anaconda/pkgs/main
custom_channels:
  conda-forge: https://mirror.sjtu.edu.cn/anaconda/cloud/
  pytorch: https://mirror.sjtu.edu.cn/anaconda/cloud/
channels:
  - defaults

创建学习环境

conda create -n d2l python=3.9

激活环境

conda activate d2l

变更pip源头

pip config set global.index-url https://mirror.sjtu.edu.cn/pypi/web/simple

安装必要的包

安装torch

pip install torch==1.12.0
pip install torchvision==0.13.0

安装d2l包

pip install d2l

下载代码仓

git clone https://openi.pcl.ac.cn/Datawhale/d2l

注：如果没有git工具安装命令如下

(sudo) apt install git    #ubuntu系统
(sudo) yum install git  #centos系统

安装jupyter lab

个人比较喜欢使用juypter lab进行时间，如果喜欢使用notebook的话可以不执行这一步
安装

pip install jupyterlab

设置密码

jupyter lab passwd

启动juypterlab

jupyter lab --ip 0.0.0.0 --allow-root

至此环境准备工作全部完成

预备知识部分代码实践

数据操作

#引入包
import torch

我们可以使用 arange 创建一个行向量 x。这个行向量包含以0开始的前12个整数，它们默认创建为整数。也可指定创建类型为浮点数。张量中的每个值都称为张量的 元素（element）。例如，张量 x 中有 12 个元素。除非额外指定，新的张量将存储在内存中，并采用基于CPU的计算。

#创建12个元素的张量
x = torch.arange(12)
#查看张量形状
x.shape
#查看元素总数
x.numel()
#改变形状
X = x.reshape(3, 4)
#创建全0矩阵
torch.zeros((2, 3, 4))
#创建全1矩阵
torch.ones((2, 3, 4))
#标准高斯分布（正态分布）
torch.randn(3, 4)
#创建确定值的张量列表
torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])

运算符

#张量标准计算
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), torch.cat((X, Y), dim=1)

#判断
X == Y

#求和
X.sum()

广播机制

在上面的部分中，我们看到了如何在相同形状的两个张量上执行按元素操作。 在某些情况下，即使形状不同，我们仍然可以通过调用 广播机制（broadcasting mechanism）来执行按元素操作。 这种机制的工作方式如下：

1. 通过适当复制元素来扩展一个或两个数组，以便在转换之后，两个张量具有相同的形状；
2. 对生成的数组执行按元素操作。

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

a + b

索引和切片

#我们可以用[-1]选择最后一个元素，可以用[1:3]选择第二个和第三个元素
X[-1], X[1:3]

# 通过指定索引来将元素写入矩阵
X[1, 2] = 9

#为多个元素赋值
X[0:2, :] = 12

节省内存

运行一些操作可能会导致为新结果分配内存。 例如，如果我们用Y = X + Y，我们将取消引用Y指向的张量，而是指向新分配的内存处的张量。
在下面的例子中，我们用Python的id()函数演示了这一点， 它给我们提供了内存中引用对象的确切地址。 运行Y = Y + X后，我们会发现id(Y)指向另一个位置。 这是因为Python首先计算Y + X，为结果分配新的内存，然后使Y指向内存中的这个新位置。

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

运行结果:

False

这可能是不可取的，原因有两个：

1. 首先，我们不想总是不必要地分配内存。在机器学习中，我们可能有数百兆的参数，并且在一秒内多次更新所有参数。通常情况下，我们希望原地执行这些更新；
2. 如果我们不原地更新，其他引用仍然会指向旧的内存位置，这样我们的某些代码可能会无意中引用旧的参数。

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

运行结果：

True

转换为其他Python对象

#更改一个张量也会同时更改另一个张量
A = X.numpy()
B = torch.tensor(A)
type(A), type(B)

#将大小为1的张量转换为Python标量
a = torch.tensor([3.5])
a, a.item(), float(a), int(a)

数据预处理

# 创建数据集
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')

#读取数据集
import pandas as pd

data = pd.read_csv(data_file)
print(data)

注：如果没有安装pandas，只需取消对以下行的注释来安装pandas

pip install pandas

#处理缺失值
#用同一列的均值替换“NaN”项
inputs, outputs = data.iloc[:, 0:2], data.iloc[:, 2]
inputs = inputs.fillna(inputs.mean())
print(inputs)

inputs = pd.get_dummies(inputs, dummy_na=True)
print(inputs)

转换张量格式

import torch

X, y = torch.tensor(inputs.values), torch.tensor(outputs.values)

线性代数

标量、向量

#标量
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[3]

#长度、维度和形状
len(x)
x.shape

矩阵

#创建矩阵
A = torch.arange(20).reshape(5, 4)

#矩阵转置
A.T

#定义对称矩阵
B = torch.tensor([[1, 2, 3], [2, 0, 4], [3, 4, 5]])

#转置比较
B == B.T

张量

#创建张量
X = torch.arange(24).reshape(2, 3, 4)

张量算法的基本性质

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

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.shape, A.sum()

#调用函数时指定axis=0。 由于输入矩阵沿0轴降维以生成输出向量，因此输入轴0的维数在输出形状中消失。
A_sum_axis0 = A.sum(axis=0)
A_sum_axis0, A_sum_axis0.shape

#指定axis=1将通过汇总所有列的元素降维（轴1）。因此，输入轴1的维数在输出形状中消失
A_sum_axis1 = A.sum(axis=1)
A_sum_axis1, A_sum_axis1.shape

#沿着行和列对矩阵求和，等价于对矩阵的所有元素进行求和。
A.sum(axis=[0, 1])  # 结果和A.sum()相同

#调用函数来计算任意形状张量的平均值
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元素的累积总和
A.cumsum(axis=0)

点积（Dot Product）

y = torch.ones(4, dtype = torch.float32)
x, y, torch.dot(x, y)

#进行求和来表示两个向量的点积
torch.sum(x * y)

矩阵

#向量积
A.shape, x.shape, torch.mv(A, x)

#矩阵乘法
B = torch.ones(4, 3)
torch.mm(A, B)

范数

#计算向量L2范数
u = torch.tensor([3.0, -4.0])
torch.norm(u)

#将绝对值函数和按元素求和组合起来
torch.abs(u).sum()

#计算矩阵的Frobenius范数
torch.norm(torch.ones((4, 9)))

微积分

导数和微分

%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

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

运行结果：

h=0.10000, numerical limit=2.30000
h=0.01000, numerical limit=2.03000
h=0.00100, numerical limit=2.00300
h=0.00010, numerical limit=2.00030
h=0.00001, numerical limit=2.00003

def use_svg_display():  #@save
    """使用svg格式在Jupyter中显示绘图"""
    backend_inline.set_matplotlib_formats('svg')
    
def set_figsize(figsize=(3.5, 2.5)):  #@save
    """设置matplotlib的图表大小"""
    use_svg_display()
    d2l.plt.rcParams['figure.figsize'] = figsize

#生成图表的轴的属性
#@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()

#定义一个plot函数来简洁地绘制多条曲线
#@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)'])

自动微分

# 一个简单的例子
import torch

x = torch.arange(4.0)

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

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

y.backward()
x.grad

x.grad == 4 * x

# 在默认情况下，PyTorch会累积梯度，我们需要清除之前的值
x.grad.zero_()
y = x.sum()
y.backward()
x.grad

计算结果：

tensor([1., 1., 1., 1.])

非标量变量的反向传播

# 对非标量调用backward需要传入一个gradient参数，该参数指定微分函数关于self的梯度。
# 本例只想求偏导数的和，所以传递一个1的梯度是合适的
x.grad.zero_()
y = x * x
# 等价于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

x.grad.zero_()
y.sum().backward()
x.grad == 2 * x

计算结果：

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

Python控制流的梯度计算

def f(a):
    b = a * 2
    while b.norm() < 1000:
        b = b * 2
    if b.sum() > 0:
        c = b
    else:
        c = 100 * b
    return c

#计算梯度
a = torch.randn(size=(), requires_grad=True)
d = f(a)
d.backward()

a.grad == d / a

概率

#导入包
%matplotlib inline
import torch
from torch.distributions import multinomial
from d2l import torch as d2l

fair_probs = torch.ones([6]) / 6
multinomial.Multinomial(1, fair_probs).sample()

multinomial.Multinomial(10, fair_probs).sample()

# 将结果存储为32位浮点数以进行除法
counts = multinomial.Multinomial(1000, fair_probs).sample()
counts / 1000  # 相对频率作为估计值

#进行500组实验，每组抽取10个样本
counts = multinomial.Multinomial(10, fair_probs).sample((500,))
cum_counts = counts.cumsum(dim=0)
estimates = cum_counts / cum_counts.sum(dim=1, keepdims=True)

d2l.set_figsize((6, 4.5))
for i in range(6):
    d2l.plt.plot(estimates[:, i].numpy(),
                 label=("P(die=" + str(i + 1) + ")"))
d2l.plt.axhline(y=0.167, color='black', linestyle='dashed')
d2l.plt.gca().set_xlabel('Groups of experiments')
d2l.plt.gca().set_ylabel('Estimated probability')
d2l.plt.legend();

查阅文档

#查找模块中的所有函数和类
import torch

print(dir(torch.distributions))

#查找特定函数和类的用法
help(torch.ones)