def __init__(self,
dim_in,
dim_hidden,
dim_latent,
num_layers,
num_trans,
temperature,
num_zsamples=1):
super(VAE, self).__init__()
# initialise first encoder and decoder hidden layer separately because
# the input and output dims differ from the other hidden layers
self.qlin0 = L.Linear(dim_in, dim_hidden)
self.plin0 = L.Linear(dim_latent, dim_hidden)
self._children.append('qlin0')
self._children.append('plin0')
for i in range(num_layers - 1):
# encoder
layer_name = 'qlin' + str(i + 1)
setattr(self, layer_name, L.Linear(2 * dim_hidden, dim_hidden))
self._children.append(layer_name)
# decoder
layer_name = 'plin' + str(i + 1)
setattr(self, layer_name, L.Linear(2 * dim_hidden, dim_hidden))
self._children.append(layer_name)
# initialise the encoder and decoder output layer separately because
# the input and output dims differ from the other hidden layers
self.qlin_mu = L.Linear(2 * dim_hidden, dim_latent)
self.qlin_ln_var = L.Linear(2 * dim_hidden, dim_latent)
self.plin_ln_var = L.Linear(2 * dim_hidden, dim_in)
self.plin_mu = L.Linear(2 * dim_hidden, dim_in)
self._children.append('qlin_mu')
self._children.append('qlin_ln_var')
self._children.append('plin_mu')
self._children.append('plin_ln_var')
# flow
for i in range(num_trans):
layer_name = 'flow_w_' + str(i) # weights
setattr(self, layer_name,
L.Scale(axis=1, W_shape=(dim_latent), bias_term=False))
self._children.append(layer_name)
layer_name = 'flow_b_' + str(i) # bias
setattr(self, layer_name, L.Bias(axis=0, shape=(1)))
self._children.append(layer_name)
layer_name = 'flow_u_' + str(i) # scaling factor u
setattr(self, layer_name,
L.Scale(axis=1, W_shape=(dim_latent), bias_term=False))
self._children.append(layer_name)
self.num_layers = num_layers
self.num_trans = num_trans
self.temperature = temperature
self.num_zsamples = num_zsamples
self.epochs_seen = 0
def setUp(self):
self.x = numpy.random.uniform(-1, 1, (3, 2, 3)).astype(numpy.float32)
self.W = numpy.random.uniform(-1, 1, (2)).astype(numpy.float32)
self.b = numpy.random.uniform(-1, 1, (2)).astype(numpy.float32)
self.y_expected = numpy.copy(self.x)
for i, j, k in numpy.ndindex(self.y_expected.shape):
self.y_expected[i, j, k] *= self.W[j]
if self.bias_term:
self.y_expected[i, j, k] += self.b[j]
self.gy = numpy.random.uniform(-1, 1, (3, 2, 3)).astype(numpy.float32)
bias_term = self.bias_term
bias_shape = self.bias_shape
axis = 1
if self.learn_W:
self.link = links.Scale(
axis, self.W.shape, bias_term, bias_shape)
self.link.W.data = self.W
if bias_term:
self.link.bias.b.data = self.b
else:
self.link = links.Scale(
axis, None, bias_term, bias_shape)
if bias_term:
self.link.bias.b.data = self.b
self.link.cleargrads()
def __init__(self, n_input_ch=6, at_once=True, mat_scale=1):
self.mat_scale = mat_scale
super().__init__(n_input_ch, 3, at_once) # 3 outputs
with self.init_scope():
self.prob_scale = L.Scale(W_shape=(1,))
self.prob_scale.W.copydata(np.array([100.0])) # Initial parameter
self.matting_link = MattingLink()
def _init_non_bottom(self, d_inp, d_out):
super(DecNet, self).__init__(
linear=L.Linear(d_inp, d_out),
bn=BatchNormalization(d_out, decay=0.9,
use_gamma=False, use_beta=False,
device=self.device),
sb=L.Scale(W_shape=d_out, bias_term=True)
)
def __init__(self, dim, act=F.relu, device=None, ):
d_inp, d_out = dim
super(EncNet, self).__init__(
linear=L.Linear(d_inp, d_out),
bn=L.BatchNormalization(d_out, decay=0.9,
use_gamma=False, use_beta=False),
sb=L.Scale(W_shape=d_out, bias_term=True)
)
self.sigma = 0.3
self.act = act
def _init_non_top(self, d_inp, d_out, ksize, stride, pad):
super(EncNet,
self).__init__(conv=L.Convolution2D(d_inp, d_out, ksize, stride,
pad),
bn=BatchNormalization(d_out,
decay=0.9,
use_gamma=False,
use_beta=False,
device=self.device),
sb=L.Scale(W_shape=d_out, bias_term=True))
def __init__(self, device, act=F.relu):
super(MLPDecoder, self).__init__(
linear0=L.Linear(210, 500),
linear1=L.Linear(500, 1000),
linear2=L.Linear(1000, 784),
sc=L.Scale(W_shape=(210, ), bias_term=True),
bn0=L.BatchNormalization(500, decay=0.9),
bn1=L.BatchNormalization(1000, decay=0.9),
)
self.device = device
self.act = act
def __init__(self, dim):
super(Denoise, self).__init__(
a0=L.Scale(W_shape=(dim, )),
a1=L.Scale(W_shape=(dim, )),
a2=L.Scale(W_shape=(dim, )),
a3=L.Bias(shape=(dim, )),
a4=L.Scale(W_shape=(dim, )),
b0=L.Scale(W_shape=(dim, )),
b1=L.Scale(W_shape=(dim, )),
b2=L.Scale(W_shape=(dim, )),
b3=L.Bias(shape=(dim, )),
)
def __init__(self, device, act=F.relu):
super(MLPEncoder,
self).__init__(linear0=L.Linear(784, 1000),
linear1=L.Linear(1000, 500),
linear2=L.Linear(500, 200),
classifier=L.Linear(200, 10),
bn0=L.BatchNormalization(1000, decay=0.9),
bn1=L.BatchNormalization(500, decay=0.9),
bn2=BatchNormalization(200,
decay=0.9,
use_gamma=False,
use_beta=False),
sc2=L.Scale(W_shape=(200, ), bias_term=True))
self.device = device
self.act = act
def __init__(self,
dims,
act=F.relu,
noise=False,
rc=False,
device=None):
# Setup layers
layers = {}
linears = OrderedDict()
batch_norms = OrderedDict()
scale_biases = OrderedDict()
for l, d in enumerate(zip(dims[0:-1], dims[1:])):
d_in, d_out = d[0], d[1]
# Linear
linear = L.Linear(d_in, d_out, )
l_name = "linear-enc-{:03}".format(l)
linears[l_name] = linear
# Normalization and BatchCorrection
batch_norm = BatchNormalization(d_out, decay=0.9,
use_gamma=False, use_beta=False)
bn_name = "bn-enc-{:03d}".format(l)
batch_norms[bn_name] = batch_norm
scale_bias = L.Scale(W_shape=d_out, bias_term=True)
sb_name = "sb-enc-{:03d}".format(l)
scale_biases[sb_name] = scale_bias
layers.update(linears)
layers.update(batch_norms)
layers.update(scale_biases)
super(MLPEnc, self).__init__(**layers)
self.dims = dims
self.layers = layers
self.linears = linears
self.batch_norms = batch_norms
self.scale_biases = scale_biases
self.act = act
self.noise = noise
self.rc = rc
self.device = device
self.hiddens = []
def __init__(self,
config,
batchsize,
n_classes=0,
softmax=True,
comm=None,
test=False):
self.softmax = softmax
if not test:
self.l_emd = config.l_emd
self.l_re = config.l_re
self.l_patch_dis = config.l_patch_dis
self.l_gp = config.l_gp
self.l_per = config.l_per
self.config = config
self.comm = comm
self.gen = BIGGAN()
self.dim_z = 140
params = {}
if config.initial_z == "zero":
params["z"] = L.Parameter(
np.zeros((batchsize, self.dim_z)).astype("float32"))
elif config.initial_z == "random":
params["z"] = L.Parameter(
np.random.normal(size=(batchsize,
self.dim_z)).astype("float32"))
initialW = initializers.HeNormal(0.001**0.5)
params["linear"] = L.Linear(1, 128, initialW=initialW, nobias=True)
params["BSA_linear"] = L.Scale(W_shape=(16 * self.gen.ch),
bias_term=True)
for i, (k, l) in enumerate(self.gen.namedlinks()):
if "Hyper" in k.split("/")[-1]:
params[f"hyper_bn{i}"] = l
if config.lr_g_linear > 0:
params["g_linear"] = self.gen.G_linear
super(AdaBIGGAN, self).__init__(**params)
if not test:
self.setup_optimizer()
self.z.W.update_rule.hyperparam.alpha = 0.05
self.linear.W.update_rule.hyperparam.alpha = 0.001
if config.lr_g_linear > 0:
self.g_linear.W.update_rule.hyperparam.alpha = config.lr_g_linear
def __init__(self, in_channels, out_channels, LoopTimes=5):
super(Block, self).__init__()
with self.init_scope():
"""
ffconv : feedforword Convolution.
fbconv : feedback Convolution (deconvolution).
bpconv : bypass Convolution (1x1 convolution).
update_late : A learnable and non-negative parameter.
"""
self.bn = L.BatchNormalization(in_channels)
self.ffconv = L.Convolution2D(in_channels,
out_channels,
ksize=3,
pad=1)
self.fbconv = L.Deconvolution2D(out_channels,
in_channels,
ksize=3,
pad=1)
self.bpconv = L.Convolution2D(in_channels, out_channels, ksize=1)
self.update_rate = L.Scale(axis=0, W_shape=(1, ))
self.LoopTimes = LoopTimes
self.out_channels = out_channels
def test_scale_invalid_argc1(self):
func = links.Scale(self.axis, self.W.data.shape)
with chainer.DebugMode(True):
with self.assertRaises(AssertionError):
func(self.x, self.W)
def __init__(self):
super(SSD, self).__init__(
conv1_1=L.Convolution2D(3, 64, 3, pad=1),
conv1_2=L.Convolution2D(64, 64, 3, pad=1),
conv2_1=L.Convolution2D(64, 128, 3, pad=1),
conv2_2=L.Convolution2D(128, 128, 3, pad=1),
conv3_1=L.Convolution2D(128, 256, 3, pad=1),
conv3_2=L.Convolution2D(256, 256, 3, pad=1),
conv3_3=L.Convolution2D(256, 256, 3, pad=1),
conv4_1=L.Convolution2D(256, 512, 3, pad=1),
conv4_2=L.Convolution2D(512, 512, 3, pad=1),
conv4_3=L.Convolution2D(512, 512, 3, pad=1),
conv5_1=L.Convolution2D(512, 512, 3, pad=1),
conv5_2=L.Convolution2D(512, 512, 3, pad=1),
conv5_3=L.Convolution2D(512, 512, 3, pad=1),
#fc6 = L.Convolution2D(512, 1024, 3, pad=6),
fc6=L.DilatedConvolution2D(512, 1024, 3, pad=6, dilate=6),
fc7=L.Convolution2D(1024, 1024, 1),
conv6_1=L.Convolution2D(1024, 256, 1),
conv6_2=L.Convolution2D(256, 512, 3, stride=2, pad=1),
conv7_1=L.Convolution2D(512, 128, 1),
conv7_2=L.Convolution2D(128, 256, 3, stride=2, pad=1),
conv8_1=L.Convolution2D(256, 128, 1),
conv8_2=L.Convolution2D(128, 256, 3, stride=2, pad=1),
normalize=L.Scale(W_shape=512),
conv4_3_norm_mbox_loc=L.Convolution2D(512, 12, 3,
pad=1), #3 prior boxes
conv4_3_norm_mbox_conf=L.Convolution2D(512, 63, 3, pad=1),
fc7_mbox_loc=L.Convolution2D(1024, 24, 3, pad=1), #6 prior boxes
fc7_mbox_conf=L.Convolution2D(1024, 126, 3, pad=1),
conv6_2_mbox_loc=L.Convolution2D(512, 24, 3,
pad=1), #6 prior boxes
conv6_2_mbox_conf=L.Convolution2D(512, 126, 3, pad=1),
conv7_2_mbox_loc=L.Convolution2D(256, 24, 3,
pad=1), #6 prior boxes
conv7_2_mbox_conf=L.Convolution2D(256, 126, 3, pad=1),
conv8_2_mbox_loc=L.Convolution2D(256, 24, 3,
pad=1), #6 prior boxes
conv8_2_mbox_conf=L.Convolution2D(256, 126, 3, pad=1),
pool6_mbox_loc=L.Convolution2D(256, 24, 3, pad=1),
pool6_mbox_conf=L.Convolution2D(256, 126, 3,
pad=1), #6 prior boxes
)
self.train = False
self.conv4_3_norm_mbox_priorbox = self.prior((38, 38), 30., 0, [2], 1,
1, (0.1, 0.1, 0.2, 0.2))
self.fc7_mbox_priorbox = self.prior((19, 19), 60., 114., [2, 3], 1, 1,
(0.1, 0.1, 0.2, 0.2))
self.conv6_2_mbox_priorbox = self.prior((10, 10), 114., 168., [2, 3],
1, 1, (0.1, 0.1, 0.2, 0.2))
self.conv7_2_mbox_priorbox = self.prior((5, 5), 168., 222., [2, 3], 1,
1, (0.1, 0.1, 0.2, 0.2))
self.conv8_2_mbox_priorbox = self.prior((3, 3), 222., 276., [2, 3], 1,
1, (0.1, 0.1, 0.2, 0.2))
self.pool6_mbox_priorbox = self.prior((1, 1), 276., 330., [2, 3], 1, 1,
(0.1, 0.1, 0.2, 0.2))
self.mbox_prior = np.hstack([
self.conv4_3_norm_mbox_priorbox, self.fc7_mbox_priorbox,
self.conv6_2_mbox_priorbox, self.conv7_2_mbox_priorbox,
self.conv8_2_mbox_priorbox, self.pool6_mbox_priorbox
])
def test_scale_invalid_argc2(self):
func = links.Scale(self.axis, None)
with chainer.using_config('debug', True):
with self.assertRaises(AssertionError):
func(self.x)
def test_scale_no_bias_shape(self):
axis = 1
with self.assertRaises(ValueError):
links.Scale(axis, None, True, None)
def test_scale_invalid_argc2(self):
func = links.Scale(self.axis, None)
with chainer.DebugMode(True):
with self.assertRaises(AssertionError):
func(self.x)
