pytorch学习笔记

学习目标：学会如何应用pytorch；理解深度学习/神经网路的基础

人工智能：1、推理。根据外界信息做出决策。2、预测。例如根据猫的图片和抽象的概念（cat）联系起来。

机器学习：把推理、预测的过程通过算法实现；算法：穷举法，贪心法，分治法，动态规划。从数据集中把想要的算法提取出来（监督学习）

开发学习系统：基于规则的学习，经典的机器学习方法（进行手工特征提取得到特征向量，和输出之间找到映射关系）、表示学习（把高维特征转换为低维特征）

因为使用电脑不方便，略过了很多内容。有机会重拾一下。

本文内容是根据up主刘二大人视频整理。
用CNN网络实现MINIST手写数字识别代码实现：

import torch
import torch.nn as nn
import torch.nn.functional as F
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.optim as optim
#数据处理
batch_size = 64
transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307,),(0.3081,))])
train_dataset = datasets.MNIST('./data',train=True,download=False,transform=transform)
test_dataset = datasets.MNIST('./data',train=False,transform=transform)
train_loader = DataLoader(train_dataset,shuffle=True,batch_size=batch_size,drop_last=True)
test_loader = DataLoader(test_dataset,shuffle=False,batch_size=batch_size,drop_last=True)

#构建模型
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=1,out_channels=10,padding=1,kernel_size=3)
        self.conv2 = nn.Conv2d(in_channels=10,out_channels=20,kernel_size=3)
        self.conv3 = nn.Conv2d(in_channels=20,out_channels=16,kernel_size=3)
        self.pooling = nn.MaxPool2d(kernel_size=2)
        self.layer1 = nn.Linear(64,128)
        self.layer2 = nn.Linear(128,32)
        self.layer3 = nn.Linear(32,10)

    def forward(self,x):
        x = self.pooling(F.relu(self.conv1(x)))
        x = self.pooling(F.relu(self.conv2(x)))
        x = self.pooling(F.relu(self.conv3(x)))
        x = x.view(batch_size,-1)
        x = F.relu(self.layer1(x))
        x = F.relu(self.layer2(x))
        x = self.layer3(x)
        return x
#实例化模型
model = Net()
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
model = model.to(device)
#选择损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(),lr=0.01,momentum=0.5)

#定义训练函数
def train(epoch):
    train_loss = 0.0
    for idx,data in enumerate(train_loader):
        inputs,target = data
        inputs,target = inputs.to(device),target.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs,target)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()
        if idx % 300==299:
            print("[%d,%5d] loss : %.3f"%(epoch+1,idx+1,train_loss/300))
            train_loss = 0.0

def test():
    correct = 0
    total = 0
    with torch.no_grad():#不计算梯度
        for data in test_loader:
            images,labels = data
            images,labels = images.to(device),labels.to(device)
            output = model(images)
            _,predicted = torch.max(output.data,dim=1)
            total += labels.size(0)
            correct += (predicted==labels).sum().item()

        print('Accuracy on test set:%d %%'%(100*correct/total))

if __name__=='__main__':
    for epoch in range(10):
        train(epoch)
        if epoch % 1 ==0:
            test()

注意的问题：卷积层输入通道和输出通道数要对应起来，卷积层的输出连接全连接层时要做flatten，在数据加载时，Datalodaer中的参数drop_last=True

google_net网络中的inception模块代码实现

 

 使用Google_Net网络实现手写数字识别：

#使用google_net实现手写数字识别
import torch
import torch.nn as nn
import torch.nn.functional as F
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.optim as optim
#数据准备
batch_size = 64
transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307,),(0.3081,))])
train_dataset = datasets.MNIST('./data',train=True,download=False,transform=transform)
test_dataset = datasets.MNIST('./data',train=False,transform=transform)
train_loader = DataLoader(train_dataset,shuffle=True,batch_size=batch_size,drop_last=True)
test_loader = DataLoader(test_dataset,shuffle=False,batch_size=batch_size,drop_last=True)

#多了InceptionA类
class InceptionA(nn.Module):
    def __init__(self,in_channels):
        super(InceptionA, self).__init__()
        self.branch1x1 = nn.Conv2d(in_channels=in_channels,out_channels=16,kernel_size=1)

        self.branch5x5_1 = nn.Conv2d(in_channels,16,kernel_size=1)
        self.branch5x5_2 = nn.Conv2d(16,24,kernel_size=5,padding=2)

        self.branch3x3_1 = nn.Conv2d(in_channels,16,kernel_size=1)
        self.branch3x3_2 = nn.Conv2d(16,24,kernel_size=3,padding=1)
        self.branch3x3_3 = nn.Conv2d(24,24,kernel_size=3,padding=1)

        self.branch_pool = nn.Conv2d(in_channels,24,kernel_size=1)

    def forward(self,x):
        branch1x1 = self.branch1x1(x)

        branch5x5 = self.branch5x5_1(x)
        branch5x5 = self.branch5x5_2(branch5x5)

        branch3x3 = self.branch3x3_1(x)
        branch3x3 = self.branch3x3_2(branch3x3)
        branch3x3 = self.branch3x3_3(branch3x3)

        branch_pool = F.avg_pool2d(x,kernel_size=3,stride=1,padding=1)#调用平均池化函数，没用现成的类
        branch_pool = self.branch_pool(branch_pool)
        outputs = [branch1x1,branch5x5,branch3x3,branch_pool]
        #沿着通道方向拼接起来，输出张量为[batch,channel,weight,height]所以dim=1,
        return torch.cat(outputs,dim=1)

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1,10,kernel_size=5)
        self.conv2 = nn.Conv2d(88,20,kernel_size=5)
        #为什么是88，在forward里inception的输出为（24*3+16）
        self.incep1 = InceptionA(in_channels=10)
        self.incep2 = InceptionA(in_channels=20)

        self.mp = nn.MaxPool2d(kernel_size=2)
        #全连接层
        self.fc = nn.Linear(1408,10)
        #这里的1408，可以让模根据全连接层之前的输出得到,forward中使用x.size()

    def forward(self,x):
        in_size = x.size(0)#in_size=batch_size
        x = F.relu(self.mp(self.conv1(x)))
        x = self.incep1(x)
        x = F.relu(self.mp(self.conv2(x)))
        x = self.incep2(x)
        x = x.view(in_size,-1)
        x = self.fc(x)
        #全连接层不用做激活，因为使用nn.CrossEntropyLoss中包含了softmax激活
        #未来可以增加全连接层来提高正确率
        return x

