李沫深度学习

目录

1.数据操作

2.数据预处理

3. 线性代数

4.矩阵计算

5.自动求导

---

http://localhost:8888/notebooks/Desktop/d2l-zh/pytorch/chapter_preliminaries/ndarray.ipynb

1.数据操作

1.数组是深度学习的主要数据结构，创建数组主要有三步：1.形状 2.每个元素的数据类型 3.每个元素的值

注意广播机制

运用torch模块

张量定义作用等

作业：

1. 运行本节中的代码。将本节中的条件语句X == Y更改为X < Y或X > Y，然后看看你可以得到什么样的张量。

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]])
torch.cat((X, Y), dim=0), torch.cat((X, Y), dim=1)
#dim=0是行 dim=1是列

运行结果为：

(tensor([[ 0.,  1.,  2.,  3.],
         [ 4.,  5.,  6.,  7.],
         [ 8.,  9., 10., 11.],
         [ 2.,  1.,  4.,  3.],
         [ 1.,  2.,  3.,  4.],
         [ 4.,  3.,  2.,  1.]]),
 tensor([[ 0.,  1.,  2.,  3.,  2.,  1.,  4.,  3.],
         [ 4.,  5.,  6.,  7.,  1.,  2.,  3.,  4.],
         [ 8.,  9., 10., 11.,  4.,  3.,  2.,  1.]]))

X ==Y

 结果为：

tensor([[False,  True, False,  True],
        [False, False, False, False],
        [False, False, False, False]])

表示 对于每个位置，如果X和Y在该位置相等，则新张量中相应项的值为1。 这意味着逻辑语句X == Y在该位置处为真，否则该位置为0。

改成

X <Y

结果为

tensor([[ True, False,  True, False],
        [False, False, False, False],
        [False, False, False, False]])

改成

X >Y

结果为

tensor([[False, False, False, False],
        [ True,  True,  True,  True],
        [ True,  True,  True,  True]])

2. 用其他形状（例如三维张量）替换广播机制中按元素操作的两个张量。结果是否与预期相同

源代码为：

在上面的部分中，我们看到了如何在相同形状的两个张量上执行按元素操作。 在某些情况下，[即使形状不同，我们仍然可以通过调用 广播机制（broadcasting mechanism）来执行按元素操作]。 这种机制的工作方式如下：

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

在大多数情况下，我们将沿着数组中长度为1的轴进行广播，如下例子：

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

(tensor([[0],
         [1],
         [2]]),
 tensor([[0, 1]]))

由于a和b分别是3×3和1×2矩阵，如果让它们相加，它们的形状不匹配。 我们将两个矩阵广播为一个更大的3×2矩阵，如下所示：矩阵a将复制列， 矩阵b将复制行，然后再按元素相加。

a + b

a + b
a + b
tensor([[0, 1],
        [1, 2],
        [2, 3]])

若用3维张量替换广播机制会出现2种情况

1.不能复制，因为a和b中同一纬度都不为1，无法进行复制

如：

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

 结果

(tensor([[[0, 1]],
 
         [[2, 3]],
 
         [[4, 5]]]),
 tensor([[[ 0,  1,  2,  3,  4,  5],
          [ 6,  7,  8,  9, 10, 11]]]))

a + b

RuntimeError                              Traceback (most recent call last)
~\AppData\Local\Temp\ipykernel_3084\1216668022.py in <module>
----> 1 a + b

RuntimeError: The size of tensor a (2) must match the size of tensor b (6) at non-singleton dimension 2

2.可以复制，因为a和b中同一纬度不都为1，可以进行复制

如

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

(tensor([[[0, 1]],
 
         [[2, 3]],
 
         [[4, 5]]]),
 tensor([[[0],
          [1],
          [2],
          [3],
          [4]]]))

a + b

tensor([[[0, 1],
         [1, 2],
         [2, 3],
         [3, 4],
         [4, 5]],

        [[2, 3],
         [3, 4],
         [4, 5],
         [5, 6],
         [6, 7]],

        [[4, 5],
         [5, 6],
         [6, 7],
         [7, 8],
         [8, 9]]])

注：arange的值要为几则乘积

2.数据预处理

pandas - Jupyter Notebook

数据预处理常用pandas包

1.读取数据集

data = pd.read_csv(data_file)读取csv文件

2.处理缺失值

典型的方法包括插值法和删除法

inputs = inputs.fillna(inputs.mean())#缺失值用平均值代替

对于inputs中的类别值或离散值，我们将“NaN”视为一个类别。

 pandas可以自动将此列转换为两列“Alley_Pave”和“Alley_na

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

