深度学习的python基础（1）

一.tensor创建

1.张量的定义

张量在形式上就是多维数组，例如标量就是0维张量，向量就是一维张量，矩阵就是二维张量，而三维张量就可以想象RGB图片，每个channel是一个二维的矩阵，共有三个channel，还可以考虑更多。

在代码中创建张量Tensor数据类型时，除了封装张量本身的数据data外，还会附加张量的一些性质和操作，例如数据的梯度（grad），创建tensor的函数（grad_fun，是求导的关键），是否为叶子节点（is_leaf），是否需要梯度（require_grad）。

2.张量的创建

2.1 tensor直接创建

   torch.tensor([1])   

arr = np.ones((3, 3))

    t = torch.tensor(arr, device='cuda')

    # t = torch.tensor(arr)

值得注意的点：

（1）tensor（）括号里的数据可以是list（以“()”表示），也可以是数组（以[]表示），也可以是numpy，即先用numpy创建一个numpy，然后直接导入（如下）；

（2）注意数据类型，有时候需要在数字后面加“.”表示float，因为求导时候需要float类型；

（3）可以添加device=’cuda’获得加速。

2.2 from_numpy从numpy中创建

    arr = np.array([[1, 2, 3], [4, 5, 6]])

    t = torch.from_numpy(arr)

      # arr[0, 0] = 0

     t[0, 0] = -1

值得注意的点：

（1）这个创建的tensor和原来的numpy共享内存，也即是说修改tensor就会修改原来的numpy。

2.3 从数字中创建

# 通过torch.zeros创建张量

out_t = torch.tensor([1])

#t=torch.zeros((3,3))

    t = torch.zeros((3, 3), out=out_t)

值得注意的点：

（1）也可以先创建一个tensor，然后在zeros函数的out接收创建的zeros，二者的size可以不一样，创建完成后二者一致。

（2）还可以torch.ones

（3）全1张量还可以用full函数

    t = torch.full((3, 3), 1)

注意试验一下是不是还可以创建全“2”张量？

（4）还可以利用torch.zeros_like()，torch.ones_like()，torch.full_like创建和input张量（类似于size,只不过是用一个真实的张量表示）一致的全0/1张量。

（5）torch.eye()创建单位对角矩阵

2.4 等差均分创建

    t = torch.arange(2, 10, 2)

（1）创建等差数列张量，后面为等差值，默认为1.

    # t = torch.linspace(2, 10, 5)

    t = torch.linspace(2, 10, 6)

（1）在[start,end]中均分n等份，这时会出现小数。

（2）还可以等log创建，torch.logspace()

2.5 依据概率创建

# 通过torch.normal创建正态分布张量

    # mean：张量 std: 张量

    # mean = torch.arange(1, 5, dtype=torch.float)

    # std = torch.arange(1, 5, dtype=torch.float)

    # t_normal = torch.normal(mean, std)

    # mean：标量 std: 标量

    # t_normal = torch.normal(0., 1., size=(4,))

    # mean：张量 std: 标量

    mean = torch.arange(1, 5, dtype=torch.float)

    std = 1

    t_normal = torch.normal(mean, std)

（1）注意mean，std可以是标量和张量的组合，共四种模式。

（2）torch.randn(),torch.randn_like()创建标准正态分布张量；

（3）torch.rand(),torch.rand_like()创建[0,1]均匀分布。

（4）torch.randint(low,high),torch.randint_like(low,high)创建[low,high)均匀分布。

（5）torch.randperm(n)，创建从0到n-1的随机排列张量

（6）torch.bernoulli(input)，创建以input为概率值的伯努利分布张量。

3.张量的操作

3.1张量拼接

torch.cat(tensors,dim)

    t = torch.ones((2, 3))

    t_0 = torch.cat([t, t], dim=0)

    t_1 = torch.cat([t, t, t], dim=1)

（1）是在原来的维度上进行拼接

torch.stack(tensor,dim)

    t = torch.ones((2, 3))

    t_stack = torch.stack([t, t, t], dim=0)

（1）是在新创建的维度上进行拼接，如果维度小于现存的维度，则创建该维度后，后面的递推。比如t现在维度是2*3，拼接后，则是3*2*3，其中后两维的2*3是原来的t。

3.2 张量切分

torch.chunk(input,chunk,dim)

    a = torch.ones((2, 7))  # 7

    list_of_tensors = torch.chunk(a, dim=1, chunks=3)   # 3

    for idx, t in enumerate(list_of_tensors):

(1)在维度dim上进行chunk均分，如果不能整除，最后一份为余数。

