深度学习基础语法——持续更新中......

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

基础知识

• 深度学习与经典方法的区别主要在于：前者关注功能强大的模型，这些模型有神经网络错综复杂的交织在一起，包含层层数据转换，因此被成为深度学习。
• 所谓“学习”是指模型自主提高完成某些任务的性能。在机器学习中，我们需要定义对模型的优劣程度的度量，这个度量在大多数情况下是“可视化”的，这被称为目标函数。通常定义一个目标函数，并希望优化它到最小值。因为越小越好，所有这些函数被称为损失函数。
• 优化算法，能够搜索出最佳参数，以最小化损失函数。通常是基于——梯度下降。
• 监督学习，在“给定输入特征”的情况下预测标签。目标是生成一个模型，该模型能够将任何输入特征映射到标签（预测）。如果给定数中不含有“目标”的机器学习问题通常被称为无监督学习。
• 分类问题的常见损失函数被称为交叉熵

数据操作+数据预处理

• 定义一个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]

---

• Sequential可以简单的认为是python中的List

net = nn.Sequential(nn.Linear(4,8),nn.ReLU(),nn.Linear(8,1))
# state_dict()表示查看nn.Linear(8,1)的参数
net[2].state_dict()
# 也可以拿具体的参数
net[2].bias.data
# 也可以访问梯度
net[2].weight.grad

• 查看主机配置GPU

!nvidia-smi

• 访问CPU和GPU

torch.device('cpu')
torch.cuda.device('cuda:1')
#查询可用的GPU数量
torch.cuda.device_count()