深度学习基础

智能2112杨阳

一、目的

1.安装PyTorch

2.标量、向量、矩阵、Tensor

3.AutoGrad

二、环境

PyTorch，VS Code，OpenCV

三、内容

1、搭建基于PyTorch+OpenCV软件开发平台

  （1）PyTorch安装问题及解决方法

       问题描述：安装时因为网络问题安装无效

       解决方法：切换国内清华镜像源安装成功

  （2）OpenCV安装问题及解决方法

       问题描述：测试样例时显示没有导入cv2库

       解决方法：导入opencv-python库后成功运行

2、数据操作

在深度学习中，我们通常会频繁地对数据进行操作。而在PyTorch中， torch.Tensor 是存储和变换数据的主要工具。 Tensor 和 NumPy 的多维数组非常类似。然而，Tensor提供GPU计算和自动求梯度等更多功能，这些使 Tensor 更加适合深度学习。"tensor"这个单词一般可译作“张量”，张量可以看作是一个多维数组。标量可以看作是0维张量，向量可以看作1维张量，矩阵可以看作是2维张量。

   (1) 主要功能源码及分析

1. 创建Tensor

import torch  导入PyTorch

1、创建一个2x3的未初始化的Tensor

x = torch.empty(2, 3)

print(x)

输出结果：

tensor([[1.1710e+32, 4.5782e-41, 1.1710e+32], [4.5782e-41, 2.1459e+20, 9.2489e-04]])

         2、创建一个2x3的随机初始化的Tensor

x = torch.rand(2, 3)  随机分布，产生[0,1)区间里的数值

print(x)

            输出结果：

tensor([[0.8891, 0.7304, 0.1292], [0.8943, 0.6942, 0.1651]])

3、创建一个2x3的long型全0的Tensor

x = torch.zeros(2, 3, dtype=torch.long)  dype指的是data数据的类型

print(x)

输出结果：

tensor([[0, 0, 0],[0, 0, 0]])

         4、直接根据数据创建

x = torch.tensor([[5.5, 3],[2.2,5]])

print(x)

输出结果：

tensor([[5.5000, 3.0000], [2.2000, 5.0000]])

         5、我们还可以通过现有的 Tensor 来创建此类方法会默认重用输入 Tensor        的一些属性，例如数据类型，除非自定义数据类型。

            返回的tensor默认具有相同的torch.dtype和torch.device

x = x.new_ones(2, 3)

print(x)

指定新的数据类型

x = torch.randn_like(x, dtype=torch.float)  生成的新张量与原来的张量的大小是相同的（2x3），只手将数据类型改为了浮点型

print(x)

输出结果：

tensor([[1., 1., 1.],[1., 1., 1.]], dtype=torch.float64)

            tensor([[ 0.5344, 0.5095, 0.3691],[ 0.0160, 1.4369, 1.3419]])

         6、通过shape或者size()来获取Tensor的形状

            这两个函数调用之后都可以返回张量的形状

返回的torch.Size其实就是一个tuple, 支持所有tuple的操作。

print(x.size())

print(x.shape)

输出结果：

            torch.Size([2, 3])

            torch.Size([2, 3])

1. Tensor的相关操作

1. 算术操作

加法形式一

x=torch.rand(2,3)

y=torch.rand(2,3)

print(x+y)

加法形式二

print(torch.add(x,y))

加法形式三

y.add_(x)

print(y)

1. 索引

我们还可以使用类似NumPy的索引操作来访问 Tensor 的一部分，需要注意的是：索引出来的结果与原数据共享内存，也即修改一个，另一个会跟着修改。

y = x[0, :]

y += 1

print(y)

print(x[0, :])  源tensor也被改了

输出结果：

tensor([1.6035, 1.8110, 0.9549])

tensor([1.6035, 1.8110, 0.9549])

1. 改变形状：用view()来改变Tensor的形状

y = x.view(6)

z = x.view(-1, 2)  只给了一个维度是2，可以推算出前面-1指定的维度应该是3（-1所指的维度可以根据其他维度的值推出来）