#实例化模型
model = Net()
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
model = model.to(device)
# 选择损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

#使用下面这段代码可以得到卷积层的输出张量，使用时去掉注释符，并把下面的训练代码和测试代码加上注释
# for idx, data in enumerate(train_loader):
#     inputs, target = data
#     inputs, target = inputs.to(device), target.to(device)
#     optimizer.zero_grad()
#     outputs = model(inputs)
#     print(outputs.size())
#     break
    #torch.Size([64, 88, 4, 4])88*4*4=1408


#定义训练函数
def train(epoch):
    train_loss = 0.0
    for idx, data in enumerate(train_loader):
        inputs, target = data
        inputs, target = inputs.to(device), target.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()
        if idx % 300 == 299:
            print("[%d,%5d] loss : %.3f" % (epoch + 1, idx + 1, train_loss / 300))
            train_loss = 0.0


def test():
    correct = 0
    total = 0
    with torch.no_grad():  # 不计算梯度
        for data in test_loader:
            images, labels = data
            images, labels = images.to(device), labels.to(device)
            output = model(images)
            _, predicted = torch.max(output.data, dim=1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()

        print('Accuracy on test set:%d %%' % (100 * correct / total))


if __name__ == '__main__':
    for epoch in range(10):
        train(epoch)
        if epoch % 1 == 0:
            test()

Residual net 残差网络

 

class ResidualBlock(nn.Module):
    def __init__(self,channels):
        super(ResidualBlock, self).__init__()
        self.channels = channels
        self.conv1 = nn.Conv2d(channels,channels,kernel_size=3,padding=1)
        self.conv2 = nn.Conv2d(channels,channels,kernel_size=3,padding=1)

    def forward(self,x):
        y = F.relu(self.conv1(x))
        y = self.conv2(y)
        return F.relu(x+y)

 使用残差网络实现手写数字识别：

import torch
import torch.nn as nn
import torch.nn.functional as F
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.optim as optim
#数据处理
batch_size = 64
transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307,),(0.3081,))])
train_dataset = datasets.MNIST('./data',train=True,download=False,transform=transform)
test_dataset = datasets.MNIST('./data',train=False,transform=transform)
train_loader = DataLoader(train_dataset,shuffle=True,batch_size=batch_size,drop_last=True)
test_loader = DataLoader(test_dataset,shuffle=False,batch_size=batch_size,drop_last=True)

#做残差连接时输入输出的大小和通道数要相同

class ResidualBlock(nn.Module):
    def __init__(self,channels):
        super(ResidualBlock, self).__init__()
        self.channels = channels
        self.conv1 = nn.Conv2d(channels,channels,kernel_size=3,padding=1)
        self.conv2 = nn.Conv2d(channels,channels,kernel_size=3,padding=1)

    def forward(self,x):
        y = F.relu(self.conv1(x))
        y = self.conv2(y)
        return F.relu(x+y)

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1,16,kernel_size=5)
        self.conv2 = nn.Conv2d(16,32,kernel_size=5)
        self.mp = nn.MaxPool2d(kernel_size=2)

        self.rblock1 = ResidualBlock(16)
        self.rblock2 = ResidualBlock(32)

        self.fc = nn.Linear(512,10)

    def forward(self,x):
        in_size = x.size(0)
        x = self.mp(F.relu(self.conv1(x)))
        x = self.rblock1(x)
        x = self.mp(F.relu(self.conv2(x)))
        x = self.rblock2(x)
        x = x.view(in_size,-1)
        x = self.fc(x)
        return x
#实例化模型
model = Net()
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
model = model.to(device)
#选择损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(),lr=0.01,momentum=0.5)
#定义训练函数
def train(epoch):
    train_loss = 0.0
    for idx, data in enumerate(train_loader):
        inputs, target = data
        inputs, target = inputs.to(device), target.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()
        if idx % 300 == 299:
            print("[%d,%5d] loss : %.3f" % (epoch + 1, idx + 1, train_loss / 300))
            train_loss = 0.0


def test():
    correct = 0
    total = 0
    with torch.no_grad():  # 不计算梯度
        for data in test_loader:
            images, labels = data
            images, labels = images.to(device), labels.to(device)
            output = model(images)
            _, predicted = torch.max(output.data, dim=1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()

        print('Accuracy on test set:%d %%' % (100 * correct / total))


if __name__ == '__main__':
    for epoch in range(10):
        train(epoch)
        if epoch % 1 == 0:
            test()

深度学习计划

1、理论学习《深度学习》

2、阅读pytorch文档（通读一遍）

3、复现经典工作（读代码+写代码）