pytorch官网上两个例程

最新推荐文章于 2022-10-18 09:50:10 发布

贝猫说python

最新推荐文章于 2022-10-18 09:50:10 发布

阅读量586

点赞数 1

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>

running_loss = 0.0 running_corrects = 0

        </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 &gt;<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风格，实在是太方便了~

分类: pytorch

好文要顶关注我收藏该文

outthinker
关注 - 9
粉丝 - 95

+加关注

« 上一篇： ORB feature(O for orientation)
» 下一篇：图像卷积

	</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>