print(x.size(), y.size(), z.size())

输出结果：

torch.Size([2, 3]) torch.Size([6]) torch.Size([3, 2])

注意：view()返回的新Tensor与源Tensor虽然可能有不同的size，但是是共享data的，也即更改其中的一个，另外一个也会跟着改变。(顾名思义，view仅仅是改变了对这个张量的观察角度，内部数据并未改变)

x += 1

print(x)

print(y) # 发现y也加了1

输出结果：

tensor([[2.0910, 2.5265, 2.3833],[1.4564, 1.3117, 1.5181]])

tensor([2.0910, 2.5265, 2.3833, 1.4564, 1.3117, 1.5181])

如果我们想返回一个真正新的副本（即不共享data内存）该怎么办呢？

Pytorch还提供了一个 reshape() 方法可以改变形状，但是此函数并不能保证返回的是其拷贝，所以不推荐使用。我们推荐先用 clone() 创造一个副本然后再使用 view() 。

x_cp = x.clone().view(6)

x -= 1

print(x)

print(x_cp)

我们发现x没有变化，x_cp相对于x改变了

输出结果；

tensor([[1.0910, 1.5265, 1.3833],[0.4564, 0.3117, 0.5181]])

tensor([2.0910, 2.5265, 2.3833, 1.4564, 1.3117, 1.5181])

1. 广播机制

当我们对两个形状不同的Tensor按元素运算时，可能会触发（broadcasting）机制：先适当复制元素使这两个Tensor形状相同后再按元素运算。

x = torch.arange(1, 3).view(1, 2)

print(x)

y = torch.arange(1, 4).view(3, 1)

print(y)

print(x + y)

输出结果：

tensor([[1, 2]])

tensor([[1],

  [2],

  [3]])

tensor([[2, 3],

  [3, 4],

      [4, 5]])

由于x和y分别是1行2列和3行1列的矩阵，要计算x+y，那么x中第一行的2个元素被广播（复制）到了第二行和第三行，而y中第一列的3个元素被广播（复制）到了第二列。如此，就可以对2个3行2列的矩阵按元素相加。

1. Tensor和Numpy相互转换

我们可以使用 numpy()和from_numpy() 将Tensor和NumPy中的数组相互转换。但是需要注意的一点是：这两个函数所产生的Tensor和NumPy中的数组共享相同的内存（所以他们之间的转换很快），改变其中一个时另一个也会改变！

Tensor转Numpy数组

a = torch.ones(5)

b = a.numpy()

print(a, b)

a += 1

print(a, b)

b += 1

print(a, b)

输出结果：

tensor([1., 1., 1., 1., 1.]) [1. 1. 1. 1. 1.]

tensor([2., 2., 2., 2., 2.]) [2. 2. 2. 2. 2.]

tensor([3., 3., 3., 3., 3.]) [3. 3. 3. 3. 3.]

Numpy数组转Tensor

import numpy as np

a = np.ones(5)

b = torch.from_numpy(a)

print(a, b)

a += 1

print(a, b)

b += 1

print(a, b)

输出结果：

[1. 1. 1. 1. 1.] tensor([1., 1., 1., 1., 1.], dtype=torch.float64)

[2. 2. 2. 2. 2.] tensor([2., 2., 2., 2., 2.], dtype=torch.float64)

[3. 3. 3. 3. 3.] tensor([3., 3., 3., 3., 3.], dtype=torch.float64)

还有一个常用的将NumPy中的array转换成Tensor的方法就是torch.tensor(), 需要注意的是，此方法总是会进行数据拷贝（就会消耗更多的时间和空间），所以返回的Tensor和原来的数据不再共享内存。

用torch.tensor()转换时不会共享内存

c = torch.tensor(a)

a += 1

print(a, c)

输出结果：

[4. 4. 4. 4. 4.] tensor([3., 3., 3., 3., 3.], dtype=torch.float64)

