def forward(self, x, to_dense=False): d = super().forward_as_dict(x) f8_3 = F.elu(self.f8_3(d['conv4'])) f8_4 = F.elu(self.f8_4(d['conv5'])) f8_5 = F.elu(self.f8_5(d['conv6'])) x = F.elu(self.f9(torch.cat([f8_3, f8_4, f8_5], dim=1))) if x.size(2) == self.predefined_featuresize and x.size(3) == self.predefined_featuresize: ind_from = self.ind_from ind_to = self.ind_to else: ind_from, ind_to = pyutils.get_indices_of_pairs(5, (x.size(2), x.size(3))) ind_from = torch.from_numpy(ind_from) ind_to = torch.from_numpy(ind_to) x = x.view(x.size(0), x.size(1), -1) if is_cuda_available: ind_from = ind_from.cuda(non_blocking=True) ind_to = ind_to.cuda(non_blocking=True) ff = torch.index_select(x, dim=2, index=ind_from) ft = torch.index_select(x, dim=2, index=ind_to) ff = torch.unsqueeze(ff, dim=2) ft = ft.view(ft.size(0), ft.size(1), -1, ff.size(3)) aff = torch.exp(-torch.mean(torch.abs(ft - ff), dim=1)) if to_dense: aff = aff.view(-1).cpu() ind_from_exp = torch.unsqueeze(ind_from, dim=0).expand(ft.size(2), -1).contiguous().view(-1) indices = torch.stack([ind_from_exp, ind_to]) indices_tp = torch.stack([ind_to, ind_from_exp]) area = x.size(2) indices_id = torch.stack([torch.arange(0, area).long(), torch.arange(0, area).long()]) if is_cuda_available: indices_id = indices_id.cuda() aff = aff.cuda() torch_ones_cuda = torch.ones([area]).cuda() aff_mat = sparse.FloatTensor(torch.cat([indices, indices_id, indices_tp], dim=1), torch.cat([aff, torch_ones_cuda, aff])).to_dense().cuda() else: aff_mat = sparse.FloatTensor(torch.cat([indices, indices_id, indices_tp], dim=1), torch.cat([aff, torch.ones([area]), aff])).to_dense() return aff_mat else: return aff
def __init__(self, data, shape=None): if type(data) is tuple: indices, values = data self._data = tsparse.FloatTensor(indices, values, shape=shape) elif isinstance(data, DTensor): self._data = data._data.to_sparse() elif isinstance(data, STensor): self._data = data._data else: self._data = tsparse.FloatTensor(data, shape=shape) self._data = self._data.cuda().coalesce()
def from_sparse_array(cls, x: sparse.COO): """Construct a sparse tensor from a `sparse.COO`. Parameters ---------- x : sparse.COO Input COO sparse array. Returns ------- STensor Sparse tensor constructed from given sparse array. Raises ------ TypeError Raise if the parameter is not `sparse.COO`. """ if not isinstance(x, sparse.COO): raise TypeError( f"Argument type should be `sparse.SparseArray`, got {type(x)}") indices = torch.from_numpy(x.coords).type(torch.long) values = torch.from_numpy(x.data) shape = torch.Size(x.shape, dtype=torch.long) t = cls.__new__(cls) t._data = tsparse.FloatTensor(indices, values, shape).cuda() t._data = t._data.coalesce() return t
def sparse_select(dims, indices, t): """ Select sparse tensor t on on dimensions dims and indices chosen by indices. Equivalent to t[i_0, i_1, ...] where i_d = : if d is not in dims and i_(dims[j]) = indices[j] for all j """ if type(dims) is not list: dims = [dims] if type(indices) is not list: indices = [indices] t_indices = t._indices() t_values = t._values() selector = torch.ones(t_indices.shape[-1]).byte() for dim, index in zip(dims, indices): selector = selector & (t._indices()[dim, :] == index) remaining_dimensions = list( filter(lambda x: x not in dims, range(t_indices.shape[0]))) indices_selected = t_indices[:, selector][remaining_dimensions, :] values_selected = t_values[selector] new_shape = torch.Size(t.shape[d] for d in remaining_dimensions) out = sp.FloatTensor(indices_selected, values_selected, new_shape) return out
def add_coordinates(self, layer_index, coordinates, lr, avg=1): param_coords = [] gradients = [] s = [] # extract coordinate-gradient pairs and combine gradients at the same coordinate for coord in coordinates: cd = coord[0][1:] coord[1] /= avg if cd in param_coords: parameters[param_coords.index(cd)] += (coord[1]) else: param_coords.append(cd) gradients.append(coord[1]) # get corresponding parameters params = [p for p in self.parameters()] # create coordinate/index tensor i, and value tensor v try: grads = FloatTensor(gradients) shape = list(params[layer_index].size()) if len(shape) > 1: # update parameters with gradients at particular coordinates grads = sparse.FloatTensor( LongTensor(param_coords).t(), grads, Size(shape)).to_dense() params[layer_index].data.add_(-lr * grads) except Exception as e: self.log.exception("Unexpected exception! %s", e)
def scipy_to_pytorch_sparse(coo): values = coo.data indices = np.stack((coo.row, coo.col)) i = torch.LongTensor(indices) v = torch.FloatTensor(values) shape = coo.shape return ts.FloatTensor(i, v, torch.Size(shape))
def from_scipy_sparse(cls, x: scipy.sparse.spmatrix): """Construct a `STensor` from a `scipy.sparse.spmatrix`. Parameters ---------- x : scipy.sparse.spmatrix Input sparse matrix. Returns ------- STensor Sparse tensor constructed from given sparse matrix. Raises ------ TypeError Raise if the parameter is not `scipy.sparse.spmatrix`. """ if not isinstance(x, scipy.sparse.spmatrix): raise TypeError( f"Argument type should be `scipy.sparse.spmatrix`, \ got {type(x)}") x = x.tocoo() indices = torch.from_numpy(np.vstack([x.row, x.col])).type(torch.long) values = torch.from_numpy(x.data) shape = torch.Size(x.shape, dtype=torch.long) t = cls.__new__(cls) t._data = tsparse.FloatTensor(indices, values, shape).cuda() t._data = t._data.coalesce() return t
def _make_sparse(self, indices): i = torch.LongTensor(2, indices.numel()) v = torch.ones(indices.numel()) i[1].copy_(torch.range(0, indices.numel() - 1)) i[0].copy_(indices) return sparse.FloatTensor( i, v, torch.Size([self._weight_size[0], indices.numel()])).contiguous()
def _get_W(x: torch.Tensor, n_Neigbr=15, n_sig=8, target=None): N, d = x.shape # N: number of samples, d: the dimension of the sample data if N < 2: raise ValueError('The number of sample must more than 1!!!') n_Neigb = min(N, n_Neigbr) n_sig = min(n_sig, n_Neigbr) # Calculate the distance X = x.detach().cpu().numpy() nbrs = NearestNeighbors(n_neighbors=n_Neigbr, algorithm='ball_tree').fit(X) dis, idx = nbrs.kneighbors(X) dis2 = np.exp(-dis**2 / dis[:, n_sig - 1:n_sig] / 2) # TV # dis2 = np.exp(- dis**2 / dis[:, n_sig-1:n_sig] ) # Aniso-TV if target is None: M = (n_Neigbr - 1) * N idx_i = torch.cat(( torch.LongTensor(range(M)), torch.LongTensor(range(M)), )) idx_j = torch.cat(( torch.LongTensor(idx[:, 0].repeat(n_Neigbr - 1)), torch.LongTensor(idx[:, 1:].repeat(1)), )) v = torch.cat(( torch.FloatTensor(dis2[:, 1:]).view(-1), -torch.FloatTensor(dis2[:, 1:]).view(-1), )) # print(idx_i.shape, idx_j.shape, v.shape) else: idx_i = [] idx_j = [] v = [] tot = 0 for i in range(N): for k in range(1, n_Neigbr): j = idx[i, k] if target[i] == target[j]: idx_i += [tot, tot] idx_j += [i, j] v += [dis2[i, k], -dis2[i, k]] tot += 1 idx_i = torch.LongTensor(idx_i) idx_j = torch.LongTensor(idx_j) v = torch.FloatTensor(v) M = tot return sparse.FloatTensor( torch.cat((idx_i.view(1, -1), idx_j.view(1, -1))), v, torch.Size([M, N]))
def get_sparse_tensor(idxs, vals, dim=74000): rows = torch.from_numpy(np.zeros(len(idxs), dtype='int64')).view(1, -1) cols = torch.from_numpy(np.array(idxs, dtype='int64')).view(1, -1) i = torch.cat((rows, cols), dim=0) vals = np.ones(len(idxs), dtype='int64') #TODO use value? v = torch.from_numpy(np.array(vals, dtype='float32')) sparse_matrix = sparse.FloatTensor(i, v, torch.Size([1, dim])) # print(sparse_matrix) return sparse_matrix
def forward(self, x_input, to_dense=False): self.eval() d = self.forward_as_dict(x_input) f8_3 = F.elu(self.f8_3(d['conv4'])) f8_4 = F.elu(self.f8_4(d['conv5'])) f8_5 = F.elu(self.f8_5(d['conv6'])) x = F.elu(self.f9(torch.cat([f8_3, f8_4, f8_5], dim=1))) if x.size(2) == self.predefined_featuresize and x.size(3) == self.predefined_featuresize: ind_from = self.ind_from ind_to = self.ind_to else: ind_from, ind_to = get_indices_of_pairs(5, (x.size(2), x.size(3))) ind_from = torch.from_numpy(ind_from); ind_to = torch.from_numpy(ind_to) x = x.view(x.size(0), x.size(1), -1) ff = torch.index_select(x, dim=2, index=ind_from.cuda(non_blocking=True)) ft = torch.index_select(x, dim=2, index=ind_to.cuda(non_blocking=True)) ff = torch.unsqueeze(ff, dim=2) ft = ft.view(ft.size(0), ft.size(1), -1, ff.size(3)) aff = torch.exp(-torch.mean(torch.abs(ft-ff), dim=1)) if to_dense: aff = aff.view(-1).cpu() ind_from_exp = torch.unsqueeze(ind_from, dim=0).expand(ft.size(2), -1).contiguous().view(-1) indices = torch.stack([ind_from_exp, ind_to]) indices_tp = torch.stack([ind_to, ind_from_exp]) area = x.size(2) indices_id = torch.stack([torch.arange(0, area).long(), torch.arange(0, area).long()]) aff_mat = sparse.FloatTensor(torch.cat([indices, indices_id, indices_tp], dim=1), torch.cat([aff, torch.ones([area]), aff])).to_dense().cuda() return aff_mat else: aff_mat = torch.zeros((x.shape[-1],x.shape[-1])).cuda() aff = aff.view(-1) ind_from_exp = torch.unsqueeze(ind_from, dim=0).expand(ft.size(2), -1).contiguous().view(-1) indices = torch.stack([ind_from_exp, ind_to]) indices_tp = torch.stack([ind_to, ind_from_exp]) area = x.size(2) indices_id = torch.stack([torch.arange(0, area).long(), torch.arange(0, area).long()]) rows_cols = torch.cat([indices.cuda(), indices_id.cuda(), indices_tp.cuda()], dim=1) values = torch.cat([aff, torch.ones([area]).cuda(), aff]) aff_mat[rows_cols[0], rows_cols[1]] = values return aff_mat
def sparse_scipy2torch(w: sp.coo_matrix): """ build pytorch sparse tensor from scipy sparse matrix reference: https://stackoverflow.com/questions/50665141 :return: """ shape = w.shape i = torch.tensor(np.vstack((w.row, w.col)).astype(int)).long() v = torch.tensor(w.data).float() return sparse.FloatTensor(i, v, torch.Size(shape))
def to_sparse_tensor(mat): """ Converts a SciPy sparse matrix into a torch sparse tensor. """ if isinstance(mat, ssp.csr_matrix) or isinstance(mat, ssp.csc_matrix): mat = mat.tocoo() data = mat.data indices = np.concatenate((mat.row.reshape(1, -1), mat.col.reshape(1, -1)), axis=0) sparse_mat = sp.FloatTensor(torch.LongTensor(indices), torch.FloatTensor(data), torch.Size(mat.shape)) return sparse_mat
def sparsify_tensor(tensor): """Convert a torch.Tensor into a torch.sparse.FloatTensor Args: tensor (torch.Tensor) returns: sparse (torch.sparse.Tensor) """ ij = tensor.nonzero() if len(ij) > 0: v = tensor[ij[:, 0], ij[:, 1]] return sp.FloatTensor(ij.t(), v, tensor.size()) else: return 0
def get_kd_sparse_tensor(idxsls, dim=74000): rowsls = [] for k in range(len(idxsls)): for j in range(len(idxsls[k])): rowsls.append(k) rows = torch.from_numpy(np.array(rowsls, dtype='int64')).view(1, -1) idxseries = [] for k in idxsls: idxseries.extend(k) cols = torch.from_numpy(np.array(idxseries, dtype='int64')).view(1, -1) i = torch.cat((rows, cols), dim=0) vals = np.ones(len(idxseries), dtype='int64') #TODO use value? v = torch.from_numpy(np.array(vals, dtype='float32')) sparse_matrix = sparse.FloatTensor(i, v, torch.Size([len(idxsls), dim])) # print(sparse_matrix)D return sparse_matrix
def normalize_adj(adj): """Symmetrically normalize adjacency matrix.""" adj = adj.coalesce() sp_adj = sp.coo_matrix((adj.values(), adj.indices()), shape=list(adj.size())) rowsum = np.array(sp_adj.sum(axis=1)) d_inv_sqrt = np.power(rowsum, -0.5).flatten() d_inv_sqrt[np.isinf(d_inv_sqrt)] = 0. d_mat_inv_sqrt = sp.diags(d_inv_sqrt) norm_sp_adj = sp_adj.dot(d_mat_inv_sqrt).transpose().dot( d_mat_inv_sqrt).tocoo() entries = norm_sp_adj.data row = norm_sp_adj.row col = norm_sp_adj.col indices = torch.LongTensor([row, col]) entries = torch.FloatTensor(entries) return sparse.FloatTensor(indices, entries, adj.size())
def collate(batch): dim = 74000 propensity = torch.cat([x['p'] for x in batch]).view(len(batch), 1) label = torch.cat([x['label'] for x in batch]).view(len(batch), 1) # propensity label batch * 1 rows = [] cols = [] for i in range(len(batch)): cols.extend(batch[i]['idx']) for k in range(len(batch[i]['idx'])): rows.append(i) Rows = torch.from_numpy(np.array(rows, dtype='int64')).view(1, -1) Cols = torch.from_numpy(np.array(cols, dtype='int64')).view(1, -1) i = torch.cat((Rows, Cols), dim=0) vals = np.ones(len(cols), dtype='float32') v = torch.from_numpy(np.array(vals, dtype='float32')) batch_sparse_matrix = sparse.FloatTensor(i, v, torch.Size([len(batch), dim])) return {'p': propensity, 'feature': batch_sparse_matrix, 'label': label}
def forward(self, x, adj): if x.is_sparse: wh = sparse.mm(x, self.weight).view(-1, self.nheads, self.out_features) else: x = F.dropout(x, p=self.dropout, training=self.training) wh = torch.mm(x, self.weight).view(-1, self.nheads, self.out_features) awh_i = (wh * self.linear_i).sum(dim=2) awh_j = (wh * self.linear_j).sum(dim=2) idx_i, idx_j = adj._indices() e_values = F.leaky_relu(awh_i[idx_i] + awh_j[idx_j], negative_slope=self.alpha) e = sparse.FloatTensor(adj._indices(), e_values) a = sparse.softmax(e.cpu(), dim=1).to(e.device) # Choose memory / speed tradeoff # keep_sparse = True : Loop through sparse tensor (Low memory usage / Slow) # keep_sparse = False : Convert sparse tensor to dense tensor (High memory usage / Fast) # Both methods return almost identical results keep_sparse = False if keep_sparse: x = torch.cat([(a[i]._values().unsqueeze(dim=2) * wh[a[i]._indices()[0]]).sum(dim=0, keepdim=True) for i in range(x.shape[0])], dim=0) else: a = a.to_dense().unsqueeze(dim=3) wh = wh.unsqueeze(dim=0) x = (a * wh).sum(dim=1) if self.concat: return x.flatten(start_dim=1) else: return x.mean(dim=1)
def __init__(self, original_conv): super(M2MSparseConv, self).__init__() # Math attributes self.IN_CH = original_conv.in_channels self.OUT_CH = original_conv.out_channels if isinstance(original_conv.kernel_size, int): self.K_W, self.K_H = original_conv.kernel_size, original_conv.kernel_size else: self.K_W, self.K_H = original_conv.kernel_size if isinstance(original_conv.padding, int): self.P_W, self.P_H = original_conv.padding, original_conv.padding else: self.P_W, self.P_H = original_conv.padding if isinstance(original_conv.stride, int): self.S_W, self.S_H = original_conv.stride, original_conv.stride else: self.S_W, self.S_H = original_conv.stride # Parameters if type(original_conv) is SoftMaskedConv2d: params = original_conv.weight * original_conv.mask else: params = original_conv.weight W = params.view(self.OUT_CH, -1) shape = W.shape indexes = torch.where(W != 0) indexes = torch.stack([indexes[0], indexes[1]]) values = W.flatten()[W.flatten() != .0] self.W = sparse.FloatTensor(indexes, values, shape) self.B = None if hasattr(original_conv, 'bias'): if original_conv.bias is not None: self.B = \ original_conv.bias.data.unsqueeze(1).unsqueeze(2).unsqueeze(0)
def __call__(self, data): assert data.face is not None assert data.face_curvature is not None assert data.face_weight is not None # Prepare the initial local coordinate system device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') # device = torch.device('cpu') norms = data.norm.to(device) positions = data.pos.to(device) faces = data.face.to(device) face_id = torch.tensor(list(range(len(faces.t())))).to( device) # checked face0 = faces[0] # checked face1 = faces[1] # checked face2 = faces[2] # checked weights = data.face_weight # checked f_curv = data.face_curvature face0 = torch.stack((face_id, face0), dim=0).t() # checked face1 = torch.stack((face_id, face1), dim=0).t() # checked face2 = torch.stack((face_id, face2), dim=0).t() # checked weights = data.face_weight * torch.ones(len(face0), dtype=torch.long).to(device) sparse_size = torch.Size((faces.shape[1], len(positions))) # checked sparse_face0 = tsp.FloatTensor( torch.LongTensor(face0).t(), weights, sparse_size).to(device) # .to_dense() # checked sparse_face1 = tsp.FloatTensor( torch.LongTensor(face1).t(), weights, sparse_size).to(device) # .to_dense() # checked sparse_face2 = tsp.FloatTensor( torch.LongTensor(face2).t(), weights, sparse_size).to(device) # .to_dense() # checked weighted_faces = sparse_face0 + sparse_face1 + sparse_face2 # checked weighted_faces = weighted_faces.coalesce() # checked On older pytorch have to cast to float weighted_faces = weighted_faces.t() node_curv = tsp.mm(weighted_faces, f_curv) sum_weights_per_node = tsp.sum(weighted_faces, dim=1).to_dense() # checked node_curv = node_curv.t() / sum_weights_per_node # checked node_curv = node_curv.t() eigs = [] for i in node_curv: # checked eig = torch.eig(i.reshape(2, 2)) principal_curvatures = eig.eigenvalues[:, 0].sort( descending=True).values eigs.append(principal_curvatures) eigs = torch.stack(eigs, dim=0) s_s = eigs[:, 0] + eigs[:, 1] s_p = eigs[:, 0] - eigs[:, 1] s = s_s.div(s_p) pi = math.pi * torch.ones(len(positions)).to(device) s = (2 / pi) * torch.atan(s) data.shape_index = s if self.remove: data.face_curvature = None data.face_weights = None data.face_normals = None return data
def get_probabilities(self, train_iter): TEXT = self.TEXT V = self.V unigram = sp.FloatTensor(V) bigram = sp.FloatTensor(V, V) trigram = sp.FloatTensor(V, V, V) for batch in tqdm(train_iter): i = batch.text.values.flatten().unsqueeze(0) unigram_counts = sp.FloatTensor(i, torch.ones(i.shape[1]), torch.Size([V])) unigram += unigram_counts ii = torch.stack( [batch.text.values[:-1, :], batch.text.values[1:, :]]).view(2, -1) bigram_counts = sp.FloatTensor(ii, torch.ones(ii.shape[-1]), torch.Size([V, V])) bigram += bigram_counts iii = torch.stack([ batch.text.values[:-2, :], batch.text.values[1:-1, :], batch.text.values[2:, :] ]).view(3, -1) trigram_counts = sp.FloatTensor(iii, torch.ones(iii.shape[-1]), torch.Size([V, V, V])) trigram += trigram_counts unigram = unigram.coalesce() unigram = unigram / sp.sum(unigram) bigram = bigram.coalesce() trigram = trigram.coalesce() bigram_df = pd.DataFrame(np.hstack([ bigram.indices().numpy().T, bigram.values().numpy()[:, np.newaxis] ]), dtype=int, columns=['word1', 'word2', 'counts']) trigram_df = pd.DataFrame( np.hstack([ trigram.indices().numpy().T, trigram.values().numpy()[:, np.newaxis] ]), dtype=int, columns=['word1', 'word2', 'word3', 'counts']) bigram_df['prob'] = ( (bigram_df['counts'] / bigram_df.groupby(['word1']).transform('sum')['counts'])) bigram_ind = torch.from_numpy(bigram_df[['word1', 'word2']].values.T) bigram_val = torch.from_numpy(bigram_df['prob'].values) bigram = torch.sparse.FloatTensor(bigram_ind, bigram_val, bigram.shape) trigram_df['prob'] = ( trigram_df['counts'] / trigram_df.groupby(['word1', 'word2']).transform('sum')['counts']) trigram_ind = torch.from_numpy(trigram_df[['word1', 'word2', 'word3']].values.T) trigram_val = torch.from_numpy(trigram_df['prob'].values) trigram = torch.sparse.FloatTensor(trigram_ind, trigram_val, trigram.shape) self.unigram = unigram.float() self.bigram = bigram.float() self.trigram = trigram.float()
def scsp2tsp(mat): return tsp.FloatTensor( torch.from_numpy(np.stack([mat.row, mat.col])).long(), torch.from_numpy(mat.data).float(), mat.shape)
def top_k_contact_metrics(features, logits, dist_matrices, seq_lens, k=5, contact_range='long', sequence_position_index1=0, sequence_position_index2=22, ang8_bin=8, **kwargs): """Calculates metrics for the top L/k predicted contacts :param logits: The logits to generate probabilities from. Should have shape (batch, logits, n, n). :type logits: torch.Tensor :param true_dist_mat: :param k: :param kwargs: kwargs to pas to top_k_contacts :return: """ from src.viz import heatmap2d features = torch.einsum('bcij -> bijc', features) # Get mask from the non-positive distances of the distance matrix # (ignores 0 as well because those are not counted in the top-k metric according to CASP) mask = torch.zeros(dist_matrices.shape, dtype=torch.uint8) mask[dist_matrices > 0] = 1 residue_distances = features[:, :, :, sequence_position_index1] - features[:, :, :, sequence_position_index2] residue_distances[~mask] = 0 # Use only the bottom diagonal side of the distance matrix, residue_distances[residue_distances <= 0] = 0 lower_bound, upper_bound = seperation_ranges[contact_range] mask[(residue_distances < lower_bound).__or__( residue_distances > upper_bound)] = 0 # Turn sparse representation into dense, byte representation predicted_contacts = top_k_predictions_(logits, seq_lens, k=k, mask=mask, ang8_bin=ang8_bin) print(predicted_contacts) indices = torch.stack([predicted_contacts[:, 0], predicted_contacts[:, 1]]).long() values = torch.ones(predicted_contacts.shape[0]) predicted_contact_mat = sparse.FloatTensor(indices, values, dist_mat.size()) predicted_contact_mat = predicted_contact_mat.to_dense().byte() dist_matrices[~mask] = -1 true_contact_matrices = (dist_matrices < ang8_bin).__and__( dist_matrices > 0) # True positive, False positive, False negative calculations tp = len( predicted_contact_mat[predicted_contact_mat.__and__(true_contact_mat)]) fp = int(predicted_contacts.shape[0]) - tp fn = total_contacts - tp # Calculate metrics if tp + fp == 0: precision = float('nan') else: precision = tp / float(tp + fp) if tp + fn == 0: recall = float('nan') else: recall = tp / float(tp + fn) if precision + recall == 0: f1 = float('nan') else: f1 = (2 * precision * recall) / (precision + recall) return torch.Tensor([precision, recall, f1])
def forward(self, adj, size): val = t.ones(size) x = sp.FloatTensor(adj, val, size=(size, size)) x = sp.mm(x, self.weight)
def get_affinity(self, image, dense=False): output = self.features(image) l1 = self.intermediate_outputs[0] l1 = self.pool1(l1) l1 = self.dimreduce_1(l1) l2 = self.intermediate_outputs[1] l2 = self.dimreduce_2(l2) l3 = output l3 = self.dimreduce_3(l3) comb = torch.cat([l1, l2, l3], dim=1) comb = self.dimreduce_final(comb) x = comb self.intermediate_outputs.clear() if x.size(2) == self.predefined_featuresize and x.size( 3) == self.predefined_featuresize: ind_from = self.ind_from ind_to = self.ind_to else: ind_from, ind_to = get_indices_of_pairs(5, (x.size(2), x.size(3))) ind_from = torch.from_numpy(ind_from) ind_to = torch.from_numpy(ind_to) x = x.view(x.size(0), x.size(1), -1) ff = torch.index_select(x, dim=2, index=ind_from.cuda(non_blocking=True)) ft = torch.index_select(x, dim=2, index=ind_to.cuda(non_blocking=True)) ff = torch.unsqueeze(ff, dim=2) ft = ft.view(ft.size(0), ft.size(1), -1, ff.size(3)) aff = torch.abs(ft - ff) aff = torch.mean(aff, dim=1) aff = torch.exp(-aff) if dense: aff = aff.view(-1).cpu() ind_from_exp = torch.unsqueeze(ind_from, dim=0).expand( ft.size(2), -1).contiguous().view(-1) indices = torch.stack([ind_from_exp, ind_to]) indices_tp = torch.stack([ind_to, ind_from_exp]) area = x.size(2) indices_id = torch.stack( [torch.arange(0, area).long(), torch.arange(0, area).long()]) aff_mat = sparse.FloatTensor( torch.cat([indices, indices_id, indices_tp], dim=1), torch.cat([aff, torch.ones([area]), aff])).to_dense().cuda() return aff_mat else: return aff
def forward(self, x, to_dense=False, name=None, save_feature=False): d = super().forward_as_dict(x) f8_3 = F.elu(self.f8_3(d['conv4'])) f8_4 = F.elu(self.f8_4(d['conv5'])) f8_5 = F.elu(self.f8_5(d['conv6'])) x = F.elu(self.f9(torch.cat([f8_3, f8_4, f8_5], dim=1))) # [1,448,46,63] """ ============ save pixel feature ============ """ if save_feature: if not op.exists("AFF_FEATURE_res38"): os.mkdir("AFF_FEATURE_res38") np.save(op.join("AFF_FEATURE_res38", name), x.clone().cpu().numpy()) if x.size(2) == self.predefined_featuresize and x.size( 3) == self.predefined_featuresize: ind_from = self.ind_from ind_to = self.ind_to else: ind_from, ind_to = pyutils.get_indices_of_pairs( 5, (x.size(2), x.size(3))) ind_from = torch.from_numpy(ind_from) ind_to = torch.from_numpy(ind_to) # """ ============ save aff_feature ============ """ # print("x.shape ", x.shape) # np.save(file=op.join("AFF_FEATURE", name), # arr=x.clone().cpu().numpy(), # allow_pickle=True) x = x.view(x.size(0), x.size(1), -1) # [1,448,46*63=2898] ff = torch.index_select( x, dim=2, index=ind_from.cuda(non_blocking=True)) # [1,448,46*63] ft = torch.index_select( x, dim=2, index=ind_to.cuda(non_blocking=True)) # [1,448,46*63] ff = torch.unsqueeze(ff, dim=2) ft = ft.view(ft.size(0), ft.size(1), -1, ff.size(3)) # [1,448,34,2310] aff = torch.exp(-torch.mean(torch.abs(ft - ff), dim=1)) # [1,34,2310] if to_dense: # True aff = aff.view(-1).cpu() ind_from_exp = torch.unsqueeze(ind_from, dim=0).expand( ft.size(2), -1).contiguous().view(-1) # [78540] indices = torch.stack([ind_from_exp, ind_to]) # [2,78540] indices_tp = torch.stack([ind_to, ind_from_exp]) # [2,78540] area = x.size(2) # 2898 # [2,2898] indices_id = torch.stack( [torch.arange(0, area).long(), torch.arange(0, area).long()]) # === sparse.floatTensor(coordinate,value) # e.g. 0 0 3 # 3 0 5 # coordinate =[[0 1 1], # [2 0 2]] # value =[3,4,5] aff_mat = sparse.FloatTensor( torch.cat([indices, indices_id, indices_tp], dim=1), # coordinate torch.cat([aff, torch.ones([area]), aff])).to_dense().cuda() # scalar return aff_mat # [2898,2898] tensor else: return aff
# print(para.size()) for t in rand_pos: input[t] = float(1) t_rand_pos = torch.from_numpy(rand_pos).long() row_indices = torch.zeros(edge_node).long() indices = torch.cat((row_indices.view(1, -1), t_rand_pos.view(1, -1)), dim=0) v = torch.ones(indices.size()[-1]) size = torch.Size([1, node_num]) print(indices) print(v) print(size) x = ts.FloatTensor(indices, v, size) print(model) if torch.cuda.is_available(): # sparse tensor do not support .cuda() print(edge_node) indices.cuda() v.cuda() input = x.cuda() print(input.dtype) print(type(x.cuda())) model.cuda() print(model(input)) # x.cuda(device=3) # model.cuda(device=3)
def load_sparse_tensor(filepath): x_dict = torch.load(filepath) return sparse.FloatTensor(x_dict['indices'], x_dict['values'], x_dict['size'])
def build_adj_matrix(corpus, vocabulary, num_documents, doc_offset=0, window_size=20): """ Builds the adjacency matrix A for the text-document graph A_ij = max(0, PMI(i,j)) if i, j are words (0 if PMI <= 0) = TF-IDF(i,j) if i is a document and j is a word (or opposite) = 1 if i = j = 0 otherwise """ num_words = len(vocabulary) num_vertices = num_words + num_documents word_to_index = {w: i for i, w in enumerate(vocabulary)} # nonzero entries in the adjacency matrix entries = [] # indices for the entries row = [] col = [] print('Building word frequencies per doc') word_freqs_per_doc = {} for i, doc in enumerate(tqdm(corpus)): doc_idx = num_words + doc_offset + i word_freq = {} text = doc.text for word in text: if word not in vocabulary: word = '<unk>' if word in word_freq: word_freq[word] += 1 else: word_freq[word] = 1 word_freqs_per_doc[doc_idx] = word_freq ### PMI calculations print('Building word frequencies per window') num_windows = 0 word_window_occurrences = defaultdict(int) word_pair_window_occurrences = defaultdict( int) # keys are tuples (x,y) where x < y are strings for doc in tqdm(corpus): text = doc.text for window_start_idx in range(max(1, len(text) - window_size + 1)): num_windows += 1 window = text[window_start_idx:window_start_idx + window_size] distinct_words = list(set(window)) for word in distinct_words: word_window_occurrences[word] += 1 for i in range(len(distinct_words)): for j in range(i + 1, len(distinct_words)): word1, word2 = distinct_words[i], distinct_words[j] if word2 < word1: word1, word2 = word2, word1 key = (word1, word2) word_pair_window_occurrences[key] += 1 # get rid of defaultdict behavior word_window_occurrences = dict(word_window_occurrences) word_pair_window_occurrences = dict(word_pair_window_occurrences) print('Calculating PMIs') for pair, pair_freq in tqdm(word_pair_window_occurrences.items()): word1, word2 = pair w1_idx, w2_idx = word_to_index[word1], word_to_index[word2] freq1 = word_window_occurrences[word1] freq2 = word_window_occurrences[word2] # PMI = P(i and j) / (P(i) * P(j)) where P(i and j) = #windows with i and j / #windows # and P(i) = #windows with i / #windows pmi = log((pair_freq * num_windows) / (freq1 * freq2)) if pmi <= 0: continue entries.append(pmi) row.append(w1_idx) col.append(w2_idx) entries.append(pmi) row.append(w2_idx) col.append(w1_idx) ### TF-IDF calculations print('Calculating TF-IDF') for w_idx, word in enumerate(tqdm(vocabulary)): doc_occurrences = 0 for doc_idx, freqs in word_freqs_per_doc.items(): if word in freqs: doc_occurrences += 1 if doc_occurrences == 0: continue idf = log(num_documents / doc_occurrences) for doc_idx, freqs in word_freqs_per_doc.items(): if word in freqs and freqs[word] > 0: entries.append(freqs[word] * idf) row.append(w_idx) col.append(doc_idx) entries.append(freqs[word] * idf) row.append(doc_idx) col.append(w_idx) ### 1s for identities print('Identities') for i in trange(num_vertices): entries.append(1) row.append(i) col.append(i) indices = torch.LongTensor([row, col]) entries = torch.FloatTensor(entries) return sparse.FloatTensor(indices, entries, torch.Size([num_vertices, num_vertices]))
idx_val = th.arange(len(x_train), len(x_train) + len(x_val)).to(device) idx_test = th.arange(len(x_train) + len(x_val), len(x)).to(device) k = 2 n = len(x) p = [th.sum(y == 0), th.sum(y == 1)] # TODO c_in = args.c_in c_out = args.c_out q = np.ones([k, k]) * c_out / n q[range(k), range(k)] *= c_in / c_out A, _ = sbm.generate(n, p, q) op = sps.coo_matrix(getattr(operators, args.op)(A)) idx = th.from_numpy(np.vstack([op.row, op.col])).long() dat = th.from_numpy(op.data).float() a = ths.FloatTensor(idx, dat, [n, n]).to(device) network_args = getattr(args, args.network + '_args') if hasattr(network_args, 'n_feats'): if network_args.n_feats is None: network_args.n_feats = [x.shape[1], k] else: network_args.n_feats = [x.shape[1]] + network_args.n_feats + [k] else: network_args.in_feats = x.shape[1] network_args.out_feats = k network = __import__(args.network).Network(**vars(network_args)).to(device) optim_args = getattr(args, args.optim.lower() + '_args') optimizer = getattr(optim, args.optim)(network.parameters(), **vars(optim_args))