论坛 › 深度学习 › Unet网络结构

GTX_AI 发表于 2019-6-21 23:42:35

Unet网络结构

extra_large的Unet网络结构：模型大小：1944756KB，1.85GB
import torch.nn as nn
import torch
from torch import autograd
import torchvision.models as models


# 导入模型结构
#resnet50 = models.resnet50(pretrained=True)
# 加载预先下载好的预训练参数到resnet18
#resnet50.load_state_dict(torch.load('resnet50-5c106cde.pth'))

class DoubleConv(nn.Module):
    def __init__(self, in_ch, out_ch):
      super(DoubleConv, self).__init__()
      self.conv = nn.Sequential(
            nn.Conv2d(in_ch, out_ch, 3, padding=1),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_ch, out_ch, 3, padding=1),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True)
      )

    def forward(self, input):
      return self.conv(input)


class Unet(nn.Module):
    def __init__(self,in_ch,out_ch):
      super(Unet, self).__init__()

      self.conv1 = DoubleConv(in_ch, 16)
      self.pool1 = nn.MaxPool2d(2)
      self.conv2 = DoubleConv(16, 32)
      self.pool2 = nn.MaxPool2d(2)
      self.conv3 = DoubleConv(32, 64)
      self.pool3 = nn.MaxPool2d(2)
      self.conv4 = DoubleConv(64, 128)
      self.pool4 = nn.MaxPool2d(2)
      self.conv5 = DoubleConv(128, 256)
      self.pool5 = nn.MaxPool2d(2)
      self.conv6 = DoubleConv(256, 512)
      self.pool6 = nn.MaxPool2d(2)
      self.conv7 = DoubleConv(512, 1024)
      self.pool7 = nn.MaxPool2d(2)
      self.conv8 = DoubleConv(1024, 2048)
      self.pool8 = nn.MaxPool2d(2)
      self.conv9 = DoubleConv(2048, 4096)
      self.up10 = nn.ConvTranspose2d(4096, 2048, 2, stride=2)
      self.conv10 = DoubleConv(4096, 2048)
      self.up11 = nn.ConvTranspose2d(2048, 1024, 2, stride=2)
      self.conv11 = DoubleConv(2048, 1024)
      self.up12 = nn.ConvTranspose2d(1024, 512, 2, stride=2)
      self.conv12 = DoubleConv(1024, 512)
      self.up13 = nn.ConvTranspose2d(512, 256, 2, stride=2)
      self.conv13 = DoubleConv(512, 256)
      self.up14 = nn.ConvTranspose2d(256, 128, 2, stride=2)
      self.conv14 = DoubleConv(256, 128)
      self.up15 = nn.ConvTranspose2d(128, 64, 2, stride=2)
      self.conv15 = DoubleConv(128, 64)
      self.up16 = nn.ConvTranspose2d(64, 32, 2, stride=2)
      self.conv16 = DoubleConv(64, 32)
      self.up17 = nn.ConvTranspose2d(32, 16, 2, stride=2)
      self.conv17 = DoubleConv(32, 16)
      self.conv18 = nn.Conv2d(16,out_ch, 1)

    def forward(self,x):
      c1=self.conv1(x)
      p1=self.pool1(c1)
      c2=self.conv2(p1)
      p2=self.pool2(c2)
      c3=self.conv3(p2)
      p3=self.pool3(c3)
      c4=self.conv4(p3)
      p4=self.pool4(c4)
      c5=self.conv5(p4)
      p5=self.pool5(c5)
      c6=self.conv6(p5)
      p6=self.pool6(c6)
      c7=self.conv7(p6)
      p7=self.pool7(c7)
      c8=self.conv8(p7)
      p8=self.pool8(c8)
      c9=self.conv9(p8)
      up_10= self.up10(c9)
      merge10 = torch.cat(, dim=1)
      c10=self.conv10(merge10)
      up_11= self.up11(c10)
      merge11 = torch.cat(, dim=1)
      c11=self.conv11(merge11)
      up_12= self.up12(c11)
      merge12 = torch.cat(, dim=1)
      c12=self.conv12(merge12)
      up_13=self.up13(c12)
      merge13 = torch.cat(, dim=1)
      c13=self.conv13(merge13)
      up_14=self.up14(c13)
      merge14 = torch.cat(, dim=1)
      c14=self.conv14(merge14)
      up_15=self.up15(c14)
      merge15 = torch.cat(,dim=1)
      c15=self.conv15(merge15)
      up_16=self.up16(c15)
      merge16 = torch.cat(,dim=1)
      c16=self.conv16(merge16)
      up_17=self.up17(c16)
      merge17 = torch.cat(,dim=1)
      c17=self.conv17(merge17)
      c18=self.conv18(c17)
      out = nn.Sigmoid()(c18)
      return out

