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)
 
    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)  #利用view函数使得conv2层输出的16*5*5维的特征图尺寸变为400大小从而方便后面的全连接层的连接
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return 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 += 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()
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 = time.time()
    best_model_wts = model.state_dict()  #Returns a dictionary containing a whole state of the module.
    best_acc = 0.0
 
    for epoch in range(num_epochs):
        print('Epoch {}/{}'.format(epoch , num_epochs - 1))
        print('-' * 10)
        #set the mode of model
        for phase in ['train' , 'val']:
            if phase == 'train':
                scheduler.step()  #about lr and gamma
                model.train(True)  #set model to training mode
            else:
                model.train(False)  #set model to evaluate mode
 
            running_loss = 0.0
            running_corrects = 0
 
            #Iterate over data
            for data in dataloders[phase]:
                inputs , labels = data
                if use_gpu:
                    inputs = Variable(inputs.cuda())
                    labels = Variable(labels.cuda())
                else:
                    inputs = Variable(inputs)
                    lables = Variable(labels)
                optimizer.zero_grad()
                #forward
                outputs = model(inputs)
                _ , preds = torch.max(outputs , 1)
                loss = criterion(outputs , labels)
                #backward
                if phase == 'train':
                    loss.backward()  #backward of gradient
                    optimizer.step()  #strategy to drop
                running_loss += loss.data[0]
                running_corrects += torch.sum(preds.data == labels.data)
 
            epoch_loss = running_loss / dataset_sizes[phase]
            epoch_acc = running_corrects / dataset_sizes[phase]
            print('{} Loss: {:.4f} Acc: {:.4f}'.format(phase , epoch_loss , epoch_acc))
 
            if phase == 'val' and epoch_acc > best_acc:
                best_acc = epoch_acc
                best_model_wts = model.state_dict()
        print()
 
    time_elapsed = time.time() - since
    print('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed // 60 , time_elapsed % 60))
    print('Best val Acc: {:4f}'.format(best_acc))
    model.load_state_dict(best_model_wts)
    return model
 
#visualizing the model predictions
def visualize_model(model , num_images = 6):
    images_so_far = 0
    fig = plt.figure()
 
    for i , data in enumerate(dataloders['val']):
        inputs , labels = data
        if use_gpu:
            inputs , labels = Variable(inputs.cuda()) , Variable(labels.cuda())
        else:
            inputs , labels = Variable(inputs) , Variable(labels)
 
        outputs = model(inputs)
        _ , preds = torch.max(outputs.data , 1)
        for j in range(inputs.size()[0]):
            images_so_far += 1
            ax = plt.subplot(num_images // 2 , 2 , images_so_far)
            ax.axis('off')
            ax.set_title('predicted: {}'.format(class_names[preds[j]]))
            imshow(inputs.cpu().data[j])
 
            if images_so_far == num_images:
                return
 
#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风格，实在是太方便了~