动手学深度学习

torch tensor的一些操作

（1）reshape()和view()操作
二者功能类似，都是为了改变tensor的shape。不同点在于view()只是改变shape，数据还是原来的数据，可以理解为看tensor的角度变了，tensor内部数据没变，并且view()只能处理连续的内存，因此前面经常跟一个contiguous()；而reshape()则没那么可控，他的执行结果可能是源数据的一个copy，也可能不是，即不共享data内存，所以不推荐使用。如果想返回一个真正新的副本（即不共享data内存）该怎么办呢？推荐先用clone创造一个副本然后再使用view，使用clone还有一个好处是会被记录在计算图中，即梯度回传到副本时也会传到源Tensor。
*注：虽然view返回的Tensor与源Tensor是共享data的，但是依然是一个新的Tensor（因为Tensor除了包含data外还有一些其他属性），二者id（内存地址）并不一致。 *
（2）item(), 它可以将一个标量Tensor转换成一个Python number。比如：

x = torch.randn(1)
print(x)
print(x.item())

最后输出

tensor([2.3466])
2.3466382026672363

（3）广播机制
当对两个形状不同的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列的矩阵按元素相加。
（4）tensor 和 numpy array相互转换

（5）tensor 放入GPU
用方法to()可以将Tensor在CPU和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()还可以同时更改数据类型

(6) 自动求梯度
在深度学习中，我们经常需要对函数求梯度（gradient）。PyTorch提供的autograd 包能够根据输入和前向传播过程自动构建计算图，并执行反向传播。本节将介绍如何使用autograd包来进行自动求梯度的有关操作。

<1> Tensor是这个autograd包的核心类，如果将其属性 .requires_grad 设置为 True，它将开始追踪(track)在其上的所有操作（这样就可以利用链式法则进行梯度传播了）。完成计算后，可以调用 .backward() 来完成所有梯度计算。此Tensor的梯度将累积到 .grad 属性中。缺失情况下默认 requires_grad = False,torch.autograd这个包就是用来计算一些雅克比矩阵的乘积的

注意：在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)
v = torch.tensor([[1.0, 0.1], [0.01, 0.001]], dtype=torch.float)
z.backward(v) #是对z进行反向传播，但是最后是x.grad
print(x.grad) #x.grad一定是和x同形的矩阵

tensor([[2., 4.],
[6., 8.]], grad_fn=) # ViewBackward代表z的操作是View
tensor([2.0000, 0.2000, 0.0200, 0.0020])

如果不想要被继续追踪，可以调用.detach()将其从追踪记录中分离出来，这样就可以防止将来的计算被追踪，这样梯度就传不过去了。此外，还可以用 with torch.no_grad() 将不想被追踪的操作代码块包裹起来，这种方法在评估模型的时候很常用，因为在评估模型时，我们并不需要计算可训练参数（requires_grad=True）的梯度。

Function是另外一个很重要的类。Tensor和Function互相结合就可以构建一个记录有整个计算过程的有向无环图（DAG）。每个Tensor都有一个.grad_fn属性，该属性即创建该Tensor的Function, 就是说该Tensor是不是通过某些运算得到的，若是，则grad_fn返回一个与这些运算相关的对象，否则是None。

所以综上，每个Tensor都有.grad_fn属性、 .requires_grad属性 、.grad属性。.grad_fn属性创建该Tensor的Function, 就是说该Tensor是不是通过某些运算得到的，若是，则grad_fn返回一个与这些运算相关的对象，否则是None。.requires_grad可以人为设置，若将其设置为 True，它将开始追踪(track)在该Tensor上的所有操作（这样就可以利用链式法则进行梯度传播了）。完成计算后，可以调用 .backward() 来完成所有梯度计算，如果不想要被继续追踪，可以调用.detach()将其从追踪记录中分离出来，这样就可以防止将来的计算被追踪，这样梯度就传不过去了。.grad属性是Tensor的梯度属性。

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

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

例子可以参考下面的文章：动手学深度学习2.3 自动求梯度

(7)二维数组，dim=0代表对列操作，dim=1代表对行操作。

X = torch.tensor([[1, 2, 3], [4, 5, 6]])
print(X.sum(dim=0, keepdim=True))
print(X.sum(dim=1, keepdim=True)) #keepdim操作是为了保持操作前后的维度不变，比如这里将行相加后原本会变成1维的，用了keepdim最后还是二维的

tensor([[5, 7, 9]])
tensor([[ 6],
[15]])