动手学深度学习（Pytorch版）代码实践-深度学习基础-01基础函数的使用

01基础函数的使用

主要内容

1. 张量操作：创建和操作张量，包括重塑、填充、逐元素操作等。
2. 数据处理：使用pandas加载和处理数据，包括处理缺失值和进行one-hot编码。
3. 线性代数：包括矩阵运算、求和、均值、点积和各种范数计算。
4. 自动求导：使用PyTorch的自动求导功能计算梯度，并演示梯度清除和分离计算图的操作。

import torch
import pandas as pd
import os

# 创建和操作张量
# 张量表示一个数值组成的数组，这个数组可能有多个维度
x = torch.arange(12)  # 创建一个包含从0到11的向量
print("x:", x)  # 打印张量x

print("x的形状:", x.shape)  # 打印张量的形状

print("x中的元素总数:", x.numel())  # 打印张量中元素的总数

# 改变一个张量的形状而不改变元素数量和元素值，采用reshape
X = x.reshape(3, 4)  # 将x重塑为一个3行4列的矩阵
print("重塑后的X:", X)  # 打印重塑后的X

# 创建全0，全1张量
print("全零张量:", torch.zeros((2, 3, 4)))  # 创建一个形状为(2,3,4)的全0张量
print("全一张量:", torch.ones((2, 3, 4)))  # 创建一个形状为(2,3,4)的全1张量

# 使用包含数值的Python列表创建张量
t = torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])  # 创建张量t
print("从列表创建的张量:", t)  # 打印张量t
print("张量t的形状:", t.shape)  # 打印张量t的形状

# 张量操作
X = torch.arange(12, dtype=torch.float32).reshape((3, 4))  # 创建并重塑张量X
Y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])  # 创建张量Y

Z = torch.zeros_like(X)  # 创建一个形状和X相同的全零张量
Z[:] = X + Y  # 计算X和Y的逐元素加法
print("Z (X + Y):", Z)  # 打印Z
print("Z的转置:", Z.T)  # 打印Z的转置

# 使用pandas创建和处理数据集
# 创建一个人工数据集，并存储在CSV（逗号分隔值）文件中
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')

data = pd.read_csv(data_file)  # 读取CSV文件
print("从CSV加载的数据:", data)  # 打印加载的数据

inputs, outputs = data.iloc[:, 0:2], data.iloc[:, 2]  # 分离输入和输出
inputs['NumRooms'] = inputs['NumRooms'].fillna(inputs['NumRooms'].mean())  # 用均值填充缺失值
print("处理后的输入数据:", inputs)  # 打印处理后的输入数据

inputs = pd.get_dummies(inputs, dummy_na=True).astype('float')  # 转换类别变量并将其转换为浮点型
print("独热编码后的输入数据:", inputs)  # 打印独热编码后的输入数据

X = torch.tensor(inputs.values)  # 将输入数据转换为张量
Y = torch.tensor(outputs.values)  # 将输出数据转换为张量
print("输入数据的张量X:", X)  # 打印输入数据的张量X
print("输出数据的张量Y:", Y)  # 打印输出数据的张量Y

# 线性代数操作
A = torch.arange(20, dtype=torch.float32).reshape(5, 4)  # 创建并重塑张量A
B = A.clone()  # 通过分配新内存，将A的副本分配给B
print("矩阵A:", A)  # 打印矩阵A
print("矩阵A + B:", A + B)  # 矩阵加法
print("矩阵A * B:", A * B)  # 矩阵逐元素乘法

a = 2
X = torch.arange(24).reshape(2, 3, 4)  # 创建并重塑张量X
print("张量X:", X)  # 打印张量X
print("a + X:", a + X)  # 标量和张量相加
print("a * X的形状:", (a * X).shape)  # 打印标量和张量相乘后的形状

# 求和与均值
A_sum_axis0 = A.sum(axis=0)  # 沿着第0维度求和
print("沿第0维度求和:", A_sum_axis0, "形状:", A_sum_axis0.shape)  # 打印求和结果及其形状

print("A中的元素总数:", A.numel())  # 打印A中的元素总数
print("A的均值:", A.mean())  # 打印A的均值
print("A的和除以元素总数:", A.sum() / A.numel())  # 打印A的和除以元素总数

