def __init__(self, in_channels, ndf=64, n_layers=3, use_bias=False, istest=False, latent=256, usetanh = False ):
super(Decoder, self).__init__()
self.model = HybridSequential()
kernel_size = 5
padding = 0
nf_mult = 2 ** n_layers
self.model.add(Conv2DTranspose(channels=ndf * nf_mult/2, kernel_size=kernel_size, strides=2,
padding=padding, in_channels=latent,
use_bias=use_bias))
self.model.add(BatchNorm(momentum=0.1, in_channels=ndf * nf_mult / 2, use_global_stats=istest))
#self.model.add(LeakyReLU(alpha=0.2))
self.model.add(Activation(activation='relu'))
for n in range(1, n_layers):
nf_mult = nf_mult / 2
self.model.add(Conv2DTranspose(channels=ndf * nf_mult / 2, kernel_size=kernel_size, strides=2,
padding=padding, in_channels=ndf * nf_mult,
use_bias=use_bias))
self.model.add(BatchNorm(momentum=0.1, in_channels=ndf * nf_mult / 2, use_global_stats=istest))
#self.model.add(LeakyReLU(alpha=0.2))
if n==2:
self.model.add(Dropout(rate=0.5))
self.model.add(Activation(activation='relu'))
self.model.add(Conv2DTranspose(channels=in_channels, kernel_size=kernel_size, strides=2,
padding=padding, in_channels=ndf))
#self.model.add(LeakyReLU(alpha=0.2))
self.model.add(Activation(activation='tanh'))
def __init__(self,
inner_channels,
outer_channels,
inner_block=None,
innermost=False,
outermost=False,
use_dropout=False,
use_bias=False,
final_out=3):
super(UnetSkipUnit, self).__init__()
with self.name_scope():
self.outermost = outermost
en_conv = Conv2D(channels=inner_channels,
kernel_size=4,
strides=2,
padding=1,
in_channels=outer_channels,
use_bias=use_bias)
en_relu = LeakyReLU(alpha=0.2)
en_norm = BatchNorm(momentum=0.1, in_channels=inner_channels)
de_relu = Activation(activation='relu')
de_norm = BatchNorm(momentum=0.1, in_channels=outer_channels)
if innermost:
de_conv = Conv2DTranspose(channels=outer_channels,
kernel_size=4,
strides=2,
padding=1,
in_channels=inner_channels,
use_bias=use_bias)
encoder = [en_relu, en_conv]
decoder = [de_relu, de_conv, de_norm]
model = encoder + decoder
elif outermost:
de_conv = Conv2DTranspose(channels=final_out,
kernel_size=4,
strides=2,
padding=1,
in_channels=inner_channels * 2)
encoder = [en_conv]
decoder = [de_relu, de_conv, Activation(activation='tanh')]
model = encoder + [inner_block] + decoder
else:
de_conv = Conv2DTranspose(channels=outer_channels,
kernel_size=4,
strides=2,
padding=1,
in_channels=inner_channels * 2,
use_bias=use_bias)
encoder = [en_relu, en_conv, en_norm]
decoder = [de_relu, de_conv, de_norm]
model = encoder + [inner_block] + decoder
if use_dropout:
model += [Dropout(rate=0.5)]
self.model = HybridSequential()
with self.model.name_scope():
for block in model:
self.model.add(block)
def build_generator(n_filters, n_channels, mx_ctx):
netG = HybridSequential()
with netG.name_scope():
# Input is Z
netG.add(Conv2DTranspose(n_filters * 8, kernel_size=4, strides=1, padding=0, use_bias=False))
netG.add(BatchNorm())
netG.add(Activation("relu"))
netG.add(Conv2DTranspose(n_filters * 4, kernel_size=4, strides=2, padding=1, use_bias=False))
netG.add(BatchNorm())
netG.add(Activation("relu"))
netG.add(Conv2DTranspose(n_filters * 2, kernel_size=4, strides=2, padding=1, use_bias=False))
netG.add(BatchNorm())
netG.add(Activation("relu"))
netG.add(Conv2DTranspose(n_filters, kernel_size=4, strides=2, padding=1, use_bias=False))
netG.add(BatchNorm())
netG.add(Activation("relu"))
netG.add(Conv2DTranspose(n_channels, kernel_size=4, strides=2, padding=1, use_bias=False))
netG.add(BatchNorm())
netG.add(Activation("tanh"))
netG.initialize(mx.init.Normal(0.02), ctx=mx_ctx)
netG.hybridize()
return netG
def __init__(self, in_channels, ndf=64, n_layers=3, use_bias=False, istest=False, usetanh = False ):
super(CEGeneratorP, self).__init__()
with self.name_scope():
self.model = HybridSequential()
kernel_size = 5
padding = 0 #int(np.ceil((kernel_size - 1) / 2))
self.model.add(Conv2D(channels=ndf, kernel_size=kernel_size, strides=2,
padding=padding, in_channels=in_channels))
self.model.add(LeakyReLU(alpha=0.2))
nf_mult = 2;
nf_mult_prev = 1;
nf_mult = 1
for n in range(1, n_layers):
nf_mult_prev = nf_mult
nf_mult = 2 ** n
self.model.add(Conv2D(channels=ndf * nf_mult, kernel_size=kernel_size, strides=2,
padding=padding, in_channels=ndf * nf_mult_prev,
use_bias=use_bias))
self.model.add(BatchNorm(momentum=0.1, in_channels=ndf * nf_mult, use_global_stats=istest))
self.model.add(LeakyReLU(alpha=0.2))
nf_mult_prev = nf_mult
nf_mult = 2 ** n_layers
self.model.add(Conv2D(channels=4096, kernel_size=kernel_size, strides=2,
padding=padding, in_channels=ndf * nf_mult_prev,
use_bias=use_bias))
#self.model.add(BatchNorm(momentum=0.1, in_channels =128, use_global_stats=istest))
if usetanh:
self.model.add(Activation(activation='tanh'))
else:
self.model.add(LeakyReLU(alpha=0.2))
# Decoder
self.model.add(Conv2DTranspose(channels=ndf * nf_mult/2, kernel_size=kernel_size, strides=2,
padding=padding, in_channels=4096,
use_bias=use_bias))
self.model.add(BatchNorm(momentum=0.1, in_channels=ndf * nf_mult / 2, use_global_stats=istest))
#self.model.add(LeakyReLU(alpha=0.2))
self.model.add(Activation(activation='relu'))
for n in range(1, n_layers):
nf_mult = nf_mult / 2
self.model.add(Conv2DTranspose(channels=ndf * nf_mult / 2, kernel_size=kernel_size, strides=2,
padding=padding, in_channels=ndf * nf_mult,
use_bias=use_bias))
self.model.add(BatchNorm(momentum=0.1, in_channels=ndf * nf_mult / 2, use_global_stats=istest))
#self.model.add(LeakyReLU(alpha=0.2))
if n==2:
self.model.add(Dropout(rate=0.5))
self.model.add(Activation(activation='relu'))
self.model.add(Conv2DTranspose(channels=in_channels, kernel_size=kernel_size, strides=2,
padding=padding, in_channels=ndf))
#self.model.add(LeakyReLU(alpha=0.2))
self.model.add(Activation(activation='tanh'))
def __init__(self, in_channels, ndf=64, n_layers=3, use_bias=False):
super(CEGenerator, self).__init__()
with self.name_scope():
self.model = HybridSequential()
kernel_size = 4
padding = int(np.ceil((kernel_size - 1) / 2))
self.model.add(Conv2D(channels=ndf, kernel_size=kernel_size, strides=2,
padding=padding, in_channels=in_channels))
self.model.add(LeakyReLU(alpha=0.2))
nf_mult = 2;
nf_mult_prev = 1;
nf_mult = 1
for n in range(1, n_layers):
nf_mult_prev = nf_mult
nf_mult = 2 ** n
self.model.add(Conv2D(channels=ndf * nf_mult, kernel_size=kernel_size, strides=2,
padding=padding, in_channels=ndf * nf_mult_prev,
use_bias=use_bias))
self.model.add(BatchNorm(momentum=0.1, in_channels=ndf * nf_mult))
self.model.add(LeakyReLU(alpha=0.2))
nf_mult_prev = nf_mult
nf_mult = 2 ** n_layers
self.model.add(Conv2D(channels=ndf * nf_mult, kernel_size=kernel_size, strides=1,
padding=padding, in_channels=ndf * nf_mult_prev,
use_bias=use_bias))
self.model.add(BatchNorm(momentum=0.1, in_channels=ndf * nf_mult))
self.model.add(LeakyReLU(alpha=0.2))
# Decoder
self.model.add(Conv2DTranspose(channels=ndf * nf_mult / 2, kernel_size=kernel_size, strides=1,
padding=padding, in_channels=ndf * nf_mult,
use_bias=use_bias))
self.model.add(BatchNorm(momentum=0.1, in_channels=ndf * nf_mult / 2))
self.model.add(LeakyReLU(alpha=0.2))
for n in range(1, n_layers):
nf_mult = nf_mult / 2
self.model.add(Conv2DTranspose(channels=ndf * nf_mult / 2, kernel_size=kernel_size, strides=2,
padding=padding, in_channels=ndf * nf_mult,
use_bias=use_bias))
self.model.add(BatchNorm(momentum=0.1, in_channels=ndf * nf_mult / 2))
self.model.add(LeakyReLU(alpha=0.2))
self.model.add(Conv2DTranspose(channels=in_channels, kernel_size=kernel_size, strides=2,
padding=padding, in_channels=ndf))
self.model.add(LeakyReLU(alpha=0.2))
def __init__(self, count: int, depth: int) -> None:
super(Network, self).__init__()
self._count = count
self._depth = depth
with self.name_scope():
self.add(Conv2D(64, 4, 2, 1, in_channels=depth))
self.add(LeakyReLU(alpha=0.2))
layer = Identity(512, 512)
layer = Skip(512, 512, layer)
for _ in range(0):
layer = Skip(512, 512, layer)
layer.block.add(Dropout(0.5))
layer = Skip(256, 256, layer)
layer = Skip(128, 128, layer)
layer = Skip(64, 64, layer)
self.add(layer)
self.add(Conv2DTranspose(count, 4, 2, 1, in_channels=128))
self.add(Activation("sigmoid"))
for param in self.collect_params().values():
param.initialize()
if "bias" in param.name:
param.set_data(zeros(param.data().shape))
elif "gamma" in param.name:
param.set_data(random_normal(1, 0.02, param.data().shape))
elif "weight" in param.name:
param.set_data(random_normal(0, 0.02, param.data().shape))
def build_decoder_nn():
nnet = nn.HybridSequential()
nnet.add(
Conv2DTranspose(channels=1,
kernel_size=(5, 5),
strides=(2, 2),
output_padding=(1, 1)))
return nnet
def __init__(self,
innerblock=None,
outer_channels=32,
inner_channels=64,
use_bias=False):
super(middlelayer, self).__init__()
with self.name_scope():
res_block_1 = Res_Block(outer_channels=outer_channels)
res_block_2 = Res_Block(outer_channels=inner_channels)
en_conv = Conv2D(channels=inner_channels,
kernel_size=4,
strides=2,
padding=1,
in_channels=outer_channels,
use_bias=use_bias)
en_relu = LeakyReLU(alpha=0.2)
en_norm = BatchNorm(momentum=0.1, in_channels=inner_channels)
de_relu = Activation(activation='relu')
de_norm = BatchNorm(momentum=0.1, in_channels=outer_channels)
de_conv = Conv2DTranspose(channels=outer_channels,
kernel_size=4,
strides=2,
padding=1,
in_channels=inner_channels,
use_bias=use_bias)
self.p_at = CA_M5(in_channel=inner_channels)
self.c_at = CA_M4()
res_block_3 = Res_Block(outer_channels=inner_channels)
res_block_4 = Res_Block(outer_channels=outer_channels)
res1 = res_block_1
encoder = [en_conv, en_norm, en_relu]
res2 = res_block_2
res3 = res_block_3
decoder = [de_conv, de_norm, de_relu]
res4 = res_block_4
self.encoder = HybridSequential()
with self.encoder.name_scope():
for block in encoder:
self.encoder.add(block)
self.inner_block = innerblock
self.res1 = res1
self.res2 = res2
self.res3 = res3
self.res4 = res4
self.decoder = HybridSequential()
with self.decoder.name_scope():
for block in decoder:
self.decoder.add(block)
def __init__(self, inchannels, outchannels, **kwargs):
super(InceptionBlock, self).__init__(**kwargs)
self.inchannels = inchannels
self.outchannels = outchannels
with self.name_scope():
self.x5 = HybridSequential(prefix='x5-')
self.x5.add(
Conv2DTranspose(outchannels,
kernel_size=5,
strides=1,
padding=2), BatchNorm(), Activation('relu'))
self.x3 = HybridSequential(prefix='x3-')
self.x3.add(
Conv2DTranspose(outchannels,
kernel_size=3,
strides=1,
padding=1), BatchNorm(), Activation('relu'))
self.x1 = HybridSequential(prefix='x1-')
self.x1.add(Conv2D(outchannels, kernel_size=1, strides=1),
BatchNorm(), Activation('relu'))
def __init__(self, base=18,
deconv_channels=(256, 128, 64),
deconv_kernels=(4, 4, 4),
pretrained=True,
root=os.path.join(os.getcwd(), 'models'),
use_dcnv2=False,
ctx=mx.cpu()):
mxnet_version = float(mx.__version__[0:3])
if mxnet_version < 1.5:
logging.error("please upgrade mxnet version above 1.5.x")
raise EnvironmentError
super(UpConvResNet, self).__init__()
self._use_dcnv2 = use_dcnv2
self._resnet = get_resnet(base, pretrained=pretrained, root=root, ctx=ctx)
self._upconv = HybridSequential('')
with self._upconv.name_scope():
for channel, kernel in zip(deconv_channels, deconv_kernels):
kernel, padding, output_padding = self._get_conv_argument(kernel)
if self._use_dcnv2:
'''
in paper, we first change the channels of the three upsampling layers to
256, 128, 64, respectively, to save computation, we then add one 3 x 3 deformable convolutional layer
before each up-convolution layer with channel 256, 128, 64
'''
assert hasattr(contrib.cnn, 'ModulatedDeformableConvolution'), \
"No ModulatedDeformableConvolution found in mxnet, consider upgrade to mxnet 1.6.0..."
self._upconv.add(contrib.cnn.ModulatedDeformableConvolution(channels=channel,
kernel_size=3,
strides=1,
padding=1,
use_bias=False,
num_deformable_group=1))
else:
self._upconv.add(Conv2D(channels=channel,
kernel_size=3,
strides=1,
padding=1, use_bias=False))
self._upconv.add(BatchNorm(momentum=0.9))
self._upconv.add(Activation('relu'))
self._upconv.add(Conv2DTranspose(channels=channel,
kernel_size=kernel,
strides=2,
padding=padding,
output_padding=output_padding,
use_bias=False,
weight_initializer=mx.init.Bilinear()))
self._upconv.add(BatchNorm(momentum=0.9))
self._upconv.add(Activation('relu'))
self._upconv.initialize(ctx=ctx)
logging.info(f"{self.__class__.__name__} weight init 완료")
def __init__(self,in_channel, out_channel):
super(decoder,self).__init__()
with self.name_scope():
de_conv=Conv2DTranspose(channels=out_channel, kernel_size=4, strides=2, padding=1,
in_channels=in_channel)
norm = BatchNorm(momentum=0.1, in_channels=out_channel)
relu = LeakyReLU(alpha=0.2)
decode=[de_conv,norm,relu]
self.decoder = HybridSequential()
with self.decoder.name_scope():
for block in decode:
self.decoder.add(block)
def __init__(self, opts, num_filters, res_block=True, factor=1, group=1):
super(DecoderBlock, self).__init__()
self.dcblock = HybridSequential()
if res_block:
self.dcblock.add(ResDBlock(opts, num_filters * 4, group=group))
self.dcblock.add(BatchNorm(momentum=opts.bn_mom, epsilon=opts.bn_eps))
self.dcblock.add(Activation(opts.activation))
self.dcblock.add(
Conv2DTranspose(channels=int(num_filters / factor),
kernel_size=(2, 2),
strides=(2, 2),
padding=(0, 0),
use_bias=opts.use_bias))
def __init__(self, inner_channels, outer_channels, inner_block=None, innermost=False, outermost=False, use_dropout=False, use_bias=False):
super(UnetSkipUnit, self).__init__()
# 先定义一些基本的组件
self.outermost = outermost
en_conv = Conv2D(channels=inner_channels, kernel_size=4, strides=2, padding=1, in_channels=outer_channels, use_bias=use_bias)
en_relu = LeakyReLU(alpha=0.2)
en_bn = BatchNorm(momentum=0.1, in_channels=inner_channels)
deconv_innermost = Conv2DTranspose(
channels=outer_channels, kernel_size=4, strides=2, padding=1, in_channels=inner_channels, use_bias=use_bias)
deconv_output = Conv2DTranspose(
channels=outer_channels, kernel_size=4, strides=2, padding=1, in_channels=2*inner_channels, use_bias=True)
deconv_common = de_conv_innermost = Conv2DTranspose(
channels=outer_channels, kernel_size=4, strides=2, padding=1, in_channels=2*inner_channels, use_bias=use_bias)
de_relu = Activation('relu')
de_bn = BatchNorm(momentum=0.1, in_channels=outer_channels)
# Unet网络块可以分为三种：最里面的，中间的，最外面的。
if innermost:
encoder = [en_relu, en_conv]
decoder = [de_relu, deconv_innermost, de_bn]
model = encoder + decoder
elif outermost:
encoder = [en_conv]
decoder = [de_relu, deconv_output]
model = encoder + [inner_block] + decoder
model += [Activation('tanh')]
else:
encoder = [en_relu, en_conv, en_bn]
decoder = [de_relu, deconv_common, de_bn]
model = encoder + [inner_block] + decoder
if use_dropout:
model += [Dropout(0.5)]
self.model = nn.HybridSequential()
with self.model.name_scope():
for block in model:
self.model.add(block)
def __init__(self, count: int, depth: int, layer: Layer) -> None:
super(Skip, self).__init__()
with self.name_scope():
self._block = HybridSequential()
self._block.add(Conv2D(layer.depth, 4, 2, 1, use_bias=False, in_channels=depth))
self._block.add(BatchNorm(momentum=0.1, in_channels=layer.depth))
self._block.add(LeakyReLU(0.2))
self._block.add(layer)
self._block.add(Conv2DTranspose(count, 4, 2, 1, use_bias=False, in_channels=layer.count))
self._block.add(BatchNorm(momentum=0.1, in_channels=count))
self._count = count
self._depth = depth
self._layer = layer
def __init__(self, innerblock=None):
super(outerpart, self).__init__()
with self.name_scope():
en_conv1 = Conv2D(channels=32,
kernel_size=4,
strides=2,
padding=1,
in_channels=3)
en_relu1 = LeakyReLU(alpha=0.2)
en_norm1 = BatchNorm(momentum=0.1,
in_channels=32,
prefix='en_norm1')
de_relu1 = Activation(activation='relu')
de_norm1 = BatchNorm(momentum=0.1,
in_channels=3,
prefix='de_norm1')
de_conv1 = Conv2DTranspose(channels=3,
kernel_size=4,
strides=2,
padding=1,
in_channels=32)
channel_trans = Conv2D(channels=1,
in_channels=3,
kernel_size=1,
prefix='')
encoder1 = [en_conv1, en_norm1, en_relu1]
decoder1 = [de_conv1, de_norm1, de_relu1, channel_trans]
self.encoder1 = HybridSequential()
with self.encoder1.name_scope():
for block in encoder1:
self.encoder1.add(block)
self.innerblock = innerblock
self.decoder1 = HybridSequential()
with self.decoder1.name_scope():
for block in decoder1:
self.decoder1.add(block)
def __init__(
self,
dir_list,
width=28,
height=28,
channel=1,
initializer=None,
batch_size=40,
learning_rate=1e-03,
ctx=mx.gpu(),
discriminative_model=None,
generative_model=None,
):
'''
Init.
If you are not satisfied with this simple default setting,
delegate `discriminative_model` and `generative_model` designed by yourself.
Args:
dir_list: `list` of `str` of path to image files.
width: `int` of image width.
height: `int` of image height.
channel: `int` of image channel.
initializer: is-a `mxnet.initializer` for parameters of model.
If `None`, it is drawing from the Xavier distribution.
batch_size: `int` of batch size.
learning_rate: `float` of learning rate.
ctx: `mx.gpu()` or `mx.cpu()`.
discriminative_model: is-a `accelbrainbase.observabledata._mxnet.adversarialmodel.discriminative_model.DiscriminativeModel`.
generative_model: is-a `accelbrainbase.observabledata._mxnet.adversarialmodel.generative_model.GenerativeModel`.
'''
image_extractor = ImageExtractor(
width=width,
height=height,
channel=channel,
ctx=ctx
)
unlabeled_image_iterator = UnlabeledImageIterator(
image_extractor=image_extractor,
dir_list=dir_list,
batch_size=batch_size,
norm_mode="z_score",
scale=1.0,
noiseable_data=GaussNoise(sigma=1e-03, mu=0.0),
)
true_sampler = TrueSampler()
true_sampler.iteratorable_data = unlabeled_image_iterator
condition_sampler = ConditionSampler()
condition_sampler.true_sampler = true_sampler
computable_loss = L2NormLoss()
if discriminative_model is None:
output_nn = NeuralNetworks(
computable_loss=computable_loss,
initializer=initializer,
learning_rate=learning_rate,
learning_attenuate_rate=1.0,
attenuate_epoch=50,
units_list=[100, 1],
dropout_rate_list=[0.5, 0.0],
optimizer_name="SGD",
activation_list=["relu", "sigmoid"],
hidden_batch_norm_list=[BatchNorm(), None],
ctx=ctx,
hybridize_flag=True,
regularizatable_data_list=[],
scale=1.0,
output_no_bias_flag=True,
all_no_bias_flag=True,
not_init_flag=False,
)
d_model = ConvolutionalNeuralNetworks(
computable_loss=computable_loss,
initializer=initializer,
learning_rate=learning_rate,
learning_attenuate_rate=1.0,
attenuate_epoch=50,
hidden_units_list=[
Conv2D(
channels=16,
kernel_size=6,
strides=(2, 2),
padding=(1, 1),
),
Conv2D(
channels=32,
kernel_size=3,
strides=(2, 2),
padding=(1, 1),
),
],
input_nn=None,
input_result_height=None,
input_result_width=None,
input_result_channel=None,
output_nn=output_nn,
hidden_dropout_rate_list=[0.5, 0.5],
hidden_batch_norm_list=[BatchNorm(), BatchNorm()],
optimizer_name="SGD",
hidden_activation_list=["relu", "relu"],
hidden_residual_flag=False,
hidden_dense_flag=False,
dense_axis=1,
ctx=ctx,
hybridize_flag=True,
regularizatable_data_list=[],
scale=1.0,
)
discriminative_model = DiscriminativeModel(
model=d_model,
initializer=None,
learning_rate=learning_rate,
optimizer_name="SGD",
hybridize_flag=True,
scale=1.0,
ctx=ctx,
)
else:
if isinstance(discriminative_model, DiscriminativeModel) is False:
raise TypeError("The type of `discriminative_model` must be `DiscriminativeModel`.")
if generative_model is None:
g_model = ConvolutionalNeuralNetworks(
computable_loss=computable_loss,
initializer=initializer,
learning_rate=learning_rate,
learning_attenuate_rate=1.0,
attenuate_epoch=50,
hidden_units_list=[
Conv2DTranspose(
channels=16,
kernel_size=6,
strides=(1, 1),
padding=(1, 1),
),
Conv2DTranspose(
channels=1,
kernel_size=3,
strides=(1, 1),
padding=(1, 1),
),
],
input_nn=None,
input_result_height=None,
input_result_width=None,
input_result_channel=None,
output_nn=None,
hidden_dropout_rate_list=[0.5, 0.0],
hidden_batch_norm_list=[BatchNorm(), None],
optimizer_name="SGD",
hidden_activation_list=["relu", "identity"],
hidden_residual_flag=False,
hidden_dense_flag=False,
dense_axis=1,
ctx=ctx,
hybridize_flag=True,
regularizatable_data_list=[],
scale=1.0,
)
generative_model = GenerativeModel(
noise_sampler=UniformNoiseSampler(
low=-1e-05,
high=1e-05,
batch_size=batch_size,
seq_len=0,
channel=channel,
height=height,
width=width,
ctx=ctx
),
model=g_model,
initializer=None,
condition_sampler=condition_sampler,
conditonal_dim=1,
learning_rate=learning_rate,
optimizer_name="SGD",
hybridize_flag=True,
scale=1.0,
ctx=ctx,
)
else:
if isinstance(generative_model, GenerativeModel) is False:
raise TypeError("The type of `generative_model` must be `GenerativeModel`.")
GAN = GANController(
true_sampler=true_sampler,
generative_model=generative_model,
discriminative_model=discriminative_model,
generator_loss=GeneratorLoss(weight=1.0),
discriminator_loss=DiscriminatorLoss(weight=1.0),
feature_matching_loss=L2NormLoss(weight=1.0),
optimizer_name="SGD",
learning_rate=learning_rate,
learning_attenuate_rate=1.0,
attenuate_epoch=50,
hybridize_flag=True,
scale=1.0,
ctx=ctx,
initializer=initializer,
)
self.GAN = GAN
def __init__(
self,
midi_path_list,
batch_size=20,
seq_len=8,
time_fraction=1.0,
learning_rate=1e-10,
learning_attenuate_rate=0.1,
attenuate_epoch=50,
generative_model=None,
discriminative_model=None,
ctx=mx.gpu(),
initializer=None,
):
'''
Init.
Args:
midi_path_list: `list` of paths to MIDI files.
batch_size: Batch size.
seq_len: The length of sequence that LSTM networks will observe.
time_fraction: Time fraction or time resolution (seconds).
learning_rate: Learning rate in `Generator` and `Discriminator`.
learning_attenuate_rate: Attenuate the `learning_rate` by a factor of this value every `attenuate_epoch`.
attenuate_epoch: Attenuate the `learning_rate` by a factor of `learning_attenuate_rate` every `attenuate_epoch`.
true_sampler: is-a `TrueSampler`.
noise_sampler: is-a `NoiseSampler`.
generative_model: is-a `GenerativeModel`.
discriminative_model: is-a `DiscriminativeModel`.
ctx: `mx.cpu()` or `mx.gpu()`.
initializer: is-a `mxnet.initializer` for parameters of model. If `None`, it is drawing from the Xavier distribution.
'''
computable_loss = mx.gluon.loss.SoftmaxCrossEntropyLoss(
sparse_label=False)
self.__midi_controller = MidiController()
self.__midi_df_list = [
self.__midi_controller.extract(midi_path)
for midi_path in midi_path_list
]
bar_gram = BarGram(midi_df_list=self.__midi_df_list,
time_fraction=time_fraction)
self.__bar_gram = bar_gram
dim = self.__bar_gram.dim
c_true_sampler = ConditionalBarGramTrueSampler(
bar_gram=bar_gram,
midi_df_list=self.__midi_df_list,
batch_size=batch_size,
seq_len=seq_len,
time_fraction=time_fraction)
true_sampler = BarGramTrueSampler(bar_gram=bar_gram,
midi_df_list=self.__midi_df_list,
batch_size=batch_size,
seq_len=seq_len,
time_fraction=time_fraction)
if generative_model is None:
condition_sampler = ConditionSampler()
condition_sampler.true_sampler = true_sampler
c_model = ConvolutionalNeuralNetworks(
computable_loss=computable_loss,
initializer=initializer,
learning_rate=learning_rate,
learning_attenuate_rate=1.0,
attenuate_epoch=50,
hidden_units_list=[
Conv2D(
channels=16,
kernel_size=6,
strides=(1, 1),
padding=(1, 1),
),
Conv2D(
channels=len(true_sampler.program_list),
kernel_size=6,
strides=(1, 1),
padding=(1, 1),
),
],
input_nn=None,
input_result_height=None,
input_result_width=None,
input_result_channel=None,
output_nn=None,
hidden_dropout_rate_list=[0.5, 0.0],
hidden_batch_norm_list=[BatchNorm(), None],
optimizer_name="SGD",
hidden_activation_list=["relu", "identity"],
hidden_residual_flag=False,
hidden_dense_flag=False,
dense_axis=1,
ctx=ctx,
hybridize_flag=True,
regularizatable_data_list=[],
scale=1.0,
)
condition_sampler.model = c_model
g_model = ConvolutionalNeuralNetworks(
computable_loss=computable_loss,
initializer=initializer,
learning_rate=learning_rate,
learning_attenuate_rate=1.0,
attenuate_epoch=50,
hidden_units_list=[
Conv2DTranspose(
channels=16,
kernel_size=6,
strides=(1, 1),
padding=(1, 1),
),
Conv2DTranspose(
channels=len(true_sampler.program_list),
kernel_size=6,
strides=(1, 1),
padding=(1, 1),
),
],
input_nn=None,
input_result_height=None,
input_result_width=None,
input_result_channel=None,
output_nn=None,
hidden_dropout_rate_list=[0.5, 0.0],
hidden_batch_norm_list=[BatchNorm(), None],
optimizer_name="SGD",
hidden_activation_list=["relu", "identity"],
hidden_residual_flag=False,
hidden_dense_flag=False,
dense_axis=1,
ctx=ctx,
hybridize_flag=True,
regularizatable_data_list=[],
scale=1.0,
)
generative_model = GenerativeModel(
noise_sampler=None,
model=g_model,
initializer=None,
condition_sampler=condition_sampler,
conditonal_dim=1,
learning_rate=learning_rate,
optimizer_name="SGD",
hybridize_flag=True,
scale=1.0,
ctx=ctx,
)
else:
if isinstance(generative_model, GenerativeModel) is False:
raise TypeError(
"The type of `generative_model` must be `GenerativeModel`."
)
if discriminative_model is None:
output_nn = NeuralNetworks(
computable_loss=computable_loss,
initializer=initializer,
learning_rate=learning_rate,
learning_attenuate_rate=1.0,
attenuate_epoch=50,
units_list=[100, 1],
dropout_rate_list=[0.5, 0.0],
optimizer_name="SGD",
activation_list=["relu", "sigmoid"],
hidden_batch_norm_list=[BatchNorm(), None],
ctx=ctx,
hybridize_flag=True,
regularizatable_data_list=[],
scale=1.0,
output_no_bias_flag=True,
all_no_bias_flag=True,
not_init_flag=False,
)
d_model = ConvolutionalNeuralNetworks(
computable_loss=computable_loss,
initializer=initializer,
learning_rate=learning_rate,
learning_attenuate_rate=1.0,
attenuate_epoch=50,
hidden_units_list=[
Conv2D(
channels=16,
kernel_size=6,
strides=(2, 2),
padding=(1, 1),
),
Conv2D(
channels=32,
kernel_size=3,
strides=(2, 2),
padding=(1, 1),
),
],
input_nn=None,
input_result_height=None,
input_result_width=None,
input_result_channel=None,
output_nn=output_nn,
hidden_dropout_rate_list=[0.5, 0.5],
hidden_batch_norm_list=[BatchNorm(), BatchNorm()],
optimizer_name="SGD",
hidden_activation_list=["relu", "relu"],
hidden_residual_flag=False,
hidden_dense_flag=False,
dense_axis=1,
ctx=ctx,
hybridize_flag=True,
regularizatable_data_list=[],
scale=1.0,
)
discriminative_model = DiscriminativeModel(
model=d_model,
initializer=None,
learning_rate=learning_rate,
optimizer_name="SGD",
hybridize_flag=True,
scale=1.0,
ctx=ctx,
)
else:
if isinstance(discriminative_model, DiscriminativeModel) is False:
raise TypeError(
"The type of `discriminative_model` must be `DiscriminativeModel`."
)
GAN = GANController(
true_sampler=c_true_sampler,
generative_model=generative_model,
discriminative_model=discriminative_model,
generator_loss=GeneratorLoss(weight=1.0),
discriminator_loss=DiscriminatorLoss(weight=1.0),
feature_matching_loss=L2NormLoss(weight=1.0),
optimizer_name="SGD",
learning_rate=learning_rate,
learning_attenuate_rate=1.0,
attenuate_epoch=50,
hybridize_flag=True,
scale=1.0,
ctx=ctx,
initializer=initializer,
)
self.__true_sampler = true_sampler
self.__generative_model = generative_model
self.__discriminative_model = discriminative_model
self.__GAN = GAN
self.__time_fraction = time_fraction
def __init__(self,
inner_channels,
outer_channels,
inner_block=None,
innermost=False,
outermost=False,
use_dropout=False,
use_bias=False,
use_attention=True,
use_resblock=True,
use_p_at=False,
use_c_at=False,
save_att=False):
super(UnetSkipUnit, self).__init__()
with self.name_scope():
self.save_att = save_att
self.outermost = outermost
self.innermost = innermost
self.use_attention = use_attention
if not self.outermost:
res_block_1 = Res_Block(outer_channels=outer_channels)
res_block_2 = Res_Block(outer_channels=inner_channels)
en_conv = Conv2D(channels=inner_channels,
kernel_size=4,
strides=2,
padding=1,
in_channels=outer_channels,
use_bias=use_bias)
en_relu = LeakyReLU(alpha=0.2)
en_norm = BatchNorm(momentum=0.1, in_channels=inner_channels)
de_relu = Activation(activation='relu')
de_norm = BatchNorm(momentum=0.1, in_channels=outer_channels)
if innermost:
de_conv = Conv2DTranspose(channels=outer_channels,
kernel_size=4,
strides=2,
padding=1,
in_channels=inner_channels,
use_bias=use_bias)
if use_p_at:
self.p_at = CA_M2(in_channel=inner_channels)
else:
self.p_at = CA_M3()
if use_c_at:
self.c_at = CA_M1()
else:
self.c_at = CA_M3()
res_block_3 = Res_Block(outer_channels=inner_channels)
res_block_4 = Res_Block(outer_channels=outer_channels)
if use_resblock:
res1 = res_block_1
encoder = [en_conv, en_norm, en_relu]
res2 = res_block_2
res3 = res_block_3
decoder = [de_conv, de_norm, de_relu]
res4 = res_block_4
else:
encoder = [en_relu, en_conv]
decoder = [de_relu, de_conv, de_norm]
elif outermost:
de_conv = Conv2DTranspose(channels=outer_channels,
kernel_size=4,
strides=2,
padding=1,
in_channels=inner_channels)
channel_trans = Conv2D(channels=1,
in_channels=outer_channels,
kernel_size=1,
prefix='')
if use_resblock:
res1 = None
encoder = [en_conv, en_norm, en_relu]
res2 = None
res3 = None
decoder = [de_conv, de_norm, de_relu, channel_trans]
res4 = None
else:
encoder = [en_conv]
decoder = [de_relu, de_conv, de_norm, channel_trans]
if use_p_at:
self.p_at = CA_M2(in_channel=inner_channels)
else:
self.p_at = CA_M3()
if use_c_at:
self.c_at = CA_M1()
else:
self.c_at = CA_M3()
else:
de_conv = Conv2DTranspose(channels=outer_channels,
kernel_size=4,
strides=2,
padding=1,
in_channels=inner_channels,
use_bias=use_bias)
if use_p_at:
self.p_at = CA_M2(in_channel=inner_channels)
else:
self.p_at = CA_M3()
if use_c_at:
self.c_at = CA_M1()
else:
self.c_at = CA_M3()
res_block_3 = Res_Block(outer_channels=inner_channels)
res_block_4 = Res_Block(outer_channels=outer_channels)
if use_resblock:
res1 = res_block_1
encoder = [en_conv, en_norm, en_relu]
res2 = res_block_2
res3 = res_block_3
decoder = [de_conv, de_norm, de_relu]
res4 = res_block_4
else:
encoder = [en_relu, en_conv, en_norm]
decoder = [de_relu, de_conv, de_norm]
if use_dropout:
decoder += [Dropout(rate=0.5)]
self.encoder = HybridSequential()
with self.encoder.name_scope():
for block in encoder:
self.encoder.add(block)
self.inner_block = inner_block
self.res1 = res1
self.res2 = res2
self.res3 = res3
self.res4 = res4
self.decoder = HybridSequential()
with self.decoder.name_scope():
for block in decoder:
self.decoder.add(block)
def __init__(
self,
Darknetlayer=53,
input_size=(416, 416),
anchors={
"shallow": [(10, 13), (16, 30), (33, 23)],
"middle": [(30, 61), (62, 45), (59, 119)],
"deep": [(116, 90), (156, 198), (373, 326)]
},
num_classes=1, # foreground만
pretrained=True,
pretrained_path="modelparam",
alloc_size=(64, 64),
ctx=mx.cpu()):
super(Yolov3, self).__init__()
if Darknetlayer not in [53]:
raise ValueError
in_height, in_width = input_size
features = []
strides = []
anchors = OrderedDict(anchors)
anchors = list(anchors.values())[::-1]
self._numoffst = len(anchors)
darknet_output = get_darknet(Darknetlayer, ctx=mx.cpu(), dummy=True)(
mx.nd.random_uniform(low=0,
high=1,
shape=(1, 3, in_height, in_width),
ctx=mx.cpu()))
for out in darknet_output: # feature_14, feature_24, feature_28
out_height, out_width = out.shape[2:]
features.append([out_width, out_height])
strides.append([in_width // out_width,
in_height // out_height]) # w, h
features = features[::-1]
strides = strides[::-1] # deep -> middle -> shallow 순으로 !!!
self._darkenet = get_darknet(Darknetlayer,
pretrained=pretrained,
ctx=ctx,
root=pretrained_path)
self._num_classes = num_classes
self._num_pred = 5 + num_classes # 고정
with self.name_scope():
head_init_num_channel = 512
trans_init_num_channel = 256
self._head = HybridSequential()
self._transition = HybridSequential()
self._upsampleconv = HybridSequential()
self._anchor_generators = HybridSequential()
# output
for j in range(len(anchors)):
if j == 0:
factor = 1
else:
factor = 2
head_init_num_channel = head_init_num_channel // factor
for _ in range(3):
self._head.add(
Conv2D(channels=head_init_num_channel,
kernel_size=(1, 1),
strides=(1, 1),
padding=(0, 0),
use_bias=True,
in_channels=0,
weight_initializer=mx.init.Normal(0.01),
bias_initializer='zeros'))
self._head.add(BatchNorm(epsilon=1e-5, momentum=0.9))
self._head.add(LeakyReLU(0.1))
self._head.add(
Conv2D(channels=head_init_num_channel * 2,
kernel_size=(3, 3),
strides=(1, 1),
padding=(1, 1),
use_bias=True,
in_channels=0,
weight_initializer=mx.init.Normal(0.01),
bias_initializer='zeros'))
self._head.add(BatchNorm(epsilon=1e-5, momentum=0.9))
self._head.add(LeakyReLU(0.1))
self._head.add(
Conv2D(channels=len(anchors[j]) * self._num_pred,
kernel_size=(1, 1),
strides=(1, 1),
padding=(0, 0),
use_bias=True,
in_channels=0,
weight_initializer=mx.init.Normal(0.01),
bias_initializer='zeros'))
# for upsample - transition
for i in range(len(anchors) - 1):
if i == 0:
factor = 1
else:
factor = 2
trans_init_num_channel = trans_init_num_channel // factor
self._transition.add(
Conv2D(channels=trans_init_num_channel,
kernel_size=(1, 1),
strides=(1, 1),
padding=(0, 0),
use_bias=True,
in_channels=0,
weight_initializer=mx.init.Normal(0.01),
bias_initializer='zeros'))
self._transition.add(BatchNorm(epsilon=1e-5, momentum=0.9))
self._transition.add(LeakyReLU(0.1))
# for deconvolution upsampleing
for i in range(len(anchors) - 1):
if i == 0:
factor = 1
else:
factor = 2
trans_init_num_channel = trans_init_num_channel // factor
self._upsampleconv.add(
Conv2DTranspose(trans_init_num_channel,
kernel_size=3,
strides=2,
padding=1,
output_padding=1,
use_bias=True,
in_channels=0))
self._upsampleconv.add(BatchNorm(epsilon=1e-5, momentum=0.9))
self._upsampleconv.add(LeakyReLU(0.1))
for i, anchor, feature, stride in zip(range(len(anchors)), anchors,
features, strides):
self._anchor_generators.add(
YoloAnchorGenerator(i, anchor, feature, stride,
(alloc_size[0] * (2**i), alloc_size[1] *
(2**i))))
self._head.initialize(ctx=ctx)
self._transition.initialize(ctx=ctx)
self._upsampleconv.initialize(ctx=ctx)
self._anchor_generators.initialize(ctx=ctx)
logging.info(f"{self.__class__.__name__} Head weight init 완료")
def __init__(
self,
dir_list,
test_dir_list,
width=28,
height=28,
channel=1,
initializer=None,
batch_size=40,
learning_rate=0.0002,
ctx=mx.gpu(),
discriminative_model=None,
generative_model=None,
re_encoder_model=None,
):
'''
Init.
If you are not satisfied with this simple default setting,
delegate `discriminative_model` and `generative_model` designed by yourself.
Args:
dir_list: `list` of `str` of path to image files.
test_dir_list: `list` of `str` of path to image files for test.
width: `int` of image width.
height: `int` of image height.
channel: `int` of image channel.
initializer: is-a `mxnet.initializer` for parameters of model.
If `None`, it is drawing from the Xavier distribution.
batch_size: `int` of batch size.
learning_rate: `float` of learning rate.
ctx: `mx.gpu()` or `mx.cpu()`.
discriminative_model: is-a `accelbrainbase.observabledata._mxnet.adversarialmodel.discriminative_model.DiscriminativeModel`.
generative_model: is-a `accelbrainbase.observabledata._mxnet.adversarialmodel.generative_model.GenerativeModel`.
re_encoder_model: is-a `HybridBlock`.
'''
image_extractor = ImageExtractor(width=width,
height=height,
channel=channel,
ctx=ctx)
unlabeled_image_iterator = UnlabeledImageIterator(
image_extractor=image_extractor,
dir_list=dir_list,
batch_size=batch_size,
norm_mode="z_score",
scale=1 / 1000,
noiseable_data=GaussNoise(sigma=1e-08, mu=0.0),
)
test_unlabeled_image_iterator = UnlabeledImageIterator(
image_extractor=image_extractor,
dir_list=test_dir_list,
batch_size=batch_size,
norm_mode="z_score",
scale=1 / 1000,
noiseable_data=GaussNoise(sigma=1e-08, mu=0.0),
)
true_sampler = TrueSampler()
true_sampler.iteratorable_data = unlabeled_image_iterator
condition_sampler = ConditionSampler()
condition_sampler.true_sampler = true_sampler
computable_loss = L2NormLoss()
if discriminative_model is None:
output_nn = NeuralNetworks(
computable_loss=computable_loss,
initializer=initializer,
learning_rate=learning_rate,
learning_attenuate_rate=1.0,
attenuate_epoch=50,
units_list=[1],
dropout_rate_list=[0.0],
optimizer_name="SGD",
activation_list=["sigmoid"],
hidden_batch_norm_list=[None],
ctx=ctx,
hybridize_flag=True,
regularizatable_data_list=[],
scale=1.0,
output_no_bias_flag=True,
all_no_bias_flag=True,
not_init_flag=False,
)
d_model = ConvolutionalNeuralNetworks(
computable_loss=computable_loss,
initializer=initializer,
learning_rate=learning_rate,
learning_attenuate_rate=1.0,
attenuate_epoch=50,
hidden_units_list=[
Conv2D(
channels=16,
kernel_size=6,
strides=(2, 2),
padding=(1, 1),
),
Conv2D(
channels=32,
kernel_size=3,
strides=(2, 2),
padding=(1, 1),
),
],
input_nn=None,
input_result_height=None,
input_result_width=None,
input_result_channel=None,
output_nn=output_nn,
hidden_dropout_rate_list=[
0.5,
0.5,
],
hidden_batch_norm_list=[BatchNorm(), BatchNorm()],
optimizer_name="SGD",
hidden_activation_list=[
"relu",
"relu",
],
hidden_residual_flag=False,
hidden_dense_flag=False,
dense_axis=1,
ctx=ctx,
hybridize_flag=True,
regularizatable_data_list=[],
scale=1.0,
)
discriminative_model = DiscriminativeModel(
model=d_model,
initializer=None,
learning_rate=learning_rate,
optimizer_name="SGD",
hybridize_flag=True,
scale=1.0,
ctx=ctx,
)
else:
if isinstance(discriminative_model, DiscriminativeModel) is False:
raise TypeError(
"The type of `discriminative_model` must be `DiscriminativeModel`."
)
if re_encoder_model is None:
re_encoder_model = ConvolutionalNeuralNetworks(
# is-a `ComputableLoss` or `mxnet.gluon.loss`.
computable_loss=computable_loss,
# `list` of int` of the number of units in hidden layers.
hidden_units_list=[
# `mxnet.gluon.nn.Conv2D`.
Conv2D(
channels=16,
kernel_size=6,
strides=(2, 2),
padding=(1, 1),
),
Conv2D(
channels=32,
kernel_size=6,
strides=(2, 2),
padding=(1, 1),
),
],
# `list` of act_type` in `mxnet.ndarray.Activation` or `mxnet.symbol.Activation` in input gate.
hidden_activation_list=[
"relu",
"relu",
],
# `list` of `float` of dropout rate.
hidden_dropout_rate_list=[
0.5,
0.5,
],
# `list` of `mxnet.gluon.nn.BatchNorm`.
hidden_batch_norm_list=[BatchNorm(), BatchNorm()],
# Call `mxnet.gluon.HybridBlock.hybridize()` or not.
hybridize_flag=True,
# `mx.gpu()` or `mx.cpu()`.
ctx=ctx,
)
if generative_model is None:
encoder = ConvolutionalNeuralNetworks(
# is-a `ComputableLoss` or `mxnet.gluon.loss`.
computable_loss=computable_loss,
# `list` of int` of the number of units in hidden layers.
hidden_units_list=[
# `mxnet.gluon.nn.Conv2D`.
Conv2D(
channels=16,
kernel_size=6,
strides=(2, 2),
padding=(1, 1),
),
Conv2D(
channels=32,
kernel_size=6,
strides=(2, 2),
padding=(1, 1),
),
],
# `list` of act_type` in `mxnet.ndarray.Activation` or `mxnet.symbol.Activation` in input gate.
hidden_activation_list=[
"relu",
"relu",
],
# `list` of `float` of dropout rate.
hidden_dropout_rate_list=[
0.5,
0.5,
],
# `list` of `mxnet.gluon.nn.BatchNorm`.
hidden_batch_norm_list=[BatchNorm(), BatchNorm()],
# Call `mxnet.gluon.HybridBlock.hybridize()` or not.
hybridize_flag=True,
# `mx.gpu()` or `mx.cpu()`.
ctx=ctx,
)
decoder = ConvolutionalNeuralNetworks(
# is-a `ComputableLoss` or `mxnet.gluon.loss`.
computable_loss=computable_loss,
# `list` of int` of the number of units in hidden layers.
hidden_units_list=[
Conv2DTranspose(
channels=16,
kernel_size=6,
strides=(2, 2),
padding=(1, 1),
),
Conv2DTranspose(
channels=channel,
kernel_size=6,
strides=(2, 2),
padding=(0, 0),
),
],
# `list` of act_type` in `mxnet.ndarray.Activation` or `mxnet.symbol.Activation` in input gate.
hidden_activation_list=["relu", "tanh"],
# `list` of `float` of dropout rate.
hidden_dropout_rate_list=[0.5, 0.0],
# `list` of `mxnet.gluon.nn.BatchNorm`.
hidden_batch_norm_list=[BatchNorm(), None],
# Call `mxnet.gluon.HybridBlock.hybridize()` or not.
hybridize_flag=True,
# `mx.gpu()` or `mx.cpu()`.
ctx=ctx,
)
g_model = ConvolutionalAutoEncoder(
# is-a `ConvolutionalNeuralNetworks`.
encoder=encoder,
# is-a `ConvolutionalNeuralNetworks`.
decoder=decoder,
computable_loss=computable_loss,
initializer=initializer,
learning_rate=learning_rate,
learning_attenuate_rate=1.0,
attenuate_epoch=50,
input_nn=None,
input_result_height=None,
input_result_width=None,
input_result_channel=None,
output_nn=None,
optimizer_name="SGD",
hidden_residual_flag=False,
hidden_dense_flag=False,
dense_axis=1,
ctx=ctx,
hybridize_flag=True,
regularizatable_data_list=[],
scale=1.0,
)
generative_model = GenerativeModel(
noise_sampler=UniformNoiseSampler(low=-1e-05,
high=1e-05,
batch_size=batch_size,
seq_len=0,
channel=channel,
height=height,
width=width,
ctx=ctx),
model=g_model,
initializer=None,
condition_sampler=condition_sampler,
conditonal_dim=1,
learning_rate=learning_rate,
optimizer_name="SGD",
hybridize_flag=True,
scale=1.0,
ctx=ctx,
)
else:
if isinstance(generative_model, GenerativeModel) is False:
raise TypeError(
"The type of `generative_model` must be `GenerativeModel`."
)
ganomaly_controller = GanomalyController(
generative_model=generative_model,
re_encoder_model=re_encoder_model,
discriminative_model=discriminative_model,
advarsarial_loss=L2NormLoss(weight=0.015),
encoding_loss=L2NormLoss(weight=0.015),
contextual_loss=L1Loss(weight=0.5),
discriminator_loss=DiscriminatorLoss(weight=0.015),
feature_matching_loss=None,
optimizer_name="SGD",
learning_rate=learning_rate,
learning_attenuate_rate=1.0,
attenuate_epoch=50,
hybridize_flag=True,
scale=1.0,
ctx=ctx,
initializer=initializer,
)
self.ganomaly_controller = ganomaly_controller
self.test_unlabeled_image_iterator = test_unlabeled_image_iterator
def __init__(self,
inner_channels,
outer_channels,
inner_block=None,
innermost=False,
outermost=False,
use_dropout=False,
use_bias=False,
use_attention=True,
use_resblock=True):
super(UnetSkipUnit, self).__init__()
with self.name_scope():
self.outermost = outermost
self.innermost = innermost
self.use_attention = use_attention
res_block = Res_Block(outer_channels=outer_channels)
en_conv = Conv2D(channels=inner_channels,
kernel_size=4,
strides=2,
padding=1,
in_channels=outer_channels,
use_bias=use_bias)
en_relu = LeakyReLU(alpha=0.2)
en_norm = BatchNorm(momentum=0.1, in_channels=inner_channels)
de_relu = Activation(activation='relu')
de_norm = BatchNorm(momentum=0.1, in_channels=outer_channels)
if innermost:
de_conv = Conv2DTranspose(channels=outer_channels,
kernel_size=4,
strides=2,
padding=1,
in_channels=inner_channels,
use_bias=use_bias)
res_block1 = Res_Block(outer_channels=inner_channels)
if use_resblock:
encoder = [res_block, en_relu, en_conv]
decoder = [de_relu, res_block1, de_conv, de_norm]
else:
encoder = [en_relu, en_conv]
decoder = [de_relu, de_conv, de_norm]
attention = self_attention_block(in_channel=inner_channels)
model = encoder
elif outermost:
de_conv = Conv2DTranspose(channels=outer_channels,
kernel_size=4,
strides=2,
padding=1,
in_channels=inner_channels * 2)
res_block1 = Res_Block(outer_channels=inner_channels * 2)
if use_resblock:
encoder = [res_block, en_conv]
decoder = [
de_relu, res_block1, de_conv,
Activation(activation='tanh')
]
else:
encoder = [en_conv]
decoder = [de_relu, de_conv, Activation(activation='tanh')]
attention = self_attention_block(in_channel=inner_channels * 2)
model = encoder + [inner_block]
else:
de_conv = Conv2DTranspose(channels=outer_channels,
kernel_size=4,
strides=2,
padding=1,
in_channels=inner_channels * 2,
use_bias=use_bias)
res_block1 = Res_Block(outer_channels=inner_channels * 2)
if use_resblock:
encoder = [res_block, en_relu, en_conv, en_norm]
decoder = [de_relu, res_block1, de_conv, de_norm]
else:
encoder = [en_relu, en_conv, en_norm]
decoder = [de_relu, de_conv, de_norm]
attention = self_attention_block(in_channel=inner_channels * 2)
model = encoder + [inner_block]
if use_dropout:
decoder += [Dropout(rate=0.5)]
self.encoder = HybridSequential()
with self.encoder.name_scope():
for block in model:
self.encoder.add(block)
self.inner_block = inner_block
self.attention = attention
self.decoder = HybridSequential()
with self.decoder.name_scope():
for block in decoder:
self.decoder.add()
return d_iter
batch_size = 256
train_iter, test_iter = d2l.load_data_mnist(batch_size=1)
train_iter = blendData(train_iter, imgs)
test_iter = blendData(test_iter, imgs)
num_classes = 2
net = HybridSequential()
net.add(Conv2D(channels=3, kernel_size=5, activation='sigmoid'),
MaxPool2D(pool_size=2, strides=2),
Conv2D(channels=8, kernel_size=5, activation='sigmoid'),
MaxPool2D(pool_size=2, strides=2),
Conv2D(channels=120, kernel_size=4, activation='sigmoid'),
Conv2D(channels=84, kernel_size=1, activation='sigmoid'),
Conv2D(channels=10, kernel_size=1),
Conv2DTranspose(num_classes, kernel_size=56, padding=14, strides=28, activation='sigmoid'))
lr, num_epochs = 0.9, 10
ctx = d2l.try_gpu()
net.initialize(force_reinit=True, ctx=ctx, init=init.Xavier())
trainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': lr})
d2l.train_ch5(net, train_iter, test_iter, batch_size, trainer, ctx, num_epochs)
def __init__(
self,
dir_list,
width=28,
height=28,
channel=1,
normal_height=14,
normal_width=14,
normal_channel=32,
initializer=None,
batch_size=40,
learning_rate=1e-03,
ctx=mx.gpu(),
discriminative_model=None,
generative_model=None,
discriminator_loss_weight=1.0,
reconstruction_loss_weight=1.0,
feature_matching_loss_weight=1.0,
):
'''
Init.
If you are not satisfied with this simple default setting,
delegate `discriminative_model` and `generative_model` designed by yourself.
Args:
dir_list: `list` of `str` of path to image files.
width: `int` of image width.
height: `int` of image height.
channel: `int` of image channel.
normal_width: `int` of width of image drawn from normal distribution, p(z).
normal_height: `int` of height of image drawn from normal distribution, p(z).
normal_channel: `int` of channel of image drawn from normal distribution, p(z).
initializer: is-a `mxnet.initializer` for parameters of model.
If `None`, it is drawing from the Xavier distribution.
batch_size: `int` of batch size.
learning_rate: `float` of learning rate.
ctx: `mx.gpu()` or `mx.cpu()`.
discriminative_model: is-a `accelbrainbase.observabledata._mxnet.adversarialmodel.discriminative_model.discriminativemodel.eb_discriminative_model.EBDiscriminativeModel`.
generative_model: is-a `accelbrainbase.observabledata._mxnet.adversarialmodel.generative_model.GenerativeModel`.
discriminator_loss_weight: `float` of weight for discriminator loss.
reconstruction_loss_weight: `float` of weight for reconstruction loss.
feature_matching_loss_weight: `float` of weight for feature matching loss.
'''
image_extractor = ImageExtractor(width=width,
height=height,
channel=channel,
ctx=ctx)
unlabeled_image_iterator = UnlabeledImageIterator(
image_extractor=image_extractor,
dir_list=dir_list,
batch_size=batch_size,
norm_mode="z_score",
scale=1.0,
noiseable_data=GaussNoise(sigma=1e-03, mu=0.0),
)
computable_loss = L2NormLoss()
if initializer is None:
initializer = mx.initializer.Uniform()
else:
if isinstance(initializer, mx.initializer.Initializer) is False:
raise TypeError(
"The type of `initializer` must be `mxnet.initializer.Initializer`."
)
if discriminative_model is None:
d_encoder = ConvolutionalNeuralNetworks(
# is-a `ComputableLoss` or `mxnet.gluon.loss`.
computable_loss=computable_loss,
# `list` of int` of the number of units in hidden layers.
hidden_units_list=[
# `mxnet.gluon.nn.Conv2D`.
Conv2D(
channels=16,
kernel_size=6,
strides=(2, 2),
padding=(1, 1),
),
Conv2D(
channels=32,
kernel_size=3,
strides=(1, 1),
padding=(1, 1),
),
],
# `list` of act_type` in `mxnet.ndarray.Activation` or `mxnet.symbol.Activation` in input gate.
hidden_activation_list=["relu", "relu"],
# `list` of `float` of dropout rate.
hidden_dropout_rate_list=[0.5, 0.5],
# `list` of `mxnet.gluon.nn.BatchNorm`.
hidden_batch_norm_list=[BatchNorm(), BatchNorm()],
# Call `mxnet.gluon.HybridBlock.hybridize()` or not.
hybridize_flag=True,
# `mx.gpu()` or `mx.cpu()`.
ctx=ctx,
)
d_decoder = ConvolutionalNeuralNetworks(
# is-a `ComputableLoss` or `mxnet.gluon.loss`.
computable_loss=computable_loss,
# `list` of int` of the number of units in hidden layers.
hidden_units_list=[
# `mxnet.gluon.nn.Conv2DTranspose`.
Conv2DTranspose(
channels=16,
kernel_size=3,
strides=(1, 1),
padding=(1, 1),
),
Conv2DTranspose(
channels=32,
kernel_size=6,
strides=(2, 2),
padding=(1, 1),
),
],
# `list` of act_type` in `mxnet.ndarray.Activation` or `mxnet.symbol.Activation` in input gate.
hidden_activation_list=["identity", "identity"],
# `list` of `float` of dropout rate.
hidden_dropout_rate_list=[0.0, 0.0],
# `list` of `mxnet.gluon.nn.BatchNorm`.
hidden_batch_norm_list=[BatchNorm(), None],
# Call `mxnet.gluon.HybridBlock.hybridize()` or not.
hybridize_flag=True,
# `mx.gpu()` or `mx.cpu()`.
ctx=ctx,
)
d_model = ConvolutionalAutoEncoder(
# is-a `ConvolutionalNeuralNetworks`.
encoder=d_encoder,
# is-a `ConvolutionalNeuralNetworks`.
decoder=d_decoder,
# is-a `ComputableLoss` or `mxnet.gluon.loss`.
computable_loss=computable_loss,
# `bool` of flag to tied weights or not.
tied_weights_flag=True,
# Call `mxnet.gluon.HybridBlock.hybridize()` or not.
hybridize_flag=True,
# `mx.gpu()` or `mx.cpu()`.
ctx=ctx,
)
d_model.batch_size = 40
discriminative_model = EBDiscriminativeModel(
# is-a `ConvolutionalAutoEncoder`.
model=d_model,
# Call `mxnet.gluon.HybridBlock.hybridize()` or not.
hybridize_flag=True,
# `mx.gpu()` or `mx.cpu()`.
ctx=ctx,
)
else:
if isinstance(discriminative_model, DiscriminativeModel) is False:
raise TypeError(
"The type of `discriminative_model` must be `DiscriminativeModel`."
)
if generative_model is None:
encoder = ConvolutionalNeuralNetworks(
computable_loss=computable_loss,
initializer=initializer,
learning_rate=learning_rate,
learning_attenuate_rate=1.0,
attenuate_epoch=50,
hidden_units_list=[
Conv2D(
channels=16,
kernel_size=6,
strides=(2, 2),
padding=(0, 0),
),
Conv2D(
channels=32,
kernel_size=3,
strides=(1, 1),
padding=(1, 1),
),
],
input_nn=None,
input_result_height=None,
input_result_width=None,
input_result_channel=None,
output_nn=None,
hidden_dropout_rate_list=[0.5, 0.5],
hidden_batch_norm_list=[BatchNorm(), BatchNorm()],
optimizer_name="SGD",
hidden_activation_list=["relu", "relu"],
hidden_residual_flag=False,
hidden_dense_flag=False,
dense_axis=1,
ctx=ctx,
hybridize_flag=True,
regularizatable_data_list=[],
scale=1.0,
)
decoder = ConvolutionalNeuralNetworks(
computable_loss=computable_loss,
initializer=initializer,
learning_rate=learning_rate,
learning_attenuate_rate=1.0,
attenuate_epoch=50,
hidden_units_list=[
Conv2DTranspose(
channels=16,
kernel_size=3,
strides=(1, 1),
padding=(1, 1),
),
Conv2DTranspose(
channels=channel,
kernel_size=6,
strides=(2, 2),
padding=(0, 0),
),
],
input_nn=None,
input_result_height=None,
input_result_width=None,
input_result_channel=None,
output_nn=None,
hidden_dropout_rate_list=[0.0, 0.0],
hidden_batch_norm_list=[BatchNorm(), None],
optimizer_name="SGD",
hidden_activation_list=["identity", "identity"],
hidden_residual_flag=False,
hidden_dense_flag=False,
dense_axis=1,
ctx=ctx,
hybridize_flag=True,
regularizatable_data_list=[],
scale=1.0,
)
g_model = ConvolutionalAutoEncoder(
encoder=encoder,
decoder=decoder,
computable_loss=computable_loss,
initializer=initializer,
learning_rate=learning_rate,
learning_attenuate_rate=1.0,
attenuate_epoch=50,
optimizer_name="SGD",
ctx=ctx,
hybridize_flag=True,
regularizatable_data_list=[],
scale=1.0,
)
d_model.batch_size = 40
true_sampler = TrueSampler()
true_sampler.iteratorable_data = unlabeled_image_iterator
condition_sampler = ConditionSampler()
condition_sampler.true_sampler = true_sampler
generative_model = GenerativeModel(
noise_sampler=UniformNoiseSampler(low=-1e-03,
high=1e-03,
batch_size=batch_size,
seq_len=0,
channel=channel,
height=height,
width=width,
ctx=ctx),
model=g_model,
initializer=initializer,
condition_sampler=condition_sampler,
conditonal_dim=1,
learning_rate=learning_rate,
optimizer_name="SGD",
hybridize_flag=True,
scale=1.0,
ctx=ctx,
)
else:
if isinstance(generative_model, GenerativeModel) is False:
raise TypeError(
"The type of `generative_model` must be `GenerativeModel`."
)
normal_ture_sampler = NormalTrueSampler(batch_size=batch_size,
seq_len=0,
channel=normal_channel,
height=normal_height,
width=normal_width,
ctx=ctx)
EBAAE = EBAAEController(
true_sampler=normal_ture_sampler,
generative_model=generative_model,
discriminative_model=discriminative_model,
discriminator_loss=EBDiscriminatorLoss(
weight=discriminator_loss_weight),
reconstruction_loss=L2NormLoss(weight=reconstruction_loss_weight),
feature_matching_loss=L2NormLoss(
weight=feature_matching_loss_weight),
optimizer_name="SGD",
learning_rate=learning_rate,
learning_attenuate_rate=1.0,
attenuate_epoch=50,
hybridize_flag=True,
scale=1.0,
ctx=ctx,
initializer=initializer,
)
self.EBAAE = EBAAE
def __init__(self, inner_channels, outer_channels, inner_block=None, innermost=False, outermost=False,
use_dropout=False, use_bias=False,use_position_attention=False,use_channel_attention=False):
super(UnetSkipUnit, self).__init__()
with self.name_scope():
self.outermost = outermost
res1=Res_Block(outer_channels=outer_channels)
res2=Res_Block(outer_channels=inner_channels)
res3=Res_Block(outer_channels=inner_channels)
res4=Res_Block(outer_channels=outer_channels)
attention_non=CA_M3()
attention_position=CA_M2(in_channel=inner_channels)
attention_channel=CA_M1()
en_conv = Conv2D(channels=inner_channels, kernel_size=4, strides=2, padding=1,
in_channels=outer_channels, use_bias=use_bias)
en_relu = LeakyReLU(alpha=0.2)
en_norm = BatchNorm(momentum=0.1, in_channels=inner_channels)
de_relu = Activation(activation='relu')
de_norm = BatchNorm(momentum=0.1, in_channels=outer_channels)
if innermost:
if use_position_attention:
p_attention=attention_position
else:
p_attention=attention_non
if use_channel_attention:
c_attention=attention_channel
else:
c_attention=attention_non
de_conv = Conv2DTranspose(channels=outer_channels, kernel_size=4, strides=2, padding=1,
in_channels=inner_channels, use_bias=use_bias)
encoder = [res1,en_relu, en_conv,p_attention,res2]
decoder = [res3,de_relu, de_conv, de_norm,res4]
model = encoder + decoder
elif outermost:
if use_position_attention:
p_attention=attention_position
else:
p_attention=attention_non
if use_channel_attention:
c_attention=attention_channel
else:
c_attention=attention_non
de_conv = Conv2DTranspose(channels=outer_channels, kernel_size=4, strides=2, padding=1,
in_channels=inner_channels)
encoder = [en_conv,p_attention]
decoder = [de_relu, de_conv, de_norm]
model = encoder + [inner_block] + decoder
else:
if use_position_attention:
p_attention=attention_position
else:
p_attention=attention_non
if use_channel_attention:
c_attention=attention_channel
else:
c_attention=attention_non
de_conv = Conv2DTranspose(channels=outer_channels, kernel_size=4, strides=2, padding=1,
in_channels=inner_channels, use_bias=use_bias)
encoder = [res1,en_relu, en_conv, en_norm,p_attention,res2]
decoder = [res3,de_relu, de_conv, de_norm,res4]
model = encoder + [inner_block] + decoder
self.c_attention=c_attention
self.model = HybridSequential()
with self.model.name_scope():
for block in model:
self.model.add(block)
def build_upsample_nn():
nnet = nn.HybridSequential()
nnet.add(WithELU(Conv2DTranspose(channels=32, kernel_size=(4, 4), strides=(4, 4))))
return nnet, (32, 64, 64)
def __init__(self, Darknetlayer=53,
anchors={"shallow": [(10, 13), (16, 30), (33, 23)],
"middle": [(30, 61), (62, 45), (59, 119)],
"deep": [(116, 90), (156, 198), (373, 326)]},
num_classes=1, # foreground만
pretrained=True,
pretrained_path="modelparam",
ctx=mx.cpu()):
super(YoloV3output, self).__init__()
if Darknetlayer not in [53]:
raise ValueError
anchors = OrderedDict(anchors)
anchors = list(anchors.values())[::-1]
# 각 레이어에서 나오는 anchor갯수가 바뀔수도 있으니!!
self._num_anchors = []
for anchor in anchors:
self._num_anchors.append(len(anchor)) # 변화 가능
self._darkenet = get_darknet(Darknetlayer, pretrained=pretrained, ctx=ctx, root=pretrained_path)
self._num_classes = num_classes
self._num_pred = 5 + num_classes # 고정
with self.name_scope():
head_init_num_channel = 512
trans_init_num_channel = 256
self._head = HybridSequential()
self._transition = HybridSequential()
self._upsampleconv = HybridSequential()
# output
for j in range(len(anchors)):
if j == 0:
factor = 1
else:
factor = 2
head_init_num_channel = head_init_num_channel // factor
for _ in range(3):
self._head.add(Conv2D(channels=head_init_num_channel,
kernel_size=(1, 1),
strides=(1, 1),
padding=(0, 0),
use_bias=True,
in_channels=0,
weight_initializer=mx.init.Normal(0.01),
bias_initializer='zeros'
))
self._head.add(BatchNorm(epsilon=1e-5, momentum=0.9))
self._head.add(LeakyReLU(0.1))
self._head.add(Conv2D(channels=head_init_num_channel * 2,
kernel_size=(3, 3),
strides=(1, 1),
padding=(1, 1),
use_bias=True,
in_channels=0,
weight_initializer=mx.init.Normal(0.01),
bias_initializer='zeros'
))
self._head.add(BatchNorm(epsilon=1e-5, momentum=0.9))
self._head.add(LeakyReLU(0.1))
self._head.add(Conv2D(channels=len(anchors[j]) * self._num_pred,
kernel_size=(1, 1),
strides=(1, 1),
padding=(0, 0),
use_bias=True,
in_channels=0,
weight_initializer=mx.init.Normal(0.01),
bias_initializer='zeros'
))
# for upsample - transition
for i in range(len(anchors) - 1):
if i == 0:
factor = 1
else:
factor = 2
trans_init_num_channel = trans_init_num_channel // factor
self._transition.add(Conv2D(channels=trans_init_num_channel,
kernel_size=(1, 1),
strides=(1, 1),
padding=(0, 0),
use_bias=True,
in_channels=0,
weight_initializer=mx.init.Normal(0.01),
bias_initializer='zeros'
))
self._transition.add(BatchNorm(epsilon=1e-5, momentum=0.9))
self._transition.add(LeakyReLU(0.1))
# for deconvolution upsampleing
for i in range(len(anchors) - 1):
if i == 0:
factor = 1
else:
factor = 2
trans_init_num_channel = trans_init_num_channel // factor
self._upsampleconv.add(Conv2DTranspose(trans_init_num_channel, kernel_size=3, strides=2, padding=1,
output_padding=1, use_bias=True, in_channels=0))
self._upsampleconv.add(BatchNorm(epsilon=1e-5, momentum=0.9))
self._upsampleconv.add(LeakyReLU(0.1))
self._head.initialize(ctx=ctx)
self._transition.initialize(ctx=ctx)
self._upsampleconv.initialize(ctx=ctx)
print(f"{self.__class__.__name__} Head weight init 완료")