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

gsMap/{GNN_VAE → GNN}/adjacency_matrix.py

@@ -1,75 +1,75 @@
-import numpy as np
-import pandas as pd
-import scipy.sparse as sp
-from sklearn.neighbors import NearestNeighbors
-import torch
-
-def cal_spatial_net(adata, n_neighbors=5, verbose=True):
-    """Construct the spatial neighbor network."""
-    if verbose:
-        print('------Calculating spatial graph...')
-    coor = pd.DataFrame(adata.obsm['spatial'], index=adata.obs.index)
-    nbrs = NearestNeighbors(n_neighbors=n_neighbors).fit(coor)
-    distances, indices = nbrs.kneighbors(coor)
-    n_cells, n_neighbors = indices.shape
-    cell_indices = np.arange(n_cells)
-    cell1 = np.repeat(cell_indices, n_neighbors)
-    cell2 = indices.flatten()
-    distance = distances.flatten()
-    knn_df = pd.DataFrame({'Cell1': cell1, 'Cell2': cell2, 'Distance': distance})
-    knn_df = knn_df[knn_df['Distance'] > 0].copy()
-    cell_id_map = dict(zip(cell_indices, coor.index))
-    knn_df['Cell1'] = knn_df['Cell1'].map(cell_id_map)
-    knn_df['Cell2'] = knn_df['Cell2'].map(cell_id_map)
-    return knn_df
-
-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):
-    """Symmetrically normalize the adjacency matrix."""
-    adj = sp.coo_matrix(adj)
-    adj_ = adj + sp.eye(adj.shape[0])
-    rowsum = np.array(adj_.sum(1)).flatten()
-    degree_mat_inv_sqrt = sp.diags(np.power(rowsum, -0.5))
-    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 adjacency matrix from spatial data."""
-    spatial_net = cal_spatial_net(adata, n_neighbors=params.n_neighbors, verbose=verbose)
-    if verbose:
-        num_edges = spatial_net.shape[0]
-        num_cells = adata.n_obs
-        print(f'The graph contains {num_edges} edges, {num_cells} cells.')
-        print(f'{num_edges / num_cells:.2f} neighbors per cell on average.')
-    cell_ids = {cell: idx for idx, cell in enumerate(adata.obs.index)}
-    spatial_net['Cell1'] = spatial_net['Cell1'].map(cell_ids)
-    spatial_net['Cell2'] = spatial_net['Cell2'].map(cell_ids)
-    if params.weighted_adj:
-        distance_normalized = spatial_net['Distance'] / (spatial_net['Distance'].max() + 1)
-        weights = np.exp(-0.5 * distance_normalized ** 2)
-        adj_org = sp.coo_matrix(
-            (weights, (spatial_net['Cell1'], spatial_net['Cell2'])),
-            shape=(adata.n_obs, adata.n_obs)
-        )
-    else:
-        adj_org = sp.coo_matrix(
-            (np.ones(spatial_net.shape[0]), (spatial_net['Cell1'], spatial_net['Cell2'])),
-            shape=(adata.n_obs, adata.n_obs)
-        )
-    adj_norm = preprocess_graph(adj_org)
-    norm_value = adj_org.shape[0] ** 2 / ((adj_org.shape[0] ** 2 - adj_org.sum()) * 2)
-    graph_dict = {
-        "adj_org": adj_org,
-        "adj_norm": adj_norm,
-        "norm_value": norm_value
-    }
-    return graph_dict
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+from sklearn.neighbors import NearestNeighbors
+import torch
+
+def cal_spatial_net(adata, n_neighbors=5, verbose=True):
+    """Construct the spatial neighbor network."""
+    if verbose:
+        print('------Calculating spatial graph...')
+    coor = pd.DataFrame(adata.obsm['spatial'], index=adata.obs.index)
+    nbrs = NearestNeighbors(n_neighbors=n_neighbors).fit(coor)
+    distances, indices = nbrs.kneighbors(coor)
+    n_cells, n_neighbors = indices.shape
+    cell_indices = np.arange(n_cells)
+    cell1 = np.repeat(cell_indices, n_neighbors)
+    cell2 = indices.flatten()
+    distance = distances.flatten()
+    knn_df = pd.DataFrame({'Cell1': cell1, 'Cell2': cell2, 'Distance': distance})
+    knn_df = knn_df[knn_df['Distance'] > 0].copy()
+    cell_id_map = dict(zip(cell_indices, coor.index))
+    knn_df['Cell1'] = knn_df['Cell1'].map(cell_id_map)
+    knn_df['Cell2'] = knn_df['Cell2'].map(cell_id_map)
+    return knn_df
+
+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_coo_tensor(indices, values, shape)
+
+def preprocess_graph(adj):
+    """Symmetrically normalize the adjacency matrix."""
+    adj = sp.coo_matrix(adj)
+    adj_ = adj + sp.eye(adj.shape[0])
+    rowsum = np.array(adj_.sum(1)).flatten()
+    degree_mat_inv_sqrt = sp.diags(np.power(rowsum, -0.5))
+    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 adjacency matrix from spatial data."""
+    spatial_net = cal_spatial_net(adata, n_neighbors=params.n_neighbors, verbose=verbose)
+    if verbose:
+        num_edges = spatial_net.shape[0]
+        num_cells = adata.n_obs
+        print(f'The graph contains {num_edges} edges, {num_cells} cells.')
+        print(f'{num_edges / num_cells:.2f} neighbors per cell on average.')
+    cell_ids = {cell: idx for idx, cell in enumerate(adata.obs.index)}
+    spatial_net['Cell1'] = spatial_net['Cell1'].map(cell_ids)
+    spatial_net['Cell2'] = spatial_net['Cell2'].map(cell_ids)
+    if params.weighted_adj:
+        distance_normalized = spatial_net['Distance'] / (spatial_net['Distance'].max() + 1)
+        weights = np.exp(-0.5 * distance_normalized ** 2)
+        adj_org = sp.coo_matrix(
+            (weights, (spatial_net['Cell1'], spatial_net['Cell2'])),
+            shape=(adata.n_obs, adata.n_obs)
+        )
+    else:
+        adj_org = sp.coo_matrix(
+            (np.ones(spatial_net.shape[0]), (spatial_net['Cell1'], spatial_net['Cell2'])),
+            shape=(adata.n_obs, adata.n_obs)
+        )
+    adj_norm = preprocess_graph(adj_org)
+    norm_value = adj_org.shape[0] ** 2 / ((adj_org.shape[0] ** 2 - adj_org.sum()) * 2)
+    graph_dict = {
+        "adj_org": adj_org,
+        "adj_norm": adj_norm,
+        "norm_value": norm_value
+    }
+    return graph_dict

