def forward(self, x): hs = list(self.base(x)) # TODO: change name # calculate P6, P7, ... _hs = [] h = hs[-1] for i, conv in enumerate(self.convs): if i == 0: h = conv(h) else: h = conv(F.relu(h)) _hs.append(h) for i in reversed(range(len(hs))): hs[i] = self.inner[i](hs[i]) if i + 1 < len(hs): hs[i] += F.unpooling_2d(hs[i + 1], 2, cover_all=False) for i in range(len(hs)): hs[i] = self.outer[i](hs[i]) # append P6, P7, ... to [P3, P4, P5] hs += _hs return hs
def check_backward_consistency_regression(self, backend_config): # Regression test to two-dimensional unpooling layer. x_data, = self.generate_inputs() gy_data = numpy.random.uniform(-1, 1, self.gy_shape).astype(self.dtype) ksize = self.ksize stride = self.stride pad = self.pad xp = backend.get_array_module(x_data) # Backward computation for N-dimensional unpooling layer. x_nd = chainer.Variable(xp.array(x_data)) y_nd = functions.unpooling_nd( x_nd, ksize, stride=stride, pad=pad, cover_all=self.cover_all) y_nd.grad = gy_data y_nd.backward() # Backward computation for two-dimensional unpooling layer. x_2d = chainer.Variable(xp.array(x_data)) y_2d = functions.unpooling_2d( x_2d, ksize, stride=stride, pad=pad, cover_all=self.cover_all) y_2d.grad = gy_data y_2d.backward() # Test that the two result gradients are close enough. opt = self.check_backward_options testing.assert_allclose( x_nd.grad, x_2d.grad, atol=opt['atol'], rtol=opt['rtol'])
def check_backward_consistency_regression(self, x_data, gy_data): # Regression test to two-dimensional unpooling layer. ndim = len(self.dims) if ndim != 2: return ksize = self.ksize stride = self.stride pad = self.pad xp = backend.get_array_module(x_data) # Backward computation for N-dimensional unpooling layer. x_nd = chainer.Variable(xp.array(x_data)) y_nd = functions.unpooling_nd( x_nd, ksize, stride=stride, pad=pad, cover_all=self.cover_all) y_nd.grad = gy_data y_nd.backward() # Backward computation for two-dimensional unpooling layer. x_2d = chainer.Variable(xp.array(x_data)) y_2d = functions.unpooling_2d( x_2d, ksize, stride=stride, pad=pad, cover_all=self.cover_all) y_2d.grad = gy_data y_2d.backward() # Test that the two result gradients are close enough. opt = self.check_backward_options testing.assert_allclose( x_nd.grad, x_2d.grad, atol=opt['atol'], rtol=opt['rtol'])
def straight(self, x): h = F.relu(self.scbn0(x)) h = F.unpooling_2d(h, 2, 2, 0, cover_all=False) h = self.c0(h) h = self.c1(F.relu(self.scbn1(h))) return h
def check_forward(self, x_data): x = chainer.Variable(x_data) y = functions.unpooling_2d(x, self.ksize, outsize=self.outsize, cover_all=self.cover_all) self.assertEqual(y.data.dtype, self.dtype) y_data = cuda.to_cpu(y.data) self.assertEqual(self.gy.shape, y_data.shape) for i in six.moves.range(self.N): for c in six.moves.range(self.n_channels): outsize = self.outsize or self.expected_outsize assert y_data.shape[2:] == outsize if outsize == (5, 2): expect = numpy.zeros(outsize, dtype=self.dtype) expect[:2, :] = self.x[i, c, 0, 0] expect[2:4, :] = self.x[i, c, 1, 0] elif outsize == (4, 2): expect = numpy.array([ [self.x[i, c, 0, 0], self.x[i, c, 0, 0]], [self.x[i, c, 0, 0], self.x[i, c, 0, 0]], [self.x[i, c, 1, 0], self.x[i, c, 1, 0]], [self.x[i, c, 1, 0], self.x[i, c, 1, 0]], ]) elif outsize == (3, 1): expect = numpy.array([ [self.x[i, c, 0, 0]], [self.x[i, c, 0, 0]], [self.x[i, c, 1, 0]], ]) else: raise ValueError('Unsupported outsize: {}'.format(outsize)) testing.assert_allclose(expect, y_data[i, c])
def check_forward(self, x_data): x = chainer.Variable(x_data) y = functions.unpooling_2d(x, self.ksize, outsize=self.outsize, cover_all=self.cover_all) self.assertEqual(y.data.dtype, numpy.float32) y_data = cuda.to_cpu(y.data) self.assertEqual(self.gy.shape, y_data.shape) for i in six.moves.range(self.N): for c in six.moves.range(self.n_channels): outsize = self.outsize or self.expected_outsize assert y_data.shape[2:] == outsize if outsize == (5, 2): expect = numpy.zeros(outsize, dtype=numpy.float32) expect[:2, :] = self.x[i, c, 0, 0] expect[2:4, :] = self.x[i, c, 1, 0] elif outsize == (4, 2): expect = numpy.array([ [self.x[i, c, 0, 0], self.x[i, c, 0, 0]], [self.x[i, c, 0, 0], self.x[i, c, 0, 0]], [self.x[i, c, 1, 0], self.x[i, c, 1, 0]], [self.x[i, c, 1, 0], self.x[i, c, 1, 0]], ]) elif outsize == (3, 1): expect = numpy.array([ [self.x[i, c, 0, 0]], [self.x[i, c, 0, 0]], [self.x[i, c, 1, 0]], ]) else: raise ValueError('Unsupported outsize: {}'.format(outsize)) gradient_check.assert_allclose(expect, y_data[i, c])
def __call__(self, x, last=False): l1 = F.unpooling_2d(x, 2, 2, outsize=self.outsize) l2 = F.leaky_relu(self.c1(l1)) l3 = F.leaky_relu(self.c2(l2)) if last: return self.toRGB(l3) return l3
def __call__(self, x): for nth in range(self.layers): if getattr(self, 'P' + str(nth)) is None: setattr(self, 'P' + str(nth), variable.Variable( self.xp.zeros(self.sizes[nth], dtype=x.data.dtype), volatile='auto')) E = [None] * self.layers for nth in range(self.layers): if nth == 0: E[nth] = F.concat((F.relu(x - getattr(self, 'P' + str(nth))), F.relu(getattr(self, 'P' + str(nth)) - x))) else: A = F.max_pooling_2d(F.relu(getattr(self, 'ConvA' + str(nth))(E[nth - 1])), 2, stride = 2) E[nth] = F.concat((F.relu(A - getattr(self, 'P' + str(nth))), F.relu(getattr(self, 'P' + str(nth)) - A))) R = [None] * self.layers for nth in reversed(range(self.layers)): if nth == self.layers - 1: R[nth] = getattr(self, self.rnn_module + str(nth))((E[nth],)) else: upR = F.unpooling_2d(R[nth + 1], 2, stride = 2, cover_all=False) R[nth] = getattr(self, self.rnn_module + str(nth))((E[nth], upR)) if nth == 0: setattr(self, 'P' + str(nth), F.clipped_relu(getattr(self, 'ConvP' + str(nth))(R[nth]), 1.0)) else: setattr(self, 'P' + str(nth), F.relu(getattr(self, 'ConvP' + str(nth))(R[nth]))) return self.P0
def __call__(self, x): h = x if self.activation is not None: h = self.activation(self.c0(h)) if self.sample == "up": h = F.unpooling_2d(h, 2, 2, 0, cover_all=False) return h
def __init__(self, function, inputs, outputs): self.f = lambda x: F.unpooling_2d( x, ksize=(function.params['kh'], function.params['kw']), stride=(function.params['sy'], function.params['sx']), pad=(function.params['ph'], function.params['pw']), outsize=(function.params['outh'], function.params['outw']), cover_all=function.params['cover_all'])
def __call__(self, z, stage): # stage0: c0->c1->out0 # stage1: c0->c1-> (1-a)*(up->out0) + (a)*(b1->out1) # stage2: c0->c1->b1->out1 # stage3: c0->c1->b1-> (1-a)*(up->out1) + (a)*(b2->out2) # stage4: c0->c1->b2->out2 # ... #print(np.prod(self.c0.c.b.data.shape)) stage = min(stage, self.max_stage) alpha = stage - math.floor(stage) stage = math.floor(stage) h = F.reshape(z, (len(z), self.n_hidden, 1, 1)) h = feature_vector_normalization(F.leaky_relu(self.c0(h))) h = feature_vector_normalization(F.leaky_relu(self.c1(h))) for i in range(1, int(stage // 2 + 1)): h = getattr(self, "b%d" % i)(h) if int(stage) % 2 == 0: out = getattr(self, "out%d" % (stage // 2)) x = out(h) else: out_prev = getattr(self, "out%d" % (stage // 2)) out_curr = getattr(self, "out%d" % (stage // 2 + 1)) b_curr = getattr(self, "b%d" % (stage // 2 + 1)) x_0 = out_prev( F.unpooling_2d(h, 2, 2, 0, outsize=(2 * h.shape[2], 2 * h.shape[3]))) x_1 = out_curr(b_curr(h)) x = (1.0 - alpha) * x_0 + alpha * x_1 if chainer.configuration.config.train: return x else: scale = int(self.out_width // x.data.shape[2]) return F.unpooling_2d(x, scale, scale, 0, outsize=(self.out_width, self.out_height))
def __call__(self, x, c): h = self.c0(F.relu(self.spade0(x, c))) h = self.c1(F.relu(self.spade1(h, c))) h_sc = self.c_sc(F.relu(self.spade_sc(x, c))) h = h + h_sc h = F.unpooling_2d(h, 2, 2, 0, cover_all=False) return h
def __call__(self, x): h = F.unpooling_2d(x, 2, 2, 0, cover_all=False) if self.bn: h = self.activ(self.bn0(self.c0(h))) else: h = self.activ(self.c0(h)) return h
def forward(self, x, y): x = F.concat((F.unpooling_2d(x, 2, cover_all=False), y), axis=1) for d in range(NW_DEPTHS[2]): x = self[d](x) x = F.leaky_relu(x, slope=LRELU_SLOPE) if NW_USE_RES: x = x + y return x
def __call__(self, x): if self.sample in ['down', 'none', 'none-7', 'deconv']: h = self.c(x) elif self.sample == 'unpool': h = F.unpooling_2d(x, 2, 2, 0, cover_all=False) h = self.c(h) elif self.sample == 'unpool_res': h = F.unpooling_2d(x, 2, 2, 0, cover_all=False) h0 = self.c(h) if self.use_norm: h = self.norm0(h0) if self.activation is not None: h = self.activation(h) h = h0 + self.cr(h) elif self.sample == 'maxpool': h = self.c(x) h = F.max_pooling_2d(h, 2, 2, 0) elif self.sample == 'maxpool_res': h = self.c(x) if self.use_norm: h = self.norm0(h) if self.activation is not None: h = self.activation(h) h = x + self.cr(h) h = F.max_pooling_2d(h, 2, 2, 0) elif self.sample == 'avgpool': h = self.c(x) h = F.average_pooling_2d(h, 2, 2, 0) elif self.sample == 'avgpool_res': h = self.c(x) if self.use_norm: h = self.norm0(h) if self.activation is not None: h = self.activation(h) h = x + self.cr(h) h = F.average_pooling_2d(h, 2, 2, 0) else: print('unknown sample method %s' % self.sample) exit() if self.use_norm: h = self.norm(h) if self.dropout: h = F.dropout(h, ratio=self.dropout) if self.activation is not None: h = self.activation(h) return h
def __call__(self,x,to_rgb=False): h = F.unpooling_2d(x, 2, 2, 0, outsize=(x.shape[2]*2, x.shape[3]*2)) h = F.leaky_relu(self.dc1(h)) h = F.leaky_relu(self.dc2(h)) if to_rgb: #h = F.tanh(self.to_RGB(h)) h = self.to_RGB(h,False) return h
def __call__(self, w, stage, add_noise=True, w2=None): ''' for alpha in [0, 1), and 2*k+2 + alpha < self.max_stage (-1 <= k <= ...): stage 0 + alpha : z -> block[0] -> out[0] * 1 stage 2*k+1 + alpha : z -> ... -> block[k] -> (up -> out[k]) * (1 - alpha) .................... -> (block[k+1] -> out[k+1]) * (alpha) stage 2*k+2 + alpha : z -> ............... -> (block[k+1] -> out[k+1]) * 1 over flow stages continues. ''' stage = min(stage, self.max_stage - 1e-8) alpha = stage - math.floor(stage) stage = math.floor(stage) h = None if stage % 2 == 0: k = (stage - 2) // 2 # Enable Style Mixing: if w2 is not None and k >= 0: lim = np.random.randint(1, k+2) else: lim = k+2 for i in range(0, (k + 1) + 1): # 0 .. k+1 if i == lim: w = w2 h = self.blocks[i](w, x=h, add_noise=add_noise) h = self.outs[k + 1](h) else: k = (stage - 1) // 2 if w2 is not None and k >= 1: lim = np.random.randint(1, k+1) else: lim = k+1 for i in range(0, k + 1): # 0 .. k if i == lim: w = w2 h = self.blocks[i](w, x=h, add_noise=add_noise) h_0 = self.outs[k](upscale2x(h)) h_1 = self.outs[k + 1](self.blocks[k + 1](w, x=h, add_noise=add_noise)) assert 0. <= alpha < 1. h = (1.0 - alpha) * h_0 + alpha * h_1 if chainer.configuration.config.train: return h else: min_sample_image_size = 64 if h.data.shape[2] < min_sample_image_size: # too small scale = int(min_sample_image_size // h.data.shape[2]) return F.unpooling_2d(h, scale, scale, 0, outsize=(min_sample_image_size, min_sample_image_size)) else: return h
def decode(self, x): h = F.unpooling_2d(x, 2, 2, cover_all=False) h = self.deconv7(h) h = F.relu(h) h = F.unpooling_2d(h, 2, 2, cover_all=False) h = self.deconv6(h) h = F.relu(h) h = F.unpooling_2d(h, 2, 2, cover_all=False) h = self.deconv5(h) h = F.relu(h) h = F.unpooling_2d(h, 2, 2, cover_all=False) h = self.deconv4(h) h = F.relu(h) h = F.unpooling_2d(h, 2, 2, cover_all=False) h = self.deconv3(h) h = F.relu(h) h = F.unpooling_2d(h, 2, 2, cover_all=False) h = self.deconv2(h) h = F.relu(h) h = F.unpooling_2d(h, 2, 2, cover_all=False) h = self.deconv1(h) h = F.relu(h) h = self.deconv0(h) return h
def __call__(self, x): for link in self.children(): x_ = link(x) if "conv" in link.name: x = x_ elif "bn" in link.name: x = F.relu(x_) return F.unpooling_2d(x, 2, cover_all=False)
def __call__(self, x): h = F.unpooling_2d(x, 2, 2, 0, outsize=(x.shape[2] * 2, x.shape[3] * 2)) h = F.leaky_relu(feature_vector_normalize(self.conv0(h))) h = F.leaky_relu(feature_vector_normalize(self.conv1(h))) return h
def __call__(self, x, c, last=False): l1 = F.unpooling_2d(x, 2, 2, outsize=self.outsize) y0 = self.condition(c, l1.shape[2], l1.shape[3]) l1 = F.concat((y0, l1)) l2 = F.leaky_relu(self.c1(l1)) l3 = F.leaky_relu(self.c2(l2)) if last: return self.toRGB(l3) return l3
def __call__(self, x): h = self.conv1_1(x) h = self.conv1_2(h) h = F.max_pooling_2d(h, 2) h = self.conv2_1(h) h = self.conv2_2(h) h = F.max_pooling_2d(h, 2) h = self.conv3_1(h) h = self.conv3_2(h) h = F.relu(self.deconv1_1(h)) h = F.relu(self.deconv1_2(h)) h = F.unpooling_2d(h, 2, outsize=(2 * h.shape[2], 2 * h.shape[3])) h = F.relu(self.deconv2_1(h)) h = F.relu(self.deconv2_2(h)) h = F.unpooling_2d(h, 2, outsize=(2 * h.shape[2], 2 * h.shape[3])) h = F.relu(self.deconv3_1(h)) h = F.sigmoid(self.deconv3_2(h)) return h
def __call__(self, x): h = F.unpooling_2d(x, 2, 2, 0, outsize=(x.shape[2] * 2, x.shape[3] * 2)) h = F.leaky_relu(self.bn0(self.c0(h))) h = F.leaky_relu(self.bn1(self.c1(h))) return h
def __call__(self, x): h = F.unpooling_2d(x, 2, cover_all=False) h1 = F.relu(self.conv1(h)) h1 = self.conv2(h1) h2 = self.conv_(h) return F.relu(h1 + h2)
def __call__(self, x): h = F.reshape(self.l0(x), ((x.shape[0], ) + self.embed_shape)) for i in range(self.n_blocks): for j in range(self.block_size): h = F.elu(getattr(self, 'c{}'.format(i * j + j))(h)) if i < self.n_blocks - 1: h = F.unpooling_2d(h, ksize=2, stride=2, cover_all=False) return self.ln(h)
def __call__(self, z, test=False): h = F.relu(self.bn0(self.fc(z), test=test)) h = F.reshape(h, (z.shape[0], 256, 2, 2)) # Upsample the image and then apply a dimension preserving convolution # with a kernel of size (3, 3), stride and padding of size (1, 1). h = F.unpooling_2d(h, 2, 2, cover_all=False) h = F.relu(self.bn1(self.c1(h), test=test)) h = F.unpooling_2d(h, 2, 2, cover_all=False) h = F.relu(self.bn2(self.c2(h), test=test)) h = F.unpooling_2d(h, 2, 2, cover_all=False) h = F.relu(self.bn3(self.c3(h), test=test)) h = F.unpooling_2d(h, 2, 2, cover_all=False) h = F.sigmoid(self.c4(h)) return h
def __call__(self, x): if self.sample in ['maxpool_res', 'avgpool_res']: h = self.activation(self.norm0(self.c(x))) h = self.norm(self.cr(h)) if self.sample == 'maxpool_res': h = F.max_pooling_2d(h, 2, 2, 0) h = h + F.max_pooling_2d(self.cskip(x), 2, 2, 0) elif self.sample == 'avgpool_res': h = F.average_pooling_2d(h, 2, 2, 0) h = h + F.average_pooling_2d(self.cskip(x), 2, 2, 0) elif self.sample == 'resize': H, W = x.data.shape[2:] h = F.resize_images(x, (2 * H, 2 * W)) h = self.norm(self.c(h)) elif self.sample == 'resize_res': H, W = x.data.shape[2:] h = F.resize_images(x, (2 * H, 2 * W)) h0 = self.activation(self.norm0(self.c(h))) h = self.cskip(h) + self.norm(self.cr(h0)) elif self.sample == 'unpool_res': h = F.unpooling_2d(x, 2, 2, 0, cover_all=False) h0 = self.activation(self.norm0(self.c(h))) h = self.cskip(h) + self.norm(self.cr(h0)) else: if self.sample == 'maxpool': h = self.c(x) h = F.max_pooling_2d(h, 2, 2, 0) elif self.sample == 'avgpool': h = self.c(x) h = F.average_pooling_2d(h, 2, 2, 0) elif self.sample == 'unpool': h = F.unpooling_2d(x, 2, 2, 0, cover_all=False) h = self.c(h) else: h = self.c(x) if self.use_norm: h = self.norm(h) if self.dropout: h = F.dropout(h, ratio=self.dropout) if self.activation is not None: h = self.activation(h) return h
def __call__(self, x): if self.shuffler: h = self.c0(x) h = pixel_shuffler(self.out_ch, h) h = F.relu(self.bshuffe(h)) else: h = F.unpooling_2d(x, 2, 2, 0, cover_all=False) h = F.relu(self.bn0(self.c0(h))) return h
def __call__(self, x): outsize1=x.shape[-2:] h = F.relu(self.conv1(x)) #26 h = F.relu(self.conv2(h)) #24 h = F.max_pooling_2d(h, 2) #12 h = F.relu(self.conv3(h)) #10 h = F.relu(self.conv4(h)) #8 outsize2=h.shape[-2:] h = F.max_pooling_2d(h, 2) #4 h = F.relu(self.conv5(h)) #2 h = F.relu(self.dconv5(h)) #4 h = F.unpooling_2d(h, 2, outsize=outsize2) #8 h = F.relu(self.dconv4(h)) #10 h = F.relu(self.dconv3(h)) #12 h = F.unpooling_2d(h, 2, outsize=outsize1) #24 h = F.relu(self.dconv2(h)) #26 y = F.sigmoid(self.dconv1(h)) # 28 return y
def invert_maxpooling(variable, guided=True): """ Max pooling後の~chainer.Variableから、Max pooling前の状態を復元する Args: variable (~chainer.Variable): Max pooling後の中間層 guided (bool): guided backpropagation を行う場合はTrue、行わない場合はFalse. Returns: data (ndarray): 復元されたMax pooling前の中間層のデータ(返されるのは~chainer.Variableではないことに注意) """ assert variable.creator is not None assert variable.creator.label == 'MaxPooling2D', 'variable.creator should be MaxPooling2D.' v = variable bottom_blob = v.creator.inputs[0] kw, kh = v.creator.kw, v.creator.kh sx, sy = v.creator.sx, v.creator.sy pw, ph = v.creator.pw, v.creator.ph outsize = (bottom_blob.data.shape[2], bottom_blob.data.shape[3]) # UnPooling unpooled_data = F.unpooling_2d(v, (kh, kw), stride=(sy, sx), pad=(ph, pw), outsize=outsize) # Max Location Switchesの作成(Maxの位置だけ1, それ以外は0) ## (1) Max pooling後のマップをNearest neighborでpooling前のサイズに拡大 unpooled_max_map = F.unpooling_2d(F.max_pooling_2d(bottom_blob, (kh, kw), stride=(sy, sx), pad=(ph, pw)), (kh, kw), stride=(sy, sx), pad=(ph, pw), outsize=outsize) ## (2) 最大値と値が一致するところだけ1, それ以外は0 (Max Location Switches) pool_switch = unpooled_max_map.data == bottom_blob.data ## (3) そもそも最大値が0以下だったら伝搬させない (guided backpropagation) if guided: guided_switch = bottom_blob.data > 0 pool_switch *= guided_switch # Max Location Switchesが1のところだけUnPoolingの結果を伝搬、それ以外は0 return unpooled_data.data * pool_switch
def __call__(self, x): if self.down: h = self.act(self.bn0(self.c0(x))) elif self.up: h = F.unpooling_2d(x, 2, 2, 0, cover_all=False) h = self.act(self.bn0(self.c0(h))) else: h = self.act(self.bn0(self.c0(x))) return h
def unpool2d(self, ksize, stride=None, pad=0, outsize=None, cover_all=True): f = self.funcs( 'unpool2d', lambda x: F.unpooling_2d(x, ksize, stride, pad, outsize, cover_all)) f.dot_param = '(ksize:{}, stride:{}, pad:{}, outsize:{}, cover_all:{})'.format( ksize, stride, pad, outsize, cover_all) return f
def __call__(self, x): if self.up: h = F.unpooling_2d(x, 2, 2, 0, cover_all=False) h = glu(self.bn0(self.cup(h))) elif self.down: h = glu(self.bn0(self.cdown(x))) else: h = glu(self.bn0(self.cpara(x))) return h
def resize_mask_like(mask, x): """Resize mask like shape of x. Args: mask: Original mask. x: To shape of x. """ if mask.shape[2] < x.shape[2]: mask_resize = F.unpooling_2d(mask, ksize=4, outsize=x.shape[2:]) else: rate = mask.shape[2] // x.shape[2] mask_resize = mask[:, :, ::rate, ::rate] return mask_resize
def decode(self, z): h = z # unpool1 h = F.reshape(h, self.pool1_outshape) h = F.unpooling_2d(h, ksize=3, stride=2, outsize=self.pool1_inshape[-2:]) # deconv2_1 self.deconv2_1.outsize = self.conv1_2_inshape[-2:] h = self.deconv2_1(h) # deconv2_2 self.deconv2_2.outsize = self.conv1_1_inshape[-2:] h = self.deconv2_2(h) y = h return y
def __call__(self, input_blob, test_mode=False): # explicit and very flexible DAG! ################################# data = input_blob[0] labels = input_blob[1] if(len(input_blob) >= 3): weights_classes = input_blob[2] else: weights_classes = chainer.Variable(cuda.cupy.ones((self.classes, 1), dtype='float32')) # ---- CONTRACTION BLOCKS ---- # blob_b0 = self.bnorm0(data) (blob_b1, indices_b1, size_b1) = F.max_pooling_2dIndices(self.bnorm1(F.relu(self.conv1(blob_b0)), test=test_mode), (2, 2), stride=(2,2), pad=(0, 0)) (blob_b2, indices_b2, size_b2) = F.max_pooling_2dIndices(self.bnorm2(F.relu(self.conv2(blob_b1)), test=test_mode), (2, 2), stride=(2,2), pad=(0, 0)) (blob_b3, indices_b3, size_b3) = F.max_pooling_2dIndices(self.bnorm3(F.relu(self.conv3(blob_b2)), test=test_mode), (2, 2), stride=(2,2), pad=(0, 0)) (blob_b4, indices_b4, size_b4) = F.max_pooling_2dIndices(self.bnorm4(F.relu(self.conv4(blob_b3)), test=test_mode), (2, 2), stride=(2,2), pad=(0, 0)) # ---- EXPANSION BLOCKS ---- # blob_b5 = self.bnorm5(F.relu(self.conv5(F.unpooling_2d(blob_b4, indices_b4, size_b4))), test=test_mode) blob_b6 = self.bnorm6(F.relu(self.conv6(F.unpooling_2d(blob_b5, indices_b3, size_b3))), test=test_mode) blob_b7 = self.bnorm7(F.relu(self.conv7(F.unpooling_2d(blob_b6, indices_b2, size_b2))), test=test_mode) blob_b8 = self.bnorm8(F.relu(self.conv8(F.unpooling_2d(blob_b7, indices_b1, size_b1))), test=test_mode) #ipdb.set_trace() # ---- SOFTMAX CLASSIFIER ---- # self.blob_class = self.classi(blob_b8) self.probs = F.softmax(self.blob_class) # ---- CROSS-ENTROPY LOSS ---- # #ipdb.set_trace() self.loss = F.weighted_cross_entropy(self.probs, labels, weights_classes, normalize=True) self.output_point = self.probs return self.loss
def check_forward_consistency_regression(self, backend_config): # Regression test to two-dimensional unpooling layer. inputs, = self.generate_inputs() x = chainer.Variable(backend_config.get_array(inputs)) ksize = self.ksize stride = self.stride pad = self.pad y_nd = functions.unpooling_nd(x, ksize, stride=stride, pad=pad, cover_all=self.cover_all) y_2d = functions.unpooling_2d(x, ksize, stride=stride, pad=pad, cover_all=self.cover_all) testing.assert_allclose( y_nd.array, y_2d.array, **self.check_forward_options)
def check_forward_consistency_regression(self, x_data): # Regression test to two-dimensional unpooling layer. if len(self.dims) != 2: return ksize = self.ksize stride = self.stride pad = self.pad y_nd = functions.unpooling_nd(x_data, ksize, stride=stride, pad=pad, cover_all=self.cover_all) y_2d = functions.unpooling_2d(x_data, ksize, stride=stride, pad=pad, cover_all=self.cover_all) testing.assert_allclose( y_nd.data, y_2d.data, **self.check_forward_options)
def deconv(self, variable): v = variable if(v.creator is not None): # Convolution -> Deconvolutionに変換 if (v.creator.label == 'Convolution2DFunction'): print(v.creator.label, v.rank) convW = v.creator.inputs[1].data in_cn, out_cn = convW.shape[0], convW.shape[1] # in/out channels kh, kw = convW.shape[2], convW.shape[3] # kernel size sx, sy = v.creator.sx, v.creator.sy # stride pw, ph = v.creator.pw, v.creator.ph # padding name = 'conv' + v.rank # temporal layer name super(DeconvNet, self).add_link(name, L.Deconvolution2D( in_cn, out_cn, (kh, kw), stride=(sy, sx), pad=(ph, pw), nobias=True, initialW=convW)) self.forwards[name] = self[name] # もし畳み込み層にバイアスがある場合、それも登録 if len(v.creator.inputs) == 3: F.bias(v) b = v.creator.inputs[2].data bname = 'convb' + v.rank super(DeconvNet, self).add_link(bname, L.Bias(shape=b.shape)) self[bname].b.data = b self.depends[bname] = (parent) self.depends[name] = (bname) self.forwards[bname] = self[bname] self.layers.append((bname, [parent], name)) else: self.depends[name] = (parent) elif (v.creator.label == 'ReLU'): name = parent elif (v.creator.label == 'MaxPooling2D'): kw, kh = v.creator.kw, v.creator.kh sx, sy = v.creator.sx, v.creator.sy pw, ph = v.creator.pw, v.creator.ph name = 'maxpool' + v.rank self.depends[name] = (parent) self.forwards[name] = lambda x: F.unpooling_2d(x, (kh, kw), stride=(sy, sx), pad=(ph, pw)) self.register_inv_layer(v.creator.inputs[0], name) else: depends['output'] = parent
def __call__(self, bottom_up, top_down=None): with cupy.cuda.Device(self.device): E = F.concat((F.relu(bottom_up - self.P), F.relu(self.P - bottom_up))) if self.istop: A = None R = self.ConvLSTM((E,)) else: A = F.max_pooling_2d(F.relu(self.ConvA(E)), 2, stride=2) unpooled = F.unpooling_2d(top_down, 2, stride=2, cover_all=False) R = self.ConvLSTM((E, unpooled)) if self.isbottom: P = F.clipped_relu(self.ConvP(R), 1.0) else: P = F.relu(self.ConvP(R)) self.P = P return (A, R)
def __call__(self, x, train): h = x # convolution for i in range(len(self.convs)): h = self.activation(self.convs[i](h)) if self.conv_arch[i][3] > 1: h = F.max_pooling_2d(h, self.conv_arch[i][3], self.conv_arch[i][3]) # fc enc for i in range(len(self.encs)): h = F.dropout(self.activation(self.encs[i](h)), train=train) # fc dec for i in reversed(range(len(self.decs))): h = self.activation(self.decs[i](h)) # deconv h = F.reshape(h, (h.data.shape[0], self.conv_arch[-1][1], self.dims[-1], self.dims[-1])) for i in reversed(range(len(self.deconvs))): if self.conv_arch[i][3] > 1: unpool_size = self.dims[i+1] * self.conv_arch[i][3] h = F.unpooling_2d(h, self.conv_arch[i][3], outsize=(unpool_size, unpool_size)) h = self.activation(self.deconvs[i](h)) return h
def decode(self, z): h = F.unpooling_2d(z, ksize=2, stride=2) y = self.deconv2(h) return y
def f(x): return functions.unpooling_2d(x, self.ksize, outsize=self.outsize, cover_all=self.cover_all)
def __call__(self, x): return F.unpooling_2d(x, self.ksize, self.stride, self.pad, self.outsize, self.cover_all)