def __init__(self, n_class, aspect_ratios):
init = {
'initialW': initializers.GlorotUniform(),
'initial_bias': initializers.constant.Zero(),
}
super().__init__(
base=L.VGG16Layers(pretrained_model=None),
conv5_1=L.DilatedConvolution2D(None, 512, 3, pad=1, **init),
conv5_2=L.DilatedConvolution2D(None, 512, 3, pad=1, **init),
conv5_3=L.DilatedConvolution2D(None, 512, 3, pad=1, **init),
conv6=L.DilatedConvolution2D(None,
1024,
3,
pad=6,
dilate=6,
**init),
conv7=L.Convolution2D(None, 1024, 1, **init),
conv8_1=L.Convolution2D(None, 256, 1, **init),
conv8_2=L.Convolution2D(None, 512, 3, stride=2, pad=1, **init),
conv9_1=L.Convolution2D(None, 128, 1, **init),
conv9_2=L.Convolution2D(None, 256, 3, stride=2, pad=1, **init),
conv10_1=L.Convolution2D(None, 128, 1, **init),
conv10_2=L.Convolution2D(None, 256, 3, **init),
conv11_1=L.Convolution2D(None, 128, 1, **init),
conv11_2=L.Convolution2D(None, 256, 3, **init),
multibox=MultiBox(n_class, aspect_ratios=aspect_ratios, init=init),
)
self.n_class = n_class
self.aspect_ratios = aspect_ratios
self.train = False
def __init__(self, n_fg_class):
super(LatterSsdNet, self).__init__()
with self.init_scope():
self.norm4 = Normalize(512)
# remained conv net in VGG16 class: chainercv/links/model/ssd/ssd_vgg16.py
self.conv5_1 = L.DilatedConvolution2D(512, 3, pad=1)
self.conv5_2 = L.DilatedConvolution2D(512, 3, pad=1)
self.conv5_3 = L.DilatedConvolution2D(512, 3, pad=1)
self.conv6 = L.DilatedConvolution2D(1024, 3, pad=6, dilate=6)
self.conv7 = L.Convolution2D(1024, 1)
# based on VGG16Extractor300 class: chainercv/links/model/ssd/ssd_vgg16.py
self.conv8_1 = L.Convolution2D(256, 1)
self.conv8_2 = L.Convolution2D(512, 3, stride=2, pad=1)
self.conv9_1 = L.Convolution2D(128, 1)
self.conv9_2 = L.Convolution2D(256, 3, stride=2, pad=1)
self.conv10_1 = L.Convolution2D(128, 1)
self.conv10_2 = L.Convolution2D(256, 3)
self.conv11_1 = L.Convolution2D(128, 1)
self.conv11_2 = L.Convolution2D(256, 3)
# Multibox class: chainercv/links/model/ssd/ssd_vgg16.py
self.multibox = Multibox(n_class=n_fg_class + 1,
aspect_ratios=((2, ), (2, 3), (2, 3),
(2, 3), (2, ), (2, )))
def __init__(self, **links):
super(VGG16, self).__init__(
conv1_1=L.Convolution2D(None, 64, 3, pad=1),
conv1_2=L.Convolution2D(None, 64, 3, pad=1),
conv2_1=L.Convolution2D(None, 128, 3, pad=1),
conv2_2=L.Convolution2D(None, 128, 3, pad=1),
conv3_1=L.Convolution2D(None, 256, 3, pad=1),
conv3_2=L.Convolution2D(None, 256, 3, pad=1),
conv3_3=L.Convolution2D(None, 256, 3, pad=1),
conv4_1=L.Convolution2D(None, 512, 3, pad=1),
conv4_2=L.Convolution2D(None, 512, 3, pad=1),
conv4_3=L.Convolution2D(None, 512, 3, pad=1),
norm4=Normalize(512, initial=initializers.Constant(20)),
conv5_1=L.DilatedConvolution2D(None, 512, 3, pad=1),
conv5_2=L.DilatedConvolution2D(None, 512, 3, pad=1),
conv5_3=L.DilatedConvolution2D(None, 512, 3, pad=1),
conv6=L.DilatedConvolution2D(None, 1024, 3, pad=6, dilate=6),
conv7=L.Convolution2D(None, 1024, 1),
)
for name, link in six.iteritems(links):
self.add_link(name, link)
def __init__(self, n_class=3, bn=True, wpad=True):
super(UNetDilate, self).__init__()
pad = 1 if wpad else 0
self.outsize = self.insize if wpad else (self.insize - 92)
self.add_link('c1_1', L.Convolution2D(6,
64,
ksize=3,
stride=1,
pad=pad))
self.add_link('c1_2',
L.Convolution2D(64, 64, ksize=3, stride=1, pad=pad))
self.add_link('c2_1',
L.Convolution2D(64, 64, ksize=3, stride=1, pad=pad))
self.add_link('c2_2',
L.Convolution2D(64, 64, ksize=3, stride=1, pad=pad))
self.add_link(
'di1_1',
L.DilatedConvolution2D(64, 64, ksize=3, stride=1, dilate=2, pad=2))
self.add_link(
'di2_1',
L.DilatedConvolution2D(64, 64, ksize=3, stride=1, dilate=4, pad=4))
self.add_link(
'di3_1',
L.DilatedConvolution2D(64, 64, ksize=3, stride=1, dilate=6, pad=6))
#self.add_link('up4', L.Deconvolution2D(1024, 512, ksize=4, stride=2, pad=0))
#self.add_link('up4', L.Deconvolution2D(1024, 512, ksize=2, stride=2, pad=0))
self.add_link('dc4_1',
L.Convolution2D(128, 64, ksize=3, stride=1, pad=pad))
self.add_link('dc4_2',
L.Convolution2D(64, 64, ksize=3, stride=1, pad=pad))
#self.add_link('up3', L.Deconvolution2D(512, 256, ksize=4, stride=2, pad=0))
#self.add_link('up3', L.Deconvolution2D(512, 256, ksize=2, stride=2, pad=0))
self.add_link('dc3_1',
L.Convolution2D(128, 64, ksize=3, stride=1, pad=pad))
self.add_link('score',
L.Convolution2D(64, n_class, ksize=1, stride=1, pad=0))
if bn:
self.add_link('bnc1_1', L.BatchNormalization(64))
self.add_link('bnc1_2', L.BatchNormalization(64))
self.add_link('bnc2_1', L.BatchNormalization(64))
self.add_link('bnc2_2', L.BatchNormalization(64))
self.add_link('bndi1_1', L.BatchNormalization(64))
self.add_link('bndi2_1', L.BatchNormalization(64))
self.add_link('bndi3_1', L.BatchNormalization(64))
#self.add_link('bnup4', L.BatchNormalization(512))
self.add_link('bnd4_1', L.BatchNormalization(64))
self.add_link('bnd4_2', L.BatchNormalization(64))
#self.add_link('bnup3', L.BatchNormalization(256))
self.add_link('bnd3_1', L.BatchNormalization(64))
#self.add_link('bnd3_2', L.BatchNormalization(64))
self.bn = bn
def __init__(self,
dilations,
residual_channels=16,
dilation_channels=32,
skip_channels=128,
quantization_channels=256):
'''
Args:
dilations (list of int):
A list with the dilation factor for each layer.
residual_channels (int):
How many filters to learn for the residual.
dilation_channels (int):
How many filters to learn for the dilated convolution.
skip_channels (int):
How many filters to learn that contribute to the quantized softmax output.
quantization_channels (int):
How many amplitude values to use for audio quantization and the corresponding
one-hot encoding.
Default: 256 (8-bit quantization).
'''
super(WaveNet, self).__init__(
# a "one-hot" causal conv
causal_embedID=L.EmbedID(quantization_channels,
2 * residual_channels),
# last 3 layers (include convolution on skip-connections)
conv1x1_0=L.Convolution2D(None, skip_channels, 1),
conv1x1_1=L.Convolution2D(None, skip_channels, 1),
conv1x1_2=L.Convolution2D(None, quantization_channels, 1),
)
# dilated stack
for i, dilation in enumerate(dilations):
self.add_link(
'conv_filter{}'.format(i),
L.DilatedConvolution2D(None,
dilation_channels, (1, 2),
dilate=dilation))
self.add_link(
'conv_gate{}'.format(i),
L.DilatedConvolution2D(None,
dilation_channels, (1, 2),
dilate=dilation,
bias=1))
self.add_link(
'conv_res{}'.format(i),
L.Convolution2D(None, residual_channels, 1, nobias=True))
self.residual_channels = residual_channels
self.dilations = dilations
def __init__(self, n_classes):
self.n_classes = n_classes
super().__init__(
conv1_1=L.Convolution2D(None, 64, 3, pad=1, **self.conv_init),
conv1_2=L.Convolution2D(None, 64, 3, pad=1, **self.conv_init),
conv2_1=L.Convolution2D(None, 128, 3, pad=1, **self.conv_init),
conv2_2=L.Convolution2D(None, 128, 3, pad=1, **self.conv_init),
conv3_1=L.Convolution2D(None, 256, 3, pad=1, **self.conv_init),
conv3_2=L.Convolution2D(None, 256, 3, pad=1, **self.conv_init),
conv3_3=L.Convolution2D(None, 256, 3, pad=1, **self.conv_init),
conv4_1=L.Convolution2D(None, 512, 3, pad=1, **self.conv_init),
conv4_2=L.Convolution2D(None, 512, 3, pad=1, **self.conv_init),
conv4_3=L.Convolution2D(None, 512, 3, pad=1, **self.conv_init),
norm4=_Normalize(512, **self.norm_init),
conv5_1=L.DilatedConvolution2D(None,
512,
3,
pad=1,
**self.conv_init),
conv5_2=L.DilatedConvolution2D(None,
512,
3,
pad=1,
**self.conv_init),
conv5_3=L.DilatedConvolution2D(None,
512,
3,
pad=1,
**self.conv_init),
conv6=L.DilatedConvolution2D(None,
1024,
3,
pad=6,
dilate=6,
**self.conv_init),
conv7=L.Convolution2D(None, 1024, 1, **self.conv_init),
loc=chainer.ChainList(),
conf=chainer.ChainList(),
)
for ar in self.aspect_ratios:
n = (len(ar) + 1) * 2
self.loc.add_link(
L.Convolution2D(None, n * 4, 3, pad=1, **self.conv_init))
self.conf.add_link(
L.Convolution2D(None,
n * (self.n_classes + 1),
3,
pad=1,
**self.conv_init))
def __init__(self):
super(DilatedGEN, self).__init__(
dc1=L.Convolution2D(None, 48, 5, 2, 2, wscale=0.02*math.sqrt(1*5*5)),
fc2=L.Convolution2D(48, 128, 3, 1, 1, wscale=0.02*math.sqrt(48*3*3)),
fc3=L.Convolution2D(128, 128, 3, 1, 1, wscale=0.02*math.sqrt(128*3*3)),
dc4=L.Convolution2D(128, 256, 3, 2, 1, wscale=0.02*math.sqrt(128*3*3)),
fc5=L.Convolution2D(256, 256, 3, 1, 1, wscale=0.02*math.sqrt(256*3*3)),
fc6=L.Convolution2D(256, 256, 3, 1, 1, wscale=0.02*math.sqrt(256*3*3)),
dc7=L.Convolution2D(256, 256, 3, 2, 1, wscale=0.02*math.sqrt(256*3*3)),
fc8=L.Convolution2D(256, 512, 3, 1, 1, wscale=0.02*math.sqrt(256*3*3)),
fc9=L.DilatedConvolution2D(512, 1024, 3, 1, 2, dilate=2, wscale=0.02*math.sqrt(512*3*3)),
fc10=L.DilatedConvolution2D(1024, 1024, 3, 1, 4, dilate=4, wscale=0.02*math.sqrt(1024*3*3)),
fc11=L.DilatedConvolution2D(1024, 1024, 3, 1, 8, dilate=8, wscale=0.02*math.sqrt(1024*3*3)),
fc12=L.Convolution2D(1024, 1024, 3, 1, 1, wscale=0.02*math.sqrt(1024*3*3)),
fc13=L.Convolution2D(1024, 512, 3, 1, 1, wscale=0.02*math.sqrt(1024*3*3)),
fc14=L.Convolution2D(512, 256, 3, 1, 1, wscale=0.02*math.sqrt(512*3*3)),
uc15=L.Deconvolution2D(256, 256, 4, 2, 1, wscale=0.02*math.sqrt(256*4*4)),
fc16=L.Convolution2D(256, 256, 3, 1, 1, wscale=0.02*math.sqrt(256*3*3)),
fc17=L.Convolution2D(256, 128, 3, 1, 1, wscale=0.02*math.sqrt(256*3*3)),
uc18=L.Deconvolution2D(128, 128, 4, 2, 1, wscale=0.02*math.sqrt(128*4*4)),
fc19=L.Convolution2D(128, 128, 3, 1, 1, wscale=0.02*math.sqrt(128*3*3)),
fc20=L.Convolution2D(128, 48, 3, 1, 1, wscale=0.02*math.sqrt(128*3*3)),
uc21=L.Deconvolution2D(48, 48, 4, 2, 1, wscale=0.02*math.sqrt(48*4*4)),
fc22=L.Convolution2D(48, 24, 3, 1, 1, wscale=0.02*math.sqrt(48*3*3)),
fc23=L.Convolution2D(24, 1, 3, 1, 1, wscale=0.02*math.sqrt(24*3*3)),
bn1=L.BatchNormalization(48),
bn2=L.BatchNormalization(128),
bn3=L.BatchNormalization(128),
bn4=L.BatchNormalization(256),
bn5=L.BatchNormalization(256),
bn6=L.BatchNormalization(256),
bn7=L.BatchNormalization(256),
bn8=L.BatchNormalization(512),
bn9=L.BatchNormalization(1024),
bn10=L.BatchNormalization(1024),
bn11=L.BatchNormalization(1024),
bn12=L.BatchNormalization(1024),
bn13=L.BatchNormalization(512),
bn14=L.BatchNormalization(256),
bn15=L.BatchNormalization(256),
bn16=L.BatchNormalization(256),
bn17=L.BatchNormalization(128),
bn18=L.BatchNormalization(128),
bn19=L.BatchNormalization(128),
bn20=L.BatchNormalization(48),
bn21=L.BatchNormalization(48),
bn22=L.BatchNormalization(24)
)
def __init__(self, input_width=256, input_height=256, ch=256, wscale=0.2):
super(Generator, self).__init__()
self.input_width = input_width
self.input_height = input_height
self.ch = ch
with self.init_scope():
w = chainer.initializers.Normal(wscale)
# O = (I + 2P - F) / S + 1
self.c0 = L.Convolution2D(4, ch//4, 5, 1, 2, initialW=w)
# change karnel size from original
self.c1 = L.Convolution2D(ch//4, ch//2, 4, 2, 1, initialW=w)
self.c2 = L.Convolution2D(ch//2, ch//2, 3, 1, 1, initialW=w)
# same as up
self.c3 = L.Convolution2D(ch//2, ch, 4, 2, 1, initialW=w)
self.c4 = L.Convolution2D(ch, ch, 3, 1, 1, initialW=w)
self.c5 = L.Convolution2D(ch, ch, 3, 1, 1, initialW=w)
# dilated convolution
# O = {I + 2P - F - (F-1) * (D-1)} / S + 1
self.c6 = L.DilatedConvolution2D(ch, ch, 3, 1, 2, 2, initialW=w)
self.c7 = L.DilatedConvolution2D(ch, ch, 3, 1, 4, 4, initialW=w)
self.c8 = L.DilatedConvolution2D(ch, ch, 3, 1, 8, 8, initialW=w)
self.c9 = L.DilatedConvolution2D(ch, ch, 3, 1, 16, 16, initialW=w)
self.c10 = L.Convolution2D(ch, ch, 3, 1, 1, initialW=w)
self.c11 = L.Convolution2D(ch, ch, 3, 1, 1, initialW=w)
# deconv
# O = S * (I-1) + F - 2P
self.c12 = L.Deconvolution2D(ch, ch//2, 4, 2, 1, initialW=w)
self.c13 = L.Convolution2D(ch//2, ch//2, 3, 1, 1, initialW=w)
self.c14 = L.Deconvolution2D(ch//2, ch//4, 4, 2, 1, initialW=w)
self.c15 = L.Convolution2D(ch//4, ch//8, 3, 1, 1, initialW=w)
self.c16 = L.Convolution2D(ch//8, 3, 3, 1, 1, initialW=w)
# BN
self.bn0 = L.BatchNormalization(ch//4)
self.bn1 = L.BatchNormalization(ch//2)
self.bn2 = L.BatchNormalization(ch//2)
self.bn3 = L.BatchNormalization(ch)
self.bn4 = L.BatchNormalization(ch)
self.bn5 = L.BatchNormalization(ch)
self.bn6 = L.BatchNormalization(ch)
self.bn7 = L.BatchNormalization(ch)
self.bn8 = L.BatchNormalization(ch)
self.bn9 = L.BatchNormalization(ch)
self.bn10 = L.BatchNormalization(ch)
self.bn11 = L.BatchNormalization(ch)
self.bn12 = L.BatchNormalization(ch//2)
self.bn13 = L.BatchNormalization(ch // 2)
self.bn14 = L.BatchNormalization(ch // 4)
self.bn15 = L.BatchNormalization(ch // 8)
def __init__(self, numLabel, architecture, act):
'''
@param architecture: ((channel, input len, filter len), ...)
'''
super(Net, self).__init__()
self.numLabel = numLabel
self.structure = architecture
self.act = act
self.prev = [None] * len(architecture)
for li, st in enumerate(architecture):
numChannel, inputLen, filterLen = st
if li == 0: inChannel = 1
else: inChannel = architecture[li - 1][0]
if filterLen == 1:
assert inputLen == 1
dil = 1
else:
assert (inputLen - 1) % (filterLen - 1) == 0
dil = (inputLen - 1) // (filterLen - 1)
conv = links.DilatedConvolution2D(inChannel, numChannel,
(filterLen, 1), 1, 0, (dil, 1))
super(Net, self).add_link("c" + str(li), conv)
if numLabel > 0:
full = links.Convolution2D(architecture[-1][0], numLabel, 1)
super(Net, self).add_link("full", full)
def __init__(self,
in_ch,
out_ch,
ksize,
stride=1,
pad=1,
dilation=1,
nobias=False,
upsample=False):
super(Conv, self).__init__()
with self.init_scope():
if upsample:
self.conv = L.Deconvolution2D(in_ch,
out_ch,
ksize,
stride,
pad,
nobias=nobias)
else:
if dilation > 1:
self.conv = L.DilatedConvolution2D(in_ch,
out_ch,
ksize,
stride,
pad,
dilation,
nobias=nobias)
else:
self.conv = L.Convolution2D(in_ch,
out_ch,
ksize,
stride,
pad,
nobias=nobias)
def __init__(self, in_channel, out_channel, ksize, dilate=1, causal=True):
self.in_ch = in_channel
self.out_ch = out_channel
self.ksize = ksize
self.dilate = dilate
self.causal = causal
self.conv_size = (self.ksize - 1) * self.dilate + 1
layers = {}
if self.dilate is None or self.dilate == 1:
layers["conv"] = L.ConvolutionND(1,
self.in_ch,
self.out_ch,
self.ksize,
stride=1,
pad=0)
else:
layers["conv"] = L.DilatedConvolution2D( \
self.in_ch,
self.out_ch,
(self.ksize, 1),
stride=1,
pad=(0, 0),
dilate = (self.dilate, 1)
)
super(DilateConvCausal1D, self).__init__(**layers)
def __init__(self, n_in_channel, n_skip_channel, n_dilate, useGPU):
dilatedConvTan = L.DilatedConvolution2D(None,
n_skip_channel, (1, 2),
dilate=n_dilate)
dilatedConvSig = L.DilatedConvolution2D(None,
n_skip_channel, (1, 2),
dilate=n_dilate)
conv = L.Convolution2D(n_skip_channel, n_in_channel, ksize=1)
super(WaveBlock, self).__init__(
dilatedConvTan=dilatedConvTan,
dilatedConvSig=dilatedConvSig,
conv=conv,
batchNormSig=L.BatchNormalization(n_skip_channel),
batchNormTan=L.BatchNormalization(n_skip_channel),
batchNormCnn=L.BatchNormalization(n_skip_channel),
)
self.useGPU = useGPU
def __init__(self, n_out):
super().__init__(
# the size of the inputs to each layer will be inferred
l1=L.Convolution2D(None, 8, ksize=3), # n_in -> n_units
l2=L.DilatedConvolution2D(None, 16, ksize=3,
dilate=2), # n_units -> n_units
l3=L.Linear(None, n_out), # n_units -> n_out
)
def __init__(self, in_channels, out_channels, dilate):
super(GAU, self).__init__()
with self.init_scope():
self.dilate = dilate
# if not dilate:
# self.convT = L.Convolution2D(in_channels, out_channels, ksize=(1, 2), pad=(0, 1))
# self.convS = L.Convolution2D(in_channels, out_channels, ksize=(1, 2), pad=(0, 1))
# else:
self.convT = L.DilatedConvolution2D(in_channels,
out_channels,
ksize=(1, 2),
dilate=(0, dilate))
self.convS = L.DilatedConvolution2D(in_channels,
out_channels,
ksize=(1, 2),
dilate=(0, dilate))
self.conv = L.Convolution2D(out_channels, out_channels, ksize=1)
def __init__(self, n_channel):
super(Extractor, self).__init__()
init = {
'initialW': initializers.LeCunUniform(),
'initial_bias': initializers.Zero(),
}
with self.init_scope():
self.conv1_1 = L.Convolution2D(n_channel, 3, pad=1, **init)
self.conv1_2 = L.Convolution2D(n_channel, 3, pad=1, **init)
self.conv2_1 = L.Convolution2D(n_channel*2, 3, pad=1, **init)
self.conv2_2 = L.Convolution2D(n_channel*2, 3, pad=1, **init)
self.conv3_1 = L.DilatedConvolution2D(n_channel*4, 3, pad=1, dilate=2, **init)
self.conv3_2 = L.DilatedConvolution2D(n_channel*4, 3, pad=1, dilate=2, **init)
self.conv4_1 = L.Convolution2D(n_channel*8, 3, pad=1, **init)
self.conv4_2 = L.Convolution2D(n_channel*8, 3, pad=1, **init)
def setUp(self):
self.link = links.DilatedConvolution2D(*self.args, **self.kwargs)
self.x = numpy.random.uniform(-1, 1,
(2, 3, 4, 3)).astype(numpy.float32)
self.link(chainer.Variable(self.x))
b = self.link.b.data
b[...] = numpy.random.uniform(-1, 1, b.shape)
self.link.cleargrads()
self.gy = numpy.random.uniform(-1, 1,
(2, 2, 2, 2)).astype(numpy.float32)
def __init__(self, nb_in, nb_out, ksize=3, dilate=1, no_bn=False):
super(DConv_BN, self).__init__()
self.no_bn = no_bn
with self.init_scope():
self.conv = L.DilatedConvolution2D(nb_in,
nb_out,
ksize=(ksize, 1),
pad=(dilate, 0),
dilate=(dilate, 1))
if not no_bn:
self.bn = L.BatchNormalization(nb_out)
def __init__(self, dilation, n_channel1, n_channel2, conditional, d):
super(ResidualBlock, self).__init__()
with self.init_scope():
self.conv = L.DilatedConvolution2D(n_channel2,
n_channel1 * 2,
ksize=(2, 1),
pad=(dilation, 0),
dilate=(dilation, 1))
if conditional:
self.cond = L.DilatedConvolution2D(d,
n_channel1 * 2,
ksize=(2, 1),
pad=(dilation, 0),
dilate=(dilation, 1))
self.proj = L.Convolution2D(n_channel1, n_channel2 * 2, 1)
self.dilation = dilation
self.n_channel2 = n_channel2
self.d = d
self.conditional = conditional
def setUp(self):
self.link = links.DilatedConvolution2D(
3, 2, 3, stride=2, pad=2, dilate=2)
b = self.link.b.data
b[...] = numpy.random.uniform(-1, 1, b.shape)
self.link.cleargrads()
self.x = numpy.random.uniform(-1, 1,
(2, 3, 4, 3)).astype(numpy.float32)
self.gy = numpy.random.uniform(-1, 1,
(2, 2, 2, 2)).astype(numpy.float32)
def __init__(self, n_classes, aspect_ratios):
init = {
'initialW': initializers.GlorotUniform(),
'initial_bias': initializers.Zero(),
}
super().__init__(
conv1_1=L.Convolution2D(None, 64, 3, pad=1, **init),
conv1_2=L.Convolution2D(None, 64, 3, pad=1, **init),
conv2_1=L.Convolution2D(None, 128, 3, pad=1, **init),
conv2_2=L.Convolution2D(None, 128, 3, pad=1, **init),
conv3_1=L.Convolution2D(None, 256, 3, pad=1, **init),
conv3_2=L.Convolution2D(None, 256, 3, pad=1, **init),
conv3_3=L.Convolution2D(None, 256, 3, pad=1, **init),
conv4_1=L.Convolution2D(None, 512, 3, pad=1, **init),
conv4_2=L.Convolution2D(None, 512, 3, pad=1, **init),
conv4_3=L.Convolution2D(None, 512, 3, pad=1, **init),
norm4=Normalize(512, initial=initializers.Constant(20)),
conv5_1=L.DilatedConvolution2D(None, 512, 3, pad=1, **init),
conv5_2=L.DilatedConvolution2D(None, 512, 3, pad=1, **init),
conv5_3=L.DilatedConvolution2D(None, 512, 3, pad=1, **init),
conv6=L.DilatedConvolution2D(None,
1024,
3,
pad=6,
dilate=6,
**init),
conv7=L.Convolution2D(None, 1024, 1, **init),
conv8_1=L.Convolution2D(None, 256, 1, **init),
conv8_2=L.Convolution2D(None, 512, 3, stride=2, pad=1, **init),
conv9_1=L.Convolution2D(None, 128, 1, **init),
conv9_2=L.Convolution2D(None, 256, 3, stride=2, pad=1, **init),
conv10_1=L.Convolution2D(None, 128, 1, **init),
conv10_2=L.Convolution2D(None, 256, 3, **init),
conv11_1=L.Convolution2D(None, 128, 1, **init),
conv11_2=L.Convolution2D(None, 256, 3, **init),
multibox=MultiBox(n_classes,
aspect_ratios=aspect_ratios,
init=init),
)
self.n_classes = n_classes
self.aspect_ratios = aspect_ratios
def setUp(self):
in_channels = None
self.link = links.DilatedConvolution2D(
in_channels, 2, 3, stride=2, pad=2, dilate=2)
self.x = numpy.random.uniform(-1, 1,
(2, 3, 4, 3)).astype(numpy.float32)
self.link(chainer.Variable(self.x))
b = self.link.b.data
b[...] = numpy.random.uniform(-1, 1, b.shape)
self.link.cleargrads()
self.gy = numpy.random.uniform(-1, 1,
(2, 2, 2, 2)).astype(numpy.float32)
def __init__(self, number_features, dilation_factor, nobias):
self.dilation_factor = dilation_factor
super(convolutional_layer, self).__init__(
# the size of the inputs to each layer will be inferred
L.DilatedConvolution2D(
in_channels=number_features,
out_channels=number_features,
ksize=(3, 1),
dilate=dilation_factor,
pad=(dilation_factor, 0),
initialW=chainer.initializers.HeNormal(),
nobias=nobias))
def __init__(self, d_factor, weight, bias):
super(DilatedConvBlock, self).__init__(diconv=L.DilatedConvolution2D(
in_channels=16,
out_channels=16,
ksize=3,
stride=1,
pad=d_factor,
dilate=d_factor,
nobias=False,
initialW=weight,
initial_bias=bias), )
self.train = True
def __init__(self, d_factor):
super(DilatedConvBlock,
self).__init__(diconv=L.DilatedConvolution2D(in_channels=64,
out_channels=64,
ksize=3,
stride=1,
pad=d_factor,
dilate=d_factor,
nobias=False),
#bn=L.BatchNormalization(64)
)
self.train = True
def __init__(self):
super(VGG16, self).__init__()
with self.init_scope():
self.conv1_1 = L.Convolution2D(64, 3, pad=1)
self.conv1_2 = L.Convolution2D(64, 3, pad=1)
self.conv2_1 = L.Convolution2D(128, 3, pad=1)
self.conv2_2 = L.Convolution2D(128, 3, pad=1)
self.conv3_1 = L.Convolution2D(256, 3, pad=1)
self.conv3_2 = L.Convolution2D(256, 3, pad=1)
self.conv3_3 = L.Convolution2D(256, 3, pad=1)
self.conv4_1 = L.Convolution2D(512, 3, pad=1)
self.conv4_2 = L.Convolution2D(512, 3, pad=1)
self.conv4_3 = L.Convolution2D(512, 3, pad=1)
self.conv5_1 = L.DilatedConvolution2D(512, 3, pad=1)
self.conv5_2 = L.DilatedConvolution2D(512, 3, pad=1)
self.conv5_3 = L.DilatedConvolution2D(512, 3, pad=1)
self.conv6 = L.DilatedConvolution2D(1024, 3, pad=6, dilate=6)
self.conv7 = L.Convolution2D(1024, 1)
def __init__(self, in_channels, out_channels, dilate):
super(Swish, self).__init__()
with self.init_scope():
self.dilate = dilate
if not dilate:
self.conv = L.Convolution2D(in_channels,
out_channels,
ksize=(1, 3),
pad=(0, 1))
else:
self.conv = L.DilatedConvolution2D(in_channels,
out_channels,
ksize=(1, 3),
dilate=(0, dilate),
pad=(0, dilate))
def __init__(self, in_size, ch):
super(DilatedBottleNeckB, self).__init__()
initialW = initializers.HeNormal()
with self.init_scope():
self.conv1 = L.Convolution2D(
in_size, ch, 1, 1, 0, initialW=initialW, nobias=True)
self.bn1 = L.BatchNormalization(ch, eps=self.eps)
self.conv2 = L.DilatedConvolution2D(
ch, ch, 3, 1, 2, dilate=2,
initialW=initialW, nobias=True)
self.bn2 = L.BatchNormalization(ch, eps=self.eps)
self.conv3 = L.Convolution2D(
ch, in_size, 1, 1, 0, initialW=initialW, nobias=True)
self.bn3 = L.BatchNormalization(in_size, eps=self.eps)
def __init__(self):
super(VGG16RefineDet, self).__init__()
with self.init_scope():
self.conv1_1 = L.Convolution2D(64, 3, pad=1)
self.conv1_2 = L.Convolution2D(64, 3, pad=1)
self.conv2_1 = L.Convolution2D(128, 3, pad=1)
self.conv2_2 = L.Convolution2D(128, 3, pad=1)
self.conv3_1 = L.Convolution2D(256, 3, pad=1)
self.conv3_2 = L.Convolution2D(256, 3, pad=1)
self.conv3_3 = L.Convolution2D(256, 3, pad=1)
self.conv4_1 = L.Convolution2D(512, 3, pad=1)
self.conv4_2 = L.Convolution2D(512, 3, pad=1)
self.conv4_3 = L.Convolution2D(512, 3, pad=1)
self.norm4 = Normalize(512, initial=initializers.Constant(20))
self.conv5_1 = L.DilatedConvolution2D(512, 3, pad=1)
self.conv5_2 = L.DilatedConvolution2D(512, 3, pad=1)
self.conv5_3 = L.DilatedConvolution2D(512, 3, pad=1)
self.conv6 = L.DilatedConvolution2D(1024, 3, pad=3, dilate=3)
self.conv7 = L.Convolution2D(1024, 1)
def __init__(self, filter_size, dilation,
residual_channels, dilated_channels, skip_channels):
super(ResidualBlock, self).__init__()
with self.init_scope():
self.conv = L.DilatedConvolution2D(
residual_channels, dilated_channels,
ksize=(filter_size, 1),
pad=(dilation * (filter_size - 1), 0), dilate=(dilation, 1))
self.res = L.Convolution2D(
dilated_channels // 2, residual_channels, 1)
self.skip = L.Convolution2D(
dilated_channels // 2, skip_channels, 1)
self.filter_size = filter_size
self.dilation = dilation
self.residual_channels = residual_channels
def __init__(self, in_ch, out_ch, ksize, stride=1, pad=1, dilation=1):
super(ConvBNReLU, self).__init__()
comm = chainer.config.comm
w = chainer.config.initialW
with self.init_scope():
if dilation > 1:
self.conv = L.DilatedConvolution2D(
in_ch, out_ch, ksize, stride, pad, dilation, True, w)
else:
self.conv = L.Convolution2D(
in_ch, out_ch, ksize, stride, pad, True, w)
if comm is not None:
self.bn = MultiNodeBatchNormalization(
out_ch, comm, eps=1e-5, decay=0.95)
else:
self.bn = L.BatchNormalization(out_ch, eps=1e-5, decay=0.95)
