动手学深度学习PyTorch版

基本的数据操作

import torch
# 创建一个行向量，默认为从0开始的12个整数
# n维数组也称为张量
x = torch.arange(12)
x

# 张量的形状
x.shape

# 张量的大小,张量所有元素的个数
x.numel()

#修改张量的形状
x = x.reshape(3,4)

#生成形状为3*4的两个向量，向量中数字全为0
torch.zeros(2,3,4)

#生成形状为3*4的两个向量，向量中数字全为1
torch.ones(2,3,4)

随机取样

# 创建一个形状为(3,4)的张量，其中每个元素为0，标准差为1的标准高斯分布（正态分布）中随机取样
torch.randn(3,4)

张量的运算操作

x = torch.tensor([1.0, 2.0, 3.0, 4])
y = torch.tensor([2, 3, 5, 7])
x + y, x - y, x * y, x / y, x ** y

张量的拼接操作

x = torch.arange(12, dtype=torch.float32).reshape((3, 4))
y = torch.tensor([[2.0, 1, 3, 4],[1, 2, 5, 6],[5, 6, 2, 1]])
print(x)
# dim=0时y的每一行都添加到x的每一行下方
torch.cat((x, y),dim=0),torch.cat((x, y),dim=1)

广播机制

# 我们可以在形状不同的两个张量调用广播机制进行按元素操作
# 可以适当复制元素来扩展一个或两个数组
import torch
a = torch.arange(3).reshape(3,1)
b = torch.arange(2).reshape(1,2)
a, b

# 矩阵a将复制列，矩阵b将复制行，然后按元素相加
# 复制的都是原本的元素
a + b

索引和切片

# 索引和切片
x = torch.arange(12).reshape(3,4)
# 输出的是行
print(x[-1])
print(x[1:3])

# 第2行，第三列的元素改为9
x[1,2] = 9

#前两行的所有元素都变为12
x[0:2, : ] = 12

转换为其他python对象

# 转换为其他python对象
a = x.numpy()
b = torch.tensor(a)
type(a), type(b)
# numpy.ndarray

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

数据预处理

写入文件

# os模块提供了很多与操作系统交互的功能，如文件路径操作、文件读写
import os

# exist_ok=True 表示如果目录已存在，则不会抛出异常，而是继续执行
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,125700\n')
    f.write('2,NA,106000\n')
    f.write('4,NA,10000\n')
    f.write('NA,NA,120000\n')

加载原始数据集

# 要从创建的CSV文件中加载原始数据集，我们导入pandas包并调用read_csv函数
import pandas as pd

data = pd.read_csv(data_file)
data

处理缺失值

inputs, outputs = data.iloc[:, 0:2], data.iloc[:, 2]
# 将inputs中的所有NaN值替换为其非空值的平均值，并将结果重新赋值给inputs
inputs = inputs.fillna(inputs.mean())
print(inputs)

# 将分类变量（也称为因子或枚举类型）转换为一种称为独热编码（One-Hot Encoding）的格式
# 当 dummy_na=True 时，该函数还会为缺失值（NaN）创建额外的列
inputs = pd.get_dummies(inputs, dummy_na=True)
print(inputs)

转换为张量格式

# 转换为张量格式
import torch

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

张量算法

import torch
x = torch.arange(4, dtype=torch.float32)
x,x.sum()

x = torch.arange(20, dtype=torch.float32).reshape(5, 4)
print(x)
# 张量的每列相加
x_sum_axis0 = x.sum(axis=0)
# 张量的每行相加
x_sum_axis1 = x.sum(axis=1)
print(x_sum_axis0)
print(x_sum_axis1)
print(x_sum_axis0.shape)
print(x_sum_axis1.shape)
x_sum = x.sum(axis=[0, 1])
print(x_sum)
print(x.mean())
print(x.sum() / x.numel())

非降维求和

sum_x = x.sum(axis=1, keepdims=True)
print(sum_x)
print(x / sum_x)
# 每一行的数都加上上面的数字
print(x.cumsum(axis=0))

向量的点积操作

x = torch.arange(4, dtype=torch.float32)
y = torch.ones(4, dtype=torch.float32)
x, y, torch.dot(x, y)
# 两个操作结果是一样的
torch.sum(x * y)


# 矩阵向量积
A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
torch.mv(A, y)

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

范数

范数的性质

