SunlitDeadline's picture
commited from namirahrasul/DSRNet -main local
b9e72b4 verified
Raw History Blame
9.47 kB
import functools
import numpy as np
import torch
import torch.nn as nn
from torch.nn import init
###############################################################################
# Functions
###############################################################################
def weights_init_normal(m):
classname = m.__class__.__name__
# print(classname)
if isinstance(m, nn.Sequential):
return
if isinstance(m, (nn.Conv2d, nn.ConvTranspose2d)):
init.normal_(m.weight.data, 0.0, 0.02)
elif isinstance(m, nn.Linear):
init.normal_(m.weight.data, 0.0, 0.02)
elif isinstance(m, nn.BatchNorm2d):
init.normal_(m.weight.data, 1.0, 0.02)
init.constant_(m.bias.data, 0.0)
def weights_init_xavier(m):
classname = m.__class__.__name__
# print(classname)
if isinstance(m, (nn.Conv2d, nn.ConvTranspose2d)):
init.xavier_normal_(m.weight.data, gain=0.02)
elif isinstance(m, nn.Linear):
init.xavier_normal_(m.weight.data, gain=0.02)
elif isinstance(m, nn.BatchNorm2d):
init.normal_(m.weight.data, 1.0, 0.02)
init.constant_(m.bias.data, 0.0)
def weights_init_kaiming(m):
classname = m.__class__.__name__
# print(classname)
if isinstance(m, (nn.Conv2d, nn.ConvTranspose2d)):
init.kaiming_normal_(m.weight.data, a=0, mode='fan_in')
elif isinstance(m, nn.Linear):
init.kaiming_normal_(m.weight.data, a=0, mode='fan_in')
elif isinstance(m, nn.BatchNorm2d):
init.normal_(m.weight.data, 1.0, 0.02)
init.constant_(m.bias.data, 0.0)
def weights_init_orthogonal(m):
classname = m.__class__.__name__
print(classname)
if isinstance(m, (nn.Conv2d, nn.ConvTranspose2d)):
init.orthogonal(m.weight.data, gain=1)
elif isinstance(m, nn.Linear):
init.orthogonal(m.weight.data, gain=1)
elif isinstance(m, nn.BatchNorm2d):
init.normal(m.weight.data, 1.0, 0.02)
init.constant_(m.bias.data, 0.0)
def init_weights(net, init_type='normal'):
print('[i] initialization method [%s]' % init_type)
if init_type == 'normal':
net.apply(weights_init_normal)
elif init_type == 'xavier':
net.apply(weights_init_xavier)
elif init_type == 'kaiming':
net.apply(weights_init_kaiming)
elif init_type == 'orthogonal':
net.apply(weights_init_orthogonal)
elif init_type == 'edsr':
pass
else:
raise NotImplementedError('initialization method [%s] is not implemented' % init_type)
def get_norm_layer(norm_type='instance'):
if norm_type == 'batch':
norm_layer = functools.partial(nn.BatchNorm2d, affine=True)
elif norm_type == 'instance':
norm_layer = functools.partial(nn.InstanceNorm2d, affine=False)
elif norm_type == 'none':
norm_layer = None
else:
raise NotImplementedError('normalization layer [%s] is not found' % norm_type)
return norm_layer
def define_D(opt, in_channels=3):
# use_sigmoid = opt.gan_type == 'gan'
use_sigmoid = False # incorporate sigmoid into BCE_stable loss
if opt.which_model_D == 'disc_vgg':
netD = Discriminator_VGG(in_channels, use_sigmoid=use_sigmoid)
init_weights(netD, init_type='kaiming')
elif opt.which_model_D == 'disc_patch':
netD = NLayerDiscriminator(in_channels, 64, 3, nn.InstanceNorm2d, use_sigmoid, getIntermFeat=False)
init_weights(netD, init_type='normal')
else:
raise NotImplementedError('%s is not implemented' % opt.which_model_D)
if len(opt.gpu_ids) > 0:
assert (torch.cuda.is_available())
netD.cuda(opt.gpu_ids[0])
return netD
def print_network(net):
num_params = 0
for param in net.parameters():
num_params += param.numel()
# print(net)
print('Network Architecture: ', type(net).__name__)
print('Total number of parameters: %d,%.3fMb' % (num_params, num_params / (1024 * 1024)))
print('The size of receptive field: %d' % receptive_field(net))
def receptive_field(net):
def _f(output_size, ksize, stride, dilation):
return (output_size - 1) * stride + ksize * dilation - dilation + 1
stats = []
# print(list(net.modules()))
for m in net.modules():
if isinstance(m, nn.Conv2d):
stats.append((m, m.kernel_size, m.stride, m.dilation))
rsize = 1
for (name, ksize, stride, dilation) in reversed(stats):
if type(ksize) == tuple: ksize = ksize[0]
if type(stride) == tuple: stride = stride[0]
if type(dilation) == tuple: dilation = dilation[0]
rsize = _f(rsize, ksize, stride, dilation)
return rsize
def debug_network(net):
def _hook(m, i, o):
print(o.size())
for m in net.modules():
m.register_forward_hook(_hook)
##############################################################################
# Classes
##############################################################################
# Defines the PatchGAN discriminator with the specified arguments.
class NLayerDiscriminator(nn.Module):
def __init__(self, input_nc, ndf=64, n_layers=3,
norm_layer=nn.BatchNorm2d, use_sigmoid=False,
branch=1, bias=True, getIntermFeat=False):
super(NLayerDiscriminator, self).__init__()
self.getIntermFeat = getIntermFeat
self.n_layers = n_layers
kw = 4
padw = int(np.ceil((kw - 1.0) / 2))
sequence = [[nn.Conv2d(input_nc * branch, ndf * branch, kernel_size=kw, stride=2, padding=padw, groups=branch,
bias=True), nn.LeakyReLU(0.2, True)]]
nf = ndf
for n in range(1, n_layers):
nf_prev = nf
nf = min(nf * 2, 512)
sequence += [[
nn.Conv2d(nf_prev * branch, nf * branch, groups=branch, kernel_size=kw, stride=2, padding=padw,
bias=bias),
norm_layer(nf * branch), nn.LeakyReLU(0.2, True)
]]
nf_prev = nf
nf = min(nf * 2, 512)
sequence += [[
nn.Conv2d(nf_prev * branch, nf * branch, groups=branch, kernel_size=kw, stride=1, padding=padw, bias=bias),
norm_layer(nf * branch),
nn.LeakyReLU(0.2, True)
]]
sequence += [
[nn.Conv2d(nf * branch, 1 * branch, groups=branch, kernel_size=kw, stride=1, padding=padw, bias=True)]]
if use_sigmoid:
sequence += [[nn.Sigmoid()]]
if getIntermFeat:
for n in range(len(sequence)):
setattr(self, 'model' + str(n), nn.Sequential(*sequence[n]))
else:
sequence_stream = []
for n in range(len(sequence)):
sequence_stream += sequence[n]
self.model = nn.Sequential(*sequence_stream)
def forward(self, input):
if self.getIntermFeat:
res = [input]
for n in range(self.n_layers + 2):
model = getattr(self, 'model' + str(n))
res.append(model(res[-1]))
return res[1:]
else:
return self.model(input)
class Discriminator_VGG(nn.Module):
def __init__(self, in_channels=3, use_sigmoid=True):
super(Discriminator_VGG, self).__init__()
def conv(*args, **kwargs):
return nn.Conv2d(*args, **kwargs)
num_groups = 32
body = [
conv(in_channels, 64, kernel_size=3, padding=1), # 224
nn.LeakyReLU(0.2),
conv(64, 64, kernel_size=3, stride=2, padding=1), # 112
nn.GroupNorm(num_groups, 64),
nn.LeakyReLU(0.2),
conv(64, 128, kernel_size=3, padding=1),
nn.GroupNorm(num_groups, 128),
nn.LeakyReLU(0.2),
conv(128, 128, kernel_size=3, stride=2, padding=1), # 56
nn.GroupNorm(num_groups, 128),
nn.LeakyReLU(0.2),
conv(128, 256, kernel_size=3, padding=1),
nn.GroupNorm(num_groups, 256),
nn.LeakyReLU(0.2),
conv(256, 256, kernel_size=3, stride=2, padding=1), # 28
nn.GroupNorm(num_groups, 256),
nn.LeakyReLU(0.2),
conv(256, 512, kernel_size=3, padding=1),
nn.GroupNorm(num_groups, 512),
nn.LeakyReLU(0.2),
conv(512, 512, kernel_size=3, stride=2, padding=1), # 14
nn.GroupNorm(num_groups, 512),
nn.LeakyReLU(0.2),
conv(512, 512, kernel_size=3, stride=1, padding=1),
nn.GroupNorm(num_groups, 512),
nn.LeakyReLU(0.2),
conv(512, 512, kernel_size=3, stride=2, padding=1), # 7
nn.GroupNorm(num_groups, 512),
nn.LeakyReLU(0.2),
]
tail = [
nn.AdaptiveAvgPool2d(1),
nn.Conv2d(512, 1024, kernel_size=1),
nn.LeakyReLU(0.2),
nn.Conv2d(1024, 1, kernel_size=1)
]
if use_sigmoid:
tail.append(nn.Sigmoid())
self.body = nn.Sequential(*body)
self.tail = nn.Sequential(*tail)
def forward(self, x):
x = self.body(x)
out = self.tail(x)
return out