GTX_AI 发表于 2019-6-21 23:49:00

large Unet网络1：模型大小：121652KB，118MB
import torch.nn as nn
import torch
from torch import autograd
import torchvision.models as models


# 导入模型结构
#resnet50 = models.resnet50(pretrained=True)
# 加载预先下载好的预训练参数到resnet18
#resnet50.load_state_dict(torch.load('resnet50-5c106cde.pth'))

class DoubleConv(nn.Module):
    def __init__(self, in_ch, out_ch):
      super(DoubleConv, self).__init__()
      self.conv = nn.Sequential(
            nn.Conv2d(in_ch, out_ch, 3, padding=1),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_ch, out_ch, 3, padding=1),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True)
      )

    def forward(self, input):
      return self.conv(input)


class Unet(nn.Module):
    def __init__(self,in_ch,out_ch):
      super(Unet, self).__init__()

      self.conv1 = DoubleConv(in_ch, 16)
      self.pool1 = nn.MaxPool2d(2)
      self.conv2 = DoubleConv(16, 32)
      self.pool2 = nn.MaxPool2d(2)
      self.conv3 = DoubleConv(32, 64)
      self.pool3 = nn.MaxPool2d(2)
      self.conv4 = DoubleConv(64, 128)
      self.pool4 = nn.MaxPool2d(2)
      self.conv5 = DoubleConv(128, 256)
      self.pool5 = nn.MaxPool2d(2)
      self.conv6 = DoubleConv(256, 512)
      self.pool6 = nn.MaxPool2d(2)
      self.conv7 = DoubleConv(512, 1024)
      self.up8 = nn.ConvTranspose2d(1024, 512, 2, stride=2)
      self.conv8 = DoubleConv(1024, 512)
      self.up9 = nn.ConvTranspose2d(512, 256, 2, stride=2)
      self.conv9 = DoubleConv(512, 256)
      self.up10 = nn.ConvTranspose2d(256, 128, 2, stride=2)
      self.conv10 = DoubleConv(256, 128)
      self.up11 = nn.ConvTranspose2d(128, 64, 2, stride=2)
      self.conv11 = DoubleConv(128, 64)
      self.up12 = nn.ConvTranspose2d(64, 32, 2, stride=2)
      self.conv12 = DoubleConv(64, 32)
      self.up13 = nn.ConvTranspose2d(32, 16, 2, stride=2)
      self.conv13 = DoubleConv(32, 16)
      self.conv14 = nn.Conv2d(16,out_ch, 1)

    def forward(self,x):
      c1=self.conv1(x)
      p1=self.pool1(c1)
      c2=self.conv2(p1)
      p2=self.pool2(c2)
      c3=self.conv3(p2)
      p3=self.pool3(c3)
      c4=self.conv4(p3)
      p4=self.pool4(c4)
      c5=self.conv5(p4)
      p5=self.pool5(c5)
      c6=self.conv6(p5)
      p6=self.pool6(c6)
      c7=self.conv7(p6)
      up_8= self.up8(c7)
      merge8 = torch.cat(, dim=1)
      c8=self.conv8(merge8)
      up_9=self.up9(c8)
      merge9 = torch.cat(, dim=1)
      c9=self.conv9(merge9)
      up_10=self.up10(c9)
      merge10 = torch.cat(, dim=1)
      c10=self.conv10(merge10)
      up_11=self.up11(c10)
      merge11=torch.cat(,dim=1)
      c11=self.conv11(merge11)
      up_12=self.up12(c11)
      merge12=torch.cat(,dim=1)
      c12=self.conv12(merge12)
      up_13=self.up13(c12)
      merge13=torch.cat(,dim=1)
      c13=self.conv13(merge13)
      c14=self.conv14(c13)
      out = nn.Sigmoid()(c14)
      return out

