def __init__(self, n_units, n_out, n_worker):
super(CNN, self).__init__()
with self.init_scope():
dim, c_in, c_out, = 1, 1, 1
#引数は、次元、入力チャネル、出力チャネル、フィルタサイズ、ストライド
self.c1 = L.ConvolutionND(dim,
c_in,
c_out,
n_worker,
stride=n_worker)
#正則化してみる
self.bn1 = L.BatchNormalization(c_out)
# the size of the inputs to each layer will be inferred
self.l1 = L.Linear(None, n_units) # n_in -> n_units
#self.l2 = L.Linear(None, n_units) # n_units -> n_units
#self.l3 = L.Linear(None, n_units) # n_units -> n_units
#self.l4 = L.Linear(None, n_units) # n_units -> n_units
self.lout = L.Linear(None, n_out) # n_units -> n_out
def __init__(self, n_voc, n_hidden):
super(Generator, self).__init__()
self.n_voc = n_voc
self.n_hidden = n_hidden
initializer = chainer.initializers.HeNormal()
with self.init_scope():
self.l = L.Linear(16 * 16)
self.deconv = L.DeconvolutionND(1, 16, 32, 7, stride=2, pad=2)
self.block1 = GenBlock(32, 32, 4, 2, 1)
self.block2 = GenBlock(32, 64, 4, 2, 1)
self.block3 = GenBlock(64, 64, 4, 2, 1)
self.block4 = GenBlock(64, 128, 4, 2, 1)
self.block5 = DisBlock(128, 128, 5, 2, 0)
self.block6 = DisBlock(128, 256, 3, 1, 1)
self.bn = L.BatchNormalization(256)
self.decoder = L.ConvolutionND(1, 256, n_voc, ksize=1, stride=1)
def __init__(self, base=64):
super(Refine, self).__init__()
with self.init_scope():
self.cbr0 = CBR_3D(3, base, down=True)
self.cbr1 = CBR_3D(base, base * 2, down=True)
self.cbr2 = CBR_3D(base * 2, base * 4, down=True)
self.cbr3 = CBR_3D(base * 4, base * 8, down=True)
self.cbr4 = CBR_3D(base * 16, base * 4, up=True)
self.cbr5 = CBR_3D(base * 8, base * 2, up=True)
self.cbr6 = CBR_3D(base * 4, base, up=True)
self.cbr7 = CBR_3D(base * 2, base, up=True)
self.cbr8 = L.ConvolutionND(3,
base,
3,
3,
1,
1,
initialW=initializers.Normal(0.01))
def __init__(self, n_dims, n_actions):
self.head = links.Sequence(
L.ConvolutionND(ndim=1,
in_channels=n_dims,
out_channels=100,
ksize=3,
stride=1,
pad=1,
cover_all=True), F.relu)
self.pi = policies.FCSoftmaxPolicy(n_input_channels=100,
n_actions=n_actions,
n_hidden_layers=2,
n_hidden_channels=100)
self.v = v_functions.FCVFunction(n_input_channels=100,
n_hidden_layers=2,
n_hidden_channels=100)
super(A3CFF, self).__init__(self.head, self.pi, self.v)
def __init__(self, maxdisp, gpu0, gpu1, training=True, train_type=None):
super(PSMNet, self).__init__()
self.gpu0 = gpu0
self.gpu1 = gpu1
self.training = training
self.train_type = train_type
with self.init_scope():
self.maxdisp = maxdisp
self.feature_extraction = feature_extraction(self.gpu0)
self.dres0 = Sequential(convbn_3d(64, 32, 3, 1, 1), F.relu,
convbn_3d(32, 32, 3, 1, 1),
F.relu).to_gpu(self.gpu1)
self.dres1 = Sequential(convbn_3d(32, 32, 3, 1, 1), F.relu,
convbn_3d(32, 32, 3, 1,
1)).to_gpu(self.gpu1)
self.dres2 = Sequential(convbn_3d(32, 32, 3, 1, 1), F.relu,
convbn_3d(32, 32, 3, 1,
1)).to_gpu(self.gpu1)
self.dres3 = Sequential(convbn_3d(32, 32, 3, 1, 1), F.relu,
convbn_3d(32, 32, 3, 1,
1)).to_gpu(self.gpu1)
self.dres4 = Sequential(convbn_3d(32, 32, 3, 1, 1), F.relu,
convbn_3d(32, 32, 3, 1,
1)).to_gpu(self.gpu1)
self.classify = Sequential(
convbn_3d(32, 32, 3, 1, 1), F.relu,
L.ConvolutionND(3,
32,
1,
ksize=3,
stride=1,
pad=1,
nobias=True,
initialW=ini.Normal(
math.sqrt(2. / (3 * 3 * 3 * 1))))).to_gpu(
self.gpu1)
def __init__(self,
in_channels,
out_channels,
kernel_size=2,
pooling="f",
zoneout=False,
zoneout_ratio=0.1,
wgain=1):
self.num_split = len(pooling) + 1
wstd = kernel_size * out_channels * wgain
super(QRNN, self).__init__(
W=links.ConvolutionND(1,
in_channels,
self.num_split * out_channels,
kernel_size,
stride=1,
pad=kernel_size - 1,
initialW=initializers.Normal(wstd)))
self._in_channels, self._out_channels, self._kernel_size, self._pooling, self._zoneout, self._zoneout_ratio = in_channels, out_channels, kernel_size, pooling, zoneout, zoneout_ratio
self.reset_state()
def __init__(self, n_layers, n_dim, n_filters, filter_size, pad_size,
n_output, use_bn):
links = []
for i_layer in range(n_layers):
links.append(
L.ConvolutionND(ndim=n_dim,
in_channels=1 if i_layer == 0 else n_filters,
out_channels=n_filters,
ksize=filter_size,
stride=1,
pad=pad_size,
initialW=chainer.initializers.HeNormal()))
if use_bn:
links.append(L.BatchNormalization(n_filters))
links.append(L.Linear(None, n_output))
self.n_layers = len(links)
self.h = {}
super(CNN_ND, self).__init__(*links)
def __init__(self,
ch0,
ch1,
bn=True,
sample='down',
activation=F.relu,
dropout=False):
self.bn = bn
self.activation = activation
self.dropout = dropout
layers = {}
w = chainer.initializers.Normal(0.02)
if sample == 'down':
layers['c'] = L.Convolution2D(ch0, ch1, 4, 2, 1, initialW=w)
elif sample == "dis":
layers['c'] = L.ConvolutionND(3, ch0, ch1, 4, 2, 1, initialW=w)
else:
layers['c'] = L.DeconvolutionND(3, ch0, ch1, 4, 2, 1, initialW=w)
if bn:
layers['batchnorm'] = L.BatchNormalization(ch1)
super(CBR, self).__init__(**layers)
def __init__(self,
in_size,
out_size,
kernel_size=2,
attention=False,
decoder=False):
if kernel_size == 1:
super().__init__(W=Linear(in_size, 3 * out_size))
elif kernel_size == 2:
super().__init__(W=Linear(in_size, 3 * out_size, nobias=True),
V=Linear(in_size, 3 * out_size))
else:
super().__init__(conv=L.ConvolutionND(1,
in_size,
3 * out_size,
kernel_size,
stride=1,
pad=kernel_size - 1))
if attention:
self.add_link('U', Linear(out_size, 3 * in_size))
self.add_link('o', Linear(2 * out_size, out_size))
self.in_size, self.size, self.attention = in_size, out_size, attention
self.kernel_size = kernel_size
def __init__(self, in_channels, out_channels, ksize, stride, pad):
super(DisBlock, self).__init__()
with self.init_scope():
self.bn = L.BatchNormalization(in_channels)
self.conv = L.ConvolutionND(1, in_channels, out_channels, ksize,
stride, pad)
def __init__(self, num_of_label):
w = chainer.initializers.HeNormal()
super(UNet3D, self).__init__()
with self.init_scope():
# encoder pass
self.ce0 = L.ConvolutionND(ndim=3, in_channels=1, out_channels=16, ksize=3, pad=1,initialW=w)
self.bne0 = L.BatchNormalization(16)
self.ce1 = L.ConvolutionND(ndim=3, in_channels=16, out_channels=32, ksize=3, pad=1,initialW=w)
self.bne1 = L.BatchNormalization(32)
self.ce2 = L.ConvolutionND(ndim=3, in_channels=32, out_channels=32, ksize=3, pad=1, initialW=w)
self.bne2 = L.BatchNormalization(32)
self.ce3 = L.ConvolutionND(ndim=3, in_channels=32, out_channels=64, ksize=3, pad=1, initialW=w)
self.bne3 = L.BatchNormalization(64)
self.ce4 = L.ConvolutionND(ndim=3, in_channels=64, out_channels=64, ksize=3, pad=1, initialW=w)
self.bne4 = L.BatchNormalization(64)
# decoder pass
self.cd4 = L.ConvolutionND(ndim=3, in_channels=64, out_channels=128, ksize=3, pad=1, initialW=w)
self.bnd4 = L.BatchNormalization(128)
self.deconv2 = L.DeconvolutionND(ndim=3, in_channels=128, out_channels=128, ksize=2, stride=2, initialW=w, nobias=True)
self.cd3 = L.ConvolutionND(ndim=3, in_channels=64+128, out_channels=64, ksize=3, pad=1, initialW=w)
self.bnd3 = L.BatchNormalization(64)
self.cd2 = L.ConvolutionND(ndim=3, in_channels=64, out_channels=64, ksize=3, pad=1, initialW=w)
self.bnd2 = L.BatchNormalization(64)
self.deconv1 = L.DeconvolutionND(ndim=3, in_channels=64, out_channels=64, ksize=2, stride=2, initialW=w,nobias=True)
self.cd1 = L.ConvolutionND(ndim=3, in_channels=32+64, out_channels=32, ksize=3, pad=1, initialW=w)
self.bnd1 = L.BatchNormalization(32)
self.cd0 = L.ConvolutionND(ndim=3, in_channels=32, out_channels=32, ksize=3, pad=1, initialW=w)
self.bnd0 = L.BatchNormalization(32)
self.lcl = L.ConvolutionND(ndim=3, in_channels=32, out_channels=num_of_label, ksize=1, pad=0, initialW=w)
def __init__(self,
mask,
channels: Sequence[int],
n_conv_per_block,
pca_dim=1,
init_n_blocks=None,
with_reconstruction_loss=True,
with_pca=False,
with_pca_loss=False,
debug=False):
super().__init__()
try:
assert len(channels) >= 2
except AssertionError as e:
print("len(channels) must be equal or more than 2")
raise e
if init_n_blocks is None:
init_n_blocks = len(channels)
self.mask = mask
self.channels = channels
self.tmp_n_blocks = init_n_blocks
self.n_blocks = len(self.channels)
self.n_conv_per_block = n_conv_per_block
self.loss_const = self.mask.size / self.mask.sum()
self.decoder_backprop_enabled = [True] * self.n_blocks
self.encoder_backprop_enabled = [True] * self.n_blocks
self.pca_attached = with_pca
self.pca_block_idx = self.tmp_n_blocks - 1
self.pca_dim = pca_dim
self.pca_loss_attached = with_pca_loss
self.reconstruction_loss_attached = with_reconstruction_loss
self.debug = debug
with self.init_scope():
# ConvolutionND(dim, in_channel, out_channel, kernel, stride, padding)
for block_idx in range(self.n_blocks):
for conv_idx in range(self.n_conv_per_block):
if conv_idx == 0:
in_channel = 1 if block_idx == 0 else self.channels[
block_idx - 1]
else:
in_channel = self.channels[block_idx]
out_channel = self.channels[block_idx]
nobias = False if block_idx == 0 and conv_idx == 0 else True # 入力層はnobias=False
self.add_link(
"conv_{}_{}".format(block_idx, conv_idx),
L.ConvolutionND(3,
in_channel,
out_channel, (3, 3, 3),
1,
1,
nobias=nobias))
# self.pca = PCA(self.channels[self.pca_block_idx], self.pca_dim)
self.pca = PCA(self.pca_dim)
for block_idx in reversed(range(self.n_blocks)):
for conv_idx in range(self.n_conv_per_block):
in_channel = self.channels[block_idx]
if conv_idx == self.n_conv_per_block - 1:
out_channel = 1 if block_idx == 0 else self.channels[
block_idx - 1]
else:
out_channel = self.channels[block_idx]
nobias = False if block_idx == 0 and conv_idx == self.n_conv_per_block - 1 else True # 出力層はnobias=False
self.add_link(
"dcnv_{}_{}".format(block_idx, conv_idx),
L.ConvolutionND(3,
in_channel,
out_channel, (3, 3, 3),
1,
1,
nobias=nobias))
def __init__(self, cin, cout, k, s, p, batch_norm=True):
super(Conv3d, self).__init__()
with self.init_scope():
self.conv = L.ConvolutionND(3, cin, cout, ksize=k, stride=s, pad=p)
self.bn = L.BatchNormalization(cout) if batch_norm else None
def __init__(self, in_channels=1, n_classes=4):
init = chainer.initializers.HeNormal(scale=0.01)
super(VoxResNet,
self).__init__(conv1a=L.ConvolutionND(3,
in_channels,
32,
3,
pad=1,
initialW=init),
bnorm1a=L.BatchNormalization(32),
conv1b=L.ConvolutionND(3,
32,
32,
3,
pad=1,
initialW=init),
bnorm1b=L.BatchNormalization(32),
conv1c=L.ConvolutionND(3,
32,
64,
3,
stride=2,
pad=1,
initialW=init),
voxres2=VoxResModule(),
voxres3=VoxResModule(),
bnorm3=L.BatchNormalization(64),
conv4=L.ConvolutionND(3,
64,
64,
3,
stride=2,
pad=1,
initialW=init),
voxres5=VoxResModule(),
voxres6=VoxResModule(),
bnorm6=L.BatchNormalization(64),
conv7=L.ConvolutionND(3,
64,
64,
3,
stride=2,
pad=1,
initialW=init),
voxres8=VoxResModule(),
voxres9=VoxResModule(),
c1deconv=L.DeconvolutionND(3,
32,
32,
3,
pad=1,
initialW=init),
c1conv=L.ConvolutionND(3,
32,
n_classes,
3,
pad=1,
initialW=init),
c2deconv=L.DeconvolutionND(3,
64,
64,
4,
stride=2,
pad=1,
initialW=init),
c2conv=L.ConvolutionND(3,
64,
n_classes,
3,
pad=1,
initialW=init),
c3deconv=L.DeconvolutionND(3,
64,
64,
6,
stride=4,
pad=1,
initialW=init),
c3conv=L.ConvolutionND(3,
64,
n_classes,
3,
pad=1,
initialW=init),
c4deconv=L.DeconvolutionND(3,
64,
64,
10,
stride=8,
pad=1,
initialW=init),
c4conv=L.ConvolutionND(3,
64,
n_classes,
3,
pad=1,
initialW=init))
def __init__(self, ch=64):
w = chainer.initializers.Normal(scale=0.02) #Inspired by DCGAN
super(Discriminator, self).__init__()
with self.init_scope():
self.conv1 = L.ConvolutionND(ndim=3,
in_channels=1,
out_channels=ch,
ksize=3,
stride=1,
pad=1,
initialW=w)
self.conv2 = L.ConvolutionND(ndim=3,
in_channels=ch,
out_channels=ch,
ksize=3,
stride=2,
pad=1,
initialW=w)
self.bn1 = L.BatchNormalization(ch)
self.conv3 = L.ConvolutionND(ndim=3,
in_channels=ch,
out_channels=ch * 2,
ksize=3,
stride=1,
pad=1,
initialW=w)
self.bn2 = L.BatchNormalization(ch * 2)
self.conv4 = L.ConvolutionND(ndim=3,
in_channels=ch * 2,
out_channels=ch * 2,
ksize=3,
stride=2,
pad=1,
initialW=w)
self.bn3 = L.BatchNormalization(ch * 2)
self.conv5 = L.ConvolutionND(ndim=3,
in_channels=ch * 2,
out_channels=ch * 4,
ksize=3,
stride=1,
pad=1,
initialW=w)
self.bn4 = L.BatchNormalization(ch * 4)
self.conv6 = L.ConvolutionND(ndim=3,
in_channels=ch * 4,
out_channels=ch * 4,
ksize=3,
stride=2,
pad=1,
initialW=w)
self.bn5 = L.BatchNormalization(ch * 4)
self.conv7 = L.ConvolutionND(ndim=3,
in_channels=ch * 4,
out_channels=ch * 8,
ksize=3,
stride=1,
pad=1,
initialW=w)
self.bn6 = L.BatchNormalization(ch * 8)
self.conv8 = L.ConvolutionND(ndim=3,
in_channels=ch * 8,
out_channels=ch * 8,
ksize=3,
stride=2,
pad=1,
initialW=w)
self.bn7 = L.BatchNormalization(ch * 8)
self.fc1 = L.Linear(None, ch * 16, initialW=w)
self.fc2 = L.Linear(ch * 16, 1, initialW=w)
def __init__(self,
n_dims,
in_channels,
hidden_channels,
out_channel,
kernel_size=3,
initialW=initializers.HeNormal(),
initial_bias=None,
block_type='default',
is_residual=False,
batch_norm=False):
self.n_dims = n_dims
self.in_channels = in_channels
self.hidden_channels = hidden_channels
self.out_channel = out_channel
self.kernel_size = kernel_size
self.initialW = initialW
self.initial_bias = initial_bias
self.block_type = block_type
self.is_residual = is_residual
self.batch_norm = batch_norm
pad = self.kernel_size // 2 if self.kernel_size % 2 == 0 else (
self.kernel_size - 1) // 2
super().__init__()
with self.init_scope():
if self.block_type == 'default':
self.conv_1 = L.ConvolutionND(self.n_dims,
self.in_channels,
self.hidden_channels,
self.kernel_size,
stride=1,
pad=pad,
initialW=self.initialW,
initial_bias=self.initial_bias)
self.conv_2 = L.ConvolutionND(self.n_dims,
self.hidden_channels,
self.out_channel,
self.kernel_size,
stride=1,
pad=pad,
initialW=self.initialW,
initial_bias=self.initial_bias)
elif self.block_type == 'dilated':
assert self.n_dims != 2, 'Currently, dilated convolution is unsupported in 3D.'
self.conv_1 = L.DilatedConvolution2D(
self.in_channels,
self.hidden_channels,
self.kernel_size,
stride=1,
pad=pad,
dilate=1,
initialW=self.initialW,
initial_bias=self.initial_bias)
self.conv_2 = L.DilatedConvolution2D(
self.hidden_channels,
self.out_channel,
self.kernel_size,
stride=1,
pad=pad * 2,
dilate=2,
initialW=self.initialW,
initial_bias=self.initial_bias)
elif self.block_type == 'mlp':
assert self.n_dims != 2, 'Currently, mlp convolution is unsupported in 3D.'
self.conv_1 = L.MLPConvolution2D(self.in_channels,
[self.hidden_channels] * 3,
self.kernel_size,
stride=1,
pad=pad,
conv_init=self.initialW,
bias_init=self.initial_bias)
self.conv_2 = L.MLPConvolution2D(self.hidden_channels,
[self.out_channel] * 3,
self.kernel_size,
stride=1,
pad=pad,
conv_init=self.initialW,
bias_init=self.initial_bias)
if self.batch_norm:
self.bn_conv_1 = L.BatchNormalization(self.hidden_channels)
self.bn_conv_2 = L.BatchNormalization(self.out_channel)
def __init__(self,
ndim=3,
n_class=2,
init_channel=2,
kernel_size=3,
pool_size=2,
ap_factor=2,
gpu=-1,
class_weight=np.array([1, 1]).astype(np.float32),
loss_func='F.softmax_cross_entropy'):
self.gpu = gpu
self.pool_size = pool_size
if gpu >= 0:
self.class_weight = cuda.to_gpu(
np.array(class_weight).astype(np.float32))
else:
self.class_weight = np.array(class_weight).astype(np.float32)
self.train = True
self.loss_func = loss_func
initializer = chainer.initializers.HeNormal()
super(Model_L4, self).__init__(
c0=L.ConvolutionND(ndim,
1,
init_channel,
kernel_size,
1,
int(kernel_size / 2),
initialW=initializer,
initial_bias=None),
c1=L.ConvolutionND(ndim,
init_channel,
int(init_channel * (ap_factor**1)),
kernel_size,
1,
int(kernel_size / 2),
initialW=initializer,
initial_bias=None),
c2=L.ConvolutionND(ndim,
int(init_channel * (ap_factor**1)),
int(init_channel * (ap_factor**1)),
kernel_size,
1,
int(kernel_size / 2),
initialW=initializer,
initial_bias=None),
c3=L.ConvolutionND(ndim,
int(init_channel * (ap_factor**1)),
int(init_channel * (ap_factor**2)),
kernel_size,
1,
int(kernel_size / 2),
initialW=initializer,
initial_bias=None),
c4=L.ConvolutionND(ndim,
int(init_channel * (ap_factor**2)),
int(init_channel * (ap_factor**2)),
kernel_size,
1,
int(kernel_size / 2),
initialW=initializer,
initial_bias=None),
c5=L.ConvolutionND(ndim,
int(init_channel * (ap_factor**2)),
int(init_channel * (ap_factor**3)),
kernel_size,
1,
int(kernel_size / 2),
initialW=initializer,
initial_bias=None),
c6=L.ConvolutionND(ndim,
int(init_channel * (ap_factor**3)),
int(init_channel * (ap_factor**3)),
kernel_size,
1,
int(kernel_size / 2),
initialW=initializer,
initial_bias=None),
c7=L.ConvolutionND(ndim,
int(init_channel * (ap_factor**3)),
int(init_channel * (ap_factor**4)),
kernel_size,
1,
int(kernel_size / 2),
initialW=initializer,
initial_bias=None),
c8=L.ConvolutionND(ndim,
int(init_channel * (ap_factor**4)),
int(init_channel * (ap_factor**4)),
kernel_size,
1,
int(kernel_size / 2),
initialW=initializer,
initial_bias=None),
c9=L.ConvolutionND(ndim,
int(init_channel * (ap_factor**4)),
int(init_channel * (ap_factor**5)),
kernel_size,
1,
int(kernel_size / 2),
initialW=initializer,
initial_bias=None),
dc0=L.DeconvolutionND(ndim,
int(init_channel * (ap_factor**5)),
int(init_channel * (ap_factor**5)),
self.pool_size,
self.pool_size,
0,
initialW=initializer,
initial_bias=None),
dc1=L.ConvolutionND(ndim,
int(init_channel * (ap_factor**4) +
init_channel * (ap_factor**5)),
int(init_channel * (ap_factor**4)),
kernel_size,
1,
int(kernel_size / 2),
initialW=initializer,
initial_bias=None),
dc2=L.ConvolutionND(ndim,
int(init_channel * (ap_factor**4)),
int(init_channel * (ap_factor**4)),
kernel_size,
1,
int(kernel_size / 2),
initialW=initializer,
initial_bias=None),
dc3=L.DeconvolutionND(ndim,
int(init_channel * (ap_factor**4)),
int(init_channel * (ap_factor**4)),
self.pool_size,
self.pool_size,
0,
initialW=initializer,
initial_bias=None),
dc4=L.ConvolutionND(ndim,
int(init_channel * (ap_factor**3) +
init_channel * (ap_factor**4)),
int(init_channel * (ap_factor**3)),
kernel_size,
1,
int(kernel_size / 2),
initialW=initializer,
initial_bias=None),
dc5=L.ConvolutionND(ndim,
int(init_channel * (ap_factor**3)),
int(init_channel * (ap_factor**3)),
kernel_size,
1,
int(kernel_size / 2),
initialW=initializer,
initial_bias=None),
dc6=L.DeconvolutionND(ndim,
int(init_channel * (ap_factor**3)),
int(init_channel * (ap_factor**3)),
self.pool_size,
self.pool_size,
0,
initialW=initializer,
initial_bias=None),
dc7=L.ConvolutionND(ndim,
int(init_channel * (ap_factor**2) +
init_channel * (ap_factor**3)),
int(init_channel * (ap_factor**2)),
kernel_size,
1,
int(kernel_size / 2),
initialW=initializer,
initial_bias=None),
dc8=L.ConvolutionND(ndim,
int(init_channel * (ap_factor**2)),
int(init_channel * (ap_factor**2)),
kernel_size,
1,
int(kernel_size / 2),
initialW=initializer,
initial_bias=None),
dc9=L.DeconvolutionND(ndim,
int(init_channel * (ap_factor**2)),
int(init_channel * (ap_factor**2)),
self.pool_size,
self.pool_size,
0,
initialW=initializer,
initial_bias=None),
dc10=L.ConvolutionND(ndim,
int(init_channel * (ap_factor**1) +
init_channel * (ap_factor**2)),
int(init_channel * (ap_factor**1)),
kernel_size,
1,
int(kernel_size / 2),
initialW=initializer,
initial_bias=None),
dc11=L.ConvolutionND(ndim,
int(init_channel * (ap_factor**1)),
int(init_channel * (ap_factor**1)),
kernel_size,
1,
int(kernel_size / 2),
initialW=initializer,
initial_bias=None),
dc12=L.ConvolutionND(ndim,
int(init_channel * (ap_factor**1)),
n_class,
1,
1,
initialW=initializer,
initial_bias=None),
bnc0=L.BatchNormalization(init_channel),
bnc1=L.BatchNormalization(int(init_channel * (ap_factor**1))),
bnc2=L.BatchNormalization(int(init_channel * (ap_factor**1))),
bnc3=L.BatchNormalization(int(init_channel * (ap_factor**2))),
bnc4=L.BatchNormalization(int(init_channel * (ap_factor**2))),
bnc5=L.BatchNormalization(int(init_channel * (ap_factor**3))),
bnc6=L.BatchNormalization(int(init_channel * (ap_factor**3))),
bnc7=L.BatchNormalization(int(init_channel * (ap_factor**4))),
bnc8=L.BatchNormalization(int(init_channel * (ap_factor**4))),
bnc9=L.BatchNormalization(int(init_channel * (ap_factor**5))),
bndc1=L.BatchNormalization(int(init_channel * (ap_factor**4))),
bndc2=L.BatchNormalization(int(init_channel * (ap_factor**4))),
bndc4=L.BatchNormalization(int(init_channel * (ap_factor**3))),
bndc5=L.BatchNormalization(int(init_channel * (ap_factor**3))),
bndc7=L.BatchNormalization(int(init_channel * (ap_factor**2))),
bndc8=L.BatchNormalization(int(init_channel * (ap_factor**2))),
bndc10=L.BatchNormalization(int(init_channel * (ap_factor**1))),
bndc11=L.BatchNormalization(int(init_channel * (ap_factor**1))))
def __init__(self):
super(_CRF, self).__init__(L.ConvolutionND(1, 2, 2, 1, nobias=True))
def __init__(self, in_channel, n_classes):
self.in_channel = in_channel
super(UNet3DBN, self).__init__(
c0=L.ConvolutionND(3,
self.in_channel,
32,
3,
1,
1,
initial_bias=None),
c1=L.ConvolutionND(3, 32, 64, 3, 1, 1, initial_bias=None),
c2=L.ConvolutionND(3, 64, 64, 3, 1, 1, initial_bias=None),
c3=L.ConvolutionND(3, 64, 128, 3, 1, 1, initial_bias=None),
c4=L.ConvolutionND(3, 128, 128, 3, 1, 1, initial_bias=None),
c5=L.ConvolutionND(3, 128, 256, 3, 1, 1, initial_bias=None),
c6=L.ConvolutionND(3, 256, 256, 3, 1, 1, initial_bias=None),
c7=L.ConvolutionND(3, 256, 512, 3, 1, 1, initial_bias=None),
# c8=L.ConvolutionND(3, 512, 512, 3, 1, 1, initial_bias=None),
dc9=L.DeconvolutionND(3, 512, 512, 2, 2, initial_bias=None),
dc8=L.ConvolutionND(3, 256 + 512, 256, 3, 1, 1, initial_bias=None),
dc7=L.ConvolutionND(3, 256, 256, 3, 1, 1, initial_bias=None),
dc6=L.DeconvolutionND(3, 256, 256, 2, 2, initial_bias=None),
dc5=L.ConvolutionND(3, 128 + 256, 128, 3, 1, 1, initial_bias=None),
dc4=L.ConvolutionND(3, 128, 128, 3, 1, 1, initial_bias=None),
dc3=L.DeconvolutionND(3, 128, 128, 2, 2, initial_bias=None),
dc2=L.ConvolutionND(3, 64 + 128, 64, 3, 1, 1, initial_bias=None),
dc1=L.ConvolutionND(3, 64, 64, 3, 1, 1, initial_bias=None),
dc0=L.ConvolutionND(3, 64, n_classes, 1, 1, initial_bias=None),
bnc0=L.BatchNormalization(32),
bnc1=L.BatchNormalization(64),
bnc2=L.BatchNormalization(64),
bnc3=L.BatchNormalization(128),
bnc4=L.BatchNormalization(128),
bnc5=L.BatchNormalization(256),
bnc6=L.BatchNormalization(256),
bnc7=L.BatchNormalization(512),
# bnc8=L.BatchNormalization(512),
# bnd9=L.BatchNormalization(512),
bnd8=L.BatchNormalization(256),
bnd7=L.BatchNormalization(256),
# bnd6=L.BatchNormalization(256),
bnd5=L.BatchNormalization(128),
bnd4=L.BatchNormalization(128),
# bnd3=L.BatchNormalization(128),
bnd2=L.BatchNormalization(64),
bnd1=L.BatchNormalization(64))
self.train = True
def __init__(self,
in_size=[1, 2],
encoder_n_units=10,
regression_n_units=10,
common_out_size=10):
super(EncoderRegressionModel, self).__init__()
with self.init_scope():
initial_w = initializers.HeNormal()
self.common_out_size = common_out_size
# Encoder 1
self.encoder11 = links.Linear(in_size[0],
encoder_n_units,
initialW=initial_w)
self.encoder12 = links.Linear(encoder_n_units,
encoder_n_units,
initialW=initial_w)
self.encoder13 = links.Linear(encoder_n_units,
encoder_n_units,
initialW=initial_w)
self.encoder14 = links.Linear(encoder_n_units,
common_out_size,
initialW=initial_w)
# Encoder 2
self.encoder21 = links.Linear(in_size[1],
encoder_n_units,
initialW=initial_w)
self.encoder22 = links.Linear(encoder_n_units,
encoder_n_units,
initialW=initial_w)
self.encoder23 = links.Linear(encoder_n_units,
encoder_n_units,
initialW=initial_w)
self.encoder24 = links.Linear(encoder_n_units,
common_out_size,
initialW=initial_w)
# Decoder 1
self.decoder11 = links.Linear(common_out_size,
encoder_n_units,
initialW=initial_w)
self.decoder12 = links.Linear(encoder_n_units,
encoder_n_units,
initialW=initial_w)
self.decoder13 = links.Linear(encoder_n_units,
encoder_n_units,
initialW=initial_w)
self.decoder14 = links.Linear(encoder_n_units,
in_size[0],
initialW=initial_w)
# Regression 2
self.conv = links.ConvolutionND(ndim=1,
in_channels=1,
out_channels=regression_n_units,
ksize=common_out_size,
stride=1,
pad=0,
initialW=initial_w)
self.fc = links.Linear(encoder_n_units, 1)
def __init__(self, label):
super(UNet3D, self).__init__()
with self.init_scope():
self.conv1 = L.ConvolutionND(ndim=3,in_channels=1, out_channels=16, ksize=3)
self.conv2 = L.ConvolutionND(ndim=3,in_channels=16, out_channels=32, ksize=3)
self.conv3 = L.ConvolutionND(ndim=3,in_channels=32, out_channels=32, ksize=3)
self.conv4 = L.ConvolutionND(ndim=3,in_channels=32, out_channels=64, ksize=3)
self.conv5 = L.ConvolutionND(ndim=3,in_channels=64, out_channels=64, ksize=3)
self.conv6 = L.ConvolutionND(ndim=3,in_channels=64, out_channels=128, ksize=3)
self.conv7 = L.ConvolutionND(ndim=3,in_channels=128, out_channels=128, ksize=3)
self.conv8 = L.ConvolutionND(ndim=3,in_channels=128, out_channels=256, ksize=3)
self.dconv1 = L.DeconvolutionND(ndim=3, in_channels=256, out_channels=256, ksize=2, stride=2)
self.conv9 = L.ConvolutionND(ndim=3,in_channels=128 + 256, out_channels=128, ksize=3)
self.conv10 = L.ConvolutionND(ndim=3,in_channels=128, out_channels=128, ksize=3)
self.dconv2 = L.DeconvolutionND(ndim=3, in_channels=128, out_channels=128, ksize=2, stride=2)
self.conv11 = L.ConvolutionND(ndim=3,in_channels=64 + 128, out_channels=64, ksize=3)
self.conv12 = L.ConvolutionND(ndim=3,in_channels=64, out_channels=64, ksize=3)
self.dconv3 = L.DeconvolutionND(ndim=3, in_channels=64, out_channels=64, ksize=2, stride=2)
self.conv13 = L.ConvolutionND(ndim=3,in_channels=32 + 64, out_channels=32, ksize=3)
self.conv14 = L.ConvolutionND(ndim=3,in_channels=32, out_channels=32, ksize=3)
self.conv15 = L.ConvolutionND(ndim=3,in_channels=32, out_channels=label, ksize=1)
self.bnc0=L.BatchNormalization(16)
self.bnc1=L.BatchNormalization(32)
self.bnc2=L.BatchNormalization(32)
self.bnc3=L.BatchNormalization(64)
self.bnc4=L.BatchNormalization(64)
self.bnc5=L.BatchNormalization(128)
self.bnc6=L.BatchNormalization(128)
self.bnc7=L.BatchNormalization(256)
# bnc8=L.BatchNormalization(512)
# bnd9=L.BatchNormalization(512)
self.bnd8=L.BatchNormalization(128)
self.bnd7=L.BatchNormalization(128)
# bnd6=L.BatchNormalization(256)
self.bnd5=L.BatchNormalization(64)
self.bnd4=L.BatchNormalization(64)
# bnd3=L.BatchNormalization(128)
self.bnd2=L.BatchNormalization(32)
self.bnd1=L.BatchNormalization(32)
self.train = True
def __init__(self, vocab_size, n_labels, word_vocab_size, n_pos, out_size,
dropout, args):
self.args = args
sent_len = 4096 #args.maxlen
out_channels = int(sent_len * 2)
super().__init__(
embed_tri=L.EmbedID(vocab_size[0], out_size, ignore_label=-1),
embed_four=L.EmbedID(vocab_size[1], out_size, ignore_label=-1),
embed_word=L.EmbedID(word_vocab_size, out_size, ignore_label=-1),
embed_pos=L.EmbedID(n_pos, out_size, ignore_label=-1),
# Block 1
bn1=L.BatchNormalization(out_size),
conv1=L.ConvolutionND(ndim=1,
in_channels=out_size,
out_channels=out_size,
ksize=3,
stride=2,
cover_all=True),
bn2=L.BatchNormalization(out_size),
conv2=L.ConvolutionND(ndim=1,
in_channels=out_size,
out_channels=out_size,
ksize=2,
stride=2,
cover_all=True),
# Block 2
bn3=L.BatchNormalization(out_size * 2),
conv3=L.ConvolutionND(ndim=1,
in_channels=out_size * 2,
out_channels=out_size * 2,
ksize=2,
stride=2,
cover_all=True),
bn4=L.BatchNormalization(out_size * 2),
conv4=L.ConvolutionND(ndim=1,
in_channels=out_size * 2,
out_channels=out_size * 2,
ksize=2,
stride=2,
cover_all=True),
# Block 3
bn5=L.BatchNormalization(out_size * 4),
conv5=L.ConvolutionND(ndim=1,
in_channels=out_size * 4,
out_channels=out_size * 4,
ksize=2,
stride=2,
cover_all=True),
bn6=L.BatchNormalization(out_size * 4),
conv6=L.ConvolutionND(ndim=1,
in_channels=out_size * 4,
out_channels=out_size * 4,
ksize=2,
stride=2,
cover_all=True),
# Block 4
bn7=L.BatchNormalization(out_size * 8),
conv7=L.ConvolutionND(ndim=1,
in_channels=out_size * 8,
out_channels=out_size * 8,
ksize=2,
stride=2,
cover_all=True),
bn8=L.BatchNormalization(out_size * 8),
conv8=L.ConvolutionND(ndim=1,
in_channels=out_size * 8,
out_channels=out_size * 8,
ksize=2,
stride=2,
cover_all=True),
# Block 1
bn1_b=L.BatchNormalization(out_size),
conv1_b=L.ConvolutionND(ndim=1,
in_channels=out_size,
out_channels=out_size,
ksize=3,
stride=2,
cover_all=True),
bn2_b=L.BatchNormalization(out_size),
conv2_b=L.ConvolutionND(ndim=1,
in_channels=out_size,
out_channels=out_size,
ksize=2,
stride=2,
cover_all=True),
# Block 2
bn3_b=L.BatchNormalization(out_size * 2),
conv3_b=L.ConvolutionND(ndim=1,
in_channels=out_size * 2,
out_channels=out_size * 2,
ksize=2,
stride=2,
cover_all=True),
bn4_b=L.BatchNormalization(out_size * 2),
conv4_b=L.ConvolutionND(ndim=1,
in_channels=out_size * 2,
out_channels=out_size * 2,
ksize=2,
stride=2,
cover_all=True),
# Block 3
bn5_b=L.BatchNormalization(out_size * 4),
conv5_b=L.ConvolutionND(ndim=1,
in_channels=out_size * 4,
out_channels=out_size * 4,
ksize=2,
stride=2,
cover_all=True),
bn6_b=L.BatchNormalization(out_size * 4),
conv6_b=L.ConvolutionND(ndim=1,
in_channels=out_size * 4,
out_channels=out_size * 4,
ksize=2,
stride=2,
cover_all=True),
# Block 4
bn7_b=L.BatchNormalization(out_size * 8),
conv7_b=L.ConvolutionND(ndim=1,
in_channels=out_size * 8,
out_channels=out_size * 8,
ksize=2,
stride=2,
cover_all=True),
bn8_b=L.BatchNormalization(out_size * 8),
conv8_b=L.ConvolutionND(ndim=1,
in_channels=out_size * 8,
out_channels=out_size * 8,
ksize=2,
stride=2,
cover_all=True),
# Block 1
bn1_w=L.BatchNormalization(out_size),
conv1_w=L.ConvolutionND(ndim=1,
in_channels=out_size,
out_channels=out_size,
ksize=2,
stride=2,
cover_all=True),
bn2_w=L.BatchNormalization(out_size),
conv2_w=L.ConvolutionND(ndim=1,
in_channels=out_size,
out_channels=out_size,
ksize=2,
stride=2,
cover_all=True),
# Block 2
bn3_w=L.BatchNormalization(out_size * 2),
conv3_w=L.ConvolutionND(ndim=1,
in_channels=out_size * 2,
out_channels=out_size * 2,
ksize=2,
stride=2,
cover_all=True),
bn4_w=L.BatchNormalization(out_size * 2),
conv4_w=L.ConvolutionND(ndim=1,
in_channels=out_size * 2,
out_channels=out_size * 2,
ksize=2,
stride=2,
cover_all=True),
# Block 1
bn1_p=L.BatchNormalization(out_size),
conv1_p=L.ConvolutionND(ndim=1,
in_channels=out_size,
out_channels=out_size,
ksize=2,
stride=2,
cover_all=True),
bn2_p=L.BatchNormalization(out_size),
conv2_p=L.ConvolutionND(ndim=1,
in_channels=out_size,
out_channels=out_size,
ksize=2,
stride=2,
cover_all=True),
# Block 2
bn3_p=L.BatchNormalization(out_size * 2),
conv3_p=L.ConvolutionND(ndim=1,
in_channels=out_size * 2,
out_channels=out_size * 2,
ksize=2,
stride=2,
cover_all=True),
bn4_p=L.BatchNormalization(out_size * 2),
conv4_p=L.ConvolutionND(ndim=1,
in_channels=out_size * 2,
out_channels=out_size * 2,
ksize=2,
stride=2,
cover_all=True),
fcb1=L.Linear(None, 1024),
fcb2=L.Linear(1024, 128),
# Fully connected
#fc3 = L.Linear(None, 2048),
#fctri = L.Linear(None, 2048),
fcfour=L.Linear(None, 2048),
fcword=L.Linear(None, 1024),
#fcpos = L.Linear(None, 1024),
#fc4 = L.Linear(None, 1024),
fc5=L.Linear(None, 1024),
fc6=L.Linear(None, 256),
fc7=L.Linear(None, n_labels),
)
self.dropout = dropout
self.train = True
self.first = True
def __init__(self, label):
super(UNet3D, self).__init__()
with self.init_scope():
#encorder pass
self.conv1 = L.ConvolutionND(ndim=3,
in_channels=1,
out_channels=8,
ksize=3,
pad=1)
self.bnc0 = L.BatchNormalization(8)
self.conv2 = L.ConvolutionND(ndim=3,
in_channels=8,
out_channels=16,
ksize=3,
pad=1)
self.bnc1 = L.BatchNormalization(16)
self.conv3 = L.ConvolutionND(ndim=3,
in_channels=16,
out_channels=16,
ksize=3,
pad=1)
self.bnc2 = L.BatchNormalization(16)
self.conv4 = L.ConvolutionND(ndim=3,
in_channels=16,
out_channels=32,
ksize=3,
pad=1)
self.bnc3 = L.BatchNormalization(32)
self.conv5 = L.ConvolutionND(ndim=3,
in_channels=32,
out_channels=32,
ksize=3,
pad=1)
self.bnc4 = L.BatchNormalization(32)
self.conv6 = L.ConvolutionND(ndim=3,
in_channels=32,
out_channels=64,
ksize=3,
pad=1)
self.bnc5 = L.BatchNormalization(64)
#decorder pass
self.dconv1 = L.DeconvolutionND(ndim=3,
in_channels=64,
out_channels=64,
ksize=2,
stride=2)
self.conv7 = L.ConvolutionND(ndim=3,
in_channels=32 + 64,
out_channels=32,
ksize=3,
pad=1)
self.bnd4 = L.BatchNormalization(32)
self.conv8 = L.ConvolutionND(ndim=3,
in_channels=32,
out_channels=32,
ksize=3,
pad=1)
self.bnd3 = L.BatchNormalization(32)
self.dconv2 = L.DeconvolutionND(ndim=3,
in_channels=32,
out_channels=32,
ksize=2,
stride=2)
self.conv9 = L.ConvolutionND(ndim=3,
in_channels=16 + 32,
out_channels=16,
ksize=3,
pad=1)
self.bnd2 = L.BatchNormalization(16)
self.conv10 = L.ConvolutionND(ndim=3,
in_channels=16,
out_channels=16,
ksize=3,
pad=1)
self.bnd1 = L.BatchNormalization(16)
self.lcl = L.ConvolutionND(ndim=3,
in_channels=16,
out_channels=label,
ksize=1,
pad=0)
def __init__(self, in_channel, n_classes):
self.in_channel = in_channel
super(UNet3D, self).__init__(
c0=L.ConvolutionND(3, self.in_channel, 32, 3, 1, 1, initial_bias=None),
c1=L.ConvolutionND(3, 32, 64, 3, 1, 1, initial_bias=None),
c2=L.ConvolutionND(3, 64, 64, 3, 1, 1, initial_bias=None),
c3=L.ConvolutionND(3, 64, 128, 3, 1, 1, initial_bias=None),
c4=L.ConvolutionND(3, 128, 128, 3, 1, 1, initial_bias=None),
c5=L.ConvolutionND(3, 128, 256, 3, 1, 1, initial_bias=None),
c6=L.ConvolutionND(3, 256, 256, 3, 1, 1, initial_bias=None),
c7=L.ConvolutionND(3, 256, 512, 3, 1, 1, initial_bias=None),
dc9=L.DeconvolutionND(3, 512, 512, 2, 2, initial_bias=None),
dc8=L.ConvolutionND(3, 256 + 512, 256, 3, 1, 1, initial_bias=None),
dc7=L.ConvolutionND(3, 256, 256, 3, 1, 1, initial_bias=None),
dc6=L.DeconvolutionND(3, 256, 256, 2, 2, initial_bias=None),
dc5=L.ConvolutionND(3, 128 + 256, 128, 3, 1, 1, initial_bias=None),
dc4=L.ConvolutionND(3, 128, 128, 3, 1, 1, initial_bias=None),
dc3=L.DeconvolutionND(3, 128, 128, 2, 2, initial_bias=None),
dc2=L.ConvolutionND(3, 64 + 128, 64, 3, 1, 1, initial_bias=None),
dc1=L.ConvolutionND(3, 64, 64, 3, 1, 1, initial_bias=None),
dc0=L.ConvolutionND(3, 64, n_classes, 1, 1, initial_bias=None),
)
self.train = True
def __init__(self, vocab, vocab_ngram_tokens, n_units, n_units_char,
dropout, subword): # dropout ratio, zero indicates no dropout
super(CNN1D, self).__init__()
with self.init_scope():
self.subword = subword
# n_units_char = 15
self.embed = L.EmbedID(
len(vocab_ngram_tokens.lst_words) + 2,
n_units_char,
initialW=I.Uniform(1. / n_units_char)
) # ngram tokens embedding plus 2 for OOV and end symbol.
self.n_ngram = vocab_ngram_tokens.metadata[
"max_gram"] - vocab_ngram_tokens.metadata["min_gram"] + 1
# n_filters = {i: min(200, i * 5) for i in range(1, 1 + 1)}
# self.cnns = (L.Convolution2D(1, v, (k, n_units_char),) for k, v in n_filters.items())
# self.out = L.Linear(sum([v for k, v in n_filters.items()]), n_units)
if 'small' in self.subword:
self.cnn1 = L.ConvolutionND(
1,
n_units_char,
50,
(1, ),
)
self.out = L.Linear(50, n_units)
else:
self.cnn1 = L.ConvolutionND(
1,
n_units_char,
50,
(1, ),
)
self.cnn2 = L.ConvolutionND(
1,
n_units_char,
100,
(2, ),
)
self.cnn3 = L.ConvolutionND(
1,
n_units_char,
150,
(3, ),
)
self.cnn4 = L.ConvolutionND(
1,
n_units_char,
200,
(4, ),
)
self.cnn5 = L.ConvolutionND(
1,
n_units_char,
200,
(5, ),
)
self.cnn6 = L.ConvolutionND(
1,
n_units_char,
200,
(6, ),
)
self.cnn7 = L.ConvolutionND(
1,
n_units_char,
200,
(7, ),
)
self.out = L.Linear(1100, n_units)
self.dropout = dropout
self.vocab = vocab
self.vocab_ngram_tokens = vocab_ngram_tokens
def __init__(self, dimz, gf_dim=512, lamda=0.1):
self.dimz = dimz
self.gf_dim = gf_dim
self.lamda = lamda
w = chainer.initializers.Normal(0.02)
super(Generator, self).__init__(
### fore img generator
l_f0=L.Linear(dimz, 4 * 4 * gf_dim // 2 * 2, initialW=w),
bn_f0=L.BatchNormalization(4 * 4 * gf_dim // 2 * 2),
dc_f1=CBR3D(gf_dim // 2,
gf_dim // 4,
bn=True,
sample='up',
activation=F.relu),
dc_f2=CBR3D(gf_dim // 4,
gf_dim // 8,
bn=True,
sample='up',
activation=F.relu),
### back img generator
l_b0=L.Linear(self.dimz, 4 * 4 * gf_dim, initialW=w),
bn_b0=L.BatchNormalization(4 * 4 * gf_dim),
dc_b1=CBR(None,
gf_dim // 2,
bn=True,
sample='up',
activation=F.relu),
dc_b2=CBR(None,
gf_dim // 4,
bn=True,
sample='up',
activation=F.relu),
dc_b3=CBR(None,
gf_dim // 8,
bn=True,
sample='up',
activation=F.relu),
dc_b4=L.Deconvolution2D(None, 3, 4, 2, 1, initialW=w),
### flow colorizer w U-net
c_m1=CBR3D(2,
gf_dim // 16,
bn=False,
sample='down',
activation=F.leaky_relu),
c_m2=CBR3D(gf_dim // 16,
gf_dim // 8,
bn=True,
sample='down',
activation=F.leaky_relu),
c_m3=CBR3D(gf_dim // 4,
gf_dim // 4,
bn=True,
sample='same',
activation=F.leaky_relu),
c_m4=CBR3D(gf_dim // 4,
gf_dim // 2,
bn=True,
sample='down',
activation=F.leaky_relu),
c_m5=CBR3D(gf_dim // 2,
gf_dim,
bn=True,
sample='down',
activation=F.leaky_relu),
dc_m1=CBR3D(gf_dim,
gf_dim // 2,
bn=True,
sample='up',
activation=F.relu),
dc_m2=CBR3D(gf_dim,
gf_dim // 4,
bn=True,
sample='up',
activation=F.relu),
dc_m3=CBR3D(gf_dim // 2,
gf_dim // 8,
bn=True,
sample='up',
activation=F.relu),
dc_mask=L.DeconvolutionND(3, gf_dim // 8, 1, 4, 2, 1, initialW=w),
dc_m4=CBR3D(gf_dim // 16 * 3,
gf_dim // 16,
bn=True,
sample='up',
activation=F.relu),
dc_m5=L.ConvolutionND(3, gf_dim // 16, 3, 3, 1, 1, initialW=w),
)
def __init__(self,
in_channel,
out_channel,
n_dims=2,
kernel_size=3,
n_layers=5,
n_filters=64,
is_bayesian=False,
is_residual=False,
initialW=initializers.HeNormal(),
initial_bias=None,
batch_norm=False,
block_type='default',
**kwargs):
self.n_dims = n_dims
if self.n_dims != 2 and self.n_dims != 3:
warnings.warn('unsupported number of input dimensions.')
self.in_channel = in_channel
self.out_channel = out_channel
self.n_layers = n_layers
self.n_filters = n_filters
self.kernel_size = kernel_size
self.is_bayesian = is_bayesian
self.is_residual = is_residual
self.initialW = initialW
self.initial_bias = initial_bias
self.block_type = block_type
self.batch_norm = batch_norm
chainer.Chain.__init__(self)
with self.init_scope():
# down convolution
for i in range(1, self.n_layers + 1):
if i == 1:
setattr(
self, 'down_unet_block_%d' % i,
UNetBlock(self.n_dims,
self.in_channel,
self.n_filters * (2**(i - 1)),
self.n_filters * (2**(i - 1)),
self.kernel_size,
initialW=initialW,
initial_bias=initial_bias,
is_residual=self.is_residual,
block_type=block_type,
batch_norm=batch_norm))
else:
setattr(
self, 'down_unet_block_%d' % i,
UNetBlock(self.n_dims,
self.n_filters * (2**(i - 2)),
self.n_filters * (2**(i - 1)),
self.n_filters * (2**(i - 1)),
self.kernel_size,
initialW=initialW,
initial_bias=initial_bias,
is_residual=self.is_residual,
block_type=block_type,
batch_norm=batch_norm))
# up convolution
for i in range(1, self.n_layers):
deconv_n_filters = self['down_unet_block_%d' %
(i + 1)].out_channel
setattr(
self, 'deconv_%d' % i,
L.DeconvolutionND(self.n_dims,
deconv_n_filters,
deconv_n_filters,
self.kernel_size,
stride=2,
pad=0,
initialW=initialW,
initial_bias=initial_bias))
if self.batch_norm:
setattr(self, 'bn_deconv_%d' % i,
L.BatchNormalization(deconv_n_filters))
upconv_n_filters = self['down_unet_block_%d' %
i].out_channel + self['deconv_%d' %
i].W.shape[1]
setattr(
self, 'up_unet_block_%d' % i,
UNetBlock(self.n_dims,
upconv_n_filters,
self.n_filters * (2**(i - 1)),
self.n_filters * (2**(i - 1)),
self.kernel_size,
initialW=initialW,
initial_bias=initial_bias,
is_residual=self.is_residual,
block_type=block_type,
batch_norm=batch_norm))
if i == 1: # output layer
setattr(
self, 'up_conv%d_3' % i,
L.ConvolutionND(self.n_dims,
self.n_filters * (2**(i - 1)),
self.out_channel,
ksize=self.kernel_size,
stride=1,
pad=1,
initialW=initialW,
initial_bias=initial_bias))
# initialize weights for deconv layer
for i in range(1, self.n_layers):
deconv_k_size = self['deconv_%d' % i].W.shape[-1]
deconv_n_filters = self['deconv_%d' % i].W.shape[1]
self['deconv_%d' % i].W.data[...] = 0
if self.n_dims == 2:
filt = get_upsampling_filter_2d(deconv_k_size)
self['deconv_%d' %
i].W.data[range(deconv_n_filters),
range(deconv_n_filters), :, :] = filt
elif self.n_dims == 3:
filt = get_upsampling_filter_3d(deconv_k_size)
self['deconv_%d' %
i].W.data[range(deconv_n_filters),
range(deconv_n_filters), :, :, :] = filt
def __init__(self, comm, mask, feature_dim,
encoder_channels: Sequence[int],
encoder_layers: Sequence[int],
decoder_channels: Sequence[int],
decoder_layers: Sequence[int]):
super().__init__()
assert len(encoder_layers) == len(decoder_layers)
assert len(encoder_channels) == len(encoder_layers)
assert encoder_layers[0] == 1
assert len(decoder_channels) == len(decoder_layers)
self.comm = comm
self.mask = mask
self.feature_dim = feature_dim
self.encoder_channels = encoder_channels
self.encoder_layers = encoder_layers
self.decoder_channels = decoder_channels
self.decoder_layers = decoder_layers
self.shapes = self.get_shapes(mask.shape, len(encoder_layers))
self.loss_const = self.mask.size / self.mask.sum()
with self.init_scope():
# Encoding Block
for layer_idx, num_layers in enumerate(encoder_layers):
for rep_idx in range(num_layers):
in_channel = 2 if layer_idx == 0 and rep_idx == 0 else encoder_channels[
layer_idx]
if rep_idx == num_layers - 1 and layer_idx != len(
encoder_layers
) - 1: # 各layerの出力層，ただしfeatureを出力する層は除く
out_channel, stride = encoder_channels[layer_idx +
1], 2
else:
out_channel, stride = encoder_channels[layer_idx], 1
"""
def __init__(self, comm, in_channel, out_channel, stride=1):
"""
if layer_idx != 0:
self.add_link(
"conv_{}_{}".format(layer_idx, rep_idx),
ResBlockMN(self.comm, in_channel, out_channel,
stride))
else:
"""
def __init__(self, ndim, in_channels, out_channels, ksize, stride=1, pad=0, nobias=False, initialW=None, initial_bias=None, cover_all=False):
"""
self.add_link(
"conv_{}_{}".format(layer_idx, rep_idx),
L.ConvolutionND(3, in_channel, out_channel, 5,
stride, 2))
# Extract Block
"""
def __init__(self, in_size, out_size=None, nobias=False, initialW=None, initial_bias=None):
"""
self.linear_extract = L.Linear(
np.prod(
self.chain((self.encoder_channels[-1], ),
self.shapes[-1])), self.feature_dim)
self.linear_reconstruct = L.Linear(
self.feature_dim,
np.prod(
self.chain((self.decoder_channels[-1], ),
self.shapes[-1])))
# Decoding Block
for layer_idx, num_layers in reversed(
tuple(enumerate(decoder_layers))):
for rep_idx in range(num_layers):
if rep_idx == 0 and layer_idx != len(
decoder_layers
) - 1: # 各layerの入力層，ただしfeatureを受け取る層は除く
in_channel = decoder_channels[layer_idx + 1]
else:
in_channel = decoder_channels[layer_idx]
out_channel = 1 if layer_idx == 0 and rep_idx == num_layers - 1 else decoder_channels[
layer_idx]
stride = 1
self.add_link(
"dcnv_{}_{}".format(layer_idx, rep_idx),
ResBlockMN(self.comm, in_channel, out_channel, stride))