3.转换为张量格式

练习题

创建包含更多行和列的原始数据集。

1. 删除缺失值最多的列。
2. 将预处理后的数据集转换为张量格式。

   import os
   import pandas as pd
   import torch
    
   # 创建包含更多行和列的原始数据集。
   #
   # 删除缺失值最多的列。
   #
   # 将预处理后的数据集转换为张量格式。
   os.makedirs(os.path.join('..','data'),exist_ok=True)
   data_file = os.path.join('..','data','school.csv')
   with open(data_file,'w') as f:
       f.write('Numclass,Name,Age,Grade\n')  # 列名
       f.write('NA,Tom,21,NA\n')
       f.write('1,NA,19,NA\n')
       f.write('1,NA,NA,NA\n')
       f.write('2,Make,20,98\n')
       f.write('4,Lili,18,NA\n')
    
   # 读取数据集
   data = pd.read_csv(data_file)
   print(data)
    
   a = data.isnull().sum(axis=0)    # 每列的缺失值数量
   print(a)
   data.drop('Grade',axis=1)  # 删除Grade这一列
   print(data)
    
   inputs,outputs = data.iloc[:,0:3],data.iloc[:,3]
   inputs = inputs.fillna(inputs.mean())
   inputs = pd.get_dummies(inputs,dummy_na=True)
   x,y = torch.tensor(inputs.values),torch.tensor(outputs.values)
   print(x,y,sep="\n")

注：data.isnull() #判断缺乏值，有则为True

data.isnull().sum() #计算列中缺乏值得总数

 data.isnull().sum().idxmax() #得到最大缺失值的索引

data.drop(data.isnull().sum().idxmax(),axis=1) #按列删除 ‘Alley’

3. 线性代数

linear-algebra - Jupyter Notebook

1.降维

axis=0,1,2

0为第一个维度，1为第二个维度，2为第三个维度，即将对应的维度取消。

keepdims=True 保存对应维度，将其变成1。

例如

import torch
a=torch.ones(2,5,4)
a.shape
#结果为
#torch.Size([2, 5, 4])
a.sum(axis=[0,2]).shape
#结果为
#torch.Size([5])
a.sum(axis=[0,2],keepdims=True).shape
#结果为
torch.Size([1, 5, 1])

2.如果累加求和可以用cumsum函数， 此函数不会沿任何轴降低输入张量的维度。

A.cumsum(axis=0)
#结果为
tensor([[ 0.,  1.,  2.,  3.],
        [ 4.,  6.,  8., 10.],
        [12., 15., 18., 21.],
        [24., 28., 32., 36.],
        [40., 45., 50., 55.]])

3.常见范数函数

4.矩阵乘法torch.mm(A, B) 

在代码中使用张量表示矩阵-向量积，我们使用mv函数。 当我们为矩阵A和向量x调用torch.mv(A, x)时，会执行矩阵-向量积。 注意，A的列维数（沿轴1的长度）必须与x的维数（其长度）相同。

作业

1. 证明一个矩阵𝐀的转置的转置是𝐀，即(𝐀⊤)⊤=𝐀
2. 给出两个矩阵𝐀和𝐁，证明“它们转置的和”等于“它们和的转置”，即𝐀⊤+𝐁⊤=(𝐀+𝐁)⊤
3. 给定任意方阵𝐀，𝐀+𝐀⊤总是对称的吗?为什么?
4. 本节中定义了形状(2,3,4)的张量X。len(X)的输出结果是什么？
5. 对于任意形状的张量X,len(X)是否总是对应于X特定轴的长度?这个轴是什么?
6. 运行A/A.sum(axis=1)，看看会发生什么。请分析一下原因？
7. 考虑一个具有形状(2,3,4)的张量，在轴0、1、2上的求和输出是什么形状?
8. 为linalg.norm函数提供3个或更多轴的张量，并观察其输出。对于任意形状的张量这个函数计算得到什么?

 1.2.3略

4.输出为2

5.对应的是axis=0的长度

6.无法运行，原因是 A 是一个 5 * 4 的矩阵，而 A.sum(axis=1) 是一个被拍扁的1维的向量，两者维数不匹配不能相除。（注：广播只能发生在两者维数相同的情况下，比如都是二维）

7.aixs=0为3*4矩阵

aixs=1为2*4矩阵

axis=2为2*3矩阵

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

 结果为

tensor([[[ 0,  1,  2,  3],
         [ 4,  5,  6,  7],
         [ 8,  9, 10, 11]],

        [[12, 13, 14, 15],
         [16, 17, 18, 19],
         [20, 21, 22, 23]]])