GTX_AI 发表于 2019-6-22 09:50:45

large Unet网络2：：模型大小：486257KB，474MB
import torch.nn as nn
import torch
from torch import autograd
import torchvision.models as models


# 导入模型结构
#resnet50 = models.resnet50(pretrained=True)
# 加载预先下载好的预训练参数到resnet18
#resnet50.load_state_dict(torch.load('resnet50-5c106cde.pth'))

class DoubleConv(nn.Module):
    def __init__(self, in_ch, out_ch):
      super(DoubleConv, self).__init__()
      self.conv = nn.Sequential(
            nn.Conv2d(in_ch, out_ch, 3, padding=1),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_ch, out_ch, 3, padding=1),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True)
      )

    def forward(self, input):
      return self.conv(input)


class Unet(nn.Module):
    def __init__(self,in_ch,out_ch):
      super(Unet, self).__init__()

      self.conv1 = DoubleConv(in_ch, 32)
      self.pool1 = nn.MaxPool2d(2)
      self.conv2 = DoubleConv(32, 64)
      self.pool2 = nn.MaxPool2d(2)
      self.conv3 = DoubleConv(64, 128)
      self.pool3 = nn.MaxPool2d(2)
      self.conv4 = DoubleConv(128, 256)
      self.pool4 = nn.MaxPool2d(2)
      self.conv5 = DoubleConv(256, 512)
      self.pool5 = nn.MaxPool2d(2)
      self.conv6 = DoubleConv(512, 1024)
      self.pool6 = nn.MaxPool2d(2)
      self.conv7 = DoubleConv(1024, 2048)
      self.up8 = nn.ConvTranspose2d(2048, 1024, 2, stride=2)
      self.conv8 = DoubleConv(2048, 1024)
      self.up9 = nn.ConvTranspose2d(1024, 512, 2, stride=2)
      self.conv9 = DoubleConv(1024, 512)
      self.up10 = nn.ConvTranspose2d(512, 256, 2, stride=2)
      self.conv10 = DoubleConv(512, 256)
      self.up11 = nn.ConvTranspose2d(256, 128, 2, stride=2)
      self.conv11 = DoubleConv(256, 128)
      self.up12 = nn.ConvTranspose2d(128, 64, 2, stride=2)
      self.conv12 = DoubleConv(128, 64)
      self.up13 = nn.ConvTranspose2d(64, 32, 2, stride=2)
      self.conv13 = DoubleConv(64, 32)
      self.conv14 = nn.Conv2d(32,out_ch, 1)

    def forward(self,x):
      c1=self.conv1(x)
      p1=self.pool1(c1)
      c2=self.conv2(p1)
      p2=self.pool2(c2)
      c3=self.conv3(p2)
      p3=self.pool3(c3)
      c4=self.conv4(p3)
      p4=self.pool4(c4)
      c5=self.conv5(p4)
      p5=self.pool5(c5)
      c6=self.conv6(p5)
      p6=self.pool6(c6)
      c7=self.conv7(p6)
      up_8= self.up8(c7)
      merge8 = torch.cat(, dim=1)
      c8=self.conv8(merge8)
      up_9=self.up9(c8)
      merge9 = torch.cat(, dim=1)
      c9=self.conv9(merge9)
      up_10=self.up10(c9)
      merge10 = torch.cat(, dim=1)
      c10=self.conv10(merge10)
      up_11=self.up11(c10)
      merge11=torch.cat(,dim=1)
      c11=self.conv11(merge11)
      up_12=self.up12(c11)
      merge12=torch.cat(,dim=1)
      c12=self.conv12(merge12)
      up_13=self.up13(c12)
      merge13=torch.cat(,dim=1)
      c13=self.conv13(merge13)
      c14=self.conv14(c13)
      out = nn.Sigmoid()(c14)
      return out

GTX_AI 发表于 2019-6-22 09:58:19

large Unet网络：：模型大小：121329KB，118MB
import torch.nn as nn
import torch
from torch import autograd
import torchvision.models as models


