pytorch官网上两个例程
caffe用起来太笨重了，最近转到pytorch，用起来实在不要太方便，上手也非常快，这里贴一下pytorch官网上的两个小例程，掌握一下它的用法：
例程一：利用nn 这个module构建网络，实现一个图像分类的小功能；
链接：http://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html
# -*- coding:utf-8 -*- import torch from torch.autograd import Variable import torchvision import torchvision.transforms as transforms #数据预处理：转换为Tensor，归一化，设置训练集和验证集以及加载子进程数目 transform = transforms.Compose([transforms.ToTensor() , transforms.Normalize((0.5 , 0.5 , 0.5) , (0.5 , 0.5 , 0.5))]) #前面参数是均值，后面是标准差 trainset = torchvision.datasets.CIFAR10(root = './data' , train = True , download = True , transform = transform) trainloader = torch.utils.data.DataLoader(trainset , batch_size = 4 , shuffle = True , num_workers =2) #num_works = 2表示使用两个子进程加载数据 testset = torchvision.datasets.CIFAR10(root = './data' , train = False , download = True , transform = transform) testloader = torch.utils.data.DataLoader(testset , batch_size = 4 , shuffle = True , num_workers = 2) classes = ('plane' , 'car' , 'bird' , 'cat' , 'deer' , 'dog' , 'frog' , 'horse' , 'ship' , 'truck')
import matplotlib.pyplot as plt
import numpy as np
import pylab
def imshow(img):
img = img / 2 + 0.5
npimg = img.numpy()
plt.imshow(np.transpose(npimg , (1 , 2 , 0)))
pylab.show()
dataiter = iter(trainloader)
images , labels = dataiter.next()
for i in range(4):
p = plt.subplot()
p.set_title(“label: %5s” % classes[labels[i]])
imshow(images[i])
#构建网络
from torch.autograd import Variable
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(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)
</span><span style="color: #0000ff;">def</span><span style="color: #000000;"> forward(self , x):
x </span>=<span style="color: #000000;"> self.pool(F.relu(self.conv1(x)))
x </span>=<span style="color: #000000;"> self.pool(F.relu(self.conv2(x)))
x </span>= x.view(-1 , 16 * 5 * 5) <span style="color: #008000;">#</span><span style="color: #008000;">利用view函数使得conv2层输出的16*5*5维的特征图尺寸变为400大小从而方便后面的全连接层的连接</span>
x =<span style="color: #000000;"> F.relu(self.fc1(x))
x </span>=<span style="color: #000000;"> F.relu(self.fc2(x))
x </span>=<span style="color: #000000;"> self.fc3(x)
</span><span style="color: #0000ff;">return</span><span style="color: #000000;"> x
net = Net()
net.cuda()
#define loss function
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters() , lr = 0.001 , momentum = 0.9)
#train the Network
for epoch in range(2):
running_loss = 0.0
for i , data in enumerate(trainloader , 0):
inputs , labels = data
inputs , labels = Variable(inputs.cuda()) , Variable(labels.cuda())
optimizer.zero_grad()
#forward + backward + optimizer
outputs = net(inputs)
loss = criterion(outputs , labels)
loss.backward()
optimizer.step()
running_loss </span>+=<span style="color: #000000;"> loss.data[0]
</span><span style="color: #0000ff;">if</span> i % 2000 == 1999<span style="color: #000000;">:
</span><span style="color: #0000ff;">print</span>(<span style="color: #800000;">'</span><span style="color: #800000;">[%d , %5d] loss: %.3f</span><span style="color: #800000;">'</span> % (epoch + 1 , i + 1 , running_loss / 2000<span style="color: #000000;">))
running_loss </span>= 0.0
print(‘Finished Training’)
dataiter = iter(testloader)
images , labels = dataiter.next()
imshow(torchvision.utils.make_grid(images))
print(‘GroundTruth:’ , ’ '.join(classes[labels[j]] for j in range(4)))
outputs = net(Variable(images.cuda()))
_ , predicted = torch.max(outputs.data , 1)
print(‘Predicted: ’ , ’ ‘.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.cuda()))
_ , predicted = torch.max(outputs.data , 1)
correct += (predicted == labels.cuda()).sum()
total += labels.size(0)
print(‘Accuracy of the network on the 10000 test images: %d %%’ % (100 * correct / total))
class_correct = torch.ones(10).cuda()
class_total = torch.ones(10).cuda()
for data in testloader:
images , labels = data
outputs = net(Variable(images.cuda()))
_ , predicted = torch.max(outputs.data , 1)
c = (predicted == labels.cuda()).squeeze()
#print(predicted.data[0])
for i in range(4):
label = labels[i]
class_correct[label] += c[i]
class_total[label] += 1
for i in range(10):
print(‘Accuracy of %5s : %2d %%’ % (classes[i] , 100 * class_correct[i] / class_total[i]))
例程二：在resnet18的预训练模型上进行finetune，然后实现一个ants和bees的二分类功能：
链接：http://pytorch.org/tutorials/beginner/transfer_learning_tutorial.html
# -*- coding:utf-8 -*- from __future__ import print_function , division import torch import torch.nn as nn import torch.optim as optim from torch.optim import lr_scheduler from torch.autograd import Variable import numpy as np import torchvision from torchvision import datasets , models , transforms import matplotlib.pyplot as plt import time import os import pylab
#data process
data_transforms = {
‘train’ : transforms.Compose([
transforms.RandomSizedCrop(224) ,
transforms.RandomHorizontalFlip() ,
transforms.ToTensor() ,
transforms.Normalize([0.485 , 0.456 , 0.406] , [0.229 , 0.224 , 0.225])
]) ,
‘val’ : transforms.Compose([
transforms.Scale(256) ,
transforms.CenterCrop(224) ,
transforms.ToTensor() ,
transforms.Normalize([0.485 , 0.456 , 0.406] , [0.229 , 0.224 , 0.225])
]) ,
}
data_dir = ‘hymenoptera_data’
image_datasets = {x : datasets.ImageFolder(os.path.join(data_dir , x) , data_transforms[x]) for x in [‘train’ , ‘val’]}
dataloders = {x : torch.utils.data.DataLoader(image_datasets[x] , batch_size = 4 , shuffle = True , num_workers = 4) for x in [‘train’ , ‘val’]}
dataset_sizes = {x : len(image_datasets[x]) for x in [‘train’ , ‘val’]}
class_names = image_datasets[‘train’].classes
print(class_names)
use_gpu = torch.cuda.is_available()
#show several images
def imshow(inp , title = None):
inp = inp.numpy().transpose((1 , 2 , 0))
mean = np.array([0.485 , 0.456 , 0.406])
std = np.array([0.229 , 0.224 , 0.225])
inp = std * inp + mean
inp = np.clip(inp , 0 , 1)
plt.imshow(inp)
if title is not None:
plt.title(title)
pylab.show()
plt.pause(0.001)
inputs , classes = next(iter(dataloders[‘train’]))
out = torchvision.utils.make_grid(inputs)
imshow(out , title = [class_names[x] for x in classes])
#train the model
def train_model(model , criterion , optimizer , scheduler , num_epochs = 25):
since </span>=<span style="color: #000000;"> time.time()
best_model_wts </span>= model.state_dict() <span style="color: #008000;">#</span><span style="color: #008000;">Returns a dictionary containing a whole state of the module.</span>
best_acc = 0.0
<span style="color: #0000ff;">for</span> epoch <span style="color: #0000ff;">in</span><span style="color: #000000;"> range(num_epochs):
</span><span style="color: #0000ff;">print</span>(<span style="color: #800000;">'</span><span style="color: #800000;">Epoch {}/{}</span><span style="color: #800000;">'</span>.format(epoch , num_epochs - 1<span style="color: #000000;">))
</span><span style="color: #0000ff;">print</span>(<span style="color: #800000;">'</span><span style="color: #800000;">-</span><span style="color: #800000;">'</span> * 10<span style="color: #000000;">)
</span><span style="color: #008000;">#</span><span style="color: #008000;">set the mode of model</span>
<span style="color: #0000ff;">for</span> phase <span style="color: #0000ff;">in</span> [<span style="color: #800000;">'</span><span style="color: #800000;">train</span><span style="color: #800000;">'</span> , <span style="color: #800000;">'</span><span style="color: #800000;">val</span><span style="color: #800000;">'</span><span style="color: #000000;">]:
</span><span style="color: #0000ff;">if</span> phase == <span style="color: #800000;">'</span><span style="color: #800000;">train</span><span style="color: #800000;">'</span><span style="color: #000000;">:
scheduler.step() </span><span style="color: #008000;">#</span><span style="color: #008000;">about lr and gamma</span>
model.train(True) <span style="color: #008000;">#</span><span style="color: #008000;">set model to training mode</span>
<span style="color: #0000ff;">else</span><span style="color: #000000;">:
model.train(False) </span><span style="color: #008000;">#</span><span style="color: #008000;">set model to evaluate mode</span>
</span><span style="color: #008000;">#</span><span style="color: #008000;">Iterate over data</span>
<span style="color: #0000ff;">for</span> data <span style="color: #0000ff;">in</span><span style="color: #000000;"> dataloders[phase]:
inputs , labels </span>=<span style="color: #000000;"> data
</span><span style="color: #0000ff;">if</span><span style="color: #000000;"> use_gpu:
inputs </span>=<span style="color: #000000;"> Variable(inputs.cuda())
labels </span>=<span style="color: #000000;"> Variable(labels.cuda())
</span><span style="color: #0000ff;">else</span><span style="color: #000000;">:
inputs </span>=<span style="color: #000000;"> Variable(inputs)
lables </span>=<span style="color: #000000;"> Variable(labels)
optimizer.zero_grad()
</span><span style="color: #008000;">#</span><span style="color: #008000;">forward</span>
outputs =<span style="color: #000000;"> model(inputs)
_ , preds </span>= torch.max(outputs , 1<span style="color: #000000;">)
loss </span>=<span style="color: #000000;"> criterion(outputs , labels)
</span><span style="color: #008000;">#</span><span style="color: #008000;">backward</span>
<span style="color: #0000ff;">if</span> phase == <span style="color: #800000;">'</span><span style="color: #800000;">train</span><span style="color: #800000;">'</span><span style="color: #000000;">:
loss.backward() </span><span style="color: #008000;">#</span><span style="color: #008000;">backward of gradient</span>
optimizer.step() <span style="color: #008000;">#</span><span style="color: #008000;">strategy to drop</span>
running_loss +=<span style="color: #000000;"> loss.data[0]
running_corrects </span>+= torch.sum(preds.data ==<span style="color: #000000;"> labels.data)
epoch_loss </span>= running_loss /<span style="color: #000000;"> dataset_sizes[phase]
epoch_acc </span>= running_corrects /<span style="color: #000000;"> dataset_sizes[phase]
</span><span style="color: #0000ff;">print</span>(<span style="color: #800000;">'</span><span style="color: #800000;">{} Loss: {:.4f} Acc: {:.4f}</span><span style="color: #800000;">'</span><span style="color: #000000;">.format(phase , epoch_loss , epoch_acc))
</span><span style="color: #0000ff;">if</span> phase == <span style="color: #800000;">'</span><span style="color: #800000;">val</span><span style="color: #800000;">'</span> <span style="color: #0000ff;">and</span> epoch_acc ><span style="color: #000000;"> best_acc:
best_acc </span>=<span style="color: #000000;"> epoch_acc
best_model_wts </span>=<span style="color: #000000;"> model.state_dict()
</span><span style="color: #0000ff;">print</span><span style="color: #000000;">()
time_elapsed </span>= time.time() -<span style="color: #000000;"> since
</span><span style="color: #0000ff;">print</span>(<span style="color: #800000;">'</span><span style="color: #800000;">Training complete in {:.0f}m {:.0f}s</span><span style="color: #800000;">'</span>.format(time_elapsed // 60 , time_elapsed % 60<span style="color: #000000;">))
</span><span style="color: #0000ff;">print</span>(<span style="color: #800000;">'</span><span style="color: #800000;">Best val Acc: {:4f}</span><span style="color: #800000;">'</span><span style="color: #000000;">.format(best_acc))
model.load_state_dict(best_model_wts)
</span><span style="color: #0000ff;">return</span><span style="color: #000000;"> model
#visualizing the model predictions
def visualize_model(model , num_images = 6):
images_so_far = 0
fig = plt.figure()
</span><span style="color: #0000ff;">for</span> i , data <span style="color: #0000ff;">in</span> enumerate(dataloders[<span style="color: #800000;">'</span><span style="color: #800000;">val</span><span style="color: #800000;">'</span><span style="color: #000000;">]):
inputs , labels </span>=<span style="color: #000000;"> data
</span><span style="color: #0000ff;">if</span><span style="color: #000000;"> use_gpu:
inputs , labels </span>=<span style="color: #000000;"> Variable(inputs.cuda()) , Variable(labels.cuda())
</span><span style="color: #0000ff;">else</span><span style="color: #000000;">:
inputs , labels </span>=<span style="color: #000000;"> Variable(inputs) , Variable(labels)
outputs </span>=<span style="color: #000000;"> model(inputs)
_ , preds </span>= torch.max(outputs.data , 1<span style="color: #000000;">)
</span><span style="color: #0000ff;">for</span> j <span style="color: #0000ff;">in</span><span style="color: #000000;"> range(inputs.size()[0]):
images_so_far </span>+= 1<span style="color: #000000;">
ax </span>= plt.subplot(num_images // 2 , 2<span style="color: #000000;"> , images_so_far)
ax.axis(</span><span style="color: #800000;">'</span><span style="color: #800000;">off</span><span style="color: #800000;">'</span><span style="color: #000000;">)
ax.set_title(</span><span style="color: #800000;">'</span><span style="color: #800000;">predicted: {}</span><span style="color: #800000;">'</span><span style="color: #000000;">.format(class_names[preds[j]]))
imshow(inputs.cpu().data[j])
</span><span style="color: #0000ff;">if</span> images_so_far ==<span style="color: #000000;"> num_images:
</span><span style="color: #0000ff;">return</span>
#Finetuning the convnet
from torchvision.models.resnet import model_urls
model_urls[‘resnet18’] = model_urls[‘resnet18’].replace(‘https://’ , ‘http://’)
model_ft = models.resnet18(pretrained = True)
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs , 2)
if use_gpu:
model_ft = model_ft.cuda()
criterion = nn.CrossEntropyLoss()
optimizer_ft = optim.SGD(model_ft.parameters() , lr = 0.001 , momentum = 0.9)
exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft , step_size = 7 , gamma = 0.1)
#start finetuning
model_ft = train_model(model_ft , criterion , optimizer_ft , exp_lr_scheduler , num_epochs = 25)
torch.save(model_ft.state_dict() , ‘/home/zf/resnet18.pth’)
visualize_model(model_ft)
当然finetune的话有两种方式：在这个例子里
（1）只修改最后一层全连接层，输出类数改为2，然后在预训练模型上进行finetune；
（2）固定全连接层前面的卷积层参数，也就是它们不反向传播，只对最后一层进行反向传播；实现的时候前面这些层的requires_grad就设为False就OK了；
代码见下：
model_conv = torchvision.models.resnet18(pretrained=True) for param in model_conv.parameters(): param.requires_grad = False
# Parameters of newly constructed modules have requires_grad=True by default
num_ftrs = model_conv.fc.in_features
model_conv.fc = nn.Linear(num_ftrs, 2)
if use_gpu:
model_conv = model_conv.cuda()
criterion = nn.CrossEntropyLoss()
# Observe that only parameters of final layer are being optimized as
# opoosed to before.
optimizer_conv = optim.SGD(model_conv.fc.parameters(), lr=0.001, momentum=0.9)
# Decay LR by a factor of 0.1 every 7 epochs
exp_lr_scheduler = lr_scheduler.StepLR(optimizer_conv, step_size=7, gamma=0.1)
model_conv = train_model(model_conv, criterion, optimizer_conv,
exp_lr_scheduler, num_epochs=25)
可以说，从构建网络，到训练网络，再到测试，由于完全是python风格，实在是太方便了~
</div>
<div class="postDesc">posted @ <span id="post-date">2017-11-06 11:43</span> <a href="https://www.cnblogs.com/zf-blog/">outthinker</a> 阅读(<span id="post_view_count">5526</span>) 评论(<span id="post_comment_count">0</span>) <a href="https://i.cnblogs.com/EditPosts.aspx?postid=7792373" rel="nofollow">编辑</a> <a href="#" onclick="AddToWz(7792373);return false;">收藏</a></div>
</div>