def __init__(self, in_channel, depth, stride):
super(bottleneck_ORIG, self).__init__()
in_planes = in_channel
planes = depth
self.conv1 = Conv2d(in_planes, planes, kernel_size=1, bias=False)
self.bn1 = InstanceNorm2d(planes)
self.conv2 = Conv2d(planes,
planes,
kernel_size=3,
stride=stride,
padding=1,
bias=False)
self.bn2 = InstanceNorm2d(planes)
self.conv3 = Conv2d(planes,
self.expansion * planes,
kernel_size=1,
bias=False)
self.bn3 = InstanceNorm2d(self.expansion * planes)
self.shortcut = Sequential()
if stride != 1 or in_planes != self.expansion * planes:
self.shortcut = Sequential(
Conv2d(in_planes,
self.expansion * planes,
kernel_size=1,
stride=stride,
bias=False), InstanceNorm2d(self.expansion * planes))
def __init__(self,
in_channels,
channels,
stride=1,
downsample=False,
upsample=False):
super().__init__()
self.down_conv = Conv2d(in_channels,
channels * self.expansion,
kernel_size=1,
stride=stride) if downsample else None
self.up_conv = ConvBlock(in_channels,
channels * self.expansion,
kernel_size=1,
stride=1,
upsample=upsample) if upsample else None
self.conv_block = Sequential(
InstanceNorm2d(in_channels), ReLU(),
Conv2d(in_channels, channels, kernel_size=1, stride=1),
InstanceNorm2d(channels), ReLU(),
ConvBlock(channels,
channels,
kernel_size=3,
stride=stride,
upsample=upsample), InstanceNorm2d(channels), ReLU(),
Conv2d(channels,
channels * self.expansion,
kernel_size=1,
stride=1))
def __init__(self, in_channels = 4, ngf = 32, n_layers = 5):
super(SketchGenerator, self).__init__()
encoder = []
encoder.append(Conv2d(out_channels=ngf, kernel_size=9, padding=4, in_channels=in_channels))
encoder.append(ReLU())
encoder.append(mySConv(ngf*2, 2, ngf))
encoder.append(mySConv(ngf*4, 2, ngf*2))
transformer = []
for n in range(n_layers):
transformer.append(mySBlock(ngf*4+1))
decoder1 = []
decoder2 = []
decoder3 = []
decoder1.append(ConvTranspose2d(out_channels=ngf*2, kernel_size=4, stride=2, padding=0, in_channels=ngf*4+2))
decoder1.append(InstanceNorm2d(num_features=ngf*2))
decoder1.append(ReLU())
decoder2.append(ConvTranspose2d(out_channels=ngf, kernel_size=4, stride=2, padding=0, in_channels=ngf*2+1))
decoder2.append(InstanceNorm2d(num_features=ngf))
decoder2.append(ReLU())
decoder3.append(Conv2d(out_channels=3, kernel_size=9, padding=1, in_channels=ngf+1))
decoder3.append(Tanh())
self.encoder = nn.Sequential(*encoder)
self.transformer = nn.Sequential(*transformer)
self.decoder1 = nn.Sequential(*decoder1)
self.decoder2 = nn.Sequential(*decoder2)
self.decoder3 = nn.Sequential(*decoder3)
def __init__(self, num_layers, mode='ir', input_nc=3):
super(BackboneEncoderUsingLastLayerIntoWPlus, self).__init__()
print('Using BackboneEncoderUsingLastLayerIntoWPlus')
assert num_layers in [50, 100, 152], 'num_layers should be 50,100, or 152'
assert mode in ['ir', 'ir_se'], 'mode should be ir or ir_se'
blocks = get_blocks(num_layers)
if mode == 'ir':
unit_module = bottleneck_IR
elif mode == 'ir_se':
unit_module = bottleneck_IR_SE
self.input_layer = Sequential(Conv2d(input_nc, 64, (3, 3), 1, 1, bias=False),
InstanceNorm2d(64),
PReLU(64))
self.output_layer_2 = Sequential(InstanceNorm2d(512),
torch.nn.AdaptiveAvgPool2d((7, 7)),
Flatten(),
Linear(512 * 7 * 7, 512))
self.linear = FullyConnectedLayer(512, 512 * 18)
modules = []
for block in blocks:
for bottleneck in block:
modules.append(unit_module(bottleneck.in_channel,
bottleneck.depth,
bottleneck.stride))
self.body = Sequential(*modules)
def __init__(self, in_channel, depth, stride):
super(bottleneck_IR_SE, self).__init__()
if in_channel == depth:
self.shortcut_layer = MaxPool2d(1, stride)
else:
self.shortcut_layer = Sequential(
Conv2d(in_channel, depth, (1, 1), stride, bias=False), )
self.res_layer = Sequential(
Conv2d(in_channel,
depth,
kernel_size=1,
stride=1,
padding=0,
bias=False),
Conv2d(depth,
depth,
kernel_size=3,
stride=1,
padding=1,
bias=False,
groups=depth), PReLU(depth), InstanceNorm2d(depth),
Conv2d(depth,
depth,
kernel_size=1,
stride=1,
padding=0,
bias=False),
Conv2d(depth,
depth,
kernel_size=3,
stride=stride,
padding=1,
bias=False,
groups=depth), SEModule(depth, 16), PReLU(depth),
InstanceNorm2d(depth))
def __init__(self):
super(InverseNet, self).__init__()
self.slice = torch.nn.Sequential()
self.slice.add_module(
str(0),
Conv2d(256, 128, kernel_size=(3, 3), stride=(1, 1),
padding=(1, 1)))
self.slice.add_module(str(1), InstanceNorm2d(128, affine=True))
self.slice.add_module(str(2), ReLU())
self.slice.add_module(str(3),
nn.Upsample(scale_factor=2, mode="nearest"))
self.slice.add_module(
str(4),
Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1),
padding=(1, 1)))
self.slice.add_module(str(5), InstanceNorm2d(128, affine=True))
self.slice.add_module(str(6), ReLU())
self.slice.add_module(
str(7),
Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)))
self.slice.add_module(str(8), InstanceNorm2d(64, affine=True))
self.slice.add_module(str(9), ReLU())
self.slice.add_module(str(10),
nn.Upsample(scale_factor=2, mode="nearest"))
self.slice.add_module(
str(11),
Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)))
self.slice.add_module(str(12), InstanceNorm2d(64, affine=True))
self.slice.add_module(str(13), ReLU())
self.slice.add_module(
str(14),
Conv2d(64, 3, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)))
self.init_weights()
def __init__(self, inplanes, planes, stride=1, downsample=None): super(BasicBlockIn, self).__init__() self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=3, stride=stride, padding=1, bias=False) self.bn1 = InstanceNorm2d(planes, eps=1e-05, momentum=0.1, affine=True) self.relu = nn.ReLU(inplace=True) self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False) self.bn2 = InstanceNorm2d(planes, eps=1e-05, momentum=0.1, affine=True) self.downsample = downsample self.stride = stride
def __init__(self, in_channels=4, ngf=32, n_layers=5):
"""
生成器
:param in_channels: 传入的是 4
:param ngf: 生成器第一层的特征的数量 传入的是 32
:param n_layers: 生成器的网络的层数 传入的是 6
"""
super(SketchGenerator, self).__init__()
encoder = []
encoder.append(
Conv2d(in_channels=in_channels,
out_channels=ngf,
kernel_size=9,
padding=4))
encoder.append(ReLU())
encoder.append(mySConv(ngf * 2, 2, ngf))
encoder.append(mySConv(ngf * 4, 2, ngf * 2))
transformer = []
for n in range(n_layers): # n_layers: 生成器的网络的层数
transformer.append(mySBlock(ngf * 4 + 1)) # TODO 额外加 1？？？
decoder1 = []
decoder2 = []
decoder3 = []
decoder1.append(
ConvTranspose2d(out_channels=ngf * 2,
kernel_size=4,
stride=2,
padding=0,
in_channels=ngf * 4 + 2)) # 为什么加 2？？？
decoder1.append(InstanceNorm2d(num_features=ngf * 2))
decoder1.append(ReLU())
decoder2.append(
ConvTranspose2d(out_channels=ngf,
kernel_size=4,
stride=2,
padding=0,
in_channels=ngf * 2 + 1)) # 为什么加 1？？？
decoder2.append(InstanceNorm2d(num_features=ngf))
decoder2.append(ReLU())
decoder3.append(
Conv2d(out_channels=3,
kernel_size=9,
padding=1,
in_channels=ngf + 1))
decoder3.append(Tanh())
self.encoder = nn.Sequential(*encoder)
self.transformer = nn.Sequential(*transformer)
self.decoder1 = nn.Sequential(*decoder1)
self.decoder2 = nn.Sequential(*decoder2)
self.decoder3 = nn.Sequential(*decoder3)
def __init__(self, in_channels, out_channels):
super(FirstResBlock, self).__init__()
self.model = nn.Sequential(
Conv2d(in_channels, out_channels, 3, 1, padding=1),
InstanceNorm2d(out_channels, affine=True),
nn.ReLU(),
Conv2d(out_channels, out_channels, 3, 1, padding=1),
)
self.bypass = nn.Sequential(
Conv2d(in_channels, out_channels, 1, 1, padding=0),
InstanceNorm2d(out_channels, affine=True))
def __init__(self, in_channels, out_channels):
super(ConvBlock, self).__init__()
conv = Conv2d(in_channels, out_channels, 3, 1, padding=1)
self.out_channels = out_channels
self.model = nn.Sequential(
InstanceNorm2d(in_channels, affine=True),
nn.ReLU(),
conv,
InstanceNorm2d(out_channels,
affine=False) # normalize to (0, 1) Gaussian
)
def __init__(self, in_channels, out_channels, cat_channels):
super(DecodingResBlock, self).__init__()
# cat_channels: number of channels of the features from encoding path
self.up = UpSampleBlock(in_channels, int(in_channels / 2))
n_main = int(in_channels / 2) + cat_channels
self.main = nn.Sequential(
InstanceNorm2d(n_main, affine=True), nn.ReLU(),
Conv2d(n_main, out_channels, 3, 1, padding=1),
InstanceNorm2d(out_channels, affine=True), nn.ReLU(),
Conv2d(out_channels, out_channels, 3, 1, padding=1))
self.bypass = nn.Sequential(
Conv2d(n_main, out_channels, 1, 1, padding=0),
InstanceNorm2d(out_channels, affine=True))
def __init__(self):
super(OCRModel, self).__init__()
self.conv1 = Conv2d(1, 32, (3, 3), padding=1, bias=False)
self.conv2 = Conv2d(32, 32, (3, 3), padding=1, bias=False)
self.conv3 = Conv2d(32, 64, (3, 3), padding=1, bias=False)
self.conv4 = Conv2d(64, 64, (3, 3), padding=1, bias=False)
self.conv5 = Conv2d(64, 128, (3, 3), padding=1, bias=False)
self.conv6 = Conv2d(128, 128, (3, 3), padding=1, bias=False)
self.conv7 = Conv2d(128, 256, (3, 3), padding=1, bias=False)
self.conv8 = Conv2d(256, 256, (3, 3), padding=1, bias=False)
self.conv9 = Conv2d(256, 512, (2, 3), padding=(0, 1), bias=False)
self.conv10 = Conv2d(512, 512, (1, 5), padding=(0, 2), bias=False)
self.conv11 = Conv2d(512, 94, (1, 1), padding=(0, 0))
self.conv_attenton = Conv2d(512, 1, (1, 1), padding=0)
self.batch1 = InstanceNorm2d(32, eps=1e-05, momentum=0.1, affine=True)
self.batch2 = InstanceNorm2d(32, eps=1e-05, momentum=0.1, affine=True)
self.batch3 = InstanceNorm2d(64, eps=1e-05, momentum=0.1, affine=True)
self.batch5 = InstanceNorm2d(128, eps=1e-05, momentum=0.1, affine=True)
self.batch7 = InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
self.batch8 = InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=True)
self.batch9 = InstanceNorm2d(512, eps=1e-05, momentum=0.1, affine=True)
self.batch10 = InstanceNorm2d(512,
eps=1e-05,
momentum=0.1,
affine=True)
self.drop1 = Dropout2d(p=0.2, inplace=False)
self.leaky = LeakyReLU(negative_slope=0.01, inplace=False)
self.max1 = MaxPool2d((2, 2), stride=None)
self.max2 = MaxPool2d((2, 1), stride=(2, 1))
def __init__(self, in_channels, out_channels):
super(EncodingResBlock, self).__init__()
conv1 = Conv2d(in_channels, out_channels, 3, 2, padding=1)
conv2 = Conv2d(out_channels, out_channels, 3, 1, padding=1)
bypass_conv = Conv2d(in_channels, out_channels, 1, 1, padding=0)
self.model = nn.Sequential(
InstanceNorm2d(in_channels, affine=True),
nn.ReLU(),
conv1,
InstanceNorm2d(out_channels, affine=True),
nn.ReLU(),
conv2,
)
self.bypass = nn.Sequential(bypass_conv, nn.AvgPool2d(2),
InstanceNorm2d(out_channels, affine=True))
def __init__(self) -> None:
super(TransformerNet, self).__init__()
# Initial convolution layers
self.conv1: ConvLayer[L[3], L[32], L[9],
L[1]] = ConvLayer(3, 32, kernel_size=9, stride=1)
self.in1: InstanceNorm2d[L[32]] = InstanceNorm2d(32, affine=True)
self.conv2: ConvLayer[L[32], L[64], L[3],
L[2]] = ConvLayer(32,
64,
kernel_size=3,
stride=2)
self.in2: InstanceNorm2d[L[64]] = InstanceNorm2d(64, affine=True)
self.conv3: ConvLayer[L[64], L[128], L[3],
L[2]] = ConvLayer(64,
128,
kernel_size=3,
stride=2)
self.in3: InstanceNorm2d[L[128]] = InstanceNorm2d(128, affine=True)
# Residual layers
self.res1: ResidualBlock[L[128]] = ResidualBlock(128)
self.res2: ResidualBlock[L[128]] = ResidualBlock(128)
self.res3: ResidualBlock[L[128]] = ResidualBlock(128)
self.res4: ResidualBlock[L[128]] = ResidualBlock(128)
self.res5: ResidualBlock[L[128]] = ResidualBlock(128)
# Upsampling Layers
self.deconv1: UpsampleConvLayer[L[128], L[64], L[3], L[1],
L[2]] = UpsampleConvLayer(
128,
64,
kernel_size=3,
stride=1,
upsample=2)
self.in4: InstanceNorm2d[L[64]] = InstanceNorm2d(64, affine=True)
self.deconv2: UpsampleConvLayer[L[64], L[32], L[3], L[1],
L[2]] = UpsampleConvLayer(
64,
32,
kernel_size=3,
stride=1,
upsample=2)
self.in5: InstanceNorm2d[L[32]] = InstanceNorm2d(32, affine=True)
self.deconv3: ConvLayer[L[32], L[3], L[9],
L[1]] = ConvLayer(32,
3,
kernel_size=9,
stride=1)
# Non-linearities
self.relu = ReLU()
def __init__(self, num_layers, mode='ir', input_nc=3):
super(GradualStyleEncoder, self).__init__()
assert num_layers in [50, 100, 152], 'num_layers should be 50,100, or 152'
assert mode in ['ir', 'ir_se'], 'mode should be ir or ir_se'
blocks = get_blocks(num_layers)
if mode == 'ir':
unit_module = bottleneck_IR
elif mode == 'ir_se':
unit_module = bottleneck_IR_SE
self.input_layer = Sequential(Conv2d(input_nc, 64, (3, 3), 1, 1, bias=False),
InstanceNorm2d(64),
PReLU(64))
modules = []
for block in blocks:
for bottleneck in block:
modules.append(unit_module(bottleneck.in_channel,
bottleneck.depth,
bottleneck.stride))
self.body = Sequential(*modules)
self.styles = nn.ModuleList()
self.style_count = 18
self.coarse_ind = 3
self.middle_ind = 7
for i in range(self.style_count):
if i < self.coarse_ind:
style = GradualStyleBlock(512, 512, 32)
elif i < self.middle_ind:
style = GradualStyleBlock(512, 512, 64)
else:
style = GradualStyleBlock(512, 512, 128)
self.styles.append(style)
self.latlayer1 = nn.Conv2d(256, 512, kernel_size=1, stride=1, padding=0)
self.latlayer2 = nn.Conv2d(128, 512, kernel_size=1, stride=1, padding=0)
def __init__(self, num_filter=128):
super(mySBlock, self).__init__()
self.myconv = mySConv(num_filter=num_filter, stride=1, in_channels=num_filter)
self.conv = Conv2d(out_channels=num_filter, kernel_size=3, padding=1, in_channels=num_filter)
self.bn = InstanceNorm2d(num_features=num_filter)
self.relu = ReLU()
def __init__(self,
in_channels,
out_channels=64,
kernel_size=3,
padding=1,
useNorm='BN',
up=False):
super(RDCBBlock, self).__init__()
self.relu = ReLU()
if up == False:
self.dconv = ConvTranspose2d(out_channels=out_channels,
kernel_size=kernel_size,
stride=2,
padding=padding,
in_channels=in_channels)
else:
self.dconv = UpsampleConLayer(out_channels=out_channels,
kernel_size=kernel_size,
stride=1,
in_channels=in_channels,
upsample=2)
if useNorm == 'IN':
self.bn = InstanceNorm2d(num_features=out_channels, affine=True)
elif useNorm == 'BN':
self.bn = BatchNorm2d(num_features=out_channels)
else:
self.bn = Identity()
def __init__(self, block, input_nc, num_blocks):
super(FPN, self).__init__()
self.in_planes = 64
self.conv1 = Conv2d(input_nc,
64,
kernel_size=7,
stride=2,
padding=3,
bias=False)
self.bn1 = InstanceNorm2d(64)
# Bottom-up layers
self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1)
self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)
self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)
self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2)
# Top layer
self.toplayer = Conv2d(2048, 512, kernel_size=1, stride=1,
padding=0) # Reduce channels
# Smooth layers
self.smooth1 = Conv2d(512, 512, kernel_size=3, stride=1, padding=1)
self.smooth2 = Conv2d(512, 512, kernel_size=3, stride=1, padding=1)
# Lateral layers
self.latlayer1 = Conv2d(1024, 512, kernel_size=1, stride=1, padding=0)
self.latlayer2 = Conv2d(512, 512, kernel_size=1, stride=1, padding=0)
def conv_dw_in(inp, oup, stride, dilation=1):
return nn.Sequential(
nn.Conv2d(inp, inp, 3, stride, 1 + (dilation > 0) * (dilation -1), dilation=dilation, groups=inp, bias=False),
nn.Conv2d(inp, oup, 1, 1, 0, bias=False),
InstanceNorm2d(oup, eps=1e-05, momentum=0.1),
nn.LeakyReLU(inplace=True, negative_slope=0.01),
)
def __init__(self,
in_,
out_,
stride=(1, 1),
k=3,
activation=ReLU,
dropout=0.4):
super(ConvBlock, self).__init__()
self.activation = activation()
self.conv1 = Conv2d(in_channels=in_,
out_channels=out_,
kernel_size=k,
padding=k // 2)
self.conv2 = Conv2d(in_channels=out_,
out_channels=out_,
kernel_size=k,
padding=k // 2)
self.conv3 = Conv2d(out_,
out_,
kernel_size=(3, 3),
padding=(1, 1),
stride=stride)
self.norm_layer = InstanceNorm2d(out_,
eps=0.001,
momentum=0.99,
track_running_stats=False)
self.dropout = MixDropout(dropout_proba=dropout,
dropout2d_proba=dropout / 2)
def __init__(self, in_channels, ndf=64, n_layers=3):
super(Discriminator, self).__init__()
modelList = []
kernel_size = 4
padding = int(np.ceil((kernel_size - 1) / 2))
modelList.append(
Conv2d(out_channels=ndf,
kernel_size=kernel_size,
stride=2,
padding=padding,
in_channels=in_channels))
modelList.append(LeakyReLU(0.2))
nf_mult = 1
for n in range(1, n_layers):
nf_mult_prev = nf_mult
nf_mult = min(2**n, 8)
modelList.append(
Conv2d(out_channels=ndf * nf_mult,
kernel_size=kernel_size,
stride=2,
padding=padding,
in_channels=ndf * nf_mult_prev))
modelList.append(
InstanceNorm2d(num_features=ndf * nf_mult, affine=True))
modelList.append(LeakyReLU(0.2))
nf_mult_prev = nf_mult
nf_mult = min(2**n_layers, 8)
modelList.append(
Conv2d(out_channels=ndf * nf_mult,
kernel_size=kernel_size,
stride=1,
padding=padding,
in_channels=ndf * nf_mult_prev))
modelList.append(
InstanceNorm2d(num_features=ndf * nf_mult, affine=True))
modelList.append(LeakyReLU(0.2))
modelList.append(
Conv2d(out_channels=1,
kernel_size=kernel_size,
stride=1,
padding=padding,
in_channels=ndf * nf_mult))
self.model = nn.Sequential(*modelList)
def __init__(self, in_ch, out_ch):
super(Upward, self).__init__()
self.depool = Sequential(
UpsamplingNearest2d(scale_factor=2), ZeroPad2d((1, 2, 1, 2)),
Conv2d(in_ch, out_ch, kernel_size=4, stride=1), ReLU(inplace=True),
InstanceNorm2d(out_ch))
def __init__(self, channels: Channels) -> None:
super(ResidualBlock, self).__init__()
self.conv1: ConvLayer[Channels, Channels, L[3],
L[1]] = ConvLayer(channels,
channels,
kernel_size=3,
stride=1)
self.in1: InstanceNorm2d[Channels] = InstanceNorm2d(channels,
affine=True)
self.conv2: ConvLayer[Channels, Channels, L[3],
L[1]] = ConvLayer(channels,
channels,
kernel_size=3,
stride=1)
self.in2: InstanceNorm2d[Channels] = InstanceNorm2d(channels,
affine=True)
self.relu = ReLU()
def __init__(self, channels_in, channels_out, acti):
super(Conv33, self).__init__()
self.conv_33 = Sequential(
Conv2d(channels_in,
channels_out,
3,
padding=1,
padding_mode='reflect'), InstanceNorm2d(channels_out), acti)
pass
def __init__(self,
num_features,
alpha_in=0.5,
alpha_out=0.5,
eps=1e-5,
momentum=0.1,
affine=True):
super(_InstanceNorm2d, self).__init__()
hf_ch = int(num_features * (1 - alpha_out))
lf_ch = num_features - hf_ch
self.inh = InstanceNorm2d(hf_ch,
eps=eps,
momentum=momentum,
affine=affine)
self.inl = InstanceNorm2d(lf_ch,
eps=eps,
momentum=momentum,
affine=affine)
def __init__(self, in_channels, ndf=32, n_layers=3, multilayer=False, IN=False):
super(Discriminator, self).__init__()
modelList = []
outlist1 = []
outlist2 = []
kernel_size = 4
padding = int(np.ceil((kernel_size - 1)/2))
modelList.append(Conv2d(out_channels=ndf, kernel_size=kernel_size, stride=2,
padding=2, in_channels=in_channels))
modelList.append(LeakyReLU(0.2))
nf_mult = 1
for n in range(1, n_layers):
nf_mult_prev = nf_mult
nf_mult = min(2 ** n, 4)
modelList.append(Conv2d(out_channels=ndf * nf_mult, kernel_size=kernel_size, stride=2,
padding=2, in_channels=ndf * nf_mult_prev))
if IN:
modelList.append(InstanceNorm2d(num_features=ndf * nf_mult))
else:
modelList.append(BatchNorm2d(num_features=ndf * nf_mult, track_running_stats=True))
modelList.append(LeakyReLU(0.2))
nf_mult_prev = nf_mult
nf_mult = min(2 ** n_layers, 4)
outlist1.append(Conv2d(out_channels=1, kernel_size=kernel_size, stride=1,
padding=padding, in_channels=ndf * nf_mult_prev))
outlist2.append(Conv2d(out_channels=ndf * nf_mult, kernel_size=kernel_size, stride=1,
padding=padding, in_channels=ndf * nf_mult_prev))
if IN:
outlist2.append(InstanceNorm2d(num_features=ndf * nf_mult))
else:
outlist2.append(BatchNorm2d(num_features=ndf * nf_mult, track_running_stats=True))
outlist2.append(LeakyReLU(0.2))
outlist2.append(Conv2d(out_channels=1, kernel_size=kernel_size, stride=1,
padding=padding, in_channels=ndf * nf_mult))
self.model = nn.Sequential(*modelList)
self.out1 = nn.Sequential(*outlist1)
self.out2 = nn.Sequential(*outlist2)
self.multilayer = multilayer
def __init__(self, in_ch, out_ch, stride=2, normalise=True):
super(ConvBlock, self).__init__()
self.pool = Sequential(
ZeroPad2d((1, 2, 1, 2)),
Conv2d(in_ch, out_ch, kernel_size=4, stride=stride),
LeakyReLU(negative_slope=0.2, inplace=True))
if normalise:
self.pool.add_module('instance_norm', InstanceNorm2d(out_ch))
def DownsampleBlock(in_channels: int, initialization_method='he') -> Module:
init = create_init_function(initialization_method)
return Sequential(
init(
Conv2d(in_channels,
in_channels * 2,
kernel_size=4,
stride=2,
padding=1,
bias=False)), InstanceNorm2d(in_channels * 2, affine=True),
ReLU(inplace=True))
def __init__(self, input_nc=3):
super(GradualStyleEncoder2, self).__init__()
self.fpn = FPN101(input_nc)
self.map2style1 = Sequential(
Conv2d(512, 512, kernel_size=3, stride=2, padding=1),
LeakyReLU(inplace=True),
InstanceNorm2d(512),
Conv2d(512, 512, kernel_size=3, stride=2, padding=1),
LeakyReLU(inplace=True),
InstanceNorm2d(512),
)
self.map2style2 = Sequential(
Conv2d(512, 512, kernel_size=3, stride=2, padding=1),
LeakyReLU(inplace=True),
InstanceNorm2d(512),
)
self.map2style3 = Sequential(
Conv2d(512, 512, kernel_size=3, stride=2, padding=1),
LeakyReLU(inplace=True),
InstanceNorm2d(512),
Conv2d(512, 512, kernel_size=3, stride=2, padding=1),
LeakyReLU(inplace=True),
InstanceNorm2d(512),
Conv2d(512, 512, kernel_size=3, stride=2, padding=1),
LeakyReLU(inplace=True),
InstanceNorm2d(512),
Conv2d(512, 512, kernel_size=3, stride=2, padding=1),
LeakyReLU(inplace=True),
InstanceNorm2d(512),
Conv2d(512, 512, kernel_size=3, stride=2, padding=1),
LeakyReLU(inplace=True),
InstanceNorm2d(512),
)
self.embed = Embedding(18, 64)
self.expand_layer = Sequential(
nn.Linear(512+64, 512),
nn.LeakyReLU(inplace=True),
)
self.rnn = GRU(512, 512, num_layers=2, batch_first=True, bidirectional=True)
self.last = Sequential(
Linear(1024, 512),
LeakyReLU(inplace=True),
Linear(512, 512)
)
def __init__(self, n_class=33, ns=0.2, dp=0.1, seg_len=128):
super(PatchDiscriminator, self).__init__()
self.ns = ns
self.conv1 = Conv2d(1, 64, kernel_size=5, stride=2)
self.conv2 = Conv2d(64, 128, kernel_size=5, stride=2)
self.conv3 = Conv2d(128, 256, kernel_size=5, stride=2)
self.conv4 = Conv2d(256, 512, kernel_size=5, stride=2)
self.conv5 = Conv2d(512, 512, kernel_size=5, stride=2)
self.conv6 = Conv2d(512, 32, kernel_size=1)
if seg_len == 128:
self.conv7 = Conv2d(32, 1, kernel_size=(17, 4))
self.conv_classify = Conv2d(32, n_class, kernel_size=(17, 4))
elif seg_len == 64:
self.conv7 = Conv2d(32, 1, kernel_size=(17, 2))
self.conv_classify = Conv2d(32, n_class, kernel_size=(17, 2))
else:
raise NotImplementedError(
"Segement length {} is not supported!".format(seg_len))
self.drop1 = Dropout2d(p=dp)
self.drop2 = Dropout2d(p=dp)
self.drop3 = Dropout2d(p=dp)
self.drop4 = Dropout2d(p=dp)
self.drop5 = Dropout2d(p=dp)
self.drop6 = Dropout2d(p=dp)
self.ins_norm1 = InstanceNorm2d(self.conv1.out_channels)
self.ins_norm2 = InstanceNorm2d(self.conv2.out_channels)
self.ins_norm3 = InstanceNorm2d(self.conv3.out_channels)
self.ins_norm4 = InstanceNorm2d(self.conv4.out_channels)
self.ins_norm5 = InstanceNorm2d(self.conv5.out_channels)
self.ins_norm6 = InstanceNorm2d(self.conv6.out_channels)
