def show_graph(t, threshold=0.9, pos_color="b", neg_color="r"): t = t.cpu() apos = torch.threshold(t, threshold, 0).numpy() gpos = nx.from_numpy_matrix(apos) aneg = torch.threshold(t.neg(), threshold, 0).numpy() gneg = nx.from_numpy_matrix(aneg) pos = nx.spring_layout(gpos) nx.draw_networkx(gpos, pos=pos, with_labels=False, node_size=2, edge_color=pos_color, node_color="black", alpha=0.2) nx.draw_networkx(gneg, pos=pos, with_labels=False, node_size=2, edge_color=neg_color, node_color="black", alpha=0.2) # nx.draw_networkx_edges(gneg,pos, # with_labels=False, # edge_color='r', # width=1.0, # alpha=0.1 # ) # nx.draw_networkx_edges(gpos,pos, # with_labels=False, # edge_color='b', # width=1.0, # alpha=0.2 # ) # plt.axis('off') plt.title('correlation network')
def utc(softmax_out_target, t_feature, n_class, t_centroid, decay=0.3): n, d = t_feature.size() weight = softmax_out_target weight_sum = weight.sum(0) # [bs, nclass, d]) features_target_sl = t_feature.repeat(1, n_class).reshape(-1, n_class, d) features_target_sl2 = softmax_out_target.repeat(1, n_class).reshape( -1, n_class, n_class) feature = torch.cat((features_target_sl, features_target_sl2), dim=2) weight = weight.reshape(-1, 1).expand(-1, d + n_class).reshape( n, n_class, d + n_class) t_sum_feature = (feature * weight).sum(0) t_n_classes = weight_sum + 1e-6 current_t_centroid = torch.div(t_sum_feature, t_n_classes.view(n_class, 1)) #set decay de = torch.threshold(current_t_centroid, 1e-6, -1) de = 1 - torch.threshold(-de, 0, 0) decay = decay * de # Moving Centroid t_centroid = (1 - decay) * t_centroid + decay * current_t_centroid return t_centroid
def _iou(self, bbox, bboxes): inter_x1 = torch.max(bbox[0], bboxes[0]) inter_y1 = torch.max(bbox[1], bboxes[1]) inter_x2 = torch.min(bbox[2], bboxes[2]) inter_y2 = torch.min(bbox[3], bboxes[3]) inter_w = torch.threshold(inter_x2 - inter_x1 + 1, 0, 0) inter_h = torch.threshold(inter_y2 - inter_y1 + 1, 0, 0) inter_area = inter_w * inter_h bbox_area = (bbox[2] - bbox[0] + 1) * (bbox[3] - bbox[1] + 1) bboxes_area = (bboxes[2] - bboxes[0] + 1) * (bboxes[3] - bboxes[1] + 1) union_area = bbox_area + bboxes_area - inter_area return inter_area / union_area
def sample_select(softmax_out_target, features_tar, ad_net, iter): # with torch.no_grad(): ad_out = ad_net(features_tar, test=True).view(-1) entropy = losssntg.Entropy(softmax_out_target) entropy = 1.0 + torch.exp(-entropy) threshold = 1.6 - 0.1 * iter / 2000 # w_e = torch.threshold(entropy,threshold,0) # return ad_out*w_e w_e = torch.threshold(entropy, threshold, -1) w_e = torch.threshold(-w_e, 0, 0) return 1 - w_e
def denoise(self, x, edge_index, edge_weight, with_attack): rate = self.denoise_rate if not with_attack else self.denoise_rate + self.attack_rate _, gcn_output = self.gcn_model(x, edge_index, edge_weight) gcn_output = gcn_output.detach() enc_output = self.enc_model(x).detach() edge_score = -self.scorer( torch.cat( [ gcn_output[edge_index[0]], gcn_output[edge_index[1]], # enc_output[edge_index[0]], # enc_output[edge_index[1]], edge_weight.unsqueeze(-1) ], dim=-1)).squeeze() edge_index, edge_score = self.symmetrization(edge_index, edge_score) quantile = torch.quantile(edge_score, 1 - rate).item() # if (not with_attack) and self.scorer.training: # # quantile = quantile * 0 # quantile = min(quantile, 0) print(f"denoise threshold: {quantile:.4f}") masked_edge_score = torch.threshold(edge_score, quantile, value=-1e9) denoise_values = (1 - 2 * edge_weight) * \ torch.sigmoid(masked_edge_score) return denoise_values, edge_score
def attack(self, x, edge_index, edge_weight): _, gcn_output = self.gcn_model(x, edge_index, edge_weight) gcn_output = gcn_output.detach() enc_output = self.enc_model(x).detach() edge_score: torch.Tensor = self.scorer( torch.cat( [ gcn_output[edge_index[0]], gcn_output[edge_index[1]], # enc_output[edge_index[0]], # enc_output[edge_index[1]], edge_weight.unsqueeze(-1) ], dim=-1)).squeeze() edge_index, edge_score = self.symmetrization(edge_index, edge_score) quantile = torch.quantile(edge_score, 1 - self.attack_rate).item() print(f"attack threshold: {quantile:.4f}") masked_edge_score = torch.threshold(edge_score, quantile, value=-1e9) # print(f"threshold: {quantile:.4f}") attack_values = (1 - 2 * edge_weight) * \ torch.sigmoid(masked_edge_score) lower_bound = torch.quantile(edge_score, self.denoise_rate).item() pseudo_labels = ((edge_score > quantile) | (edge_score < lower_bound)).to(torch.float) return attack_values, pseudo_labels
def usc(y_s, s_feature, softmax_out_source, n_class, s_centroid, decay=0.3): n, d = s_feature.size() # get labels s_labels = y_s # image number in each class ones = torch.ones_like(s_labels, dtype=torch.float) zeros = torch.zeros(n_class).cuda() s_n_classes = zeros.scatter_add(0, s_labels, ones) # image number cannot be 0, when calculating centroids ones = torch.ones_like(s_n_classes) s_n_classes = torch.max(s_n_classes, ones) # calculating centroids, sum and divide zeros = torch.zeros(n_class, d).cuda() s_sum_feature = zeros.scatter_add( 0, torch.transpose(s_labels.repeat(d, 1), 1, 0), s_feature) zeros = torch.zeros(n_class, n_class).cuda() s_sum_feature2 = zeros.scatter_add( 0, torch.transpose(s_labels.repeat(n_class, 1), 1, 0), softmax_out_source) feature = torch.cat((s_sum_feature, s_sum_feature2), dim=1) current_s_centroid = torch.div(feature, s_n_classes.view(n_class, 1)) #set decay de = torch.threshold(current_s_centroid, 1e-6, -1) de = 1 - torch.threshold(-de, 0, 0) decay = decay * de # Moving Centroid s_centroid = (1 - decay) * s_centroid + decay * current_s_centroid return s_centroid
def forward(self, x): n, c, t, h, w = x.size() if DROP: if DROP_3D: if TEMPORAL_DROP: x = x.permute(0, 2, 1, 3, 4) x = self.drop(x) x = x.permute(0, 2, 1, 3, 4) else: x = self.drop(x) else: x = x.view(n, -1, h, w) x = self.drop(x) else: weight = self.conv(x) if not self.use_relu: weight = sigmoid(weight) weight = threshold(weight, self.thres, 0.) if self.random: noise = torch.rand_like(weight) noise[:, :, ::2] = 1. weight = noise * weight.clone() x = weight[:, :, None] * x.view(n, self.group, -1, t, h, w) return self.net(x.view(n, c, t, h, w))
def f(x): return torch.threshold(x, 0, -10) + x + x + x
def threshold(x: torch.Tensor, th: float, val: float): o = torch.rand_like(x) o = x * torch.threshold(o, th, val) return o
def relu_bt(self, x): threshold = torch.norm(x, p=float("inf")).clone().detach() return -torch.threshold(-F.leaky_relu(x), -threshold, -threshold)
def forward(self, input): x = (input * self._slope) + 0.5 x = torch.threshold(-x, -1, -1) x = torch.threshold(-x, 0, 0) return x
def forward(self, input): if self.inplace: result = torch.threshold_(input, self.delta, self.delta) else: result = torch.threshold(input, self.delta, self.delta) return result