Pytorch快速入门手册

一、    张量生成
（1）    生成空的5*3的张量：torch.empty(5, 3)
（2）    生成0-1分布的5*3的张量：torch.rand(5, 3)
（3）    生成一个全零的5*3的张量：torch.zeros(5, 3)
（4）    已有矩阵转化为张量：torch.tensor([5.5, 3])

二、    张量操作
（1）    张量相加的两种方式：x + y / torch.add(x, y)
（2）    张量相加并替换自身的值：y.add_(x)
（3）    调整张量的形状：x.view(-1, 8)
（4）    查看张量的具体数值：x.item()

三、    张量和numpy相互转换
（1）    tensor到numpy：a.numpy()
（2）    numpy到tensor：b = torch.from_numpy(a)
（3）    cpu下张量和numpy的机制：张量和ndarray共享物理位置，改变其中一个值，另一个也会随之变化

四、    自动微分
（1）    设置参数方式：.requires_grad=true
（2）    计算微分函数：backward()
（3）    哪个代码段可以阻止梯度计算以及避免使用存储空间：
with torch.no_grad()
（4）    取梯度值：x.grad
（5）    向量的全微分方程：
雅可比行列式，
 

五、    神经网络
（1）    卷积输出通道数取决于：卷积核个数
（2）    卷积层要求输入输出维度：四维张量
（3）    全连接层要求输入输出维度：二维张量
（4）    super初始化方式：super(class, self).__init__()

六、    神经网络完整代码模板：
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

class Net(nn.Module):

    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 6, 5)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 4* 4, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        x = torch.flatten(x, start_dim=1)
        x = F.relu(self.fc1(x))   -- 全连接之后不需要池化，池化只针对卷积
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

net = Net()
optimizer = optim.SGD(net.parameters(), lr=0.01)
optimizer.zero_grad()

input = torch.rand(1, 1, 32, 32)
output = net(input)
target = torch.randn(10).view(1, -1)

criterion = nn.MSELoss()
loss = criterion(output, target)
loss.backward()

optimizer.step()

七、    torch package
（1）    torch：tensor library
（2）    torch.nn：neural network
（3）    torch.nn.functional：loss functions / activiation functions / convolution functions
（4）    torch.optim： optimization operations(SGD / Adm)
（5）    torch.utils：data sets / data loaders
（6）    torchvision：popular datasets / model architectures / image transformations

八、    CPU / GPU区别
GPU是并行计算，cpu一般是4或16核，而GPU是上千个核更适合并行计算

九、    tensor的秩
张量中存在的维数，即需要几个索引确定一个元素，或一个张量有多少个轴

十、    CNN网络的输入格式
[Batch, Channel, Height, Width]

十一、    torch.tensor：
（1）    张量：包含一个统一类型的数据
（2）    计算依赖：张量之间的计算依赖于类型和设备
十二、创建张量的4种方式及区别
（1）    t1 = torch.Tensor(data)
（2）    t2 = torch.tensor(data)
（3）    t3 = torch.as_tensor(data)
（4）    t4 = torch.from_numpy(data)
其中前两种是创建副本，后两种是共享内存

十三、Tensor operation
（1）    squeeze()：减少一个秩，只在某一个轴为1时才生效
（2）    flatten()：使秩为1，所有轴被挤压在一起
（3）    stack()：秩加1，在一个新轴上使张量相连接

十四、张量元素间操作
同numpy的元素间操作，存在broadcast的行为

十五、缩减操作
t.sum(dim=0)等价于：t[0] + t[1] + t[2]
t.sum(dim=1)等价于：(t[0].sum, t[1].sum, t[2].sum)

十六、mnist的含义
m：modify ;
nist：标准规范

十七、torchvision
（1）    两个重要的类
Dataset类，在torchvision.datasets中，包含__len()__和__getitem()__函数
DataLoader类：在torchvision.utils.data.Dataloader中，作用是批处理、线程管理和shuffle等
（2）    torchvision加载FashionMNIST过程
import torchvision
import torchvision.transforms as transforms

trains_set = torchvision.datasets.FashionMNIST(
root=’./data/fashionmnist’,
train=True,
download=True,
transform = transform.Compose([
    transforms.ToTensor()
])
)

train_loader = torchvision.utils.data.Dataloader(train_set, batch_size=10)

（3）    访问单个样例：sample = next(iter(train_set))
（4）    访问单子批次：batch = next(iter(train_loader))

十八、创建展示图片的网格
grid = torchvision.utils.make_grid(images, nrow=10)

十九、nn.conv2d(6, 16, 5)对应滤波器维度
滤波器维度：(16, 6, 5, 5)
分别表示：滤波器个数、滤波器深度（对应输入通道数量）、高、宽

二十、访问network的参数信息的代码
for param in network.parameters():
print(param)

二十一、使预测值变为概率值的代码
F.softmax(pred, dim=1)，
因为F.softmax(pred, dim=1).sum()值为1

二十二、比较预测值与实际值差异的代码
preds.argmax(dim=1).eq(labels).sum()

二十三、取出tensor中数值的代码
t.item()

二十四、CNN和Linear作用的说明
Cnn是生成特征图，
Linear是欧几里得空间维度的转换
 
二十五、cnn output size formula
（1）    正方形filter
O = (n – f + 2*p) / s + 1
n*n：input
f*f：filter
p：padding
s：stride
举例：
Input：（28 * 28）
Convolution:（5*5）之后为(24, 24)
Max_pooling：（2*2）之后为（12，12）
（2）    长方形filter
Oh = (nh – fh + 2p) / s + 1
Ow = (nw – fw + 2p) / s + 1

二十六、计算梯度
只计算梯度，未计算权重
loss.backward()
network.conv1.weight.grad的大小与network.conv1.weight的大小一样

二十七、更新权重
利用上面计算的grad来更新权重
optimizer = optim.Adam(network.parameters(), lr=0.01)
optimizer.step()更新权重

二十八、一次epoch的意思
覆盖了所有batch的一次迭代

二十九、optimizer需要在每个batch前清空的原因
optimizer的grad默认情况下是累计的，不清空会导致不同batch的grad不断被累加

三十、局部关闭梯度跟踪的方法
with torch.no_grad():
xxxx

三十一、生成混淆矩阵
 

from sklearn.metrics import confusion_matrix
cm = confusion_matrix(train_set.targets, train_preds.argmax(dim=1))

三十二、concat和stack的区别
concat是在一个现有的轴上连接一系列张量；stack是在一个新的轴上连接一系列的张量。
举例：
t1 = torch.tensor([1,1,1])
t2 = torch.tensor([2,2,2])
torch.cat((t1,t2), dim=0)为tensor([1,1,1,2,2,2])
torch.stack((t1, t2), dim=0)为tensor([[1,1,1], [2,2,2]])

三十三、tensorboard
（1）    运行tensorboard: tensorboard –logdir==runs(指定日志的目录)
（2）    引入包
from torch.utils.tensorboard import SummaryWriter
该类可实现将数据发送到tensorboard文件中
（3）    使用
tb = SummaryWriter()
tb.add_image()  添加图像
tb.add_graph() 添加无向图
tb.add_scalar() 添加标量
tb.add_histogram() 添加直方图