gsMap/{GNN_VAE → GNN}/model.py

@@ -1,89 +1,89 @@
-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 GATModel(nn.Module):
-    def __init__(self, input_dim, params, num_classes=1):
-        super().__init__()
-        self.var = params.var
-        self.num_classes = num_classes
-        self.params = params
-
-        # Encoder
-        self.encoder = nn.Sequential(
-            full_block(input_dim, params.feat_hidden1, params.p_drop),
-            full_block(params.feat_hidden1, params.feat_hidden2, params.p_drop)
-        )
-
-        # GAT Layers
-        self.gat1 = GATConv(
-            in_channels=params.feat_hidden2,
-            out_channels=params.gat_hidden1,
-            heads=params.nheads,
-            dropout=params.p_drop
-        )
-        self.gat2 = GATConv(
-            in_channels=params.gat_hidden1 * params.nheads,
-            out_channels=params.gat_hidden2,
-            heads=1,
-            concat=False,
-            dropout=params.p_drop
-        )
-        if self.var:
-            self.gat3 = GATConv(
-                in_channels=params.gat_hidden1 * params.nheads,
-                out_channels=params.gat_hidden2,
-                heads=1,
-                concat=False,
-                dropout=params.p_drop
-            )
-
-        # Decoder
-        self.decoder = nn.Sequential(
-            full_block(params.gat_hidden2, params.feat_hidden2, params.p_drop),
-            full_block(params.feat_hidden2, params.feat_hidden1, params.p_drop),
-            nn.Linear(params.feat_hidden1, input_dim)
-        )
-
-        # Clustering Layer
-        self.cluster = nn.Sequential(
-            full_block(params.gat_hidden2, params.feat_hidden2, params.p_drop),
-            nn.Linear(params.feat_hidden2, self.num_classes)
-        )
-
-    def encode(self, x, edge_index):
-        x = self.encoder(x)
-        x = self.gat1(x, edge_index)
-        x = F.relu(x)
-        x = F.dropout(x, p=self.params.p_drop, training=self.training)
-
-        mu = self.gat2(x, edge_index)
-        if self.var:
-            logvar = self.gat3(x, edge_index)
-            return mu, logvar
-        else:
-            return mu, None
-
-    def reparameterize(self, mu, logvar):
-        if self.training and logvar is not None:
-            std = torch.exp(0.5 * logvar)
-            eps = torch.randn_like(std)
-            return eps * std + mu
-        else:
-            return mu
-
-    def forward(self, x, edge_index):
-        mu, logvar = self.encode(x, edge_index)
-        z = self.reparameterize(mu, logvar)
-        x_reconstructed = self.decoder(z)
-        pred_label = F.softmax(self.cluster(z), dim=1)
-        return pred_label, x_reconstructed, z, mu, logvar
+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 GATModel(nn.Module):
+    def __init__(self, input_dim, params, num_classes=1):
+        super().__init__()
+        self.var = params.var
+        self.num_classes = num_classes
+        self.params = params
+
+        # Encoder
+        self.encoder = nn.Sequential(
+            full_block(input_dim, params.feat_hidden1, params.p_drop),
+            full_block(params.feat_hidden1, params.feat_hidden2, params.p_drop)
+        )
+
+        # GAT Layers
+        self.gat1 = GATConv(
+            in_channels=params.feat_hidden2,
+            out_channels=params.gat_hidden1,
+            heads=params.nheads,
+            dropout=params.p_drop
+        )
+        self.gat2 = GATConv(
+            in_channels=params.gat_hidden1 * params.nheads,
+            out_channels=params.gat_hidden2,
+            heads=1,
+            concat=False,
+            dropout=params.p_drop
+        )
+        if self.var:
+            self.gat3 = GATConv(
+                in_channels=params.gat_hidden1 * params.nheads,
+                out_channels=params.gat_hidden2,
+                heads=1,
+                concat=False,
+                dropout=params.p_drop
+            )
+
+        # Decoder
+        self.decoder = nn.Sequential(
+            full_block(params.gat_hidden2, params.feat_hidden2, params.p_drop),
+            full_block(params.feat_hidden2, params.feat_hidden1, params.p_drop),
+            nn.Linear(params.feat_hidden1, input_dim)
+        )
+
+        # Clustering Layer
+        self.cluster = nn.Sequential(
+            full_block(params.gat_hidden2, params.feat_hidden2, params.p_drop),
+            nn.Linear(params.feat_hidden2, self.num_classes)
+        )
+
+    def encode(self, x, edge_index):
+        x = self.encoder(x)
+        x = self.gat1(x, edge_index)
+        x = F.relu(x)
+        x = F.dropout(x, p=self.params.p_drop, training=self.training)
+
+        mu = self.gat2(x, edge_index)
+        if self.var:
+            logvar = self.gat3(x, edge_index)
+            return mu, logvar
+        else:
+            return mu, None
+
+    def reparameterize(self, mu, logvar):
+        if self.training and logvar is not None:
+            std = torch.exp(0.5 * logvar)
+            eps = torch.randn_like(std)
+            return eps * std + mu
+        else:
+            return mu
+
+    def forward(self, x, edge_index):
+        mu, logvar = self.encode(x, edge_index)
+        z = self.reparameterize(mu, logvar)
+        x_reconstructed = self.decoder(z)
+        pred_label = F.softmax(self.cluster(z), dim=1)
+        return pred_label, x_reconstructed, z, mu, logvar

