我们从Python开源项目中，提取了以下49个代码示例，用于说明如何使用chainer.functions.softmax_cross_entropy()。
def __call__(self, x, t, train=True, finetune=False): h = x h = F.dropout(h, ratio=0.2, train=train) h = self.l1(h, train, finetune) h = self.l2(h, train, finetune) h = self.l3(h, train, finetune) h = F.dropout(h, ratio=0.5, train=train) h = self.l4(h, train, finetune) h = self.l5(h, train, finetune) h = self.l6(h, train, finetune) h = F.dropout(h, ratio=0.5, train=train) h = self.l7(h, train, finetune) h = self.l8(h, train, finetune) h = self.l9(h, train, finetune) h = F.sum(h, axis=-1) h = F.sum(h, axis=-1) h = F.sum(h, axis=-1) h /= 8 * 8 * 8 return F.softmax_cross_entropy(h, t), F.accuracy(h, t)
def __call__(self, x, t, train=True, finetune=False): h = x h = F.dropout(h, ratio=0.2, train=train) h = self.l1(h, train, finetune) h = self.l2(h, train, finetune) h = self.l3(h, train, finetune) h = F.dropout(h, ratio=0.5, train=train) h = self.l4(h, train, finetune) h = self.l5(h, train, finetune) h = self.l6(h, train, finetune) h = F.dropout(h, ratio=0.5, train=train) h = self.l7(h, train, finetune) h = self.l8(h, train, finetune) h = self.l9(h, train, finetune) h = F.sum(h, axis=-1) h = F.sum(h, axis=-1) h = F.sum(h, axis=-1) h /= 8 * 8 * 4 return F.softmax_cross_entropy(h, t), F.accuracy(h, t)
def __call__(self, x, t, train=True, finetune=False): # First conv layer h = self[0](x) # 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) n, nc, ns, nx, ny = h.data.shape h = F.reshape(h, (n, nc * ns, nx, ny)) 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 __call__(self, x, t, train=True, finetune=False): h = x h = F.dropout(h, ratio=0.2, train=train) h = self.l1(h, train, finetune) h = self.l2(h, train, finetune) h = self.l3(h, train, finetune) h = F.dropout(h, ratio=0.5, train=train) h = self.l4(h, train, finetune) h = self.l5(h, train, finetune) h = self.l6(h, train, finetune) h = F.dropout(h, ratio=0.5, train=train) h = self.l7(h, train, finetune) h = self.l8(h, train, finetune) h = self.l9(h, train, finetune) h = F.sum(h, axis=-1) h = F.sum(h, axis=-1) h /= 8 * 8 return F.softmax_cross_entropy(h, t), F.accuracy(h, t)
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 __call__(self, x, t, train=True, finetune=False): h = self.l1(x, train, finetune) h = F.dropout(h, self.dr, train) h = self.l2(h, train, finetune) h = F.max_pooling_2d(h, ksize=2, stride=2, pad=0, cover_all=True, use_cudnn=True) h = self.l3(h, train, finetune) h = F.dropout(h, self.dr, train) h = self.l4(h, train, finetune) h = F.dropout(h, self.dr, train) h = self.l5(h, train, finetune) h = F.dropout(h, self.dr, train) h = self.l6(h, train, finetune) h = F.dropout(h, self.dr, train) h = self.top(h) h = F.max(h, axis=-1, keepdims=False) h = F.max(h, axis=-1, keepdims=False) return F.softmax_cross_entropy(h, t), F.accuracy(h, t)
def compute_loss(self, y, t): arc_logits, label_logits = y true_arcs, true_labels = t.T b, l1, l2 = arc_logits.shape true_arcs = F.pad_sequence(true_arcs, padding=-1) if not self.model._cpu: true_arcs.to_gpu() arc_loss = F.softmax_cross_entropy( F.reshape(arc_logits, (b * l1, l2)), F.reshape(true_arcs, (b * l1,)), ignore_label=-1) b, l1, d = label_logits.shape true_labels = F.pad_sequence(true_labels, padding=-1) if not self.model._cpu: true_labels.to_gpu() label_loss = F.softmax_cross_entropy( F.reshape(label_logits, (b * l1, d)), F.reshape(true_labels, (b * l1,)), ignore_label=-1) loss = arc_loss + label_loss return loss
def __call__(self, xs): """ xs [(w,s,p,y), ..., ] w: word, s: suffix, p: prefix, y: label """ batchsize = len(xs) ws, ss, ps, ts = zip(*xs) ys = self.forward(ws, ss, ps) loss = reduce(lambda x, y: x + y, [F.softmax_cross_entropy(y, t) for y, t in zip(ys, ts)]) acc = reduce(lambda x, y: x + y, [F.accuracy(y, t, ignore_label=IGNORE) for y, t in zip(ys, ts)]) acc /= batchsize chainer.report({ "loss": loss, "accuracy": acc }, self) return loss
def __call__(self, xs): batchsize = len(xs) ws, cs, ls, cat_ts, dep_ts = zip(*xs) cat_ys, dep_ys = self.forward(ws, cs, ls) cat_loss = reduce(lambda x, y: x + y, [F.softmax_cross_entropy(y, t) for y, t in zip(cat_ys, cat_ts)]) cat_acc = reduce(lambda x, y: x + y, [F.accuracy(y, t, ignore_label=IGNORE) for y, t in zip(cat_ys, cat_ts)]) dep_loss = reduce(lambda x, y: x + y, [F.softmax_cross_entropy(y, t) for y, t in zip(dep_ys, dep_ts)]) dep_acc = reduce(lambda x, y: x + y, [F.accuracy(y, t, ignore_label=IGNORE) for y, t in zip(dep_ys, dep_ts)]) cat_acc /= batchsize dep_acc /= batchsize chainer.report({ "tagging_loss": cat_loss, "tagging_accuracy": cat_acc, "parsing_loss": dep_loss, "parsing_accuracy": dep_acc }, self) return cat_loss + dep_loss
def __call__(self, xs, ts): """ Inputs: xs (tuple(Variable, Variable, Variable)): each of Variables is of dim (batchsize,) ts Variable: (batchsize) """ words, suffixes, caps = xs[:,:7], xs[:, 7:14], xs[:, 14:] h_w = self.emb_word(words) h_c = self.emb_caps(caps) h_s = self.emb_suffix(suffixes) h = F.concat([h_w, h_c, h_s], 2) batchsize, ntokens, hidden = h.data.shape h = F.reshape(h, (batchsize, ntokens * hidden)) ys = self.linear(h) loss = F.softmax_cross_entropy(ys, ts) acc = F.accuracy(ys, ts) chainer.report({ "loss": loss, "accuracy": acc }, self) return loss
def __call__(self, ws, ss, ps, ts): """ xs [(w,s,p,y), ..., ] w: word, s: suffix, p: prefix, y: label """ batchsize, length = ts.shape ys = self.forward(ws, ss, ps)[1:-1] ts = [F.squeeze(x, 0) for x in F.split_axis(F.transpose(ts), length, 0)] loss = reduce(lambda x, y: x + y, [F.softmax_cross_entropy(y, t) for y, t in zip(ys, ts)]) acc = reduce(lambda x, y: x + y, [F.accuracy(y, t, ignore_label=IGNORE) for y, t in zip(ys, ts)]) acc /= length chainer.report({ "loss": loss, "accuracy": acc }, self) return loss
def __call__(self, x, t): self.clear() h = F.max_pooling_2d(F.relu( F.local_response_normalization(self.conv1(x))), 3, stride=2) h = F.max_pooling_2d(F.relu( F.local_response_normalization(self.conv2(h))), 3, stride=2) h = F.relu(self.conv3(h)) h = F.relu(self.conv4(h)) h = F.max_pooling_2d(F.relu(self.conv5(h)), 3, stride=2) h = F.dropout(F.relu(self.fc6(h)), train=self.train) h = F.dropout(F.relu(self.fc7(h)), train=self.train) h = self.fc8(h) self.loss = F.softmax_cross_entropy(h, t) self.accuracy = F.accuracy(h, t) return self.loss
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.bn2(self.conv2(h), test=not self.train) h = F.max_pooling_2d(F.relu(h), 3, stride=2) h = F.relu(self.conv3(h)) h = F.relu(self.conv4(h)) h = F.max_pooling_2d(F.relu(self.conv5(h)), 3, stride=2) h = F.dropout(F.relu(self.fc6(h)), train=self.train) h = F.dropout(F.relu(self.fc7(h)), train=self.train) h = self.fc8(h) self.loss = F.softmax_cross_entropy(h, t) self.accuracy = F.accuracy(h, t) return self.loss
def decode(self, sentences): # sentences = Variable(np.array([sentences], dtype=np.int32), volatile=False) loss = Variable(np.zeros((), dtype=np.float32)) n_words = len(sentences)-1 for word, t in zip(sentences, sentences[1:]): # print('??:{}, ??:{}'.format(word,t)) word = Variable(np.array([[word]], dtype=np.int32)) t = Variable(np.array([t], dtype=np.int32)) decode0 = self.output_embed(word) decode1 = self.decode1(decode0) decode2 = self.decode2(decode1) z = self.output(decode2) loss += F.softmax_cross_entropy(z, t) return loss, n_words
def step(self,perm,batch_index, mode, epoch): if mode =='train': data, label=self.read_batch(perm,batch_index,self.train_data) else: data, label=self.read_batch(perm,batch_index,self.test_data) data = Variable(cuda.to_gpu(data)) yl = self.network(data) label=Variable(cuda.to_gpu(label)) L_network = F.softmax_cross_entropy(yl, label) A_network = F.accuracy(yl, label) if mode=='train': self.o_network.zero_grads() L_network.backward() self.o_network.update() return {"prediction": yl.data.get(), "current_loss": L_network.data.get(), "current_accuracy": A_network.data.get(), }
def loss(model, xs, ts, uss=None): model.reset_state() tags = model([Variable( np.array([x], dtype=np.int32) ) for x in xs]) zss = [] d = Variable(np.array(0, dtype=np.float32)) for t, (y, zs) in zip(ts, tags): d += cf.sigmoid_cross_entropy( y, Variable(np.array([[t]], dtype=np.int32)) ) if t: zss.append(zs) if uss: assert len(uss) == len(zss) for us, zs in zip(uss, zss): for u, z in zip(us, zs): d += cf.softmax_cross_entropy( z, Variable(np.array([u], dtype=np.int32)) ) return d
def __call__(self, x, t): """Computes the loss value for an image and label pair. Args: x (~chainer.Variable): A variable with a batch of images. t (~chainer.Variable): A variable with the ground truth image-wise label. Returns: ~chainer.Variable: Loss value. """ self.y = self.predictor(x) self.loss = F.softmax_cross_entropy( self.y, t, class_weight=self.class_weight, ignore_label=self.ignore_label) reporter.report({'loss': self.loss}, self) return self.loss
def __call__(self, xs: List[Variable], ys: List[Variable]) -> Variable: batch_size = len(xs) xs = [x[::-1] for x in xs] eos = np.array([EOS], dtype=np.int32) ys_in = [F.concat((eos, y), axis=0) for y in ys] ys_out = [F.concat((y, eos), axis=0) for y in ys] embedded_xs = [self._embed_input(x) for x in xs] embedded_ys = [self._embed_output(y) for y in ys_in] hidden_states, cell_states, attentions = self._encoder(None, None, embedded_xs) _, _, embedded_outputs = self._decoder(hidden_states, cell_states, embedded_ys) loss = 0 for embedded_output, y, attention in zip(embedded_outputs, ys_out, attentions): if self._use_attention: output = self._calculate_attention_layer_output(embedded_output, attention) else: output = self._extract_output(embedded_output) loss += F.softmax_cross_entropy(output, y) loss /= batch_size return loss
def _get_loss_gen(self): batchsize = self.y_fake.data.shape[0] L_mce = F.softmax_cross_entropy(self.pred_label_map, self.ground_truth, normalize=False) L_bce = F.softmax_cross_entropy(self.y_fake, Variable(self.xp.ones(batchsize, dtype=self.xp.int32), volatile=not self.gen.train)) loss = L_mce + self.L_bce_weight * L_bce # log report label_true = chainer.cuda.to_cpu(self.ground_truth.data) label_pred = chainer.cuda.to_cpu(self.pred_label_map.data).argmax(axis=1) logs = [] for i in six.moves.range(batchsize): acc, acc_cls, iu, fwavacc = utils.label_accuracy_score( label_true[i], label_pred[i], self.n_class) logs.append((acc, acc_cls, iu, fwavacc)) log = np.array(logs).mean(axis=0) values = { 'loss': loss, 'accuracy': log[0], 'accuracy_cls': log[1], 'iu': log[2], 'fwavacc': log[3], } chainer.report(values, self.gen) return loss
def calc_loss(self): batchsize = self.ground_truth.shape[0] self.loss = F.softmax_cross_entropy(self.pred_label_map, self.ground_truth, normalize=False) # log report label_true = chainer.cuda.to_cpu(self.ground_truth.data) label_pred = chainer.cuda.to_cpu(self.pred_label_map.data).argmax(axis=1) logs = [] for i in six.moves.range(batchsize): acc, acc_cls, iu, fwavacc = utils.label_accuracy_score( label_true[i], label_pred[i], self.n_class) logs.append((acc, acc_cls, iu, fwavacc)) log = np.array(logs).mean(axis=0) values = { 'loss': self.loss, 'accuracy': log[0], 'accuracy_cls': log[1], 'iu': log[2], 'fwavacc': log[3], } chainer.report(values, self.model)
def cross_entropy(self, raw_network_output, target_signal_data): if isinstance(target_signal_data, Variable): raise Exception("target_signal_data cannot be Variable") raw_network_output = self.to_variable(raw_network_output) target_width = target_signal_data.shape[1] batchsize = raw_network_output.data.shape[0] if raw_network_output.data.shape[3] != target_width: raise Exception("raw_network_output.width != target.width") # (batchsize * time_step,) <- (batchsize, time_step) target_signal_data = target_signal_data.reshape((-1,)) target_signal = self.to_variable(target_signal_data) # (batchsize * time_step, channels) <- (batchsize, channels, 1, time_step) raw_network_output = F.transpose(raw_network_output, (0, 3, 2, 1)) raw_network_output = F.reshape(raw_network_output, (batchsize * target_width, -1)) loss = F.softmax_cross_entropy(raw_network_output, target_signal) return loss
def forward(net, image_batch, sentence_batch, train=True): images = xp.asarray(image_batch) n, sentence_length = sentence_batch.shape net.initialize(images) loss = 0 acc = 0 size = 0 for i in range(sentence_length - 1): target = xp.where(xp.asarray(sentence_batch[:, i]) != eos, 1, 0).astype(np.float32) if (target == 0).all(): break with chainer.using_config('train', train): with chainer.using_config('enable_backprop', train): x = xp.asarray(sentence_batch[:, i]) t = xp.asarray(sentence_batch[:, i + 1]) y = net(x) y_max_index = xp.argmax(y.data, axis=1) mask = target.reshape((len(target), 1)).repeat(y.data.shape[1], axis=1) y = y * mask loss += F.softmax_cross_entropy(y, t) acc += xp.sum((y_max_index == t) * target) size += xp.sum(target) return loss / size, float(acc) / size, float(size)
def __call__(self, *args): x = args[:-1] t = args[-1] self.y = None self.loss = None self.accuracy = None self.y = self.predictor(*x) self.loss = F.softmax_cross_entropy(self.y, t) if self.stored_variable_list is not None and \ self.fisher_list is not None: # i.e. Stored for i in range(len(self.variable_list)): self.loss += self.lam/2. * F.sum( self.fisher_list[i] * F.square(self.variable_list[i][1] - self.stored_variable_list[i])) reporter.report({'loss': self.loss}, self) if self.compute_accuracy: self.accuracy = F.accuracy(self.y, t) reporter.report({'accuracy': self.accuracy}, self) return self.loss
def loss(self,es,x,y,t): """ Forward propagation and loss calculation Args: es (pair of ~chainer.Variable): encoder state x (list of ~chainer.Variable): list of input sequences y (list of ~chainer.Variable): list of output sequences t (list of ~chainer.Variable): list of target sequences if t is None, it returns only states Return: es (pair of ~chainer.Variable(s)): encoder state ds (pair of ~chainer.Variable(s)): decoder state loss (~chainer.Variable) : cross-entropy loss """ es,ey = self.encoder(es,x) ds,dy = self.decoder(es,y) if t is not None: loss = F.softmax_cross_entropy(dy,t) # avoid NaN gradients (See: https://github.com/pfnet/chainer/issues/2505) if chainer.config.train: loss += F.sum(F.concat(ey, axis=0)) * 0 return es, ds, loss else: # if target is None, it only returns states return es, ds
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_image, t_image, x_action, t_action): self.y_image, self.y_action = self.predictor(x_image, x_action) predicted_action = self.action_meaning( F.argmax(self.y_action, axis=1).data[0]) real_action = self.action_meaning(t_action) if predicted_action != real_action: print("Predicted action:", predicted_action, "it was actually", real_action) image_loss = F.mean_squared_error(self.y_image, t_image) self.error_mask = normalize_2d(F.squared_error(self.y_image, t_image)) action_loss = F.softmax_cross_entropy( self.y_action, F.expand_dims(np.array(t_action, dtype=np.int32), axis=0), ) print('Image loss', image_loss.data, ', Action loss:', action_loss.data) return self.weight * image_loss + (1.0 - self.weight) * action_loss
def encode(self, x_input, x_query, answer): m = self.encode_input(x_input) u = self.encode_query(x_query) # print "m.data.shape", m.data.shape # print "u.data.shape", u.data.shape mu = functions.matmul(m, u, transb=True) # print "mu.data.shape", mu.data.shape # print "mu.data", mu.data p = functions.softmax(mu) c = self.encode_output(x_input) # print "p.data.shape:", p.data.shape # print "c.data.shape:", c.data.shape # print "functions.swapaxes(c ,2, 1):", functions.swapaxes(c ,2, 1).data.shape o = functions.matmul(functions.swapaxes(c ,1, 0), p) # (2, 50, 1) o = functions.swapaxes(o ,1, 0) # (2, 50) # print "u.data.shape:", u.data.shape # print "o.data.shape:", o.data.shape # print "u.data.shape:", u.data # print "o.data.shape:", o.data # print (u+o).data.shape predict = self.W(u + o) # print predict.data.shape loss = functions.softmax_cross_entropy(predict, answer) return loss
def __call__(self, x, t, predict=False): h = self.bn1(self.conv1(x), test=not self.train) h = F.max_pooling_2d(F.relu(h), 2, stride=2) h = self.bn2(self.conv2(h), test=not self.train) h = F.max_pooling_2d(F.relu(h), 2, stride=2) h = F.dropout(F.relu(self.conv3(h)), ratio=0.6, train=self.train) h = F.max_pooling_2d(F.relu(self.conv4(h)), 2, stride=2) h = F.average_pooling_2d(F.relu(self.conv5(h)), 3, stride=1) h = F.dropout(F.relu(self.fc6(h)), ratio=0.6, train=self.train) h = self.fc7(h) self.loss = F.softmax_cross_entropy(h, t) self.accuracy = F.accuracy(h, t) if predict: return h else: return self.loss
def __call__(self, x, t): # To solve the classification problem with "softmax", use "softmax_cross_entropy". h = self.fwd(x) loss = F.softmax_cross_entropy (h, t) chainer.report({'loss': loss, 'accuracy': F.accuracy(h, t)}, self) return loss
def __call__(self, x, t): h = F.relu(self.l1(x)) h = self.l2(h) self.loss = F.softmax_cross_entropy(h, t) self.accuracy = F.accuracy(h, t) return self.loss
def __call__(self, x, t=None): h = x h = F.relu(self.conv1_1(h)) h = F.relu(self.conv1_2(h)) h = F.max_pooling_2d(h, 2, stride=2) h = F.relu(self.conv2_1(h)) h = F.relu(self.conv2_2(h)) h = F.max_pooling_2d(h, 2, stride=2) h = F.relu(self.conv3_1(h)) h = F.relu(self.conv3_2(h)) h = F.relu(self.conv3_3(h)) h = F.max_pooling_2d(h, 2, stride=2) h = F.relu(self.conv4_1(h)) h = F.relu(self.conv4_2(h)) h = F.relu(self.conv4_3(h)) h = F.max_pooling_2d(h, 2, stride=2) h = F.relu(self.conv5_1(h)) h = F.relu(self.conv5_2(h)) h = F.relu(self.conv5_3(h)) h = F.max_pooling_2d(h, 2, stride=2) h = F.dropout(F.relu(self.fc6(h)), ratio=.5) h = F.dropout(F.relu(self.fc7(h)), ratio=.5) h = self.fc8(h) fc8 = h self.score = fc8 if t is None: assert not chainer.config.train return self.loss = F.softmax_cross_entropy(fc8, t) self.accuracy = F.accuracy(self.score, t) return self.loss
def decode(self,t_vec,t_pred,wei_arr=None): ys_d = self.dec(t_vec) ys_w = self.h2w(F.concat(ys_d, axis=0)) t_all = [] for t_each in t_pred: t_all += t_each.tolist() t_all = xp.array(t_all, dtype=xp.int32) if wei_arr is None: loss = F.softmax_cross_entropy(ys_w, t_all) # /len(t_all) else: sec_arr = np.array([ys_d_e.data.shape[0] for ys_d_e in ys_d[:-1]]) sec_arr = np.cumsum(sec_arr) loss = weighted_cross_entropy(ys_w,t_all,wei_arr,sec_arr) # print("t:{}".format([self.vocab.itos(tp_e) for tp_e in t_pred[0].tolist()])) # print("y:{}\n".format([self.vocab.itos(int(ys_w.data[ri].argmax())) for ri in range(len(t_pred[0]))])) return loss
def lossClassifier(self,lossFun="softmaxcrossentropy",*args): if lossFun=="softmaxcrossentropy": F.softmax_cross_entropy()
def __call__(self, x, t, train=True, finetune=False): h = self.l1(x, train, finetune) # h = F.dropout(h, self.dr, train) h = F.max(h, axis=-3, keepdims=False) h = self.l2(h, train, finetune) h = F.max(h, axis=-3, keepdims=False) h = F.max_pooling_2d(h, ksize=2, stride=2, pad=0) h = self.l3(h, train, finetune) h = F.max(h, axis=-3, keepdims=False) # h = F.dropout(h, self.dr, train) h = self.l4(h, train, finetune) h = F.max(h, axis=-3, keepdims=False) # h = F.dropout(h, self.dr, train) h = self.l5(h, train, finetune) h = F.max(h, axis=-3, keepdims=False) # h = F.dropout(h, self.dr, train) h = self.l6(h, train, finetune) h = F.max(h, axis=-3, keepdims=False) h = self.top(h) h = F.max(h, axis=-3, keepdims=False) h = F.max(h, axis=-1, keepdims=False) h = F.max(h, axis=-1, keepdims=False) return F.softmax_cross_entropy(h, t), F.accuracy(h, t)
def calc_loss(self, y, t): loss = F.softmax_cross_entropy(y, t) return loss
def calc_loss(y, t): loss = F.softmax_cross_entropy(y, t) return loss
def __call__(self, x, t): self.y = self.predictor(x, self.train_depth) if hasattr(self, 'class_weight'): if isinstance(x.data, cuda.cupy.ndarray) \ and not isinstance(self.class_weight, cuda.cupy.ndarray): self.class_weight = cuda.to_gpu( self.class_weight, device=x.data.device) self.loss = softmax_cross_entropy( self.y, t, class_weight=self.class_weight) else: self.loss = F.softmax_cross_entropy(self.y, t) reporter.report({'loss': self.loss}, self) return self.loss
def __call__(self, xs): """ xs [(w,s,p,y), ..., ] w: word, c: char, l: length, y: label """ batchsize = len(xs) ws, ss, ps, cat_ts, dep_ts = zip(*xs) cat_ys, dep_ys = self.forward(ws, ss, ps) cat_loss = reduce(lambda x, y: x + y, [F.softmax_cross_entropy(y, t) for y, t in zip(cat_ys, cat_ts)]) cat_acc = reduce(lambda x, y: x + y, [F.accuracy(y, t, ignore_label=IGNORE) for y, t in zip(cat_ys, cat_ts)]) dep_loss = reduce(lambda x, y: x + y, [F.softmax_cross_entropy(y, t) for y, t in zip(dep_ys, dep_ts)]) dep_acc = reduce(lambda x, y: x + y, [F.accuracy(y, t, ignore_label=IGNORE) for y, t in zip(dep_ys, dep_ts)]) cat_acc /= batchsize dep_acc /= batchsize chainer.report({ "tagging_loss": cat_loss, "tagging_accuracy": cat_acc, "parsing_loss": dep_loss, "parsing_accuracy": dep_acc }, self) return cat_loss + dep_loss
def __call__(self, xs): """ xs [(w,s,p,y), ..., ] w: word, c: char, l: length, y: label """ batchsize = len(xs) ws, cs, ls, cat_ts, dep_ts = zip(*xs) cat_ys, dep_ys = self.forward(ws, cs, ls, dep_ts if self.train else None) cat_loss = reduce(lambda x, y: x + y, [F.softmax_cross_entropy(y, t) for y, t in zip(cat_ys, cat_ts)]) cat_acc = reduce(lambda x, y: x + y, [F.accuracy(y, t, ignore_label=IGNORE) for y, t in zip(cat_ys, cat_ts)]) dep_loss = reduce(lambda x, y: x + y, [F.softmax_cross_entropy(y, t) for y, t in zip(dep_ys, dep_ts)]) dep_acc = reduce(lambda x, y: x + y, [F.accuracy(y, t, ignore_label=IGNORE) for y, t in zip(dep_ys, dep_ts)]) cat_acc /= batchsize dep_acc /= batchsize chainer.report({ "tagging_loss": cat_loss, "tagging_accuracy": cat_acc, "parsing_loss": dep_loss, "parsing_accuracy": dep_acc }, self) return cat_loss + dep_loss
def __call__(self, xs): """ xs [(w,s,p,y), ..., ] w: word, c: char, l: length, y: label """ batchsize = len(xs) if len(xs[0]) == 6: ws, ss, ps, ls, cat_ts, dep_ts = zip(*xs) xp = chainer.cuda.get_array_module(ws[0]) weights = [xp.array(1, 'f') for _ in xs] else: ws, ss, ps, ls, cat_ts, dep_ts, weights = zip(*xs) cat_ys, dep_ys = self.forward(ws, ss, ps, ls, dep_ts if self.train else None) cat_loss = reduce(lambda x, y: x + y, [we * F.softmax_cross_entropy(y, t) \ for y, t, we in zip(cat_ys, cat_ts, weights)]) cat_acc = reduce(lambda x, y: x + y, [F.accuracy(y, t, ignore_label=IGNORE) for y, t in zip(cat_ys, cat_ts)]) / batchsize dep_loss = reduce(lambda x, y: x + y, [we * F.softmax_cross_entropy(y, t) \ for y, t, we in zip(dep_ys, dep_ts, weights)]) dep_acc = reduce(lambda x, y: x + y, [F.accuracy(y, t, ignore_label=IGNORE) for y, t in zip(dep_ys, dep_ts)]) / batchsize chainer.report({ "tagging_loss": cat_loss, "tagging_accuracy": cat_acc, "parsing_loss": dep_loss, "parsing_accuracy": dep_acc }, self) return cat_loss + dep_loss
def __call__(self, ws, cs, cat_ts, dep_ts): batchsize, length = cat_ts.shape cat_ys, dep_ys = self.forward(ws, cs) cat_ys = cat_ys[1:-1] cat_ts = [F.reshape(x, (batchsize,)) for x \ in F.split_axis(F.transpose(cat_ts), length, 0)] assert len(cat_ys) == len(cat_ts) cat_loss = reduce(lambda x, y: x + y, [F.softmax_cross_entropy(y, t) for y, t in zip(cat_ys, cat_ts)]) cat_acc = reduce(lambda x, y: x + y, [F.accuracy(y, t, ignore_label=IGNORE) for y, t in zip(cat_ys, cat_ts)]) # hs [(length, hidden_dim), ...] dep_ys = [x[1:-1] for x in dep_ys] dep_ts = [F.reshape(x, (length,)) for x in F.split_axis(dep_ts, batchsize, 0)] dep_loss = reduce(lambda x, y: x + y, [F.softmax_cross_entropy(y, t) for y, t in zip(dep_ys, dep_ts)]) dep_acc = reduce(lambda x, y: x + y, [F.accuracy(y, t, ignore_label=IGNORE) for y, t in zip(dep_ys, dep_ts)]) cat_acc /= length dep_acc /= batchsize chainer.report({ "tagging_loss": cat_loss, "tagging_accuracy": cat_acc, "parsing_loss": dep_loss, "parsing_accuracy": dep_acc }, self) return cat_loss + dep_loss
def __call__(self, xs): """ xs [(w,s,p,y), ..., ] w: word, c: char, l: length, y: label """ batchsize = len(xs) if len(xs[0]) == 5: ws, ss, ps, cat_ts, dep_ts = zip(*xs) xp = chainer.cuda.get_array_module(ws[0]) weights = [xp.array(1, 'f') for _ in xs] else: ws, ss, ps, cat_ts, dep_ts, weights = zip(*xs) cat_ys, dep_ys = self.forward(ws, ss, ps, dep_ts if self.train else None) cat_loss = reduce(lambda x, y: x + y, [we * F.softmax_cross_entropy(y, t) \ for y, t, we in zip(cat_ys, cat_ts, weights)]) cat_acc = reduce(lambda x, y: x + y, [F.accuracy(y, t, ignore_label=IGNORE) \ for y, t in zip(cat_ys, cat_ts)]) / batchsize dep_loss = reduce(lambda x, y: x + y, [we * F.softmax_cross_entropy(y, t) \ for y, t, we in zip(dep_ys, dep_ts, weights)]) dep_acc = reduce(lambda x, y: x + y, [F.accuracy(y, t, ignore_label=IGNORE) \ for y, t in zip(dep_ys, dep_ts)]) / batchsize chainer.report({ "tagging_loss": cat_loss, "tagging_accuracy": cat_acc, "parsing_loss": dep_loss, "parsing_accuracy": dep_acc }, self) return cat_loss + dep_loss
