Python torch.clamp() Examples
The following are 30
code examples of torch.clamp().
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: 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 #2
Source File: transforms.py From audio with BSD 2-Clause "Simplified" License | 7 votes |
def forward(self, waveform: Tensor) -> Tensor: r""" Args: waveform (Tensor): Tensor of audio of dimension (..., time). Returns: Tensor: Tensor of audio of dimension (..., time). """ if self.gain_type == "amplitude": waveform = waveform * self.gain if self.gain_type == "db": waveform = F.gain(waveform, self.gain) if self.gain_type == "power": waveform = F.gain(waveform, 10 * math.log10(self.gain)) return torch.clamp(waveform, -1, 1)
Example #3
Source File: networks.py From connecting_the_dots with MIT License | 6 votes |
def tforward(self, disp, edge=None): self.sobel=self.sobel.to(disp.device) if edge is not None: grad = self.sobel(disp) grad = torch.sqrt(grad[:,0:1,...]**2 + grad[:,1:2,...]**2 + 1e-8) pdf = (1-edge)/self.b0 * torch.exp(-torch.abs(grad)/self.b0) + \ edge/self.b1 * torch.exp(-torch.abs(grad)/self.b1) val = torch.mean(-torch.log(pdf.clamp(min=1e-4))) else: # on qifeng's data we don't have ambient info # therefore we supress edge everywhere grad = self.sobel(disp) grad = torch.sqrt(grad[:,0:1,...]**2 + grad[:,1:2,...]**2 + 1e-8) grad= torch.clamp(grad, 0, 1.0) val = torch.mean(grad) return val
Example #4
Source File: nn_distance.py From H3DNet with MIT License | 6 votes |
def huber_loss(error, delta=1.0): """ Args: error: Torch tensor (d1,d2,...,dk) Returns: loss: Torch tensor (d1,d2,...,dk) x = error = pred - gt or dist(pred,gt) 0.5 * |x|^2 if |x|<=d 0.5 * d^2 + d * (|x|-d) if |x|>d Ref: https://github.com/charlesq34/frustum-pointnets/blob/master/models/model_util.py """ abs_error = torch.abs(error) #quadratic = torch.min(abs_error, torch.FloatTensor([delta])) quadratic = torch.clamp(abs_error, max=delta) linear = (abs_error - quadratic) loss = 0.5 * quadratic**2 + delta * linear return loss
Example #5
Source File: torch.py From yolo2-pytorch with GNU Lesser General Public License v3.0 | 6 votes |
def intersection_area(yx_min1, yx_max1, yx_min2, yx_max2): """ Calculates the intersection area of two lists of bounding boxes. :author 申瑞珉 (Ruimin Shen) :param yx_min1: The top left coordinates (y, x) of the first list (size [N1, 2]) of bounding boxes. :param yx_max1: The bottom right coordinates (y, x) of the first list (size [N1, 2]) of bounding boxes. :param yx_min2: The top left coordinates (y, x) of the second list (size [N2, 2]) of bounding boxes. :param yx_max2: The bottom right coordinates (y, x) of the second list (size [N2, 2]) of bounding boxes. :return: The matrix (size [N1, N2]) of the intersection area. """ ymin1, xmin1 = torch.split(yx_min1, 1, -1) ymax1, xmax1 = torch.split(yx_max1, 1, -1) ymin2, xmin2 = torch.split(yx_min2, 1, -1) ymax2, xmax2 = torch.split(yx_max2, 1, -1) max_ymin = torch.max(ymin1.repeat(1, ymin2.size(0)), torch.transpose(ymin2, 0, 1).repeat(ymin1.size(0), 1)) # PyTorch's bug min_ymax = torch.min(ymax1.repeat(1, ymax2.size(0)), torch.transpose(ymax2, 0, 1).repeat(ymax1.size(0), 1)) # PyTorch's bug height = torch.clamp(min_ymax - max_ymin, min=0) max_xmin = torch.max(xmin1.repeat(1, xmin2.size(0)), torch.transpose(xmin2, 0, 1).repeat(xmin1.size(0), 1)) # PyTorch's bug min_xmax = torch.min(xmax1.repeat(1, xmax2.size(0)), torch.transpose(xmax2, 0, 1).repeat(xmax1.size(0), 1)) # PyTorch's bug width = torch.clamp(min_xmax - max_xmin, min=0) return height * width
Example #6
Source File: box_utils.py From hand-detection.PyTorch with MIT License | 6 votes |
def intersect(box_a, box_b): """ We resize both tensors to [A,B,2] without new malloc: [A,2] -> [A,1,2] -> [A,B,2] [B,2] -> [1,B,2] -> [A,B,2] Then we compute the area of intersect between box_a and box_b. Args: box_a: (tensor) bounding boxes, Shape: [A,4]. box_b: (tensor) bounding boxes, Shape: [B,4]. Return: (tensor) intersection area, Shape: [A,B]. """ A = box_a.size(0) B = box_b.size(0) max_xy = torch.min(box_a[:, 2:].unsqueeze(1).expand(A, B, 2), box_b[:, 2:].unsqueeze(0).expand(A, B, 2)) min_xy = torch.max(box_a[:, :2].unsqueeze(1).expand(A, B, 2), box_b[:, :2].unsqueeze(0).expand(A, B, 2)) inter = torch.clamp((max_xy - min_xy), min=0) return inter[:, :, 0] * inter[:, :, 1]
Example #7
Source File: torch.py From yolo2-pytorch with GNU Lesser General Public License v3.0 | 6 votes |
def batch_intersection_area(yx_min1, yx_max1, yx_min2, yx_max2): """ Calculates the intersection area of two lists of bounding boxes for N independent batches. :author 申瑞珉 (Ruimin Shen) :param yx_min1: The top left coordinates (y, x) of the first lists (size [N, N1, 2]) of bounding boxes. :param yx_max1: The bottom right coordinates (y, x) of the first lists (size [N, N1, 2]) of bounding boxes. :param yx_min2: The top left coordinates (y, x) of the second lists (size [N, N2, 2]) of bounding boxes. :param yx_max2: The bottom right coordinates (y, x) of the second lists (size [N, N2, 2]) of bounding boxes. :return: The matrics (size [N, N1, N2]) of the intersection area. """ ymin1, xmin1 = torch.split(yx_min1, 1, -1) ymax1, xmax1 = torch.split(yx_max1, 1, -1) ymin2, xmin2 = torch.split(yx_min2, 1, -1) ymax2, xmax2 = torch.split(yx_max2, 1, -1) max_ymin = torch.max(ymin1.repeat(1, 1, ymin2.size(1)), torch.transpose(ymin2, 1, 2).repeat(1, ymin1.size(1), 1)) # PyTorch's bug min_ymax = torch.min(ymax1.repeat(1, 1, ymax2.size(1)), torch.transpose(ymax2, 1, 2).repeat(1, ymax1.size(1), 1)) # PyTorch's bug height = torch.clamp(min_ymax - max_ymin, min=0) max_xmin = torch.max(xmin1.repeat(1, 1, xmin2.size(1)), torch.transpose(xmin2, 1, 2).repeat(1, xmin1.size(1), 1)) # PyTorch's bug min_xmax = torch.min(xmax1.repeat(1, 1, xmax2.size(1)), torch.transpose(xmax2, 1, 2).repeat(1, xmax1.size(1), 1)) # PyTorch's bug width = torch.clamp(min_xmax - max_xmin, min=0) return height * width
Example #8
Source File: detection.py From seamseg with BSD 3-Clause "New" or "Revised" License | 6 votes |
def _split_and_clip(boxes, scores, index, valid_size): boxes_out, scores_out = [], [] for img_id, valid_size_i in enumerate(valid_size): idx = index == img_id if idx.any().item(): boxes_i = boxes[idx] boxes_i[:, :, [0, 2]] = torch.clamp(boxes_i[:, :, [0, 2]], min=0, max=valid_size_i[0]) boxes_i[:, :, [1, 3]] = torch.clamp(boxes_i[:, :, [1, 3]], min=0, max=valid_size_i[1]) boxes_out.append(boxes_i) scores_out.append(scores[idx]) else: boxes_out.append(None) scores_out.append(None) return boxes_out, scores_out
Example #9
Source File: eval_wrn_ebm.py From JEM with Apache License 2.0 | 6 votes |
def cond_samples(f, replay_buffer, args, device, fresh=False): sqrt = lambda x: int(t.sqrt(t.Tensor([x]))) plot = lambda p, x: tv.utils.save_image(t.clamp(x, -1, 1), p, normalize=True, nrow=sqrt(x.size(0))) if fresh: replay_buffer = uncond_samples(f, args, device, save=False) n_it = replay_buffer.size(0) // 100 all_y = [] for i in range(n_it): x = replay_buffer[i * 100: (i + 1) * 100].to(device) y = f.classify(x).max(1)[1] all_y.append(y) all_y = t.cat(all_y, 0) each_class = [replay_buffer[all_y == l] for l in range(10)] print([len(c) for c in each_class]) for i in range(100): this_im = [] for l in range(10): this_l = each_class[l][i * 10: (i + 1) * 10] this_im.append(this_l) this_im = t.cat(this_im, 0) if this_im.size(0) > 0: plot('{}/samples_{}.png'.format(args.save_dir, i), this_im) print(i)
Example #10
Source File: torch.py From yolo2-pytorch with GNU Lesser General Public License v3.0 | 6 votes |
def batch_iou_pair(yx_min1, yx_max1, yx_min2, yx_max2, min=float(np.finfo(np.float32).eps)): """ Pairwisely calculates the IoU of two lists (at the same size M) of bounding boxes for N independent batches. :author 申瑞珉 (Ruimin Shen) :param yx_min1: The top left coordinates (y, x) of the first lists (size [N, M, 2]) of bounding boxes. :param yx_max1: The bottom right coordinates (y, x) of the first lists (size [N, M, 2]) of bounding boxes. :param yx_min2: The top left coordinates (y, x) of the second lists (size [N, M, 2]) of bounding boxes. :param yx_max2: The bottom right coordinates (y, x) of the second lists (size [N, M, 2]) of bounding boxes. :return: The lists (size [N, M]) of the IoU. """ yx_min = torch.max(yx_min1, yx_min2) yx_max = torch.min(yx_max1, yx_max2) size = torch.clamp(yx_max - yx_min, min=0) intersect_area = torch.prod(size, -1) area1 = torch.prod(yx_max1 - yx_min1, -1) area2 = torch.prod(yx_max2 - yx_min2, -1) union_area = torch.clamp(area1 + area2 - intersect_area, min=min) return intersect_area / union_area
Example #11
Source File: box_utils.py From CSD-SSD with MIT License | 6 votes |
def intersect(box_a, box_b): """ We resize both tensors to [A,B,2] without new malloc: [A,2] -> [A,1,2] -> [A,B,2] [B,2] -> [1,B,2] -> [A,B,2] Then we compute the area of intersect between box_a and box_b. Args: box_a: (tensor) bounding boxes, Shape: [A,4]. box_b: (tensor) bounding boxes, Shape: [B,4]. Return: (tensor) intersection area, Shape: [A,B]. """ A = box_a.size(0) B = box_b.size(0) max_xy = torch.min(box_a[:, 2:].unsqueeze(1).expand(A, B, 2), box_b[:, 2:].unsqueeze(0).expand(A, B, 2)) min_xy = torch.max(box_a[:, :2].unsqueeze(1).expand(A, B, 2), box_b[:, :2].unsqueeze(0).expand(A, B, 2)) inter = torch.clamp((max_xy - min_xy), min=0) return inter[:, :, 0] * inter[:, :, 1]
Example #12
Source File: sil.py From ConvLab with MIT License | 6 votes |
def calc_sil_policy_val_loss(self, batch, pdparams): ''' Calculate the SIL policy losses for actor and critic sil_policy_loss = -log_prob * max(R - v_pred, 0) sil_val_loss = (max(R - v_pred, 0)^2) / 2 This is called on a randomly-sample batch from experience replay ''' v_preds = self.calc_v(batch['states'], use_cache=False) rets = math_util.calc_returns(batch['rewards'], batch['dones'], self.gamma) clipped_advs = torch.clamp(rets - v_preds, min=0.0) action_pd = policy_util.init_action_pd(self.body.ActionPD, pdparams) actions = batch['actions'] if self.body.env.is_venv: actions = math_util.venv_unpack(actions) log_probs = action_pd.log_prob(actions) sil_policy_loss = - self.sil_policy_loss_coef * (log_probs * clipped_advs).mean() sil_val_loss = self.sil_val_loss_coef * clipped_advs.pow(2).mean() / 2 logger.debug(f'SIL actor policy loss: {sil_policy_loss:g}') logger.debug(f'SIL critic value loss: {sil_val_loss:g}') return sil_policy_loss, sil_val_loss
Example #13
Source File: boxlist_ops.py From Parsing-R-CNN with MIT License | 6 votes |
def crop_by_box(masks, box, padding=0.0): n, h, w = masks.size() b_w = box[2] - box[0] b_h = box[3] - box[1] x1 = torch.clamp(box[0:1] - b_w * padding - 1, min=0) x2 = torch.clamp(box[2:3] + b_w * padding + 1, max=w - 1) y1 = torch.clamp(box[1:2] - b_h * padding - 1, min=0) y2 = torch.clamp(box[3:4] + b_h * padding + 1, max=h - 1) rows = torch.arange(w, device=masks.device, dtype=x1.dtype).view(1, 1, -1).expand(n, h, w) cols = torch.arange(h, device=masks.device, dtype=x1.dtype).view(1, -1, 1).expand(n, h, w) masks_left = rows >= x1.expand(n, 1, 1) masks_right = rows < x2.expand(n, 1, 1) masks_up = cols >= y1.expand(n, 1, 1) masks_down = cols < y2.expand(n, 1, 1) crop_mask = masks_left * masks_right * masks_up * masks_down return masks * crop_mask.float(), crop_mask
Example #14
Source File: boxlist_ops.py From Parsing-R-CNN with MIT License | 6 votes |
def boxes_to_masks(boxes, h, w, padding=0.0): n = boxes.shape[0] boxes = boxes x1 = boxes[:, 0] y1 = boxes[:, 1] x2 = boxes[:, 2] y2 = boxes[:, 3] b_w = x2 - x1 b_h = y2 - y1 x1 = torch.clamp(x1 - 1 - b_w * padding, min=0) x2 = torch.clamp(x2 + 1 + b_w * padding, max=w) y1 = torch.clamp(y1 - 1 - b_h * padding, min=0) y2 = torch.clamp(y2 + 1 + b_h * padding, max=h) rows = torch.arange(w, device=boxes.device, dtype=x1.dtype).view(1, 1, -1).expand(n, h, w) cols = torch.arange(h, device=boxes.device, dtype=x1.dtype).view(1, -1, 1).expand(n, h, w) masks_left = rows >= x1.view(-1, 1, 1) masks_right = rows < x2.view(-1, 1, 1) masks_up = cols >= y1.view(-1, 1, 1) masks_down = cols < y2.view(-1, 1, 1) masks = masks_left * masks_right * masks_up * masks_down return masks
Example #15
Source File: instance_seg.py From seamseg with BSD 3-Clause "New" or "Revised" License | 6 votes |
def _split_and_clip(boxes, scores, index, valid_size): boxes_out, scores_out = [], [] for img_id, valid_size_i in enumerate(valid_size): idx = index == img_id if idx.any().item(): boxes_i = boxes[idx] boxes_i[:, :, [0, 2]] = torch.clamp(boxes_i[:, :, [0, 2]], min=0, max=valid_size_i[0]) boxes_i[:, :, [1, 3]] = torch.clamp(boxes_i[:, :, [1, 3]], min=0, max=valid_size_i[1]) boxes_out.append(boxes_i) scores_out.append(scores[idx]) else: boxes_out.append(None) scores_out.append(None) return boxes_out, scores_out
Example #16
Source File: Losses.py From pneumothorax-segmentation with MIT License | 6 votes |
def forward(self, outputs, targets): loss = 0 weights = self.weights sigmoid_input = torch.sigmoid(outputs) for k, v in weights.items(): if not v: continue val = 0 if k in self.per_channel: channels = targets.size(1) for c in range(channels): if not self.channel_losses or k in self.channel_losses[c]: val += self.channel_weights[c] * self.mapping[k](sigmoid_input[:, c, ...] if k in self.expect_sigmoid else outputs[:, c, ...], targets[:, c, ...]) else: val = self.mapping[k](sigmoid_input if k in self.expect_sigmoid else outputs, targets) self.values[k] = val loss += self.weights[k] * val return loss.clamp(min=1e-5)
Example #17
Source File: networks.py From connecting_the_dots with MIT License | 6 votes |
def fwd(self, depth0, depth1, R0, t0, R1, t1): uv1, d1 = super().tforward(depth0, R0, t0, R1, t1) uv1[..., 0] = 2 * (uv1[..., 0] / (self.im_width-1) - 0.5) uv1[..., 1] = 2 * (uv1[..., 1] / (self.im_height-1) - 0.5) uv1 = uv1.view(-1, self.im_height, self.im_width, 2).clone() depth10 = torch.nn.functional.grid_sample(depth1, uv1, padding_mode='border') diff = torch.abs(d1.view(-1) - depth10.view(-1)) if self.clamp > 0: diff = torch.clamp(diff, 0, self.clamp) # return diff without clamping for debugging return diff.mean()
Example #18
Source File: box_utils.py From ssds.pytorch with MIT License | 6 votes |
def intersect(box_a, box_b): """ We resize both tensors to [A,B,2] without new malloc: [A,2] -> [A,1,2] -> [A,B,2] [B,2] -> [1,B,2] -> [A,B,2] Then we compute the area of intersect between box_a and box_b. Args: box_a: (tensor) bounding boxes, Shape: [A,4]. box_b: (tensor) bounding boxes, Shape: [B,4]. Return: (tensor) intersection area, Shape: [A,B]. """ A = box_a.size(0) B = box_b.size(0) max_xy = torch.min(box_a[:, 2:].unsqueeze(1).expand(A, B, 2), box_b[:, 2:].unsqueeze(0).expand(A, B, 2)) min_xy = torch.max(box_a[:, :2].unsqueeze(1).expand(A, B, 2), box_b[:, :2].unsqueeze(0).expand(A, B, 2)) inter = torch.clamp((max_xy - min_xy), min=0) return inter[:, :, 0] * inter[:, :, 1]
Example #19
Source File: modules.py From BAMnet with Apache License 2.0 | 6 votes |
def enc_ans_features(self, x_type_bow, x_types, x_type_bow_len, x_path_bow, x_paths, x_path_bow_len, x_ctx_ents, x_ctx_ent_len, x_ctx_ent_num): ''' x_types: answer type x_paths: answer path, i.e., bow of relation x_ctx_ents: answer context, i.e., bow of entity words, (batch_size, num_cands, num_ctx, L) ''' # ans_types = torch.mean(self.ent_type_embed(x_types.view(-1, x_types.size(-1))), 1).view(x_types.size(0), x_types.size(1), -1) ans_type_bow = (self.lstm_enc_type(x_type_bow.view(-1, x_type_bow.size(-1)), x_type_bow_len.view(-1))[1]).view(x_type_bow.size(0), x_type_bow.size(1), -1) ans_path_bow = (self.lstm_enc_path(x_path_bow.view(-1, x_path_bow.size(-1)), x_path_bow_len.view(-1))[1]).view(x_path_bow.size(0), x_path_bow.size(1), -1) ans_paths = torch.mean(self.relation_embed(x_paths.view(-1, x_paths.size(-1))), 1).view(x_paths.size(0), x_paths.size(1), -1) # Avg over ctx ctx_num_mask = create_mask(x_ctx_ent_num.view(-1), x_ctx_ents.size(2), self.use_cuda).view(x_ctx_ent_num.shape + (-1,)) ans_ctx_ent = (self.lstm_enc_ctx(x_ctx_ents.view(-1, x_ctx_ents.size(-1)), x_ctx_ent_len.view(-1))[1]).view(x_ctx_ents.size(0), x_ctx_ents.size(1), x_ctx_ents.size(2), -1) ans_ctx_ent = ctx_num_mask.unsqueeze(-1) * ans_ctx_ent ans_ctx_ent = torch.sum(ans_ctx_ent, dim=2) / torch.clamp(x_ctx_ent_num.float().unsqueeze(-1), min=VERY_SMALL_NUMBER) if self.ans_enc_dropout: # ans_types = F.dropout(ans_types, p=self.ans_enc_dropout, training=self.training) ans_type_bow = F.dropout(ans_type_bow, p=self.ans_enc_dropout, training=self.training) ans_path_bow = F.dropout(ans_path_bow, p=self.ans_enc_dropout, training=self.training) ans_paths = F.dropout(ans_paths, p=self.ans_enc_dropout, training=self.training) ans_ctx_ent = F.dropout(ans_ctx_ent, p=self.ans_enc_dropout, training=self.training) return ans_type_bow, None, ans_path_bow, ans_paths, ans_ctx_ent
Example #20
Source File: DDPAE.py From DDPAE-video-prediction with MIT License | 6 votes |
def test(self, input, output): ''' Return decoded output. ''' input = Variable(input.cuda()) batch_size, _, _, H, W = input.size() output = Variable(output.cuda()) gt = torch.cat([input, output], dim=1) latent = self.encode(input, sample=False) decoded_output, components = self.decode(latent, input.size(0)) decoded_output = decoded_output.view(*gt.size()) components = components.view(batch_size, self.n_frames_total, self.total_components, self.n_channels, H, W) latent['components'] = components decoded_output = decoded_output.clamp(0, 1) self.save_visuals(gt, decoded_output, components, latent) return decoded_output.cpu(), latent
Example #21
Source File: nonlinearities.py From nsf with MIT License | 5 votes |
def inverse(self, inputs, context=None): if torch.min(inputs) < 0 or torch.max(inputs) > 1: raise transforms.InputOutsideDomain() inputs = torch.clamp(inputs, self.eps, 1 - self.eps) outputs = (1 / self.temperature) * (torch.log(inputs) - torch.log1p(-inputs)) logabsdet = - utils.sum_except_batch( torch.log(self.temperature) - F.softplus( -self.temperature * outputs) - F.softplus(self.temperature * outputs) ) return outputs, logabsdet
Example #22
Source File: AnimeHeadDetector.py From AnimeHeadDetector with MIT License | 5 votes |
def detect(self, image): # Preprocess the image w, h = image.shape[1], image.shape[0] img = (letterbox_image(image, (self.inp_dim, self.inp_dim))) img_ = img[:,:,::-1].transpose((2,0,1)).copy() img_ = torch.from_numpy(img_).float().div(255.0).unsqueeze(0) im_dim_list = torch.FloatTensor([ [w, h] ]).repeat(1,2) # Send to the model for prediction if self.CUDA: img_ = img_.cuda() with torch.no_grad(): prediction = self.model(Variable(img_), self.CUDA) output = write_results(prediction, self.CONFIDENCE_THRESHOLD, self.NUM_CLASSES, nms=True, nms_conf=self.NMS_THRESHOLD) # This function does NMS and converts the format. Returns 0 if no results are found. # output has the format of [ class, cx, cy, w, h, confidence ] if type(output) == int: return None # Convert back to the coordinates in the original image before resizing # We need somewhat complicated processing here because letter boxing was used in preprocessing output = output.detach().cpu() scaling_factor = torch.min(self.inp_dim/im_dim_list,1)[0].view(-1,1) output[:,[1,3]] -= (self.inp_dim - scaling_factor*im_dim_list[:,0].view(-1,1))/2 output[:,[2,4]] -= (self.inp_dim - scaling_factor*im_dim_list[:,1].view(-1,1))/2 output[:,1:5] /= scaling_factor for i in range(output.shape[0]): output[i, [1,3]] = torch.clamp(output[i, [1,3]], 0.0, im_dim_list[0,0]) output[i, [2,4]] = torch.clamp(output[i, [2,4]], 0.0, im_dim_list[0,1]) return [ { 'l': int(output[i, 1].item()), 't': int(output[i, 2].item()), 'r': int(output[i, 3].item()), 'b': int(output[i, 4].item()), 'confidence': output[i, 5].item() } for i in range(output.shape[0]) ] # Detect heads and return the cropped faces as a list of opencv numpy arrays
Example #23
Source File: Losses.py From pneumothorax-segmentation with MIT License | 5 votes |
def forward(self, outputs, targets): outputs = outputs.contiguous() targets = targets.contiguous() eps = 1e-8 non_ignored = targets.view(-1) != self.ignore_index targets = targets.view(-1)[non_ignored].float() outputs = outputs.contiguous().view(-1)[non_ignored] outputs = torch.clamp(outputs, eps, 1. - eps) targets = torch.clamp(targets, eps, 1. - eps) pt = (1 - targets) * (1 - outputs) + targets * outputs return (-(1. - pt) ** self.gamma * torch.log(pt)).mean()
Example #24
Source File: Losses.py From pneumothorax-segmentation with MIT License | 5 votes |
def forward(self, input, target): input = input.float().view(-1) target = target.float().view(-1) neg_abs = - input.abs() # todo check correctness loss = input.clamp(min=0) - input * target + (1 + neg_abs.exp()).log() return loss.mean()
Example #25
Source File: images_data.py From nsf with MIT License | 5 votes |
def inverse(self, inputs): # Discretize the pixel values. inputs = torch.floor(inputs) # Convert to a float in [0, 1]. inputs = inputs * (256 / self.num_bins) / 255 inputs = torch.clamp(inputs, 0, 1) return inputs
Example #26
Source File: generate_samples.py From BMSG-GAN with MIT License | 5 votes |
def adjust_dynamic_range(data, drange_in=(-1, 1), drange_out=(0, 1)): """ adjust the dynamic colour range of the given input data :param data: input image data :param drange_in: original range of input :param drange_out: required range of output :return: img => colour range adjusted images """ if drange_in != drange_out: scale = (np.float32(drange_out[1]) - np.float32(drange_out[0])) / ( np.float32(drange_in[1]) - np.float32(drange_in[0])) bias = (np.float32(drange_out[0]) - np.float32(drange_in[0]) * scale) data = data * scale + bias return th.clamp(data, min=0, max=1)
Example #27
Source File: boxlist_ops.py From Parsing-R-CNN with MIT License | 5 votes |
def boxlist_overlap(boxlist1, boxlist2): if boxlist1.size != boxlist2.size: raise RuntimeError( "boxlists should have same image size, got {}, {}".format(boxlist1, boxlist2)) N = len(boxlist1) M = len(boxlist2) area1 = boxlist1.area() area2 = boxlist2.area() box1, box2 = boxlist1.bbox, boxlist2.bbox lt = torch.max(box1[:, None, :2], box2[:, :2]) # [N,M,2] rb = torch.min(box1[:, None, 2:], box2[:, 2:]) # [N,M,2] TO_REMOVE = 1 wh = (rb - lt + TO_REMOVE).clamp(min=0) # [N,M,2] inter = wh[:, :, 0] * wh[:, :, 1] # [N,M] iou = inter / (area1[:, None] + area2 - inter) overlap = iou > 0 return overlap # TODO redundant, remove
Example #28
Source File: boxlist_ops.py From Parsing-R-CNN with MIT License | 5 votes |
def boxlist_partly_overlap(boxlist1, boxlist2): if boxlist1.size != boxlist2.size: raise RuntimeError( "boxlists should have same image size, got {}, {}".format(boxlist1, boxlist2)) N = len(boxlist1) M = len(boxlist2) area1 = boxlist1.area() area2 = boxlist2.area() box1, box2 = boxlist1.bbox, boxlist2.bbox lt = torch.max(box1[:, None, :2], box2[:, :2]) # [N,M,2] rb = torch.min(box1[:, None, 2:], box2[:, 2:]) # [N,M,2] TO_REMOVE = 1 wh = (rb - lt + TO_REMOVE).clamp(min=0) # [N,M,2] inter = wh[:, :, 0] * wh[:, :, 1] # [N,M] iou = inter / (area1[:, None] + area2 - inter) overlap = iou > 0 not_complete_overlap = (inter - area1[:, None]) * (inter - area2[None, :]) != 0 partly_overlap = overlap * not_complete_overlap return partly_overlap
Example #29
Source File: boxlist_ops.py From Parsing-R-CNN with MIT License | 5 votes |
def boxlist_iou(boxlist1, boxlist2): """Compute the intersection over union of two set of boxes. The box order must be (xmin, ymin, xmax, ymax). Arguments: box1: (BoxList) bounding boxes, sized [N,4]. box2: (BoxList) bounding boxes, sized [M,4]. Returns: (tensor) iou, sized [N,M]. Reference: https://github.com/chainer/chainercv/blob/master/chainercv/utils/bbox/bbox_iou.py """ if boxlist1.size != boxlist2.size: raise RuntimeError( "boxlists should have same image size, got {}, {}".format(boxlist1, boxlist2)) N = len(boxlist1) M = len(boxlist2) area1 = boxlist1.area() area2 = boxlist2.area() box1, box2 = boxlist1.bbox, boxlist2.bbox lt = torch.max(box1[:, None, :2], box2[:, :2]) # [N,M,2] rb = torch.min(box1[:, None, 2:], box2[:, 2:]) # [N,M,2] TO_REMOVE = 1 wh = (rb - lt + TO_REMOVE).clamp(min=0) # [N,M,2] inter = wh[:, :, 0] * wh[:, :, 1] # [N,M] iou = inter / (area1[:, None] + area2 - inter) return iou # implementation from https://github.com/kuangliu/torchcv/blob/master/torchcv/utils/box.py # with slight modifications
Example #30
Source File: functions.py From c3dpo_nrsfm with MIT License | 5 votes |
def avg_l2_huber(x, y, mask=None, scaling=0.03): diff = x - y dist = (diff*diff).sum(1) dist = huber(dist, scaling=float(scaling)) if mask is not None: dist = (dist*mask).sum(1) / \ torch.clamp(mask.sum(1), 1.) else: if len(dist.shape) == 2 and dist.shape[1] > 1: dist = dist.mean(1) dist = dist.mean() return dist