90 lines
3.8 KiB
Python
90 lines
3.8 KiB
Python
import functools
|
|
|
|
import torch
|
|
import torch.nn as nn
|
|
|
|
|
|
# Defines the Unet generator.
|
|
# |num_downs|: number of downsamplings in UNet. For example,
|
|
# if |num_downs| == 7, image of size 128x128 will become of size 1x1
|
|
# at the bottleneck
|
|
class UnetGenerator(nn.Module):
|
|
def __init__(self, input_nc, output_nc, num_downs, ngf=64,
|
|
norm_layer=nn.BatchNorm2d, use_dropout=False):
|
|
super(UnetGenerator, self).__init__()
|
|
|
|
# construct unet structure
|
|
unet_block = UnetSkipConnectionBlock(ngf * 8, ngf * 8, input_nc=None, submodule=None, norm_layer=norm_layer,
|
|
innermost=True)
|
|
for i in range(num_downs - 5):
|
|
unet_block = UnetSkipConnectionBlock(ngf * 8, ngf * 8, input_nc=None, submodule=unet_block,
|
|
norm_layer=norm_layer, use_dropout=use_dropout)
|
|
unet_block = UnetSkipConnectionBlock(ngf * 4, ngf * 8, input_nc=None, submodule=unet_block,
|
|
norm_layer=norm_layer)
|
|
unet_block = UnetSkipConnectionBlock(ngf * 2, ngf * 4, input_nc=None, submodule=unet_block,
|
|
norm_layer=norm_layer)
|
|
unet_block = UnetSkipConnectionBlock(ngf, ngf * 2, input_nc=None, submodule=unet_block, norm_layer=norm_layer)
|
|
unet_block = UnetSkipConnectionBlock(output_nc, ngf, input_nc=input_nc, submodule=unet_block, outermost=True,
|
|
norm_layer=norm_layer)
|
|
|
|
self.model = unet_block
|
|
|
|
def forward(self, input):
|
|
return self.model(input)
|
|
|
|
|
|
# Defines the submodule with skip connection.
|
|
# X -------------------identity---------------------- X
|
|
# |-- downsampling -- |submodule| -- upsampling --|
|
|
class UnetSkipConnectionBlock(nn.Module):
|
|
def __init__(self, outer_nc, inner_nc, input_nc=None,
|
|
submodule=None, outermost=False, innermost=False, norm_layer=nn.BatchNorm2d, use_dropout=False):
|
|
super(UnetSkipConnectionBlock, self).__init__()
|
|
self.outermost = outermost
|
|
if type(norm_layer) == functools.partial:
|
|
use_bias = norm_layer.func == nn.InstanceNorm2d
|
|
else:
|
|
use_bias = norm_layer == nn.InstanceNorm2d
|
|
if input_nc is None:
|
|
input_nc = outer_nc
|
|
downconv = nn.Conv2d(input_nc, inner_nc, kernel_size=4,
|
|
stride=2, padding=1, bias=use_bias)
|
|
downrelu = nn.LeakyReLU(0.2, True)
|
|
downnorm = norm_layer(inner_nc)
|
|
uprelu = nn.ReLU(True)
|
|
upnorm = norm_layer(outer_nc)
|
|
|
|
if outermost:
|
|
upconv = nn.ConvTranspose2d(inner_nc * 2, outer_nc,
|
|
kernel_size=4, stride=2,
|
|
padding=1)
|
|
down = [downconv]
|
|
up = [uprelu, upconv, nn.Tanh()]
|
|
model = down + [submodule] + up
|
|
elif innermost:
|
|
upconv = nn.ConvTranspose2d(inner_nc, outer_nc,
|
|
kernel_size=4, stride=2,
|
|
padding=1, bias=use_bias)
|
|
down = [downrelu, downconv]
|
|
up = [uprelu, upconv, upnorm]
|
|
model = down + up
|
|
else:
|
|
upconv = nn.ConvTranspose2d(inner_nc * 2, outer_nc,
|
|
kernel_size=4, stride=2,
|
|
padding=1, bias=use_bias)
|
|
down = [downrelu, downconv, downnorm]
|
|
up = [uprelu, upconv, upnorm]
|
|
|
|
if use_dropout:
|
|
model = down + [submodule] + up + [nn.Dropout(0.5)]
|
|
else:
|
|
model = down + [submodule] + up
|
|
|
|
self.model = nn.Sequential(*model)
|
|
|
|
def forward(self, x):
|
|
if self.outermost:
|
|
return self.model(x)
|
|
else:
|
|
return torch.cat([x, self.model(x)], 1)
|