深度学习学习笔记(一)

预备知识

该文章内容为《动手学习深度学习》的学习笔记

导入包

import torch

数据操作

入门

张量表示一个由数值组成的数组，这个数组可能有多个维度

x = torch.arange(12)
x

对张量的操作

# 查看张量的形状
x.shape

# 查看张量中的元素综合
x.numel()

# 改变一个张量的形状而不改变元素数量和元素值，可以使用`reshape`函数
X = x.reshape(3, 4)
X

创建张量

# 创建一个形状为(2, 3 ,4)的张量，值全为0
torch.zeros((2, 3, 4))
# 如果想要值全为1，可以使用`ones`

# 通过包含数值的Python列表
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)

使用cat将多个张量连结到一起

X = torch.arange(12, dtype=torch.float32).reshape(3, 4)
Y = torch.tensor([[2, 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()

广播机制

在张量形状不同的情况下，我们可以通过广播机制来执行元素操作

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

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

索引和切片

# 访问最后一个元素
X[-1]

# 访问第二个和第三个元素
X[1:3]

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

# 将多个元素赋值相同的值
X[0:2, :] = 12
X

节省内存

一些操作，比如Y = X + Y我们会为结果分配新的内存，然后使Y指向内存中的这位置

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

我们可以使用切片表示法将操作的结果分配给现钱分配的数组

print("正常操作：")
Z = torch.zeros_like(Y)
print('id(Z):', id(Z))
Z = X + Y
print('id(Z):', id(Z))
print("使用切片")
Z = torch.zeros_like(Y)
print('id(Z):', id(Z))
Z[:] = X + Y
print('id(Z):', id(Z))

如果在后续计算中没有重复使用X，我们也可以用X[:] = X + Y或X += Y

数据预处理

读取数据集

首先我们先创建一个人工数据集，并存储在CSV文件中

import os

# 创建保存数据的目录
os.makedirs(os.path.join('..', 'data'), exist_ok=True)
data_file = os.path.join('..', 'data', 'house_tiny.csv')

# 写入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')

接下来我们读取CSV文件

import pandas as pd

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

处理缺失值

典型的方法包括插值法和删除法。插值法：用一个代替值弥补缺失值。删除法：直接忽略缺失值

这里我们使用插值法，将data分成两部分

inputs, outputs = data.iloc[:, 0:2], data.iloc[:, 2]
inputs

这里对于第一列用均值替换NaN项

inputs.iloc[:, 0] = inputs.iloc[:, 0].fillna(inputs.iloc[:, 0].mean())
inputs

对于Alley这一列只有两种值Pave和NaN，所以Pandas可以自动将此列转换为两列Alley_Pave和Alley_nan

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

转换为张量格式

现在inputs和outputs中的所有条目都是数值类型，它们可以转换为张量格式

X = torch.tensor(inputs.to_numpy(dtype=float))
y = torch.tensor(outputs.to_numpy(dtype=float))
X, y

线性代数

标量

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

张量

张量是描述具有任意数量轴的n维数组的通用方法

X = torch.arange(24).reshape(2, 3, 4)

张量的算法，是对两个张量对应的元素实行运算

A = torch.arange(20, dtype = torch.float32).reshape(5, 4)
B = A.clone()
A, A + B, A * B

与标量的运算，就是张量中的每一个数都与该标量进行运算

a = 2
a + X, a * X

降维

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

调用求和函数会沿所有轴降低张量的维度，使它变成一个标量

我们还可以指定轴来降低维度

A.sum(axis = 0)

非降维求和

A.sum(axis = 1, keepdims = True)

点积

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

向量积

A, x, torch.mv(A, x)

矩阵-矩阵乘法

B = torch.ones(4, 3)
A, B, torch.mm(A, B)

范数

向量范数是将向量映射到标量的函数f。非正式的说，向量的范数是表示一个向量到底有多大

计算L2范数，L2范数是向量元素平方和的平方根

u = torch.tensor([3.0, -4.0])
torch.norm(u)

计算L1范数，L1范数是绝对值的和

torch.abs(u).sum()