Deeplizard《Pytorch神经网络高效入门教程》笔记

硬件基础：GPU、Cuda

GPU比起CPU更适合并行计算

机器学习中的计算多为可分解为并行计算的问题

Cuda是管理GPU的软件API

# 查看GPU的设备数量：
print(torch.cuda.device_count())

# 使用Cuda之前都需要检测一下cuda是否可用，没检测就默认没有
print(torch.cuda.is_available())

Pytorch可以使用多块GPU，Cuda可以指定GPU索引

为什么不在GPU上做所有的计算

数据从CPU转移到GPU上代价昂贵，将小型任务从CPU转移到GPU可能会更慢，GPU对于可以被分解成许多小任务的任务来说效果更好

张量（tensor）

张量是神经网络主要的数据结构，网络中的输入、输出、转换都是用张量表示的

张量的实例：（上下两两对应）

计算机术语：number、array、2d-array

数学术语：scalar、vector、matrix

综上，根据表示某个数据结构中的数据所需要的索引数量，将上述所有术语统一为：nd-array/nd-tensor，所以张量是多维数组

例如：

import torch

dd = [
[1,2,3],
[4,5,6],
[7,8,9]
]

t = torch.tensor(dd)

# print(torch.cuda.is_available())
# 调用cuda函数会返回同样的张量，但是会运行在GPU上
# t = t.cuda()

print(type(t))
# 输出：<class 'torch.Tensor'>

张量的秩

张量的秩表示了张量中存在的维数，如：rank-2 tensor = matrix = 2d-array = 2d-tensor

张量的秩告诉我们要多少索引来访问数据结构中的值

# 张量的秩 = shape的长度
print(len(t.shape))
# 输出：2

张量的轴

张量的轴表示一个张量的特定维数**（有多少坐标轴）**，轴的长度表示沿轴有多少索引

张量的秩表示了张量中存在的轴数，轴数 = 维数

张量的形状

张量的形状由每个轴的长度决定，知道张量的形状，就知道了每个轴的长度

import torch

t = torch.tensor([
    [1, 1, 1, 1],
    [2, 2, 2, 2],
    [3, 3, 3, 3]
], dtype=torch.float32)

print(t.size)
# 输出：torch.Size([3, 4])
print(t.shape)
# 输出：torch.Size([3, 4])
print(len(t.shape))
# 输出：2
print(torch.tensor(t.shape).prod())
# 输出：tensor(12)
print(t.numel())
# 输出：12

张量的形状包含了关于张量的轴、秩、索引信息

重塑（reshpae）没有改变原来数据结构中的数据，但是改变了数据的存储方式，如：2 by 3变成3 by 2

重塑的分量值乘积必须等于张量中元素的个数

# 在pytorch中张量的size和张量的shape是一样的
print(t.shape)
# 输出：torch.Size([3, 3])

# 重塑t
t = t.reshape(1,9)
print(t)
# 输出：tensor([[1, 2, 3, 4, 5, 6, 7, 8, 9]])
print(t.shape)
# 输出：torch.Size([1, 9])
print(len(t.shape))
# 输出：2

##Creating tensor from data

import torch
import numpy as np

t = torch.Tensor()
print(type(t))
# 输出：<class 'torch.Tensor'>

张量包含统一的数据类型

print(t.dtype)
# 输出：torch.float32

张量计算依赖于类型和设备

print(t.device)
# 输出：cpu
print(t.layout)
# 输出：torch.strided

创建张量

# 4种方法创建张量

# 类构造函数（Constructor）
data = np.array([1,2,3])
print(type(data))
# 输出：<class 'numpy.ndarray'>

# 工厂函数(Factories)
t1 = torch.Tensor(data)
print(type(t1))
# 输出：<class 'torch.Tensor'>

# 工厂函数(Factories)
t2 = torch.tensor(data)
print(type(t2))
# 输出：<class 'torch.Tensor'>

# 工厂函数(Factories)
t3 = torch.as_tensor(data)
print(type(t3))
# 输出：<class 'torch.Tensor'>

# 工厂函数(Factories)
t4 = torch.from_numpy(data)
print(type(t4))
# 输出：<class 'torch.Tensor'>

print(t1.dtype)
# 输出：torch.float32
print(t2.dtype)
# 输出：torch.int32
print(t3.dtype)
# 输出：torch.int32
print(t4.dtype)
# 输出：torch.int32

# 分析原因：构造函数在构造张量时使用全局缺省值，工厂函数根据输入判断数据类型

print(t1)
print(t2)
print(t3)
print(t4)

# 输出：
# tensor([1., 2., 3.])
# tensor([1, 2, 3], dtype=torch.int32)
# tensor([1, 2, 3], dtype=torch.int32)
# tensor([1, 2, 3], dtype=torch.int32)

