本文目录

环境安装

PyTorch官网Jupyter NoteBook

PyTorch数据类型操作

import torchx = torch.arange(12)  # 使用arange创建一个行向量x tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
x.shape  # 通过张量的 shape 属性来访问张量的形状 torch.Size([12])
x.numel()  # 张量中元素的总数 12
X = x.reshape(3, 4)  # 要改变张量的形状
tensor([[ 0,  1,  2,  3],[ 4,  5,  6,  7],[ 8,  9, 10, 11]])
# reshape支持自动计算出一个维度用法 x.reshape(-1,4)或x.reshape(3,-1)等价于x.reshape(3,4)。torch.zeros((2, 3, 4))  # 创建全0张量
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.]]])torch.ones((2, 3, 4))  # 创建全1张量
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.]]])torch.randn(3, 4)  # 创建随机张量
tensor([[ 1.0962,  0.7937, -1.8389, -0.1989],[ 1.5041,  0.2080,  1.4398,  1.8232],[-1.3178, -0.8359,  1.8015,  0.4061]])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  # **运算符是求幂运算
(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.]))torch.exp(x)  # 张量求幂
tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])# 对张量分别按行和按列进行连结(concatenate)
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)
(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.]]))# 对于每个位置，如果 X 和 Y 在该位置相等，则新张量中相应项的值为1，这意味着逻辑语句 X == Y 在该位置处为真，否则该位置为 0。
X == Y
tensor([[False,  True, False,  True],[False, False, False, False],[False, False, False, False]])# 对张量中的所有元素进行求和会产生一个只有一个元素的张量。
X.sum()
tensor(66.)# 在大多数情况下，我们将沿着数组中长度为1的轴进行广播
a = torch.arange(3).reshape((3, 1))
b = torch.arange(2).reshape((1, 2))
a, b# 由于 a 和 b 分别是 3×1 和 1×2 矩阵，如果我们让它们相加，它们的形状不匹配。
# 我们将两个矩阵广播为一个更大的 3×2 矩阵，如下所示：矩阵 a将复制列，矩阵 b将复制行，然后再按元素相加。
a + b
tensor([[0, 1],[1, 2],[2, 3]])# 索引和切片
X = torch.arange(12, dtype=torch.float32).reshape((3,4))
tensor([[ 0.,  1.,  2.,  3.],[ 4.,  5.,  6.,  7.],[ 8.,  9., 10., 11.]])
X[-1], X[1:3]
(tensor([ 8.,  9., 10., 11.]),tensor([[ 4.,  5.,  6.,  7.],[ 8.,  9., 10., 11.]]))
# 写值
X[1, 2] = 9
tensor([[ 0.,  1.,  2.,  3.],[ 4.,  5.,  9.,  7.],[ 8.,  9., 10., 11.]])# 多元素写值
X[0:2, :] = 12
tensor([[12., 12., 12., 12.],[12., 12., 12., 12.],[ 8.,  9., 10., 11.]])# 节省内存写法一
Z = torch.zeros_like(Y)
print('id(Z):', id(Z))  # id(Z): 139674315734208
Z[:] = X + Y
print('id(Z):', id(Z))  # id(Z): 139674315734208# 节省内存写法二
X[:] = X + Y
X += Y# tensor与ndarray数据转换
tensor_cpu = torch.ones((2,2))  # 创建CPU类型的张量
tensor_gpu = tensor_cpu.cuda()  # CPU转GPU
tensor_cpu = tensor_gpu.cpu()   # GPU转CPU
np_array= tensor_cpu.numpy()    # tensor转ndarray
torch.from_numpy(np.ones((2,2)))  # ndarray转tensor(保留精度，ndarray默认64位精度，tensor默认32位。若通过from_numpy的方式，则会保留原来64位精度)
torch.Tensor(np.ones((2,2)))      # ndarray转tensor方式二(丢失精度，64位浮点数截断为32位)
torch.ones((1,1)).item()        # tensor cpu转scalar

pandas读写数据集