H0 = H.sum(axis=0)
H1 = H.sum(axis=1)
H2 = H.sum(axis=2)
H0,  H1,  H2

结果为 

(tensor([[12, 14, 16, 18],
         [20, 22, 24, 26],
         [28, 30, 32, 34]]),
 tensor([[12, 15, 18, 21],
         [48, 51, 54, 57]]),
 tensor([[ 6, 22, 38],
         [54, 70, 86]]))

8.为范数演示,此展示二范数

Z=torch.ones(2,3,4)
W=torch.ones(2,2,3,4)
torch.norm(Z)*torch.norm(Z),torch.norm(W)*torch.norm(W)

(tensor(24.0000), tensor(48.))

4.矩阵计算

1. 亚倒数

2.x,y都是向量

3.矩阵求导

5.自动求导

autograd - Jupyter Notebook

1.正向求导与反向求导

 pytorch为我们提供了自动求导机制，其机制用torch.autograd来实现

# 方法1
x = torch.randn(3,4,requires_grad = True)
x

# 方法2
x = torch.randn(3,4)
x.requires_grad = True
x

反向传播：y.backward() 

查看梯度：b.grad
2.在我们计算𝑦关于𝐱的梯度之前，需要一个地方来存储梯度。

x.requires_grad_(True)  # 等价于x=torch.arange(4.0,requires_grad=True)
x.grad  # 默认值是None

3.当y不是标量时，向量y关于向量x的导数的最自然解释是一个矩阵。但在深度学习一般不这样，一般求和来代替：y.sum().backward()

4.有时，我们希望[将某些计算移动到记录的计算图之外]。用u = y.detach()将y变成常数。

5.使用自动微分的一个好处是： [即使构建函数的计算图需要通过Python控制流（例如，条件、循环或任意函数调用），我们仍然可以计算得到的变量的梯度]。

1. 为什么计算二阶导数比一阶导数的开销要更大？
2. 在运行反向传播函数之后，立即再次运行它，看看会发生什么。
3. 在控制流的例子中，我们计算d关于a的导数，如果将变量a更改为随机向量或矩阵，会发生什么？
4. 重新设计一个求控制流梯度的例子，运行并分析结果。
5. 使𝑓(𝑥)=sin(𝑥)，绘制𝑓(𝑥)和𝑑𝑓(𝑥)/𝑑𝑥的图像，其中后者不使用𝑓′(𝑥)=cos(𝑥)。

import torch
import matplotlib.pyplot as plt
import os
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
 
# 1为什么计算二阶导数比一阶导数的开销要更大？
# 二阶导数的计算是在一阶导数的基础上进行的
 
# 2在运行反向传播函数之后，立即再次运行它，看看会发生什么
x = torch.arange(4.0, requires_grad=True)
y = 2*torch.dot(x, x)
y.backward()
print(x.grad)
# y.backward()  # 报错,不可以连续两次backward，需要更新x.grad
 
# 3将a改成随机向量或矩阵会发生什么
def f(a):
    b = a * 2
    while b.norm() < 1000:  # norm是L2范数
        b = b * 2
    if b.sum() > 0:
        c = b
    else:
        c = 100 * b
    return c
 
a = torch.randn(10,requires_grad=True)  # a是随机数，size=()指a是标量 randn(几个数代表几维)
d = f(a)  # d的结果等于一个常数k乘a，k就是a.grad！
d.sum().backward()  # 直接backward会报错 见第三条
print(a.grad)
# print(a.grad == d/a)
 
# 4重新设计一个求控制流梯度的例子。运行并分析结果
def f(e):
    g = e * e
    while g < 100:  # norm是L2范数
        g = g * 2
    if g.norm() > 0:
        h = g + 100
    else:
        h = 100 * g
    return h
 
x = torch.randn(size=(),requires_grad=True)  # a是随机数，size=()指a是标量
y = f(x)  # d的结果等于一个常数k乘a，k就是a.grad！
y.backward()
print(x.grad == y/x)
 
# 5使f(x)=sin(x)，绘制f(x)和\(\frac{df(x)}{dx}\)的图像，其中后者不使用f'(x)=\cos(x)。
x = torch.arange(-10,10,0.1,requires_grad=True,dtype=torch.float32)
y = torch.sin(x)
y.sum().backward()
plt.plot(x.detach(),y.detach(),label='y=sin(x)')
plt.plot(x.detach(),x.grad,label='dy/dx')
plt.show()