def predict(self, x_data): x = chainer.Variable(x_data, volatile=True) self.train = False test = True h = F.max_pooling_2d( F.relu(self.norm1(self.conv1(x), test=test)), 3, stride=2, pad=1) h = F.max_pooling_2d( F.relu(self.norm2(self.conv2(h), test=test)), 3, stride=2, pad=1) h = self.inc3a(h) h = self.inc3b(h) h = self.inc3c(h) h = self.inc4a(h) a = F.average_pooling_2d(h, 5, stride=3) a = F.relu(self.norma(self.conva(a), test=test)) a = F.relu(self.norma2(self.lina(a), test=test)) a = self.outa(a) h = self.inc4b(h) h = self.inc4c(h) h = self.inc4d(h) b = F.average_pooling_2d(h, 5, stride=3) b = F.relu(self.normb(self.convb(b), test=test)) b = F.relu(self.normb2(self.linb(b), test=test)) b = self.outb(b) h = self.inc4e(h) h = self.inc5a(h) h = F.average_pooling_2d(self.inc5b(h), 7) h = self.out(h) return F.softmax(h)
def forward(self, x_data, y_data, train=True): x = chainer.Variable(x_data, volatile=not train) t = chainer.Variable(y_data, volatile=not train) h = F.max_pooling_2d( F.relu(self.norm1(self.conv1(x))), 3, stride=2, pad=1) h = F.max_pooling_2d( F.relu(self.norm2(self.conv2(h))), 3, stride=2, pad=1) h = self.inc3a(h) h = self.inc3b(h) h = self.inc3c(h) h = self.inc4a(h) a = F.average_pooling_2d(h, 5, stride=3) a = F.relu(self.norma(self.conva(a))) a = F.relu(self.norma2(self.lina(a))) a = self.outa(a) a = F.softmax_cross_entropy(a, t) h = self.inc4b(h) h = self.inc4c(h) h = self.inc4d(h) b = F.average_pooling_2d(h, 5, stride=3) b = F.relu(self.normb(self.convb(b))) b = F.relu(self.normb2(self.linb(b))) b = self.outb(b) b = F.softmax_cross_entropy(b, t) h = self.inc4e(h) h = self.inc5a(h) h = F.average_pooling_2d(self.inc5b(h), 7) h = self.out(h) return 0.3 * (a + b) + F.softmax_cross_entropy(h, t), F.accuracy(h, t)
def __call__(self, x): h2 = F.average_pooling_2d(x[0], 56, stride=1) h3 = F.average_pooling_2d(x[1], 28, stride=1) h4 = F.average_pooling_2d(x[2], 14, stride=1) h5 = F.average_pooling_2d(x[3], 7, stride=1) h = F.concat((h2, h3, h4, h5), axis=1) return self.fc(h)
def forward(self, img, doc, train=True, regression=False, useImage=True, useDoc=True): test = not train if useImage: h = F.max_pooling_2d( F.relu(self.norm1(self.conv1(img), test=test)), 3, stride=2, pad=1) h = F.max_pooling_2d( F.relu(self.norm2(self.conv2(h), test=test)), 3, stride=2, pad=1) h = self.inc3a(h) h = self.inc3b(h) h = self.inc3c(h) h = self.inc4a(h) if train: a = F.average_pooling_2d(h, 5, stride=3) a = F.relu(self.norma(self.conva(a), test=test)) a = F.relu(self.norma2(self.lina(a), test=test)) a = self.outa(a) h = self.inc4b(h) h = self.inc4c(h) h = self.inc4d(h) if train: b = F.average_pooling_2d(h, 5, stride=3) b = F.relu(self.normb(self.convb(b), test=test)) b = F.relu(self.normb2(self.linb(b), test=test)) b = self.outb(b) h = self.inc4e(h) h = self.inc5a(h) h = F.average_pooling_2d(self.inc5b(h), 7) h = F.relu(self.linz(h)) if useDoc: h2 = F.relu(self.doc_fc1(F.dropout(doc, train=train))) h2 = F.relu(self.doc_fc2(h2)) if useDoc and useImage: bi = F.relu(self.bi1(h, h2))#F.concat((h, h2), axis=1) h = self.out(bi) elif useImage: h = self.outimg(h) else: h = self.outdoc(h2) if train: if useImage: return { "a": a, "b": b, "h": h } else: return h else: return h
def __call__(self, x): h1 = F.sigmoid(F.average_pooling_2d(self.conv1(x), 2)) h2 = F.sigmoid(F.average_pooling_2d(self.conv2(h1),2)) h3 = self.conv3(h2) h4 = F.tanh(self.l1(h3)) p = self.l2(h4) return p
def forward(self, x): y0 = F.relu(self.model.conv1(x)) y1 = self.model.cccp2(F.relu(self.model.cccp1(y0))) x1 = F.relu(self.model.conv2(F.average_pooling_2d(F.relu(y1), 3, stride=2))) y2 = self.model.cccp4(F.relu(self.model.cccp3(x1))) x2 = F.relu(self.model.conv3(F.average_pooling_2d(F.relu(y2), 3, stride=2))) y3 = self.model.cccp6(F.relu(self.model.cccp5(x2))) x3 = F.relu(getattr(self.model,"conv4-1024")(F.dropout(F.average_pooling_2d(F.relu(y3), 3, stride=2), train=False))) return [y0,x1,x2,x3]
def forward(model, x_data, y_data, train=True): x, t = Variable(x_data, volatile=not train), Variable(y_data, volatile=not train) h = F.relu(F.max_pooling_2d(model.conv1(x), 3, stride=2)) h = F.relu(F.average_pooling_2d(model.conv2(h), 3, stride=2)) h = F.relu(F.average_pooling_2d(model.conv3(h), 3, stride=2)) h = model.fl4(h) # <- cifar10_quick.prototxt in caffe, instead of below line # h = F.relu(model.fl4(h)) y = model.fl5(h) return F.softmax_cross_entropy(y, t), F.accuracy(y, t)
def __call__(self, x, t): self.clear() test = not self.train h = F.max_pooling_2d( F.relu(self.norm1(self.conv1(x), test=test)), 3, stride=2, pad=1) h = F.max_pooling_2d( F.relu(self.norm2(self.conv2(h), test=test)), 3, stride=2, pad=1) h = self.inc3a(h) h = self.inc3b(h) h = self.inc3c(h) h = self.inc4a(h) a = F.average_pooling_2d(h, 5, stride=3) a = F.relu(self.norma(self.conva(a), test=test)) a = F.relu(self.norma2(self.lina(a), test=test)) a = self.outa(a) self.loss1 = F.softmax_cross_entropy(a, t) h = self.inc4b(h) h = self.inc4c(h) h = self.inc4d(h) b = F.average_pooling_2d(h, 5, stride=3) b = F.relu(self.normb(self.convb(b), test=test)) b = F.relu(self.normb2(self.linb(b), test=test)) b = self.outb(b) self.loss2 = F.softmax_cross_entropy(b, t) h = self.inc4e(h) h = self.inc5a(h) h = F.average_pooling_2d(self.inc5b(h), 7) h = self.out(h) self.loss3 = F.softmax_cross_entropy(h, t) self.loss = 0.3 * (self.loss1 + self.loss2) + self.loss3 self.accuracy = F.accuracy(h, t) shishi = F.softmax(h) # kankan = shishi.data[0].tolist() # categories = np.loadtxt("labels.txt", str, delimiter="\t") # top_k = 10 # prediction = zip(kankan,categories) # for feifei in categories: # print(feifei) # prediction.sort(cmp=lambda x,y: cmp(x[0],y[0]),reverse=True) # cuowushuchu = ('cuowuchushu.txt','w') # for rank,(score,name) in enumerate(prediction[:3],start=1): # print('#%d | %s | %4.1f%%' % (rank,name,score * 100)) # print('\n') # for rank,(score,name) in enumerate(prediction[:2],start=1): # feijigege = score * 100 # cuowushuchu.write(str(name)+' '+str(feijigege)) # cuowushuchu.close() return shishi
def forward(self, x_img, x_doc, y_data, train=True): x_img = cuda.cupy.asarray(x_img) x_doc = cuda.cupy.asarray(x_doc) y_data = cuda.cupy.asarray(y_data) img, doc, t = Variable(x_img), Variable(x_doc), Variable(y_data) h = F.relu(self.conv1(img)) h = F.local_response_normalization( F.max_pooling_2d(h, 3, stride=2), n=5) h = F.relu(self.conv2_reduce(h)) h = F.relu(self.conv2(h)) h = F.max_pooling_2d( F.local_response_normalization(h, n=5), 3, stride=2) h = self.inc3a(h) h = self.inc3b(h) h = F.max_pooling_2d(h, 3, stride=2) h = self.inc4a(h) l = F.average_pooling_2d(h, 5, stride=3) l = F.relu(self.loss1_conv(l)) l = F.relu(self.loss1_fc1(l)) l = self.loss1_fc2(l) self.loss1 = F.softmax_cross_entropy(l, t) h = self.inc4b(h) h = self.inc4c(h) h = self.inc4d(h) l = F.average_pooling_2d(h, 5, stride=3) l = F.relu(self.loss2_conv(l)) l = F.relu(self.loss2_fc1(l)) l = self.loss2_fc2(l) self.loss2 = F.softmax_cross_entropy(l, t) h = self.inc4e(h) h = F.max_pooling_2d(h, 3, stride=2) h = self.inc5a(h) h = self.inc5b(h) h = F.average_pooling_2d(h, 7, stride=1) h = self.loss3_fc1(F.dropout(h, 0.4, train=train)) h2 = F.relu(self.doc_fc1(F.dropout(doc, train=train))) h2 = F.relu(self.doc_fc2(h2)) b = F.relu(self.bi1(h, h2)) h = self.loss3_fc2(b) self.loss3 = F.softmax_cross_entropy(h, t) if train: return 0.3 * (self.loss1 + self.loss2) + self.loss3 else: return F.accuracy(h, t)
def forward_super(self, x, train=True): h = F.relu(self.conv1(x)) h = F.relu(self.conv2(h)) h = F.relu(self.conv3(h)) h = F.relu(self.conv4(h)) h = F.relu(self.conv5(h)) h1 = F.average_pooling_2d(h, self.p_w, stride=self.p_w) h1 = F.average_pooling_2d(h1, self.p_w, stride=self.p_w) return h, h1
def forward(self, x): y1 = self.model.conv1_2(F.relu(self.model.conv1_1(x))) x1 = F.average_pooling_2d(F.relu(y1), 2, stride=2) y2 = self.model.conv2_2(F.relu(self.model.conv2_1(x1))) x2 = F.average_pooling_2d(F.relu(y2), 2, stride=2) y3 = self.model.conv3_3(F.relu(self.model.conv3_2(F.relu(self.model.conv3_1(x2))))) x3 = F.average_pooling_2d(F.relu(y3), 2, stride=2) y4 = self.model.conv4_3(F.relu(self.model.conv4_2(F.relu(self.model.conv4_1(x3))))) # x4 = F.average_pooling_2d(F.relu(y4), 2, stride=2) # y5 = model.conv5_3(F.relu(model.conv5_2(F.relu(model.conv5_1(x4))))) return [y1,y2,y3,y4]
def __call__(self, x_recon, x): bs = x.shape[0] d = np.prod(x.shape[1:]) if x.shape[1:] == 3: h_recon = F.average_pooling_2d(x_recon, (2, 2)) h = F.average_pooling_2d(x, (2, 2)) self.loss = F.mean_squared_error(x_recon, x) / d else: self.loss = F.mean_squared_error(x_recon, x) / d return self.loss
def __call__(self, x, h_feat, test=False): bs = x.shape[0] h = self.convunit0(x, test) h = self.convunit1(h, test) h_feat = F.average_pooling_2d(h_feat, (7, 7)) h_feat = F.reshape(h_feat, (bs, 128)) h = F.average_pooling_2d(h, (7, 7)) h = F.reshape(h_feat, (bs, 128)) h = F.concat((h, h_feat)) h = self.linear(h) #h = F.sigmoid(h) return h
def calc_loss(self, x, t, layer,train=True): self.clear() if(layer ==0) : h = F.max_pooling_2d(F.relu(model.conv1(x)),4) h = self.norm2(h,test= not train) h = F.relu(model.l1(h)) h = F.relu(model.l2(h)) elif layer ==1 : h = F.spatial_pyramid_pooling_2d(F.relu(model.conv1(x)),4,F.MaxPooling2D) h = self.norm5(h,test= not train) h = F.relu(model.l4(h)) h = F.relu(model.l2(h)) elif layer ==2 : h = F.average_pooling_2d(F.relu(model.conv1(x)),4) h = self.norm2(h,test= not train) h = F.relu(model.l1(h)) h = F.relu(model.l2(h)) elif layer ==3 : h = F.max_pooling_2d(F.relu(model.conv1(x)),2) h = self.norm2(h,test= not train) h = F.max_pooling_2d(F.relu(model.conv2(h)),2) h = self.norm1(h,test= not train) h = F.relu(model.l3(h)) h = F.relu(model.l2(h)) elif layer ==4 : h = F.max_pooling_2d(F.relu(model.conv4(x)),2) h = self.norm3(h,test= not train) h = F.spatial_pyramid_pooling_2d(F.relu(model.conv3(h)),2,F.MaxPooling2D) h = self.norm6(h,test= not train) h = F.relu(model.l5(h)) h = F.relu(model.l2(h)) elif layer ==5 : h = F.average_pooling_2d(F.relu(model.conv1(x)),2) h = self.norm2(h,test= not train) h = F.average_pooling_2d(F.relu(model.conv2(h)),2) h = self.norm1(h,test= not train) h = F.relu(model.l3(h)) h = F.relu(model.l2(h)) ''' print (h.data.shape) #t=t.T.data print (t.data) print (h.data.shape) #print (h.data.T) print (t.data.shape) ''' loss = F.mean_squared_error(h, t) return loss
def __call__(self, x): h = F.relu(self.mlpconv1(x)) h = F.max_pooling_2d(h, 3, stride=2) h = F.dropout(h, ratio=0.5) h = F.relu(self.mlpconv2(h)) h = F.average_pooling_2d(h, 3, stride=2) h = F.dropout(h, ratio=0.5) h = self.mlpconv3(h) h = F.average_pooling_2d(h, h.shape[2]) y = F.reshape(h, (x.shape[0], 10)) return y
def forward(model, x_data, ratio=0.1, train=True): """ @summary: フィードフォワードを行う """ x = chainer.Variable(x_data, volatile=False) h = F.max_pooling_2d(F.relu(model.conv1(x)), 3, stride=2) h = F.average_pooling_2d(F.relu(model.conv2(h)), 3, stride=2) h = F.average_pooling_2d(F.relu(model.conv3(h)), 3, stride=2) h = F.dropout(F.relu(model.fl5(h)), train=train, ratio=ratio) y = model.fl6(h) return y
def forward(self, x_data, y_data, train=True): x = chainer.Variable(x_data, volatile=not train) t = chainer.Variable(y_data, volatile=not train) h = F.relu(self.conv1(x)) h = F.local_response_normalization( F.max_pooling_2d(h, 3, stride=2), n=5) h = F.relu(self.conv2_reduce(h)) h = F.relu(self.conv2(h)) h = F.max_pooling_2d( F.local_response_normalization(h, n=5), 3, stride=2) h = self.inc3a(h) h = self.inc3b(h) h = F.max_pooling_2d(h, 3, stride=2) h = self.inc4a(h) if train: loss1 = F.average_pooling_2d(h, 5, stride=3) loss1 = F.relu(self.loss1_conv(loss1)) loss1 = F.relu(self.loss1_fc1(loss1)) loss1 = self.loss1_fc2(loss1) loss1 = F.softmax_cross_entropy(loss1, t) h = self.inc4b(h) h = self.inc4c(h) h = self.inc4d(h) if train: loss2 = F.average_pooling_2d(h, 5, stride=3) loss2 = F.relu(self.loss2_conv(loss2)) loss2 = F.relu(self.loss2_fc1(loss2)) loss2 = self.loss2_fc2(loss2) loss2 = F.softmax_cross_entropy(loss2, t) h = self.inc4e(h) h = F.max_pooling_2d(h, 3, stride=2) h = self.inc5a(h) h = self.inc5b(h) h = F.dropout(F.average_pooling_2d(h, 7, stride=1), 0.4, train=train) h = self.loss3_fc(h) loss3 = F.softmax_cross_entropy(h, t) if train: loss = 0.3 * (loss1 + loss2) + loss3 else: loss = loss3 accuracy = F.accuracy(h, t) return loss, accuracy
def __call__(self, x, t): h = F.relu(self.conv1(x)) h = F.local_response_normalization( F.max_pooling_2d(h, 3, stride=2), n=5) h = F.relu(self.conv2_reduce(h)) h = F.relu(self.conv2(h)) h = F.max_pooling_2d( F.local_response_normalization(h, n=5), 3, stride=2) h = self.inc3a(h) h = self.inc3b(h) h = F.max_pooling_2d(h, 3, stride=2) h = self.inc4a(h) l = F.average_pooling_2d(h, 5, stride=3) l = F.relu(self.loss1_conv(l)) l = F.relu(self.loss1_fc1(l)) l = self.loss1_fc2(l) loss1 = F.softmax_cross_entropy(l, t) h = self.inc4b(h) h = self.inc4c(h) h = self.inc4d(h) l = F.average_pooling_2d(h, 5, stride=3) l = F.relu(self.loss2_conv(l)) l = F.relu(self.loss2_fc1(l)) l = self.loss2_fc2(l) loss2 = F.softmax_cross_entropy(l, t) h = self.inc4e(h) h = F.max_pooling_2d(h, 3, stride=2) h = self.inc5a(h) h = self.inc5b(h) h = F.average_pooling_2d(h, 7, stride=1) h = self.loss3_fc(F.dropout(h, 0.4)) loss3 = F.softmax_cross_entropy(h, t) loss = 0.3 * (loss1 + loss2) + loss3 accuracy = F.accuracy(h, t) chainer.report({ 'loss': loss, 'loss1': loss1, 'loss2': loss2, 'loss3': loss3, 'accuracy': accuracy }, self) return loss
def __call__(self, x, t): h = F.relu(self['conv1/7x7_s2'](x)) h = F.local_response_normalization( F.max_pooling_2d(h, 3, stride=2), n=5, alpha=(1e-4)/5, k=1) h = F.relu(self['conv2/3x3_reduce'](h)) h = F.relu(self['conv2/3x3'](h)) h = F.max_pooling_2d(F.local_response_normalization( h, n=5, alpha=(1e-4)/5, k=1), 3, stride=2) h = self.call_inception(h, 'inception_3a') h = self.call_inception(h, 'inception_3b') h = F.max_pooling_2d(h, 3, stride=2) h = self.call_inception(h, 'inception_4a') l = F.average_pooling_2d(h, 5, stride=3) l = F.relu(self['loss1/conv'](l)) l = F.dropout(F.relu(self['loss1/fc'](l)), 0.7, train=self.train) l = self['loss1/classifier'](l) loss1 = F.softmax_cross_entropy(l, t) h = self.call_inception(h, 'inception_4b') h = self.call_inception(h, 'inception_4c') h = self.call_inception(h, 'inception_4d') l = F.average_pooling_2d(h, 5, stride=3) l = F.relu(self['loss2/conv'](l)) l = F.dropout(F.relu(self['loss2/fc'](l)), 0.7, train=self.train) l = self['loss2/classifier'](l) loss2 = F.softmax_cross_entropy(l, t) h = self.call_inception(h, 'inception_4e') h = F.max_pooling_2d(h, 3, stride=2) h = self.call_inception(h, 'inception_5a') h = self.call_inception(h, 'inception_5b') h = F.average_pooling_2d(h, 7, stride=1) h = self['loss3/classifier'](F.dropout(h, 0.4, train=self.train)) loss3 = F.softmax_cross_entropy(h, t) loss = 0.3 * (loss1 + loss2) + loss3 accuracy = F.accuracy(h, t) chainer.report({ 'loss': loss, 'loss1': loss1, 'loss2': loss2, 'loss3': loss3, 'accuracy': accuracy }, self) return loss
def __call__(self, x, t): test = not self.train finetune = self.finetune h = self.call_conv_bn_sc(x, 'conv1/7x7_s2', test=test, finetune=finetune) h = F.max_pooling_2d(h, 3, stride=2, pad=1) h = self.call_conv_bn_sc(h, 'conv2/3x3_reduce', test=test, finetune=finetune) h = self.call_conv_bn_sc(h, 'conv2/3x3', test=test) h = F.max_pooling_2d(h, 3, stride=2, pad=1) h = self.call_inception_bn(h, 'inception_3a', test=test, finetune=finetune) h = self.call_inception_bn(h, 'inception_3b', test=test, finetune=finetune) h = self.call_inception_bn(h, 'inception_3c', test=test, finetune=finetune) a = F.average_pooling_2d(h, 5, stride=3) a = self.call_conv_bn_sc(a, 'loss1/conv', test=test, finetune=finetune) a = self.call_fc_bn_sc(a, 'loss1/fc', test=test, finetune=finetune) a = self['loss1/classifier'](a) loss1 = F.softmax_cross_entropy(a, t) h = self.call_inception_bn(h, 'inception_4a', test=test, finetune=finetune) h = self.call_inception_bn(h, 'inception_4b', test=test, finetune=finetune) h = self.call_inception_bn(h, 'inception_4c', test=test, finetune=finetune) h = self.call_inception_bn(h, 'inception_4d', test=test, finetune=finetune) h = self.call_inception_bn(h, 'inception_4e', test=test, finetune=finetune) b = F.average_pooling_2d(h, 5, stride=3) b = self.call_conv_bn_sc(b, 'loss2/conv', test=test, finetune=finetune) b = self.call_fc_bn_sc(b, 'loss2/fc', test=test, finetune=finetune) b = self['loss2/classifier'](b) loss2 = F.softmax_cross_entropy(b, t) h = self.call_inception_bn(h, 'inception_5a', test=test, finetune=finetune) h = self.call_inception_bn(h, 'inception_5b', test=test, finetune=finetune) h = F.average_pooling_2d(h, 7, stride=1) h = self['loss3/classifier'](h) loss3 = F.softmax_cross_entropy(h, t) loss = 0.3 * (loss1 + loss2) + loss3 accuracy = F.accuracy(h, t) chainer.report({ 'loss': loss, 'loss1': loss1, 'loss2': loss2, 'loss3': loss3, 'accuracy': accuracy }, self) return loss
def forward_one_step(self, x, test): f = activations[self.activation_function] chain = [x] # Hidden convolutinal layers for i in range(self.n_hidden_layers): u = getattr(self, "layer_%i" % i)(chain[-1]) if self.apply_batchnorm: if i == 0 and self.apply_batchnorm_to_input is False: pass else: u = getattr(self, "batchnorm_%i" % i)(u, test=test) chain.append(f(u)) if self.projection_type == "fully_connection": u = self.projection_layer(chain[-1]) if self.apply_batchnorm: u = self.projection_batchnorm(u, test=test) chain.append(f(u)) elif self.projection_type == "global_average_pooling": batch_size = chain[-1].data.shape[0] n_maps = chain[-1].data[0].shape[0] chain.append(F.average_pooling_2d(chain[-1], self.top_filter_size)) chain.append(F.reshape(chain[-1], (batch_size, n_maps))) u = self.projection_layer(chain[-1]) if self.apply_batchnorm: u = self.projection_batchnorm(u, test=test) chain.append(f(u)) else: raise NotImplementedError() return chain[-1]
def __call__(self, x, test=False): # add gaussian noise #xp = cuda.get_array_module(x.data) #with cuda.get_device_from_id(self.device): # noise = xp.random.randn(*x.shape) * 0.0015 # x.data += noise h = self.conv00(x, test) h = self.conv01(h, test) h = self.conv02(h, test) h = F.max_pooling_2d(h, (2, 2)) # 32 -> 16 h = self.bn0(h, test) h = F.dropout(h, train=not test) h = self.conv10(h, test) h = self.conv11(h, test) h = self.conv12(h, test) h = F.max_pooling_2d(h, (2, 2)) # 16 -> 8 h = self.bn1(h, test) h = F.dropout(h, train=not test) h = self.conv20(h, test) # 8 -> 6 h = self.conv21(h, test) h = self.conv22(h, test) h = self.conv23(h, test) h = F.average_pooling_2d(h, (6, 6)) # 6 -> 1 h = self.bn2(h, test) h = F.reshape(h, (h.shape[0], np.prod(h.shape[1:]))) return h
def check_backward_consistency_regression(self, x_data, gy_data, use_cudnn='always'): # Regression test to two-dimensional average pooling layer. if len(self.dims) != 2: return ksize = self.ksize stride = self.stride pad = self.pad xp = cuda.get_array_module(x_data) # Backward computation for N-dimensional average pooling layer. x_nd = chainer.Variable(xp.array(x_data)) with chainer.using_config('use_cudnn', use_cudnn): y_nd = functions.average_pooling_nd( x_nd, ksize, stride=stride, pad=pad) y_nd.grad = gy_data y_nd.backward() # Backward computation for two-dimensional average pooling layer. x_2d = chainer.Variable(xp.array(x_data)) with chainer.using_config('use_cudnn', use_cudnn): y_2d = functions.average_pooling_2d( x_2d, ksize, stride=stride, pad=pad) y_2d.grad = gy_data y_2d.backward() # Test that the two result gradients are close enough. testing.assert_allclose(x_nd.grad, x_2d.grad)
def __call__(self, x, test=False): h = self.convunit0(x, test) h = self.convunit1(h, test) h = F.average_pooling_2d(h, (7, 7)) h = self.linear(h) #h = F.sigmoid(h) return h
def __call__(self, x): h = x h = self.__dict__["P1_1"](F.leaky_relu(h)) h = self.__dict__["BN1_1"](h) h = self.__dict__["P1_2"](F.leaky_relu(h)) h = self.__dict__["BN1_2"](h) h = F.max_pooling_2d(F.leaky_relu(h), ksize=3, stride=2, cover_all=False) h = self.__dict__["P2_1"](h) h = self.__dict__["BN2_1"](h) h = self.__dict__["P2_2"](F.leaky_relu(h)) h = self.__dict__["BN2_2"](h) h = self.__dict__["P2_2"](F.leaky_relu(h)) h = self.__dict__["BN2_3"](h) h = F.max_pooling_2d(F.leaky_relu(h), ksize=3, stride=2, cover_all=False) h = self.__dict__["P3_1"](h) h = self.__dict__["BN3_1"](h) h = self.__dict__["P3_2"](F.leaky_relu(h)) h = self.__dict__["BN3_2"](h) h = self.__dict__["P3_3"](F.leaky_relu(h)) #h = self.__dict__["BN3_3"](h) h = F.average_pooling_2d(F.leaky_relu(h), ksize=6) #h = self.__dict__["BN3_3"](h) h = self.__dict__["L1"](F.leaky_relu(h)) h = self.__dict__["L2"](h) y = h #h = F.spatial_pyramid_pooling_2d(F.leaky_relu(h), 3) #y = F.reshape(h,(len(h.data),self.F_unit)) return y
def forward(x_data, y_data, print_conf_matrix=False): ''' Neural net architecture :param x_data: :param y_data: :param train: :return: ''' x, t = Variable(x_data), Variable(y_data) h1 = F.relu(model.l1(x)) h1 = F.max_pooling_2d(h1,max_pool_window_1,stride=max_pool_stride_1) h2 = F.dropout(F.relu(model.l2(h1))) h2 = F.average_pooling_2d(h2, avg_pool_window_2, stride=avg_pool_stride_2) h2 = F.max_pooling_2d(h2,max_pool_window_2,stride=max_pool_stride_2) y = model.l3(h2) # display confusion matrix if print_conf_matrix: pdb.set_trace() print confusion_matrix(cuda.to_cpu(t.data), cuda.to_cpu(y.data).argmax(axis=1)) return F.softmax_cross_entropy(y, t), F.accuracy(y, t)
def forward_single(x_data, _size, train=False): datum = x_data[0].transpose([1, 2, 0]) / 255.0 datum = datum.transpose([2, 0, 1]) c, h, w = datum.shape datum = datum.reshape([1, c, h, w]) x = Variable(datum) h = model.conv1(x) h = model.norm1(h) h = F.relu(h) h = F.max_pooling_2d(h, 3, stride=2) h = model.conv2(h) h = model.norm2(h) h = F.relu(h) h = F.max_pooling_2d(h, 3, stride=2) h = model.conv3(h) h = model.norm3(h) h = F.relu(h) h = F.average_pooling_2d(h, 3, stride=2) h = model.conv4(h) h = F.softmax(h) y = h.data """ positive 領域 """ fmap = resize(y[0][1], _size).astype(np.float32) return fmap
def __call__(self, x, test=False): # add gaussian noise xp = cuda.get_array_module(x.data) with cuda.get_device(self.device): noise = xp.random.randn(*x.shape) * 0.15 x.data += noise # (conv -> act -> bn) x 3 -> maxpool -> dropout h = self.bn_conv0(self.act(self.conv0(x), 0.1), test) h = self.bn_conv1(self.act(self.conv1(h), 0.1), test) h = self.bn_conv2(self.act(self.conv2(h), 0.1), test) h = F.max_pooling_2d(h, (2, 2)) # 32 -> 16 h = F.dropout(h, 0.5, not test) # (conv -> act -> bn) x 3 -> maxpool -> dropout h = self.bn_conv3(self.act(self.conv3(h), 0.1), test) h = self.bn_conv4(self.act(self.conv4(h), 0.1), test) h = self.bn_conv5(self.act(self.conv5(h), 0.1), test) h = F.max_pooling_2d(h, (2, 2)) # 16 -> 8 h = F.dropout(h, 0.5, not test) # conv -> act -> bn -> (nin -> act -> bn) x 2 h = self.bn_conv6(self.act(self.conv6(h), 0.1), test) # 8 -> 6 h = self.bn_conv7(self.act(self.conv7(h), 0.1), test) h = self.bn_conv8(self.act(self.conv8(h), 0.1), test) h = F.average_pooling_2d(h, (6, 6)) h = self.linear(h) return h
def compute(s): datum = x_data[0].transpose([1, 2, 0]) / 255.0 datum = rescale(datum, s).astype(np.float32) datum = datum.transpose([2, 0, 1]) c, h, w = datum.shape datum = datum.reshape([1, c, h, w]) x = Variable(datum) h = model.conv1(x) h = model.norm1(h) h = F.relu(h) h = F.max_pooling_2d(h, 3, stride=2) h = model.conv2(h) h = model.norm2(h) h = F.relu(h) h = F.max_pooling_2d(h, 3, stride=2) h = model.conv3(h) h = model.norm3(h) h = F.relu(h) h = F.average_pooling_2d(h, 3, stride=2) h = model.conv4(h) h = F.softmax(h) y = h.data """ positive 領域 """ fmap = resize(y[0][1], _size).astype(np.float32) global_output.append(fmap)
def check_backward_consistency_regression( self, x_data, gy_data, backend_config): # Regression test to two-dimensional average pooling layer. ksize = self.ksize stride = self.stride pad = self.pad pad_value = self.pad_value # Backward computation for N-dimensional average pooling layer. x_nd = chainer.Variable(x_data) with backend_config: y_nd = functions.average_pooling_nd( x_nd, ksize, stride=stride, pad=pad, pad_value=pad_value) y_nd.grad = gy_data y_nd.backward() # Backward computation for two-dimensional average pooling layer. x_2d = chainer.Variable(x_data) with backend_config: y_2d = functions.average_pooling_2d( x_2d, ksize, stride=stride, pad=pad) y_2d.grad = gy_data y_2d.backward() # Test that the two result gradients are close enough. testing.assert_allclose(x_nd.grad, x_2d.grad, **self.tolerance)
def __call__(self, x, t): self.clear() h = self.bn1(self.conv1(x), test=not self.train) h = F.max_pooling_2d(F.relu(h), 3, stride=2) h = self.res2(h, self.train) h = self.res3(h, self.train) h = self.res4(h, self.train) h = self.res5(h, self.train) h = F.average_pooling_2d(h, 7, stride=1) if t == "feature": return h h = self.fc(h) if self.train: self.loss = F.softmax_cross_entropy(h, t) self.accuracy = F.accuracy(h, t) return self.loss else: return h
def __call__(self, x): h = F.leaky_relu(self.bias1(self.bn1(self.conv1(x))), slope=0.1) h = F.max_pooling_2d(h, ksize=3, stride=2, pad=0) h = F.leaky_relu(self.bias2(self.bn2(self.conv2(h))), slope=0.1) h = F.max_pooling_2d(h, ksize=3, stride=2, pad=0) h = F.leaky_relu(self.bias3(self.bn3(self.conv3(h))), slope=0.1) h = F.max_pooling_2d(h, ksize=3, stride=2, pad=0) h = F.leaky_relu(self.bias4(self.bn4(self.conv4(h))), slope=0.1) h = F.max_pooling_2d(h, ksize=3, stride=2, pad=0) h = self.conv5(h) h = F.average_pooling_2d(h, ksize=(h.shape[-2], h.shape[-1])) h = self.conv6(h) # h = F.dropout(h, ratio=0.4) # h = self.out(h) return h.reshape((h.shape[0], -1))
def check_forward(self, x_data, use_cudnn=True): x = chainer.Variable(x_data) y = functions.average_pooling_2d(x, 3, stride=2, pad=1, use_cudnn=use_cudnn) self.assertEqual(y.data.dtype, self.dtype) y_data = cuda.to_cpu(y.data) self.assertEqual(self.gy.shape, y_data.shape) for k in six.moves.range(2): for c in six.moves.range(3): x = self.x[k, c] expect = numpy.array([[x[0:2, 0:2].sum(), x[0:2, 1:3].sum()], [x[1:4, 0:2].sum(), x[1:4, 1:3].sum()] ]) / 9 testing.assert_allclose(expect, y_data[k, c], **self.check_forward_options)
def __call__(self, x): """ Function that computes forward Parametors ---------------- x: Variable input image data. this shape is (N, C, H, W) """ h = F.leaky_relu(self.c0(x)) h = F.leaky_relu(self.bn1(self.c1(h))) h = F.leaky_relu(self.bn2(self.c2(h))) h = F.leaky_relu(self.bn3(self.c3(h))) # mimcing global max pooling with average_pooling_2d h = self.c4(h) logits = F.average_pooling_2d(h, ksize=(4, 4)) logits = F.squeeze(logits, axis=(1, 2, 3)) # scalarにするため.必要なし? return logits
def first_forward(self, x, num_lm): self.rnn_1(Variable( xp.zeros((num_lm, self.n_unit)).astype(xp.float32))) h2 = F.relu( self.l_norm_cc1( self.context_cnn_1(F.average_pooling_2d(x, 4, stride=4)))) h3 = F.relu( self.l_norm_cc2( self.context_cnn_2(F.max_pooling_2d(h2, 2, stride=2)))) h4 = F.relu( self.l_norm_cc3( self.context_cnn_3(F.max_pooling_2d(h3, 2, stride=2)))) h4r = F.relu(self.context_full(h4)) h5 = F.relu(self.rnn_2(h4r)) l = F.sigmoid(self.attention_loc(h5)) s = F.sigmoid(self.attention_scale(h5)) b = F.sigmoid(self.baseline(Variable(h5.data))) return l, s, b
def __call__(self, x): ha = F.average_pooling_2d(x, ksize=3, stride=1, pad=1) ha = self.conv_a(ha) hb = self.conv_b(x) hc = self.conv_c1(x) hc = self.conv_c2(hc) hc = self.conv_c3(hc) hd = self.conv_d1(x) hd = self.conv_d2(hd) hd = self.conv_d3(hd) hd = self.conv_d4(hd) hd = self.conv_d5(hd) h = F.concat((ha, hb, hc, hd), axis=1) # output dimensions: size=(17, 17), channels=base_filter_num*32 return h
def forward(self, x): h = self.conv_bn(x) h = self.conv_ds_2(h) h = self.conv_ds_3(h) h = self.conv_ds_4(h) h = self.conv_ds_5(h) h = self.conv_ds_6(h) h = self.conv_ds_7(h) h = self.conv_ds_8(h) h = self.conv_ds_9(h) h = self.conv_ds_10(h) h = self.conv_ds_11(h) h = self.conv_ds_12(h) h = self.conv_ds_13(h) h = self.conv_ds_14(h) h = F.average_pooling_2d(h, 7, stride=1) h = self.fc(h) #h = F.softmax(h) return h
def __call__(self, x): h = self.conv_bn(x) h = self.conv_ds_2(h) h = self.conv_ds_3(h) h = self.conv_ds_4(h) h = self.conv_ds_5(h) h = self.conv_ds_6(h) h = self.conv_ds_7(h) h = self.conv_ds_8(h) h = self.conv_ds_9(h) h = self.conv_ds_10(h) h = self.conv_ds_11(h) h = self.conv_ds_12(h) h = self.conv_ds_13(h) h = self.conv_ds_14(h) h = F.average_pooling_2d(h, 7, stride=1) # x = F.average(x, axis=(2, 3),keepdims=True) h = self.fc7(h) return h
def __call__(self, x): h = self.bn1(self.conv1(x)) h = F.max_pooling_2d(F.relu(h), 3, stride=2) h = self.res2(h) h = self.res3(h) h = self.res4(h) if hasattr(self, 'res5'): h = self.res5(h) if hasattr(self, 'res6'): h = self.res6(h) if hasattr(self, 'res7'): h = self.res7(h) if self.class_labels is not None: _, _, height, width = h.shape h = F.average_pooling_2d(h, (height, width), stride=1) if self.class_labels is not None: h = self.fc(h) return h
def __call__(self, x, t, train=True, finetune=False): h = x # First conv layer h = self[0](h) # Residual blocks for i in range(1, len(self) - 2): h = self[i](h, train, finetune) # BN, relu, pool, final layer h = self[-2](h) h = F.relu(h) h = F.average_pooling_2d(h, ksize=h.data.shape[2:]) h = self[-1](h) h = F.reshape(h, h.data.shape[:2]) return F.softmax_cross_entropy(h, t), F.accuracy(h, t)
def rasterize(faces, textures, image_size=256, anti_aliasing=True, near=0.1, far=100, eps=1e-3, background_color=(0, 0, 0)): if anti_aliasing: images = Rasterize(image_size * 2, near, far, eps, background_color)(faces, textures) images = images.transpose((0, 3, 1, 2)) images = cf.average_pooling_2d(images, 2, 2) else: images = Rasterize(image_size, near, far, eps, background_color)(faces, textures) images = images.transpose((0, 3, 1, 2)) images = images[:, :, ::-1, :] return images
def forward(self, x, t=None): h = F.max_pooling_2d(F.relu(self.mlpconv1(x)), 3, stride=2) h = F.max_pooling_2d(F.relu(self.mlpconv2(h)), 3, stride=2) h = F.max_pooling_2d(F.relu(self.mlpconv3(h)), 3, stride=2) h = self.mlpconv4(F.dropout(h)) h = F.reshape(F.average_pooling_2d(h, 6), (len(x), self.n_class)) self.pred = F.softmax(h) if t is None: assert not chainer.config.train return self.loss = F.softmax_cross_entropy(h, t) self.acc = F.accuracy(self.pred, t) chainer.report({'loss': self.loss, 'accuracy': self.acc}, self) return self.loss
def compute_policy(self, h): h = F.average_pooling_2d(h, 3) h = h.reshape((len(h), 1, self.L_stages+12)) h = self.f(self.dbn1(self.dc1(h))) h = self.f(self.dbn2(self.dc2(h))) h = self.f(self.dbn3(self.dc3(h))) h = self.f(self.dbn4(self.dc4(h))) h = self.f(self.dbn5(self.dc5(h))) h = self.dc6(h) probs = [] acts = [] for i in range(self.action_size): p = SoftmaxDistribution(h[:, i, :]) a = p.sample() probs.append(p) acts.append(a) return probs, acts
def __call__(self, x_high, x_low): x_high = self.conv_high(x_high) x_low = self.conv_low(x_low) w_high = F.average_pooling_2d(x_high, ksize=x_high.shape[2:]) w_high = self.conv_w_high(w_high) w_high = self.relu(w_high) w_high = self.sigmoid(w_high) w_low = x_low.mean(axis=1, keepdims=True) w_low = self.conv_w_low(w_low) w_low = self.sigmoid(w_low) x_high = self.up(x_high) x_high = x_high * w_low x_low = x_low * w_high out = x_high + x_low return out
def __call__(self, x): h = self.conv1(x) h = F.max_pooling_2d(h, 3, stride=2) h = self.conv1_reduce(h) h = self.conv2(h) h = F.max_pooling_2d(h, 3, stride=2) h = self.conv2_reduce(h) h = self.conv3(h) h = F.max_pooling_2d(h, 3, stride=2) h = self.conv3_reduce(h) h = self.conv4(h) h = F.average_pooling_2d(h, 3, stride=1) h = self.fc1(h) return h
def check_forward_consistency_regression(self, x_data, use_cudnn='always'): # Regression test to average_pooling_2d. if len(self.dims) != 2: return ksize = self.ksize stride = self.stride pad = self.pad with chainer.using_config('use_cudnn', use_cudnn): y_nd = functions.average_pooling_nd(x_data, ksize, stride=stride, pad=pad) y_2d = functions.average_pooling_2d(x_data, ksize, stride=stride, pad=pad) testing.assert_allclose(y_nd.data, y_2d.data)
def foward(self, x): out = self.model.conv1(x) out = F.elu(out) out = self.model.conv2(out) out = F.max_pooling_2d(out, 2) out = F.elu(out) out = self.model.conv3(out) out = F.elu(out) out = self.model.conv4(out) out = F.elu(out) out = F.average_pooling_2d(out, 6) out = F.dropout(out) out = self.model.linear1(out) out = F.elu(out) out = F.dropout(out) out = self.model.linear2(out) return out
def check_forward(self, inputs, backend_config): # TODO(niboshi): Support it if backend_config.use_chainerx and self.dtype == numpy.float16: raise unittest.SkipTest('ChainerX does not support float16') y_expect, = self.forward_cpu(inputs) inputs = backend_config.get_array(inputs) if not self.c_contiguous: with backend_config: inputs = _to_fcontiguous(inputs) with backend_config: x, = inputs y = functions.average_pooling_2d(x, 3, stride=2, pad=1) assert y.data.dtype == self.dtype y_data = cuda.to_cpu(y.data) assert self.output_shape == y_data.shape testing.assert_allclose(y_expect, y_data, **self.check_forward_options)
def __call__(self, x): xp = chainer.cuda.get_array_module(x.data) sh, sw = self.conv1.stride c_out, c_in, kh, kw = self.conv1.W.data.shape b, c, hh, ww = x.data.shape if sh == 1 and sw == 1: shape_out = (b, c_out, hh, ww) else: hh = (hh + 2 - kh) // sh + 1 ww = (ww + 2 - kw) // sw + 1 shape_out = (b, c_out, hh, ww) h = x if x.data.shape[2:] != shape_out[2:]: x = F.average_pooling_2d(x, 1, 2) if x.data.shape[1] != c_out: n, c, hh, ww = x.data.shape pad_c = c_out - c p = xp.zeros((n, pad_c, hh, ww), dtype=xp.float32) p = chainer.Variable(p) x = F.concat((x, p), axis=1) h = self.bn1(h) h = self.conv1(h) h = self.bn2(h) if self.activation is not None: h = self.activation(h) h = self.conv2(h) h = self.bn3(h) # 再掲:skip==True -> shakeする if not chainer.config.train: skip = False scale = (1 - self.skip_ratio) + self.expect_alpha * self.skip_ratio return h * scale + x else: skip = np.random.rand() < self.skip_ratio if skip: return shake_noise_multiplier(h, self.alpha, self.beta) + x else: return h + x
def __call__(self, x, t): h = F.max_pooling_2d(F.leaky_relu(self.conv1(x)), 2, 2) h = F.max_pooling_2d(F.leaky_relu(self.conv2(h)), 2, 2) h = F.leaky_relu(self.conv3(h)) h = F.leaky_relu(self.conv4(h)) h = F.leaky_relu(self.conv5(h)) h = F.max_pooling_2d(F.leaky_relu(self.conv6(h)), 2, 2) h = F.leaky_relu(self.conv7(h)) h = F.leaky_relu(self.conv8(h)) h = F.leaky_relu(self.conv9(h)) h = F.leaky_relu(self.conv10(h)) h = F.leaky_relu(self.conv11(h)) h = F.leaky_relu(self.conv12(h)) h = F.leaky_relu(self.conv13(h)) h = F.leaky_relu(self.conv14(h)) h = F.leaky_relu(self.conv15(h)) h = F.max_pooling_2d(F.leaky_relu(self.conv16(h)), 2, 2) h = F.leaky_relu(self.conv17(h)) h = F.leaky_relu(self.conv18(h)) h = F.leaky_relu(self.conv19(h)) if self.pre_train: h = F.average_pooling_2d(h, 2, 2) h = self.fc_pre(h) self.loss = F.softmax_cross_entropy(h, t) self.accuracy = F.accuracy(h, t) return self.loss else: h = F.leaky_relu(self.conv20(h)) h = F.leaky_relu(self.conv21(h)) h = F.leaky_relu(self.conv22(h)) h = F.leaky_relu(self.conv23(h)) h = F.leaky_relu(self.conv24(h)) self.h = h h = F.leaky_relu(self.fc25(h)) h = F.relu(self.fc26(h)) #self.loss = self.loss_func(h, t) #self.accuracy = self.loss self.img = (x, h)
def __init__(self, n_layers, n_out, stride=(1, 2, 2), layer_names=None): super().__init__() kwargs = {'initialW': normal.HeNormal(scale=1.0)} if (n_layers - 2) % 3 == 0: block = [(n_layers - 2) // 9] * 3 else: raise ValueError( 'The n_layers argument should be mod({} - 2, 3) == 0, \ but {} was given.'.format(n_layers, n_layers)) with self.init_scope(): self.conv1 = L.Convolution2D(3, 16, 3, 1, 1, **kwargs) self.res2 = PreBuildingBlock(block[0], 16, 16, 64, stride[0], **kwargs) self.res3 = PreBuildingBlock(block[1], 64, 32, 128, stride[1], **kwargs) self.res4 = PreBuildingBlock(block[2], 128, 64, 256, stride[2], **kwargs) self.bn4 = L.BatchNormalization(256) self.fc5 = L.Linear(None, n_out) self.functions = collections.OrderedDict([ ('conv1', [self.conv1]), ('res2', [self.res2]), ('res3', [self.res3]), ('res4', [self.res4]), ('pool4', [self.bn4, F.relu, lambda x: F.average_pooling_2d(x, 8, stride=1)]), ('fc5', [self.fc5]), ]) if layer_names is None: layer_names = list(self.functions.keys())[-1] if (not isinstance(layer_names, str) and all([isinstance(name, str) for name in layer_names])): return_tuple = True else: return_tuple = False layer_names = [layer_names] self._return_tuple = return_tuple self._layer_names = layer_names
def __call__(self, images, localizations): points = F.spatial_transformer_grid(localizations, self.target_shape) rois = F.spatial_transformer_sampler(images, points) h = F.relu(self.bn0(self.conv0(rois))) if self.use_dropout: h = F.dropout(h, ratio=self.dropout_ratio) h = F.relu(self.bn1(self.conv1(h))) if self.use_dropout: h = F.dropout(h, ratio=self.dropout_ratio) h = self.rs1(h) h = self.rs2(h) h = F.max_pooling_2d(h, 2, stride=2) h = self.rs3(h) self.vis_anchor = h h = F.average_pooling_2d(h, 5, stride=1) if self.uses_original_data: # merge data of all 4 individual images in channel dimension batch_size, num_channels, height, width = h.shape h = F.reshape(h, (batch_size // 4, 4 * num_channels, height, width)) h = F.relu(self.fc1(h)) # for each timestep of the localization net do the 'classification' h = F.reshape(h, (self.num_timesteps, -1, self.fc1.out_size)) overall_predictions = [] for timestep in F.separate(h, axis=0): # go 2x num_labels plus 1 timesteps because of ctc loss lstm_predictions = [] self.lstm.reset_state() for _ in range(self.num_labels * 2 + 1): lstm_prediction = self.lstm(timestep) classified = self.classifier(lstm_prediction) lstm_predictions.append(classified) overall_predictions.append(lstm_predictions) return overall_predictions, rois, points
def check_forward_consistency_regression(self, x_data, use_cudnn=True): # Regression test to average_pooling_2d. if len(self.dims) != 2: return ksize = self.ksize stride = self.stride pad = self.pad y_nd = functions.average_pooling_nd(x_data, ksize, stride=stride, pad=pad, use_cudnn=use_cudnn) y_2d = functions.average_pooling_2d(x_data, ksize, stride=stride, pad=pad, use_cudnn=use_cudnn) testing.assert_allclose(y_nd.data, y_2d.data)
def predict(self, x_data): x = chainer.Variable(x_data, volatile=True) h = F.relu(self.conv1(x)) h = F.relu(self.conv1a(h)) h = F.relu(self.conv1b(h)) h = F.max_pooling_2d(h, 3, stride=2) h = F.relu(self.conv2(h)) h = F.relu(self.conv2a(h)) h = F.relu(self.conv2b(h)) h = F.max_pooling_2d(h, 3, stride=2) h = F.relu(self.conv3(h)) h = F.relu(self.conv3a(h)) h = F.relu(self.conv3b(h)) h = F.max_pooling_2d(h, 3, stride=2) h = F.dropout(h, train=False) h = F.relu(self.conv4(h)) h = F.relu(self.conv4a(h)) h = F.relu(self.conv4b(h)) h = F.reshape(F.average_pooling_2d(h, 6), (x_data.shape[0], 1000)) return F.softmax(h)
def __call__(self, x): h = chainer.Variable(x) h = self.conv1(h) self.conv1.out_size = h.shape[-2:] h = self.block3(h) h = self.trans_conv1(h) self.trans_conv1.out_size = h.shape[-2:] h = self.block4(h) h = self.trans_conv2(h) self.trans_conv2.out_size = h.shape[-2:] h = self.block5(h) h = F.relu(self.bn5(h)) h = F.average_pooling_2d(h, h.shape[2:]) h = self.fc7(h) return h
def __call__(self, x, t=None): h = F.relu(self.bn1(self.conv1(x))) h = self.conv2(F.relu(self.bn2(h))) h = F.max_pooling_2d(h, 2) h = F.dropout(h, 0.25) h = self.conv3(F.relu(self.bn3(h))) h = F.max_pooling_2d(h, 2) h = F.dropout(h, 0.25) h = self.conv4(F.relu(self.bn4(h))) h = F.max_pooling_2d(h, 2) h = F.dropout(h, 0.25) h = self.conv5(F.relu(self.bn5(h))) h = F.average_pooling_2d(h, 4) h = self.fc(h) if t is not None: self.loss = F.softmax_cross_entropy(h, t) self.accuracy = F.accuracy(h, t) return self.loss else: self.pred = F.softmax(h) return self.pred
def __call__(self, x): h = self.conv1(self.bn1(x)) h = self.conv2(F.relu(self.bn2(h))) if self.stride == 2: h = self.conv3(pgp(F.relu(self.bn3(h)), 2)) else: h = self.conv3(F.relu(self.bn3(h))) h = self.bn4(h) batch, h_channel, h_height, h_width = h.shape del h_channel with chainer.cuda.get_device_from_array(x.data): zero = chainer.Variable( self.xp.zeros((batch, self.zero_ch, h_height, h_width), dtype=self.xp.float32)) if self.stride == 2: h0 = F.concat( (pgp(F.average_pooling_2d(x, 2, 1, 1)[:, :, 1:, 1:], 2), zero)) return h + h0 else: return h + F.concat((x, zero))
def forward(self, x, t): h = self.bn1(self.conv1(x)) h = F.max_pooling_2d(F.relu(h), 3, stride=2) h = self.res2(h) h = self.res3(h) h = self.res4(h) h = self.res5(h) h = F.average_pooling_2d(h, 7, stride=1) h = self.fc(h) #loss = F.softmax_cross_entropy(h, t) loss = self.softmax_cross_entropy(h, t) if self.compute_accuracy: chainer.report( { 'loss': loss, 'accuracy': F.accuracy(h, np.argmax(t, axis=1)) }, self) else: chainer.report({'loss': loss}, self) return loss
def __call__(self, x): """Feed-Forward calculation.""" bs = len(x) h = F.relu(self.bn1(self.conv1(x))) h = self.block1(h) h = self.trans1(h) h = self.block2(h) h = self.trans2(h) h = self.block3(h) h = self.trans3(h) h = self.bn4(self.block4(h)) h = F.relu(h) h = F.average_pooling_2d(h, h.shape[2]) h = F.reshape(h, (bs, -1)) return self.prob(h)
def __call__(self, x): # => 3 × 256 h = self.conv1(x) # => 64 × 128 h = F.max_pooling_2d(h, 3, 2) # => 64 × 64 n = 1 / 2 / 8 h = self.block1_1(h, 1 * n) # => 64 × 64 h = self.block1_2(h, 2 * n) # => 64 × 64 h = self.block2_1(h, 3 * n) # => 128 × 32 h = self.block2_2(h, 4 * n) # => 128 × 32 h = self.block3_1(h, 5 * n) # => 256 × 16 h = self.block3_2(h, 6 * n) # => 256 × 16 h = self.block4_1(h, 7 * n) # => 512 × 8 h = self.block4_2(h, 8 * n) # => 512 × 8 h = F.average_pooling_2d(h, h.shape[2]) # global average pooling # h = self.l1(h) return F.tanh(self.l2(h))