def __init__(self, nc, ndf, include_sigmoid):
super(_netD4, self).__init__()
self.main = nn.Sequential(
# input is (nc) x 64 x 64
SNConv2d(nc, ndf, 4, 2, 1, bias=False),
nn.LeakyReLU(0.2, inplace=True),
# state size. (ndf) x 32 x 32
SNConv2d(ndf, ndf * 2, 4, 2, 1, bias=False),
nn.BatchNorm2d(ndf * 2),
nn.LeakyReLU(0.2, inplace=True),
# state size. (ndf*2) x 16 x 16
SNConv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),
nn.BatchNorm2d(ndf * 4),
nn.LeakyReLU(0.2, inplace=True),
SNConv2d(ndf * 4, ndf * 16, 4, 2, 1, bias=False),
nn.BatchNorm2d(ndf * 16),
nn.LeakyReLU(0.2, inplace=True),
# state size. (ndf*16) x 4 x 4
SNConv2d(ndf * 16, 1, 4, 1, 0, bias=False),
#nn.Sigmoid()
)
self.sigmoid = nn.Sigmoid()
self.extra_layers_to_run = []
if include_sigmoid:
self.extra_layers_to_run.append(self.sigmoid)
def __init__(self, nc, ndf, num_classes):
super(_netC, self).__init__()
self.main = nn.Sequential(
# input is (nc) x 64 x 64
SNConv2d(nc, ndf, 4, 2, 1, bias=False),
nn.LeakyReLU(0.2, inplace=True),
# state size. (ndf) x 32 x 32
SNConv2d(ndf, ndf * 2, 4, 2, 1, bias=False),
nn.BatchNorm2d(ndf * 2),
nn.LeakyReLU(0.2, inplace=True),
# state size. (ndf*2) x 16 x 16
SNConv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False),
nn.BatchNorm2d(ndf * 4),
nn.LeakyReLU(0.2, inplace=True),
SNConv2d(ndf * 4, ndf * 16, 4, 2, 1, bias=False),
nn.BatchNorm2d(ndf * 16),
nn.LeakyReLU(0.2, inplace=True),
SNConv2d(ndf * 16, ndf * 64, 4, 1, 0, bias=False),
# state size. (ndf*16) x 4 x 4
#SNConv2d(ndf * 16, 1, 4, 1, 0, bias=False),
#nn.Sigmoid()
)
self.linear = nn.Linear(1024*4, num_classes)
self.softmax = nn.Softmax()
self.sigmoid = nn.Sigmoid()
def __init__(self, nc, ndf, include_sigmoid):
super(_netD6, self).__init__()
# Upsampling
self.down = nn.Sequential(
SNConv2d(3, 64, 3, 2, 1),
nn.ReLU(),
)
# Fully-connected layers
self.down_size = (64 // 2)
down_dim = 64 * (64 // 2)**2
self.fc = nn.Sequential(
nn.Linear(down_dim, 32),
nn.BatchNorm1d(32, 0.8),
nn.ReLU(inplace=True),
nn.Linear(32, down_dim),
nn.BatchNorm1d(down_dim),
nn.ReLU(inplace=True)
)
# Upsampling
self.up = nn.Sequential(
nn.Upsample(scale_factor=2),
SNConv2d(64, 3, 3, 1, 1)
)
self.final = nn.Sequential(
nn.MaxPool3d([3, 64, 64]),
#nn.Sigmoid()
)
self.sigmoid = nn.Sigmoid()
self.extra_layers_to_run = []
if include_sigmoid:
self.extra_layers_to_run.append(self.sigmoid)
def __init__(self, nc, ndf, ncontext, ndiscriminators):
super(_netE, self).__init__()
self.main = nn.Sequential(
# input is (nc * ncontext) x 32 x 32 TODO add ncontext
#nn.Linear(32, ndiscriminators, bias=False),
SNConv2d(nc, ndf, 7, 4, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
SNConv2d(ndf, 3, 7, 4, 1, bias=False),
nn.Sigmoid())
def make_res_block(self, in_channels, out_channels):
model = []
model += [
SNConv2d(in_channels, out_channels, kernel_size=3, padding=1)
]
model += [nn.ReLU()]
model += [
SNConv2d(out_channels, out_channels, kernel_size=3, padding=1)
]
model += [nn.AvgPool2d(2)]
return nn.Sequential(*model)
def __init__(self, nc, ndf):
super(_netD2, self).__init__()
self.main = nn.Sequential(
SNConv2d(nc, ndf, 3, 4, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
SNConv2d(ndf, ndf, 5, 2, 1, bias=False),
nn.LeakyReLU(0.1, inplace=True),
SNConv2d(ndf, 1, 3, 2, 0, bias=False),
nn.Sigmoid()
)
def __init__(self, nc, ndf):
super(_netD1, self).__init__()
self.main = nn.Sequential(SNConv2d(nc, ndf, 5, 2, 2),
nn.LeakyReLU(0.2, inplace=True),
SNConv2d(ndf, ndf * 2, 5, 2, 2),
nn.LeakyReLU(0.2, inplace=True),
SNConv2d(ndf * 2, ndf * 4, 5, 2, 2),
nn.LeakyReLU(0.2, inplace=True),
SNConv2d(ndf * 4, ndf * 8, 5, 2, 2),
nn.LeakyReLU(0.2, inplace=True),
SNConv2d(ndf * 8, 1, 4), nn.Sigmoid())
def __init__(self, nc, ndf):
super(_netD3, self).__init__()
self.main = nn.Sequential(
# input is (nc) x 32 x 32
SNConv2d(nc, ndf, 3, 1, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
SNConv2d(ndf, ndf, 4, 2, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
# state size. (ndf) x 1 x 32
SNConv2d(ndf, ndf * 2, 3, 1, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
SNConv2d(ndf*2, ndf * 2, 4, 2, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
# state size. (ndf*2) x 16 x 16
SNConv2d(ndf * 2, ndf * 4, 3, 1, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
SNConv2d(ndf * 4, ndf * 4, 4, 2, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
# state size. (ndf*8) x 4 x 4
SNConv2d(ndf * 4, ndf * 8, 3, 1, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
SNConv2d(ndf * 8, 1, 4, 1, 0, bias=False),
nn.Sigmoid()
)
def cyclegan_discriminator_block(in_filters, out_filters, normalize=True):
"""Returns downsampling layers of each discriminator block"""
layers = [SNConv2d(in_filters, out_filters, 4, stride=2, padding=1)]
if normalize:
layers.append(nn.InstanceNorm2d(out_filters))
layers.append(nn.LeakyReLU(0.2, inplace=True))
return layers
def make_residual_connect(self, in_channels, out_channels):
model = []
model += [
SNConv2d(in_channels, out_channels, kernel_size=1, padding=0)
]
model += [nn.AvgPool2d(2)]
return nn.Sequential(*model)
def dcgan_discriminator_block(in_filters, out_filters, bn=True):
block = [ SNConv2d(in_filters, out_filters, 3, 2, 1),
nn.LeakyReLU(0.2, inplace=True),
nn.Dropout2d(0.25)]
if bn:
block.append(nn.BatchNorm2d(out_filters, 0.8))
return block
def make_res_block(self, in_channels, out_channels, hidden_channels,
use_BN, downsample):
model = []
if use_BN:
model += [nn.BatchNorm2d(in_channels)]
model += [nn.ReLU()]
model += [
SNConv2d(in_channels, hidden_channels, kernel_size=3, padding=1)
]
model += [nn.ReLU()]
model += [
SNConv2d(hidden_channels, out_channels, kernel_size=3, padding=1)
]
if downsample:
model += [nn.AvgPool2d(2)]
return nn.Sequential(*model)
def __init__(self):
super(_netD, self).__init__()
ndf = 64
self.main = nn.Sequential(
# state size. 1 x 32 x 32
SNConv2d(1, ndf, 3, 1, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
SNConv2d(ndf, ndf, 4, 2, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
# state size. (ndf) x 16 x 16
SNConv2d(ndf, ndf * 2, 3, 1, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
SNConv2d(ndf * 2, ndf * 2, 4, 2, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
# state size. (ndf*2) x 8 x 8
SNConv2d(ndf * 2, ndf * 4, 3, 1, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
SNConv2d(ndf * 4, ndf * 4, 4, 2, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
# state size. (ndf*4) x 4 x 4
SNConv2d(ndf * 4, ndf * 8, 3, 1, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
)
self.ln = nn.Sequential(SNLinear(ndf * 8 * 2 * 5, 1024),
nn.LeakyReLU(0.2, inplace=True),
SNLinear(1024, 1), nn.Sigmoid())
def __init__(self):
super(_netD, self).__init__()
nc = 1
ndf = 64
self.ini_w = 2
self.ini_h = 5
self.main = nn.Sequential(
# input is (nc) x 32 x 32
SNConv2d(nc, ndf, 3, 1, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
SNConv2d(ndf, ndf, 4, 2, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
# state size. (ndf) x 16 x 16
SNConv2d(ndf, ndf * 2, 3, 1, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
SNConv2d(ndf * 2, ndf * 2, 4, 2, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
# state size. (ndf*2) x 8 x 8
SNConv2d(ndf * 2, ndf * 4, 3, 1, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
SNConv2d(ndf * 4, ndf * 4, 4, 2, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
# state size. (ndf*4) x 4 x 4
SNConv2d(ndf * 4, ndf * 8, 3, 1, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
)
self.snlinear = nn.Sequential(
SNLinear(ndf * 8 * self.ini_w * self.ini_h, 1), nn.Sigmoid())
def __init__(self, nc, ndf, include_sigmoid):
super(_netD1, self).__init__()
self.main = nn.Sequential(
# input is (nc) x 32 x 32
SNConv2d(nc, ndf, 3, 4, 1, bias=False),
nn.LeakyReLU(0.1, inplace=True),
SNConv2d(ndf, ndf, 5, 2, 1, bias=False),
nn.LeakyReLU(0.1, inplace=True),
SNConv2d(ndf, ndf, 3, 2, 0, bias=False),
nn.LeakyReLU(0.1, inplace=True),
SNConv2d(ndf, 1, 3, 1, 0, bias=False),
#nn.Sigmoid()
)
self.sigmoid = nn.Sigmoid()
self.extra_layers_to_run = []
if include_sigmoid:
self.extra_layers_to_run.append(self.sigmoid)
def __init__(self, nc, ndf, include_sigmoid):
super(_netD2, self).__init__()
self.main = nn.Sequential(
SNConv2d(nc, ndf, 5, 2, 2),
nn.LeakyReLU(0.2, inplace=True),
SNConv2d(ndf, ndf * 2, 5, 2, 2),
nn.LeakyReLU(0.2, inplace=True),
SNConv2d(ndf * 2, ndf * 4, 5, 2, 2),
nn.LeakyReLU(0.2, inplace=True),
SNConv2d(ndf * 4, ndf * 8, 5, 2, 2),
nn.LeakyReLU(0.2, inplace=True),
SNConv2d(ndf * 8, 1, 4),
#nn.Sigmoid()
)
self.sigmoid = nn.Sigmoid()
self.extra_layers_to_run = []
if include_sigmoid:
self.extra_layers_to_run.append(self.sigmoid)
def __init__(self, nc, nef, ndiscriminators, context_vector_size):
super(_netE, self).__init__()
self.main = nn.Sequential(
# input is (nc * ncontext) x 32 x 32 TODO add ncontext
#nn.Linear(32, ndiscriminators, bias=False),
SNConv2d(nc, nef, 7, 4, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
SNConv2d(nef, ndiscriminators, 7, 4, 1, bias=False),
nn.Sigmoid()
)
self.image = nn.Sequential(
SNConv2d(nc, nef, 4, 2, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
SNConv2d(nef, nef * 2, 4, 2, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
SNConv2d(nef * 2, nef * 4, 4, 2, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
SNConv2d(nef * 4, ndiscriminators, 7, 4, 1, bias=False),
nn.LeakyReLU(0.1, inplace=True),
#nn.Softmax() # remove once context has been added
)
self.context = nn.Sequential(
#nn.Linear(nc * nef * nef + ndiscriminators, nef * 8),
nn.Linear(context_vector_size + ndiscriminators, nef * 8),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(nef * 8, ndiscriminators),
nn.Softmax()
)
def __init__(self, nc, nef, ndiscriminators):
super(_netE, self).__init__()
self.main = nn.Sequential(
# input is (nc * ncontext) x 32 x 32 TODO add ncontext
#nn.Linear(32, ndiscriminators, bias=False),
SNConv2d(nc, nef, 7, 4, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
SNConv2d(nef, ndiscriminators, 7, 4, 1, bias=False),
nn.Sigmoid())
self.image = nn.Sequential(
SNConv2d(nc, nef, 4, 2, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
SNConv2d(nef, nef * 2, 4, 2, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
SNConv2d(nef * 2, nef * 4, 4, 2, 1, bias=True),
nn.LeakyReLU(0.1, inplace=True),
SNConv2d(nef * 4, ndiscriminators, 7, 4, 1, bias=False),
nn.LeakyReLU(0.1, inplace=True),
)
self.context = nn.Sequential(
nn.Linear(nc * nef * nef + ndiscriminators, nef * 8),
nn.LeakyReLU(0.2, inplace=True), nn.Linear(nef * 8,
ndiscriminators),
nn.Sigmoid())
def __init__(self, in_channels=4, lookahead=1, num_actions=18, ngf=64):
super(_netD, self).__init__()
self.en_conv1 = SNConv2d(in_channels=in_channels + lookahead,
out_channels=ngf,
kernel_size=8,
stride=4,
padding=1)
self.en_norm1 = nn.BatchNorm2d(num_features=ngf)
self.en_relu2 = nn.LeakyReLU(negative_slope=0.2, inplace=True)
self.en_conv2 = SNConv2d(in_channels=ngf,
out_channels=ngf * 2,
kernel_size=4,
stride=2,
padding=1)
self.en_norm2 = nn.BatchNorm2d(num_features=ngf * 2)
self.en_relu3 = nn.LeakyReLU(negative_slope=0.2, inplace=True)
self.en_conv3 = SNConv2d(in_channels=ngf * 2,
out_channels=ngf * 4,
kernel_size=4,
stride=2,
padding=1)
self.en_norm3 = nn.BatchNorm2d(num_features=ngf * 4)
self.en_relu4 = nn.LeakyReLU(negative_slope=0.2, inplace=True)
self.en_conv4 = SNConv2d(in_channels=ngf * 4,
out_channels=16,
kernel_size=3,
stride=1,
padding=1)
self.en_norm4 = nn.BatchNorm2d(num_features=16)
self.dense6 = nn.Linear(in_features=16 * 25 + num_actions * lookahead,
out_features=18)
self.dense7 = nn.Linear(in_features=18 + num_actions * lookahead,
out_features=1)
def __init__(self, nc, ndf, include_sigmoid):
super(_netD9, self).__init__()
self.main = nn.Sequential(
*cyclegan_discriminator_block(3, 64, normalize=False),
*cyclegan_discriminator_block(64, 128),
*cyclegan_discriminator_block(128, 256),
*cyclegan_discriminator_block(256, 512),
nn.ZeroPad2d((1, 0, 1, 0)),
SNConv2d(512, 1, 4, padding=1),
nn.MaxPool3d([1, 4, 4]),
#nn.Sigmoid()
)
self.sigmoid = nn.Sigmoid()
self.extra_layers_to_run = []
if include_sigmoid:
self.extra_layers_to_run.append(self.sigmoid)
def __init__(self):
super(discriminator_SN_ff, self).__init__()
self.CNN = nn.Sequential(
SNConv2d(in_channels=2,
out_channels=4,
kernel_size=(1, 7),
dilation=(1, 1)),
# nn.BatchNorm2d(64),
nn.LeakyReLU(0.3),
SNConv2d(in_channels=4,
out_channels=8,
kernel_size=(7, 1),
dilation=(1, 1)),
# nn.BatchNorm2d(64),
nn.LeakyReLU(0.3),
SNConv2d(in_channels=8,
out_channels=16,
kernel_size=(5, 5),
dilation=(1, 1)),
# nn.BatchNorm2d(64),
nn.LeakyReLU(0.3),
SNConv2d(in_channels=16,
out_channels=32,
kernel_size=(5, 5),
dilation=(3, 3)),
# nn.BatchNorm2d(64),
nn.LeakyReLU(0.3),
SNConv2d(in_channels=32,
out_channels=64,
kernel_size=(5, 5),
dilation=(5, 5)),
# nn.BatchNorm2d(64),
nn.LeakyReLU(0.3),
SNConv2d(in_channels=64,
out_channels=128,
kernel_size=(5, 5),
dilation=(13, 13)),
# nn.BatchNorm2d(64),
nn.LeakyReLU(0.3),
SNConv2d(in_channels=128, out_channels=256, kernel_size=(1, 31)),
nn.LeakyReLU(0.3),
SNConv2d(in_channels=256, out_channels=512, kernel_size=(1, 31)),
nn.LeakyReLU(0.3),
SNConv2d(in_channels=512, out_channels=1024, kernel_size=(1, 31)),
nn.LeakyReLU(0.3),
SNConv2d(in_channels=1024, out_channels=1, kernel_size=1),
nn.LeakyReLU(0.3))
self.FC3 = nn.Sequential(nn.Dropout(0.5, False), SNLinear(7 * 73, 1),
nn.ReLU())
for name, param in self.FC3.named_parameters():
if 'bias' in name:
nn.init.constant_(param, 0)
elif 'weight' in name:
nn.init.xavier_normal_(param)
self.FC4 = nn.Sequential(nn.Dropout(0.5, False), nn.Linear(600, 257))
for name, param in self.FC4.named_parameters():
if 'bias' in name:
nn.init.constant_(param, 0)
elif 'weight' in name:
nn.init.xavier_normal_(param)
for name, param in self.CNN.named_parameters():
if 'bias' in name:
nn.init.constant_(param, 0.0)
elif 'weight' in name:
nn.init.xavier_normal_(param)
