def network_atlas(C, K, alpha, T): datap = [] for i in range(len(C)): datap.append(C[i][:][:]) affinity_networks = snf.make_affinity(datap, K=K, mu=alpha) #The first step in SNF is converting these data arrays into similarity (or "affinity") networks. fused_network_atlas_C = snf.snf(affinity_networks, K=K, alpha=alpha, t=T) # Once we have our similarity networks we can fuse them together. return fused_network_atlas_C
def cal_A(x): ## SNF gene_A = snf.make_affinity(x, metric='cosine', K=20) #N_i gene_A = torch.FloatTensor(gene_A) ## End of SNF ### replace snf with pd.corr() # gene_A = pd.DataFrame(x) # gene_A = gene_A.T.corr() # gene_A = torch.FloatTensor(np.array(gene_A)) # ### End of the replace # ### replace snf with pg.pcorr() # gene_A = pd.DataFrame(x) # gene_A = gene_A.T.pcorr() # gene_A = torch.FloatTensor(np.array(gene_A)) # ### value, index = gene_A.sort(descending=True) index_0 = index[:, :10] #k gene_A_kNN = torch.zeros_like(gene_A) for i in range(len(gene_A)): temp = gene_A[i, index_0[i]] temp = torch.softmax(temp, dim=0) k = 0 for j in index_0[i]: gene_A_kNN[i, j] = temp[k] k = k + 1 return gene_A_kNN
def snf_cal(D): view_num = len(D) k_neighs = 20 mu = 0.4 iter = 20 aff_mat_ls = snf.make_affinity(D, K=k_neighs, mu=mu) if view_num != len(aff_mat_ls): assert "the number of views check fails" # denoise for each network order = 2 alpha = 0.7 ne_aff_mat_ls = [ ne(aff_mat_ls[i], order, k_neighs, alpha) for i in range(view_num) ] # fuse networks fuesd_network = snf.snf(ne_aff_mat_ls[0:3], K=k_neighs, t=iter) ne_fused_network = ne(fuesd_network, order, k_neighs, alpha) D = np.diag(ne_fused_network.sum(axis=1)) L = D - ne_fused_network return L
def cal_A(x): gene_A = snf.make_affinity(x, metric='cosine', K=10) gene_A = torch.FloatTensor(gene_A) value, index = gene_A.sort(descending=True) index_0 = index[:, :10] gene_A_kNN = torch.zeros_like(gene_A) for i in range(len(gene_A)): temp = gene_A[i, index_0[i]] temp = torch.softmax(temp, dim=0) k = 0 for j in index_0[i]: gene_A_kNN[i, j] = temp[k] k = k + 1 return gene_A_kNN
def __snf_based_merge(link_1, link_2): """ snf network merge based on Wang, Bo, et al. Nature methods 11.3 (2014): 333. """ warnings.simplefilter("ignore") node_list = list(set(link_1['source']) & set(link_1['target']) & set(link_2['source']) & set(link_2['target'])) adjlinks = list() adjlinks.append(__linkage_to_adjlink(link_1, node_list)) adjlinks.append(__linkage_to_adjlink(link_2, node_list)) affinity_matrix = snf.make_affinity(adjlinks) fused_network = snf.snf(affinity_matrix) Graph = nx.from_pandas_adjacency(pd.DataFrame(fused_network, index=node_list, columns=node_list)) return pd.DataFrame(Graph.edges, columns=['source', 'target'])
def NAGFS(train_data, train_Labels, Nf, displayResults): XC1 = np.empty((0, train_data.shape[2], train_data.shape[2]), int) XC2 = np.empty((0, train_data.shape[2], train_data.shape[2]), int) # * * (5.1) In this part, Training samples which were chosen last part are seperated as class-1 and class-2 samples. for i in range(len(train_Labels)): if (train_Labels[i] == 1): XC1 = np.append(XC1, [train_data[i, :, :]], axis=0) else: XC2 = np.append(XC2, [train_data[i, :, :]], axis=0) # * * # * * (5.2) SIMLR functions need matrixes which has 1x(N*N) shape.So all training matrixes are converted to this shape. #For C1 group k = np.empty((0, XC1.shape[1] * XC1.shape[1]), int) for i in range(XC1.shape[0]): k1 = np.concatenate(XC1[i]) #it vectorizes all NxN matrixes k = np.append(k, [k1.reshape(XC1.shape[1] * XC1.shape[1])], axis=0) # For C2 group kk = np.empty((0, XC2.shape[1] * XC2.shape[1]), int) for i in range(XC2.shape[0]): kk1 = np.concatenate(XC2[i]) kk = np.append(kk, [kk1.reshape(XC2.shape[1] * XC2.shape[1])], axis=0) # * * # * * (5.3) SIMLR(Single-Cell Interpretation via Multi Kernel Learning) is used to clustering of samples of 2 classes into 3 clusters. #For C1 group #[t1, S2, F2, ydata2,alpha2] = SIMLR(kk,3,2); simlr = SIMLR.SIMLR_LARGE( 3, 4, 0 ) #This is how we initialize an object for SIMLR.The first input is number of rank (clusters) and the second input is number of neighbors.The third one is an binary indicator whether to use memory-saving mode.You can turn it on when the number of cells are extremely large to save some memory but with the cost of efficiency. S1, F1, val1, ind1 = simlr.fit(k) y_pred_X1 = simlr.fast_minibatch_kmeans( F1, 3 ) #This SIMLR function predicts training 1x(N*N) samples what they belong. #to first, second or third clusters.(0,1 or 2) # For C2 group simlr = SIMLR.SIMLR_LARGE(3, 4, 0) S2, F2, val2, ind2 = simlr.fit(kk) y_pred_X2 = simlr.fast_minibatch_kmeans(F2, 3) # * * # * * (5.4) Training samples are placed into their predicted clusters for Class-1 and Class-2 samples. #For XC1, +1 k Ca1 = np.empty((0, XC1.shape[2], XC1.shape[2]), int) Ca2 = np.empty((0, XC1.shape[2], XC1.shape[2]), int) Ca3 = np.empty((0, XC1.shape[2], XC1.shape[2]), int) for i in range(len(y_pred_X1)): if y_pred_X1[i] == 0: Ca1 = np.append(Ca1, [XC1[i, :, :]], axis=0) Ca1 = np.abs(Ca1) elif y_pred_X1[i] == 1: Ca2 = np.append(Ca2, [XC1[i, :, :]], axis=0) Ca2 = np.abs(Ca2) elif y_pred_X1[i] == 2: Ca3 = np.append(Ca3, [XC1[i, :, :]], axis=0) Ca3 = np.abs(Ca3) #For XC2, -1 kk Cn1 = np.empty((0, XC2.shape[2], XC2.shape[2]), int) Cn2 = np.empty((0, XC2.shape[2], XC2.shape[2]), int) Cn3 = np.empty((0, XC2.shape[2], XC2.shape[2]), int) for i in range(len(y_pred_X2)): if y_pred_X2[i] == 0: Cn1 = np.append(Cn1, [XC2[i, :, :]], axis=0) Cn1 = np.abs(Cn1) elif y_pred_X2[i] == 1: Cn2 = np.append(Cn2, [XC2[i, :, :]], axis=0) Cn2 = np.abs(Cn2) elif y_pred_X2[i] == 2: Cn3 = np.append(Cn3, [XC2[i, :, :]], axis=0) Cn3 = np.abs(Cn3) # * * #SNF PROCESS # * * (5.5) SNF(Similarity Network Fusion) is used for create a local centered network atlas which is the best representative matrix #of other similar matrixes.In this process, for every class, there are 3 clusters, so snf create 3 representative-center #matrixes for both classes.After that it create 1 general representative matrixes of 3 matrixes. #So finally there are 2 general representative matrixes. #Ca1 class1 = [] if Ca1.shape[0] > 1: for i in range(Ca1.shape[0]): class1.append(Ca1[i, :, :]) affinity_networks = snf.make_affinity(class1, metric='euclidean', K=20, mu=0.5) AC11 = snf.snf(affinity_networks, K=20) #First local network atlas for C1 group class1 = [] else: AC11 = Ca1[0] #Ca2 class1 = [] if Ca2.shape[0] > 1: for i in range(Ca2.shape[0]): class1.append(Ca2[i, :, :]) affinity_networks = snf.make_affinity(class1, metric='euclidean', K=20, mu=0.5) AC12 = snf.snf(affinity_networks, K=20) #Second local network atlas for C1 group class1 = [] else: AC12 = Ca2[0] #Ca3 class1 = [] if Ca3.shape[0] > 1: for i in range(Ca3.shape[0]): class1.append(Ca3[i, :, :]) affinity_networks = snf.make_affinity(class1, metric='euclidean', K=20, mu=0.5) AC13 = snf.snf(affinity_networks, K=20) #Third local network atlas for C1 group class1 = [] else: AC13 = Ca3[0] #Cn1 if Cn1.shape[0] > 1: class1 = [] for i in range(Cn1.shape[0]): class1.append(Cn1[i, :, :]) affinity_networks = snf.make_affinity(class1, metric='euclidean', K=20, mu=0.5) AC21 = snf.snf(affinity_networks, K=20) #First local network atlas for C2 group class1 = [] else: AC21 = Cn1[0] #Cn2 class1 = [] if Cn2.shape[0] > 1: for i in range(Cn2.shape[0]): class1.append(Cn2[i, :, :]) affinity_networks = snf.make_affinity(class1, metric='euclidean', K=20, mu=0.5) AC22 = snf.snf(affinity_networks, K=20) #Second local network atlas for C2 group class1 = [] else: AC22 = Cn2[0] #Cn3 class1 = [] if Cn3.shape[0] > 1: for i in range(Cn3.shape[0]): class1.append(Cn3[i, :, :]) affinity_networks = snf.make_affinity(class1, metric='euclidean', K=20, mu=0.5) AC23 = snf.snf(affinity_networks, K=20) #Third local network atlas for C2 group class1 = [] else: AC23 = Cn3[0] #A1 AC1 = snf.snf([AC11, AC12, AC13], K=20) #Global network atlas for C1 group #A2 AC2 = snf.snf([AC21, AC22, AC23], K=20) #Global network atlas for C2 group # * * # * * (5.6) In this part, most 5 discriminative connectivities are determined and their indexes are saved in ind array. D0 = np.abs(AC1 - AC2) #find differences between AC1 and AC2 D = np.triu(D0) #Upper triangular part of matrix D1 = D[np.triu_indices(AC1.shape[0], 1)] #Upper triangular part of matrix D1 = D1.transpose() D2 = np.sort(D1) #Ranking features D2 = D2[::-1] Dif = D2[0:Nf] #Extract most 5 discriminative connectivities D3 = [] for i in D1: D3.append(i) ind = [] for i in range(len(Dif)): ind.append(D3.index(Dif[i])) # * * # * * (5.7) Coordinates of most 5 disriminative features are determined for plotting for each iteration if displayresults==1. coord = [] for i in range(len(Dif)): for j in range(D0.shape[0]): for k in range(D0.shape[1]): if Dif[i] == D0[j][k]: coord.append([j, k]) topFeatures = np.zeros((D0.shape[0], D0.shape[1])) s = 0 ss = 0 for i in range(len(Dif) * 2): topFeatures[coord[i][0]][coord[i][1]] = Dif[s] ss += 1 if ss == 2: s += 1 ss = 0 if displayResults == 1: plt.imshow(topFeatures) plt.colorbar() plt.show() # * * return AC1, AC2, ind
def BGSR(train_data, train_labels, HR_features, kn, K1, K2): #These are a reproduction of the closeness, degrees and isDirected functions of aeolianine since I couldn't find a compatible functions in python. def isDirected(adj): adj_transpose = np.transpose(adj) for i in range(len(adj)): for j in range(len(adj[0])): if adj[j][i] != adj_transpose[j][i]: return True return False def degrees(adj): indeg = np.sum(adj, axis=1) outdeg = np.sum(np.transpose(adj), axis=0) if isDirected(adj): deg = indeg + outdeg #total degree else: #undirected graph: indeg=outdeg deg = indeg + np.transpose( np.diag(adj)) #add self-loops twice, if any return deg def closeness(G, adj): c = np.zeros((len(adj), 1)) all_sum = np.zeros((len(adj[1]), 1)) spl = nx.all_pairs_dijkstra_path_length(G, weight="weight") spl_list = list(spl) for i in range(len(adj[1])): spl_dict = spl_list[i][1] c[i] = 1 / sum(spl_dict.values()) return c sz1, sz2, sz3 = train_data.shape # (1) Estimation of a connectional brain template (CBT) CBT = atlas(train_data, train_labels) # (2) Proposed CBT-guided graph super-resolution # Initialization c_degree = np.zeros((sz1, sz2)) c_closeness = np.zeros((sz1, sz2)) c_betweenness = np.zeros((sz1, sz2)) residual = np.zeros( (len(train_data), len(train_data[1]), len(train_data[1]))) for i in range(sz1): residual[i][:][:] = np.abs(train_data[i][:][:] - CBT) #Residual brain graph G = nx.from_numpy_matrix(np.array(residual[i][:][:])) for j in range(0, sz2): c_degree[i][j] = degrees(residual[i][:][:])[j] #Degree matrix c_closeness[i][j] = closeness( G, residual[i][:][:])[j] #Closeness matrix c_betweenness[i][j] = nx.betweenness_centrality( G, weight=True)[j] #Betweenness matrix # Degree similarity matrix simlr1 = SIMLR.SIMLR_LARGE( 1, K1, 0 ) #The first input is number of rank (clusters) and the second input is number of neighbors.The third one is an binary indicator whether to use memory-saving mode.You can turn it on when the number of cells are extremely large to save some memory but with the cost of efficiency. S1, F1, val1, ind1 = simlr1.fit(c_degree) y_pred_X1 = simlr1.fast_minibatch_kmeans(F1, 1) # Closeness similarity matrix simlr2 = SIMLR.SIMLR_LARGE(1, K1, 0) S2, F2, val2, ind2 = simlr2.fit(c_closeness) y_pred_X2 = simlr2.fast_minibatch_kmeans(F2, 1) # Betweenness similarity matrix if not np.count_nonzero(c_betweenness): S3 = np.zeros((len(c_betweenness), len(c_betweenness))) else: simlr3 = SIMLR.SIMLR_LARGE(1, K1, 0) S3, F3, val3, ind3 = simlr3.fit(c_betweenness) y_pred_X3 = simlr3.fast_minibatch_kmeans(F3, 1) alpha = 0.5 # hyperparameter, usually (0.3~0.8) T = 20 # Number of Iterations, usually (10~20) wp1 = snf.make_affinity(S1.toarray(), K=K2, mu=alpha) wp2 = snf.make_affinity(S2.toarray(), K=K2, mu=alpha) wp3 = snf.make_affinity(S3, K=K2, mu=alpha) FSM = snf.snf([wp1, wp2, wp3], K=K2, alpha=alpha, t=T) #Fused similarity matrix FSM_sorted = np.sort(FSM, axis=0) ind = np.zeros((kn, 1)) HR_ind = np.zeros((kn, len(HR_features[1]))) for i in range(1, kn + 1): a, b, pos = np.intersect1d(FSM_sorted[len(FSM_sorted) - i][0], FSM, return_indices=True) ind[i - 1] = pos for j in range(len(HR_features[1])): HR_ind[i - 1][j] = HR_features[int(ind[i - 1][0])][j] pHR = np.mean(HR_ind, axis=0) # Predicted features of the testing subject return pHR