gsMap 1.66__py3-none-any.whl → 1.70__py3-none-any.whl

gsMap/GNN_VAE/adjacency_matrix.py

@@ -1,95 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Created on Tue Jul  4 21:31:27 2023
-
-@author: songliyang
-"""
-import numpy as np
-import pandas as pd
-import scipy.sparse as sp
-import sklearn.neighbors
-import torch
-
-
-def Cal_Spatial_Net(adata, n_neighbors=5, verbose=True):
-    """\
-    Construct the spatial neighbor networks.
-    """
-    #- 
-    if verbose:
-        print('------Calculating spatial graph...')
-    coor = pd.DataFrame(adata.obsm['spatial'])
-    coor.index = adata.obs.index
-    #- 
-    nbrs = sklearn.neighbors.NearestNeighbors(n_neighbors=n_neighbors).fit(coor)
-    #- 
-    distances, indices = nbrs.kneighbors(coor, return_distance=True)
-    KNN_list = []
-    for it in range(indices.shape[0]):
-        KNN_list.append(pd.DataFrame(zip([it]*indices[it].shape[0], indices[it], distances[it])))
-    #- 
-    KNN_df = pd.concat(KNN_list)
-    KNN_df.columns = ['Cell1', 'Cell2', 'Distance']
-    #- 
-    Spatial_Net = KNN_df.copy()
-    Spatial_Net = Spatial_Net.loc[Spatial_Net['Distance']>0,]
-    id_cell_trans = dict(zip(range(coor.shape[0]), np.array(coor.index), ))
-    Spatial_Net['Cell1'] = Spatial_Net['Cell1'].map(id_cell_trans)
-    Spatial_Net['Cell2'] = Spatial_Net['Cell2'].map(id_cell_trans)
-    #- 
-    return Spatial_Net
-
-
-def sparse_mx_to_torch_sparse_tensor(sparse_mx):
-    """Convert a scipy sparse matrix to a torch sparse tensor."""
-    sparse_mx = sparse_mx.tocoo().astype(np.float32)
-    indices = torch.from_numpy(np.vstack((sparse_mx.row, sparse_mx.col)).astype(np.int64))
-    values = torch.from_numpy(sparse_mx.data)
-    shape = torch.Size(sparse_mx.shape)
-    return torch.sparse.FloatTensor(indices, values, shape)
-
-
-def preprocess_graph(adj):
-    adj = sp.coo_matrix(adj)
-    adj_ = adj + sp.eye(adj.shape[0])
-    rowsum = np.array(adj_.sum(1))
-    degree_mat_inv_sqrt = sp.diags(np.power(rowsum, -0.5).flatten())
-    adj_normalized = adj_.dot(degree_mat_inv_sqrt).transpose().dot(degree_mat_inv_sqrt).tocoo()
-    return sparse_mx_to_torch_sparse_tensor(adj_normalized)
-
-
-
-def Construct_Adjacency_Matrix(adata,Params, verbose=True):
-    # Construct the neighbor graph 
-    Spatial_Net = Cal_Spatial_Net(adata, n_neighbors=Params.n_neighbors)
-    #- 
-    if verbose:
-        print('The graph contains %d edges, %d cells.' %(Spatial_Net.shape[0], adata.n_obs))
-        print('%.2f neighbors per cell on average.' %(Spatial_Net.shape[0]/adata.n_obs))
-    #-  
-    cells = np.array(adata.obs.index)
-    cells_id_tran = dict(zip(cells, range(cells.shape[0])))
-    #- 
-    G_df = Spatial_Net.copy()
-    G_df['Cell1'] = G_df['Cell1'].map(cells_id_tran)
-    G_df['Cell2'] = G_df['Cell2'].map(cells_id_tran)
-    #- 
-    if Params.weighted_adj:
-        distance_normalized = G_df.Distance/(max(G_df.Distance)+1)
-        adj_org = sp.coo_matrix((np.exp(-distance_normalized**2/(2)), (G_df['Cell1'], G_df['Cell2'])), shape=(adata.n_obs, adata.n_obs))
-    else:
-        adj_org = sp.coo_matrix((np.ones(G_df.shape[0]), (G_df['Cell1'], G_df['Cell2'])), shape=(adata.n_obs, adata.n_obs))
-    #- 
-    adj_m1 = adj_org
-    adj_norm_m1 = preprocess_graph(adj_m1)
-    adj_label_m1 = adj_m1 + sp.eye(adj_m1.shape[0])
-    norm_m1 = adj_m1.shape[0] * adj_m1.shape[0] / float((adj_m1.shape[0] * adj_m1.shape[0] - adj_m1.sum()) * 2)
-    #- 
-    graph_dict = {
-        "adj_org": adj_org,
-        "adj_norm": adj_norm_m1,
-        "norm_value": norm_m1
-    }
-    #- 
-    return graph_dict

gsMap/GNN_VAE/model.py

@@ -1,87 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Created on Mon Jul  3 11:42:44 2023
-
-@author: songliyang
-"""
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torch_geometric.nn import GATConv
-
-
-def full_block(in_features, out_features, p_drop):
-    return nn.Sequential(nn.Linear(in_features, out_features),
-                         nn.BatchNorm1d(out_features),
-                         nn.ELU(),
-                         nn.Dropout(p=p_drop))
-
-
-class GNN(nn.Module):
-    def __init__(self, in_features, out_features, dr=0, act=F.relu,heads=1):
-        super().__init__()
-        self.conv1 = GATConv(in_features, out_features,heads)
-        self.act = act
-        self.dr = dr
-    #-
-    def forward(self, x, edge_index):
-        out = self.conv1(x, edge_index)
-        out = self.act(out)
-        out = F.dropout(out, self.dr, self.training)
-        return out
-
-
-    
-class GNN_VAE_Model(nn.Module):
-    def __init__(self, input_dim,params,num_classes=1):
-        super(GNN_VAE_Model, self).__init__()
-        self.var = params.var
-        self.num_classes = num_classes
-            
-        # Encoder
-        self.encoder = nn.Sequential()
-        self.encoder.add_module('encoder_L1', full_block(input_dim, params.feat_hidden1, params.p_drop))
-        self.encoder.add_module('encoder_L2', full_block(params.feat_hidden1, params.feat_hidden2, params.p_drop))
-        
-        # GNN (GAT)
-        self.gn1 = GNN(params.feat_hidden2, params.gat_hidden1, params.p_drop, act=F.relu,heads = params.nheads)
-        self.gn2 = GNN(params.gat_hidden1*params.nheads, params.gat_hidden2, params.p_drop, act=lambda x: x)
-        self.gn3 = GNN(params.gat_hidden1*params.nheads, params.gat_hidden2, params.p_drop, act=lambda x: x) 
-        
-        # Decoder
-        self.decoder = nn.Sequential()
-        self.decoder.add_module('decoder_L1', full_block(params.gat_hidden2, params.feat_hidden2, params.p_drop))
-        self.decoder.add_module('decoder_L2', full_block(params.feat_hidden2, params.feat_hidden1, params.p_drop))
-        self.decoder.add_module('decoder_output', nn.Sequential(nn.Linear(params.feat_hidden1, input_dim)))
-        
-        # Cluster
-        self.cluster = nn.Sequential()
-        self.cluster.add_module('cluster_L1', full_block(params.gat_hidden2, params.feat_hidden2, params.p_drop))
-        self.cluster.add_module('cluster_output', nn.Linear(params.feat_hidden2, self.num_classes))
-           
-    def encode(self, x, adj):
-        feat_x = self.encoder(x)
-        hidden1 = self.gn1(feat_x, adj)
-        mu = self.gn2(hidden1, adj)
-        if self.var:
-            logvar = self.gn3(hidden1, adj)
-            return mu, logvar
-        else:
-            return mu, None
-     
-    def reparameterize(self, mu, logvar):
-        if self.training and logvar is not None:
-            std = torch.exp(logvar)
-            eps = torch.randn_like(std)
-            return eps.mul(std).add_(mu)
-        else:
-            return mu
-    
-    def forward(self, x, adj):
-        mu, logvar = self.encode(x, adj)
-        gnn_z = self.reparameterize(mu, logvar)
-        x_reconstructed = self.decoder(gnn_z)
-        pred_label = F.softmax(self.cluster(gnn_z),dim=1)
-        return pred_label, x_reconstructed, gnn_z, mu, logvar