①： $f(\alpha x) =\left | \alpha \right |f(x)$

②： $f(x+y)\leqslant f(x)+f(y)$

③： $f(x)\geqslant 0$

# L2范数
u = torch.tensor([3.0, -4.0])
print(torch.norm(u))    # tensor(5.)
# L1范数
print(torch.abs(u).sum())    # tensor(7.)

# 弗罗贝尼乌斯范数：矩阵元素平方和的平方根
# 矩阵元素为4行9列的1
torch.norm(torch.ones((4,9)))    # tensor(6.)

微积分

导数和微分

# 使 Matplotlib 生成的图形在 Notebook 单元格中直接显示，而不是弹出一个新的窗口
%matplotlib inline
import numpy as np
# 在 Matplotlib 中，后端（backend）是指用于渲染图形和与用户界面交互的软件组件。不同的后端支持不同的输出格式和交互方式。
# 通常使用内联后端（inline backend）来在单元格中直接显示图形。
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

保存标记 #save

#@save 会将对应的函数,类或语句保存在d2l包中
# 以后无需重新定义就可以直接调用它们
def use_svg_display():  #@save
    # 使用svg格式在jupyter中显示绘图
    backend_inline.set_matplotlib_formats('svg')

def set_figsize(figsize=(3.5, 2.5)): #@save
    # 第一个元素是宽度,第二个元素是高度
    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()

#@save
# 一个元组，用于设置X轴的显示范围。例如，xlim=(0, 10)会确保X轴只显示从0到10的值
# legend:一个标签列表，用于表示数据集中的每个系列

# fmts:一个字符串元组，用于定义数据系列的绘制格式。
# 例如，'-'表示实线，'m--'表示紫色的虚线，'g-.'表示绿色的点划线，'r:'表示红色的点状线。
# axes这个参数允许用户在一个已存在的图形上绘制，而不是创建一个新的图形。
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)

    # d2l.plt.gca()表示当前的轴对象
    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)'])

偏导数和梯度

我们可以连接一个多元函数对其所有变量的偏导数，以得到该函数的梯度向量

函数f(x)相对于x的梯度是一个包含n个偏导数的向量

自动微分

# 自动微分使系统能够随后反向传播梯度
import torch
x = torch.arange(4.0)

# 一个标量函数关于向量x的梯度是向量，并且与x有相同的形状
# x.requires_grad 是 True，那么在 x 上进行的所有操作都会被跟踪，
# 这样当你调用 .backward() 方法时，PyTorch可以计算出 x 关于某个标量函数（通常是损失函数）的梯度
x.requires_grad_(True)
print(x.grad)   # 默认值为None
y = 2 * torch.dot(x, x)
print(y)

# x是一个长度为4的向量，计算x和x的点积，我们赋值给y的标量输出
# 通过调用反向传播函数来自动计算y关于x的每个分量的梯度  4x
y.backward()
x.grad

# 在默认情况下，PyTorch会累积梯度，我们需要清除之前的值
# 就地操作，直接修改原始张量
# .zero()：非就地操作，返回一个新的零张量，原始张量保持不变
x.grad.zero_()
print(x)
print(x.grad)

y = x.sum()
print(y)

# 代码执行反向传播操作，计算y相对于x的梯度，并将结果存储在x.grad中
# 首先给网络输入一组训练数据，并计算输出结果；然后计算输出结果与实际结果的差异，得到网络的误差；
# 接着计算每个节点对误差的贡献，并将这些贡献反向传播到前一层；
# 最后根据贡献的大小调整每个节点的权重，使得误差减小
y.backward()

# 因为 y 是 x 的所有元素的和，所以 y 关于 x 的梯度是一个全为 1 的向量
print(x.grad)

x.grad.zero_()
y = x * x
# 等价于y.backward(torch.ones(len(x)))
y.sum().backward()
x.grad

张量的分离计算操作

x.grad.zero_()
y = x * x
print(y)
# 处理计算图和梯度反向传播时更加灵活地控制哪些张量需要参与梯度计算，哪些张量不需要参与梯度计算
# 从计算图中分离出来的新张量u，它的值与y相同，不再追踪计算历史
u = y.detach()
print(u)

# 通过反向传播函数计算z = u * x 关于x的偏导数，同时将u作为常数处理
z = u * x
print(z)

z.sum().backward()
x.grad == u