# 导入模型结构
#resnet50 = models.resnet50(pretrained=True)
# 加载预先下载好的预训练参数到resnet18
#resnet50.load_state_dict(torch.load('resnet50-5c106cde.pth'))

class DoubleConv(nn.Module):
    def __init__(self, in_ch, out_ch):
      super(DoubleConv, self).__init__()
      self.conv = nn.Sequential(
            nn.Conv2d(in_ch, out_ch, 3, padding=1),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_ch, out_ch, 3, padding=1),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True)
      )

    def forward(self, input):
      return self.conv(input)


class Unet(nn.Module):
    def __init__(self,in_ch,out_ch):
      super(Unet, self).__init__()

      self.conv1 = DoubleConv(in_ch, 64)
      self.pool1 = nn.MaxPool2d(2)
      self.conv2 = DoubleConv(64, 128)
      self.pool2 = nn.MaxPool2d(2)
      self.conv3 = DoubleConv(128, 256)
      self.pool3 = nn.MaxPool2d(2)
      self.conv4 = DoubleConv(256, 512)
      self.pool4 = nn.MaxPool2d(2)
      self.conv5 = DoubleConv(512, 1024)
      self.up6 = nn.ConvTranspose2d(1024, 512, 2, stride=2)
      self.conv6 = DoubleConv(1024, 512)
      self.up7 = nn.ConvTranspose2d(512, 256, 2, stride=2)
      self.conv7 = DoubleConv(512, 256)
      self.up8 = nn.ConvTranspose2d(256, 128, 2, stride=2)
      self.conv8 = DoubleConv(256, 128)
      self.up9 = nn.ConvTranspose2d(128, 64, 2, stride=2)
      self.conv9 = DoubleConv(128, 64)
      self.conv10 = nn.Conv2d(64,out_ch, 1)

    def forward(self,x):
      c1=self.conv1(x)
      p1=self.pool1(c1)
      c2=self.conv2(p1)
      p2=self.pool2(c2)
      c3=self.conv3(p2)
      p3=self.pool3(c3)
      c4=self.conv4(p3)
      p4=self.pool4(c4)
      c5=self.conv5(p4)
      up_6= self.up6(c5)
      merge6 = torch.cat(, dim=1)
      c6=self.conv6(merge6)
      up_7=self.up7(c6)
      merge7 = torch.cat(, dim=1)
      c7=self.conv7(merge7)
      up_8=self.up8(c7)
      merge8 = torch.cat(, dim=1)
      c8=self.conv8(merge8)
      up_9=self.up9(c8)
      merge9=torch.cat(,dim=1)
      c9=self.conv9(merge9)
      c10=self.conv10(c9)
      out = nn.Sigmoid()(c10)
      return out

GTX_AI 发表于 2019-6-22 11:54:30

normal网络：：模型大小：30126KB，29.4MB
import torch.nn as nn
import torch
from torch import autograd
import torchvision.models as models


# 导入模型结构
#resnet50 = models.resnet50(pretrained=True)
# 加载预先下载好的预训练参数到resnet18
#resnet50.load_state_dict(torch.load('resnet50-5c106cde.pth'))

class DoubleConv(nn.Module):
    def __init__(self, in_ch, out_ch):
      super(DoubleConv, self).__init__()
      self.conv = nn.Sequential(
            nn.Conv2d(in_ch, out_ch, 3, padding=1),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_ch, out_ch, 3, padding=1),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True)
      )

    def forward(self, input):
      return self.conv(input)


