def __init__(self, n_out, pretrained_model='auto', layers=None):
super(ResNet101, self).__init__()
init_param = initializers.HeNormal()
self.n_out = n_out
if layers:
self.layers = layers
else:
self.layers = ['pool5']
with self.init_scope():
self.base = L.ResNet101Layers(pretrained_model=pretrained_model)
self.fc = L.Linear(None, n_out, initialW=init_param)
def __init__(self, n_in, n_out, stride=1):
self.dtype = np.float32
w = 1/np.sqrt(2)
initW = initializers.HeNormal(scale=w)
initbias = initializers.Zero()
super(Module, self).__init__(
conv1=L.Convolution2D(n_in, n_out, 3, stride, 1, 1, initialW=initW, initial_bias=initbias),
bn1=L.BatchNormalization(n_out,dtype=self.dtype),
conv2=L.Convolution2D(n_out, n_out, 3, 1, 1, 1, initialW=initW, initial_bias=initbias),
bn2=L.BatchNormalization(n_out,dtype=self.dtype),
)
def __init__(self,
growth_rate=32,
n_layers=(6, 12, 24, 16),
init_features=64,
bn_size=4,
dropout_rate=0,
n_class=1000):
r"""Initialization of DenseNetImagenet.
Args:
growth_rate (int): growth_rate
n_layers (int): # of layers for each block
init_features (int): # of self.conv1's outputs' channels
bn_size (int): bn_size
dropout_rate (float): dropout rate \in [0, 1). If > 0,
apply dropout
n_class (int): # of class
"""
super(DenseNetImagenet, self).__init__()
with self.init_scope():
initialW = initializers.HeNormal()
self.conv1 = L.Convolution2D(None,
init_features,
7,
2,
3,
initialW=initialW,
nobias=True)
self.bn1 = L.BatchNormalization(init_features)
self.block1 = DenseBlock(n_layers[0], init_features, bn_size,
growth_rate, dropout_rate)
n_feature = init_features + n_layers[0] * growth_rate
self.trans1 = Transition(n_feature, dropout_rate)
self.block2 = DenseBlock(n_layers[1], n_feature, bn_size,
growth_rate, dropout_rate)
n_feature += n_layers[1] * growth_rate
self.trans2 = Transition(n_feature, dropout_rate)
self.block3 = DenseBlock(n_layers[2], n_feature, bn_size,
growth_rate, dropout_rate)
n_feature += n_layers[2] * growth_rate
self.trans3 = Transition(n_feature, dropout_rate)
self.block4 = DenseBlock(n_layers[3], n_feature, bn_size,
growth_rate, dropout_rate)
n_feature += n_layers[3] * growth_rate
self.bn4 = L.BatchNormalization(n_feature)
self.prob = L.Linear(None, n_class)
self.n_class = n_class
def __init__(self, optimizer, dtype, use_placeholder):
self.dtype = dtype
weight = initializers.HeNormal(1 / numpy.sqrt(2), dtype)
bias = initializers.Constant(0, dtype)
in_size = None if use_placeholder else self.UNIT_NUM
self.model = L.Linear(in_size, 2, initialW=weight, initial_bias=bias)
self.optimizer = optimizer
# true parameters
self.w = numpy.random.uniform(
-1, 1, (self.UNIT_NUM, 1)).astype(dtype)
self.b = numpy.random.uniform(-1, 1, (1, )).astype(dtype)
def __init__(self, ninput, nhidden, nhidden2, noutput):
super(RNN_Elman2, self).__init__(
L1=CL.Elman(ninput, nhidden, actfun=sigmoid.sigmoid),
L2=CL.Elman(nhidden,nhidden2, actfun=sigmoid.sigmoid),
L3=L.Linear(nhidden2, noutput, initialW=init.HeNormal()),
)
self.ninput = ninput
self.nhidden = nhidden
self.noutput = noutput
self.h={}
self.h[1]=None
def __init__(self):
super(ResNet50_Nhwc, self).__init__()
with self.init_scope():
self.conv1 = L.Convolution2D(
3, 64, 7, 2, 3, initialW=initializers.HeNormal())
self.bn1 = L.BatchNormalization(64)
with chainer.using_config('compute_mode', 'cudnn_fast'):
self.res2 = Block(3, 64, 64, 256, 1)
self.res3 = Block(4, 256, 128, 512)
self.res4 = Block(6, 512, 256, 1024)
self.res5 = Block(3, 1024, 512, 2048)
self.fc = L.Linear(2048, 1000)
def __init__(self, output=8):
super(ResNet50, self).__init__()
with self.init_scope():
self.conv1 = L.Convolution2D(3,
64,
7,
2,
3,
initialW=initializers.HeNormal(),
nobias=True)
self.bn1 = L.BatchNormalization(64)
self.layer1 = Block(3, 64, 64, 256, 1)
self.layer2 = Block(4, 256, 128, 512)
self.layer3 = Block(6, 512, 256, 1024)
self.att_layer4 = Block(3, 1024, 512, 2048, 1)
self.bn_att = L.BatchNormalization(512 * blockexpansion)
self.att_conv = L.Convolution2D(512 * blockexpansion,
output,
ksize=1,
pad=0,
initialW=initializers.HeNormal(),
nobias=True)
self.bn_att2 = L.BatchNormalization(output)
self.att_conv2 = L.Convolution2D(output,
output,
ksize=1,
pad=0,
initialW=initializers.HeNormal(),
nobias=True)
self.att_conv3 = L.Convolution2D(output,
1,
ksize=3,
pad=1,
initialW=initializers.HeNormal(),
nobias=True)
self.bn_att3 = L.BatchNormalization(1)
self.layer4 = Block(3, 1024, 512, 2048)
self.fc = L.Linear(512 * blockexpansion, output)
def __init__(self,
in_ch,
out_ch_list,
n_convs_list=None,
ksize_list=None,
use_bn_list=None,
activation_list=None,
w_init=inits.HeNormal()):
if n_convs_list is None:
n_convs_list = [2] * len(out_ch_list)
if ksize_list is None:
ksize_list = [3] * len(out_ch_list)
if use_bn_list is None:
use_bn_list = [True] * len(out_ch_list)
if activation_list is None:
activation_list = [F.relu] * len(out_ch_list)
assert len(out_ch_list) == len(n_convs_list), \
(len(out_ch_list), len(n_convs_list))
assert len(n_convs_list) == len(ksize_list), \
(len(n_convs_list), len(ksize_list))
assert len(ksize_list) == len(use_bn_list), \
(len(ksize_list), len(use_bn_list))
assert len(use_bn_list) == len(activation_list), \
(len(use_bn_list), len(activation_list))
super(Block, self).__init__()
in_ch_list = [in_ch] + out_ch_list[:-1]
for in_ch, out_ch, n_convs, ksize, use_bn, activation in zip(
in_ch_list, out_ch_list, n_convs_list, ksize_list, use_bn_list,
activation_list):
out_ch_list_for_unit = [
in_ch + (out_ch - in_ch) * (idx + 1) // n_convs
for idx in range(n_convs)
]
self.append(
Residual(
Unit(in_ch=in_ch,
out_ch_list=out_ch_list_for_unit,
ksize_list=[ksize] * n_convs,
use_bn_list=[use_bn] * n_convs,
activation_list=[None] + [activation] * (n_convs - 1),
w_init=w_init)))
def __init__(
self,
database,
n_layers: int,
in_size: int,
out_size: int,
initialW=None,
spatial_edge_model: SpatialEdgeMode = SpatialEdgeMode.all_edge,
recurrent_block_type: RecurrentType = RecurrentType.rnn,
attn_heads=8,
bi_lstm=False):
super(SpaceTimeRNN, self).__init__()
self.neg_pos_ratio = 3
self.database = database
self.spatial_edge_mode = spatial_edge_model
self.out_size = out_size
self.in_size = in_size
self.frame_node_num = config.BOX_NUM[self.database]
self.mid_size = 1024
NodeRecurrentModule = AttentionBlock if recurrent_block_type == RecurrentType.attention_block else TemporalRNN
if recurrent_block_type == RecurrentType.no_temporal:
NodeRecurrentModule = PositionwiseFeedForwardLayer
with self.init_scope():
if not initialW:
initialW = initializers.HeNormal()
self.top = dict()
for i in range(self.frame_node_num):
if recurrent_block_type == RecurrentType.rnn:
self.add_link(
"Node_{}".format(i),
TemporalRNN(n_layers,
self.mid_size,
self.out_size,
use_bi_lstm=bi_lstm))
else:
self.add_link(
"Node_{}".format(i),
NodeRecurrentModule(n_layers, self.mid_size,
self.out_size))
self.top[str(i)] = getattr(self, "Node_{}".format(i))
if spatial_edge_model != SpatialEdgeMode.no_edge:
self.space_lstm = L.NStepBiLSTM(n_layers,
self.in_size,
self.mid_size // 2,
dropout=0.1,
initialW=initialW) #FIXME
else:
self.transfer_dim_fc = L.Linear(self.in_size,
self.mid_size,
initialW=initialW)
def __post_init__(self):
super(ClassifierNet, self).__init__()
w = initializers.HeNormal()
with self.init_scope():
self.l_phr = L.Linear(None, self.out_size, initialW=w)
self.l_img = L.Linear(None, self.out_size, initialW=w)
self.l_1 = L.Linear(None, self.out_size, initialW=w, nobias=True)
self.bn_l0 = L.BatchNormalization(self.out_size)
self.bn_v0 = L.BatchNormalization(self.out_size)
self.bn_1 = L.BatchNormalization(self.out_size)
self.cls = L.Linear(None, 1, initialW=w)
def __init__(self, nfeats, out_per_feat):
self.dtype = np.float32
w = 1./np.sqrt(2)
initW = initializers.HeNormal(scale=w)
initbias = initializers.Zero()
super(SplitCNN,self).__init__()
self.cnns = []
for i in range(nfeats):
self.forward.append('CNN%s'%i)
self.add_link('CNN%s'%i, CNN(out_per_feat))
self.add_link('fc1',F.Linear(out_per_feat*len(inputs),out_size=64,initialW=initW, initial_bias=initbias))
self.add_link('fc2',F.Linear(64,out_size=2,initialW=initW, initial_bias=initbias))
def __init__(self, hidden_state, dtype=np.float32):
self.dtype = dtype
W = initializers.HeNormal(1 / np.sqrt(2), self.dtype)
super(ConvNet, self).__init__()
with self.init_scope():
self.conv1 = L.Convolution2D(3, 96, 3, stride=1, pad=1, initialW=W)
self.bn1 = L.BatchNormalization(size=96, dtype=np.float32)
self.conv2 = L.Convolution2D(None, 96, 3, stride=1, pad=1, initialW=W)
self.bn2 = L.BatchNormalization(size=96, dtype=dtype)
self.conv3 = L.Convolution2D(None, 96, 3, stride=1, pad=1, initialW=W)
self.bn3 = L.BatchNormalization(size=96, dtype=dtype)
self.conv4 = L.Convolution2D(None, hidden_state, 3, stride=1, pad=1, initialW=W)
self.bn4 = L.BatchNormalization(size=hidden_state, dtype=dtype)
def __init__(self):
super(ResNet, self).__init__()
with self.init_scope():
self.conv1 = L.Convolution2D(3,
64,
3,
2,
1,
initialW=initializers.HeNormal(),
nobias=True)
self.bn1 = L.BatchNormalization(64)
self.res2 = Block(3, 64, 64, 128, 1)
self.res3 = Block(4, 128, 64, 32)
def __call__(self, link, cfg, initialW=I.HeNormal()):
assert isinstance(link, self.cls)
link_ = AdaLossConvolution2D(link.in_channels,
link.out_channels,
ksize=link.ksize,
stride=link.stride,
pad=link.pad,
dilate=link.dilate,
groups=link.groups,
nobias=link.b is None,
ada_loss_cfg=cfg)
link_.copyparams(link)
return link_
def __init__(self, n_layer,
n_class=None,
pretrained_model=None,
mean=None, initialW=None, fc_kwargs={}, arch='fb'):
if arch == 'fb':
if pretrained_model == 'imagenet':
raise ValueError(
'Pretrained weights for Facebook ResNet models '
'are not supported. Please set arch to \'he\'.')
stride_first = False
conv1_no_bias = True
elif arch == 'he':
stride_first = True
# Kaiming He uses bias only for ResNet50
conv1_no_bias = n_layer != 50
else:
raise ValueError('arch is expected to be one of [\'he\', \'fb\']')
blocks = self._blocks[n_layer]
param, path = utils.prepare_pretrained_model(
{'n_class': n_class, 'mean': mean},
pretrained_model, self._models[arch][n_layer],
{'n_class': 1000, 'mean': _imagenet_mean})
self.mean = param['mean']
if initialW is None:
initialW = initializers.HeNormal(scale=1., fan_option='fan_out')
if 'initialW' not in fc_kwargs:
fc_kwargs['initialW'] = initializers.Normal(scale=0.01)
if pretrained_model:
# As a sampling process is time-consuming,
# we employ a zero initializer for faster computation.
initialW = initializers.constant.Zero()
fc_kwargs['initialW'] = initializers.constant.Zero()
kwargs = {'initialW': initialW, 'stride_first': stride_first}
super(ResNet, self).__init__()
with self.init_scope():
self.conv1 = Conv2DBNActiv(None, 64, 7, 2, 3, nobias=conv1_no_bias,
initialW=initialW)
self.pool1 = lambda x: F.max_pooling_2d(x, ksize=3, stride=2)
self.res2 = ResBlock(blocks[0], None, 64, 256, 1, **kwargs)
self.res3 = ResBlock(blocks[1], None, 128, 512, 2, **kwargs)
self.res4 = ResBlock(blocks[2], None, 256, 1024, 2, **kwargs)
self.res5 = ResBlock(blocks[3], None, 512, 2048, 2, **kwargs)
self.pool5 = _global_average_pooling_2d
self.fc6 = L.Linear(None, param['n_class'], **fc_kwargs)
self.prob = F.softmax
if path:
chainer.serializers.load_npz(path, self)
def __init__(self,
depth,
n_class,
widen_factor=1,
drop_rate=0.0,
initialW=None):
""" CTOR. """
super(WideResNet, self).__init__()
k = widen_factor
assert (depth - 4) % 6 == 0, 'Depth should be 6n + 4'
n = (depth - 4) // 6
n_channel = [16, 16 * k, 32 * k, 64 * k]
if initialW is None:
initialW = initializers.HeNormal(scale=1., fan_option='fan_out')
kwargs = {'initialW': initialW}
with self.init_scope():
self.conv1 = L.Convolution2D(3,
n_channel[0],
ksize=3,
stride=1,
pad=1,
nobias=True,
**kwargs)
self.wide2 = _WideResBlock(n,
n_channel[0],
n_channel[1],
1,
drop_rate=drop_rate,
**kwargs)
self.wide3 = _WideResBlock(n,
n_channel[1],
n_channel[2],
2,
drop_rate=drop_rate,
**kwargs)
self.wide4 = _WideResBlock(n,
n_channel[2],
n_channel[3],
2,
drop_rate=drop_rate,
**kwargs)
self.bn = L.BatchNormalization(n_channel[3])
self.relu = lambda x: F.relu(x)
self.pool5 = lambda x: F.average(x, axis=(2, 3))
self.fc6 = L.Linear(n_channel[3], n_class, **kwargs)
def __init__(
self,
model_name,
insize,
keypoint_names,
edges, # limbs, keypoints connection
local_grid_size,
parts_scale,
instance_scale,
width_multiplier=1.0,
lambda_resp=0.25,
lambda_iou=1.0,
lambda_coor=5.0,
lambda_size=5.0,
lambda_limb=0.5,
dtype=np.float32):
super(PoseProposalNet, self).__init__()
self.model_name = model_name
self.insize = insize
self.keypoint_names = keypoint_names
self.edges = edges
self.local_grid_size = local_grid_size
self.dtype = dtype
self.lambda_resp = lambda_resp
self.lambda_iou = lambda_iou
self.lambda_coor = lambda_coor
self.lambda_size = lambda_size
self.lambda_limb = lambda_limb
self.parts_scale = np.array(
parts_scale) # side length of square for kps
self.instance_scale = np.array(instance_scale)
with self.init_scope():
# 基础的网络 feature size narrow 32 multiple channels=512
self.feature_layer = get_network(model_name,
dtype=dtype,
width_multiplier=width_multiplier)
ksize = self.feature_layer.last_ksize # 1
self.lastconv = L.Convolution2D(
None,
6 * len(self.keypoint_names) + self.local_grid_size[0] *
self.local_grid_size[1] * len(self.edges),
ksize=ksize,
stride=1,
pad=ksize // 2,
initialW=initializers.HeNormal(1 / np.sqrt(2), dtype))
self.outsize = self.get_outsize(
) # the number of gird fixed or not? --- (7, 7) #p1 No fixed, changed by insize and local_grid_size
inW, inH = self.insize # image input shape[1:]
outW, outH = self.outsize
self.gridsize = (int(inW / outW), int(inH / outH)) #32 32
def __init__(self, class_labels=9):
super(ResNet, self).__init__()
with self.init_scope():
self.conv1 = L.Convolution2D(1,
64,
7,
2,
3,
initialW=initializers.HeNormal())
self.bn1 = L.BatchNormalization(64)
self.res1 = Block(2, 64, 64, 64, 1)
self.res2 = Block(2, 64, 128, 128)
self.res3 = Block(2, 128, 256, 256)
self.fc = L.Linear(256, class_labels)
def __init__(self):
super(ResnetFeatureExtractor, self).__init__()
with self.init_scope():
self.conv1 = L.Convolution2D(3,
64,
7,
2,
3,
initialW=initializers.HeNormal(),
nobias=True)
self.bn1 = L.BatchNormalization(64)
self.res2 = Block(3, 64, 64, 256, 1)
self.res3 = Block(4, 256, 128, 512)
self.res4 = Block(23, 512, 256, 1024)
def __init__(self, in_size, ch):
super(BottleNeckB, 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)
self.conv2 = L.Convolution2D(
ch, ch, 3, 1, 1, initialW=initialW, nobias=True)
self.bn2 = L.BatchNormalization(ch)
self.conv3 = L.Convolution2D(
ch, in_size, 1, 1, 0, initialW=initialW, nobias=True)
self.bn3 = L.BatchNormalization(in_size)
def __init__(self, n_class=1000): # 1000 is for ImageNet
super(NIN, self).__init__()
conv_init = I.HeNormal() # MSRA scaling
self.n_class = n_class
with self.init_scope():
self.mlpconv1 = L.MLPConvolution2D(
None, (96, 96, 96), 11, stride=4, conv_init=conv_init)
self.mlpconv2 = L.MLPConvolution2D(
None, (256, 256, 256), 5, pad=2, conv_init=conv_init)
self.mlpconv3 = L.MLPConvolution2D(
None, (384, 384, 384), 3, pad=1, conv_init=conv_init)
self.mlpconv4 = L.MLPConvolution2D(
None, (1024, 1024, self.n_class), 3, pad=1, conv_init=conv_init)
def __init__(self, inch, outch, first_stride=2):
super(BlockA, self).__init__()
initialW = initializers.HeNormal(scale=1.0)
with self.init_scope():
self.conv1 = L.Convolution2D(
inch, outch, ksize=3, stride=first_stride, pad=3 // 2, initialW=initialW, nobias=True)
self.bn1 = L.BatchNormalization(outch)
self.conv2 = L.Convolution2D(
outch, outch, ksize=3, stride=1, pad=3 // 2, initialW=initialW, nobias=True)
self.bn2 = L.BatchNormalization(outch)
self.conv_skip = L.Convolution2D(
inch, outch, ksize=3, stride=first_stride, pad=3 // 2, initialW=initialW, nobias=True)
self.bn_skip = L.BatchNormalization(outch)
def __init__(self, depth, ksize, stride=1, pad=0, initialW=I.HeNormal()):
super(ConvBnRelu, self).__init__()
with self.init_scope():
self.conv = L.Convolution2D(None,
depth,
ksize=ksize,
stride=stride,
pad=pad,
initialW=initialW,
nobias=True)
self.bn = L.BatchNormalization(depth,
decay=0.9997,
eps=0.001,
use_gamma=False)
def __init__(self, n_layers, insize, outsize, initialW=None, use_bi_lstm=False):
super(TemporalRNN, self).__init__()
if not initialW:
initialW = initializers.HeNormal()
self.n_layer = n_layers
self.insize= insize
with self.init_scope():
if use_bi_lstm:
self.lstm = L.NStepBiLSTM(self.n_layer, 1024, 256, dropout=0.1) #dropout = 0.0
else:
self.lstm = L.NStepLSTM(self.n_layer, 1024, 512, dropout=0.1)
self.fc1 = L.Linear(insize, 1024, initialW=initialW)
self.fc2 = L.Linear(1024, 1024, initialW=initialW)
self.fc3 = L.Linear(512, outsize, initialW=initialW)
def __init__(self, use_optical_flow=False, temporal_length=10):
super(ResnetFeatureExtractor, self).__init__()
with self.init_scope():
if use_optical_flow:
self.conv1 = L.Convolution2D(2 * temporal_length,
64,
7,
2,
3,
initialW=initializers.HeNormal(),
nobias=True)
else:
self.conv1 = L.Convolution2D(3,
64,
7,
2,
3,
initialW=initializers.HeNormal(),
nobias=True)
self.bn1 = L.BatchNormalization(64)
self.res2 = Block(3, 64, 64, 256, 1)
self.res3 = Block(4, 256, 128, 512)
self.res4 = Block(23, 512, 256, 1024)
def __init__(self,
roi_size=7,
spatial_scale=1 / 16.0,
n_class=22,
classify_mode=False):
# n_class includes the background
super(MobileNetHead, self).__init__()
self.classify_mode = classify_mode
initialW = initializers.HeNormal()
self.roi_size = roi_size
self.spatial_scale = spatial_scale # 这个很关键,一般都是1/16.0
with self.init_scope():
self.convert_feature_dim_fc = L.Linear(75264, 2048)
self.score = L.Linear(2048, n_class)
def __init__(self):
super(ResNet_v2_50, self).__init__()
with self.init_scope():
self.conv1 = L.Convolution2D(3,
64,
7,
2,
3,
initialW=initializers.HeNormal())
self.res2 = Block(3, 64, 64, 256, stride=2)
self.res3 = Block(4, 256, 128, 512, stride=2)
self.res4 = Block(6, 512, 256, 1024, stride=2)
self.res5 = Block(3, 1024, 512, 2048, stride=1)
self.postnorm = L.BatchNormalization(2048)
def __init__(self, action_space, hidden_layers=[100, 100, 100], seed=0):
super().__init__()
# assert hasattr(action_space, 'n')
# assert hasattr(action_space, 'sample')
self.action_size = action_space.shape[0]
w_init = initializers.HeNormal(rng=np.random.RandomState(seed))
with self.init_scope():
self.hidden_layers = chainer.ChainList(
*[L.Linear(None, h, initialW=w_init) for h in hidden_layers])
# self.mu_layers = chainer.ChainList(*[L.Linear(None, self.action_size, initialW=w_init)])
self.mu_layers = L.Linear(None, self.action_size, initialW=w_init)
self.action_out = SoftmaxDistribution
self.activation = F.relu
def __init__(self, n_classes):
super(ResNet50, self).__init__()
with self.init_scope():
self.conv1 = L.Convolution2D(3,
64,
7,
2,
3,
initialW=initializers.HeNormal())
self.bn1 = L.BatchNormalization(64)
self.res2 = Block(3, 64, 64, 256, 1)
self.res3 = Block(4, 256, 128, 512)
self.res4 = Block(6, 512, 256, 1024)
self.res5 = Block(3, 1024, 512, 2048)
self.fc = L.Linear(2048, n_classes)
def __init__(self, inout_units, hidden_units):
"""
@param inout_units: the number of input units
@param hidden_units: the number of hidden units
"""
initializer = I.HeNormal()
super(Seq2Seq, self).__init__(
l1=L.Linear(inout_units, hidden_units, initialW=initializer),
l2=L.LSTM(hidden_units, hidden_units),
l3=L.Linear(hidden_units, inout_units, initialW=initializer),
w1=L.Linear(hidden_units, hidden_units, initialW=initializer),
w2=L.Linear(hidden_units, hidden_units, initialW=initializer),
)
self.phase = Seq2Seq.Train
self.train = True
