Python torch.max() Examples
The following are 30
code examples of torch.max().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
torch
, or try the search function
.
Example #1
Source File: utils.py From pruning_yolov3 with GNU General Public License v3.0 | 7 votes |
def plot_one_box(x, img, color=None, label=None, line_thickness=None): # Plots one bounding box on image img tl = line_thickness or round(0.002 * (img.shape[0] + img.shape[1]) / 2) + 1 # line thickness color = color or [random.randint(0, 255) for _ in range(3)] c1, c2 = (int(x[0]), int(x[1])), (int(x[2]), int(x[3])) cv2.rectangle(img, c1, c2, color, thickness=tl) if label: tf = max(tl - 1, 1) # font thickness t_size = cv2.getTextSize(label, 0, fontScale=tl / 3, thickness=tf)[0] c2 = c1[0] + t_size[0], c1[1] - t_size[1] - 3 cv2.rectangle(img, c1, c2, color, -1) # filled cv2.putText(img, label, (c1[0], c1[1] - 2), 0, tl / 3, [225, 255, 255], thickness=tf, lineType=cv2.LINE_AA)
Example #2
Source File: utils.py From pruning_yolov3 with GNU General Public License v3.0 | 7 votes |
def plot_evolution_results(hyp): # from utils.utils import *; plot_evolution_results(hyp) # Plot hyperparameter evolution results in evolve.txt x = np.loadtxt('evolve.txt', ndmin=2) f = fitness(x) weights = (f - f.min()) ** 2 # for weighted results fig = plt.figure(figsize=(12, 10)) matplotlib.rc('font', **{'size': 8}) for i, (k, v) in enumerate(hyp.items()): y = x[:, i + 5] # mu = (y * weights).sum() / weights.sum() # best weighted result mu = y[f.argmax()] # best single result plt.subplot(4, 5, i + 1) plt.plot(mu, f.max(), 'o', markersize=10) plt.plot(y, f, '.') plt.title('%s = %.3g' % (k, mu), fontdict={'size': 9}) # limit to 40 characters print('%15s: %.3g' % (k, mu)) fig.tight_layout() plt.savefig('evolve.png', dpi=200)
Example #3
Source File: bbox.py From easy-faster-rcnn.pytorch with MIT License | 7 votes |
def iou(source: Tensor, other: Tensor) -> Tensor: source, other = source.unsqueeze(dim=-2).repeat(1, 1, other.shape[-2], 1), \ other.unsqueeze(dim=-3).repeat(1, source.shape[-2], 1, 1) source_area = (source[..., 2] - source[..., 0]) * (source[..., 3] - source[..., 1]) other_area = (other[..., 2] - other[..., 0]) * (other[..., 3] - other[..., 1]) intersection_left = torch.max(source[..., 0], other[..., 0]) intersection_top = torch.max(source[..., 1], other[..., 1]) intersection_right = torch.min(source[..., 2], other[..., 2]) intersection_bottom = torch.min(source[..., 3], other[..., 3]) intersection_width = torch.clamp(intersection_right - intersection_left, min=0) intersection_height = torch.clamp(intersection_bottom - intersection_top, min=0) intersection_area = intersection_width * intersection_height return intersection_area / (source_area + other_area - intersection_area)
Example #4
Source File: metric.py From torch-toolbox with BSD 3-Clause "New" or "Revised" License | 6 votes |
def get(self): """Get top cost recorded. You should call step before get at least once. Returns: A float number of cost. """ assert len(self.coll) != 0, 'Please call step before get' if self.type == 'mean': ret = np.mean(self.coll) elif self.type == 'max': ret = np.max(self.coll) else: ret = np.min(self.coll) return ret
Example #5
Source File: model2.py From controllable-text-attribute-transfer with Apache License 2.0 | 6 votes |
def greedy_decode(self, latent, max_len, start_id): ''' latent: (batch_size, max_src_seq, d_model) src_mask: (batch_size, 1, max_src_len) ''' batch_size = latent.size(0) ys = get_cuda(torch.ones(batch_size, 1).fill_(start_id).long()) # (batch_size, 1) for i in range(max_len - 1): # input("==========") # print("="*10, i) # print("ys", ys.size()) # (batch_size, i) # print("tgt_mask", subsequent_mask(ys.size(1)).size()) # (1, i, i) out = self.decode(latent.unsqueeze(1), to_var(ys), to_var(subsequent_mask(ys.size(1)).long())) prob = self.generator(out[:, -1]) # print("prob", prob.size()) # (batch_size, vocab_size) _, next_word = torch.max(prob, dim=1) # print("next_word", next_word.size()) # (batch_size) # print("next_word.unsqueeze(1)", next_word.unsqueeze(1).size()) ys = torch.cat([ys, next_word.unsqueeze(1)], dim=1) # print("ys", ys.size()) return ys[:, 1:]
Example #6
Source File: model_utils.py From medicaldetectiontoolkit with Apache License 2.0 | 6 votes |
def shem(roi_probs_neg, negative_count, ohem_poolsize): """ stochastic hard example mining: from a list of indices (referring to non-matched predictions), determine a pool of highest scoring (worst false positives) of size negative_count*ohem_poolsize. Then, sample n (= negative_count) predictions of this pool as negative examples for loss. :param roi_probs_neg: tensor of shape (n_predictions, n_classes). :param negative_count: int. :param ohem_poolsize: int. :return: (negative_count). indices refer to the positions in roi_probs_neg. If pool smaller than expected due to limited negative proposals availabel, this function will return sampled indices of number < negative_count without throwing an error. """ # sort according to higehst foreground score. probs, order = roi_probs_neg[:, 1:].max(1)[0].sort(descending=True) select = torch.tensor((ohem_poolsize * int(negative_count), order.size()[0])).min().int() pool_indices = order[:select] rand_idx = torch.randperm(pool_indices.size()[0]) return pool_indices[rand_idx[:negative_count].cuda()]
Example #7
Source File: model2.py From controllable-text-attribute-transfer with Apache License 2.0 | 6 votes |
def greedy_decode(self, latent, max_len, start_id): ''' latent: (batch_size, max_src_seq, d_model) src_mask: (batch_size, 1, max_src_len) ''' batch_size = latent.size(0) ys = get_cuda(torch.ones(batch_size, 1).fill_(start_id).long()) # (batch_size, 1) for i in range(max_len - 1): # input("==========") # print("="*10, i) # print("ys", ys.size()) # (batch_size, i) # print("tgt_mask", subsequent_mask(ys.size(1)).size()) # (1, i, i) out = self.decode(latent.unsqueeze(1), to_var(ys), to_var(subsequent_mask(ys.size(1)).long())) prob = self.generator(out[:, -1]) # print("prob", prob.size()) # (batch_size, vocab_size) _, next_word = torch.max(prob, dim=1) # print("next_word", next_word.size()) # (batch_size) # print("next_word.unsqueeze(1)", next_word.unsqueeze(1).size()) ys = torch.cat([ys, next_word.unsqueeze(1)], dim=1) # print("ys", ys.size()) return ys[:, 1:]
Example #8
Source File: model2.py From controllable-text-attribute-transfer with Apache License 2.0 | 6 votes |
def greedy_decode(self, latent, max_len, start_id): ''' latent: (batch_size, max_src_seq, d_model) src_mask: (batch_size, 1, max_src_len) ''' batch_size = latent.size(0) ys = get_cuda(torch.ones(batch_size, 1).fill_(start_id).long()) # (batch_size, 1) for i in range(max_len - 1): # input("==========") # print("="*10, i) # print("ys", ys.size()) # (batch_size, i) # print("tgt_mask", subsequent_mask(ys.size(1)).size()) # (1, i, i) out = self.decode(latent.unsqueeze(1), to_var(ys), to_var(subsequent_mask(ys.size(1)).long())) prob = self.generator(out[:, -1]) # print("prob", prob.size()) # (batch_size, vocab_size) _, next_word = torch.max(prob, dim=1) # print("next_word", next_word.size()) # (batch_size) # print("next_word.unsqueeze(1)", next_word.unsqueeze(1).size()) ys = torch.cat([ys, next_word.unsqueeze(1)], dim=1) # print("ys", ys.size()) return ys[:, 1:]
Example #9
Source File: kaldi.py From audio with BSD 2-Clause "Simplified" License | 6 votes |
def _get_waveform_and_window_properties(waveform: Tensor, channel: int, sample_frequency: float, frame_shift: float, frame_length: float, round_to_power_of_two: bool, preemphasis_coefficient: float) -> Tuple[Tensor, int, int, int]: r"""Gets the waveform and window properties """ channel = max(channel, 0) assert channel < waveform.size(0), ('Invalid channel %d for size %d' % (channel, waveform.size(0))) waveform = waveform[channel, :] # size (n) window_shift = int(sample_frequency * frame_shift * MILLISECONDS_TO_SECONDS) window_size = int(sample_frequency * frame_length * MILLISECONDS_TO_SECONDS) padded_window_size = _next_power_of_2(window_size) if round_to_power_of_two else window_size assert 2 <= window_size <= len(waveform), ('choose a window size %d that is [2, %d]' % (window_size, len(waveform))) assert 0 < window_shift, '`window_shift` must be greater than 0' assert padded_window_size % 2 == 0, 'the padded `window_size` must be divisible by two.' \ ' use `round_to_power_of_two` or change `frame_length`' assert 0. <= preemphasis_coefficient <= 1.0, '`preemphasis_coefficient` must be between [0,1]' assert sample_frequency > 0, '`sample_frequency` must be greater than zero' return waveform, window_shift, window_size, padded_window_size
Example #10
Source File: main.py From slot-filling with MIT License | 6 votes |
def do_eval(model, test_loader, cuda): model.is_training = False predicted = [] true_label = [] for X, y in test_loader: X = Variable(X) if cuda: X = X.cuda() output = model(X) output = output.squeeze(0) _, output = torch.max(output, 1) if cuda: output = output.cpu() predicted.extend(output.data.numpy().tolist()) y = y.squeeze(0) true_label.extend(y.numpy().tolist()) print("Acc: %.3f" % accuracy(predicted, true_label)) return predicted
Example #11
Source File: deeplab_resnet_2D.py From pytorch-mri-segmentation-3D with MIT License | 6 votes |
def forward(self,x): input_size = x.size()[2] self.interp1 = nn.UpsamplingBilinear2d(size = ( int(input_size*0.75)+1, int(input_size*0.75)+1 )) self.interp2 = nn.UpsamplingBilinear2d(size = ( int(input_size*0.5)+1, int(input_size*0.5)+1 )) self.interp3 = nn.UpsamplingBilinear2d(size = ( outS(input_size), outS(input_size) )) out = [] x2 = self.interp1(x) x3 = self.interp2(x) out.append(self.Scale(x)) #1.0x out.append(self.interp3(self.Scale(x2))) #0.75x out.append(self.interp3(self.Scale(x3))) #0.5x #out.append(self.Scale(x3)) # for 0.5x scale x2Out_interp = out[1] x3Out_interp = out[2] temp1 = torch.max(out[0],x2Out_interp) out.append(torch.max(temp1,x3Out_interp)) return out
Example #12
Source File: functional.py From torch-toolbox with BSD 3-Clause "New" or "Revised" License | 6 votes |
def evo_norm(x, prefix, running_var, v, weight, bias, training, momentum, eps=0.1, groups=32): if prefix == 'b0': if training: var = torch.var(x, dim=(0, 2, 3), keepdim=True) running_var.mul_(momentum) running_var.add_((1 - momentum) * var) else: var = running_var if v is not None: den = torch.max((var + eps).sqrt(), v * x + instance_std(x, eps)) x = x / den * weight + bias else: x = x * weight + bias else: if v is not None: x = x * torch.sigmoid(v * x) / group_std(x, groups, eps) * weight + bias else: x = x * weight + bias return x
Example #13
Source File: main.py From transferlearning with MIT License | 6 votes |
def test(model, target_test_loader): model.eval() test_loss = utils.AverageMeter() correct = 0 criterion = torch.nn.CrossEntropyLoss() len_target_dataset = len(target_test_loader.dataset) with torch.no_grad(): for data, target in target_test_loader: data, target = data.to(DEVICE), target.to(DEVICE) s_output = model.predict(data) loss = criterion(s_output, target) test_loss.update(loss.item()) pred = torch.max(s_output, 1)[1] correct += torch.sum(pred == target) print('{} --> {}: max correct: {}, accuracy{: .2f}%\n'.format( source_name, target_name, correct, 100. * correct / len_target_dataset))
Example #14
Source File: main.py From transferlearning with MIT License | 6 votes |
def extract_feature(model, dataloader, save_path, load_from_disk=True, model_path=''): if load_from_disk: model = models.Network(base_net=args.model_name, n_class=args.num_class) model.load_state_dict(torch.load(model_path)) model = model.to(DEVICE) model.eval() correct = 0 fea_all = torch.zeros(1,1+model.base_network.output_num()).to(DEVICE) with torch.no_grad(): for inputs, labels in dataloader: inputs, labels = inputs.to(DEVICE), labels.to(DEVICE) feas = model.get_features(inputs) labels = labels.view(labels.size(0), 1).float() x = torch.cat((feas, labels), dim=1) fea_all = torch.cat((fea_all, x), dim=0) outputs = model(inputs) preds = torch.max(outputs, 1)[1] correct += torch.sum(preds == labels.data.long()) test_acc = correct.double() / len(dataloader.dataset) fea_numpy = fea_all.cpu().numpy() np.savetxt(save_path, fea_numpy[1:], fmt='%.6f', delimiter=',') print('Test acc: %f' % test_acc) # You may want to classify with 1nn after getting features
Example #15
Source File: metrics.py From dogTorch with MIT License | 6 votes |
def record_output(self, output, output_indices, target, prev_absolutes, next_absolutes, batch_size=1): assert output.dim() == 4 assert target.dim() == 3 _, predictions = output.max(3) # Compute per class accuracy for unbalanced data. sequence_length = output.size(1) num_label = output.size(2) num_class = output.size(3) correct_alljoint = (target == predictions).float().sum(2) sum_of_corrects = correct_alljoint.sum(1) max_value = num_label * sequence_length count_correct = (sum_of_corrects == max_value).float().mean() correct_per_seq = ((correct_alljoint == num_label - 1).sum(1).float() / sequence_length).mean() self.meter.update( torch.Tensor([count_correct * 100, correct_per_seq * 100]), batch_size)
Example #16
Source File: utils.py From pruning_yolov3 with GNU General Public License v3.0 | 6 votes |
def crop_images_random(path='../images/', scale=0.50): # from utils.utils import *; crop_images_random() # crops images into random squares up to scale fraction # WARNING: overwrites images! for file in tqdm(sorted(glob.glob('%s/*.*' % path))): img = cv2.imread(file) # BGR if img is not None: h, w = img.shape[:2] # create random mask a = 30 # minimum size (pixels) mask_h = random.randint(a, int(max(a, h * scale))) # mask height mask_w = mask_h # mask width # box xmin = max(0, random.randint(0, w) - mask_w // 2) ymin = max(0, random.randint(0, h) - mask_h // 2) xmax = min(w, xmin + mask_w) ymax = min(h, ymin + mask_h) # apply random color mask cv2.imwrite(file, img[ymin:ymax, xmin:xmax])
Example #17
Source File: model_utils.py From medicaldetectiontoolkit with Apache License 2.0 | 5 votes |
def bbox_overlaps_3D(boxes1, boxes2): """Computes IoU overlaps between two sets of boxes. boxes1, boxes2: [N, (y1, x1, y2, x2, z1, z2)]. """ # 1. Tile boxes2 and repeate boxes1. This allows us to compare # every boxes1 against every boxes2 without loops. # TF doesn't have an equivalent to np.repeate() so simulate it # using tf.tile() and tf.reshape. boxes1_repeat = boxes2.size()[0] boxes2_repeat = boxes1.size()[0] boxes1 = boxes1.repeat(1,boxes1_repeat).view(-1,6) boxes2 = boxes2.repeat(boxes2_repeat,1) # 2. Compute intersections b1_y1, b1_x1, b1_y2, b1_x2, b1_z1, b1_z2 = boxes1.chunk(6, dim=1) b2_y1, b2_x1, b2_y2, b2_x2, b2_z1, b2_z2 = boxes2.chunk(6, dim=1) y1 = torch.max(b1_y1, b2_y1)[:, 0] x1 = torch.max(b1_x1, b2_x1)[:, 0] y2 = torch.min(b1_y2, b2_y2)[:, 0] x2 = torch.min(b1_x2, b2_x2)[:, 0] z1 = torch.max(b1_z1, b2_z1)[:, 0] z2 = torch.min(b1_z2, b2_z2)[:, 0] zeros = Variable(torch.zeros(y1.size()[0]), requires_grad=False) if y1.is_cuda: zeros = zeros.cuda() intersection = torch.max(x2 - x1, zeros) * torch.max(y2 - y1, zeros) * torch.max(z2 - z1, zeros) # 3. Compute unions b1_volume = (b1_y2 - b1_y1) * (b1_x2 - b1_x1) * (b1_z2 - b1_z1) b2_volume = (b2_y2 - b2_y1) * (b2_x2 - b2_x1) * (b2_z2 - b2_z1) union = b1_volume[:,0] + b2_volume[:,0] - intersection # 4. Compute IoU and reshape to [boxes1, boxes2] iou = intersection / union overlaps = iou.view(boxes2_repeat, boxes1_repeat) return overlaps
Example #18
Source File: metric.py From torch-toolbox with BSD 3-Clause "New" or "Revised" License | 5 votes |
def __init__(self, name=None, record_type='mean'): super(NumericalCost, self).__init__(name) self.coll = [] self.type = record_type assert record_type in ('mean', 'max', 'min')
Example #19
Source File: mrcnn.py From medicaldetectiontoolkit with Apache License 2.0 | 5 votes |
def compute_rpn_class_loss(rpn_match, rpn_class_logits, shem_poolsize): """ :param rpn_match: (n_anchors). [-1, 0, 1] for negative, neutral, and positive matched anchors. :param rpn_class_logits: (n_anchors, 2). logits from RPN classifier. :param shem_poolsize: int. factor of top-k candidates to draw from per negative sample (stochastic-hard-example-mining). :return: loss: torch tensor :return: np_neg_ix: 1D array containing indices of the neg_roi_logits, which have been sampled for training. """ # filter out neutral anchors. pos_indices = torch.nonzero(rpn_match == 1) neg_indices = torch.nonzero(rpn_match == -1) # loss for positive samples if 0 not in pos_indices.size(): pos_indices = pos_indices.squeeze(1) roi_logits_pos = rpn_class_logits[pos_indices] pos_loss = F.cross_entropy(roi_logits_pos, torch.LongTensor([1] * pos_indices.shape[0]).cuda()) else: pos_loss = torch.FloatTensor([0]).cuda() # loss for negative samples: draw hard negative examples (SHEM) # that match the number of positive samples, but at least 1. if 0 not in neg_indices.size(): neg_indices = neg_indices.squeeze(1) roi_logits_neg = rpn_class_logits[neg_indices] negative_count = np.max((1, pos_indices.cpu().data.numpy().size)) roi_probs_neg = F.softmax(roi_logits_neg, dim=1) neg_ix = mutils.shem(roi_probs_neg, negative_count, shem_poolsize) neg_loss = F.cross_entropy(roi_logits_neg[neg_ix], torch.LongTensor([0] * neg_ix.shape[0]).cuda()) np_neg_ix = neg_ix.cpu().data.numpy() else: neg_loss = torch.FloatTensor([0]).cuda() np_neg_ix = np.array([]).astype('int32') loss = (pos_loss + neg_loss) / 2 return loss, np_neg_ix
Example #20
Source File: utils.py From pruning_yolov3 with GNU General Public License v3.0 | 5 votes |
def bbox_iou(box1, box2, x1y1x2y2=True, GIoU=False): # Returns the IoU of box1 to box2. box1 is 4, box2 is nx4 box2 = box2.t() # Get the coordinates of bounding boxes if x1y1x2y2: # x1, y1, x2, y2 = box1 b1_x1, b1_y1, b1_x2, b1_y2 = box1[0], box1[1], box1[2], box1[3] b2_x1, b2_y1, b2_x2, b2_y2 = box2[0], box2[1], box2[2], box2[3] else: # x, y, w, h = box1 b1_x1, b1_x2 = box1[0] - box1[2] / 2, box1[0] + box1[2] / 2 b1_y1, b1_y2 = box1[1] - box1[3] / 2, box1[1] + box1[3] / 2 b2_x1, b2_x2 = box2[0] - box2[2] / 2, box2[0] + box2[2] / 2 b2_y1, b2_y2 = box2[1] - box2[3] / 2, box2[1] + box2[3] / 2 # Intersection area inter_area = (torch.min(b1_x2, b2_x2) - torch.max(b1_x1, b2_x1)).clamp(0) * \ (torch.min(b1_y2, b2_y2) - torch.max(b1_y1, b2_y1)).clamp(0) # Union Area union_area = ((b1_x2 - b1_x1) * (b1_y2 - b1_y1) + 1e-16) + \ (b2_x2 - b2_x1) * (b2_y2 - b2_y1) - inter_area iou = inter_area / union_area # iou if GIoU: # Generalized IoU https://arxiv.org/pdf/1902.09630.pdf c_x1, c_x2 = torch.min(b1_x1, b2_x1), torch.max(b1_x2, b2_x2) c_y1, c_y2 = torch.min(b1_y1, b2_y1), torch.max(b1_y2, b2_y2) c_area = (c_x2 - c_x1) * (c_y2 - c_y1) + 1e-16 # convex area return iou - (c_area - union_area) / c_area # GIoU return iou
Example #21
Source File: model_utils.py From medicaldetectiontoolkit with Apache License 2.0 | 5 votes |
def bbox_overlaps_2D(boxes1, boxes2): """Computes IoU overlaps between two sets of boxes. boxes1, boxes2: [N, (y1, x1, y2, x2)]. """ # 1. Tile boxes2 and repeate boxes1. This allows us to compare # every boxes1 against every boxes2 without loops. # TF doesn't have an equivalent to np.repeate() so simulate it # using tf.tile() and tf.reshape. boxes1_repeat = boxes2.size()[0] boxes2_repeat = boxes1.size()[0] boxes1 = boxes1.repeat(1,boxes1_repeat).view(-1,4) boxes2 = boxes2.repeat(boxes2_repeat,1) # 2. Compute intersections b1_y1, b1_x1, b1_y2, b1_x2 = boxes1.chunk(4, dim=1) b2_y1, b2_x1, b2_y2, b2_x2 = boxes2.chunk(4, dim=1) y1 = torch.max(b1_y1, b2_y1)[:, 0] x1 = torch.max(b1_x1, b2_x1)[:, 0] y2 = torch.min(b1_y2, b2_y2)[:, 0] x2 = torch.min(b1_x2, b2_x2)[:, 0] zeros = Variable(torch.zeros(y1.size()[0]), requires_grad=False) if y1.is_cuda: zeros = zeros.cuda() intersection = torch.max(x2 - x1, zeros) * torch.max(y2 - y1, zeros) # 3. Compute unions b1_area = (b1_y2 - b1_y1) * (b1_x2 - b1_x1) b2_area = (b2_y2 - b2_y1) * (b2_x2 - b2_x1) union = b1_area[:,0] + b2_area[:,0] - intersection # 4. Compute IoU and reshape to [boxes1, boxes2] iou = intersection / union overlaps = iou.view(boxes2_repeat, boxes1_repeat) return overlaps
Example #22
Source File: bbox.py From easy-faster-rcnn.pytorch with MIT License | 5 votes |
def clip(bboxes: Tensor, left: float, top: float, right: float, bottom: float) -> Tensor: bboxes[..., [0, 2]] = bboxes[..., [0, 2]].clamp(min=left, max=right) bboxes[..., [1, 3]] = bboxes[..., [1, 3]].clamp(min=top, max=bottom) return bboxes
Example #23
Source File: metrics.py From dogTorch with MIT License | 5 votes |
def record_output(self, output, output_indices, target, prev_absolute_imu, next_absolute_imu, batch_size=1): prediction = torch.max(output, 1)[1] success = torch.sum((prediction == target).float()) / len(prediction) self.meter.update(success * 100, batch_size)
Example #24
Source File: metrics.py From dogTorch with MIT License | 5 votes |
def record_output(self, output, output_indices, target, prev_absolute_imu, next_absolute_imu, batch_size=1): if self.args.no_angle_metric: return [] prev_absolute_imu = prev_absolute_imu[:, output_indices] next_absolute_imu = next_absolute_imu[:, output_indices] assert output.dim() == 4 if self.regression: # Output is the vectors itself. relative_imus = output else: output = torch.max(output, -1)[1] #get labels from vectors relative_imus = self.get_diff_from_initial(output) if self.absolute_regress: resulting_imus = output else: resulting_imus = self.inverse_subtract(prev_absolute_imu, relative_imus) angle_diff = self.get_angle_diff(next_absolute_imu, resulting_imus) whole_diff = self.get_angle_diff(next_absolute_imu[:, 0:1, :, :], next_absolute_imu[:, -1:, :, :]) self.stats.append([whole_diff, angle_diff.mean()]) self.outputs.append(output) self.targets.append(target) degree = angle_diff * 180 / math.pi self.meter.update(degree, batch_size) return resulting_imus
Example #25
Source File: metrics.py From dogTorch with MIT License | 5 votes |
def record_output(self, output, output_indices, target, prev_absolutes, next_absolutes, batch_size=1): assert output.dim() == 4 assert target.dim() == 3 _, predictions = output.max(3) # Compute per class accuracy for unbalanced data. sequence_length = output.size(1) num_label = output.size(2) num_class = output.size(3) if self.confusion is None: # Confusion matrix is 4D because it's defined per label and sequence # element. self.confusion = torch.zeros(sequence_length, num_label, num_class, num_class) # Compute per class accuracy in this batch and update the confusion # matrix. per_class_acc = [] for seq_id in range(sequence_length): for imu_id in range(num_label): imu_target = target[:, seq_id, imu_id].contiguous() imu_preds = predictions[:, seq_id, imu_id].contiguous() for label, pred in zip(imu_target.view(-1), imu_preds.view(-1)): self.confusion[seq_id, imu_id, label, pred] += 1.0 for class_id in range(num_class): # Look at targets where label is class_id, and see what # percentage of predictions are class_id. preds_for_class = imu_preds[imu_target == class_id] if len(preds_for_class) > 0: per_class_acc.append( (preds_for_class == class_id).float().mean()) per_class_acc = sum(per_class_acc) / len(per_class_acc) accuracy = (predictions == target).float().mean() self.meter.update( torch.Tensor([100 * accuracy, 100 * per_class_acc]), batch_size)
Example #26
Source File: test_compliance_kaldi.py From audio with BSD 2-Clause "Simplified" License | 5 votes |
def _print_diagnostic(self, output, expect_output): # given an output and expected output, it will print the absolute/relative errors (max and mean squared) abs_error = output - expect_output abs_mse = abs_error.pow(2).sum() / output.numel() abs_max_error = torch.max(abs_error.abs()) relative_error = abs_error / expect_output relative_mse = relative_error.pow(2).sum() / output.numel() relative_max_error = torch.max(relative_error.abs()) print('abs_mse:', abs_mse.item(), 'abs_max_error:', abs_max_error.item()) print('relative_mse:', relative_mse.item(), 'relative_max_error:', relative_max_error.item())
Example #27
Source File: ctc_decoder.py From LipNet-PyTorch with BSD 3-Clause "New" or "Revised" License | 5 votes |
def decode_greedy(self, logits, seq_lens): decoded = [] tlogits = logits.transpose(0, 1) _, tokens = torch.max(tlogits, 2) for i in range(tlogits.size(0)): output_str = self.convert_to_string(tokens[i], seq_lens[i]) decoded.append(output_str) return decoded
Example #28
Source File: kaldi.py From audio with BSD 2-Clause "Simplified" License | 5 votes |
def _get_log_energy(strided_input: Tensor, epsilon: Tensor, energy_floor: float) -> Tensor: r"""Returns the log energy of size (m) for a strided_input (m,*) """ device, dtype = strided_input.device, strided_input.dtype log_energy = torch.max(strided_input.pow(2).sum(1), epsilon).log() # size (m) if energy_floor == 0.0: return log_energy return torch.max( log_energy, torch.tensor(math.log(energy_floor), device=device, dtype=dtype))
Example #29
Source File: functional.py From audio with BSD 2-Clause "Simplified" License | 5 votes |
def amplitude_to_DB( x: Tensor, multiplier: float, amin: float, db_multiplier: float, top_db: Optional[float] = None ) -> Tensor: r"""Turn a tensor from the power/amplitude scale to the decibel scale. This output depends on the maximum value in the input tensor, and so may return different values for an audio clip split into snippets vs. a a full clip. Args: x (Tensor): Input tensor before being converted to decibel scale multiplier (float): Use 10. for power and 20. for amplitude amin (float): Number to clamp ``x`` db_multiplier (float): Log10(max(reference value and amin)) top_db (float or None, optional): Minimum negative cut-off in decibels. A reasonable number is 80. (Default: ``None``) Returns: Tensor: Output tensor in decibel scale """ x_db = multiplier * torch.log10(torch.clamp(x, min=amin)) x_db -= multiplier * db_multiplier if top_db is not None: x_db = x_db.clamp(min=x_db.max().item() - top_db) return x_db
Example #30
Source File: roi_pool_py.py From cascade-rcnn_Pytorch with MIT License | 5 votes |
def forward(self, features, rois): batch_size, num_channels, data_height, data_width = features.size() num_rois = rois.size()[0] outputs = Variable(torch.zeros(num_rois, num_channels, self.pooled_height, self.pooled_width)).cuda() for roi_ind, roi in enumerate(rois): batch_ind = int(roi[0].data[0]) roi_start_w, roi_start_h, roi_end_w, roi_end_h = np.round( roi[1:].data.cpu().numpy() * self.spatial_scale).astype(int) roi_width = max(roi_end_w - roi_start_w + 1, 1) roi_height = max(roi_end_h - roi_start_h + 1, 1) bin_size_w = float(roi_width) / float(self.pooled_width) bin_size_h = float(roi_height) / float(self.pooled_height) for ph in range(self.pooled_height): hstart = int(np.floor(ph * bin_size_h)) hend = int(np.ceil((ph + 1) * bin_size_h)) hstart = min(data_height, max(0, hstart + roi_start_h)) hend = min(data_height, max(0, hend + roi_start_h)) for pw in range(self.pooled_width): wstart = int(np.floor(pw * bin_size_w)) wend = int(np.ceil((pw + 1) * bin_size_w)) wstart = min(data_width, max(0, wstart + roi_start_w)) wend = min(data_width, max(0, wend + roi_start_w)) is_empty = (hend <= hstart) or(wend <= wstart) if is_empty: outputs[roi_ind, :, ph, pw] = 0 else: data = features[batch_ind] outputs[roi_ind, :, ph, pw] = torch.max( torch.max(data[:, hstart:hend, wstart:wend], 1)[0], 2)[0].view(-1) return outputs