def __init__(self, in_size, out_size):
super(GammaBlock, self).__init__()
self.base_conv = SpectralNorm(nn.Conv2d(in_size, out_size, 1, 1, 0))
self.power_conv = SpectralNorm(nn.Conv2d(in_size, out_size, 1, 1, 0))
# self.coeff_conv = SpectralNorm(nn.Conv2d(in_size, out_size, 1, 1, 0))
self.sigmoid = nn.Sigmoid()
self.avgpoolsig = nn.Sigmoid()
def __init__(self, in_size, out_size):
super(LogBlock, self).__init__()
self.base_conv = SpectralNorm(nn.Conv2d(in_size, out_size, 1, 1, 0))
self.logarithm_conv = SpectralNorm(
nn.Conv2d(in_size, out_size, 1, 1, 0))
# self.coeff_conv = SpectralNorm(nn.Conv2d(in_size, out_size, 1, 1, 0))
self.sigmoid = nn.Sigmoid()
self.avgpoolsig = nn.Sequential(nn.AdaptiveAvgPool2d(1), nn.Sigmoid())
def __init__(self, in_size, out_size, normalize=False):
super(FusionUp, self).__init__()
self.gammablock = GammaBlock(in_size, in_size // 4) # GammaBlock
self.logblock = GammaBlock(in_size, in_size // 4) # LogBlock
self.up_conv = UpBlock(in_size, in_size // 4)
self.up_sample = SpectralNorm(nn.Conv2d(in_size, in_size // 4, 1, 1,
0))
self.fusion_conv = SpectralNorm(nn.Conv2d(in_size, out_size, 3, 1, 1))
def __init__(self, args):
super().__init__()
self.args = args
m_g = args.m_g
ch = args.ndf
self.layer1 = self.make_layer(3, ch // 8)
self.layer2 = self.make_layer(ch // 8, ch // 4)
self.layer3 = self.make_layer(ch // 4, ch // 2)
self.layer4 = SpectralNorm(nn.Conv2d(ch // 2, ch, 3, 1, 1), self.args)
self.linear = SpectralNorm(nn.Linear(ch * m_g * m_g, 1), self.args)
def __init__(self, in_size, out_size):
super(LaplaceBlock, self).__init__()
self.lap1 = nn.Parameter(torch.FloatTensor([[0, -1, 0], [-1, 5, -1],
[0, -1, 0]]).expand(
out_size, out_size, 3,
3),
requires_grad=False)
self.lap2 = nn.Parameter(torch.FloatTensor([[-1, -1, -1], [-1, 9, -1],
[-1, -1, -1]]).expand(
out_size, out_size, 3,
3),
requires_grad=False)
self.lap1_conv = SpectralNorm(nn.Conv2d(in_size, out_size, 3, 1, 1))
self.lap2_conv = SpectralNorm(nn.Conv2d(in_size, out_size, 3, 1, 1))
self.coeff_conv = SpectralNorm(
nn.Conv2d(out_size * 2, out_size, 3, 1, 1))
self.sigmoid = nn.Sigmoid()
def __init__(self, in_size, out_size, normalize=False):
super(DownBlock, self).__init__()
layers = []
layers.append(
SpectralNorm(nn.Conv2d(in_size, out_size, 4, 2, 1, bias=True)))
layers.append(nn.LeakyReLU(0.2, inplace=True))
if normalize:
layers.append(
SpectralNorm(nn.Conv2d(out_size, out_size, 3, 1, 1,
bias=False)))
layers.append(nn.InstanceNorm2d(out_size))
else:
layers.append(
SpectralNorm(nn.Conv2d(out_size, out_size, 3, 1, 1,
bias=True)))
layers.append(nn.LeakyReLU(0.2, inplace=True))
self.model = nn.Sequential(*layers)
def __init__(self, in_dim=3, num_classes=1000):
super(RGBVGG16_FC_BN, self).__init__()
# feature extraction part
# conv1 output size 224 * 224
self.conv1 = nn.Sequential(
SpectralNorm(
nn.Conv2d(in_channels=in_dim,
out_channels=64,
kernel_size=3,
stride=1,
padding=1)), nn.LeakyReLU(0.2, inplace=True),
SpectralNorm(
nn.Conv2d(in_channels=64,
out_channels=64,
kernel_size=3,
stride=1,
padding=1)), nn.BatchNorm2d(64),
nn.LeakyReLU(0.2, inplace=True))
# conv2 output size 112 * 112
self.conv2 = nn.Sequential(
SpectralNorm(
nn.Conv2d(in_channels=64,
out_channels=128,
kernel_size=3,
stride=2,
padding=1)), nn.BatchNorm2d(128),
nn.LeakyReLU(0.2, inplace=True),
SpectralNorm(
nn.Conv2d(in_channels=128,
out_channels=128,
kernel_size=3,
stride=1,
padding=1)), nn.BatchNorm2d(128),
nn.LeakyReLU(0.2, inplace=True))
# conv3 output size 56 * 56
self.conv3 = nn.Sequential(
SpectralNorm(
nn.Conv2d(in_channels=128,
out_channels=256,
kernel_size=3,
stride=2,
padding=1)), nn.BatchNorm2d(256),
nn.LeakyReLU(0.2, inplace=True),
SpectralNorm(
nn.Conv2d(in_channels=256,
out_channels=256,
kernel_size=3,
stride=1,
padding=1)), nn.BatchNorm2d(256),
nn.LeakyReLU(0.2, inplace=True),
SpectralNorm(
nn.Conv2d(in_channels=256,
out_channels=256,
kernel_size=3,
stride=1,
padding=1)), nn.BatchNorm2d(256),
nn.LeakyReLU(0.2, inplace=True))
# conv4 output size 28 * 28
self.conv4 = nn.Sequential(
SpectralNorm(
nn.Conv2d(in_channels=256,
out_channels=512,
kernel_size=3,
stride=2,
padding=1)), nn.BatchNorm2d(512),
nn.LeakyReLU(0.2, inplace=True),
SpectralNorm(
nn.Conv2d(in_channels=512,
out_channels=512,
kernel_size=3,
stride=1,
padding=1)), nn.BatchNorm2d(512),
nn.LeakyReLU(0.2, inplace=True),
SpectralNorm(
nn.Conv2d(in_channels=512,
out_channels=512,
kernel_size=3,
stride=1,
padding=1)), nn.BatchNorm2d(512),
nn.LeakyReLU(0.2, inplace=True))
# conv5 output size 14 * 14
self.conv5 = nn.Sequential(
SpectralNorm(
nn.Conv2d(in_channels=512,
out_channels=512,
kernel_size=3,
stride=2,
padding=1)), nn.BatchNorm2d(512),
nn.LeakyReLU(0.2, inplace=True),
SpectralNorm(
nn.Conv2d(in_channels=512,
out_channels=512,
kernel_size=3,
stride=1,
padding=1)), nn.BatchNorm2d(512),
nn.LeakyReLU(0.2, inplace=True),
SpectralNorm(
nn.Conv2d(in_channels=512,
out_channels=512,
kernel_size=3,
stride=1,
padding=1)), nn.BatchNorm2d(512),
nn.LeakyReLU(0.2, inplace=True))
# conv6 output size 7 * 7
self.conv6 = nn.Sequential(
SpectralNorm(
nn.Conv2d(in_channels=512,
out_channels=512,
kernel_size=3,
stride=2,
padding=1)), nn.LeakyReLU(0.2, inplace=True))
# classification part
self.classifier = nn.Sequential(
nn.Linear(512 * 7 * 7, 4096),
nn.ReLU(inplace=True),
nn.Dropout(),
nn.Linear(4096, 4096),
nn.ReLU(inplace=True),
nn.Dropout(),
nn.Linear(4096, num_classes),
)
def make_layer(self, in_plane, out_plane):
return nn.Sequential(
SpectralNorm(nn.Conv2d(in_plane, out_plane, 3, 1, 1), self.args),
nn.LeakyReLU(0.1),
SpectralNorm(nn.Conv2d(out_plane, out_plane, 4, 2, 1), self.args),
nn.LeakyReLU(0.1))