1. Tensor on GPU

用方法 to() 可以将Tensor在CPU和GPU（需要硬件支持）之间相互移动。

以下代码只有在PyTorch GPU版本上才会执行

if torch.cuda.is_available():

device = torch.device("cuda")          GPU

y = torch.ones_like(x, device=device)   直接创建一个在GPU上的Tensor

x = x.to(device)                     等价于 .to("cuda")

z = x + y

print(z)

         print(z.to("cpu", torch.double))        to()还可以同时更改数据类型

(2) 作业/练习答案

          练习：将广播机制中按元素操作的两个 NDArray 替换成其他形状，结果是否和预期一样？

                  x = torch.arange(1, 3).view(1, 2)

print(x)

y = torch.arange(1, 7).view(3, 2)

print(y)

print(x + y)

x = x.reshape(2,1,1)

print(x)

y = y.reshape(2,1,3)

print(y)

print(x + y)

输出结果：

tensor([[1, 2]])

tensor([[1, 2],

                     [3, 4],

                     [5, 6]])

tensor([[2, 4],

                     [4, 6],

                     [6, 8]])

tensor([[[1]],

                     [[2]]])

tensor([[[1, 2, 3]],

                     [[4, 5, 6]]])

tensor([[[2, 3, 4]],

                     [[6, 7, 8]]])

               结果不一样，reshape函数是将tensor转化为m个n*p的数组，如上所述样      例，将x转化为2个1*1的数组，将y转化为2个1*3的数组，因而产生了不同的结果。

3、自动微分

   在深度学习中，我们经常需要对函数求梯度（gradient）。PyTorch提供的autograd包能够根据输入和前向传播过程自动构建计算图，并执行反向传播。

   (1) 主要功能源码及分析

      a.创建Tensor并设置requires_grad

        x = torch.ones(2, 2, requires_grad=True)

print(x)

print(x.grad_fn)

        输出结果：

        tensor([[1., 1.],

        [1., 1.]], requires_grad=True)

None

运算操作

y = x + 2

print(y)

print(y.grad_fn)

输出结果：

tensor([[3., 3.],

        [3., 3.]], grad_fn=)

注意x是直接创建的，所以它没有grad_fn, 而y是通过一个加法操作创建的，所以它有一个为的grad_fn。

像x这种直接创建的称为叶子节点，叶子节点对应的grad_fn是None。

print(x.is_leaf, y.is_leaf)

输出结果：

True False

复杂运算操作

z = y * y * 3

out = z.mean()

print(z, out)

输出结果：

tensor([[27., 27.],

      [27., 27.]], grad_fn=) tensor(27.,grad_fn=)

通过.requires_grad_()来用in-place的方式改变requires_grad属性：

a = torch.randn(2, 2) # 缺失情况下默认 requires_grad = False

a = ((a * 3) / (a - 1))

print(a.requires_grad) # False

a.requires_grad_(True)

print(a.requires_grad) # True

b = (a * a).sum()

print(b.grad_fn)

输出结果：

False

True

      b.梯度计算

        因为out是一个标量，所以调用backward()时不需要指定求导变量：

out.backward()  等价于 out.backward(torch.tensor(1.))

我们来看看out关于x的梯度d(out)/dx：

print(x.grad)

输出结果：

tensor([[4.5000, 4.5000],

      [4.5000, 4.5000]])

我们令out为 � , 因为

=14∑=14=14∑=143(+2)2�=14∑�=14��=14∑�=143(��+2)2

所以∂∂||=1=92=4.5∂�∂��|��=1=92=4.5

所以上面的输出是正确的。

注意：grad在反向传播过程中是累加的(accumulated)，这意味着每一次运行反向传播，梯度都会累加之前的梯度，所以一般在反向传播之前需把梯度清零。

再来反向传播一次，注意grad是累加的

out2 = x.sum()

out2.backward()

print(x.grad)

out3 = x.sum()

x.grad.data.zero_()

out3.backward()

print(x.grad)

输出结果：

