def __init__(self, in_channels, out_channels, stride=2, initialW=None):
super(BlockA, self).__init__()
with self.init_scope():
self.bn1 = BatchNormalization(in_channels)
self.conv1 = Convolution2D(in_channels,
out_channels,
3,
stride,
1,
initialW=initialW,
nobias=True)
self.bn2 = BatchNormalization(out_channels)
self.conv2 = Convolution2D(out_channels,
out_channels,
3,
1,
1,
initialW=initialW,
nobias=True)
self.conv3 = Convolution2D(in_channels,
out_channels,
1,
stride,
0,
initialW=initialW,
nobias=True)
def __init__(self, in_channels, mid_channels, initialW=None):
super(BottleneckB, self).__init__(
conv1=Convolution2D(in_channels,
mid_channels,
1,
1,
0,
initialW=initialW,
nobias=True),
bn1=BatchNormalization(mid_channels),
conv2=Convolution2D(mid_channels,
mid_channels,
3,
1,
1,
initialW=initialW,
nobias=True),
bn2=BatchNormalization(mid_channels),
conv3=Convolution2D(mid_channels,
in_channels,
1,
1,
0,
initialW=initialW,
nobias=True),
bn3=BatchNormalization(in_channels),
)
def __init__(self, in_channels, mid_channels, dilate=1, initialW=None):
super(BottleneckB, self).__init__()
with self.init_scope():
self.conv1 = Convolution2D(
in_channels, mid_channels, 1, 1, 0, initialW=initialW,
nobias=True)
self.bn1 = BatchNormalization(mid_channels)
self.conv2 = Convolution2D(
mid_channels, mid_channels, 3, 1, dilate, initialW=initialW,
nobias=True, dilate=dilate)
self.bn2 = BatchNormalization(mid_channels)
self.conv3 = Convolution2D(
mid_channels, in_channels, 1, 1, 0, initialW=initialW,
nobias=True)
self.bn3 = BatchNormalization(in_channels)
def __init__(self, pretrained_model='auto'):
if pretrained_model:
# As a sampling process is time-consuming,
# we employ a zero initializer for faster computation.
kwargs = {'initialW': constant.Zero()}
else:
# employ default initializers used in the original paper
kwargs = {'initialW': normal.HeNormal(scale=1.0)}
super(ResNet50Layers, self).__init__(
conv1=Convolution2D(3, 64, 7, 2, 3, **kwargs),
bn1=BatchNormalization(64),
res2=BuildingBlock(3, 64, 64, 256, 1, **kwargs),
res3=BuildingBlock(4, 256, 128, 512, 2, **kwargs),
res4=BuildingBlock(6, 512, 256, 1024, 2, **kwargs),
res5=BuildingBlock(3, 1024, 512, 2048, 2, **kwargs),
fc6=Linear(2048, 1000),
)
if pretrained_model == 'auto':
_retrieve(
'ResNet-50-model.npz', 'ResNet-50-model.caffemodel', self)
elif pretrained_model:
npz.load_npz(pretrained_model, self)
self.functions = OrderedDict([
('conv1', [self.conv1, self.bn1, relu]),
('pool1', [lambda x: max_pooling_2d(x, ksize=3, stride=2)]),
('res2', [self.res2]),
('res3', [self.res3]),
('res4', [self.res4]),
('res5', [self.res5]),
('pool5', [_global_average_pooling_2d]),
('fc6', [self.fc6]),
('prob', [softmax]),
])
def __init__(self, pretrained_model='auto', n_layers=50):
super(ExtractorResNet, self).__init__()
print('Extractor ResNet', n_layers, ' initialization')
kwargs = {'initialW': constant.Zero()}
if pretrained_model == 'auto':
if n_layers == 50:
pretrained_model = 'ResNet-50-model.caffemodel'
block = [3, 4, 6, 3]
elif n_layers == 101:
pretrained_model = 'ResNet-101-model.caffemodel'
block = [3, 4, 23, 3]
with self.init_scope():
self.conv1 = Convolution2D(3, 64, 7, 2, 3, **kwargs)
self.bn1 = BatchNormalization(64)
self.res2 = BuildingBlock(block[0], 64, 64, 256, 1, **kwargs)
self.res3 = BuildingBlock(block[1], 256, 128, 512, 2, **kwargs)
self.res4 = BuildingBlock(block[2], 512, 256, 1024, 2, **kwargs)
self.res5 = BuildingBlock(block[3], 1024, 512, 2048, 1, **kwargs)
self.fc6 = Linear(2048, 1000)
if pretrained_model and pretrained_model.endswith('.caffemodel'):
_retrieve(n_layers, 'ResNet-{}-model.npz'.format(n_layers),
pretrained_model, self)
elif pretrained_model:
npz.load_npz(pretrained_model, self)
del self.fc6
def __init__(self, in_ch, mid_ch, out_ch):
super(FireBlock, self).__init__()
with self.init_scope():
self.squeeze_11 = Convolution2D(in_ch, mid_ch, 1)
self.expand_11 = Convolution2D(mid_ch, out_ch, 1)
self.expand_33 = Convolution2D(mid_ch, out_ch, 3, pad=1)
self.bn = BatchNormalization(out_ch * 2)
def __init__(self, pretrained_model, n_layers):
super(ResNetLayers, self).__init__()
if pretrained_model:
# As a sampling process is time-consuming,
# we employ a zero initializer for faster computation.
kwargs = {'initialW': constant.Zero()}
else:
# employ default initializers used in the original paper
kwargs = {'initialW': normal.HeNormal(scale=1.0)}
if n_layers == 50:
block = [3, 4, 6, 3]
elif n_layers == 101:
block = [3, 4, 23, 3]
elif n_layers == 152:
block = [3, 8, 36, 3]
else:
raise ValueError('The n_layers argument should be either 50, 101,'
' or 152, but {} was given.'.format(n_layers))
with self.init_scope():
self.conv1 = Convolution2D(3, 64, 7, 2, 3, **kwargs)
self.bn1 = BatchNormalization(64)
self.res2 = BuildingBlock(block[0], 64, 64, 256, 1, **kwargs)
self.res3 = BuildingBlock(block[1], 256, 128, 512, 2, **kwargs)
self.res4 = BuildingBlock(block[2], 512, 256, 1024, 2, **kwargs)
self.res5 = BuildingBlock(block[3], 1024, 512, 2048, 2, **kwargs)
self.fc6 = Linear(2048, 1000)
if pretrained_model and pretrained_model.endswith('.caffemodel'):
_retrieve(n_layers, 'ResNet-{}-model.npz'.format(n_layers),
pretrained_model, self)
elif pretrained_model:
npz.load_npz(pretrained_model, self)
def __init__(self):
super().__init__()
with self.init_scope():
self.first = Convolution2D(3,
64,
ksize=3,
stride=1,
pad=1,
initialW=Normal(0.02))
self.res1 = SRGeneratorResBlock()
self.res2 = SRGeneratorResBlock()
self.res3 = SRGeneratorResBlock()
self.res4 = SRGeneratorResBlock()
self.res5 = SRGeneratorResBlock()
self.conv_mid = Convolution2D(64,
64,
ksize=3,
stride=1,
pad=1,
initialW=Normal(0.02))
self.bn_mid = BatchNormalization(64)
self.upscale1 = SRGeneratorUpScaleBlock()
self.upscale2 = SRGeneratorUpScaleBlock()
self.conv_output = Convolution2D(64,
3,
ksize=3,
stride=1,
pad=1,
initialW=Normal(0.02))
def __init__(self, pretrained_model, n_layers, n_class, class_weight=None):
super(ResNetLayersFCN32, self).__init__()
self.n_class = n_class
if class_weight is not None:
assert class_weight.shape == (self.n_class,)
self.class_weight = class_weight
else:
self.class_weight = None
if pretrained_model:
# As a sampling process is time-consuming,
# we employ a zero initializer for faster computation.
kwargs = {'initialW': constant.Zero()}
else:
# employ default initializers used in the original paper
kwargs = {'initialW': normal.HeNormal(scale=1.0)}
kwargs2 = {
'initialW': chainer.initializers.Zero(),
'initial_bias': chainer.initializers.Zero(),
}
if n_layers == 50:
block = [3, 4, 6, 3]
elif n_layers == 101:
block = [3, 4, 23, 3]
elif n_layers == 152:
block = [3, 8, 36, 3]
else:
raise ValueError('The n_layers argument should be either 50, 101,'
' or 152, but {} was given.'.format(n_layers))
with self.init_scope(): #in the comments are the sizes (of default images of 224x224) AFTER the cooresponding layer
self.conv1 = Convolution2D(3, 64, 7, 2, 3, **kwargs) #112x112
self.bn1 = BatchNormalization(64)
self.res2 = BuildingBlock(block[0], 64, 64, 256, 1, **kwargs) #56x56
self.res3 = BuildingBlock(block[1], 256, 128, 512, 2, **kwargs) #28x28
self.res4 = BuildingBlock(block[2], 512, 256, 1024, 2, **kwargs) #14x14
self.res5 = BuildingBlock(block[3], 1024, 512, 2048, 2, **kwargs) #7x7
#self.fc6 = Linear(2048, 1000)
self.score_fr = L.Convolution2D(2048, n_class, 1, 1, 0, **kwargs2)
self.upscore = L.Deconvolution2D(n_class, n_class, 64, 32, 0, nobias=True, initialW=initializers.UpsamplingDeconvWeight()) #224x224
if pretrained_model and pretrained_model.endswith('.caffemodel'): #default resnet model
originalresnet = ResNetLayers(pretrained_model, n_layers)
if n_layers == 50:
_transfer_resnet50(originalresnet, self)
elif n_layers == 101:
_transfer_resnet101(originalresnet, self)
elif n_layers == 152:
_transfer_resnet152(originalresnet, self)
else:
raise ValueError('The n_layers argument should be either 50, 101,'
' or 152, but {} was given.'.format(n_layers))
elif pretrained_model:
npz.load_npz(pretrained_model, self)
def __init__(self,
in_channels,
mid_channels,
out_channels,
stride=2,
initialW=None,
downsample_fb=False):
super(BottleneckA, self).__init__()
# In the original MSRA ResNet, stride=2 is on 1x1 convolution.
# In Facebook ResNet, stride=2 is on 3x3 convolution.
stride_1x1, stride_3x3 = (stride, 1) if downsample_fb else (1, stride)
with self.init_scope():
self.conv1 = Convolution2D(in_channels,
mid_channels,
1,
stride_1x1,
0,
initialW=initialW,
nobias=True)
self.bn1 = BatchNormalization(mid_channels)
self.conv2 = Convolution2D(mid_channels,
mid_channels,
3,
stride_3x3,
1,
initialW=initialW,
nobias=True)
self.bn2 = BatchNormalization(mid_channels)
self.conv3 = Convolution2D(mid_channels,
out_channels,
1,
1,
0,
initialW=initialW,
nobias=True)
self.bn3 = BatchNormalization(out_channels)
self.conv4 = Convolution2D(in_channels,
out_channels,
1,
stride,
0,
initialW=initialW,
nobias=True)
self.bn4 = BatchNormalization(out_channels)
def __init__(self):
super().__init__()
with self.init_scope():
self.c1 = Convolution2D(64,
64,
ksize=3,
stride=1,
pad=1,
initialW=Normal(0.02))
self.bn1 = BatchNormalization(64)
self.c2 = Convolution2D(64,
64,
ksize=3,
stride=1,
pad=1,
initialW=Normal(0.02))
self.bn2 = BatchNormalization(64)
def __init__(self,
in_channels,
mid_channels,
out_channels,
stride=2,
initialW=None):
super(BottleneckA, self).__init__()
with self.init_scope():
self.in_channels = in_channels
self.mid_channels = mid_channels
self.out_channels = out_channels
self.conv1 = Convolution2D(in_channels,
mid_channels,
1,
stride,
0,
initialW=initialW,
nobias=True)
self.bn1 = BatchNormalization(mid_channels)
self.conv2 = Convolution2D(mid_channels,
mid_channels,
3,
1,
1,
initialW=initialW,
nobias=True)
self.bn2 = BatchNormalization(mid_channels)
self.conv3 = Convolution2D(mid_channels,
out_channels,
1,
1,
0,
initialW=initialW,
nobias=True)
self.bn3 = BatchNormalization(out_channels)
self.conv4 = Convolution2D(in_channels,
out_channels,
1,
stride,
0,
initialW=initialW,
nobias=True)
self.bn4 = BatchNormalization(out_channels)
def __init__(self, pretrained_model, n_layers, n_class=3):
super(ResNetLayersFCN, self).__init__()
self.n_class = n_class
if pretrained_model:
# As a sampling process is time-consuming,
# we employ a zero initializer for faster computation.
kwargs = {'initialW': constant.Zero()}
else:
# employ default initializers used in the original paper
kwargs = {'initialW': normal.HeNormal(scale=1.0)}
if n_layers == 50:
block = [3, 4, 6, 3]
elif n_layers == 101:
block = [3, 4, 23, 3]
elif n_layers == 152:
block = [3, 8, 36, 3]
else:
raise ValueError('The n_layers argument should be either 50, 101,'
' or 152, but {} was given.'.format(n_layers))
with self.init_scope(): #in the comments are the sizes (of default images of 224x224) AFTER the cooresponding layer
self.conv1 = Convolution2D(3, 64, 7, 2, 3, **kwargs) #112x112
self.bn1 = BatchNormalization(64)
self.res2 = BuildingBlock(block[0], 64, 64, 256, 1, **kwargs) #56x56
self.res3 = BuildingBlock(block[1], 256, 128, 512, 2, **kwargs) #28x28
self.res4 = BuildingBlock(block[2], 512, 256, 1024, 2, **kwargs) #14x14
self.res5 = BuildingBlock(block[3], 1024, 512, 2048, 2, **kwargs) #7x7
#self.fc6 = Linear(2048, 1000)
self.score_fr = L.Convolution2D(2048, n_class, 1, 1, 0, **kwargs)
self.upscore = L.Deconvolution2D(
n_class, n_class, 64, 32, 0, nobias=True,
initialW=initializers.UpsamplingDeconvWeight()) #224x224
#if pretrained_model and pretrained_model.endswith('.caffemodel'):
# _retrieve(n_layers, 'ResNet-{}-model.npz'.format(n_layers),
# pretrained_model, self)
if pretrained_model and pretrained_model is in ['ResNet-101-model.caffemodel']: #later maybe and 50 and 152 here
# open default resnet and extract weigths form it
# pretrained_model, self)
resnet101 = ResNetLayers(pretrained_model, 101)
init_from_resnet101(resnet101)
elif pretrained_model:
npz.load_npz(pretrained_model, self)
def __init__(self, pretrained_model, n_layers):
super(ResNetLayers, self).__init__()
if pretrained_model:
# As a sampling process is time-consuming,
# we employ a zero initializer for faster computation.
kwargs = {'initialW': constant.Zero()}
else:
# employ default initializers used in the original paper
kwargs = {'initialW': normal.HeNormal(scale=1.0)}
if n_layers == 50:
block = [3, 4, 6, 3]
elif n_layers == 101:
block = [3, 4, 23, 3]
elif n_layers == 152:
block = [3, 8, 36, 3]
else:
raise ValueError('The n_layers argument should be either 50, 101,'
' or 152, but {} was given.'.format(n_layers))
with self.init_scope():
self.conv1 = Convolution2D(3, 64, 7, 2, 3, **kwargs)
self.bn1 = BatchNormalization(64)
self.res2 = BuildingBlock(block[0], 64, 64, 256, 1, **kwargs)
self.res3 = BuildingBlock(block[1], 256, 128, 512, 2, **kwargs)
self.res4 = BuildingBlock(block[2], 512, 256, 1024, 2, **kwargs)
self.res5 = BuildingBlock(block[3], 1024, 512, 2048, 2, **kwargs)
self.fc6 = Linear(2048, 1000)
if pretrained_model and pretrained_model.endswith('.caffemodel'):
_retrieve(n_layers, 'ResNet-{}-model.npz'.format(n_layers),
pretrained_model, self)
elif pretrained_model:
npz.load_npz(pretrained_model, self)
self.functions = collections.OrderedDict([
('conv1', [self.conv1, self.bn1, relu]),
('pool1', [lambda x: max_pooling_2d(x, ksize=3, stride=2)]),
('res2', [self.res2]),
('res3', [self.res3]),
('res4', [self.res4]),
('res5', [self.res5]),
('pool5', [_global_average_pooling_2d]),
('fc6', [self.fc6]),
('prob', [softmax]),
])
def __init__(self):
super().__init__()
with self.init_scope():
self.conv_input = Convolution2D(3,
64,
ksize=3,
stride=1,
pad=0,
initialW=Normal(0.02))
self.c1 = Convolution2D(64,
64,
ksize=3,
stride=2,
pad=0,
initialW=Normal(0.02))
self.bn1 = BatchNormalization(64)
self.c2 = Convolution2D(64,
128,
ksize=3,
stride=1,
pad=0,
initialW=Normal(0.02))
self.bn2 = BatchNormalization(128)
self.c3 = Convolution2D(128,
128,
ksize=3,
stride=2,
pad=0,
initialW=Normal(0.02))
self.bn3 = BatchNormalization(128)
self.c4 = Convolution2D(128,
256,
ksize=3,
stride=1,
pad=0,
initialW=Normal(0.02))
self.bn4 = BatchNormalization(256)
self.c5 = Convolution2D(256,
256,
ksize=3,
stride=2,
pad=0,
initialW=Normal(0.02))
self.bn5 = BatchNormalization(256)
self.c6 = Convolution2D(256,
512,
ksize=3,
stride=1,
pad=0,
initialW=Normal(0.02))
self.bn6 = BatchNormalization(512)
self.c7 = Convolution2D(512,
512,
ksize=3,
stride=2,
pad=0,
initialW=Normal(0.02))
self.bn7 = BatchNormalization(512)
self.linear1 = Linear(in_size=4608, out_size=1024)
self.linear2 = Linear(in_size=None, out_size=2)
