def match_anchor_to_bbox(ground_truth, anchors, device, iou_threshold=0.5): """Assign ground-truth bounding boxes to anchor boxes similar to them.""" num_anchors, num_gt_boxes = anchors.shape[0], ground_truth.shape[0] # Element `x_ij` in the `i^th` row and `j^th` column is the IoU # of the anchor box `anc_i` to the ground-truth bounding box `box_j` jaccard = box_iou(anchors, ground_truth) # Initialize the tensor to hold assigned ground truth bbox for each anchor anchors_bbox_map = np.full((num_anchors, ), fill_value=-1, dtype=np.int32, ctx=device) # Assign ground truth bounding box according to the threshold max_ious, indices = np.max(jaccard, axis=1), np.argmax(jaccard, axis=1) anc_i = np.nonzero(max_ious >= iou_threshold)[0] box_j = indices[max_ious >= iou_threshold] anchors_bbox_map[anc_i] = box_j # Find the largest iou for each bbox col_discard = np.full((num_anchors, ), -1) row_discard = np.full((num_gt_boxes, ), -1) for _ in range(num_gt_boxes): max_idx = np.argmax(jaccard) box_idx = (max_idx % num_gt_boxes).astype('int32') anc_idx = (max_idx / num_gt_boxes).astype('int32') anchors_bbox_map[anc_idx] = box_idx jaccard[:, box_idx] = col_discard jaccard[anc_idx, :] = row_discard return anchors_bbox_map
def predict_snli(net, vocab, premise, hypothesis): premise = np.array(vocab[premise], ctx=d2l.try_gpu()) hypothesis = np.array(vocab[hypothesis], ctx=d2l.try_gpu()) label = np.argmax(net([premise.reshape((1, -1)), hypothesis.reshape((1, -1))]), axis=1) return 'entailment' if label == 0 else 'contradiction' if label == 1 \ else 'neutral'
def test_acc(net, test_feats, test_thrpts, print_log=True): """Test the model accuracy.""" if print_log: log.info('\nExpected\tThrpt-Pred\tThrpt-Error') thrpt_pred_range = (float('inf'), 0) # Confusion matrix for each class. error = 0 TP = [] FN = [] FP = [] for start in range(0, len(test_feats), 512): thrpt_preds = net(test_feats[start:min(start + 512, len(test_feats))]) for idx, thrpt_pred_prob in enumerate(thrpt_preds): real = test_thrpts[start + idx].tolist() thrpt_pred = int(np.argmax(thrpt_pred_prob).tolist()) while len(TP) <= max(real, thrpt_pred): TP.append(0) FN.append(0) FP.append(0) if thrpt_pred == real: TP[real] += 1 else: error += 1 FN[real] += 1 FP[thrpt_pred] += 1 thrpt_pred_range = (min(thrpt_pred_range[0], thrpt_pred), max(thrpt_pred_range[1], thrpt_pred)) if print_log: log.info('\t%d\t%d', real, thrpt_pred) accuracy = 100.0 * (1.0 - (error / len(test_feats))) recalls = [ '{:.2f}%'.format(100.0 * tp / (tp + fn)) if tp + fn > 0 else 'N/A' for tp, fn in zip(TP, FN) ] precisions = [ '{:.2f}%'.format(100.0 * tp / (tp + fp)) if tp + fp > 0 else 'N/A' for tp, fp in zip(TP, FP) ] log.info('Thrpt predict range: %d, %d', thrpt_pred_range[0], thrpt_pred_range[1]) log.info('Recalls: %s', ', '.join(recalls[-3:-1])) log.info('Precisions: %s', ', '.join(precisions[-3:-1])) if print_log: log.info('Accuracy: %.2f%%', accuracy) return accuracy
def test_argmax(): A = np.zeros((INT_OVERFLOW, 2)) A[10][1] = 1 A.attach_grad() with mx.autograd.record(): B = np.argmax(A) print(B) assert B == 21 B.backward() assert A.grad.shape == (INT_OVERFLOW, 2) assert A.grad[0][0] == 0
def decode_step(self, step_input: np.ndarray, states: List, vocab_slice_ids: Optional[np.ndarray] = None): logits, states, target_factor_outputs = self._model.decode_step(step_input, states, vocab_slice_ids) if not self._skip_softmax: logits = npx.log_softmax(logits, axis=-1, temperature=self._softmax_temperature) scores = -logits target_factors = None # type: Optional[np.ndarray] if target_factor_outputs: # target factors are greedily 'decoded'. factor_predictions = [npx.cast(np.expand_dims(np.argmax(tfo, axis=1), axis=1), dtype='int32') for tfo in target_factor_outputs] target_factors = factor_predictions[0] if len(factor_predictions) == 1 \ else np.concatenate(factor_predictions, axis=1) return scores, states, target_factors
def IoU(pred, target): eps = 1e-7 ''' iou or jaccard loss for binary classes ''' intersect = pixel_accuracy(pred, target) * target.sum() if pred.shape[1] == 1: classes = (pred > 0.5).astype('int32') else: classes = np.argmax(pred, axis=1) union = pred.sum() + target.sum().astype('int32') - intersect.astype( 'int32') if union > 0: sum_ious = intersect / (union + eps) elif union <= 0: sum_ious = 0 ''' Autograd wants to minimize a loss, so negate the IOU ''' return 1. - sum_ious
def pixel_accuracy(output, y): ''' binary class prediction accuracy. output is dim(B, 1, W, H, {D}) target is dim(B, W, H, {D}) ''' true_pos = np.sum(y) if output.shape[1] == 1: classes = (output > 0.5).astype('float32') if output.shape[1] == 2: classes = np.argmax(output, axis=1) acc = (classes.astype('bool') * y.astype('bool')).sum() # print('Acc:',acc) if true_pos > 0: pix_acc = acc / y.sum().astype('float32') if true_pos == 0 and acc == 0: pix_acc = 1.0 if true_pos == 0 and acc != 0: pix_acc = 0.0 return pix_acc
def multibox_detection(cls_probs, offset_preds, anchors, nms_threshold=0.5, pos_threshold=0.00999999978): device, batch_size = cls_probs.ctx, cls_probs.shape[0] anchors = np.squeeze(anchors, axis=0) num_classes, num_anchors = cls_probs.shape[1], cls_probs.shape[2] out = [] # print(offset_preds) for i in range(batch_size): cls_prob, offset_pred = cls_probs[i], offset_preds[i].reshape(-1, 4) conf, class_id = np.max(cls_prob[1:], 0), np.argmax(cls_prob[1:], 0) predicted_bb = offset_inverse(anchors, offset_pred) keep = nms(predicted_bb, conf, 0.5) print(keep) # Find all non_keep indices and set the class_id to background all_idx = np.arange(num_anchors, dtype=np.int32, ctx=device) combined = np.concatenate((keep, all_idx)) unique, counts = np.unique(combined, return_counts=True) print(unique, " . ", counts) non_keep = unique[counts == 1] all_id_sorted = np.concatenate((keep, non_keep)) class_id[non_keep] = -1 print(class_id) class_id = class_id[all_id_sorted].astype('float32') print(class_id) conf, predicted_bb = conf[all_id_sorted], predicted_bb[all_id_sorted] print(conf) print(predicted_bb) # threshold to be a positive prediction below_min_idx = (conf < pos_threshold) class_id[below_min_idx] = -1 conf[below_min_idx] = 1 - conf[below_min_idx] pred_info = np.concatenate((np.expand_dims( class_id, axis=1), np.expand_dims(conf, axis=1), predicted_bb), axis=1) out.append(pred_info) return np.stack(out)
def get_corrupted_tokens(self, inputs, original_tokens, masked_positions, logits): """ Sample from the generator to create corrupted input. Parameters ---------- F inputs The masked input - layout = 'NT' Shape (batch_size, seq_length) - layout = 'TN' Shape (seq_length, batch_size) original_tokens The original tokens that appear in the unmasked input sequence Shape (batch_size, num_masked_positions). masked_positions The masked position of the sequence Shape (batch_size, num_masked_positions). logits The logits of each tokens Shape (batch_size, num_masked_positions, vocab_size) Returns ------- corrupted_tokens Shape (batch_size, ) fake_data - layout = 'NT' Shape (batch_size, seq_length) - layout = 'TN' Shape (seq_length, batch_size) labels - layout = 'NT' Shape (batch_size, seq_length) - layout = 'TN' Shape (seq_length, batch_size) """ if self._disallow_correct: # TODO(sxjscience), Revise the implementation disallow = npx.one_hot(masked_positions, depth=self.vocab_size, dtype=self._dtype) logits = logits - 1000.0 * disallow # gumbel_softmax() samples from the logits with a noise of Gumbel distribution prob = gumbel_softmax( F, logits, temperature=self._temperature, eps=self._gumbel_eps, use_np_gumbel=False) corrupted_tokens = np.argmax(prob, axis=-1).astype(np.int32) if self.disc_backbone.layout == 'TN': inputs = inputs.T original_data = update_vectors_by_position(F, inputs, original_tokens, masked_positions) fake_data = update_vectors_by_position(F, inputs, corrupted_tokens, masked_positions) updates_mask = add_vectors_by_position(np.zeros_like(inputs), np.ones_like(masked_positions), masked_positions) # Dealing with multiple zeros in masked_positions which # results in a non-zero value in the first index [CLS] updates_mask = np.minimum(updates_mask, 1) labels = updates_mask * np.not_equal(fake_data, original_data) if self.disc_backbone.layout == 'TN': return corrupted_tokens, fake_data.T, labels.T else: return corrupted_tokens, fake_data, labels
train_acc_sum = sum( d2l.accuracy(py.asnumpy(), y.asnumpy()) for py, y in zip(pys, ys)) l, acc = train_loss_sum, train_acc_sum metric.add(l, acc, ys_in.shape[0], ys_in.size) timer.stop() if (i + 1) % (num_batches // 5) == 0: animator.add( epoch + i / num_batches, (metric[0] / metric[2], metric[1] / metric[3], None, None)) # val_acc = d2l.evaluate_accuracy_gpus(net, val_iter, split_f) metric_val = d2l.Accumulator(2) # num_corrected_examples, num_examples for i, (Xs_in, ys_in) in enumerate(DataLoader_Single_test): Xs = gluon.utils.split_and_load(Xs_in.astype("float32"), ctx) ys = gluon.utils.split_and_load(ys_in.astype("float32"), ctx) pys = [net(X) for X in Xs] ls = [loss(py, y) for py, y in zip(pys, ys)] val_loss_sum = sum([float(l.sum().asnumpy()[0]) for l in ls]) OA_val = np.sum( np.argmax(pys[0].asnumpy(), axis=1) == ys[0].asnumpy()).astype( "float32") / np.prod(ys[0].shape) metric_val.add(OA_val, len(ys)) val_acc = OA_val animator.add(epoch + 1, (None, None, val_loss_sum / ys_in.shape[0], val_acc)) print('loss %.3f, train acc %.3f, val acc %.3f' % (metric[0] / metric[2], metric[1] / metric[3], val_acc)) print('%.1f examples/sec on %s' % (metric[2] * num_epochs / timer.sum(), d2l.try_all_gpus()))
def predict_sentiment(net, vocab, sentence): sentence = np.array(vocab[sentence.split()], ctx=d2l.try_gpu()) label = np.argmax(net(sentence.reshape(1, -1)), axis=1) return 'positive' if label == 1 else 'negative'