代码搬运自戳我
同时感谢提供了详细学习笔记的maomao9173神仙
PART1
from __future__ import print_function
import torch
x = torch.empty(5, 3)
# empty -> 未初始化，随机值
x = torch.rand(5, 3)
# rand -> [0, 1] 均匀随机
x = torch.randn(5, 3)
# randn -> [0, 1] 正态分布
x = torch.zeros(5, 3, dtype = torch.long)
# zeros -> 全 0
x = torch.tensor([5.5, 3])
# 直接用数据构造 tensor
x = x.new_ones(5, 3, dtype = torch.double)
# new_ones : 获得一个n.m的张量，元素均为1，属性继承于张量x
x = torch.randn_like(x, dtype = torch.float)
# randn_like : 随机数
print(x.size())
# 展示张量的形状
y = torch.rand(5, 3)
print(x + y)
print(torch.add(x, y))
# 逐位相加，上面两个语句结果相同
result = torch.empty(5, 3)
torch.add(x, y, out = result)
# 把 x 和 y 相加的结果存到 result 里面
y.add_(x)
y.copy_(x)
# 把 x 加到 y 上去 / 把 x 拷到 y 里面去
# 常见语法 : 带有"_"后缀的函数一般都是把结果存在当前变量里
print(x[:, 1])
# 遍历行的第一列输出
x = torch.randn(4, 4)
y = x.view(16)
z = x.view(-1, 8)
# view 表示将原矩阵改变性状（长宽比）
# z 的第一维度尺寸会自动推断
x = torch.randn(1)
print(x)
print(x.item())
# 单元素tensor通过item获得其包含的值
a = torch.ones(5)
b = a.numpy()
# tensor <-> numpy : 轻而易举
a.add_(1)
print(a)
print(b)
# 如果torch tensor在gpu上跑，那么把tensor给numpy
# 和把numpy给tensor时，他们会占用同样的内存空间。
import numpy as np
a = np.ones(5)
b = torch.from_numpy(a)
np.add(a, 1, out = a)
print(a)
print(b)
# All the tensors on the CPU except a CharTensor
# support converting to Numpy and back
if torch.cuda.is_available():
device = torch.device("cuda")
y = torch.ones_like(x, device = device)
# ones_like : 返回一个用1填充的 和输入形状与类型一致的数组
print(x)
print(y)
# 通过这种方法，直接创建一个gpu上的tensor
# x = x.to(device)
# z = x + y
print(z)
print(z.to("cpu", torch.double))
# .to还可以同时改变dtype！
PART2
import torch
import numpy as np
'''
torch.Tensor是autograd包里的核心类。如果把
[.requires_grad]设置为True，它就会跟踪每一
个操作，并在完成其他计算后，执行[.backward]
进行反向传播，自动计算梯度。它所得到的结果会
被累加到[.grad]属性中。
'''
# 使用[.detach()]来阻止它自动进行跟踪历史。
# 也可以使用[with torch.no_grad()]
# 避免它自动跟踪历史并占用空间。
# .grad_fn: 是创建这个tensor的function
x = torch.ones(2, 2, requires_grad = True)
print(x)
y = x + 2
print(y)
# y是通过一个操作创造的tensor而不是用户自行
# 所以它有grad_fn
print(y.grad_fn)
z = y * y * 3
out = z.mean()
print(z, out)
# mean函数求平均值
a = torch.randn(2, 2)
a = ((a * 3) / (a - 1))
print(a.requires_grad)
a.requires_grad_(True)
print(a.requires_grad)
b = (a * a).sum()
print(b.grad_fn)
# .requires_grad_改变requires_grad变量
# requires_grad默认设置为False
out.backward() # 进行反向传播
print(x.grad_fn)
x = x * x
x.backward()
print(x.grad)
x = torch.randn(3, requires_grad = True)
y = x * 2
while y.data.norm() < 1000:
y = y * 2
# .data.norm()表示对数组里面（类型为float）所有值求平方和，然后开方
print(y)
# ones : 全1
# zeros: 全0
PART3
import torch
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
# 哇！又不会啦！
# 1 input image channel, 6 output channels, 3x3 square convolution
# kernel
self.conv1 = nn.Conv2d(1, 6, 3)
self.conv2 = nn.Conv2d(6, 16, 3)
# 输入通道数 / 输出通道数 / 卷积核大小
# 在pytorch中，定义层会默认使用HE初始化
self.fc1 = nn.Linear(16 * 6 * 6, 120)
# 输入张量大小 / 输出张量大小
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
# an affine operation: y = Wx + b
def forward(self, x):
# Max polling over a (2, 2) window
x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
# if the size is a square you can only specify a single number
x = F.max_pool2d(F.relu(self.conv2(x)), (2,3))
x = x.view(-1, self.num_flat_features(x))
# num_flat_features把之前的张量铺开成一维的
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
def num_flat_features(self, x):
size = x.size()[1:]
# 哇 是不会的诶!
num_features = 1
for s in size:
num_features *= s
return num_features
net = Net()
print(net)
params = list(net.parameters())
# print(params)
# print(params.size())
print(params[0].size())
input = torch.randn(1, 1, 32, 32)
out = net(input)
print(out)
net.zero_grad()
out.backward(torch.randn(1, 10))
output = net(input)
target = torch.randn(10)
# 这样得到的target形状是10，我们需要转化它为[1, 10]
target = target.view(1, -1)
# print(target.size())
criterion = nn.MSELoss()
loss = criterion(output, target)
# print(loss)
# print(loss.grad_fn)
# print(loss.grad_fn.next_functions[0][0])
# print(loss.grad_fn.next_functions[0][0].next_functions[0][0])
net.zero_grad()
# 先清零梯度，不然会发生累积
print('conv1.bias.grad before backward:')
print(net.conv1.bias.grad)
loss.backward()
print('conv1.bias.grad after backward:')
print(net.conv1.bias.grad)
learning_rate = 0.01
for f in net.parameters:
f.data.sub_(f.grad.data * learning_rate)
# 实现weight = weight - learning_rate * gradient
import torch.optim as optim
# 用这个包实现SGD / Nesterov-SGD / Adam / RMSProp.etc
optimizer = optim.SGD(net.parameters(), lr = 0.01)
# net的参数 / 学习率
# in your training loop:
optimizer.zero_grad() # zero the gradient buffers
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step() # Do the update
# 注意: 每次一定要做zero_grad
PART4
# What about data?
# Generally, when you have to deal with image, text, audio
# or video data, you can use standard python packages that
# load data into a numpy array. Then you can convert this
# array into a torch.*Tensor.
# For images, packages such as Pillow, OpenCV are useful
# For audio, packages such as scipy and librosa
# For text, either raw Python or Cython based loading, or
# NLTK and SpaCy are useful
# CIFAR-10和CIFAR-100是带有标签的数据集
import torch
import torchvision
import torchvision.transforms as transforms
# torchvision中提供的数据集是[0, 1]间的实数。
# 我们要把它转化成范围为[-1, 1]的实数。
# 注意！如果在Windows上运行，返回一个BrokenPipeError
# 的错误，请尝试把torch.utils.data.DataLoader() 的
# num_worker设置为0
transform = transforms.Compose(
[
transforms.ToTensor(),
# 转化为tensor
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
# 前面的(0.5, 0.5, 0.5)是RGB通道上的均值
# 后面(0.5, 0.5, 0.5)是三个通道的标准差
# image = (图像 - 平均值) / std
# 通过这个转化会把它变成[-1, 1]上的值
]
)
trainset = torchvision.datasets.CIFAR10(
root = './data',
train = True, # 训练数据
download = True,
transform = transform
)
trainloader = torch.utils.data.DataLoader(
trainset, # 训练数据来源
batch_size = 4, # 每次训练几个数据: default = 1
shuffle = True, # 是否随机打乱
# num_workers = 1 # 使用几个subprocesses
)
testset = torchvision.datasets.CIFAR10(
root = './data',
train = False, # 非训练数据
download = True,
transform = transform
)
testloader = torch.utils.data.DataLoader(
testset,
batch_size = 4,
shuffle = False, # 每次不随机打乱
# num_workers = 1
)
classes = ('plane', 'car', 'bird', 'cat', 'deer',
'dog', 'frog', 'horse', 'ship', 'truck')
import matplotlib.pyplot as plt
import numpy as np
# functions to show an image
def imshow(img):
img = img / 2 + 0.5 # unnormalize
npimg = img.numpy()
plt.imshow(np.transpose(npimg, (1, 2, 0)))
# transpose 是一个轴变换操作, x是0, y是1, z是2
# 此处:y -> x, z -> y, x -> z
plt.show()
# get some random training images
'''
dataiter = iter(trainloader)
images, lables = dataiter.next()
# 用dataiter来遍历所有的数据
# 由于shuffle为True, 每次都会随机选择。
# show images
imshow(torchvision.utils.make_grid(images))
# make_grid: 画图 &网格
# print lables
print(' '.join(classes[lables[j]] for j in range(4)))
# .join: 用' '链接join里面的字符串
'''
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
# self.conv1 = nn.Conv2d(3, 6, 5)
self.conv1 = nn.Conv2d(3, 100, 5)
self.pool = nn.MaxPool2d(2, 2)
# self.conv2 = nn.Conv2d(6, 16, 5)
self.conv2 = nn.Conv2d(100, 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 = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(-1, 16 * 5 * 5)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
net = Net()
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr = 0.001, momentum = 0.9)
# 网络元素 & 学习率 & 动量因子
path = './cifar_net.pth'
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
net.to(device)
# 这个操作会递归地把所有模块转变为gpu上的模块
if (input() == "Train"):
for epoch in range(10): # loop over the dataset multiple times
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
# enumerate (sequence, start = 0)
# i是当前标号，data是获取到的元素
inputs, lables = data
# inputs = inputs
# lables = lables
inputs = inputs.to(device)
lables = lables.to(device)
# 由于网络本身不是很大，所以对速度提升不太明显
# zero the parameter gradients first
optimizer.zero_grad()
#forward + backward + optimize
outputs = net(inputs)
loss = criterion(outputs, lables)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
if i % 2000 == 1999: # print every 2000 mini-batches
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0
print('Finished Training')
torch.save(net.state_dict(), path)
# net.state_dict() -> 当前参数状态
dataiter = iter(testloader)
images, lables = dataiter.next()
#print images
imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ', ' '.join(classes[lables[j]] for j in range(4)))
net = Net()
net.load_state_dict(torch.load(path))
# load back in our saved model
correct = 0
total = 0
with torch.no_grad():
# 在接下来的操作中不自动计算grad
for data in testloader:
images, lables = data
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
# 第一个参数是softmax函数输出的一个tensor
# 第二个参数: 维度索引0/1, 0是每列max, 1是每行max
# 返回两个Tensor, 第一个tensor是每行最大值，第二个tensor是最大值索引
total += lables.size(0)
correct += (predicted == lables).sum().item()
# tensor.sum() 返回总和
# tensor.item() 把Tensor转换为一个数字
print('Accuracy of the network on the 10000 test images: %d %%' % (
100 * correct / total))
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
# list(a, b, c)代表创建一个为[a, b, c]的列表
# 0. 是一个double型的0
# for i in range(10)是创建10个这样的0
with torch.no_grad():
for data in testloader:
images, lables = data
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
c = (predicted == lables).squeeze()
# squeeze: 把他们的结果压缩成一个Bool列表
for i in range(4):
# 数据集大小为4, 所以每次取testloader里面样本都有四个
lable = lables[i]
class_correct[lable] += c[i].item()
# True为1, False为0
class_total[lable] += 1
for i in range(10):
print("Accuracy of %s : %2d %%" % (
classes[i], 100 * class_correct[i] / class_total[i]))
# 附注：让人沮丧的是，简单的加深深度并不能有效地提高识别精度，甚至会导致loss函数不收敛。