torch.split(input,int/list,dim)

    t = torch.ones((2, 5))

    list_of_tensors = torch.split(t, [2, 1, 1], dim=1)  # [2 , 1, 2]

    for idx, t in enumerate(list_of_tensors):

    # list_of_tensors = torch.split(t, [2, 1, 2], dim=1)

    # for idx, t in enumerate(list_of_tensors):

(1)为int时，和chunk功能类似；

（2）为list时，可以按照设定值切分，但总和要与input维度上值一致。

3.3 张量索引

torch.index_select(input,dim,select)

    t = torch.randint(0, 9, size=(3, 3))

    idx = torch.tensor([0, 2], dtype=torch.long)    # float

    t_select = torch.index_select(t, dim=0, index=idx)

(1)在dim维度上按照select索引数值。

torch.maksed_select(input,mask)

    t = torch.randint(0, 9, size=(3, 3))

    mask = t.le(5)  # ge is mean greater than or equal/   gt: greater than  le  lt

    t_select = torch.masked_select(t, mask)

 

1. mask是和input同大小的布尔类型张量，按照TRUE返回一维张量。

3.4张量变形

torch.reshape(input,shape)

    t = torch.randperm(8)

    t_reshape = torch.reshape(t, (-1, 2, 2))    # -1

    t[0] = 1024

3.5 张量维度交换

torch.transpose(input,dim1,dim2)

    # torch.transpose

    t = torch.rand((2, 3, 4))

    t_transpose = torch.transpose(t, dim0=1, dim1=2)    # c*h*w     h*w*c

(1)维度变换之后，数据是如何变化的？

（2）torch.t()二维张量（矩阵）转置

3.6 张量压缩

torch.sequeeze(input,dim)

    t = torch.rand((1, 2, 3, 1))

    t_sq = torch.squeeze(t)

    t_0 = torch.squeeze(t, dim=0)

    t_1 = torch.squeeze(t, dim=1)

（1）默认压缩所有为1的维度，也可以指定维度，若指定维度不为1，则不会压缩。

（2）torch.unsequeeze()，扩展维度的值。

4.张量的数学运算

    t_0 = torch.randn((3, 3))

    t_1 = torch.ones_like(t_0)

    t_add = torch.add(t_0, 10, t_1)

1. torch.add可同时执行乘法运算。

5.计算图

计算图是用来描述运算的有向无环图，包括结点（node）和边（edge）。结点表示数据，如向量，矩阵，张量等，边表示运算，如加减乘除卷积等。

import torch

w = torch.tensor([1.], requires_grad=True)

x = torch.tensor([2.], requires_grad=True)

a = torch.add(w, x)     # retain_grad()

b = torch.add(w, 1)

y = torch.mul(a, b)

y.backward()

print(w.grad)

# 查看叶子结点

# print("is_leaf:\n", w.is_leaf, x.is_leaf, a.is_leaf, b.is_leaf, y.is_leaf)

# 查看梯度

# print("gradient:\n", w.grad, x.grad, a.grad, b.grad, y.grad)

# 查看 grad_fn

print("grad_fn:\n", w.grad_fn, x.grad_fn, a.grad_fn, b.grad_fn, y.grad_fn)

6.自动求导

torch.autograd.backward(tensors,retain_graph)

    w = torch.tensor([1.], requires_grad=True)

    x = torch.tensor([2.], requires_grad=True)

    a = torch.add(w, x)

    b = torch.add(w, 1)

    y = torch.mul(a, b)

    y.backward(retain_graph=True)

    # print(w.grad)

    y.backward()

    w = torch.tensor([1.], requires_grad=True)

    x = torch.tensor([2.], requires_grad=True)

    a = torch.add(w, x)     # retain_grad()

    b = torch.add(w, 1)

    y0 = torch.mul(a, b)    # y0 = (x+w) * (w+1)

    y1 = torch.add(a, b)    # y1 = (x+w) + (w+1)    dy1/dw = 2

    loss = torch.cat([y0, y1], dim=0)       # [y0, y1]

    grad_tensors = torch.tensor([1., 2.])

    loss.backward(gradient=grad_tensors)    # gradient 传入 torch.autograd.backward()中的grad_tensors

torch.autograd.grad(outputs,inputs,retain_graph)

    x = torch.tensor([3.], requires_grad=True)

    y = torch.pow(x, 2)     # y = x**2

    grad_1 = torch.autograd.grad(y, x, create_graph=True)   # grad_1 = dy/dx = 2x = 2 * 3 = 6

    grad_2 = torch.autograd.grad(grad_1[0], x)              # grad_2 = d(dy/dx)/dx = d(2x)/dx = 2

1. autograd.grad()会返回梯度张量供保存。