class Unet(nn.Module):
    def __init__(self,in_ch,out_ch):
      super(Unet, self).__init__()

      self.conv1 = DoubleConv(in_ch, 64)
      self.pool1 = nn.MaxPool2d(2)
      self.conv2 = DoubleConv(64, 128)
      self.pool2 = nn.MaxPool2d(2)
      self.conv3 = DoubleConv(128, 256)
      self.pool3 = nn.MaxPool2d(2)
      self.conv4 = DoubleConv(256, 512)
      self.up5 = nn.ConvTranspose2d(512, 256, 2, stride=2)
      self.conv5 = DoubleConv(512, 256)
      self.up6 = nn.ConvTranspose2d(256, 128, 2, stride=2)
      self.conv6 = DoubleConv(256, 128)
      self.up7 = nn.ConvTranspose2d(128, 64, 2, stride=2)
      self.conv7 = DoubleConv(128, 64)
      self.conv8 = nn.Conv2d(64,out_ch, 1)

    def forward(self,x):
      c1=self.conv1(x)
      p1=self.pool1(c1)
      c2=self.conv2(p1)
      p2=self.pool2(c2)
      c3=self.conv3(p2)
      p3=self.pool3(c3)
      c4=self.conv4(p3)
      up_5= self.up5(c4)
      merge5 = torch.cat(, dim=1)
      c5=self.conv5(merge5)
      up_6=self.up6(c5)
      merge6 = torch.cat(, dim=1)
      c6=self.conv6(merge6)
      up_7=self.up7(c6)
      merge7 = torch.cat(,dim=1)
      c7=self.conv7(merge7)
      c8=self.conv8(c7)
      out = nn.Sigmoid()(c8)
      return out

GTX_AI 发表于 2019-6-22 11:56:22

normal 网络2：：模型大小：7306KB，7.13MB
import torch.nn as nn
import torch
from torch import autograd
import torchvision.models as models


# 导入模型结构
#resnet50 = models.resnet50(pretrained=True)
# 加载预先下载好的预训练参数到resnet18
#resnet50.load_state_dict(torch.load('resnet50-5c106cde.pth'))

class DoubleConv(nn.Module):
    def __init__(self, in_ch, out_ch):
      super(DoubleConv, self).__init__()
      self.conv = nn.Sequential(
            nn.Conv2d(in_ch, out_ch, 3, padding=1),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_ch, out_ch, 3, padding=1),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True)
      )

    def forward(self, input):
      return self.conv(input)


class Unet(nn.Module):
    def __init__(self,in_ch,out_ch):
      super(Unet, self).__init__()
      # 128x128
      self.conv1 = DoubleConv(in_ch, 64)
      self.pool1 = nn.MaxPool2d(2)
      self.conv2 = DoubleConv(64, 128)
      self.pool2 = nn.MaxPool2d(2)
      self.conv3 = DoubleConv(128, 256)
      self.up4 = nn.ConvTranspose2d(256, 128, 2, stride=2)
      self.conv4 = DoubleConv(256, 128)
      self.up5 = nn.ConvTranspose2d(128, 64, 2, stride=2)
      self.conv5 = DoubleConv(128, 64)
      self.conv6 = nn.Conv2d(64,out_ch, 1)

    def forward(self,x):
      c1=self.conv1(x)
      p1=self.pool1(c1)
      c2=self.conv2(p1)
      p2=self.pool2(c2)
      c3=self.conv3(p2)
      up_4=self.up4(c3)
      merge4 = torch.cat(, dim=1)
      c4=self.conv4(merge4)
      up_5=self.up5(c4)
      merge5 = torch.cat(,dim=1)
      c5=self.conv5(merge5)
      c6=self.conv6(c5)
      out = nn.Sigmoid()(c6)
      return out

GTX_AI 发表于 2019-6-22 11:57:57

normal 网络3：：模型大小：29126KB，28.4MB
import torch.nn as nn
import torch
from torch import autograd
import torchvision.models as models


# 导入模型结构
#resnet50 = models.resnet50(pretrained=True)
# 加载预先下载好的预训练参数到resnet18
#resnet50.load_state_dict(torch.load('resnet50-5c106cde.pth'))

class DoubleConv(nn.Module):
    def __init__(self, in_ch, out_ch):
      super(DoubleConv, self).__init__()
      self.conv = nn.Sequential(
            nn.Conv2d(in_ch, out_ch, 3, padding=1),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_ch, out_ch, 3, padding=1),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True)
      )

    def forward(self, input):
      return self.conv(input)


