一、Tensor
Tensor是Pytorch中重要的数据结构，可以认为是一个高维数组。Tensor可以是一个标量、一维数组（向量）、二维数组（矩阵）或者高维数组等。Tensor和numpy的ndarrays相似。
import torch as t
构建矩阵：x = t.Tensor(m, n)
注意这种情况下只分配了空间，并没有初始化。
使用[0,1]均匀分布随机初始化矩阵：x = t.rand(m, n)
查看x的形状：x.size()
加法：
(1)x + y
(2)t.add(x, y)
(3)t.add(x, y, out = res)
(4)y.add(x) #不改变y的内容
(5)y.add_(x) #改变y的内容
注意，函数名后面带下划线_的函数会修改Tensor本身，而x.add(y)等则会返回一个新的Tensor，而x不变。
Tensor可以进行数学运算、线性代数、选择、切片等。而且Tensor与numpy的数组间互操作十分方便。对于Tensor不支持的操作可以先转为numpy处理，再转为Tensor。
a = t.ones(5) b = a.numpy() # Tensor -> Numpy a = np.ones(5) b = t.from_numpy(a) # Numpy -> Tensor
Tensor和numpy的对象是共享内存的，如果其中一个改变，那么另一个也会随之改变。
Tensor可以通过.cuda方法转为GPU的Tensor。GPU加速：
if t.cuda.is_available():
x = x.cuda()
y = y.cuda()
x + y
二、Autograd：自动微分
Pytorch的Autograd模块实现了求导功能，在Tensor上的所有操作，Autograd都能自动为它们提供微分。
autograd.Variable是Autograd的核心类，简单封装了Tensor，并几乎支持所有的Tensor操作。当Tensor被封装为Variable后，可以通过调用.backward实现反向传播，自动计算所有的梯度。
Variable包括三个属性：
（1）data：保存Variable包含的Tensor；
（2）grad：保存data对应的梯度，grad也是个Variable；
（3）grad_fn：指向一个Function对象，该Function用于反向传播计算输入的梯度。
from torch.autograd import Variable x = Variable(t.ones(2, 2), requires_grad = True) y = x.sum() print(y.grad_fn) y.backward() print(x.grad) y.backward() print(x.grad)
注意，grad在反向传播中是累加的，也就是说每次运行反向传播时梯度都会累加之前的梯度，因此需要反向传播之前要把梯度清零。
x.grad.data.zero_() # inplace操作，把x的data对应的梯度值清零 Variable和Tensor的转换： x = Variable(t.ones(4, 5)) y = t.cos(x) x_tensor_cos = t.cos(x.data) # Variable x的data的cosine对应的Tensor
三、神经网络
torch.nn是专门为神经网络设计的模块化接口。nn.Module可以看做是一个网络的封装，包括网络各层的定义以及forward方法，调用forward(input)方法，可返回前向传播的结果。
LeNet网络结构如下图：
定义网络时，要继承nn.Module，并实现它的forward方法，把网络中具有可学习参数的层放在构造函数__init__中。如果某层不具有可学习的参数，则既可以放在构造函数中，也可以不放。
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
def __init__(self):
# nn.Module子类的函数必须在构造函数中执行父类的构造函数
# 下式等价于nn.Module.__init__(self)
super(Net, self).__init__()
# '1'表示输入图像为单通道，'6'表示输出通道数
# '5'表示卷积核大小为5*5
self.conv1 = nn.Conv2d(1, 6, 5)
# 卷积层
self.conv2 = nn.Conv2d(6, 16, 5)
# 仿射层/全连接层，y = Wx + b
self.fc1 = nn.Linear(16 * 5 * 5, 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)
# reshape, '-1'表示自适应
x = x.view(x.size()[0], -1)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
net = Net()
print(net)
运行结果：
只要在nn.Module的子类中定义了forward函数，backward函数就会被自动实现。网络的可学习参数通过net.parameters()返回，而net.named_parameters可同时返回可学习的参数及名称。
params = list(net.parameters())
print(len(params))
for name, parameters in net.named_parameters():
print(name, ':', parameters.size())
运行结果：
注意，输入和输出都必须是Variable。
torch.nn只支持mini-batches，不支持一次只输入一个样本，也就是说一次必须是一个batch。如果只想输入一个样本，那么要用input.unsqueeze(0)将batch_size设为1。
损失函数：
（1）nn.MSELoss用于计算均方误差
（2）nn.CrossEntropyLoss用于计算交叉熵损失
output = net(input) target = Variable(t.arange(0, 10)) target = target.float() criterion = nn.MSELoss() loss = criterion(output, target)
在反向传播计算所有参数的梯度后，还需要使用优化方法更新网络的权重和参数，如SGD：
weight = weight - lr * gradient
手工实现如下：
lr = 0.01
for f in net.parameters():
f.data.sub_(f.grad.data * lr)
torch.optim中实现了深度学习中的绝大多数优化方法，如RMSProp、Adam、SGD等。
# 新建一个优化器，指定要调整的参数和学习率
optimizer = optim.SGD(net.parameters(), lr = 0.01)
# 训练过程中，先梯度清零
optimizer.zero_grad()
# 计算损失
output = net(input)
loss = criterion(output, target)
# 反向传播
loss.backward()
optimizer.step()
torchvision实现了常用的图像数据加载功能。
四、CIFAR-10 分类
import torch.nn as nn
import torch as t
from torch.autograd import Variable
import torch.nn.functional as F
import torch.optim as optim
import torchvision as tv
import torchvision.transforms as transforms
from torchvision.transforms import ToPILImage
show = ToPILImage() # 把Tensor转换成Image，方便可视化
# 数据预处理
transform = transforms.Compose([transforms.ToTensor(), # 转为Tensor
transforms.Normalize((0.5, 0.5, 0.5), (0.5,0.5, 0.5)),])
# 训练集
trainset = tv.datasets.CIFAR10(root = 'F:/PycharmProjects/', train = True, download =
True, transform = transform)
trainloader = t.utils.data.DataLoader(trainset, batch_size = 4, shuffle = True, num_workers = 2)
# 测试集
testset = tv.datasets.CIFAR10(root = 'F:/PycharmProjects/', train = False, download =
True, transform = transform)
testloader = t.utils.data.DataLoader(testset, batch_size = 4, shuffle = False, num_workers = 2)
classes = ('plane', 'car', 'bird', 'cat',
'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
(data, label) = trainset[100]
print(classes[label])
show((data + 1) / 2).resize(100, 100)
# 将dataset返回的每一条数据样本拼接成一个batch
dataiter = iter(trainloader)
images, labels = dataiter.next()
print(' '.join('%11s' % classes[labels[j]] for j in range(4)))
show(tv.utils.make_grid((images + 1) / 2)).resize((400, 100))
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 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 = x.view(x.size()[0], -1)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
net = Net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr = 0.001, momentum = 0.9)
for epoch in range(2):
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
inputs, labels = data
inputs, labels = Variable(inputs), Variable(labels)
optimizer.zero_grad()
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
# 参数更新
optimizer.step()
running_loss += loss.data[0]
if i % 2000 == 1999:
print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0
print('Finished Training')
dataiter = iter(testloader)
images, labels = dataiter.next()
outputs = net(Variable(images))
_, predicted = t.max(outputs.data, 1)
print('predicted result', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))
correct = 0
total = 0
for data in testloader:
images, labels = data
outputs = net(Variable(images))
_, predicted = t.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted ==labels).sum
print('The accuracy is: %d %%' % (100 * correct / total))
#GPU加速操作：
if t.cuda.is_available():
net.cuda()
images = images.cuda()
labels = labels.cuda()
output = net(Variable(images))
loss = criterion(output, Variable(labels))