gsMap/{GNN_VAE → GNN}/train.py

@@ -1,86 +1,88 @@
-import logging
-import time
-
-import torch
-import torch.nn.functional as F
-from progress.bar import Bar
-
-from gsMap.GNN_VAE.model import GATModel
-
-logger = logging.getLogger(__name__)
-
-
-def reconstruction_loss(decoded, x):
-    """Compute the mean squared error loss."""
-    return F.mse_loss(decoded, x)
-
-
-def label_loss(pred_label, true_label):
-    """Compute the cross-entropy loss."""
-    return F.cross_entropy(pred_label, true_label)
-
-class ModelTrainer:
-    def __init__(self, node_x, graph_dict, params, label=None):
-        """Initialize the ModelTrainer with data and hyperparameters."""
-        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-        self.params = params
-        self.epochs = params.epochs
-        self.node_x = torch.FloatTensor(node_x).to(self.device)
-        self.adj_norm = graph_dict["adj_norm"].to(self.device).coalesce()
-        self.label = label
-        self.num_classes = 1
-
-        if self.label is not None:
-            self.label = torch.tensor(self.label).to(self.device)
-            self.num_classes = len(torch.unique(self.label))
-
-        # Set up the model
-        self.model = GATModel(self.params.feat_cell, self.params, self.num_classes).to(self.device)
-        self.optimizer = torch.optim.Adam(
-            self.model.parameters(),
-            lr=self.params.gat_lr,
-            weight_decay=self.params.gcn_decay
-        )
-
-    def run_train(self):
-        """Train the model."""
-        self.model.train()
-        prev_loss = float('inf')
-        bar = Bar('GAT-AE model train:', max=self.epochs)
-        bar.check_tty = False
-
-        logger.info('Start training...')
-        for epoch in range(self.epochs):
-            start_time = time.time()
-            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)
-
-            if self.label is not 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()
-
-            batch_time = time.time() - start_time
-            left_time = batch_time * (self.epochs - epoch - 1) / 60  # in minutes
-
-            bar.suffix = f'{epoch + 1} / {self.epochs} | Left time: {left_time:.2f} mins | Loss: {loss.item():.4f}'
-            bar.next()
-
-            if abs(loss.item() - prev_loss) <= self.params.convergence_threshold and epoch >= 200:
-                logger.info('\nConvergence reached. Training stopped.')
-                break
-
-            prev_loss = loss.item()
-        bar.finish()
-
-    def get_latent(self):
-        """Retrieve the latent representation from the model."""
-        self.model.eval()
-        with torch.no_grad():
-            _, _, latent_z, _, _ = self.model(self.node_x, self.adj_norm)
-        return latent_z.cpu().numpy()
+import logging
+import time
+
+import torch
+import torch.nn.functional as F
+from tqdm import tqdm
+
+from gsMap.GNN.model import GATModel
+
+logger = logging.getLogger(__name__)
+
+
+def reconstruction_loss(decoded, x):
+    """Compute the mean squared error loss."""
+    return F.mse_loss(decoded, x)
+
+
+def label_loss(pred_label, true_label):
+    """Compute the cross-entropy loss."""
+    return F.cross_entropy(pred_label, true_label)
+
+
+class ModelTrainer:
+    def __init__(self, node_x, graph_dict, params, label=None):
+        """Initialize the ModelTrainer with data and hyperparameters."""
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        self.params = params
+        self.epochs = params.epochs
+        self.node_x = torch.FloatTensor(node_x).to(self.device)
+        self.adj_norm = graph_dict["adj_norm"].to(self.device).coalesce()
+        self.label = label
+        self.num_classes = 1
+
+        if self.label is not None:
+            self.label = torch.tensor(self.label).to(self.device)
+            self.num_classes = len(torch.unique(self.label))
+
+        # Set up the model
+        self.model = GATModel(self.params.feat_cell, self.params, self.num_classes).to(self.device)
+        self.optimizer = torch.optim.Adam(
+            self.model.parameters(),
+            lr=self.params.gat_lr,
+            weight_decay=self.params.gcn_decay
+        )
+
+    def run_train(self):
+        """Train the model."""
+        self.model.train()
+        prev_loss = float('inf')
+        logger.info('Start training...')
+        pbar = tqdm(range(self.epochs), desc='GAT-AE model train:', total=self.epochs)
+        for epoch in range(self.epochs):
+            start_time = time.time()
+            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)
+
+            if self.label is not 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()
+
+            batch_time = time.time() - start_time
+            left_time = batch_time * (self.epochs - epoch - 1) / 60  # in minutes
+
+            pbar.set_postfix({'Left time': f'{left_time:.2f} mins', 'Loss': f'{loss.item():.4f}'})
+            pbar.update(1)
+
+            if abs(loss.item() - prev_loss) <= self.params.convergence_threshold and epoch >= 200:
+                pbar.close()
+                logger.info('Convergence reached. Training stopped.')
+                break
+            prev_loss = loss.item()
+        else:
+            pbar.close()
+            logger.info('Max epochs reached. Training stopped.')
+
+
+    def get_latent(self):
+        """Retrieve the latent representation from the model."""
+        self.model.eval()
+        with torch.no_grad():
+            _, _, latent_z, _, _ = self.model(self.node_x, self.adj_norm)
+        return latent_z.cpu().numpy()

gsMap/__init__.py

@@ -1,5 +1,5 @@
-'''
-Genetics-informed pathogenic spatial mapping
-'''
-
-__version__ = '1.67'
+'''
+Genetics-informed pathogenic spatial mapping
+'''
+
+__version__ = '1.70'

gsMap/__main__.py

@@ -1,3 +1,3 @@
-from .main import main
-if __name__ == '__main__':
+from .main import main
+if __name__ == '__main__':
     main()