class Unet(nn.Module):
    def __init__(self,in_ch,out_ch):
      super(Unet, self).__init__()
      # 256x256
      self.conv1 = DoubleConv(in_ch, 128)
      self.pool1 = nn.MaxPool2d(2)
      self.conv2 = DoubleConv(128, 256)
      self.pool2 = nn.MaxPool2d(2)
      self.conv3 = DoubleConv(256, 512)
      self.up4 = nn.ConvTranspose2d(512, 256, 2, stride=2)
      self.conv4 = DoubleConv(512, 256)
      self.up5 = nn.ConvTranspose2d(256, 128, 2, stride=2)
      self.conv5 = DoubleConv(256, 128)
      self.conv6 = nn.Conv2d(128,out_ch, 1)

    def forward(self,x):
      c1=self.conv1(x)
      p1=self.pool1(c1)
      c2=self.conv2(p1)
      p2=self.pool2(c2)
      c3=self.conv3(p2)
      up_4=self.up4(c3)
      merge4 = torch.cat(, dim=1)
      c4=self.conv4(merge4)
      up_5=self.up5(c4)
      merge5 = torch.cat(,dim=1)
      c5=self.conv5(merge5)
      c6=self.conv6(c5)
      out = nn.Sigmoid()(c6)
      return out
   

GTX_AI 发表于 2019-6-22 12:10:57

normal 网络4：：模型大小：120329KB，117MB
# -*- coding: utf-8 -*-
"""
Created on Sat Jun 22 12:05:39 2019

@author: Solem
"""

import torch.nn as nn
import torch
from torch import autograd
import torchvision.models as models


# 导入模型结构
#resnet50 = models.resnet50(pretrained=True)
# 加载预先下载好的预训练参数到resnet18
#resnet50.load_state_dict(torch.load('resnet50-5c106cde.pth'))

class DoubleConv(nn.Module):
    def __init__(self, in_ch, out_ch):
      super(DoubleConv, self).__init__()
      self.conv = nn.Sequential(
            nn.Conv2d(in_ch, out_ch, 3, padding=1),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_ch, out_ch, 3, padding=1),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True)
      )

    def forward(self, input):
      return self.conv(input)


class Unet(nn.Module):
    def __init__(self,in_ch,out_ch):
      super(Unet, self).__init__()

      self.conv1 = DoubleConv(in_ch, 128)
      self.pool1 = nn.MaxPool2d(2)
      self.conv2 = DoubleConv(128, 256)
      self.pool2 = nn.MaxPool2d(2)
      self.conv3 = DoubleConv(256, 512)
      self.pool3 = nn.MaxPool2d(2)
      self.conv4 = DoubleConv(512, 1024)
      self.up5 = nn.ConvTranspose2d(1024, 512, 2, stride=2)
      self.conv5 = DoubleConv(1024, 512)
      self.up6 = nn.ConvTranspose2d(512, 256, 2, stride=2)
      self.conv6 = DoubleConv(512, 256)
      self.up7 = nn.ConvTranspose2d(256, 128, 2, stride=2)
      self.conv7 = DoubleConv(256, 128)
      self.conv8 = nn.Conv2d(128,out_ch, 1)

    def forward(self,x):
      c1=self.conv1(x)
      p1=self.pool1(c1)
      c2=self.conv2(p1)
      p2=self.pool2(c2)
      c3=self.conv3(p2)
      p3=self.pool3(c3)
      c4=self.conv4(p3)
      up_5=self.up5(c4)
      merge5 = torch.cat(, dim=1)
      c5=self.conv5(merge5)
      up_6=self.up6(c5)
      merge6 = torch.cat(, dim=1)
      c6=self.conv6(merge6)
      up_7=self.up7(c6)
      merge7 = torch.cat(,dim=1)
      c7=self.conv7(merge7)
      c8=self.conv8(c7)
      out = nn.Sigmoid()(c8)
      return out

GTX_AI 发表于 2019-6-23 19:21:00

normal 网络5：：模型大小：67176KB，66.1MB
import torch.nn as nn
import torch
from torch import autograd
import torchvision.models as models


# 导入模型结构
#resnet50 = models.resnet50(pretrained=True)
# 加载预先下载好的预训练参数到resnet18
#resnet50.load_state_dict(torch.load('resnet50-5c106cde.pth'))

class DoubleConv(nn.Module):
    def __init__(self, in_ch, out_ch, kernel_size, stride, padding):
      super(DoubleConv, self).__init__()
      self.conv = nn.Sequential(
            nn.Conv2d(in_ch, out_ch, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_ch, out_ch, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True)
      )

    def forward(self, input):
      return self.conv(input)


