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 _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
def __init__(self, inplanes, gpu): super(hourglass, self).__init__() self.gpu = gpu self.conv1 = Sequential( convbn_3d(inplanes, inplanes * 2, kernel_size=3, stride=2, pad=1), F.relu).to_gpu(self.gpu) self.conv2 = convbn_3d(inplanes * 2, inplanes * 2, kernel_size=3, stride=1, pad=1).to_gpu(self.gpu) self.conv3 = Sequential( convbn_3d(inplanes * 2, inplanes * 2, kernel_size=3, stride=2, pad=1), F.relu).to_gpu(self.gpu) self.conv4 = Sequential( convbn_3d(inplanes * 2, inplanes * 2, kernel_size=3, stride=1, pad=1), F.relu).to_gpu(self.gpu) self.conv5 = Sequential( L.DeconvolutionND(3, inplanes * 2, inplanes * 2, ksize=4, stride=2, pad=1, nobias=True, initialW=ini.Normal(math.sqrt(2. / 32))), L.BatchNormalization(inplanes * 2, eps=1e-5, decay=0.95, initial_gamma=ini.One(), initial_beta=ini.Zero())).to_gpu( self.gpu) # +conv2 self.conv6 = Sequential( L.DeconvolutionND(3, inplanes * 2, inplanes, ksize=4, stride=2, pad=1, nobias=True), L.BatchNormalization(inplanes, eps=1e-5, decay=0.95, initial_gamma=ini.One(), initial_beta=ini.Zero())).to_gpu( self.gpu) # +x
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 __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 __init__(self, levels=7, first_channels=16, last_channels=512, categories=1, depth=8, group_size=None): super().__init__() in_channels = [first_channels] * (levels - 1) out_channels = [last_channels] * (levels - 1) for i in range(1, levels - 1): channels = min(first_channels * 2 ** i, last_channels) in_channels[i] = channels out_channels[i - 1] = channels with self.init_scope(): self.main = Sequential( FromRGB(first_channels), Sequential(*[ResidualBlock(i, o) for i, o in zip(in_channels, out_channels)]), OutputBlock(last_channels, categories > 1, group_size)) if categories > 1: self.embedder = EqualizedLinear(categories, last_channels, gain=1) self.mapper = Sequential(EqualizedLinear(last_channels, last_channels), LeakyRelu()).repeat(depth)
def fully_connected(input_dim, output_dim, with_bn=True): bn = L.BatchNormalization(output_dim) if with_bn else F.identity return Sequential( L.Linear(input_dim, output_dim), bn, F.relu, )
def __init__(self, channels: int, num_classes: int, layers: int, auxiliary, genotype): super(NetworkCIFAR, self).__init__() self._layers = layers self._auxiliary = auxiliary stem_multiplier = 3 curr_ch = stem_multiplier * channels self.stem = Sequential( links.Convolution2D(3, curr_ch, 3, pad=1, nobias=True), links.BatchNormalization(curr_ch) ) pp_ch, p_ch, curr_ch = curr_ch, curr_ch, channels self.cells = chainer.ChainList() reduction_prev = False ch_to_auxiliary: int = -1 for i in range(layers): if i in [layers // 3, 2 * layers // 3]: curr_ch *= 2 reduction = True else: reduction = False cell = Cell(genotype, pp_ch, p_ch, curr_ch, reduction, reduction_prev) reduction_prev = reduction self.cells.add_link(cell) pp_ch, p_ch = p_ch, cell.multiplier * curr_ch if i == 2 * layers // 3: ch_to_auxiliary = p_ch assert ch_to_auxiliary != -1 if auxiliary: self.auxiliary_head = AuxiliaryHeadCIFAR(ch_to_auxiliary, num_classes) self.classifier = links.Linear(p_ch, num_classes)
def __init__(self, in_channels, out_channels, k_size, stride, padding, dilation, affine=True): super(DilConv, self).__init__() with self.init_scope(): self.op = Sequential( func.relu, links.Convolution2D(in_channels, out_channels, ksize=k_size, stride=stride, pad=padding, dilate=dilation, groups=in_channels, nobias=True), links.Convolution2D(in_channels, out_channels, ksize=1, pad=0, nobias=True), links.BatchNormalization(out_channels, use_gamma=affine, use_beta=affine), )
def __init__(self, inplanes, planes, stride=1): super(BasicBlock, self).__init__() with self.init_scope(): self.conv1 = L.Convolution2D(inplanes, planes, ksize=3, stride=stride, pad=1, nobias=True) self.bn1 = L.BatchNormalization(planes) self.conv2 = L.Convolution2D(planes, planes, ksize=3, stride=1, pad=1, nobias=True) self.bn2 = L.BatchNormalization(planes) if inplanes != planes: self.downsample = Sequential( L.Convolution2D(inplanes, planes, ksize=1, stride=stride, nobias=True), L.BatchNormalization(planes)) else: self.downsample = lambda x: x
def __init__(self, n_inputs, n_outputs, ksize, stride, dilate, pad, dropout=0.2): super(TemporalBlock, self).__init__() with self.init_scope(): self.conv1 = DilatedConvolution1D(n_inputs, n_outputs, ksize, stride=stride, pad=pad, dilate=dilate) self.chomp1 = Chomp1d(pad) self.relu1 = F.relu self.dropout1 = partial(F.dropout, ratio=dropout) self.conv2 = DilatedConvolution1D(n_outputs, n_outputs, ksize, stride=stride, pad=pad, dilate=dilate) self.chomp2 = Chomp1d(pad) self.relu2 = F.relu self.dropout2 = partial(F.dropout, ratio=dropout) self.net = Sequential(self.conv1, self.chomp1, self.relu1, self.dropout1, self.conv2, self.chomp2, self.relu2, self.dropout2) self.downsample = L.ConvolutionND( 1, n_inputs, n_outputs, 1) if n_inputs != n_outputs else None self.relu = F.relu
def __init__(self, channels, blocks, ksize): super().__init__() with self.init_scope(): self.frgb = Convolution2D(3, channels, ksize=1) self.resnet = Sequential(ResidualBlock(channels, ksize)).repeat(blocks) self.trgb = Convolution2D(channels, 3, ksize=1)
def _make_layer(self, block, planes, blocks, stride): strides = [stride] + [1] * (blocks - 1) layers = [] for stride in strides: layers.append(block(self.inplane, planes, stride)) self.inplane = planes return Sequential(*layers)
def __init__(self, channels, blocks, ksize): super().__init__() with self.init_scope(): self.resnet = Sequential(ResidualBlock(channels, ksize)).repeat(blocks) self.c = Convolution2D(channels + 3, channels, ksize=3) self.r = LeakyReluLink() self.up = Upsampler()
def __init__(self, classes, pretrained_resnet, use_roialign=False, mean_path="", min_size=512, max_size=512): super(FPN101, self).__init__() self.classes = classes self.use_roialign = use_roialign self.min_size = min_size self.max_size = max_size mean = np.load(mean_path) self.mean = np.resize(mean, (3, self.min_size, self.min_size)) with self.init_scope(): self.top_layer = L.Convolution2D(2048, 256, ksize=1, stride=1, pad=0) # Reduce channels # smooth layer self.smooth1 = L.Convolution2D(256, 256, ksize=3, stride=1, pad=1) self.smooth2 = L.Convolution2D(256, 256, ksize=3, stride=1, pad=1) self.smooth3 = L.Convolution2D(256, 256, ksize=3, stride=1, pad=1) # Lateral layers self.latlayer1 = L.Convolution2D(1024, 256, ksize=1, stride=1, pad=0) self.latlayer2 = L.Convolution2D(512, 256, ksize=1, stride=1, pad=0) self.latlayer3 = L.Convolution2D(256, 256, ksize=1, stride=1, pad=0) self.roi_feat_downsample = L.Convolution2D(256, 256, ksize=3, stride=2, pad=1) self.rcnn_top = Sequential( L.Convolution2D(256, 1024, ksize=7, stride=7, pad=0), F.relu, L.Convolution2D(1024, 1024, ksize=1, stride=1, pad=0), F.relu) self.cls_score = L.Linear(1024, self.classes) self.resnet101 = ResNet101Layers( pretrained_model=self._models["resnet101"]["path"]) if pretrained_resnet.endswith(".npz"): print("loading :{} to FPN-101".format(pretrained_resnet)) chainer.serializers.load_npz(pretrained_resnet, self)
def __init__(self, channels: int, stride): super(MixedOp, self).__init__() with self.init_scope(): self._ops = chainer.ChainList() for primitive in PRIMITIVES: op = OPS[primitive](channels, stride, False) if 'pool' in primitive: op = Sequential(op, links.BatchNormalization(channels, use_gamma=False, use_beta=False)) self._ops.add_link(op)
def convbn_3d(in_planes, out_planes, kernel_size, stride, pad): return Sequential( L.ConvolutionND(3, in_planes, out_planes, ksize=kernel_size, stride=stride, pad=pad, nobias=True, initialW=ini.Normal(math.sqrt(2. / (kernel_size * kernel_size * kernel_size * out_planes)))), L.BatchNormalization(out_planes, eps=1e-5, decay=0.95, initial_gamma=ini.One(), initial_beta=ini.Zero()), )
def make_layers_reverse(kernel, input_dim, output_dim, modules, layer=conv_bn_relu): heads = layer(kernel, input_dim, input_dim).repeat(modules - 1) tail = layer(kernel, input_dim, output_dim) return Sequential(heads, tail)
def __init__(self, inplanes, planes, stride, downsample, pad, dilation): super(BasicBlock, self).__init__() with self.init_scope(): self.conv1 = Sequential(convbn(inplanes, planes, 3, stride, pad, dilation), F.relu) self.conv2 = convbn(planes, planes, 3, 1, pad, dilation) self.downsample = downsample self.stride = stride
def __init__(self, channels: int, num_classes: int, layers: int, auxiliary, genotype): super(NetworkImageNet, self).__init__() self._layers = layers self._auxiliary = auxiliary self.stem0 = Sequential( links.Convolution2D(3, channels // 2, ksize=3, stride=2, pad=1, nobias=True), links.BatchNormalization(channels // 2), func.relu, links.Convolution2D(channels // 2, channels, ksize=3, stride=2, pad=1, nobias=True), links.BatchNormalization(channels), ) self.stem1 = Sequential( func.relu, links.Convolution2D(channels, channels, 3, stride=2, pad=1, nobias=True), links.BatchNormalization(channels), ) pp_ch, p_ch, curr_ch = channels, channels, channels self.cells = chainer.ChainList() reduction_prev = True ch_to_auxiliary = -1 for i in range(layers): if i in [layers // 3, 2 * layers // 3]: curr_ch *= 2 reduction = True else: reduction = False cell = Cell(genotype, pp_ch, p_ch, curr_ch, reduction, reduction_prev) reduction_prev = reduction self.cells.add_link(cell) pp_ch, p_ch = p_ch, cell.multiplier * curr_ch if i == 2 * layers // 3: ch_to_auxiliary = p_ch assert ch_to_auxiliary != -1 if auxiliary: self.auxiliary_head = AuxiliaryHeadImageNet(ch_to_auxiliary, num_classes) self.classifier = links.Linear(p_ch, num_classes)
class TwoLayerNet: def __init__(self, input_size, hidden_size, output_size): self.net = Sequential(L.Linear(input_size, hidden_size), F.relu, L.Linear(hidden_size, output_size)) def predict(self, x): return self.net(x) def loss(self, x, t): y = self.predict(x) return F.softmax_cross_entropy(y, t) def accuracy(self, x, t): y = self.predict(x) accuracy = F.accuracy(y, t) return accuracy def gradient(self, x, t): loss = self.loss(x, t) self.net.cleargrads() loss.backward() return loss.grad
def prepare(self, x, t): x = x.astype('float32') t = t.astype('float32') indices = np.arange(len(t)) #インデックスリスト #データ全体を訓練データ&検証データセットとテストデータセットに分割 self.x_train_val, self.x_test, self.t_train_val, self.t_test, self.train_indices, self.test_indices \ = train_test_split(x, t, indices, test_size=0.3) #訓練データと検証データセットに分割 self.x_train, self.x_val, self.t_train, self.t_val = train_test_split( self.x_train_val, self.t_train_val, test_size=0.3) #ネットワークの定義 self.net = Sequential(L.Linear(self.n_input, self.n_hidden), F.relu, L.Linear(self.n_hidden, self.n_hidden), F.relu, L.Linear(self.n_hidden, self.n_output)) #最適化手法の定義 self.optimizer = chainer.optimizers.SGD(lr=0.001) #ネットワークのパラメータを optimizer 設定 self.optimizer.setup(self.net)
def __init__(self, channels, num_classes): """assuming input size 14x14""" super(AuxiliaryHeadImageNet, self).__init__() self.features = Sequential( func.relu, func.AveragePooling2D(ksize=5, stride=2, pad=0, cover_all=False).apply, links.Convolution2D(channels, 128, 1, nobias=True), links.BatchNormalization(128), func.relu, links.Convolution2D(128, 768, 2, nobias=True), links.BatchNormalization(768), func.relu ) self.classifier = links.Linear(768, num_classes)
def __init__(self, in_ch, out_ch, w_init=inits.HeNormal()): super(OCBlock, self).__init__() with self.init_scope(): self.conv_pre = Sequential( L.Convolution2D(in_ch, out_ch, ksize=3, pad=1, nobias=True, initialW=w_init), AutomaticBatchRenormalization(out_ch, decay=0.99)) self.context = ObjectContextPooling(out_ch, out_ch // 2, out_ch, w_init=w_init) self.conv_post = Sequential( L.Convolution2D(2 * out_ch, out_ch, ksize=1, pad=0, nobias=True, initialW=w_init), AutomaticBatchRenormalization(out_ch, decay=0.99))
def inference(self, input_data): loaded_net = Sequential(L.Linear(self.n_input, self.n_hidden), F.relu, L.Linear(self.n_hidden, self.n_hidden), F.relu, L.Linear(self.n_hidden, self.n_output)) chainer.serializers.load_npz('sample.net', loaded_net) with chainer.using_config('train', False), chainer.using_config( 'enable_backprop', False): y_test = loaded_net(input_data) #self.t_test.data.dtype = np.float32 y_test = y_test[:].array y_test = y_test.T y_test = y_test[0] return y_test
def inferrene_cifar10(test_data, test_label): # ニューラルネットを使って推論 loaded_net = Sequential( L.Linear(n_input, n_hidden), F.relu, L.Linear(n_hidden, n_hidden), F.relu, L.Linear(n_hidden, n_output) ) chainer.serializers.load_npz('my_cifar10.net', loaded_net) with chainer.using_config('train', False), chainer.using_config('enablebackprop', False): results_test = loaded_net(test_data) print(np.argmax(results_test[0, :].array)) return 0
def conv_bn_relu(kernel_size, input_dim, output_dim, stride=1, with_bn=True) -> Sequential: pad = (kernel_size - 1) // 2 bn = L.BatchNormalization(output_dim) if with_bn else F.identity return Sequential( L.Convolution2D(input_dim, output_dim, kernel_size, stride, pad, nobias=(not with_bn)), bn, F.relu, )
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 __init__(self, in_ch, key_ch, out_ch, w_init=inits.HeNormal()): super(ObjectContextPooling, self).__init__() with self.init_scope(): self.f_key = Sequential( L.Convolution2D(in_ch, key_ch, ksize=1, pad=0, nobias=True, initialW=w_init), AutomaticBatchRenormalization(key_ch, decay=0.99)) self.f_value = L.Convolution2D(in_ch, out_ch, ksize=1, pad=0, nobias=False, initialW=w_init)
def __init__(self, channels: int, num_classes: int, layers: int, steps: int=4, multiplier: int=4, stem_multiplier: int=3, criterion=func.softmax_cross_entropy): super(Network, self).__init__() # 初項2 (入力数), 項数steps, 公差1 k = int(steps * (2 * 2 + (steps - 1)) / 2) num_ops = len(PRIMITIVES) self._steps = steps self._multiplier = multiplier curr_ch = stem_multiplier * channels with self.init_scope(): self.stem = Sequential( links.Convolution2D(in_channels=3, out_channels=curr_ch, ksize=3, pad=1, nobias=True), links.BatchNormalization(curr_ch) ) pp_ch, p_ch, curr_ch = curr_ch, curr_ch, channels self.cells = chainer.ChainList() reduction_prev = False for i in range(layers): if i in [layers // 3, 2 * layers // 3]: curr_ch *= 2 reduction = True else: reduction = False cell = Cell(steps, multiplier, pp_ch, p_ch, curr_ch, reduction, reduction_prev) reduction_prev = reduction self.cells.add_link(cell) pp_ch, p_ch = p_ch, multiplier * curr_ch self.classifier = links.Linear(p_ch, num_classes) # params()ではalphaを取得したくないのでinit_scopeの外に出す # 元実装に従うけどこれはresumeしない前提なのかな self.alphas_normal = Attention(k, num_ops) self.alphas_reduce = Attention(k, num_ops) self._arch_parameters = [self.alphas_normal, self.alphas_reduce] self.normal_shape = self.alphas_normal.attention.shape self.reduce_shape = self.alphas_reduce.attention.shape self._criterion = criterion