精华内容
下载资源
问答
  • PyTorch深度学习实战

    2019-07-22 17:42:39
    资源名称:PyTorch深度学习实战 资源截图: 资源太大,传百度网盘了,链接在附件中,有需要的同学自取。
  • pytorch深度学习实战

    2019-04-18 10:23:22
    本文档是pytorch入门书的全书代码,调试无误,通过代码的运行了解pytorch基本框架,了解深度学习基本原理。
  • Pytorch深度学习实战

    2021-03-03 10:14:04
    pytorch 自动求梯度过程 设置该参数为可微分 ,后续保持跟踪 .requries_grad(ture) 输入特征与模型进行前向计算 调用.backward() 计算梯度 此时梯度保存在.grad属性中
    1. 设置该参数为可微分 ,后续保持跟踪

    .requries_grad(ture)

    1. 输入特征与模型进行前向计算
    2. 调用.backward() 计算梯度
      在这里插入图片描述

    此时梯度保存在.grad属性中
    在这里插入图片描述

    第一步:生成数据

    #%%
    
    x_values = [i for i in range(11)]
    x_train = np.array(x_values, dtype=np.float32)
    x_train = x_train.reshape(-1, 1)
    x_train.shape
    
    #%%
    
    y_values = [2*i + 1 for i in x_values]
    y_train = np.array(y_values, dtype=np.float32)
    y_train = y_train.reshape(-1, 1)
    y_train.shape
    

    在这里插入图片描述
    第二步: 导入模块,构建模型

    #%%
    
    import torch
    import torch.nn as nn
    
    #%% md
    
    ### 线性回归模型
    - 其实线性回归就是一个不加激活函数的全连接层
    
    #%%
    
    class LinearRegressionModel(nn.Module):
        def __init__(self, input_dim, output_dim):
            super(LinearRegressionModel, self).__init__()
            self.linear = nn.Linear(input_dim, output_dim)  
    
        def forward(self, x):
            out = self.linear(x)
            return out
    

    第三步:模型超参数设置

    #%%
    
    input_dim = 1
    output_dim = 1
    
    
    model = LinearRegressionModel(input_dim, output_dim)
    epochs = 1000
    learning_rate = 0.01
    optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
    criterion = nn.MSELoss()
    

    分类任务: 交叉熵损失
    回归任务: MSE 均方差损失

    第四步:训练模型

    for epoch in range(epochs):
        epoch += 1
        # 注意转行成tensor
        inputs = torch.from_numpy(x_train)
        labels = torch.from_numpy(y_train)
    
        # 梯度要清零每一次迭代
        optimizer.zero_grad() 
    
        # 前向传播 
        outputs = model(inputs)
    
        # 计算损失
        loss = criterion(outputs, labels)
    
        # 返向传播
        loss.backward()
    
        # 更新权重参数
        optimizer.step()
        if epoch % 50 == 0:
            print('epoch {}, loss {}'.format(epoch, loss.item()))
    

    第五步: 计算预测结果

    predicted = model(torch.from_numpy(x_train).requires_grad_()).data.numpy()
    predicted
    

    第六步:保存模型

    #%%
    
    torch.save(model.state_dict(), 'model.pkl')
    
    #%%
    
    model.load_state_dict(torch.load('model.pkl'))
    
    

    补充:使用GPU训练模型

    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    model.to(device)
    
    展开全文
  • 千里之行,始于足下。...本文是《PyTorch深度学习实战》系列的第一篇文章,介绍如何在一个纯净的Linux环境(Centos 7)下安装python 3以及PyTorch。 一、Python 3环境 1.1 下载Python 3安装包 下载地址: ...

    千里之行,始于足下。

    本文是《PyTorch深度学习实战》系列的第一篇文章,介绍如何在一个纯净的Linux环境(Centos 7)下安装python 3以及PyTorch。

    一、Python 3环境

    1.1 下载Python 3安装包

    下载地址:
    https://www.python.org/downloads/release

    wget命令获取3.7.5源码:

    wget https://www.python.org/ftp/python/3.7.5/Python-3.7.5.tar.xz
    

    解压缩:

    tar  -xvJf  Python-3.7.5.tar.xz
    

    1.2 安装Python 3

    先装一下基础必须的依赖:

    yum -y groupinstall "Development tools"
    
    
    yum -y install zlib zlib-devel bzip2-devel gcc g++ openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gdbm-devel db4-devel libpcap-devel xz-devel gcc libffi-devel python-devel openssl-devel zlib* vim -y
    

    编译:

    mkdir /usr/local/python3 
    
    cd Python-3.7.5
    
    ./configure --prefix=/usr/local/python3
    
    make && make install
    

    生成软链:

    ln -s /usr/local/python3/bin/python3 /usr/bin/python3 
    ln -s /usr/local/python3/bin/pip3 /usr/bin/pip3
    

    更新pip:

    pip3 install --upgrade pip 
    
    pip3 install --upgrade setuptools
    

    测试:

    [root@node5 Python-3.7.5]# python3 -V
    Python 3.7.5
    

    至此,Python3环境安装成功。

    二、PyTorch环境搭建

    2.1 安装PyTorch

    
    pip3 install torch==1.8.1 torchvision==0.9.1 torchaudio==0.8.1
    
    

    如果镜像拉不下来,配置pip的镜像源:

    mkdir ~/.pip
    cd ~/.pip
    touch pip.conf
    vim pip.conf
    

    写入以下内容:

    [global]
    index-url = http://mirrors.aliyun.com/pypi/simple/
    [install]
    trusted-host=mirrors.aliyun.com
    
    

    2.2 测试

    import torch
    import time
    print(torch.__version__)
    print(torch.cuda.is_available())
    
    a = torch.randn(10000, 1000)
    b = torch.randn(1000,2000)
    
    t0 = time.time()
    c  = torch.matmul(a, b)
    
    t1  = time.time()
    
    print(a.device, t1 - t0, c.norm(2))
    

    运行结果:

    1.8.1+cu102
    False
    cpu 0.41905760765075684 tensor(140310.5156)
    

    至此,PyThon3 和 PyTorch环境搭建完成。

    PS: PyTorch深度学习交流群: 531360538, 欢迎加入!

    展开全文
  • Pytorch深度学习实战教程。包含语义分割基础与环境搭建、UNet语义分割网、UNet模型训练。了解UNet语义分割网、以及用Unet网络对自己的数据训练模型
  • 适合学习pytorch的人,有很多案例
  • 如果不了解语义分割原理以及开发环境的搭建,请看该系列教程的上一篇文章《Pytorch深度学习实战教程(一):语义分割基础与环境搭建》。 本文的开发环境采用上一篇文章搭建好的Windows环境,环境情况如下: 开发环境...

    一、前言

    本文属于Pytorch深度学习语义分割系列教程。

    该系列文章的内容有:

    Pytorch的基本使用
    语义分割算法讲解
    如果不了解语义分割原理以及开发环境的搭建,请看该系列教程的上一篇文章《Pytorch深度学习实战教程(一):语义分割基础与环境搭建》。

    本文的开发环境采用上一篇文章搭建好的Windows环境,环境情况如下:

    开发环境:Windows

    开发语言:Python3.7.4

    框架版本:Pytorch1.3.0

    CUDA:10.2

    cuDNN:7.6.0

    本文主要讲解UNet网络结构,以及相应代码的代码编写。

    二、UNet网络结构

    在语义分割领域,基于深度学习的语义分割算法开山之作是FCN (Fully Convolutional Networks for Semantic Segmentation), 而UNet是遵循FCN的原理,并进行了相应的改进,使其适应小样本的简单分割问题。
    研究一个深度学习算法,可以先看网络结构,看懂网络结构后,再Loss计算方法、训练方法等。本文主要针对UNet的网络结构进行讲解,其他内容会在后续章节进行说明。

    1.网络结构原理

    UNet最早发表在2015的MICCAI会议上,4年多的时间,论文引用量已经达到了9700多次。
    UNet成为了大多做医疗影像语义分割任务的baseline,同时也启发了大量研究者对于U型网络结构的研究,发表了一批基于UNet网络结构的改进方法的论文。
    UNet网络结构,最主要的两个特点是:U型网络结构和Skip Connection跳层链接。
    在这里插入图片描述
    UNet是一个对称的网络结构,左侧为下采样,右侧为上采样。
    按照功能可以将左侧的一系列下采样操作成为encoder, 将右侧的一系列上采样操作成为decoder。
    Skip Connection中间四条灰色的平行线,Skip Connection就是在上采样的过程中,融合下采样过程中的Feature map。
    Skip Connection用到的融合的操作也很简单,就是将feature map的通道进行叠加,俗称Concat。
    Concat操作也很好理解,举个例子:一本大小为10cm10cm,厚度为3cm的书A,和一本大小为10cm10cm,厚度为4cm的书B。
    将书A和书B,边缘对齐地摞在一起。这样就得到了,大小为10cm*10cm, 厚度为7cm的书,类似这种:
    在这里插入图片描述
    这种摞在一起的操作,就是concat。
    同样道理,对于feature map, 一个大小为256x256x64的feature map,即feature map的w(宽)为256,h(高)为256,c(通道数)为64,。和一个大小为256x256x32的feature map进行concat融合,就会得到一个大小为256x256x96的feature map。
    在实际使用中,Concat融合的两个feature map的大小不一定相同,例如256x256x64的feature map和240x240x32的feature map进行concat。
    这时候就有两种办法:
    第一种:将大256x256x64的feature map进行裁剪,裁剪为240x240x64的feature map,比如上下左右,各舍弃8pixel,裁剪后再进行concat,得到240x240x96的feature map。
    第二种:将小240x240x32的feature map进行padding操作,padding为256x256x32的feature map,比如上下左右,各补8pixel,padding后在进行concat,得到256x256x96的feature map。
    UNet采用的concat方案就是第二种,将小的feature map进行padding,padding的方式是补0,一种常规的常量填充。

    2.代码

    我们将整个UNet网络拆分为多个模块进行讲解。
    DoubleConv模块:
    先看下连续两次的卷积操作。

    在这里插入图片描述
    从UNet网络中可以看出,不管是下采样过程还是上采样过程,每一层都会连续进行两次卷积操作,这种操作在UNet网络中重复很多次,可以单独写一个DoubleConv模块:

    import torch.nn as nn
    
    class DoubleConv(nn.Module):
    	“”“(convolution => [BN] => ReLU) * 2”“”
    	def __init__(self, in_channels, out_channels):
    		super().__init__()
    		self.double_conv = nn.Sequential(
    		nn.Conv2d(in_channels, out_channels, kernel_size = 3, padding = 0),
    		nn.BatchNorm2d(out_channels),
    		nn.ReLU(inplace = True),
    		nn.Conv2d(out_channels, out_channels, kernel_size = 3, padding = 0),
    		nn.BatchNorm2d(out_channels),
    		nn.ReLU(inplace = True)
    		)
    	def forward(self, x):
    		return self.double_conv(x)
    		
    

    解释下,上述的pytorch代码,torch.nn.Sequential是一个时序容器,Modules会以它们传入的顺序被添加到容器中。比如上述代码的操作顺序:卷积->BN->ReLU->卷积->BN->ReLU
    DoubleConv模块的in_channels和out_channels可以灵活设定,以便扩展使用。
    如上图所示的网络,in_channels设为1,out_channels设为64。
    输入图片大小为572x572,经过步长为1,padding为0的3x3卷积,得到570x570的feature map,再经过一次卷积得到568x568的feature map。
    计算公式:O= (H-F+2*P)/ S + 1
    H为输入feature map大小,O为输出feature map大小,F为卷积核的大小,P为padding的大小,S为步长。

    Down模块
    在这里插入图片描述
    UNet网络一共有4次下采样过程,模块化代码如下:

    class Down(nn.Module):
    	"""Downscaling with maxpool then double conv"""
    	def __init__(self, in_channels, out_channels):
    		super.__init__():
    		self.maxpool_conv = nn.Sequential(
    			nn.MaxPool2d(2),
    			DoubleConv(in_channels, out_channels)
    		)
    	def forward(self, x):
    		return self.maxpool_conv(x)
    

    这里的代码很简单,就是一个maxpool池化层,进行下采样,然后接一个DoubleConv模块。
    至此,UNet网络的左半部分的下采样过程的代码都写好了,接下来是右半部分的上采样过程。
    Up模块:
    上采样过程用到的最多的当然就是上采样了,除了常规的上采样操作,还有进行特征的融合。
    在这里插入图片描述
    这块的代码实现起来也稍复杂一些:

    class Up(nn.Moudule):
    	"""Upscaling then double conv"""
    	def __init__(self, in_channels, out_channels, bilinear=True):
    		super().__init__()
    		# if bilinear, use the normal convolutions to reduce the number of channels
    		if bilinear:
    			self.up = nn.Upsample(scale_factor = 2, mode='bilinear', align_corner = True)
    		else:
    			self.up = nn.ConvTranspose2d(in_channels, in_channels // 2, kernel_size=2, 				   			  stride=2)
    		self.conv = DoubleConv(in_channels, out_channels)
    
    	def forward(self, x1, x2):
    		x1 = self.up(x1)
    		# input is CHW
    		diffY = torch.tensor([x2.size()[2] - x1.size()[2]])
    		diffX = torch.tensor([x2.size()[3] - x1.size()[3]])
    		
    		x1 = F.pad(x1, [diffX // 2, diffX - diffY // 2])
    		x = torch.cat([x2, x1], dim = 1)
    		
    		return self.conv(x)
    

    代码复杂一些,我们可以分开来看,首先是__init__初始化函数里定义的上采样方法以及卷积采用DoubleConv。上采样,定义了两种方法:Upsample和ConvTranspose2d,也就是双线性插值和反卷积
    双线性插值很好理解,示意图:
    在这里插入图片描述
    熟悉双线性插值的朋友对于这幅图应不陌生,简单地讲:已知Q11、Q12、Q21、Q22四个点坐标,通过Q11和Q21求R1,再通过Q12和Q22求R2,最后通过R1和R2求P,这个过程就是双线性插值。
    对于一个feature map而言,其实就像是在像素点中间补点,补的点的值是多少,是由相邻像素点的值决定的。
    反卷积,顾名思义,就是反着卷积。卷积是让feature map越来越小,反卷积就是让feature map越来越大,示意图:
    在这里插入图片描述
    下面蓝色为原始图片,周围白色的虚线方块为padding结果,通常为0,上面绿色为卷积后的图片。
    这个示意图就是一个从2x2的feature map -> 4x4的feature map过程。
    在forward前向传播函数中,x1接收的是上采样的数据,x2接收的是特征融合的数据。特征融合的方法就是,上文提到的,先对小的feature map进行padding,在进行concat。

    OutConv模块:
    用上述的DoubleConv模块、Down模块、Up模块就可以拼出UNet的主题网络结构。UNet网络的输出需要根据分割数量,整合输出通道,结果如下图所示:
    在这里插入图片描述
    操作很简单,就是channel的变换,上图展示的是分类为2的情况(通道为2)

    虽然这个操作很简单,也就调用一次,为了美观整洁,也封装一下吧。

    class OutConv(nn.Module):
    	def __init__(self, in_channels, out_channels):
    		super(OutConv, self).__init__()
    		self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1)
    	def forward(self, x):
    		return self.conv(x)
    

    至此,UNet网络用到的模块都已经写好,我们可以将上述的模块代码都放到一个unet_part.py文件里,然后再创建unet_model.py,根据UNet网络结构,设置每个模块的输入输出通道个数以及调用顺序,编写如下代码:

    import torch.nn.functional as F
    from unet_parts import *
    class UNet(nn.Module):
    	def __init__(self, n_channels, n_classes, bilinear=False):
    		super(UNet, self).__init__()
    		self.n_channels = n_channels
    		self.n_classes = n_classes
    		self.bilinear = bilinear
    		
    		self.inc = DoubleConv(n_channels, 64)
    		self.down1 = Down(64, 128)
    		self.down2 = Down(128, 256)
    		self.down3 = Down(256, 512)
    		self.down4 = Down(512, 1024)
    		self.up1 = Up(1024, 512, bilinear)
    		self.up2 = Up(512, 256, bilinear)
    		self.up3 = Up(256, 128, bilinear)
    		self.up4 = Up(128, 64, bilinear)
    		self.outc = OutConv(64, n_classes)
    	
    	def forward(self, x):
    		x1 = self.inc(x)
    		x2 = self.down1(x1)
    		x3 = self.down(x2)
    		x4 = self.down(x3)
    		x5 = self.down(x4)
    		x = self.up1(x5, x4)
    		x = self.up2(x, x3)
    		x = self.up3(x, x2)
    		x = self.up4(x, x1)
    		logits = self.outc(x)
    		return logits
    
    if __name__ == '__main__':
    	net = UNet(n_channels=3, n_classes=1)
    	print(net)
    		
    

    使用命令python unet_model.py,如果没有错误,你会得到如下结果:

    17
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    UNet(
      (inc): DoubleConv(
        (double_conv): Sequential(
          (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1))
          (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (2): ReLU(inplace=True)
          (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1))
          (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
          (5): ReLU(inplace=True)
        )
      )
      (down1): Down(
        (maxpool_conv): Sequential(
          (0): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
          (1): DoubleConv(
            (double_conv): Sequential(
              (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1))
              (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
              (2): ReLU(inplace=True)
              (3): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1))
              (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
              (5): ReLU(inplace=True)
            )
          )
        )
      )
      (down2): Down(
        (maxpool_conv): Sequential(
          (0): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
          (1): DoubleConv(
            (double_conv): Sequential(
              (0): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1))
              (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
              (2): ReLU(inplace=True)
              (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
              (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
              (5): ReLU(inplace=True)
            )
          )
        )
      )
      (down3): Down(
        (maxpool_conv): Sequential(
          (0): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
          (1): DoubleConv(
            (double_conv): Sequential(
              (0): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1))
              (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
              (2): ReLU(inplace=True)
              (3): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1))
              (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
              (5): ReLU(inplace=True)
            )
          )
        )
      )
      (down4): Down(
        (maxpool_conv): Sequential(
          (0): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
          (1): DoubleConv(
            (double_conv): Sequential(
              (0): Conv2d(512, 1024, kernel_size=(3, 3), stride=(1, 1))
              (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
              (2): ReLU(inplace=True)
              (3): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1))
              (4): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
              (5): ReLU(inplace=True)
            )
          )
        )
      )
      (up1): Up(
        (up): ConvTranspose2d(1024, 512, kernel_size=(2, 2), stride=(2, 2))
        (conv): DoubleConv(
          (double_conv): Sequential(
            (0): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1))
            (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
            (2): ReLU(inplace=True)
            (3): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1))
            (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
            (5): ReLU(inplace=True)
          )
        )
      )
      (up2): Up(
        (up): ConvTranspose2d(512, 256, kernel_size=(2, 2), stride=(2, 2))
        (conv): DoubleConv(
          (double_conv): Sequential(
            (0): Conv2d(512, 256, kernel_size=(3, 3), stride=(1, 1))
            (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
            (2): ReLU(inplace=True)
            (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1))
            (4): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
            (5): ReLU(inplace=True)
          )
        )
      )
      (up3): Up(
        (up): ConvTranspose2d(256, 128, kernel_size=(2, 2), stride=(2, 2))
        (conv): DoubleConv(
          (double_conv): Sequential(
            (0): Conv2d(256, 128, kernel_size=(3, 3), stride=(1, 1))
            (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
            (2): ReLU(inplace=True)
            (3): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1))
            (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
            (5): ReLU(inplace=True)
          )
        )
      )
      (up4): Up(
        (up): ConvTranspose2d(128, 64, kernel_size=(2, 2), stride=(2, 2))
        (conv): DoubleConv(
          (double_conv): Sequential(
            (0): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1))
            (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
            (2): ReLU(inplace=True)
            (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1))
            (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
            (5): ReLU(inplace=True)
          )
        )
      )
      (outc): OutConv(
        (conv): Conv2d(64, 1, kernel_size=(1, 1), stride=(1, 1))
      )
    )
    

    网络搭建完成,下一步就是使用网络进行训练了。

    总结

    本文主要讲解了UNet网络结构,并对UNet网络进行了模块化梳理。
    下篇文章讲解如何使用UNet网络,编写训练代码。

    展开全文
  • Pytorch深度学习实战教程:UNet模型训练

    千次阅读 多人点赞 2020-04-21 12:22:00
    1前言本文属于 Pytorch 深度学习语义分割系列教程。该系列文章的内容有:Pytorch 的基本使用语义分割算法讲解由于微信不允许外部链接,你需要点击页尾左下角的“阅读原文”,才能访...

    1

    前言

    本文属于 Pytorch 深度学习语义分割系列教程。

    该系列文章的内容有:

    • Pytorch 的基本使用

    • 语义分割算法讲解

    由于微信不允许外部链接,你需要点击页尾左下角的“阅读原文”,才能访问文中的链接,文中的所有外部链接都已使用蓝色字体标记

    2

    项目背景

    深度学习算法,无非就是我们解决一个问题的方法。选择什么样的网络去训练,进行什么样的预处理,采用什么Loss和优化方法,都是根据具体的任务而定的。

    所以,让我们先看一下今天的任务。

    没错,就是 UNet 论文中的经典任务:医学图像分割。

    选择它作为今天的任务,就是因为简单,好上手。

    简单描述一个这个任务:如动图所示,给一张细胞结构图,我们要把每个细胞互相分割开来。

    这个训练数据只有30张,分辨率为512x512,这些图片是果蝇的电镜图。

    好了,任务介绍完毕,开始准备训练模型。

    3

    UNet训练

    想要训练一个深度学习模型,可以简单分为三个步骤:

    • 数据加载:数据怎么加载,标签怎么定义,用什么数据增强方法,都是这一步进行。

    • 模型选择:模型我们已经准备好了,就是该系列上篇文章讲到的 UNet 网络。

    • 算法选择:算法选择也就是我们选什么 loss ,用什么优化算法。

    每个步骤说的比较笼统,我们结合今天的医学图像分割任务,展开说明。

    1、数据加载

    这一步,可以做很多事情,说白了,无非就是图片怎么加载,标签怎么定义,为了增加算法的鲁棒性或者增加数据集,可以做一些数据增强的操作。

    既然是处理数据,那么我们先看下数据都是什么样的,再决定怎么处理。

    数据已经备好,都在这里:(点原文连接了解更多)

    https://github.com/Jack-Cherish/Deep-Learning/tree/master/Pytorch-Seg/lesson-2/data

    数据分为训练集和测试集,各30张,训练集有标签,测试集没有标签。

    数据加载要做哪些处理,是根据任务和数据集而决定的,对于我们的分割任务,不用做太多处理,但由于数据量很少,仅30张,我们可以使用一些数据增强方法,来扩大我们的数据集。

    Pytorch 给我们提供了一个方法,方便我们加载数据,我们可以使用这个框架,去加载我们的数据。看下伪代码:

    # ================================================================== #
    #                Input pipeline for custom dataset                 #
    # ================================================================== #
    
    
    # You should build your custom dataset as below.
    class CustomDataset(torch.utils.data.Dataset):
        def __init__(self):
            # TODO
            # 1. Initialize file paths or a list of file names. 
            pass
        def __getitem__(self, index):
            # TODO
            # 1. Read one data from file (e.g. using numpy.fromfile, PIL.Image.open).
            # 2. Preprocess the data (e.g. torchvision.Transform).
            # 3. Return a data pair (e.g. image and label).
            pass
        def __len__(self):
            # You should change 0 to the total size of your dataset.
            return 0 
    
    
    # You can then use the prebuilt data loader. 
    custom_dataset = CustomDataset()
    train_loader = torch.utils.data.DataLoader(dataset=custom_dataset,
                                               batch_size=64, 
                                               shuffle=True)
    

    这是一个标准的模板,我们就使用这个模板,来加载数据,定义标签,以及进行数据增强。

    创建一个dataset.py文件,编写代码如下:

    import torch
    import cv2
    import os
    import glob
    from torch.utils.data import Dataset
    import random
    
    
    class ISBI_Loader(Dataset):
        def __init__(self, data_path):
            # 初始化函数,读取所有data_path下的图片
            self.data_path = data_path
            self.imgs_path = glob.glob(os.path.join(data_path, 'image/*.png'))
    
    
        def augment(self, image, flipCode):
            # 使用cv2.flip进行数据增强,filpCode为1水平翻转,0垂直翻转,-1水平+垂直翻转
            flip = cv2.flip(image, flipCode)
            return flip
    
    
        def __getitem__(self, index):
            # 根据index读取图片
            image_path = self.imgs_path[index]
            # 根据image_path生成label_path
            label_path = image_path.replace('image', 'label')
            # 读取训练图片和标签图片
            image = cv2.imread(image_path)
            label = cv2.imread(label_path)
            # 将数据转为单通道的图片
            image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
            label = cv2.cvtColor(label, cv2.COLOR_BGR2GRAY)
            image = image.reshape(1, image.shape[0], image.shape[1])
            label = label.reshape(1, label.shape[0], label.shape[1])
            # 处理标签,将像素值为255的改为1
            if label.max() > 1:
                label = label / 255
            # 随机进行数据增强,为2时不做处理
            flipCode = random.choice([-1, 0, 1, 2])
            if flipCode != 2:
                image = self.augment(image, flipCode)
                label = self.augment(label, flipCode)
            return image, label
    
    
        def __len__(self):
            # 返回训练集大小
            return len(self.imgs_path)
    
    
    
    
    if __name__ == "__main__":
        isbi_dataset = ISBI_Loader("data/train/")
        print("数据个数:", len(isbi_dataset))
        train_loader = torch.utils.data.DataLoader(dataset=isbi_dataset,
                                                   batch_size=2, 
                                                   shuffle=True)
        for image, label in train_loader:
            print(image.shape)
    

    运行代码,你可以看到如下结果:

    解释一下代码:

    __init__函数是这个类的初始化函数,根据指定的图片路径,读取所有图片数据,存放到self.imgs_path列表中。

    __len__函数可以返回数据的多少,这个类实例化后,通过len()函数调用。

    __getitem__函数是数据获取函数,在这个函数里你可以写数据怎么读,怎么处理,并且可以一些数据预处理、数据增强都可以在这里进行。我这里的处理很简单,只是将图片读取,并处理成单通道图片。同时,因为 label 的图片像素点是0和255,因此需要除以255,变成0和1。同时,随机进行了数据增强。

    augment函数是定义的数据增强函数,怎么处理都行,我这里只是进行了简单的旋转操作。

    在这个类中,你不用进行一些打乱数据集的操作,也不用管怎么按照 batchsize 读取数据。因为实例化这个类后,我们可以用 torch.utils.data.DataLoader 方法指定 batchsize 的大小,决定是否打乱数据。

    Pytorch 提供给给我们的 DataLoader 很强大,我们甚至可以指定使用多少个进程加载数据,数据是否加载到 CUDA 内存中等高级用法,本文不涉及,就不再展开讲解了。

    2、模型选择

    模型我们已经选择为 UNet 网络结构。

    但是我们需要对网络进行微调,完全按照论文的结构,模型输出的尺寸会稍微小于图片输入的尺寸,如果使用论文的网络结构需要在结果输出后,做一个 resize 操作。为了省去这一步,我们可以修改网络,使网络的输出尺寸正好等于图片的输入尺寸。

    创建unet_parts.py文件,编写如下代码:

    """ Parts of the U-Net model """
    """https://github.com/milesial/Pytorch-UNet/blob/master/unet/unet_parts.py"""
    
    
    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    
    
    class DoubleConv(nn.Module):
        """(convolution => [BN] => ReLU) * 2"""
    
    
        def __init__(self, in_channels, out_channels):
            super().__init__()
            self.double_conv = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1),
                nn.BatchNorm2d(out_channels),
                nn.ReLU(inplace=True),
                nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1),
                nn.BatchNorm2d(out_channels),
                nn.ReLU(inplace=True)
            )
    
    
        def forward(self, x):
            return self.double_conv(x)
    
    
    class Down(nn.Module):
        """Downscaling with maxpool then double conv"""
    
    
        def __init__(self, in_channels, out_channels):
            super().__init__()
            self.maxpool_conv = nn.Sequential(
                nn.MaxPool2d(2),
                DoubleConv(in_channels, out_channels)
            )
    
    
        def forward(self, x):
            return self.maxpool_conv(x)
    
    
    class Up(nn.Module):
        """Upscaling then double conv"""
    
    
        def __init__(self, in_channels, out_channels, bilinear=True):
            super().__init__()
    
    
            # if bilinear, use the normal convolutions to reduce the number of channels
            if bilinear:
                self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)
            else:
                self.up = nn.ConvTranspose2d(in_channels // 2, in_channels // 2, kernel_size=2, stride=2)
    
    
            self.conv = DoubleConv(in_channels, out_channels)
    
    
        def forward(self, x1, x2):
            x1 = self.up(x1)
            # input is CHW
            diffY = torch.tensor([x2.size()[2] - x1.size()[2]])
            diffX = torch.tensor([x2.size()[3] - x1.size()[3]])
    
    
            x1 = F.pad(x1, [diffX // 2, diffX - diffX // 2,
                            diffY // 2, diffY - diffY // 2])
    
    
            x = torch.cat([x2, x1], dim=1)
            return self.conv(x)
    
    
    
    
    class OutConv(nn.Module):
        def __init__(self, in_channels, out_channels):
            super(OutConv, self).__init__()
            self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1)
    
    
        def forward(self, x):
            return self.conv(x)
    

    创建unet_model.py文件,编写如下代码:

    """ Full assembly of the parts to form the complete network """
    """Refer https://github.com/milesial/Pytorch-UNet/blob/master/unet/unet_model.py"""
    
    
    import torch.nn.functional as F
    
    
    from .unet_parts import *
    
    
    class UNet(nn.Module):
        def __init__(self, n_channels, n_classes, bilinear=True):
            super(UNet, self).__init__()
            self.n_channels = n_channels
            self.n_classes = n_classes
            self.bilinear = bilinear
    
    
            self.inc = DoubleConv(n_channels, 64)
            self.down1 = Down(64, 128)
            self.down2 = Down(128, 256)
            self.down3 = Down(256, 512)
            self.down4 = Down(512, 512)
            self.up1 = Up(1024, 256, bilinear)
            self.up2 = Up(512, 128, bilinear)
            self.up3 = Up(256, 64, bilinear)
            self.up4 = Up(128, 64, bilinear)
            self.outc = OutConv(64, n_classes)
    
    
        def forward(self, x):
            x1 = self.inc(x)
            x2 = self.down1(x1)
            x3 = self.down2(x2)
            x4 = self.down3(x3)
            x5 = self.down4(x4)
            x = self.up1(x5, x4)
            x = self.up2(x, x3)
            x = self.up3(x, x2)
            x = self.up4(x, x1)
            logits = self.outc(x)
            return logits
    
    
    if __name__ == '__main__':
        net = UNet(n_channels=3, n_classes=1)
        print(net)
    

    这样调整过后,网络的输出尺寸就与图片的输入尺寸相同了。

    3、算法选择

    选择什么 Loss 很重要,Loss 选择的好坏,都会影响算法拟合数据的效果。

    选择什么 Loss 也是根据任务而决定的。我们今天的任务,只需要分割出细胞边缘,也就是一个很简单的二分类任务,所以我们可以使用 BCEWithLogitsLoss。

    啥是 BCEWithLogitsLoss?BCEWithLogitsLoss 是 Pytorch 提供的用来计算二分类交叉熵的函数。

    它的公式是:

    看过我机器学习系列教程的朋友,对这个公式一定不陌生,它就是 Logistic 回归的损失函数。它利用的是 Sigmoid 函数阈值在[0,1]这个特性来进行分类的。

    目标函数,也就是 Loss 确定好了,怎么去优化这个目标呢?

    最简单的方法就是,我们耳熟能详的梯度下降算法,逐渐逼近局部的极值。

    但是这种简单的优化算法,求解速度慢,也就是想找到最优解,费劲儿。

    各种优化算法,本质上其实都是梯度下降,例如最常规的 SGD,就是基于梯度下降改进的随机梯度下降算法,Momentum 就是引入了动量的 SGD,以指数衰减的形式累计历史梯度。

    除了这些最基本的优化算法,还有自适应参数的优化算法。这类算法最大的特点就是,每个参数有不同的学习率,在整个学习过程中自动适应这些学习率,从而达到更好的收敛效果。

    本文就是选择了一种自适应的优化算法 RMSProp。

    ‍由于篇幅有限,这里就不再扩展,讲解这个优化算法单写一篇都不够,要弄懂 RMSProp,你得先知道什么是 AdaGrad,因为 RMSProp 是基于 AdaGrad 的改进。

    比 RMSProp 更高级的优化算法也有,比如大名顶顶的 Adam,它可以看做是修正后的Momentum+RMSProp 算法。

    总之,对于初学者,你只要知道 RMSProp 是一种自适应的优化算法,比较高级就行了。

    下面,我们就可以开始写训练UNet的代码了,创建 train.py 编写如下代码:

    from model.unet_model import UNet
    from utils.dataset import ISBI_Loader
    from torch import optim
    import torch.nn as nn
    import torch
    
    
    def train_net(net, device, data_path, epochs=40, batch_size=1, lr=0.00001):
        # 加载训练集
        isbi_dataset = ISBI_Loader(data_path)
        train_loader = torch.utils.data.DataLoader(dataset=isbi_dataset,
                                                   batch_size=batch_size, 
                                                   shuffle=True)
        # 定义RMSprop算法
        optimizer = optim.RMSprop(net.parameters(), lr=lr, weight_decay=1e-8, momentum=0.9)
        # 定义Loss算法
        criterion = nn.BCEWithLogitsLoss()
        # best_loss统计,初始化为正无穷
        best_loss = float('inf')
        # 训练epochs次
        for epoch in range(epochs):
            # 训练模式
            net.train()
            # 按照batch_size开始训练
            for image, label in train_loader:
                optimizer.zero_grad()
                # 将数据拷贝到device中
                image = image.to(device=device, dtype=torch.float32)
                label = label.to(device=device, dtype=torch.float32)
                # 使用网络参数,输出预测结果
                pred = net(image)
                # 计算loss
                loss = criterion(pred, label)
                print('Loss/train', loss.item())
                # 保存loss值最小的网络参数
                if loss < best_loss:
                    best_loss = loss
                    torch.save(net.state_dict(), 'best_model.pth')
                # 更新参数
                loss.backward()
                optimizer.step()
    
    
    if __name__ == "__main__":
        # 选择设备,有cuda用cuda,没有就用cpu
        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
        # 加载网络,图片单通道1,分类为1。
        net = UNet(n_channels=1, n_classes=1)
        # 将网络拷贝到deivce中
        net.to(device=device)
        # 指定训练集地址,开始训练
        data_path = "data/train/"
        train_net(net, device, data_path)
    

    为了让工程更加清晰简洁,我们创建一个 model 文件夹,里面放模型相关的代码,也就是我们的网络结构代码,unet_parts.py 和 unet_model.py。

    创建一个 utils 文件夹,里面放工具相关的代码,比如数据加载工具dataset.py。

    这种模块化的管理,大大提高了代码的可维护性。

    train.py 放在工程根目录即可,简单解释下代码。

    由于数据就30张,我们就不分训练集和验证集了,我们保存训练集 loss 值最低的网络参数作为最佳模型参数。

    如果都没有问题,你可以看到 loss 正在逐渐收敛。

    4

    预测

    模型训练好了,我们可以用它在测试集上看下效果。

    在工程根目录创建 predict.py 文件,编写如下代码:

    import glob
    import numpy as np
    import torch
    import os
    import cv2
    from model.unet_model import UNet
    
    
    if __name__ == "__main__":
        # 选择设备,有cuda用cuda,没有就用cpu
        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
        # 加载网络,图片单通道,分类为1。
        net = UNet(n_channels=1, n_classes=1)
        # 将网络拷贝到deivce中
        net.to(device=device)
        # 加载模型参数
        net.load_state_dict(torch.load('best_model.pth', map_location=device))
        # 测试模式
        net.eval()
        # 读取所有图片路径
        tests_path = glob.glob('data/test/*.png')
        # 遍历所有图片
        for test_path in tests_path:
            # 保存结果地址
            save_res_path = test_path.split('.')[0] + '_res.png'
            # 读取图片
            img = cv2.imread(test_path)
            # 转为灰度图
            img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
            # 转为batch为1,通道为1,大小为512*512的数组
            img = img.reshape(1, 1, img.shape[0], img.shape[1])
            # 转为tensor
            img_tensor = torch.from_numpy(img)
            # 将tensor拷贝到device中,只用cpu就是拷贝到cpu中,用cuda就是拷贝到cuda中。
            img_tensor = img_tensor.to(device=device, dtype=torch.float32)
            # 预测
            pred = net(img_tensor)
            # 提取结果
            pred = np.array(pred.data.cpu()[0])[0]
            # 处理结果
            pred[pred >= 0.5] = 255
            pred[pred < 0.5] = 0
            # 保存图片
            cv2.imwrite(save_res_path, pred)
    

    运行完后,你可以在data/test目录下,看到预测结果:

    大功告成!

    5

    最后

    • 本文主要讲解了训练模型的三个步骤:数据加载、模型选择、算法选择。

    • 这是一个简单的例子,训练正常的视觉任务,要复杂很多。比如:在训练模型的时候,需要根据模型在验证集上的准确率选择保存哪个模型;需要支持tensorboard方便我们观察loss收敛情况等等。

    PS:如果觉得本篇本章对您有所帮助,欢迎关注、评论、赞!

    更多精彩内容(请点击图片进行阅读)

    公众号:AI蜗牛车

    保持谦逊、保持自律、保持进步

    个人微信

    备注:昵称+学校/公司+方向

    如果没有备注不拉群!

    拉你进AI蜗牛车交流群

    点个在看,么么哒!
    
    展开全文
  • Pytorch深度学习实战教程:UNet语义分割网络

    千次阅读 多人点赞 2020-01-18 10:11:00
    1前言本文属于Pytorch深度学习语义分割系列教程。该系列文章的内容有:Pytorch的基本使用语义分割算法讲解本文的开发环境如下:开发环境:Windows开发语言:Python3.7...
  • 很久没有碰Pytorch了,准备以实战项目代码回顾的方式进行复习。 2.Pytorch安装 现在我又切回了ubuntu系统,里面没有Pytorch,所以顺便从Pytorch最新版安装开始讲起吧。 (1)本机配置 CUDA9.0, CUDNN7.1.2 Anaconda...
  • import torch import numpy # 创建tensor torch_data = torch.Tensor([1,-2,3]) # Torch-->array np_data = torch_data.numpy() # array --> Torch ...torch_data = torch.from_numpy(np_data)
  • 2、模型选择 模型我们已经选择完了,就用上篇文章《Pytorch深度学习实战教程(二):UNet语义分割网络》讲解的 UNet 网络结构。 但是我们需要对网络进行微调,完全按照论文的结构,模型输出的尺寸会稍微小于图片...
  • 看了一下刘二大人保姆级Pytorch教程,就先写个笔记记录一下,感兴趣的客官可以去B站看一下哦 教程地址:https://www.bilibili.com/video/BV1Y7411d7Ys?p=8 首先,区分一下Batch、Epoch和Iteration三个概念 Epoch...
  • Pytorch 深度学习实战教程(二):UNet语义分割网络

    千次阅读 多人点赞 2020-05-23 11:00:16
    该系列文章的内容有: Pytorch的基本使用 语义分割算法讲解 如果不了解语义分割原理以及开发环境的搭建,请看该系列教程的上一篇文章《Pytorch深度学习实战教程(一):语义分割基础与环境搭建》。 本文的开发环境...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,429
精华内容 2,971
关键字:

pytorch深度学习实战