import os# 写入数据集
os.makedirs(os.path.abspath('data'), exist_ok=True)
data_file = os.path.join(os.path.abspath('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 pddata = pd.read_csv(data_file)
print(data)  # type(data) = pandas.core.frame.DataFrame
#  NumRooms Alley   Price
0       NaN  Pave  127500
1       2.0   NaN  106000
2       4.0   NaN  178100
3       NaN   NaN  140000# 读取第0行数据
data.loc[0]
NumRooms       NaN
Alley         Pave
Price       127500
Name: 0, dtype: object# 读取第0行的Price字段
data.loc[0]["Price"]
127500# 处理缺失值
inputs, outputs = data.iloc[:, 0:2], data.iloc[:, 2]
inputs = inputs.fillna(inputs.mean(numeric_only=True))
print(inputs)NumRooms Alley
0       3.0  Pave
1       2.0   NaN
2       4.0   NaN
3       3.0   NaN# 将NaN转换为0/1表示
# 对于inputs中的类别值或离散值，我们将“NaN”视为一个类别。由于“巷子”(“Alley”)列只接受两种类型的类别值“Pave”和“NaN”，pandas可以自动将此列转换为两列“Alley_Pave”和“Alley_nan”。巷子类型为“Pave”的行会将“Alley_Pave”的值设置为1，“Alley_nan”的值设置为0。缺少巷子类型的行会将“Alley_Pave”和“Alley_nan”分别设置为0和1。
inputs = pd.get_dummies(inputs, dummy_na=True)
print(inputs)NumRooms  Alley_Pave  Alley_nan
0       3.0           1          0
1       2.0           0          1
2       4.0           0          1
3       3.0           0          1# 转换为张量格式
X, y = torch.tensor(inputs.values), torch.tensor(outputs.values)
X, y
(tensor([[3., 1., 0.],[2., 0., 1.],[4., 0., 1.],[3., 0., 1.]], dtype=torch.float64),tensor([127500, 106000, 178100, 140000]))# 导入库
import numpy as np
import pandas as pd# 导入CSV或者xlsx文件：
df = pd.DataFrame(pd.read_csv('name.csv',header=1))
df = pd.DataFrame(pd.read_excel('name.xlsx'))# 用pandas创建数据表：
df = pd.DataFrame({"id":[1001,1002,1003,1004,1005,1006],
"date":pd.date_range('20130102', periods=6),
"city":['Beijing ', 'SH', ' guangzhou ', 'Shenzhen', 'shanghai', 'BEIJING '],
"age":[23,44,54,32,34,32],
"category":['100-A','100-B','110-A','110-C','210-A','130-F'],
"price":[1200,np.nan,2133,5433,np.nan,4432]},
columns =['id','date','city','category','age','price'])# 查看维度
df.shape
(6, 6)# 数据表基本信息(维度、列名称、数据格式、所占空间等)
df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 6 entries, 0 to 5
Data columns (total 6 columns):#   Column    Non-Null Count  Dtype
---  ------    --------------  -----         0   id        6 non-null      int64         1   date      6 non-null      datetime64[ns]2   city      6 non-null      object        3   category  6 non-null      object        4   age       6 non-null      int64         5   price     4 non-null      float64
dtypes: datetime64[ns](1), float64(1), int64(2), object(2)
memory usage: 416.0+ bytes# 每一列数据的格式
df.dtypes
id                   int64
date        datetime64[ns]
city                object
category            object
age                  int64
price              float64
dtype: object# 某一列格式
df['B'].dtype# 空值
type(df.isnull())
df.isnull()
pandas.core.frame.DataFrame
id  date    city    category    age price
0   False   False   False   False   False   False
1   False   False   False   False   False   True
2   False   False   False   False   False   False
3   False   False   False   False   False   False
4   False   False   False   False   False   True
5   False   False   False   False   False   False

矩阵操作

# 创建矩阵
A = torch.arange(20).reshape(5, 4)
A
tensor([[ 0,  1,  2,  3],[ 4,  5,  6,  7],[ 8,  9, 10, 11],[12, 13, 14, 15],[16, 17, 18, 19]])# 矩阵转置
A.T
tensor([[ 0,  4,  8, 12, 16],[ 1,  5,  9, 13, 17],[ 2,  6, 10, 14, 18],[ 3,  7, 11, 15, 19]])# 矩阵运算
A = torch.arange(20, dtype=torch.float32).reshape(5, 4)
B = A.clone()  # 通过分配新内存，将A的一个副本分配给B
A, A + B, A * B
(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.]]),tensor([[  0.,   1.,   4.,   9.],[ 16.,  25.,  36.,  49.],[ 64.,  81., 100., 121.],[144., 169., 196., 225.],[256., 289., 324., 361.]]))# 降维运算
x = torch.arange(4, dtype=torch.float32)
x, x.sum()
(tensor([0., 1., 2., 3.]), tensor(6.))A.shape, A.sum()
(torch.Size([5, 4]), tensor(190.))A
(tensor([[ 0.,  1.,  2.,  3.],[ 4.,  5.,  6.,  7.],[ 8.,  9., 10., 11.],[12., 13., 14., 15.],[16., 17., 18., 19.]]),
A_sum_axis0 = A.sum(axis=0)
A_sum_axis0, A_sum_axis0.shape
(tensor([40., 45., 50., 55.]), torch.Size([4]))# 降维运算是一类操作的统称，例如求平均也是降维运算
A.sum(axis=[0, 1])
A.mean(), A.sum() / A.numel()
(tensor(9.5000), tensor(9.5000))
A.mean(axis=0), A.sum(axis=0) / A.shape[0]
(tensor([ 8.,  9., 10., 11.]), tensor([ 8.,  9., 10., 11.]))# 非降维求和，使用广播机制保留维度
sum_A = A.sum(axis=1, keepdims=True)
sum_A
tensor([[ 6.],[22.],[38.],[54.],[70.]])A / sum_A
tensor([[0.0000, 0.1667, 0.3333, 0.5000],[0.1818, 0.2273, 0.2727, 0.3182],[0.2105, 0.2368, 0.2632, 0.2895],[0.2222, 0.2407, 0.2593, 0.2778],[0.2286, 0.2429, 0.2571, 0.2714]])# 点积
y = torch.ones(4, dtype = torch.float32)
x, y, torch.dot(x, y)
(tensor([0., 1., 2., 3.]), tensor([1., 1., 1., 1.]), tensor(6.))
torch.sum(x * y)
tensor(6.)# 矩阵-向量积
A.shape, x.shape, torch.mv(A, x)
(torch.Size([5, 4]), torch.Size([4]), tensor([ 14.,  38.,  62.,  86., 110.]))# 矩阵-矩阵乘法
B = torch.ones(4, 3)
torch.mm(A, B)
tensor([[ 6.,  6.,  6.],[22., 22., 22.],[38., 38., 38.],[54., 54., 54.],[70., 70., 70.]])# 范数
# 一个向量的范数告诉我们一个向量有多大。 这里考虑的大小(size)概念不涉及维度，而是分量的大小。
# 计算L2范数
u = torch.tensor([3.0, -4.0])
torch.norm(u)
tensor(5.)
# 计算L1范数
torch.abs(u).sum()
tensor(7.)

自动求导

# 对函数y=2x⊤x求导# 创建输入值，包含四个元素的一维向量
x = torch.arange(4.0)
x
tensor([0., 1., 2., 3.])# 共享内存，减少内存损耗
x.requires_grad_(True)  # 等价于 `x = torch.arange(4.0, requires_grad=True)`
x.requires_grad  # 默认值是False# 计算y
# x是一个长度为4的向量，计算x和x的内积，得到了我们赋值给y的标量输出。
y = 2 * torch.dot(x, x)
y
tensor(28., grad_fn=<MulBackward0>)# 可以通过调用反向传播函数来自动计算y关于x每个分量的梯度，并打印这些梯度。
y.backward()
x.grad
tensor([ 0.,  4.,  8., 12.])# 函数y=2x⊤x关于x的梯度应为4x。让我们快速验证我们想要的梯度是否正确计算。
x.grad == 4 * x
tensor([True, True, True, True])# 在默认情况下，PyTorch会累积梯度，我们需要清除之前的值
x.grad.zero_()
y = x.sum()
y.backward()
x.grad# 非标量变量的反向传播
# 对非标量调用`backward`需要传入一个`gradient`参数，该参数指定微分函数关于`self`的梯度。
# 在我们的例子中，我们只想求偏导数的和，所以传递一个1的梯度是合适的
x.grad.zero_()
y = x * x
y.sum().backward()  # 等价于y.backward(torch.ones(len(x)))# 也可以y.backward(torch.ones_like(x))
x.grad# 分离计算
# 将计算移动到记录的计算图之外
# 在这里，我们可以分离y来返回一个新变量u，该变量与y具有相同的值，但丢弃计算图中如何计算y的任何信息。换句话说，梯度不会向后流经u到x。因此，下面的反向传播函数计算z=u*x关于x的偏导数，同时将u作为常数处理，而不是z=x*x*x关于x的偏导数。
x.grad.zero_()
y = x * x
u = y.detach()  # !Important
z = u * x
z.sum().backward()
x.grad == u
tensor([True, True, True, True])# Python控制流的梯度计算
def f(a):b = a * 2while b.norm() < 1000:b = b * 2if b.sum() > 0:c = belse:c = 100 * breturn ca = torch.randn(size=(), requires_grad=True)  # 创建一维随机向量，维度为0，即只有一个数据
d = f(a)
d.backward()

概率论

# 导入库
%matplotlib inline
import torch
from torch.distributions import multinomial
from d2l import torch as d2l# 对丢色子进行抽样，众所周知每个面的概率是均分1/6
fair_probs = torch.ones([6]) / 6# Multinomial函数第一参数为重复次数，第二参数为概率向量
multinomial.Multinomial(1, fair_probs).sample()