数据操作

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


import torch
# 创建行向量
x = torch.arange(12)
# 访问沿轴形状
x.shape
# 元素总数 num element
x.numel()
# 改变张量形状
X = x.reshape(3, 4)
# 创建特殊张量
torch.zeros((2, 3, 4))
torch.ones((2, 3, 4))
torch.randn(3, 4)
torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])

# 运算
x + y, x - y, x * y, x / y, x ** y
X == Y
X.sum()
torch.exp(x)
# 沿轴连接（轴0）
torch.cat((X, Y), dim=0)

# 与numpy转换
A = X.numpy()
B = torch.tensor(A)
# 转换py标量
a.item()
float(a)

数据预处理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


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

# 加载数据集
# !pip install pandas
import pandas as pd
data = pd.read_csv(data_file)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34



# 创建出的数据集
#    NumRooms Alley   Price
# 0       NaN  Pave  127500
# 1       2.0   NaN  106000
# 2       4.0   NaN  178100
# 3       NaN   NaN  140000


# 利用iloc切分数据集
inputs = data.iloc[:, 0:2]
outputs = data.iloc[:, 2]
# 均值替换NaN
inputs = inputs.fillna(inputs.mean(numeric_only=True))
# 离散值处理
inputs = pd.get_dummies(inputs, dummy_na=True)


# 处理后的inputs
#    NumRooms  Alley_Pave  Alley_nan
# 0       3.0        True      False
# 1       2.0       False       True
# 2       4.0       False       True
# 3       3.0       False       True


# 转换为张量
import torch
X = torch.rensor(inputs.to_numpy(dtype=float))

# (tensor([[3., 1., 0.],
#          [2., 0., 1.],
#          [4., 0., 1.],
#          [3., 0., 1.]], dtype=torch.float64)

线代

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


import torch
# 标量
x = torch.tensor(3.0)
# 向量
x = torch.arange(4)
# 形状
len(x)
x.shape
# 矩阵 转置
A = torch.arange(20).reshape(5, 4)
A.T
# 张量
X = torch.arange(24).reshape(2, 3, 4)
# Hadamard积
A * B
# 降维沿轴求和
A_sum_axis0 = A.sum(axis=0)
# 非降维求和
sum_A = A.sum(axis=1, keepdims=True)
# 沿轴计算累计总和
A.cumsum(axis=0)
# 点积
torch.dot(x, y)
torch.sum(x*y)
# 矩阵向量积
torch.mv(A, x)
# 矩阵乘法
torch.(A, B)
# L2范数
torch.norm(u)
# L1范数需要手动求
torch.abs(u).sum()

微积分

亚导数

将导数扩展到不可导的地方，如y = |x| 的 x = 0 处

梯度

将倒数拓展到向量

自动求导

两种求导模式

	计算复杂度	内存复杂度
正向	O(n)	O(n) （需要存储所有中间结果）
反向	O(n)	O(1)

代码实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


x = torch.arange(4.0, requires_grad=True)
# x.requires_grad_(True)
x.grad
y = 2 * torch.dot(x, x)
# 反向传播计算x每个分量的梯度，结果在x.grad中
y.backward()
# PyTorch默认累计梯度
# 清除梯度值
x.grad_zero_()
# 分离并记录张量
u = y.detach()
# 自动微分同样可应用在py控制流中