深度学习是关于优化的学习。对一个带有参数的模型，找到其中能拟合数据最好的模型。

一、数据操作

  张量：表示一个由数值组成的数组，这个数组可能有多个维度。具有一个轴的张量对应数学上的向量，具有两个轴的张量对应数学上的矩阵，具有两个以上轴的张量没有特定的数学名称。
  深度学习的张量与Numpy类似，但深度学习框架比Numpy的ndarray多一些重要功能：首先，GPU很好支持加速计算，而Numpy仅支持CPU计算；其次，张量类支持自动微分。这类功能使得张量类更适合深度学习。
  导入torch，虽然它被称为Pytorch。但代码中使用torch而不是pytorch。

import torch
x=torch.arange(12)
x.shape    #访问张量形状
x.numel()  #计算张量中总数，即形状的所有元素乘积
X=x.reshape(3,4) #通过reshape函数，改变张量的形状而不改变元素数量和元素值。
x.reshape(-1,4)或者reshape(3,-1) #通过-1来调用此自动计算出形状
#创建全为0或者1的张量
torch.zeros((2,3,4))
torch.ones((2,3,4))
##通过某个特定概率分布中随机采样来得到张量中每个元素的值
torch.randn(3,4) #均值0，标准差为1的正态分布中随机采样
##通过提供办好数值的python列表来为张量的每个元素赋值
torch.tensor([2,1,4,3],[1,2,3,4],[4,3,2,1]]) #外层列表对应轴0，内层列表对应轴1

1.1 运算符

import torch
x=torch.tensor([1,2,4,8])
y=torch.tensor([2,2,2,2])
x+y,x-y,x*y,x/y
torch.exp(x)  #求幂
x.sum()  #对张量中的所有元素求和，会产生一个单元素张量

• 多个张量连接cat

x=torch.arange(12,dtype=torch.float32).reshape(3,4)
y=torch.tensor([[2.0,1.0,4.0,5.0],[3.0,2.0,1.0,2.0],[6.0,7.0,8.0,9.0]])
torch.cat((x,y),dim=0),torch.cat((x,y),dim=1)

1.2 广播机制

  1.1中看到如何在相同形状的两个张量上执行按元素操作，在某些情况下，即使形状不同，我们仍然可以通过调用广播机制来执行按元素操作。这种机制的工作方式如下：
（1）通过适当复制元素来扩展一个或两个数组，以便在转换之后，两个张量具有相同的形状；
（2）对生成的数组执行按元素操作
  在大多数情况下，我们将沿着数组中长度为1的轴进行广播，如下：

import torch
x=torch.arange(3).reshape(3,1)
y=torch.arange(2).reshape(1,2)
x,y
x+y

  由于x和y分别是3x1矩阵和1x2矩阵，它们的形状不匹配，如果相加，矩阵x将复制列，矩阵y将复制行，实现两个矩阵广播为一个更大的3x2矩阵。

1.3 索引和切片

  与python数组一样，张量中的元素可以通过索引访问，第一个元素的索引是0，最后一个元素的索引是-1。

x=torch.arange(12,dtype=torch.float32).reshape(3,4)
x[-1],x[1:3]

• 可以通过指定索引来将元素写入矩阵

x[1,2]=9
x

• 想为多个元素赋予相同的值，只需要索引所有元素，然后为它们赋值。

x[0:2,:]=12
x

1.4 转换为其他python对象

  将深度学习框架定义的张量转换为numpy张量很容易，反之也同样容易。torch张量和numpy数组将共享它们的底层内存，就地操作更改一个张量也会同时更改另一个张量。

import torch
a=x.numpy()
b=torch.tensor(a)
type(a),type(b)

• 要将大小为1的张量转换为python标量，可以调用item函数或python的内置函数。

import torch
a=torch.tensor([3.5])
a,a.item(),float(a),int(a)

二、数据预处理

  在python常用的数据分析中，通常使用pandas包，与庞大的python生态系统中的许多其他扩展包一样，pandas可以与张量兼容。接下来介绍pandas预处理原始数据，并将原始数据转换为张量格式的步骤。

2.1 读取数据集

import pandas as pd
data =pd.read_excel('data.xlsx')
print(data)

2.2 处理缺失值

  通过位置索引 iloc，将data分成 inputs 和 outputs，其中前者为data的前两列，后者为data的最后一列，对于inputs 中的缺失值，用一列的均值替换NaN项。

inputs,outputs=data.iloc[:,0:2],data.iloc[:,2]
inputs=inputs.fillna(inputs.mean())
print(inputs)

  将NaN视为一个类别，由于Alley列只接受两种类型值Pave和NaN，pandas可以自动将此列转换为两列Alley_pave和Alley_nan。Alley列为pave的行会将Alley_pave的值设置为1，Alley_nan的值设置为0。

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

2.3 转换为张量格式

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

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

三、线性代数

3.1 标量

标量由只有一个元素的张量表示。

x=torch.tensor(3.0)
y=torch.tensor(2.0)
x+y,x*y,x/y,x**y

3.2 向量

  向量可以被视为标量值组成的列表，这些标量值被称为向量的元素。当向量表示数据集中的样本时，它们的值具有一定的实际意义。在数学上，具有一个轴的张量表示向量。

x=torch.arange(4)
x

与普通的python数组一样，可以通过调用python的内置函数len来访问张量的长度，shape属性访问向量的长度。

X=torch.arange(12,dtype=torch.float32).reshape(3,4)
len(X),X.shape

3.3 矩阵

正如向量将标量从零阶推广到一维，矩阵将向量从一维推广到二维。在代码中表示为具有两个轴的张量。

X=torch.arange(16).reshape(4,4)
X,X.T

3.4 张量算法的基本性质