sum_A = A.sum(axis=1, keepdims=True)  # 沿第1维度求和，并保持维度
print("沿第1维度求均值，保持维度:", A.mean(axis=1, keepdim=True))  # 打印沿第1维度的均值，并保持维度
print("沿第1维度求和，保持维度:", sum_A)  # 打印沿第1维度的求和，并保持维度

print("A的归一化 (A / sum_A):", A / sum_A)  # 打印归一化的A

print("沿第0维度的累积和:", A.cumsum(axis=0))  # 打印沿第0维度的累积和

# 点积
x = torch.arange(4, dtype=torch.float32)  # 创建张量x
y = torch.ones(4, dtype=torch.float32)  # 创建全1张量y
print("x和y的点积:", torch.dot(x, y))  # 打印x和y的点积
print("逐元素乘积的和:", torch.sum(x * y))  # 打印逐元素乘积的和

print("矩阵A和向量x的乘积:", torch.mv(A, x))  # 打印矩阵和向量的乘积

# 矩阵乘法
B = torch.ones(4, 3)  # 创建全1矩阵B
print("矩阵A:", A)  # 打印矩阵A
print("矩阵B:", B)  # 打印矩阵B
print("矩阵A和B的矩阵乘法:", torch.mm(A, B))  # 打印矩阵A和B的矩阵乘法

# 各种范数
u = torch.tensor([3.0, -4.0])  # 创建张量u
print("u的L2范数:", torch.norm(u))  # 打印u的L2范数
print("u的L1范数:", torch.abs(u).sum())  # 打印u的L1范数
print("一个全1矩阵(4x9)的弗罗贝尼乌斯范数:", torch.norm(torch.ones((4, 9))))  # 打印全1矩阵的弗罗贝尼乌斯范数

print("张量元素的和:", sum(torch.arange(20, dtype=torch.float32)))  # 打印张量元素的和

A = torch.arange(40, dtype=torch.float32).reshape(2, 5, 4)  # 创建并重塑张量A
print("3D张量A:", A)  # 打印3D张量A
print("沿轴[1,2]求和:", A.sum(axis=[1, 2]))  # 打印沿轴[1,2]求和结果
print("沿轴[1,2]求和，保持维度:", A.sum(axis=[1, 2], keepdims=True))  # 打印沿轴[1,2]求和结果，并保持维度

A = torch.ones(2, 5, 4)  # 创建全1张量A
print("3D张量A，全为1:", A)  # 打印全1张量A
print("沿轴[0,1]求和，保持维度:", A.sum(axis=[0, 1], keepdim=True))  # 打印沿轴[0,1]求和结果，并保持维度

# 自动求导
x = torch.arange(4.0)  # 创建张量x
print("张量x:", x)  # 打印张量x

x.requires_grad_(True)  # 开启自动求导
print("x的梯度 (初始为None):", x.grad)  # 打印x的梯度 (初始为None)

y = 2 * torch.dot(x, x)  # 2 * (x · x) 求导为 4x
print("y = 2 * (x · x):", y)  # 打印y

y.backward()  # 计算导数
print("backward之后x的梯度:", x.grad)  # 打印x的梯度
print("x的梯度是否等于4 * x:", x.grad == 4 * x)  # 打印x的梯度是否等于4 * x

# 清除梯度
x.grad.zero_()  # 清除x的梯度
y = x.sum()
y.backward()
print("求和y并backward之后的x梯度:", x.grad)  # 打印求和y并backward之后的x梯度

# 对非标量调用backward需要传入一个gradient参数
x.grad.zero_()  # 清除x的梯度
y = x * x
y.sum().backward()  # 等价于 y.backward(torch.ones(len(x)))
print("平方并求和y之后的x梯度:", x.grad)  # 打印平方并求和y之后的x梯度

# 分离计算图
x.grad.zero_()  # 清除x的梯度
y = x * x
u = y.detach()  # 从计算图中分离y
print("张量y:", y)  # 打印张量y
print("从y分离的张量u:", u)  # 打印从y分离的张量u

z = u * x
z.sum().backward()
print("分离u乘以x的梯度:", x.grad == u)  # 打印分离u乘以x的梯度

x.grad.zero_()  # 清除x的梯度
y.sum().backward()
print("再次求和y之后的x梯度:", x.grad == 2 * x)  # 打印再次求和y之后的x梯度
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161