numpy与pytorch的转换关系：

import torch
import numpy as np

data = np.array([1,2,3])

t1 = torch.Tensor(data)
t2 = torch.tensor(data)     # 最常用
t3 = torch.as_tensor(data)  # 可以接受python中的任意数据类型
t4 = torch.from_numpy(data) # 只可以接受numpy中的数据类型

data[0] = 0
data[1] = 0
data[2] = 0

print(t1)
print(t2)
print(t3)
print(t4)

# 输出：
# tensor([1., 2., 3.])
# tensor([1, 2, 3], dtype=torch.int32)
# tensor([0, 0, 0], dtype=torch.int32)
# tensor([0, 0, 0], dtype=torch.int32)

# 分析原因：这种差异源于每个创建选项中分配内存的方式
# 前两个选项在内存中创建额外的输入数据副本(copy)
# 后两者用数组在内存中的共享，两者指针相同（share）

创建特殊张量：

# 创建特殊张量

# 创建2*2的单位张量（矩阵）
t5 = torch.eye(2)
print(t5)
# 输出：
# tensor([[1., 0.],
#         [0., 1.]])

# 创建2*2的0张量
t6 = torch.zeros(2,2)
print(t6)
# 输出：
# tensor([[0., 0.],
#         [0., 0.]])

# 创建全1张量
t7 = torch.ones(2,2)
print(t7)
# 输出：
# tensor([[1., 1.],
#         [1., 1.]])

# 创建随机张量
t8 = torch.rand(2,2)
print(t8)
# 输出：
# tensor([[0.9487, 0.1351],
#         [0.9750, 0.0050]])

张量运算

压缩（flatten）操作：

import torch

# 将下面3个张量看做3张4*4的图片，作为1个批次传入CNN（CNN输入一般长度为4，即有一个秩为4的张量，有 4个坐标轴）

t1 = torch.tensor([
    [1,1,1,1],
    [1,1,1,1],
    [1,1,1,1],
    [1,1,1,1],
])

t2 = torch.tensor([
    [2,2,2,2],
    [2,2,2,2],
    [2,2,2,2],
    [2,2,2,2],
])

t3 = torch.tensor([
    [3,3,3,3],
    [3,3,3,3],
    [3,3,3,3],
    [3,3,3,3],
])

# 用堆栈将3个张量连接到一个轴上
t = torch.stack((t1,t2,t3))
print(t.shape)
# 输出：torch.Size([3, 4, 4])
# 3：表示轴的长度（批大小）；4：长和宽

# 重塑图像
t = t.reshape(3,1,4,4)
print(t)
# 输出：
# tensor([[[[1, 1, 1, 1],
#           [1, 1, 1, 1],
#           [1, 1, 1, 1],
#           [1, 1, 1, 1]]],
#
#
#         [[[2, 2, 2, 2],
#           [2, 2, 2, 2],
#           [2, 2, 2, 2],
#           [2, 2, 2, 2]]],
#
#
#         [[[3, 3, 3, 3],
#           [3, 3, 3, 3],
#           [3, 3, 3, 3],
#           [3, 3, 3, 3]]]])

用索引解释每个轴的意义：

# 输出第一个图像
print(t[0])
# 输出：
# tensor([[[1, 1, 1, 1],
#          [1, 1, 1, 1],
#          [1, 1, 1, 1],
#          [1, 1, 1, 1]]])

# 输出第一个图像里第一个彩色通道
print(t[0][0])
# 输出：
# tensor([[1, 1, 1, 1],
#         [1, 1, 1, 1],
#         [1, 1, 1, 1],
#         [1, 1, 1, 1]])

# 输出第一个图像里第一个彩色通道的第一行像素
print(t[0][0][0])
# 输出：
# tensor([1, 1, 1, 1])

# 输出第一个图像里第一个彩色通道的第一行像素的第一个像素值
print(t[0][0][0][0])
# 输出：
# tensor(1)

元素操作：两个张量必须有相同的形状才能执行一个元素操作

import numpy as np
import torch

t1 = torch.tensor([
    [1,2],
    [3,4]
],dtype=torch.float32)

t2 = torch.tensor([
    [9,8],
    [7,6]
],dtype=torch.float32)

t3 = torch.tensor([
    [9,8]
],dtype=torch.float32)

print(t1+t2)
# 输出：
# tensor([[10., 10.],
#         [10., 10.]])

# 张量广播：低秩的张量会通过广播转换，复制张量的一个或多个轴，使它与另一个张量形状相同

print(t1+2)
# 输出：
# tensor([[3., 4.],
#         [5., 6.]])
print(t3+t2)
# 输出：
# tensor([[18., 16.],
#         [16., 14.]])