class Unet(nn.Module):
    def __init__(self,in_ch,out_ch):
      super(Unet, self).__init__()

      self.conv1 = DoubleConv(in_ch, 96,   kernel_size=3, stride=1, padding=1)
      self.pool1 = nn.MaxPool2d(2)
      self.conv2 = DoubleConv(96, 192,       kernel_size=3, stride=1, padding=1)
      self.pool2 = nn.MaxPool2d(2)
      self.conv3 = DoubleConv(192, 384,       kernel_size=3, stride=1, padding=1)
      self.pool3 = nn.MaxPool2d(2)
      self.conv4 = DoubleConv(384, 768,       kernel_size=3, stride=1, padding=1)
      self.up5 = nn.ConvTranspose2d(768, 384, kernel_size=2, stride=2, padding=0)
      self.conv5 = DoubleConv(768, 384,       kernel_size=3, stride=1, padding=1)
      self.up6 = nn.ConvTranspose2d(384, 192, kernel_size=2, stride=2, padding=0)
      self.conv6 = DoubleConv(384, 192,       kernel_size=3, stride=1, padding=1)
      self.up7 = nn.ConvTranspose2d(192, 96, kernel_size=2, stride=2, padding=0)
      self.conv7 = DoubleConv(192, 96,       kernel_size=3, stride=1, padding=1)
      self.conv8 = nn.Conv2d(96, out_ch, 1)

    def forward(self,x):
      c1=self.conv1(x)
      p1=self.pool1(c1)
      c2=self.conv2(p1)
      p2=self.pool2(c2)
      c3=self.conv3(p2)
      p3=self.pool3(c3)
      c4=self.conv4(p3)
      up_5=self.up5(c4)
      merge5 = torch.cat(, dim=1)
      c5=self.conv5(merge5)
      up_6=self.up6(c5)
      merge6 = torch.cat(, dim=1)
      c6=self.conv6(merge6)
      up_7=self.up7(c6)
      merge7 = torch.cat(,dim=1)
      c7=self.conv7(merge7)
      c8=self.conv8(c7)
      out = nn.Sigmoid()(c8)
      return out

GTX_AI 发表于 2019-6-23 22:18:32

small 网络：：模型大小：16400KB，16MB
import torch.nn as nn
import torch
from torch import autograd
import torchvision.models as models


# 导入模型结构
#resnet50 = models.resnet50(pretrained=True)
# 加载预先下载好的预训练参数到resnet18
#resnet50.load_state_dict(torch.load('resnet50-5c106cde.pth'))

class DoubleConv(nn.Module):
    def __init__(self, in_ch, out_ch):
      super(DoubleConv, self).__init__()
      self.conv = nn.Sequential(
            nn.Conv2d(in_ch, out_ch, 3, padding=1),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_ch, out_ch, 3, padding=1),
            nn.BatchNorm2d(out_ch),
            nn.ReLU(inplace=True)
      )

    def forward(self, input):
      return self.conv(input)


class Unet(nn.Module):
    def __init__(self,in_ch,out_ch):
      super(Unet, self).__init__()
      # 256x256
      self.conv1 = DoubleConv(in_ch, 96)
      self.pool1 = nn.MaxPool2d(2)
      self.conv2 = DoubleConv(96, 192)
      self.pool2 = nn.MaxPool2d(2)
      self.conv3 = DoubleConv(192, 384)
      self.up4 = nn.ConvTranspose2d(384, 192, 2, stride=2)
      self.conv4 = DoubleConv(384, 192)
      self.up5 = nn.ConvTranspose2d(192, 96, 2, stride=2)
      self.conv5 = DoubleConv(192, 96)
      self.conv6 = nn.Conv2d(96,out_ch, 1)

    def forward(self,x):
      c1=self.conv1(x)
      p1=self.pool1(c1)
      c2=self.conv2(p1)
      p2=self.pool2(c2)
      c3=self.conv3(p2)
      up_4=self.up4(c3)
      merge4 = torch.cat(, dim=1)
      c4=self.conv4(merge4)
      up_5=self.up5(c4)
      merge5 = torch.cat(,dim=1)
      c5=self.conv5(merge5)
      c6=self.conv6(c5)
      out = nn.Sigmoid()(c6)
      return out

查看完整版本: Unet网络结构