tensor([[5.5000, 5.5000],

       [5.5000, 5.5000]])

tensor([[1., 1.],

       [1., 1.]])

为什么在y.backward()时，如果y是标量，则不需要为backward()传入任何参数；否则，需要传入一个与y同形的Tensor?

简单来说就是为了避免向量（甚至更高维张量）对张量求导，而转换成标量对张量求导。举个例子，假设形状为 m x n 的矩阵 X 经过运算得到了 p x q 的矩阵 Y，Y 又经过运算得到了 s x t 的矩阵 Z。那么按照前面讲的规则，dZ/dY 应该是一个 s x t x p x q 四维张量，dY/dX 是一个 p x q x m x n的四维张量。问题来了，怎样反向传播？怎样将两个四维张量相乘？？？这要怎么乘？？？就算能解决两个四维张量怎么乘的问题，四维和三维的张量又怎么乘？导数的导数又怎么求，这一连串的问题，感觉要疯掉……

为了避免这个问题，我们不允许张量对张量求导，只允许标量对张量求导，求导结果是和自变量同形的张量。所以必要时我们要把张量通过将所有张量的元素加权求和的方式转换为标量，举个例子，假设y由自变量x计算而来，w是和y同形的张量，则y.backward(w)的含义是：先计算l = torch.sum(y * w)，则l是个标量，然后求l对自变量x的导数。

实例

x = torch.tensor([1.0, 2.0, 3.0, 4.0], requires_grad=True)

y = 2 * x

z = y.view(2, 2)

print(z)

输出结果；

tensor([[2., 4.],

       [6., 8.]], grad_fn=)

现在 z 不是一个标量，所以在调用backward时需要传入一个和z同形的权重向量进行加权求和得到一个标量。

v = torch.tensor([[1.0, 0.1], [0.01, 0.001]], dtype=torch.float)

z.backward(v)

print(x.grad)

输出结果：

tensor([2.0000, 0.2000, 0.0200, 0.0020])

注意，x.grad是和x同形的张量。

中断梯度追踪

x = torch.tensor(1.0, requires_grad=True)

y1 = x ** 2

with torch.no_grad():

2 = x ** 3

y3 = y1 + y2

print(x.requires_grad)

print(y1, y1.requires_grad)  True

print(y2, y2.requires_grad)  False

print(y3, y3.requires_grad)  True

输出结果：

True

tensor(1., grad_fn=) True

tensor(1.) False

tensor(2., grad_fn=) True

可以看到，上面的y2是没有grad_fn而且y2.requires_grad=False的，而y3是有grad_fn的。如果我们将y3对x求梯度的话会是多少呢？

y3.backward()

print(x.grad)

输出结果：

tensor(2.)

为什么是2呢？

由于2的定义是被torch.no_grad():包裹的，所以与2有关的梯度是不会回传的，只有与 1有关的梯度才会回传，即 2 对  的梯度。

上面提到，y2.requires_grad=False，所以不能调用 y2.backward()，会报错：

RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn

此外，如果我们想要修改tensor的数值，但是又不希望被autograd记录（即不会影响反向传播），那么我么可以对tensor.data进行操作。

x = torch.ones(1,requires_grad=True)

print(x.data)  还是一个tensor

print(x.data.requires_grad)  但是已经是独立于计算图之外

y = 2 * x

x.data *= 100  只改变了值，不会记录在计算图，所以不会影响梯度传播

y.backward()

print(x)  更改data的值也会影响tensor的值

print(x.grad)

输出结果：

tensor([1.])

False

tensor([100.], requires_grad=True)

tensor([2.])

四、总结

深度学习是一门理论性和实践性都很强的课程，因此要在理解概念的情况下再去学习，本次博客让我对深度学习有了新的认识和理解，对Pytorch的基本语法有了一定了解，也学习了一些函数，并在此基础上完成了平台的练习，但由于本身python基础较差，因此还需要补充python的基础以更好的学习深度学习这门课程，总的来说收获满满。