def translate(self, indices: torch.Tensor, reduce_token: Optional[str] = None, keep_sos: bool = False, keep_eos: bool = False, keep_pad: bool = False ) -> Union[List[str], List[List[str]]]: r""" Translate a prediction tensor to its corresponding strings Args: indices: a tensor of shape :math:`(B, L)` where :math:`B` is the batch size, :math:`L` is the sequence length. reduce_token: a token to concatenate over :math:`L` dim. *None* to not concat. Default is *None*. keep_sos: whether to keep the start of sequence token after translation. Default is `False`. keep_eos: whether to keep the end of sequence token after translation. Default is `False`. keep_pad: whether to keep the padding token after translation. Default is `False`. Return: a list of size :math:`B`, each item is a string if *reduce_token* is not *None*, or a list of tokens """ indices = indices.cpu() sos_mask = indices == self.SOS_IDX # [B, L] eos_mask = indices == self.EOS_IDX # [B, L] sos_pos = sos_mask.max(-1)[1] # [B] eos_pos = eos_mask.max(-1)[1] # [B] # TODO: implement keep_pad if not keep_sos: sos_pos += 1 sos_pos.masked_fill_(torch.bitwise_not(torch.any(sos_mask, dim=-1)), 0) if keep_eos: eos_pos += 1 eos_pos.masked_fill_(torch.bitwise_not(torch.any(eos_mask, dim=-1)), indices.size(1)) outs: Union[List[str], List[List[str]]] = [] for indices_, start, end in zip(indices.tolist(), sos_pos, eos_pos): tokens = self.lookup_tokens(indices_[start:end]) if reduce_token is None: outs.append(tokens) else: outs.append(reduce_token.join(tokens)) return outs
def _masked_mean(self, vector: torch.Tensor, mask: torch.Tensor, dim: int, keepdim: bool = False, eps: float = 1e-8) -> torch.Tensor: """ To calculate mean along certain dimensions on masked values Parameters ---------- vector : ``torch.Tensor`` The vector to calculate mean. mask : ``torch.Tensor`` The mask of the vector. It must be broadcastable with vector. dim : ``int`` The dimension to calculate mean keepdim : ``bool`` Whether to keep dimension eps : ``float`` A small value to avoid zero division problem. Returns ------- A ``torch.Tensor`` of including the mean values. """ one_minus_mask = torch.bitwise_not(mask).to(dtype=torch.bool) replaced_vector = vector.masked_fill(one_minus_mask, 0.0) value_sum = torch.sum(replaced_vector, dim=dim, keepdim=keepdim) value_count = torch.sum(mask.float(), dim=dim, keepdim=keepdim) return value_sum / value_count.clamp(min=eps)
def batch_argmax_adl_Q_predictionNetwork_given_State(self, states_batch): """ :param state: :return: argmax(over action) Q(state, action, theta) """ # possible_actions = sorted(self.batch_adl_give_possible_actions(state[2])) # output = np.expand_dims(self.prediction_adl_model.forward(torch.FloatTensor(state)).cpu().detach().numpy(), # axis=0) output = self.prediction_adl_model.forward(states_batch) output = output + 1.0 - torch.min(output, dim=1).values.unsqueeze_(1) batchsize = output.shape[0] actionsize = output.shape[1] action_indices = torch.arange(0, actionsize).unsqueeze_(0).repeat([batchsize,1]) # only when an action index bit specifies 1 and this adl load is already satisfied, then this # action is not possible so its FLAG is false adl_states_batch = states_batch[:,2] action_FLAGS_batch = (action_indices & \ torch.bitwise_not(adl_states_batch.long().unsqueeze_(1).repeat([1,actionsize])) == 0) output = output * action_FLAGS_batch indexes_batch = torch.argmax(output, dim=1) return indexes_batch
def _output(self): #每个anchor box 对应哪个gt, #如果没有anchor box 没有对应的gt,下面这个也会max出一个来 anchorGtMat = self.anchorGtMat.type(torch.int8) anchorBoxIndexGtBox = torch.argmax(anchorGtMat, dim=1) #anchor box对应gt bbox的索引 anchorBoxGtClass = self.labelsGt[ anchorBoxIndexGtBox] #anchor box对应gt bbox的标签 #解决上面的问题, 去掉没有对应上的anchor box indexFliter = self.anchorGtMat.any(dim=1) #.bool() posIndex = torch.nonzero(indexFliter).reshape(-1) indexFliter = torch.bitwise_not(indexFliter) #进行过滤 anchorBoxGtClass[indexFliter] = -1 anchorBoxIndexGtBox[indexFliter] = -1 anchorBoxGt = torch.zeros_like(self.bboxesAnchor) anchorBoxGt[posIndex] = self.bboxesGt[anchorBoxIndexGtBox[posIndex]] infos = { 'anchorBoxGt': anchorBoxGt, 'anchorBoxGtClass': anchorBoxGtClass, 'anchorBoxIndexGtBox': anchorBoxIndexGtBox, 'posIndex': posIndex } return infos
def forward(self, hidden_output_nodes : torch.Tensor, input_nodes : torch.Tensor, node_mask : torch.Tensor) -> torch.Tensor: """ Defines forward pass. """ Softmax = torch.nn.Softmax(dim=1) batch_size = input_nodes.shape[0] energy_mask = torch.bitwise_not(node_mask).float() * self.C.big_negative lstm_input = torch.zeros(batch_size, self.memory_size, device=self.constants.device) cat = torch.cat((hidden_output_nodes, input_nodes), dim=2) memory = self.embedding_matrix(cat) hidden_state = torch.zeros(batch_size, self.memory_size, device=self.constants.device) cell_state = torch.zeros(batch_size, self.memory_size, device=self.constants.device) for _ in range(self.lstm_computations): query, cell_state = self.lstm(lstm_input, (hidden_state, cell_state)) # dot product query x memory energies = (query.view(batch_size, 1, self.memory_size) * memory).sum(dim=-1) attention = Softmax(energies + energy_mask) read = (attention.unsqueeze(-1) * memory).sum(dim=1) hidden_state = query lstm_input = read cat = torch.cat((query, read), dim=1) return cat
def func_dawson_2nd(self, x: Tensor) -> Tensor: y = torch.zeros_like(x) idx1 = torch.lt(x, -10.) idx2 = torch.gt(x, 10.) y[idx1] = self.func_asym_neg_inf(x[idx1]) y[idx2] = self.func_asym_pos_inf(x[idx2]) idx1 = torch.bitwise_not(torch.bitwise_or(idx1, idx2)) y[idx1] = chebyshev_val_neg(-x[idx1].abs_(), self.cheb_neg, num_sub=self.div) idx1 = torch.bitwise_and(idx1, x > 0) if x.is_cuda: if x[idx1].numel() < mnn_config.get_value('cpu_or_gpu'): device = x.device temp = torch.from_numpy(scipy.erfi( x[idx1].cpu().numpy())).to(device=device) y[idx1] = math.sqrt(math.pi) * torch.exp(torch.pow(x[idx1], 2)) * \ (0.5 * math.log(2) + 2 * self.dawson1(-x[idx1]) + math.pi / 2 * temp) - y[idx1] else: y[idx1] = math.sqrt(math.pi) * torch.exp(torch.pow(x[idx1], 2)) * \ (0.5 * math.log(2) + 2 * self.dawson1(-x[idx1]) + math.pi / 2 * self.dawson1.erfi(x[idx1])) - \ y[idx1] else: y[idx1] = math.sqrt(math.pi) * torch.exp(torch.pow(x[idx1], 2)) * \ (0.5 * math.log(2) + 2 * self.dawson1(-x[idx1]) + math.pi / 2 * torch.from_numpy( scipy.erfi(x[idx1].numpy()))) - y[idx1] return y
def loss(self, pred_masks, bboxes, gt_masks, img_metas, cfg): losses = torch.zeros(1, device=pred_masks[0].device) total_pos_num = 0 final_masks = [] final_boxes = [] for pred_mask, bbox, gt_mask, img_meta in zip(pred_masks, bboxes, gt_masks, img_metas): # pred_mask with size: [N, mask_h, mask_w, 2]; gt_mask with size: [N, h, w] assert pred_mask.size(0) == gt_mask.size(0) num_pos = pred_mask.size(0) if num_pos == 0: h, w = img_meta[ 'pad_shape'][:2] if cfg.upsampling else pred_mask.size( )[1:3] final_masks.append(pred_mask.new_zeros(0, h, w)) final_boxes.append(bbox.new_zeros(0, 4)) continue # The bbox and gt_mask are in 'pad_shape', while pred_mask may be not. # So we need rescale the bbox and gt_mask before cropping and calculating losses. assert pred_mask.size(1) / img_meta['pad_shape'][ 0] == pred_mask.size(2) / img_meta['pad_shape'][1] scale_factor = pred_mask.size(1) / img_meta['pad_shape'][0] _bbox = bbox * scale_factor if scale_factor != 1: gt_mask = F.interpolate(gt_mask.unsqueeze(0), scale_factor=scale_factor, mode='bilinear').squeeze(0) gt_mask = (gt_mask > 0.5).float() assert gt_mask.size()[1:3] == pred_mask.size()[1:3] # crop_mask with size: [N, h, w], bool tensor, 1 for pixels in bbox area, 0 for others if cfg.crop is not None: crop_mask = self.crop(pred_mask, _bbox, cfg.crop) gt_mask[torch.bitwise_not(crop_mask)] = -1 else: crop_mask = gt_mask.new_ones(gt_mask.size()) # pred mask with size: [N, 2, mask_h, mask_w] pred_mask = pred_mask.permute(0, 3, 1, 2) mask_loss = self.mask_loss(pred_mask, gt_mask, crop_mask, cfg.mask_loss) losses += mask_loss total_pos_num += num_pos # prepare final_mask and final_bbox if cfg.upsampling: _bbox = bbox pred_mask = F.interpolate(pred_mask, img_meta['pad_shape'][:2], mode='bilinear') # final_mask should be cropped according to test_cfg test_crop_mask = self.crop(pred_mask.permute(0, 2, 3, 1), _bbox, cfg.test_crop) final_mask = F.softmax(pred_mask, dim=1)[:, 1, :, :] * test_crop_mask.float() final_masks.append(final_mask) final_boxes.append(_bbox) # avoid dividing by zero losses = losses / (total_pos_num + 1) * cfg.mask_loss['loss_weight'] return dict(loss_mask=losses), final_masks, final_boxes
def make_SA_bool(weights, mask, mask1): ## Inject errors # output = ((weights + mask) > 0.) # inject stuck at 0 # output = ((output - mask1)> 0.) # inject stuck at 1 not_mask0 = torch.bitwise_not(mask) output = torch.bitwise_and(weights, not_mask0) # inject stuck at 0 output = torch.bitwise_or(output, mask1) # inject stuck at 1 return output
def forward(self, x: Tensor) -> Tensor: idx1 = torch.lt(x, -10) idx2 = torch.gt(x, self.cheb_xmas_for_H) idx3 = torch.bitwise_and(torch.bitwise_not(idx1), x <= 0) idx4 = torch.bitwise_and(torch.bitwise_not(idx2), x > 0) y = torch.zeros_like(x) y[idx1] = self.func_int_asym_neg_inf(x[idx1]) y[idx2] = self.func_int_asym_pos_inf(x[idx2]) y[idx3] = chebyshev_val_neg(x[idx3], self.cheb_H_neg, num_sub=self.div) y[idx4] = torch.exp( 2 * torch.pow(x[idx4], 2)) * chebyshev_val_no_transform( x[idx4], self.cheb_H_pos, x_max=self.cheb_xmas_for_H, num_sub=self.div_pos) return y
def build_odims_(x, dims): # build indices for other dimensions if not isinstance(dims, torch.Tensor): dims = torch.tensor(dims).to(x.device) odims = torch.arange(0, x.shape[-1]).long().to(dims.device) odims = torch.bitwise_not(torch.eq(dims, odims[:, None])).prod(1).nonzero()[:, 0] return odims.detach(), dims
def forward(self, features, targets=None): global_feat = self.pool_layer(features) bn_feat = self.bnneck(global_feat) if not self.training: return bn_feat bn_feat = F.normalize(bn_feat) n = bn_feat.size(0) # Compute pairwise distance, replace by the official when merged dist = torch.pow(bn_feat, 2).sum(dim=1, keepdim=True).expand(n, n) dist = dist + dist.t() dist.addmm_(1, -2, bn_feat, bn_feat.t()) dist = dist.clamp(min=1e-12).sqrt( ) # for numerical stability & pairwise distance, dij S = torch.exp(-1.0 * torch.pow(dist, 2) / (self.osm_sigma * self.osm_sigma)) S_ = torch.clamp( self.alpha - dist, min=1e-12 ) # max (0 , \alpha - dij) # 1e-12, 0 may result in nan error p_mask = targets.expand(n, n).eq(targets.expand(n, n).t()) # same label == 1 n_mask = torch.bitwise_not(p_mask) # oposite label == 1 S = S * p_mask.float() S = S + S_ * n_mask.float() denominator = torch.exp(F.linear(bn_feat, F.normalize(self.weight))) A = [] # attention corresponding to each feature fector for i in range(n): a_i = denominator[i][targets[i]] / torch.sum(denominator[i]) A.append(a_i) # a_i's atten_class = torch.stack(A) # a_ij's A = torch.min(atten_class.expand(n, n), atten_class.view(-1, 1).expand( n, n)) # pairwise minimum of attention weights W = S * A W_P = W * p_mask.float() W_N = W * n_mask.float() W_P = W_P * ( 1 - torch.eye(n, n).float().cuda() ) # dist between (xi,xi) not necessarily 0, avoiding precision error W_N = W_N * (1 - torch.eye(n, n).float().cuda()) L_P = 1.0 / 2 * torch.sum(W_P * torch.pow(dist, 2)) / torch.sum(W_P) L_N = 1.0 / 2 * torch.sum(W_N * torch.pow(S_, 2)) / torch.sum(W_N) L = (1 - self.l) * L_P + self.l * L_N return L, global_feat
def __init__(self, data=None, device=None, is_test=False): """Create a Batch from a list of examples.""" if data is not None: self.batch_size = len(data) pre_src = [x[0] for x in data] pre_labels = [x[1] for x in data] pre_segs = [x[2] for x in data] pre_clss = [x[3] for x in data] topic_pro = [x[-1] for x in data] if not is_test: pre_tgt_idxs = [x[4] for x in data] pre_decoder_tgt_idxs = [x[5] for x in data] tgt_idxs = torch.tensor(self._pad(pre_tgt_idxs, 0)) decoder_tgt_idxs = torch.tensor( self._pad(pre_decoder_tgt_idxs, 0)) setattr(self, 'tgt_idxs', tgt_idxs.to(device)) setattr(self, 'decoder_tgt_idxs', decoder_tgt_idxs.to(device)) src = torch.tensor(self._pad(pre_src, 0)) labels = torch.tensor(self._pad(pre_labels, 0)) segs = torch.tensor(self._pad(pre_segs, 0)) mask = torch.bitwise_not(src == 0) clss = torch.tensor(self._pad(pre_clss, -1)) mask_cls = torch.bitwise_not(clss == -1) clss[clss == -1] = 0 topic_pro = torch.tensor(topic_pro) setattr(self, 'clss', clss.to(device)) setattr(self, 'mask_cls', mask_cls.to(device)) setattr(self, 'src', src.to(device)) setattr(self, 'labels', labels.to(device)) setattr(self, 'segs', segs.to(device)) setattr(self, 'mask', mask.to(device)) setattr(self, 'topic_pro', topic_pro.to(device)) if (is_test): src_str = [x[-3] for x in data] setattr(self, 'src_str', src_str) tgt_str = [x[-2] for x in data] setattr(self, 'tgt_str', tgt_str)
def bitwise_not(input_): """Wrapper of `torch.bitwise_not`. Parameters ---------- input_ : DTensor Input dense tensor. """ return torch.bitwise_not(input_._data)
def forward(self, embeddings, label): cos_theta, origin_cos = calc_logits(embeddings, self.kernel) cos_theta_, _ = calc_logits(embeddings, self.kernel.detach()) mask = torch.zeros_like(cos_theta) mask.scatter_(1, label.view(-1, 1).long(), 1.0) sample_num = embeddings.size(0) tmp_cos_theta = cos_theta - 2 * mask tmp_cos_theta_ = cos_theta_ - 2 * mask target_cos_theta = cos_theta[torch.arange(0, sample_num), label].view(-1, 1) target_cos_theta_ = cos_theta_[torch.arange(0, sample_num), label].view(-1, 1) target_cos_theta_m = target_cos_theta - self.margin far = 1 / (self.out_features - 1) # far = 1e-4 topk_mask = torch.greater(tmp_cos_theta, target_cos_theta) topk_sum = torch.sum(topk_mask.to(torch.int32)) dist.all_reduce(topk_sum) far_rank = math.ceil( far * (sample_num * (self.out_features - 1) * dist.get_world_size() - topk_sum)) cos_theta_neg_topk = torch.topk( (tmp_cos_theta - 2 * topk_mask.to(torch.float32)).flatten(), k=far_rank)[0] cos_theta_neg_topk = all_gather_tensor(cos_theta_neg_topk.contiguous()) cos_theta_neg_th = torch.topk(cos_theta_neg_topk, k=far_rank)[0][-1] cond = torch.mul(torch.bitwise_not(topk_mask), torch.greater(tmp_cos_theta, cos_theta_neg_th)) _, cos_theta_neg_topk_index = torch.where(cond) cos_theta_neg_topk = torch.mul(cond.to(torch.float32), tmp_cos_theta) cos_theta_neg_topk_ = torch.mul(cond.to(torch.float32), tmp_cos_theta_) cond = torch.greater(target_cos_theta_m, cos_theta_neg_topk) cos_theta_neg_topk = torch.where(cond, cos_theta_neg_topk, cos_theta_neg_topk_) cos_theta_neg_topk = torch.pow(cos_theta_neg_topk, 2) times = torch.sum(torch.greater(cos_theta_neg_topk, 0).to(torch.float32), dim=1, keepdim=True) times = torch.where(torch.greater(times, 0), times, torch.ones_like(times)) cos_theta_neg_topk = torch.sum(cos_theta_neg_topk, dim=1, keepdim=True) / times target_cos_theta_m = target_cos_theta_m - ( 1 + target_cos_theta_) * cos_theta_neg_topk cos_theta.scatter_(1, label.view(-1, 1).long(), target_cos_theta_m) output = cos_theta * self.scale return output, origin_cos * self.scale
def non_nan(self): actual = torch.Tensor(self.actual) pred = torch.Tensor(self.pred) non_nan_idx = torch.bitwise_not(torch.isnan(pred)) pred = pred[non_nan_idx].numpy().tolist() actual = actual[non_nan_idx].numpy().tolist() return pred, actual
def _adjust_pred(self, pred_coords, distmaps, gt_coords): gt_coords = gt_coords.to(pred_coords.device) # 获取mask new_masks = self._mask_pred(pred_coords, distmaps) # 将mask所有值取反 new_masks = torch.bitwise_not(new_masks) # 获取到预测的坐标 pred_coords[new_masks] = gt_coords[new_masks] # 返回预测的坐标 return pred_coords
def mux_p_cuda(x, y, rands): #global mask #mask = torch.cuda.ByteTensor([2 ** x for x in range(8)]) xs = x.shape[0] ys = y.shape[0] assert xs == ys #rands = torch.cuda.FloatTensor(xs << 3).uniform_() > p #rands = torch.sum(rands.view(xs, 8) * mask, 1) top = torch.bitwise_and(x, rands) bot = torch.bitwise_and(y, torch.bitwise_not(rands)) return torch.bitwise_or(top, bot)
def _get_dp_dm(distances, targets, plabels, with_indices=False): """Returns the d+ and d- values for a batch of distances.""" matcher = _get_matcher(targets, plabels) not_matcher = torch.bitwise_not(matcher) inf = torch.full_like(distances, fill_value=float("inf")) d_matching = torch.where(matcher, distances, inf) d_unmatching = torch.where(not_matcher, distances, inf) dp = torch.min(d_matching, dim=-1, keepdim=True) dm = torch.min(d_unmatching, dim=-1, keepdim=True) if with_indices: return dp, dm return dp.values, dm.values
def maj_p_cuda(x, y, rands): #FIX THIS ASAP #global mask #mask = torch.cuda.ByteTensor([2 ** x for x in range(8)]) xs = x.shape[0] ys = y.shape[0] assert xs == ys and_ = torch.bitwise_and(x, y) or_ = torch.bitwise_or(x, y) top = torch.bitwise_and(and_, torch.bitwise_not(rands)) bot = torch.bitwise_and(or_, rands) return torch.bitwise_or(top, bot)
def __getitem__(self, index): # Grab and transform RGB image X = Image.open(self.imageList[index]).convert('RGB') X = transforms.Compose(self.transform)(X) # Get all masks associated with RGB image skin_mask = Image.open(self.maskList[index]).convert('L') skin_mask = transforms.Compose(self.transform)(skin_mask) skin_mask = skin_mask.type(torch.BoolTensor) no_skin_mask = torch.bitwise_not(skin_mask) # Construct Construct masks of both classes y = torch.cat([no_skin_mask, skin_mask], dim=0) return X.float(), y.float()
def forward(self, input: List[torch.Tensor], target: List[torch.Tensor]): loss = 0 weight_sum = 0 for i, (_input, _target) in enumerate(zip(input, target)): if self.weights: weight = self.weights[i] else: weight = 1 _target = _target.to(_input.device) mask = torch.bitwise_not(torch.isnan(_target)) loss += weight * self.torch_loss(_input[mask], _target[mask]) weight_sum += weight return loss / weight_sum
def unique_and_padding(mat, padding_idx, dim=-1): """Conducts unique operation along dim and pads to the same length.""" samples, _ = torch.sort(mat, dim=dim) samples_roll = torch.roll(samples, -1, dims=dim) samples_diff = samples - samples_roll samples_diff[:, -1] = 1 # deal with the edge case that there is only one unique sample in a row samples_mask = torch.bitwise_not(samples_diff == 0) # unique mask samples *= samples_mask.to(dtype=samples.dtype) samples += (1 - samples_mask.to(dtype=samples.dtype)) * padding_idx samples, _ = torch.sort(samples, dim=dim) # shrink size to max unique length samples = torch.unique(samples, dim=dim) return samples
def forward(self, input: Dict[str, torch.Tensor], target: Dict[str, torch.Tensor]): loss = 0 weight_sum = 0 for key, _target in target.items(): if key not in input: continue weight = self.weights.get(key, 1) mask = torch.bitwise_not(torch.isnan(_target)) _target = _target.to(input[key].device) loss += weight * self.torch_loss(input[key][mask], _target[mask]) weight_sum += weight return loss / weight_sum
def del_word( output_tokens, output_scores, attn: Optional[Tensor], word_del_attn: Optional[Tensor], word_del_out, can_del_word, pad_idx: int, bos_idx: int, eos_idx: int, ): # delete words # do not delete tokens if it is <s> </s> if can_del_word.sum() != 0: # we cannot delete, skip word_del_score = F.log_softmax(word_del_out, 2) word_del_pred = word_del_score.max(-1)[1].to(torch.bool) in_tokens = output_tokens[can_del_word] in_scores = output_scores[can_del_word] # apply deletion to a tensor in_masks = in_tokens.ne(pad_idx) bos_eos_masks = in_tokens.eq(bos_idx) + in_tokens.eq(eos_idx) max_len = in_tokens.size(1) word_del_pred.masked_fill_(torch.bitwise_not(in_masks), 1) word_del_pred.masked_fill_(bos_eos_masks, 0) reordering = (torch.arange(max_len, device=in_tokens.device)[ None, :].expand_as(in_tokens).contiguous().masked_fill( word_del_pred, max_len).sort(1)[1]) _tokens = in_tokens.masked_fill(word_del_pred, pad_idx).gather(1, reordering) _scores = in_scores.masked_fill(word_del_pred, 0).gather(1, reordering) if word_del_attn is not None: _mask = word_del_pred[:, :, None].expand_as(word_del_attn) _reordering = reordering[:, :, None].expand_as(word_del_attn) _attn = word_del_attn.masked_fill(_mask, 0.0).gather( 1, _reordering) attn = _fill(attn, can_del_word, _attn, 0) output_tokens = coalesce( _fill(output_tokens, can_del_word, _tokens, pad_idx), output_tokens) output_scores = coalesce( _fill(output_scores, can_del_word, _scores, 0), output_scores) return output_tokens, output_scores, attn
def _get_dp_dm(distances, targets, plabels): matcher = torch.eq(targets.unsqueeze(dim=1), plabels) if plabels.ndim == 2: # if the labels are one-hot vectors nclasses = targets.size()[1] matcher = torch.eq(torch.sum(matcher, dim=-1), nclasses) not_matcher = torch.bitwise_not(matcher) inf = torch.full_like(distances, fill_value=float('inf')) d_matching = torch.where(matcher, distances, inf) d_unmatching = torch.where(not_matcher, distances, inf) dp = torch.min(d_matching, dim=1, keepdim=True).values dm = torch.min(d_unmatching, dim=1, keepdim=True).values return dp, dm
def glvq_loss(distances, target_labels, prototype_labels): """GLVQ loss function with support for one-hot labels.""" matcher = torch.eq(target_labels.unsqueeze(dim=1), prototype_labels) if prototype_labels.ndim == 2: # if the labels are one-hot vectors nclasses = target_labels.size()[1] matcher = torch.eq(torch.sum(matcher, dim=-1), nclasses) not_matcher = torch.bitwise_not(matcher) inf = torch.full_like(distances, fill_value=float('inf')) distances_to_wpluses = torch.where(matcher, distances, inf) distances_to_wminuses = torch.where(not_matcher, distances, inf) dpluses = torch.min(distances_to_wpluses, dim=1, keepdim=True).values dminuses = torch.min(distances_to_wminuses, dim=1, keepdim=True).values mu = (dpluses - dminuses) / (dpluses + dminuses) return mu
def forward(self, x, encoder_padding_mask): residual = x x = self.maybe_layer_norm(x, before=True) converted_mask = None if encoder_padding_mask is not None: x = x.masked_fill( encoder_padding_mask.transpose(0, 1).unsqueeze(2), 0) if self.left_pad: x, converted_mask = convert_padding_direction( x, encoder_padding_mask, left_to_right=True) max_len, bsz, _ = x.size() src_lengths = torch.bitwise_not(converted_mask).long().sum(dim=1).data.tolist() if \ converted_mask is not None else [max_len for _ in range(bsz)] packed_x = nn.utils.rnn.pack_padded_sequence(x, src_lengths) if self.bidirectional: state_size = 2 * self.num_layers, bsz, self.hidden_dim else: state_size = self.num_layers, bsz, self.hidden_dim h0 = x.new_zeros(*state_size) c0 = x.new_zeros(*state_size) packed_outs, (final_hiddens, final_cells) = self.lstm(packed_x, (h0, c0)) x, _ = nn.utils.rnn.pad_packed_sequence(packed_outs, padding_value=0) if encoder_padding_mask is not None: if self.left_pad: x, _ = convert_padding_direction(x, converted_mask, right_to_left=True) assert list(x.size()) == [max_len, bsz, self.output_units] x = self.linear(x) x = F.dropout(x, p=self.dropout, training=self.training) x = residual + x x = self.maybe_layer_norm(x, after=True) if self.bidirectional: def combine_bidir(outs): out = outs.view(self.num_layers, 2, bsz, -1).transpose(1, 2).contiguous() return out.view(self.num_layers, bsz, -1) final_hiddens = combine_bidir(final_hiddens) final_cells = combine_bidir(final_cells) return x, {"lstm_hidden_state": (final_hiddens, final_cells)}
def forward(self, top_vecs, mask): """ See :obj:`EncoderBase.forward()`""" batch_size, n_sents = top_vecs.size(0), top_vecs.size(1) pos_emb = self.pos_emb.pe[:, :n_sents] x = top_vecs * mask[:, :, None].float() x = x + pos_emb for i in range(self.num_inter_layers): x = self.transformer_inter[i]( i, x, x, torch.bitwise_not(mask)) # all_sents * max_tokens * dim x = self.layer_norm(x) sent_scores = self.sigmoid(self.wo(x)) sent_scores = sent_scores.squeeze(-1) * mask.float() return sent_scores
def cnn_kernel_3x3(img, kernel, N): """Unipolar kernel convolve -> AND gates Bipolar kernel convolve -> XNOR gates""" is_bp = np.any(kernel < 0) h, w = img.shape rng = bs.SC_RNG() rng_type = rng.bs_bp_uniform if is_bp else rng.bs_uniform img_bs = img_io.img_to_bs(img, rng_type, bs_len=N) #Correlated at +1 img_bs = torch.from_numpy(img_bs).to(device) rng.reset() kernel_bs = img_io.img_to_bs(kernel, rng_type, bs_len=N, scale=False) kernel_bs = torch.from_numpy(kernel_bs).to(device) nb = N>>3 rc_mat = torch.cuda.ByteTensor(h-2, w-2, nb).fill_(0) m = torch.cuda.ByteTensor(3, 3, nb).fill_(0) z = torch.cuda.ByteTensor(nb).fill_(0) for i in range(h-2): for j in range(w-2): for k in range(3): for l in range(3): if is_bp: m[k][l] = torch.bitwise_not(torch.bitwise_xor(img_bs[i + k][j + l], kernel_bs[k][l])) else: m[k][l] = torch.bitwise_and(img_bs[i + k][j + l], kernel_bs[k][l]) #mux sum tree l1_1 = mux_p_cuda(m[0][0], m[0][1], 0.5) l1_2 = mux_p_cuda(m[0][2], m[1][0], 0.5) l1_3 = mux_p_cuda(m[1][1], m[1][2], 0.5) l1_4 = mux_p_cuda(m[2][0], m[2][1], 0.5) l2_1 = mux_p_cuda(l1_1, l1_2, 0.5) l2_2 = mux_p_cuda(l1_3, l1_4, 0.5) l3 = mux_p_cuda(l2_1, l2_2, 0.5) rc_mat[i][j] = mux_p_cuda(l3, mux_p_cuda(m[2][2], z, 1.0/8.0), 1.0/9.0) #mean_type = bs.bs_mean_bp if is_bp else bs.bs_mean #rc_mat = rc_mat.to(cpu) #img_io.disp_img(img_io.bs_to_img(rc_mat, mean_type, scaling=9)) return bs.get_corr_mat_cuda(rc_mat.view((h-2)*(w-2), nb)).to(cpu).numpy()
def __getitem__(self, index): preprocess = transforms.Compose([ transforms.Resize((384, 288), 2), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) X = Image.open(self.imageList[index]).convert('RGB') X = preprocess(X) trfresize = transforms.Resize((384, 288), 2) trftensor = transforms.ToTensor() yimg = Image.open(self.maskList[index]).convert('L') y1 = trftensor(trfresize(yimg)) y1 = y1.type(torch.BoolTensor) y2 = torch.bitwise_not(y1) y = torch.cat([y2, y1], dim=0) return X, y