深度学习基础-李沐课程跟学

数据操作+数据预处理

定义一个1-11个数值的一维张量

x = torch.arange(12)
tensor([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

通过shape访问张量的形状和张量中元素的总数

x.shape

元素总数

x.numel

改变一个张量的形状，但是不改变元素数量和元素值

#3行4列
x = x.reshape(3,4)

使用全0、全1、其他常量或者从特定分布中随机采样的数字

#形状是(三维)2 3 4
torch.zeros((2,3,4))
torch.ones((2,3,4))

嵌套python列表赋值

troch.tensor([[1,2,3,4],[2,3,4,1],[2,4,1,5]])

加减乘除运算

x = torch.tensor([1.0,2,3,1])
y = torch.tensor([2,2,1,3])
x+y,x-y,x*y,x/y,x**y
#**表示求幂运算
#指数运算
torch.exp(x)

把多个张量连结在一起

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]])
#0按行连结，1按列连结
torch.cat((x,y),dim=0),torch.cat((x,y),dim=1)

逻辑运算符判断两个张量是否相等
x==y
对张量中所有元素进行求和会生成一个只有一个元素的张量—sum后是一个标量
x.sum()
对于形状不同的张量运算，可以调用广播机制来执行按元素操作

a = torch.arange(3).reshape((3,1))
b = torch.arange(2).reshape((1,2))
#按行复制，按列复制，再进行加和运算 
a + b

运行一些操作可能会导致为新结果分配内存，导致内存占用过多，可以通过执行原地操作来避免

#生成一个z和y由相同的构造，且值为0
z = torch.zeros_like(y)
#对z所有的元素改写成x+y
z[:] = x+y
#也可以通过x+=y来实现

转换为Numpy张量

a = x.numpy()
b = torch.tensor(a)

将大小为1的张量转换为python标量

a = torch.tensor([3,2])
a.item(), float(a), int(a)

创建人工数据集的方法

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')
#读取文件
data = pd.read_csv(data_file)

处理数据

inputs, outputs = data.iloc[:,0:2], data.iloc[:,2]
#NaN设置成列的均值填入
inputs = inputs.fillna(inputs.mean())
#将NaN列拆开分别成0/1
inputs = pd.get_dummies(inputs,dummy_na=True)

将inputs和outputs中的所有条目转换成张量

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

通过分配新内存，将a的一个副本分配给b

b = a.clone()

将维度为1的汇总加和

a_sum_axis0 = a.sum(axis=0)

求均值

a.mean()
a.sum()/a.numel()

计算总和或均值时保持轴数(维度)不变

sum_a = a.sum(axis=1,keepdims=True)

某个轴计算a元素的累积求和

a.cumsum(axis=0)

点积是相同位置的按元素乘积的和——标量

y = torch.ones(4,dtype=torch.float32)
x,y,torch.dot(x,y)
#等价于
torch.sum(x*y)

矩阵向量积

a.shape,x.shape,torch.mv(a,x)

矩阵-矩阵的向量积

torch.mm(a,b)

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

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

L1范数，表示向量元素的绝对值求和

torch.abs(u).sum()

矩阵的Frobenius norm是矩阵元素的平方和的平方根

torch.norm(torch.ones((4,9)))

存储梯度

x = torch.arange(4.0,requires_grad=True)
x.grad #默认是None

计算y

y = 2*torch.dot(x,x)

通过调用反向传播函数来自动计算y关于x每个分量的梯度

y.backward() #求导
x.grad #访问导数

在默认情况下，pytorch会累积梯度，所以需要清除之前的值

x.grad.zero_()
#求向量的sum梯度是全1，也就是y=x1+x2+x3对其求偏导
y = x.sum()
y.backward()
x.grad

detach表示将变量变成标量

x.grad.zero_()
y = x*x
u = y.detach() #表示脱离掉
z = u*x
z.sum().backward()
x.grad == u

矩阵x向量

torch.matmul(x,w)

矩阵按照某个轴求和

X = torch.tensor([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
X.sum(0, keepdim=True), X.sum(1, keepdim=True)

创建一个数据y_hat，其中包含2个样本在3个类别的预测概率，使用y作为y_hat中概率的索引

y = torch.tensor([0, 2])
y_hat = torch.tensor([[0.1, 0.3, 0.6], [0.3, 0.2, 0.5]])
#表示拿到0.1和0.5
y_hat[[0, 1], y]

JZTXT

深度学习基础-李沐

深度学习基础-李沐课程跟学

数据操作+数据预处理