我们从Python开源项目中，提取了以下42个代码示例，用于说明如何使用chainer.functions.transpose()。
def __call__(self, ht, xs, d_bar_s_1): #ht:encoder????????????????? #batch_size * n_words * in_size #xs:?????? if d_bar_s_1 == None: d_bar_s_1 = np.zeros(self.in_size) ht_T = list(map(F.transpose, ht)) phi_ht = list(map(W1, ht_T)) d_s = rnn(d_bar_s_1, y_s_1) phi_d = F.transpose_sequence(W2(F.transpose_sequence(d_s))) u_st = list(map(lambda x: phi_d*x, phi_ht)) #(4) sum_u = F.sum(u_st) alpha_st = list(map(lambda x:x/sum_u, u_st)) #(3) z_s = F.argmax(alpha_st, axis=0) c_s = F.sum(list(map(lambda x,y:x*y , alpha_st, ht))) #(2) d_bar_s = F.relu(W3(F.concat([c_s, d_s]))) return d_bar_s, d_s, c_s, z_s
def predict(self, xs): """ batch: list of splitted sentences """ batchsize = len(xs) fs = [self.extractor.process(x)[:2] for x in xs] ws, cs = concat_examples(fs, padding=IGNORE) cat_ys, dep_ys = self.forward(ws, cs) cat_ys = F.transpose(F.stack(cat_ys, 2), (0, 2, 1)) # dep_ys = F.transpose(F.stack(dep_ys, 2), (0, 2, 1)) cat_ys = [F.log_softmax( F.reshape(y, (y.shape[1], -1))[1:len(x) + 1]).data for x, y in \ zip(xs, F.split_axis(cat_ys, batchsize, 0))] dep_ys = [F.log_softmax(y[1:len(x) + 1, :len(x) + 1]).data \ for x, y in zip(xs, dep_ys)] assert len(cat_ys) == len(dep_ys) return zip(cat_ys, dep_ys)
def forward(self, ws, ss, ps): batchsize, length = ws.shape xp = chainer.cuda.get_array_module(ws[0]) ws = self.emb_word(ws) # (batch, length, word_dim) ss = F.reshape(self.emb_suf(ss), (batchsize, length, -1)) ps = F.reshape(self.emb_prf(ps), (batchsize, length, -1)) hs = F.transpose(F.concat([ws, ss, ps], 2), (1, 0, 2)) hs = F.dropout(hs, self.dropout_ratio, train=self.train) hs = F.split_axis(hs, length, 0) hs_f = [] hs_b = [] self._init_state() for h_in_f, h_in_b in zip(hs, reversed(hs)): h_f = self.lstm_f2(self.lstm_f1(F.squeeze(h_in_f, 0))) hs_f.append(h_f) h_b = self.lstm_b2(self.lstm_b1(F.squeeze(h_in_b, 0))) hs_b.append(h_b) ys = [self.linear2(F.relu(self.linear1(F.concat([h_f, h_b])))) for h_f, h_b in zip(hs_f, reversed(hs_b))] return ys
def predict(self, xs): """ batch: list of splitted sentences """ batchsize = len(xs) xs = [self.extractor.process(x) for x in xs] ws, ss, ps = concat_examples(xs, padding=IGNORE) cat_ys, dep_ys = self.forward(ws, ss, ps) cat_ys = F.transpose(F.stack(cat_ys, 2), (0, 2, 1)) dep_ys = F.transpose(F.stack(dep_ys, 2), (0, 2, 1)) cat_ys = [F.squeeze(y, 0).data[1:len(x) + 1] for x, y in \ zip(xs, F.split_axis(cat_ys, batchsize, 0))] dep_ys = [F.squeeze(F.log_softmax(y[1:len(x) + 1, :-1]), 0).data \ for x, y in zip(xs, F.split_axis(dep_ys, batchsize, 0))] return cat_ys, dep_ys
def __call__(self, chars): if not isinstance(chars, (tuple, list)): chars = [chars] char_ids, boundaries = self._create_sequence(chars) x = self.embed(self.xp.array(char_ids)) x = F.dropout(x, self._dropout) length, dim = x.shape C = self.conv(F.reshape(x, (1, 1, length, dim))) # C.shape -> (1, out_size, length, 1) C = F.split_axis(F.transpose(F.reshape(C, (self.out_size, length))), boundaries, axis=0) ys = F.max(F.pad_sequence( [matrix for i, matrix in enumerate(C) if i % 2 == 1], padding=-np.inf), axis=1) # max over time pooling # assert len(chars) == ys.shape[0] return ys
def __call__(self, x1, x2): xp = self.xp out_size = self.out_size batch_size, len1, dim1 = x1.shape if not self.nobias[0]: x1 = F.concat((x1, xp.ones((batch_size, len1, 1), dtype=xp.float32)), axis=2) dim1 += 1 len2, dim2 = x2.shape[1:] if not self.nobias[1]: x2 = F.concat((x2, xp.ones((batch_size, len2, 1), dtype=xp.float32)), axis=2) dim2 += 1 x1_reshaped = F.reshape(x1, (batch_size * len1, dim1)) W_reshaped = F.reshape(F.transpose(self.W, (0, 2, 1)), (dim1, out_size * dim2)) affine = F.reshape(F.matmul(x1_reshaped, W_reshaped), (batch_size, len1 * out_size, dim2)) biaffine = F.transpose( F.reshape(batch_matmul(affine, x2, transb=True), (batch_size, len1, out_size, len2)), (0, 1, 3, 2)) if not self.nobias[2]: biaffine += F.broadcast_to(self.b, biaffine.shape) return biaffine
def __call__(self, x): xp = chainer.cuda.get_array_module(x.data) batchsize = x.shape[0] if self.train_weights == False and self.initial_T is not None: self.T.W.data = self.initial_T M = F.reshape(self.T(x), (-1, self.num_kernels, self.ndim_kernel)) M = F.expand_dims(M, 3) M_T = F.transpose(M, (3, 1, 2, 0)) M, M_T = F.broadcast(M, M_T) norm = F.sum(abs(M - M_T), axis=2) eraser = F.broadcast_to(xp.eye(batchsize, dtype=x.dtype).reshape((batchsize, 1, batchsize)), norm.shape) c_b = F.exp(-(norm + 1e6 * eraser)) o_b = F.sum(c_b, axis=2) if self.train_weights == False: self.initial_T = self.T.W.data return F.concat((x, o_b), axis=1)
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 reorg(input, stride=2): batch_size, input_channel, input_height, input_width = input.data.shape output_height, output_width, output_channel = int(input_height/stride), int(input_width/stride), input_channel*stride*stride output = F.transpose(F.reshape(input, (batch_size, input_channel, output_height, stride, output_width, stride)), (0, 1, 2, 4, 3, 5)) output = F.transpose(F.reshape(output, (batch_size, input_channel, output_height, output_width, -1)), (0, 4, 1, 2, 3)) output = F.reshape(output, (batch_size, output_channel, output_height, output_width)) return output
def predict(self, input_x): if isinstance(input_x, chainer.Variable): device = cuda.get_device(input_x.data) else: device = cuda.get_device(input_x) xp = self.predictor.xp with device: output = self.predictor(input_x) batch_size, input_channel, input_h, input_w = input_x.shape batch_size, _, grid_h, grid_w = output.shape x, y, w, h, conf, prob = F.split_axis(F.reshape(output, (batch_size, self.predictor.n_boxes, self.predictor.n_classes+5, grid_h, grid_w)), (1, 2, 3, 4, 5), axis=2) x = F.sigmoid(x) y = F.sigmoid(y) conf = F.sigmoid(conf) prob = F.transpose(prob, (0, 2, 1, 3, 4)) prob = F.softmax(prob) prob = F.transpose(prob, (0, 2, 1, 3, 4)) # convert coordinates to those on the image x_shift = xp.asarray(np.broadcast_to(np.arange(grid_w, dtype=np.float32), x.shape)) y_shift = xp.asarray(np.broadcast_to(np.arange(grid_h, dtype=np.float32).reshape(grid_h, 1), y.shape)) w_anchor = xp.asarray(np.broadcast_to(np.reshape(np.array(self.anchors, dtype=np.float32)[:, 0], (self.predictor.n_boxes, 1, 1, 1)), w.shape)) h_anchor = xp.asarray(np.broadcast_to(np.reshape(np.array(self.anchors, dtype=np.float32)[:, 1], (self.predictor.n_boxes, 1, 1, 1)), h.shape)) box_x = (x + x_shift) / grid_w box_y = (y + y_shift) / grid_h box_w = F.exp(w) * w_anchor / grid_w box_h = F.exp(h) * h_anchor / grid_h return box_x, box_y, box_w, box_h, conf, prob
def extract_best_label_logits(self, arc_logits, label_logits, lengths): pred_arcs = self.model.xp.argmax(arc_logits.data, axis=1) label_logits = F.transpose(label_logits, (0, 2, 1, 3)) label_logits = [_logits[np.arange(_length), _arcs[:_length]] for _logits, _arcs, _length in zip(label_logits, pred_arcs, lengths)] label_logits = F.pad_sequence(label_logits) return label_logits
def parse(self, pretrained_word_tokens=None, word_tokens=None, pos_tokens=None): if word_tokens is not None: self.forward(pretrained_word_tokens, word_tokens, pos_tokens) ROOT = self._ROOT_LABEL arcs_batch, labels_batch = [], [] arc_logits = cuda.to_cpu(self._arc_logits.data) label_logits = cuda.to_cpu(self._label_logits.data) for arc_logit, label_logit, length in \ zip(arc_logits, np.transpose(label_logits, (0, 2, 1, 3)), self._lengths): arc_probs = softmax2d(arc_logit[:length, :length]) arcs = mst(arc_probs) label_probs = softmax2d(label_logit[np.arange(length), arcs]) labels = np.argmax(label_probs, axis=1) labels[0] = ROOT tokens = np.arange(1, length) roots = np.where(labels[tokens] == ROOT)[0] + 1 if len(roots) < 1: root_arc = np.where(arcs[tokens] == 0)[0] + 1 labels[root_arc] = ROOT elif len(roots) > 1: label_probs[roots, ROOT] = 0 new_labels = \ np.argmax(label_probs[roots], axis=1) root_arc = np.where(arcs[tokens] == 0)[0] + 1 labels[roots] = new_labels labels[root_arc] = ROOT arcs_batch.append(arcs) labels_batch.append(labels) return arcs_batch, labels_batch
def forward(self, ws, cs): batchsize, length, max_word_len = cs.shape ws = self.emb_word(ws) # (batch, length, word_dim) cs = F.reshape( F.max_pooling_2d( self.conv_char( F.reshape( self.emb_char(cs), (batchsize * length, 1, max_word_len, 50))), (max_word_len, 1)), (batchsize, length, self.char_dim)) hs = F.transpose(F.concat([ws, cs], 2), (1, 0, 2)) hs = F.dropout(hs, self.dropout_ratio, train=self.train) hs = F.split_axis(hs, length, 0) hs_f = [] hs_b = [] self._init_state() for h_in_f, h_in_b in zip(hs, reversed(hs)): h_f = self.lstm_f2(self.lstm_f1(F.reshape(h_in_f, (batchsize, -1)))) hs_f.append(h_f) h_b = self.lstm_b2(self.lstm_b1(F.reshape(h_in_b, (batchsize, -1)))) hs_b.append(h_b) hs = [F.concat([h_f, h_b]) for h_f, h_b in zip(hs_f, reversed(hs_b))] cat_ys = [self.linear_cat2(F.dropout( F.elu(self.linear_cat1(h)), 0.5, train=self.train)) for h in hs] hs = [F.reshape(h, (length, -1)) for h in \ F.split_axis(F.transpose(F.stack(hs, 2), (0, 2, 1)), batchsize, 0)] dep_ys = [self.biaffine( F.relu(F.dropout(self.linear_dep(h), 0.32, train=self.train)), F.relu(F.dropout(self.linear_head(h), 0.32, train=self.train))) for h in hs] return cat_ys, dep_ys
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 predict(self, xs): """ batch: list of splitted sentences """ batchsize = len(xs) fs = [self.extractor.process(x) for x in xs] ws, ss, ps = concat_examples(fs, padding=-1) ys = self.forward(ws, ss, ps) ys = F.transpose(F.stack(ys, 2), (0, 2, 1)) return [F.squeeze(y, 0).data[1:len(x) + 1] for x, y in \ zip(xs, F.split_axis(ys, batchsize, 0))]
def __call__(self, ws, ss, ps, ts): """ xs [(w,s,p,y), ..., ] w: word, s: suffix, p: prefix, y: label """ batchsize, length = ws.shape cat_ys, dep_ys = self.forward(ws, ss, ps)[1:-1] cat_ts = [F.reshape(x, (batchsize,)) for x \ in F.split_axis(F.transpose(cat_ts), length, 0)] dep_ts = [F.reshape(x, (batchsize,)) for x \ in F.split_axis(F.transpose(dep_ts), length, 0)] 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 /= length dep_acc /= length 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 forward(self, ws, ss, ps): batchsize, length = ws.shape xp = chainer.cuda.get_array_module(ws[0]) ws = self.emb_word(ws) # (batch, length, word_dim) ss = F.reshape(self.emb_suf(ss), (batchsize, length, -1)) ps = F.reshape(self.emb_prf(ps), (batchsize, length, -1)) hs = F.transpose(F.concat([ws, ss, ps], 2), (1, 0, 2)) hs = F.dropout(hs, self.dropout_ratio, train=self.train) hs = F.split_axis(hs, length, 0) hs_f = [] hs_b = [] self._init_state() for h_in_f, h_in_b in zip(hs, reversed(hs)): h_f = self.lstm_f2(self.lstm_f1(F.reshape(h_in_f, (-1, self.in_dim)))) hs_f.append(h_f) h_b = self.lstm_b2(self.lstm_b1(F.reshape(h_in_b, (-1, self.in_dim)))) hs_b.append(h_b) hs = zip(hs_f, reversed(hs_b)) cat_ys = [self.linear_cat2(F.dropout( F.elu(self.linear_cat1(h)), 0.5, train=self.train)) for h in hs] dep_ys = [self.biaffine( F.elu(F.dropout(self.linear_dep(h), 0.32, train=self.train)), F.elu(F.dropout(self.linear_head(h), 0.32, train=self.train))) for h in hs] return cat_ys, dep_ys
def planar_flows(self,z): self.z_trans = [] self.z_trans.append(z) self.phi = [] for i in range(self.num_trans): flow_w_name = 'flow_w_' + str(i) flow_b_name = 'flow_b_' + str(i) flow_u_name = 'flow_u_' + str(i) h = self[flow_w_name](z) h = F.sum(h,axis=(1)) h = self[flow_b_name](h) h = F.tanh(h) h_tanh = h dim_latent = z.shape[1] h = F.transpose(F.tile(h, (dim_latent,1))) h = self[flow_u_name](h) z += h self.z_trans.append(z) # Calculate and store the phi term h_tanh_derivative = 1-(h_tanh*h_tanh) h_tanh_derivative = F.transpose(F.tile(h_tanh_derivative, (dim_latent,1))) phi = self[flow_w_name](h_tanh_derivative) # Equation (11) self.phi.append(phi) return z
def __call__(self, x): return functions.transpose(x, self.axes) # Noise injections
def check_forward(self, x_data): axes = self.axes x = chainer.Variable(x_data) y = functions.transpose(x, axes) self.assertEqual(y.data.dtype, self.dtype) self.assertTrue((self.x.transpose(axes) == cuda.to_cpu(y.data)).all())
def check_backward(self, x_data): x = chainer.Variable(x_data) y = functions.transpose(x, self.axes) y.grad = y.data y.backward() gradient_check.assert_allclose(x.data, x.grad, atol=0, rtol=0)
def angular_mc_loss(f, f_p, alpha=45, in_degree=True): ''' Args: f (chainer.Variable or xp.npdarray): Anchor vectors. Each vectors in f must be l2 normalized. f_p (chainer.Variable or xp.npdarray): Positive vectors. Each vectors in f must be l2 normalized. ''' xp = cuda.get_array_module(f) if in_degree: alpha = np.deg2rad(alpha) sq_tan_alpha = np.tan(alpha) ** 2 n_pairs = len(f) # first and second term of f_{a,p,n} term1 = 4 * sq_tan_alpha + matmul(f + f_p, transpose(f_p)) term2 = 2 * (1 + sq_tan_alpha) * F.sum(f * f_p, axis=1, keepdims=True) # term2 = 2 * (1 + sq_tan_alpha) * F.batch_matmul(f, f_p, transa=True).reshape(n_pairs, 1) f_apn = term1 - F.broadcast_to(term2, (n_pairs, n_pairs)) # multiply zero to diagonal components of f_apn mask = xp.ones_like(f_apn.data) - xp.eye(n_pairs, dtype=f.dtype) f_apn = f_apn * mask return F.average(F.logsumexp(f_apn, axis=1))
def n_pair_mc_loss(f, f_p, l2_reg): """Multi-class N-pair loss (N-pair-mc loss) function. Args: f (~chainer.Variable): Feature vectors. All examples must be different classes each other. f_p (~chainer.Variable): Positive examples corresponding to f. Each example must be the same class for each example in f. l2_reg (~float): A weight of L2 regularization for feature vectors. Returns: ~chainer.Variable: Loss value. See: `Improved Deep Metric Learning with Multi-class N-pair Loss \ Objective <https://papers.nips.cc/paper/6200-improved-deep-metric-\ learning-with-multi-class-n-pair-loss-objective>`_ """ logit = matmul(f, transpose(f_p)) N = len(logit.data) xp = cuda.get_array_module(logit.data) loss_sce = softmax_cross_entropy(logit, xp.arange(N)) l2_loss = sum(batch_l2_norm_squared(f) + batch_l2_norm_squared(f_p)) / (2.0 * N) loss = loss_sce + l2_reg * l2_loss return loss
def sentence_block_embed(embed, x): batch, length = x.shape e = embed(x.reshape((batch * length, ))) # (batch * length, units) e = F.transpose(F.stack(F.split_axis(e, batch, axis=0), axis=0), (0, 2, 1)) # (batch, units, length) return e
def seq_linear(linear, x): batch, units, length, _ = x.shape h = linear(F.transpose(x, (0, 2, 1, 3)).reshape(batch * length, units)) return F.transpose(h.reshape((batch, length, units, 1)), (0, 2, 1, 3))
def __call__(self, chars): xp = self.xp if not isinstance(chars, (tuple, list)): chars = [chars] lengths = [len(_chars) for _chars in chars] n_words = len(lengths) pad_width = self._pad_width char_ids = F.PadSequence(length=max(lengths) + pad_width, padding=self._pad_id).forward(chars)[0] left_pads = xp.full((n_words, pad_width), self._pad_id, xp.int32) char_ids = xp.concatenate((left_pads, xp.array(char_ids)), axis=1) """note: cupy does not have `inf`.""" mask = xp.full(char_ids.shape, np.inf) for i, length in enumerate(lengths): mask[i, pad_width:pad_width + length] = 0 mask = xp.expand_dims(mask, axis=2) xs = self.embed(char_ids) xs = F.dropout(xs, self._dropout) C = self.conv(F.expand_dims(xs, axis=1)) C = F.transpose(F.squeeze(C, axis=3), (0, 2, 1)) """ assert C.shape == (n_words, pad_width + max(lengths) + pad_width, self.out_size) """ ys = F.max(C - mask, axis=1) return ys
def __call__(self, x): r = self.r out = self.conv(x) batchsize = out.shape[0] in_channels = out.shape[1] out_channels = int(in_channels / (r ** 2)) in_height = out.shape[2] in_width = out.shape[3] out_height = in_height * r out_width = in_width * r out = F.reshape(out, (batchsize, r, r, out_channels, in_height, in_width)) out = F.transpose(out, (0, 3, 4, 1, 5, 2)) out = F.reshape(out, (batchsize, out_channels, out_height, out_width)) return out
def predicted_image(self): # The transpose is because OpenAI gym and chainer have # different depth conventions return F.transpose(self._predicted_image[0])
def error_mask(self): return F.transpose(self.attention_mask)
def process_image(raw_image): floated = raw_image.astype('float32') / 255.0 transposed = F.transpose(floated) expanded = F.expand_dims(transposed, 0) # Make a "batch size" of 1 return expanded
def __call__(self, orig_img, input_size=None): xp = self.model.xp orig_input_width, orig_input_height = orig_img.size if input_size is not None: img = orig_img.resize(input_size, Image.BILINEAR) else: img = utils.reshape_to_yolo_size(orig_img) input_width, input_height = img.size img = np.asarray(img, dtype=np.float32) / 255.0 img = img.transpose(2, 0, 1) # forward x = xp.asarray(img[np.newaxis, :, :, :]) x, y, w, h, conf, prob = self.model.predict(x) # parse results _, _, _, grid_h, grid_w = x.shape x = F.reshape(x, (self.n_boxes, grid_h, grid_w)).data y = F.reshape(y, (self.n_boxes, grid_h, grid_w)).data w = F.reshape(w, (self.n_boxes, grid_h, grid_w)).data h = F.reshape(h, (self.n_boxes, grid_h, grid_w)).data conf = F.reshape(conf, (self.n_boxes, grid_h, grid_w)).data prob = F.transpose(F.reshape(prob, (self.n_boxes, self.n_classes, grid_h, grid_w)), (1, 0, 2, 3)).data x = cuda.to_cpu(x) y = cuda.to_cpu(y) w = cuda.to_cpu(w) h = cuda.to_cpu(h) conf = cuda.to_cpu(conf) prob = cuda.to_cpu(prob) detected_indices = (conf * prob).max(axis=0) > self.detection_thresh x = x[detected_indices] y = y[detected_indices] w = w[detected_indices] h = h[detected_indices] conf = conf[detected_indices] prob = prob.transpose(1, 2, 3, 0)[detected_indices] results = [] for i in range(detected_indices.sum()): class_id = prob[i].argmax() label = self.labels[class_id] results.append({ 'class_id': class_id, 'label': label, 'probs': prob[i], 'conf' : conf[i], 'objectness': conf[i] * prob[i].max(), 'box' : utils.Box( x[i] * orig_input_width, y[i] * orig_input_height, w[i] * orig_input_width, h[i] * orig_input_height).crop_region(orig_input_height, orig_input_width) }) # nms nms_results = utils.nms(results, self.iou_thresh) return nms_results
def __call__(self, orig_img, input_size=None): xp = self.model.xp orig_input_width, orig_input_height = orig_img.size if input_size is not None: img = orig_img.resize(input_size, Image.BILINEAR) else: img = utils.reshape_to_yolo_size(orig_img) input_width, input_height = img.size img = np.asarray(img, dtype=np.float32) / 255.0 img = img.transpose(2, 0, 1) # forward x = xp.asarray(img[np.newaxis, :, :, :]) x, y, w, h, conf, prob = self.model.predict(x) # parse results _, _, _, grid_h, grid_w = x.shape x = F.reshape(x, (self.n_boxes, grid_h, grid_w)).data y = F.reshape(y, (self.n_boxes, grid_h, grid_w)).data w = F.reshape(w, (self.n_boxes, grid_h, grid_w)).data h = F.reshape(h, (self.n_boxes, grid_h, grid_w)).data conf = F.reshape(conf, (self.n_boxes, grid_h, grid_w)).data prob = F.transpose(F.reshape(prob, (self.n_boxes, self.n_classes, grid_h, grid_w)), (1, 0, 2, 3)).data x = cuda.to_cpu(x) y = cuda.to_cpu(y) w = cuda.to_cpu(w) h = cuda.to_cpu(h) conf = cuda.to_cpu(conf) prob = cuda.to_cpu(prob) detected_indices = (conf * prob).max(axis=0) > self.detection_thresh x = x[detected_indices] y = y[detected_indices] w = w[detected_indices] h = h[detected_indices] conf = conf[detected_indices] prob = prob.transpose(1, 2, 3, 0)[detected_indices] results = [] for i in range(detected_indices.sum()): class_id = prob[i].argmax() label = self.labels[class_id] results.append({ 'class_id': class_id, 'label': label, 'probs': prob[i], 'conf' : conf[i], 'objectness': conf[i] * prob[i].max(), 'box' : utils.Box( x[i] * orig_input_width, y[i] * orig_input_height, w[i] * orig_input_width, h[i] * orig_input_height).crop_region(orig_input_height, orig_input_width) }) # nms print len(results) nms_results = utils.nms(results, self.iou_thresh) return nms_results
def forward(self, ws, ss, ps, ls, dep_ts=None): batchsize, slen = ws.shape xp = chainer.cuda.get_array_module(ws[0]) wss = self.emb_word(ws) sss = F.reshape(self.emb_suf(ss), (batchsize, slen, 4 * self.afix_dim)) pss = F.reshape(self.emb_prf(ps), (batchsize, slen, 4 * self.afix_dim)) ins = F.dropout(F.concat([wss, sss, pss], 2), self.dropout_ratio, train=self.train) xs_f = F.transpose(ins, (1, 0, 2)) xs_b = xs_f[::-1] cx_f, hx_f, cx_b, hx_b = self._init_state(xp, batchsize) _, _, hs_f = self.lstm_f(hx_f, cx_f, xs_f, train=self.train) _, _, hs_b = self.lstm_b(hx_b, cx_b, xs_b, train=self.train) # (batch, length, hidden_dim) hs = F.transpose(F.concat([hs_f, hs_b[::-1]], 2), (1, 0, 2)) dep_ys = self.biaffine_arc( F.elu(F.dropout(self.arc_dep(hs), 0.32, train=self.train)), F.elu(F.dropout(self.arc_head(hs), 0.32, train=self.train))) if dep_ts is not None and random.random >= 0.5: heads = dep_ts else: heads = F.flatten(F.argmax(dep_ys, axis=2)) + \ xp.repeat(xp.arange(0, batchsize * slen, slen), slen) hs = F.reshape(hs, (batchsize * slen, -1)) heads = F.permutate( F.elu(F.dropout( self.rel_head(hs), 0.32, train=self.train)), heads) childs = F.elu(F.dropout(self.rel_dep(hs), 0.32, train=self.train)) cat_ys = self.biaffine_tag(childs, heads) dep_ys = F.split_axis(dep_ys, batchsize, 0) if batchsize > 1 else [dep_ys] dep_ys = [F.reshape(v, v.shape[1:])[:l, :l] for v, l in zip(dep_ys, ls)] cat_ys = F.split_axis(cat_ys, batchsize, 0) if batchsize > 1 else [cat_ys] cat_ys = [v[:l] for v, l in zip(cat_ys, ls)] return cat_ys, dep_ys
def __call__(self, xs): """ xs [(w,s,p,y), ..., ] w: word, c: char, l: length, y: label """ batchsize = len(xs) ws, cs, ls, ts = zip(*xs) # cs: [(sentence length, max word length)] ws = map(self.emb_word, ws) # ls: [(sentence length, char dim)] # cs = map(lambda (c, l): F.sum(self.emb_char(c), 1) / l, zip(cs, ls)) # cs = [F.reshape(F.average_pooling_2d( # F.expand_dims(self.emb_char(c), 0), (l, 1)), (-1, self.char_dim)) # for c, l in zip(cs, ls)] # before conv: (sent len, 1, max word len, char_size) # after conv: (sent len, char_size, max word len, 1) # after max_pool: (sent len, char_size, 1, 1) cs = [F.squeeze( F.max_pooling_2d( self.conv_char( F.expand_dims( self.emb_char(c), 1)), (l, 1))) for c, l in zip(cs, ls)] # [(sentence length, (word_dim + char_dim))] xs_f = [F.dropout(F.concat([w, c]), self.dropout_ratio, train=self.train) for w, c in zip(ws, cs)] xs_b = [x[::-1] for x in xs_f] cx_f, hx_f, cx_b, hx_b = self._init_state(batchsize) _, _, hs_f = self.lstm_f(hx_f, cx_f, xs_f, train=self.train) _, _, hs_b = self.lstm_b(hx_b, cx_b, xs_b, train=self.train) hs_b = [x[::-1] for x in hs_b] # ys: [(sentence length, number of category)] ys = [self.linear2(F.relu(self.linear1(F.concat([h_f, h_b])))) for h_f, h_b in zip(hs_f, hs_b)] # ys = [self.linear2(F.relu( # self.linear1( # F.squeeze( # F.transpose( # F.relu(self.conv1( # F.reshape( # F.concat([h_f, h_b]), # (1, 1, -1, 2 * self.hidden_dim))), (0, 3, 2, 1)) # ))))) # for h_f, h_b in zip(hs_f, hs_b)] 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): """Compute loc and conf from feature maps This method computes :obj:`mb_locs` and :obj:`mb_confs` from given feature maps. Args: xs (iterable of chainer.Variable): An iterable of feature maps. The number of feature maps must be same as the number of :obj:`aspect_ratios`. Returns: tuple of chainer.Variable: This method returns two :obj:`chainer.Variable`: :obj:`mb_locs` and :obj:`mb_confs`. * **mb_locs**: A variable of float arrays of shape \ :math:`(B, K, 4)`, \ where :math:`B` is the number of samples in the batch and \ :math:`K` is the number of default bounding boxes. * **mb_confs**: A variable of float arrays of shape \ :math:`(B, K, n\_fg\_class + 1)`. """ mb_locs = list() mb_confs = list() for i, x in enumerate(xs): mb_loc = self.loc[i](x) mb_loc = F.transpose(mb_loc, (0, 2, 3, 1)) mb_loc = F.reshape(mb_loc, (mb_loc.shape[0], -1, 4)) mb_locs.append(mb_loc) mb_conf = self.conf[i](x) mb_conf = F.transpose(mb_conf, (0, 2, 3, 1)) mb_conf = F.reshape( mb_conf, (mb_conf.shape[0], -1, self.n_class)) mb_confs.append(mb_conf) mb_locs = F.concat(mb_locs, axis=1) mb_confs = F.concat(mb_confs, axis=1) return mb_locs, mb_confs
def __call__(self, x): batchsize = x.data.shape[0] input_x_width = x.data.shape[3] if self.dilation == 1: # perform normal convolution padded_x = self.padding_1d(x, self.filter_width - 1) return super(DilatedConvolution1D, self).__call__(padded_x) # padding pad = 0 padded_x_width = input_x_width ## check if we can reshape mod = padded_x_width % self.dilation if mod > 0: pad += self.dilation - mod padded_x_width = input_x_width + pad ## check if height < filter width height = padded_x_width / self.dilation if height < self.filter_width: pad += (self.filter_width - height) * self.dilation padded_x_width = input_x_width + pad if pad > 0: padded_x = self.padding_1d(x, pad) else: padded_x = x # to skip (dilation - 1) elements padded_x = F.reshape(padded_x, (batchsize, self.in_channels, -1, self.dilation)) # we can remove transpose operation when residual_conv_filter_width is set to the kernel's height # padded_x = F.transpose(padded_x, (0, 1, 3, 2)) # convolution out = super(DilatedConvolution1D, self).__call__(padded_x) # reshape to the original shape out = F.reshape(out, (batchsize, self.out_channels, 1, -1)) # remove padded elements / add missing elements cut = out.data.shape[3] - input_x_width if cut > 0: out = self.slice_1d(out, cut) elif cut < 0: out = self.padding_1d(out, -cut) return out
def __call__(self, x): r = self.r out = self.conv(x) batchsize = out.shape[0] in_channels = out.shape[1] out_channels = in_channels / (r ** 2) in_height = out.shape[2] in_width = out.shape[3] out_height = in_height * r out_width = in_width * r out = F.reshape(out, (batchsize, 1, r * r, out_channels * in_height * in_width, 1)) out = F.transpose(out, (0, 1, 3, 2, 4)) out = F.reshape(out, (batchsize, out_channels, in_height, in_width, r, r)) out = F.transpose(out, (0, 1, 2, 4, 3, 5)) out = F.reshape(out, (batchsize, out_channels, out_height, out_width)) return out # class BatchRenormalization(link.Link): # def __init__(self, size, decay=0.9, eps=2e-5, rmax=1, dmax=0, dtype=numpy.float32, use_gamma=True, use_beta=True, initial_gamma=None, initial_beta=None, use_cudnn=True): # super(BatchNormalization, self).__init__(size, decay=decay, eps=eps, dtype=dtype, use_gamma=use_gamma, use_beta=use_beta, initial_gamma=initial_gamma, initial_beta=initial_beta, use_cudnn=use_cudnn) # self.add_persistent("r", numpy.zeros(size, dtype=dtype)) # self.add_persistent("d", numpy.zeros(size, dtype=dtype)) # self.rmax = rmax # self.dmax = dmax # def __call__(self, x, test=False, finetune=False): # if hasattr(self, "gamma"): # gamma = self.gamma # else: # with cuda.get_device(self._device_id): # gamma = variable.Variable(self.xp.ones(self.avg_mean.shape, dtype=x.dtype), volatile="auto") # if hasattr(self, "beta"): # beta = self.beta # else: # with cuda.get_device(self._device_id): # beta = variable.Variable(self.xp.zeros(self.avg_mean.shape, dtype=x.dtype), volatile="auto") # if not test: # if finetune: # self.N += 1 # decay = 1. - 1. / self.N # else: # decay = self.decay # func = batch_normalization.BatchNormalizationFunction( # self.eps, self.avg_mean, self.avg_var, True, decay, # self.use_cudnn) # ret = func(x, gamma, beta) # self.avg_mean[:] = func.running_mean # self.avg_var[:] = func.running_var # else: # # Use running average statistics or fine-tuned statistics. # mean = variable.Variable(self.avg_mean, volatile="auto") # var = variable.Variable(self.avg_var, volatile="auto") # ret = batch_normalization.fixed_batch_normalization( # x, gamma, beta, mean, var, self.eps, self.use_cudnn) # return ret
