首页 / 深度学习 / Pytorch深度学习实战教程（二）：UNet语义分割网络

Pytorch深度学习实战教程（二）：UNet语义分割网络

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Pytorch深度学习实战教程（二）：UNet语义分割网络，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含11909字，纯文字阅读大概需要18分钟。

内容图文

一、前言

本文属于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跳层链接。
Pytorch深度学习实战教程（二）：UNet语义分割网络 - 文章图片
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的书，类似这种：
Pytorch深度学习实战教程（二）：UNet语义分割网络 - 文章图片
这种摞在一起的操作，就是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模块：
先看下连续两次的卷积操作。

Pytorch深度学习实战教程（二）：UNet语义分割网络 - 文章图片
从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模块
Pytorch深度学习实战教程（二）：UNet语义分割网络 - 文章图片
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模块：
上采样过程用到的最多的当然就是上采样了，除了常规的上采样操作，还有进行特征的融合。
Pytorch深度学习实战教程（二）：UNet语义分割网络 - 文章图片
这块的代码实现起来也稍复杂一些：

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，也就是双线性插值和反卷积
双线性插值很好理解，示意图：
Pytorch深度学习实战教程（二）：UNet语义分割网络 - 文章图片
熟悉双线性插值的朋友对于这幅图应不陌生，简单地讲：已知Q11、Q12、Q21、Q22四个点坐标，通过Q11和Q21求R1，再通过Q12和Q22求R2，最后通过R1和R2求P，这个过程就是双线性插值。
对于一个feature map而言，其实就像是在像素点中间补点，补的点的值是多少，是由相邻像素点的值决定的。
反卷积，顾名思义，就是反着卷积。卷积是让feature map越来越小，反卷积就是让feature map越来越大，示意图：
Pytorch深度学习实战教程（二）：UNet语义分割网络 - 文章图片
下面蓝色为原始图片，周围白色的虚线方块为padding结果，通常为0，上面绿色为卷积后的图片。
这个示意图就是一个从2x2的feature map -> 4x4的feature map过程。
在forward前向传播函数中，x1接收的是上采样的数据，x2接收的是特征融合的数据。特征融合的方法就是，上文提到的，先对小的feature map进行padding，在进行concat。

OutConv模块：
用上述的DoubleConv模块、Down模块、Up模块就可以拼出UNet的主题网络结构。UNet网络的输出需要根据分割数量，整合输出通道，结果如下图所示：
Pytorch深度学习实战教程（二）：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语义分割网络全部内容，希望文章能够帮你解决Pytorch深度学习实战教程（二）：UNet语义分割网络所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/984014.html

来源：【匿名】

【上一篇】基于深度学习的肺炎识别【下一篇】关于Nginx的深度学习内容

更多 ►

【Pytorch深度学习实战教程（二）：UNet语义分割网络】教程文章相关的互联网学习教程文章

有关深度学习框架pytorch

参考http://www.sohu.com/a/164171974_741733 或者https://blog.csdn.net/jxy0123456789/article/details/80630238原文：https://www.cnblogs.com/maxiaonong/p/10654346.html

深度学习框架PyTorch一书的学习-第七章-生成对抗网络(GAN)【代码】【图】

参考：https://github.com/chenyuntc/pytorch-book/tree/v1.0/chapter7-GAN生成动漫头像GAN解决了非监督学习中的著名问题：给定一批样本，训练一个系统能够生成类似的新样本生成对抗网络的网络结构如下图所示：生成器(generator)：输入一个随机噪声，生成一张图片判别器(discriminator):判断输入的图片是真图片还是假图片训练判别器D时，需要利用生成器G生成的假图片和来自现实世界的真图片；训练生成器时，只需要使用噪声生成假图...

一线开发者在Reddit上讨论深度学习框架:PyTorch和TensorFlow到底哪个更好？

本文标签：机器学习TensorFlowGoogle深度学习框架分布式机器学习PyTorch 近日，Reddit 用户 cjmcmurtrie 发了一个主题为「PyTorch vs. TensorFlow」的讨论帖，想要了解这两大流行的框架之间各自有什么优势。原帖地址：https://redd.it/5w3q74 帖子一楼写道：我还没有从 Torch7 迁移到 TensorFlow。我玩过 TensorFlow，但我发现 Torch7 更加直观（也许是我玩得不够？）。我也尝试了一点 PyTorch，所以我决定先看看效果。使用了几周...

