import torch
"""
构建非初始化的矩阵
"""
x = torch.empty(5,3)#print(x)"""
构建随机初始化矩阵
"""
x = torch.rand(5,3)"""
构造一个矩阵全为 0,而且数据类型是 long
"""
x = torch.zeros(5,3, dtype=torch.long)"""
直接构造一个张量:
"""
x = torch.tensor([5.5,3])"""
创建一个 tensor 基于已经存在的 tensor。
"""
x = x.new_ones(5,3, dtype=torch.double)
x = torch.randn_like(x, dtype=torch.float)#randn_like->返回与输入大小相同的张量,该张量由正态分布中的随机数填充,平均值为0,方差为1。"""
获取它的维度信息:
"""print(x.size())"""
tensor的加法
"""
y = torch.rand(5,3)#第一种方法print(x + y)#第二种方法print(torch.add(x, y))#第三种方法
result = torch.empty(5,3)
torch.add(x, y, out=result)print(result)#第四种方法
y.add_(x)#注意:这是原地加法,y=x+y#任何在原地(in-place)改变张量的操作都有一个_后缀。例如x.copy_(y), x.t_()操作将改变x."""
tensor切片
"""print(x[:,1])#这里输出的x第二列,如果是第二行就是[1,:]"""
改变一个 tensor 的大小或者形状
"""
y = x.view(16)
z = x.view(-1,8)#注意这个-1,这个-1代表你并不清楚这个tensor修改后的行数或者列数是多少,所以用-1代替,只能存在一个-1"""
获取tensor值(这里可以直接提取使用value)
"""print(x.item())
Pytorch自动微分
import torch
"""
创建一个张量,设置 requires_grad=True 来跟踪与它相关的计算(来源)
"""
x = torch.ones(2,2, requires_grad=True)print(x)
y = x +2print(y)#如果这时打印y,你会发现y有了一个grad_fn也在跟踪计算print(y.grad_fn)#打印grad_fn就会得到y的来源
z = y * y *3
out = z.mean()#mean函数中的参数dim代表在第几维度求平均数。print(z, out)print(z.requires_grad)#.requires_grad_( ... ) 会改变张量的 requires_grad 标记。输入的标记默认为 False ,如果没有提供相应的参数。"""
反向传播梯度
"""#我们现在后向传播,因为输出包含了一个标量,out.backward() 等同于out.backward(torch.tensor(1.))。
out.backward()print(x.grad)#out反向传播后,改变的是之前变量的梯度,即x"""
雅可比向量积的例子:
在向量微积分中,雅可比矩阵是一阶偏导数以一定方式排列成的矩阵,其行列式称为雅可比行列式。
"""
x = torch.randn(3, requires_grad=True)
y = x *2while y.data.norm()<1000:#torch.norm是对输入的Tensor求范数
y = y *2print(y)#现在在这种情况下,y 不再是一个标量。torch.autograd 不能够直接计算整个雅可比,但是如果我们只想要雅可比向量积,只需要简单的传递向量给 backward 作为参数。
v = torch.tensor([0.1,1.0,0.0001], dtype=torch.float)
y.backward(v)print(x.grad)#你可以通过将代码包裹在 with torch.no_grad(),来停止对从跟踪历史中的 .requires_grad=True 的张量自动求导。with torch.no_grad():print((x **2).requires_grad)
Pytorch神经网络
import torch
import torch.nn as nn
import torch.functional as F
classNet(nn.Module):def__init__(self):super(Net, self).__init__()
self.conv1 = nn.Conv2d(1,6,5)#Conv2d(in_channels, out_channels, kernel_size, stride=1,padding=0, dilation=1, groups=1,bias=True, padding_mode=‘zeros’)
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)defforward(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(-1, self.num_flat_features(x))
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)return x
defnum_flat_features(self, x):
size = x.size()[1:]
num_features =1for s in size:
num_features *= s
return num_features
net = Net()#print(net)"""
一个模型可训练的参数可以通过调用 net.parameters() 返回:
"""# params = list(net.parameters())# print(len(params))# print(params[0].size())"""
让我们尝试随机生成一个 32x32 的输入。注意:期望的输入维度是 32x32
"""input= torch.randn(1,1,32,32)#这一步会错误,我也不知道为什么:AttributeError: module 'torch.functional' has no attribute 'max_pool2d'
out = net(input)print(out)"""
把所有参数梯度缓存器置零,用随机的梯度来反向传播
"""
net.zero_grad()
out.backward(torch.randn(1,10))"""
一个损失函数需要一对输入:模型输出和目标,然后计算一个值来评估输出距离目标有多远。
有一些不同的损失函数在 nn 包中。一个简单的损失函数就是 nn.MSELoss ,这计算了均方误差。
"""
output = net(input)
target = torch.randn(10)
target = target.view(1,-1)# make it the same shape as output
criterion = nn.MSELoss()
loss = criterion(output, target)print(loss)"""
现在,如果你跟随损失到反向传播路径,可以使用它的 .grad_fn 属性,查看计算图
"""print(loss.grad_fn)"""
为了实现反向传播损失,我们所有需要做的事情仅仅是使用 loss.backward()。你需要清空现存的梯度,要不然帝都将会和现存的梯度累计到一起。
"""# net.zero_grad()# loss.backward()"""
如果你是用神经网络,你想使用不同的更新规则,类似于 SGD, Nesterov-SGD, Adam, RMSProp, 等。为了让这可行,我们建立了一个小包:torch.optim 实现了所有的方法。使用它非常的简单。
"""import torch.optim as optim
# create your optimizer
optimizer = optim.SGD(net.parameters(), lr=0.01)# in your training loop:
optimizer.zero_grad()# zero the gradient buffers
output = net(input)
loss = criterion(output, target)
loss.backward()
optimizer.step()
Pytorch图像分类器
import torch
import torchvision
import torchvision.transforms as transforms
"""
下载数据集并将其归一化
torchvision 数据集的输出是范围在[0,1]之间的 PILImage,我们将他们转换成归一化范围为[-1,1]之间的张量 Tensors。
"""
transform = transforms.Compose([transforms.ToTensor(),
transforms.Normalize(mean =(0.5,0.5,0.5), std =(0.5,0.5,0.5))])#(1)transforms.Compose就是将transforms组合在一起;#(2)transforms.Normalize使用如下公式进行归一化:# channel=(channel-mean)/std(因为transforms.ToTensor()已经把数据处理成[0,1],那么(x-0.5)/0.5就是[-1.0, 1.0])# 这样一来,我们的数据中的每个值就变成了[-1,1]的数了。
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
download=False, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
shuffle=True, num_workers=2)
testset = torchvision.datasets.CIFAR10(root='./data', train=False,
download=False, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
shuffle=False, num_workers=2)
classes =('plane','car','bird','cat','deer','dog','frog','horse','ship','truck')"""
展示其中的一些训练图片。
"""import matplotlib.pyplot as plt
import numpy as np
defimshow(img):
img = img /2+0.5
npimg = img.numpy()
plt.imshow(np.transpose(npimg,(1,2,0)))
plt.show()# dataiter = iter(trainloader)# images, labels = dataiter.next()# imshow(torchvision.utils.make_grid(images))# for j in range(4):# print(' '.join('%5s' % classes[labels[j]]))"""
之前的神经网络复制过来
"""import torch.nn as nn
import torch.nn.functional as F
classNet(nn.Module):def__init__(self):super(Net, self).__init__()
self.conv1 = nn.Conv2d(3,6,5)
self.pool = nn.MaxPool2d(2,2)
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)defforward(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()"""
定义一个损失函数和优化器 让我们使用分类交叉熵Cross-Entropy 作损失函数,动量SGD做优化器。
"""import torch.optim as optim
if __name__ =='__main__':#<--遇到BUG:The “freeze_support()” line can be omitted if the program is not going to be frozen的解决办法-->
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)"""
在数据迭代器上循环传给网络和优化器 输入就可以
"""for epoch inrange(2):# loop over the dataset multiple times
running_loss =0.0for i, data inenumerate(trainloader,0):
inputs, labels = data
optimizer.zero_grad()
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()if i %2000==1999:# print every 2000 mini-batchesprint('[%d, %5d] loss: %.3f'%(epoch +1, i +1, running_loss /2000))
running_loss =0.0print('Finished Training')"""选取测试数据集"""
dataiter =iter(testloader)
images, labels = dataiter.next()
imshow(torchvision.utils.make_grid(images))print('GraoundTruth: ',' '.join(['%5s'% classes[labels[j]]for j inrange(4)]))"""显示预测值"""
outputs = net(images)
_, predicted = torch.max(outputs,1)print('Predicted: ',' '.join(['%5s'% classes[predicted[j]]for j inrange(4)]))"""
看看网络在整个数据集上的表现
"""
correct =0
total =0with torch.no_grad():for data in testloader:
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs.data,1)
total += labels.size(0)
correct +=(predicted == labels).sum().item()print('Accuracy of the network on the 10000 test images: %d %%'%(100* correct / total))"""
各类的准确率
"""
class_correct =list(0.for i inrange(10))
class_total =list(0.for i inrange(10))with torch.no_grad():for data in testloader:
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs,1)
c =(predicted == labels).squeeze()for i inrange(4):
label = labels[i]
class_correct[label]+= c[i].item()
class_total[label]+=1for i inrange(10):print('Accuracy of %5s : %2d %%'%(
classes[i],100* class_correct[i]/ class_total[i]))