def _get_model(layers, comm, predict=False): model = Sequential() W = chainer.initializers.HeNormal(1 / np.sqrt(1 / 2), dtype=np.float32) bias = chainer.initializers.Zero(dtype=np.float32) for layer in layers: name = layer['name'] parameter = copy.deepcopy(layer['parameter']) if name.split('.')[0] == 'GC': parameter.update({'predict': predict}) if 'batch_norm' in parameter.keys() and parameter['batch_norm']: parameter.update({'comm': comm}) if 'activation' in parameter.keys() and parameter['activation']: parameter['activation'] = eval(parameter['activation']) add_layer = eval(name)(**parameter) elif name.split('.')[0] == 'L': if 'Linear' in name.split('.')[1]: parameter.update({'initialW': W, 'initial_bias': bias}) add_layer = eval(name)(**parameter) elif name.split('.')[0] == 'F': if len(parameter) == 0: add_layer = partial(eval(name)) else: add_layer = partial(eval(name), **parameter) elif name.split('.')[0] == 'MNL': if predict: add_layer = L.BatchNormalization(size=parameter['size']) else: add_layer = MNL.MultiNodeBatchNormalization( size=parameter['size'], comm=comm) elif name == 'Flat': add_layer = partial(lambda *x: x[0]) model.append(add_layer) return model
class Upsampler(Chain): def __init__(self, channels, ksize, repeat): super().__init__() self.channels = channels self.ksize = ksize self.repeat = repeat with self.init_scope(): self.convs = Sequential( Convolution2D(channels * 2, channels * 2, ksize=ksize, stride=1, pad=0), relu).repeat(repeat) self.convs.append( Convolution2D(channels * 2, channels, ksize=1, stride=1, pad=0)) def __call__(self, x, y): x_height, x_width = x.shape[2:4] z_height, z_width = x_height * 2, x_width * 2 z = resize_images(x, (z_height, z_width), mode="nearest") y_height, y_width = y.shape[2:4] height, width = min(x_height, y_height), min(x_width, y_height) z_width_sub = (z_width - width) // 2 z_height_sub = (z_height - height) // 2 y_width_sub = (y_width - width) // 2 y_height_sub = (y_height - height) // 2 zs = z[:, :, z_height_sub:-z_height_sub, z_width_sub:-z_width_sub] ys = y[:, :, y_height_sub:-y_height_sub, y_width_sub:-y_width_sub] return self.convs(concat((zs, ys), axis=1))
def define_upsampling(opt, input_ch, output_ch=None): if opt.upsampling_mode == 'bilinear': seq = Sequential(lambda x: F.resize_images( x, (x.shape[2] * 2, x.shape[3] * 2), mode='bilinear')) if output_ch is not None: seq.append( define_conv(opt)(input_ch, output_ch, ksize=3, stride=1, pad=1, initialW=HeNormal())) return seq if opt.upsampling_mode == 'nearest': seq = Sequential(lambda x: F.resize_images( x, (x.shape[2] * 2, x.shape[3] * 2), mode='nearest')) if output_ch is not None: seq.append( define_conv(opt)(input_ch, output_ch, ksize=3, stride=1, pad=1, initialW=HeNormal())) return seq if opt.upsampling_mode == 'deconv': return define_deconv(opt)(input_ch, input_ch if output_ch is None else output_ch, ksize=3, stride=1, pad=1, initialW=HeNormal()) if opt.upsampling_mode == 'subpx_conv': return PixelShuffler(opt, input_ch, input_ch if output_ch is None else output_ch)
def _make_layer(self, block, planes, blocks, stride, pad, dilation): downsample = None if stride != 1 or self.inplanes != planes * block.expansion: downsample = Sequential( L.Convolution2D(self.inplanes, planes * block.expansion, ksize=1, stride=stride, nobias=True, initialW=ini.Normal(math.sqrt(2. / (planes * block.expansion)))), L.BatchNormalization(planes * block.expansion, eps=1e-5, decay=0.95, initial_gamma=ini.One(), initial_beta=ini.Zero()), ) layers = Sequential() layers.append(block(self.inplanes, planes, stride, downsample, pad, dilation)) self.inplanes = planes * block.expansion for i in range(1, blocks): layers.append(block(self.inplanes, planes, 1, None, pad, dilation)) return layers
class ShallowConcateS(chainer.Chain): def __init__(self, hidden_units): print(hidden_units) super(ShallowConcateS, self).__init__() with self.init_scope(): self.layers = Sequential() for layer_units in hidden_units: self.layers.append(L.Linear(None, layer_units)) self.layers.append(F.relu) self.layers.append(L.BatchNormalization(layer_units)) self.layers.append(F.dropout) self.last = L.Linear(None, 2) print(self.layers) def __call__(self, x): y = self.layers(x) return self.last(y)