标量、向量、矩阵和任意数量轴的张量由一些使用的属性。

X=torch.arange(16).reshape(4,4)
y=X.clone()  #通过分配新的内存，将X的一个副本分配给y
X,X+y,X*y

将张量加上或乘以一个标量不会改变张量的形状，其中张量的每个元素都将与标量相加或相乘。

a=2
X=torch.arange(24).reshape(2,3,4)
a+X,(a*X).shape

3.5 降维

我们可以对任意张量进行的一个有用的操作是计算其元素的和。

X=torch.arange(24).reshape(2,3,4)
X,X.sum()
X.sum(axis=0)#对所有的行元素求和
X.sum(axis=1)#对所有的列元素求和

• 非降维求和

有时在调用函数来计算总和或平均值时保持轴数不变会很有用。keepdims=True

A=torch.arange(20).reshape(5,4)
sum_a=A.sum(axis=1)
sum_A=A.sum(axis=1,keepdims=True)
A,sum_a,sum_A,A/sum_A,A.cumsum(axis=0)#按行累计求和

3.6 点积

点积：相同位置的按元素乘积的和。

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

• 矩阵-向量积

使用mv函数表示矩阵-向量积，矩阵A和向量x调用torch.mv(A,x)时，执行矩阵-向量积。

A=torch.arange(20).reshape(5,4)
x=torch.arange(4)
A,x,torch.mv(A,x)

• 矩阵-矩阵乘法（矩阵乘法）

A=torch.arange(20,dtype=torch.float32).reshape(5,4)
B=torch.ones(4,3)
torch.mm(A,B)

3.7 范数

  线性代数中最有用的一些运算符是范数，向量的范数表示一个向量有多大。这里考虑的大小概念不涉及维度，而是分量的大小。在线性代数中，向量范数是将向量映射到标量的函数 f 。给定任意向量 x ，向量范数具有如下性质：
(1)如果按常数因子 ɑ 缩放向量的所有元素，其范数也会按相同常熟因子的绝对值缩放：f(ɑx)=|ɑ|f(x)
(2)f(x+y)≤f(x)+f(y)
(3)非负性f(x)≥0
  范数很像距离的度量，欧几里得距离是一个L2范数：假设 n 维向量 x 中的元素是x1，…,xn，其L2范数是向量元素平方和的平方根。

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

深度学习中经常使用L2范数的平方，也会经常遇到L1范数，它表示为向量元素的绝对值之和：

与L2范数相比，L1范数受异常值的影响较小。为了计算L1范数，我们将绝对值函数和按元素求和组合起来。

torch.abs(u).sum()

L2范数和L1范数都是更一般的LP范数的特例：

四、自动微分

  在深度学习中，我们“训练”模型，不断更新它们，使它们在见到越来越多的数据时变得越来越好。通常情况下，变得更好意味着最小化一个损失函数，即一个衡量“模型有多糟糕”这个问题的分数。最终我们真正关心的是生成一个模型，它能够在从未见到过数据上表现良好。但“训练”模型只能将模型与我们实际见到的数据相拟合。因此，我们可以将拟合模型的任务分解为两个关键问题。

• 优化：用模型拟合观察数据的过程。
• 泛化：模型不仅在训练集表现良好，在未知的数据（测试集）也表现良好，即具有良好的泛化能力。

  求导是几乎所有深度学习优化算法的关键步骤，虽然求导的计算简单，但对于复杂的模型，手动进行更新是一件痛苦的事情，深度学习框架通过自动计算导数，即自动微分来加快求导。实践中，根据设计好的模型，系统会构建一个计算图，来跟踪计算是哪些数据通过哪些操作组合起来产生输出。自动微分使系统能够随后反向传播梯度。这里，反向传播意味着跟踪整个计算图，填充关于每个参数的偏导数。

import torch
x = torch.arange(4.0, requires_grad=True)  # 设置 requires_grad=True 使得 x 被标记为需要计算梯度的张量。
y = 2 * torch.dot(x, x)
y.backward()  #调用 y.backward() 后，x.grad 会保存 x 关于 y 的梯度。
print(x.grad)  # 输出 x 的梯度

函数y=2*x^2关于x的梯度应为4x，验证梯度是否正确：

x.grad==4*x

计算x的另一个函数:

x.grad.zero_() #将x的梯度清零的操作。通常在反向传播 (backward) 之前或之后调用它，目的是防止梯度的累积。
y=x.sum() 
y.backward()
x.grad

4.1 分离计算

  有时，我们希望将某些计算移到记录的计算图之外。例如，假设y是作为x的函数计算的，而z则是作为y和x的函数计算的。想计算z关于x的梯度，但由于某种原因，希望将y视为一个常数，并且只考虑x在y被计算后发挥的作用。
  这里可以分离y来返回一个新变量u，该变量与y具有相同的值，但丢弃计算图中如何计算y的任何信息，换句话说，梯度不会向后流经u到x。因此，下面的反向传播函数计算z=ux关于x的偏导数，同时将u作为常数处理，而不是计算z=xx*x关于x的偏导数。

x.grad.zero_()
y=x*x
u=y.detach() #创建一个新的张量 u，它是 y 的一个 detach 副本。detach() 是 PyTorch 中的一个方法，用于返回一个新的张量，该张量与原始张量 y 共享相同的数据，但不会参与梯度计算，也就是说，它与计算图分离了。
z=u*x  # u 是通过 y.detach() 得到的，所以 u 不再跟踪梯度，而 x 仍然是需要梯度的。因此，这条语句不会改变 x 的梯度计算行为，但会产生一个新的张量 z。
z.sum().backward() #计算 z 的所有元素的和，然后对其进行反向传播，计算 x 的梯度。
x.grad==u #x.grad 会被更新，存储关于 x 的梯度值。