MINIST深度学习识别：python全连接神经网络和pytorch LeNet CNN网络训练实现及比较（二）【代码】【图】

版权声明：本文为博主原创文章，欢迎转载，并请注明出处。联系方式：460356155@qq.com在前一篇文章MINIST深度学习识别：python全连接神经网络和pytorch LeNet CNN网络训练实现及比较（一）中，直接用python创建全连接神经网络模型进行深度学习训练，这样可以对神经网络有较为深刻的认识。但是在实际应用中，一般都是采用各种深度学习框架来开展人工智能项目，以下就采用pytorch来实现前一篇文章中的全连接神经网络（784-300-10）。...

深度学习识别CIFAR10：pytorch训练LeNet、AlexNet、VGG19实现及比较（三）【代码】【图】

版权声明：本文为博主原创文章，欢迎转载，并请注明出处。联系方式：460356155@qq.comVGGNet在2014年ImageNet图像分类任务竞赛中有出色的表现。网络结构如下图所示：同样的，对32*32的CIFAR10图片，网络结构做了微调：删除了最后一层最大池化，具体参见网络定义代码，这里采用VGG19，并加入了BN： 1‘‘‘ 2创建VGG块3参数分别为输入通道数，输出通道数，卷积层个数，是否做最大池化4‘‘‘ 5def make_vgg_block(in_channel, out_c...

Keras vs PyTorch，哪一个更适合做深度学习？【图】

Keras vs PyTorch，哪一个更适合做深度学习？　　如何选择工具对深度学习初学者是个难题。本文作者以 Keras 和 Pytorch 库为例，提供了解决该问题的思路。　　当你决定学习深度学习时，有一个问题会一直存在——学习哪种工具？　　深度学习有很多框架和库。这篇文章对两个流行库 Keras 和 Pytorch 进行了对比，因为二者都很容易上手，初学者能够轻松掌握。　　那么到底应该选哪一个呢？本文分享了一个解决思路。　　做出合适选择的...

MINIST深度学习识别：python全连接神经网络和pytorch LeNet CNN网络训练实现及比较（三）【代码】【图】

版权声明：本文为博主原创文章，欢迎转载，并请注明出处。联系方式：460356155@qq.com在前两篇文章MINIST深度学习识别：python全连接神经网络和pytorch LeNet CNN网络训练实现及比较（一）、MINIST深度学习识别：python全连接神经网络和pytorch LeNet CNN网络训练实现及比较（二）中，采用全连接神经网络（784-300-10），分别用非深度学习框架和基于pytorch实现，训练结果相当。这里采用卷积神经网络（CNN）中著名的LeNet-5网络来训...

Ubuntu16.04深度学习基本环境搭建，tensorflow , keras , pytorch , cuda【代码】

Ubuntu16.04深度学习基本环境搭建，tensorflow , keras , pytorch , cudaUbuntu16.04安装参考https://blog.csdn.net/flyyufenfei/article/details/79187656安装nvidia驱动sudo add-apt-repository ppa:graphics-drivers/ppa sudo apt update选择安装驱动 ubuntu-drivers devices查看自己显卡对应的驱动型号，可在nvidia官网查询 sudo apt install nvidia-410通过以下命令查看是否安装成功nvidia-smi 安装cuda,可选方式3种1.直接安装...

保姆级教你从零开始配置win10深度学习环境anaconda+python3+tensorflow+pytorch+cuda+cudnn+pycharm全家桶【代码】【图】

自从开始接触深度学习就踩坑不断，一言不合就要装各种东西，这里记录一下自己的折腾过程，也写一个教材教小白们入坑。#我也是小白#请大家多指教 1、准备工作 1.1 确定自己电脑的显卡配置今天介绍的方法只支持NVIDIA显卡的用户。确定自己显卡型号，到下方网站查询其算力是否大于3.5（https://developer.nvidia.com/cuda-gpus）下面为节选，目前主流的GPU算力基本上都符合标准。1.2 为自己的显卡安装最新的显卡驱动（https://www.nv...

Python深度学习：PyTorch API【代码】【图】

Python深度学习：PyTorch API 1、nn.Module initforward：完成一次前向计算的过程nn.Linear(input的特征数量， output的特征数量) class Lr(nn.Module):'''定义模型'''def __init__(self):super(Lr, self).__init__()self.linear = nn.Linear(1, 1)def forward(self, x):out = self.linear(x)return outmodel = Lr() # 实例化模型 predict = model(x)2、优化器类 optimizer = optim.Ad...

深度学习初探/02-Pytorch知识/03-Tensor索引【代码】【图】

深度学习初探/02-Pytorch知识/03-Tensor索引 1、普通索引方式感觉和C语言中数组索引很像，基本上是按照下标来的。比如现在创建一个CNN的4维输入数据[batch,通道数, height, width]，并对其进行索引，打印一些信息： In: a = torch.rand(6, 3, 28, 28)print(a[0].shape) Out: torch.Size([3, 28, 28])In: print(a[0, 0, 2]) Out:tensor([0.2051, 0.8100, 0.2595, 0.1082, 0.9873, 0.1227, 0.8523, 0.9968, 0.4570,0.4776, 0.9779,...

Ubuntu18.04下安装深度学习框架Pytorch（GPU加速）

前面我们已经在windows10环境下成功安装了CPU版本的Pytorch,推荐的是利用Anaconda安装。经过接近一天的奋战，博主成功在linux系统安装GPU加速的pytorch，博主使用的发行版是Ubuntu18.04。感谢原博主的分享，安装大同小异，原文地址：https://blog.csdn.net/wuzhiwuweisun/article/details/82753403说一下CUDA和CUDNN都是啥吧。 CUDA(Compute Unified Device Architecture)，是英伟达公司推出的一种基于新的并行编程模型和指令集架构...

PyTorch深度学习实践（五）---pytorch实现线性回归【代码】

pytorch写神经网络（1）准备数据集（2）涉及模型（yheight）（3）构造损失函数和优化器（4）训练周期（前馈、反馈、更新） 1 import torch2 3 #1.准备数据4 x_data=torch.tensor([[1.0],[2.0],[3.0]])5 y_data=torch.tensor([[2.0],[4.0],[6.0]])6 #2.构造模型7 class LinearModel(torch.nn.Module):8 def __init__(self):#构造函数9 super(LinearModel,self).__init__() 10 self.linear=torch.nn.Linear(...

【教程分享】Anaconda+Cuda+Cudnn+TensorFlow+Pytorch+Pycharm+Win10深度学习环境配置（GPU + CPU版本）

【教程分享】Anaconda+Cuda+Cudnn+TensorFlow+Pytorch+Pycharm+Win10深度学习环境配置（GPU + CPU版本）【良心教程】Anaconda+Cuda+Cudnn+TensorFlow+Pytorch+Pycharm+Win10深度学习环境配置（GPU + CPU版本）参考视频 https://www.bilibili.com/video/BV1Lv41177BW?share_source=copy_web 视频地址点击这里（原作者不是我，转载自B站，若有不当，请联系我删除!）版权归UP Ternence_hh 所有。话前吐槽和注意事项 csdn的好多讲...

Pytorch深度学习实践第十二讲 RNN 课后2（GRU）【代码】【图】

B站刘二大人传送门循环神经网络（基础篇）课件链接：https://pan.baidu.com/s/1vZ27gKp8Pl-qICn_p2PaSw 提取码：cxe4模型还是将输入“hello”训练输出为“ohlol”，用GRU网络实现。按照计算图实现GRU之后，像前面一样又尝试了加入embedding的方法，效果略有改进。 GRU的网络结构示意图和公式：下面的公式和上面一样，就是写法不同。首先看公式有6个线性层，之后又进行了非线性运算，所以模型定义了6个linear。输入是4维向...

深度学习 - 最热教程

【深度学习】③--神经网络细节与训练注...Ubuntu16安装深度学习环境流程基于tensorflow2.x版本python代码实现深...深度学习笔记（三）—— 反向传播[Back...在NLP中深度学习模型何时需要树形结构？Windows系统基于tensorflow+keras+cuda...深度学习原理与框架-神经网络-cifar10分...使用RTX3080显卡搭建基于Pycharm+Pytho...Java 深度学习实践 DJL中文系列课程深度学习模型里super函数的作用和def _...

首页 / 深度学习 / Pytorch深度学习实战教程（二）：UNet语义分割网络

Pytorch深度学习实战教程（二）：UNet语义分割网络

内容导读

内容图文

一、前言

二、UNet网络结构

1.网络结构原理

2.代码

总结

内容总结

内容备注

内容手机端

【Pytorch深度学习实战教程（二）：UNet语义分割网络】教程文章相关的互联网学习教程文章

深度学习 - 最新教程

深度学习 - 最热教程