gsMap/GNN_VAE/train.py

@@ -1,97 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Created on Tue Jul  4 19:58:58 2023
-
-@author: songliyang
-"""
-import time
-
-import torch
-from progress.bar import Bar
-
-from gsMap.GNN_VAE.model import GNN_VAE_Model
-
-
-def reconstruction_loss(decoded, x):
-    loss_fn = torch.nn.MSELoss()
-    loss = loss_fn(decoded, x)
-    return loss
-
-
-def label_loss(pred_label, true_label):
-    loss_fn = torch.nn.CrossEntropyLoss()
-    loss = loss_fn(pred_label, true_label)
-    return loss
-
-
-class Model_Train:
-    def __init__(self, node_X, graph_dict, params, label=None):
-        device = 'cuda' if torch.cuda.is_available() else 'cpu'
-        torch.cuda.empty_cache()
-
-        self.params = params
-        self.device = device
-        self.epochs = params.epochs
-        self.node_X = torch.FloatTensor(node_X.copy()).to(device)
-        self.adj_norm = graph_dict["adj_norm"].to(device).coalesce()
-        self.label = label
-        self.num_classes = 1
-        
-        if not self.label is None:
-            self.label = torch.tensor(self.label).to(self.device)
-            self.num_classes = len(self.label.unique())
-        
-        # Set Model 
-        self.model = GNN_VAE_Model(self.params.feat_cell,self.params,self.num_classes).to(device)
-        self.optimizer = torch.optim.Adam(params = list(self.model.parameters()),
-                                          lr = self.params.gat_lr, weight_decay = self.params.gcn_decay)               
-    
-    # Train    
-    def run_train(self):
-        self.model.train()
-        prev_loss = float('inf')
-        
-        bar = Bar('GAT-AE model train:', max = self.epochs)
-        bar.check_tty = False 
-        for epoch in range(self.epochs):
-            start_time = time.time()
-            self.model.train()
-            self.optimizer.zero_grad()
-            pred_label, de_feat, latent_z, mu, logvar = self.model(self.node_X, self.adj_norm)
-            loss_rec = reconstruction_loss(de_feat, self.node_X)
-            
-            # Check whether annotation was provided
-            if not self.label is None:
-                loss_pre = label_loss(pred_label, self.label)
-                loss = (self.params.rec_w * loss_rec) + (self.params.label_w * loss_pre)
-            else:
-                loss = loss_rec
-                
-            loss.backward()
-            self.optimizer.step()
-            
-            # Update process
-            end_time = time.time()
-            batch_time = end_time - start_time
-            
-            
-            bar_str = '{} / {} | Left time: {batch_time:.2f} mins| Loss: {loss:.4f}'
-            bar.suffix = bar_str.format(epoch + 1,self.epochs,
-                                        batch_time = batch_time * (self.epochs - epoch) / 60, loss=loss.item())
-            bar.next()
-            
-            # Check convergence
-            if abs(loss.item() - prev_loss) <= self.params.convergence_threshold and epoch >= 200:
-                print('\nConvergence reached. Training stopped.')
-                break
-
-            prev_loss = loss.item()
-            
-        bar.finish()
-    #-    
-    def get_latent(self):
-        self.model.eval()
-        pred, de_fea, latent_z, mu, logvar = self.model(self.node_X, self.adj_norm)
-        latent_z = latent_z.data.cpu().numpy()
-        return latent_z

gsmap-1.66.dist-info/RECORD

@@ -1,31 +0,0 @@
-gsMap/__init__.py,sha256=eQ-mfdcGTJtKS2KIu5PEQMqgx_9j9W5KKTBVr-iI4yo,78
-gsMap/__main__.py,sha256=jR-HT42Zzfj2f-7kFJy0bkWjNxcV1MyfQHXFpef2nSE,62
-gsMap/cauchy_combination_test.py,sha256=zBPR7DOaNkr7rRoua4tAjRZL7ArjCyMRSQlPSUdHNSE,5694
-gsMap/config.py,sha256=hMUvlwlKZXeRdTJZfMINz_8DadVhEIT6X6fyJf11M9E,41134
-gsMap/diagnosis.py,sha256=pp3ONVaWCOoNCog1_6eud38yicBFxL-XhH7D8iTBgF4,13220
-gsMap/find_latent_representation.py,sha256=BVv4dyTolrlciHG3I-vwNDh2ruPpTf9jiT1hMKZnpto,6044
-gsMap/format_sumstats.py,sha256=9OBxuunoOLml3LKZvvRsPEEjQvT1Cuqb0w6lqsRIYPw,13714
-gsMap/generate_ldscore.py,sha256=2JfQoMWeQ0-B-zRHakmwq8ovkeewlnWHUCnih6od6ZE,29089
-gsMap/latent_to_gene.py,sha256=MwoGQd0EDvDmvpuMoVD83SI1EeGJXXzMW8YZp_6wxI8,10082
-gsMap/main.py,sha256=skyBtESdjvuXd9HNq5c83OPxQTNgLVErkYhwuJm8tE4,1285
-gsMap/report.py,sha256=H0uYAru2L5-d41_LFHPPdoJbtiTzP4f8kX-mirUNAfc,6963
-gsMap/run_all_mode.py,sha256=sPEct9fRw7aAQuU7BNChxk-I8YQcXuq--mtBn-2wTTY,8388
-gsMap/setup.py,sha256=eOoPalGAHTY06_7a35nvbOaKQhq0SBE5GK4pc4bp3wc,102
-gsMap/spatial_ldsc_multiple_sumstats.py,sha256=09j2zG98JUjQvSHPaRIDQVMZZLYDd1JBFaZTkW7tdvY,18470
-gsMap/visualize.py,sha256=FLIRHHj1KntLMFDjAhg1jZnJUdvrncR74pCW2Kj5pus,7453
-gsMap/GNN_VAE/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gsMap/GNN_VAE/adjacency_matrix.py,sha256=pmSfK9TTwdrsWTmHvCqVrbRE0PAiq1lvgmxzrdQgpiU,3500
-gsMap/GNN_VAE/model.py,sha256=Fixl8-2zN3T5MmMtpMIvxsBYydM3QVR4uC3Hhsg0DzI,3349
-gsMap/GNN_VAE/train.py,sha256=KnvZYHImRzTwJl1H0dkZZqWASdZ5VgYTCifQVW8TavM,3389
-gsMap/templates/report_template.html,sha256=pdxHFl_W0W351NUzuJTf_Ay_BfKlEbD_fztNabAGmmg,8214
-gsMap/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gsMap/utils/generate_r2_matrix.py,sha256=A1BrUnlTrYjRwEKxK0I1FbZ5SCQzcviWVM-JzFHHRkw,29352
-gsMap/utils/jackknife.py,sha256=nEDPVQJOPQ_uqfUCGX_v5cQwokgCqUmJTT_8rVFuIQo,18244
-gsMap/utils/make_annotations.py,sha256=lCbtahT27WFOwLgZrEUE5QcNRuMXmAFYUfsFR-cT-m0,22197
-gsMap/utils/manhattan_plot.py,sha256=k3n-NNgMsov9-8UQrirVqG560FUfJ4d6wNG8C0OeCjY,26235
-gsMap/utils/regression_read.py,sha256=n_hZZzQXHU-CSLvSofXmQM5Jw4Zpufv3U2HoUW344ko,8768
-gsmap-1.66.dist-info/entry_points.txt,sha256=s_P2Za22O077tc1FPLKMinbdRVXaN_HTcDBgWMYpqA4,41
-gsmap-1.66.dist-info/LICENSE,sha256=Ni2F-lLSv_H1xaVT3CoSrkiKzMvlgwh-dq8PE1esGyI,1094
-gsmap-1.66.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
-gsmap-1.66.dist-info/METADATA,sha256=HXeRNmaP_UPzG2Qjn5s-jcLBvrfLgPYl7qVGDAKJG5Y,3376
-gsmap-1.66.dist-info/RECORD,,