gsMap 1.73.4__py3-none-any.whl → 1.73.6__py3-none-any.whl

gsMap/__init__.py

@@ -1,5 +1,5 @@
 """
-Genetics-informed pathogenic spatial mapping
+Genetically informed spatial mapping of cells for complex traits
 """
 
-__version__ = "1.73.4"
+__version__ = "1.73.6"

gsMap/config.py

@@ -1,7 +1,10 @@
 import argparse
 import dataclasses
+import functools
 import logging
 import os
+import re
+import subprocess
 import sys
 import threading
 import time
@@ -38,6 +41,48 @@ def get_gsMap_logger(logger_name):
 logger = get_gsMap_logger("gsMap")
 
 
+@functools.cache
+def macos_timebase_factor():
+    """
+    On MacOS, `psutil.Process.cpu_times()` is not accurate, check activity monitor instead.
+    see: https://github.com/giampaolo/psutil/issues/2411#issuecomment-2274682289
+    """
+    default_factor = 1
+    ioreg_output_lines = []
+
+    try:
+        result = subprocess.run(
+            ["ioreg", "-p", "IODeviceTree", "-c", "IOPlatformDevice"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        ioreg_output_lines = result.stdout.splitlines()
+    except subprocess.CalledProcessError as e:
+        print(f"Command failed: {e}")
+        return default_factor
+
+    if not ioreg_output_lines:
+        return default_factor
+
+    for line in ioreg_output_lines:
+        if "timebase-frequency" in line:
+            match = re.search(r"<([0-9a-fA-F]+)>", line)
+            if not match:
+                return default_factor
+            byte_data = bytes.fromhex(match.group(1))
+            timebase_freq = int.from_bytes(byte_data, byteorder="little")
+            # Typically, it should be 1000/24.
+            return pow(10, 9) / timebase_freq
+    return default_factor
+
+
+def process_cpu_time(proc: psutil.Process):
+    cpu_times = proc.cpu_times()
+    total = cpu_times.user + cpu_times.system
+    return total
+
+
 def track_resource_usage(func):
     """
     Decorator to track resource usage during function execution.
@@ -79,7 +124,7 @@ def track_resource_usage(func):
 
         # Get start times
         start_wall_time = time.time()
-        start_cpu_time = process.cpu_times().user + process.cpu_times().system
+        start_cpu_time = process_cpu_time(process)
 
         try:
             # Run the actual function
@@ -92,7 +137,7 @@ def track_resource_usage(func):
 
             # Calculate elapsed times
             end_wall_time = time.time()
-            end_cpu_time = process.cpu_times().user + process.cpu_times().system
+            end_cpu_time = process_cpu_time(process)
 
             wall_time = end_wall_time - start_wall_time
             cpu_time = end_cpu_time - start_cpu_time
@@ -102,6 +147,10 @@ def track_resource_usage(func):
                 sum(cpu_percent_samples) / len(cpu_percent_samples) if cpu_percent_samples else 0
             )
 
+            if sys.platform == "darwin":
+                cpu_time *= macos_timebase_factor()
+                avg_cpu_percent *= macos_timebase_factor()
+
             # Format memory for display
             if peak_memory < 1024:
                 memory_str = f"{peak_memory:.2f} MB"
@@ -192,9 +241,6 @@ def add_find_latent_representations_args(parser):
     parser.add_argument(
         "--input_hdf5_path", required=True, type=str, help="Path to the input HDF5 file."
     )
-    parser.add_argument(
-        "--annotation", required=True, type=str, help="Name of the annotation in adata.obs to use."
-    )
     parser.add_argument(
         "--data_layer",
         type=str,
@@ -202,6 +248,9 @@ def add_find_latent_representations_args(parser):
         required=True,
         help='Data layer for gene expression (e.g., "count", "counts", "log1p").',
     )
+    parser.add_argument(
+        "--annotation", type=str, default=None, help="Name of the annotation in adata.obs to use."
+    )
     parser.add_argument("--epochs", type=int, default=300, help="Number of training epochs.")
     parser.add_argument(
         "--feat_hidden1", type=int, default=256, help="Neurons in the first hidden layer."
@@ -375,6 +424,10 @@ def add_spatial_ldsc_args(parser):
     parser.add_argument(
         "--chisq_max", type=int, help="Maximum chi-square value for filtering SNPs."
     )
+    parser.add_argument(
+        "--chunk_range", nargs=2, type=int, default=None,
+        help="Range of chunks to run in this batch, omit to run all chunks"
+    )
     parser.add_argument(
         "--num_processes", type=int, default=4, help="Number of processes for parallel computing."
     )

gsMap/diagnosis.py

@@ -1,4 +1,6 @@
 import logging
+import multiprocessing
+import os
 import warnings
 from pathlib import Path
 
@@ -221,25 +223,34 @@ def generate_GSS_distribution(config: DiagnosisConfig):
     # save plot gene list
     config.get_GSS_plot_select_gene_file(config.trait_name).write_text("\n".join(plot_genes))
 
+    paralleized_params = []
     for selected_gene in plot_genes:
         expression_series = pd.Series(
             adata[:, selected_gene].X.toarray().flatten(), index=adata.obs.index, name="Expression"
         )
         threshold = np.quantile(expression_series, 0.9999)
         expression_series[expression_series > threshold] = threshold
-        generate_and_save_plots(
-            adata,
-            mk_score,
-            expression_series,
-            selected_gene,
-            point_size,
-            pixel_width,
-            pixel_height,
-            sub_fig_save_dir,
-            config.sample_name,
-            config.annotation,
+
+        paralleized_params.append(
+            (
+                adata,
+                mk_score,
+                expression_series,
+                selected_gene,
+                point_size,
+                pixel_width,
+                pixel_height,
+                sub_fig_save_dir,
+                config.sample_name,
+                config.annotation,
+            )
         )
 
+    with multiprocessing.Pool(os.cpu_count() // 2) as pool:
+        pool.starmap(generate_and_save_plots, paralleized_params)
+        pool.close()
+        pool.join()
+
 
 def generate_and_save_plots(
     adata,
@@ -292,11 +303,12 @@ def generate_and_save_plots(
 def save_plot(sub_fig, sub_fig_save_dir, sample_name, selected_gene, plot_type):
     """Save the plot to HTML and PNG."""
     save_sub_fig_path = (
-        sub_fig_save_dir / f"{sample_name}_{selected_gene}_{plot_type}_Distribution.html"
+        sub_fig_save_dir / f"{sample_name}_{selected_gene}_{plot_type}_Distribution.png"
     )
     # sub_fig.write_html(str(save_sub_fig_path))
     sub_fig.update_layout(showlegend=False)
-    sub_fig.write_image(str(save_sub_fig_path).replace(".html", ".png"))
+    sub_fig.write_image(save_sub_fig_path)
+    assert save_sub_fig_path.exists(), f"Failed to save {plot_type} plot for {selected_gene}."
 
 
 def generate_gsMap_plot(config: DiagnosisConfig):

gsMap/generate_ldscore.py

@@ -49,8 +49,7 @@ def load_gtf(
     logger.info("Loading GTF data from %s", gtf_file)
 
     # Load GTF file
-    gtf = pr.read_gtf(gtf_file)
-    gtf = gtf.df
+    gtf = pr.read_gtf(gtf_file, as_df=True)
 
     # Filter for gene features
     gtf = gtf[gtf["Feature"] == "gene"]
@@ -303,7 +302,7 @@ class LDScoreCalculator:
         ].index.tolist()
 
         # Create a simple unit annotation (all ones) for the filtered SNPs
-        unit_annotation = np.ones((len(keep_snps_indices), 1))
+        unit_annotation = np.ones((len(keep_snps_indices), 1), dtype="float32")
 
         # Calculate LD scores
         w_ld_scores = plink_bed.get_ldscore(

gsMap/run_all_mode.py

@@ -176,7 +176,7 @@ def run_pipeline(config: RunAllModeConfig):
 
     # Step 5: Cauchy combination test
     start_time = time.time()
-    logger.info("Step 6: Running Cauchy combination test")
+    logger.info("Step 5: Running Cauchy combination test")
     for trait_name in sumstats_config:
         # check if the cauchy combination has been done
         cauchy_result_file = config.get_cauchy_result_file(trait_name)
@@ -196,8 +196,9 @@ def run_pipeline(config: RunAllModeConfig):
     logger.info(f"Step 5 completed in {format_duration(end_time - start_time)}.")
 
     # Step 6: Generate final report
+    start_time = time.time()
     for trait_name in sumstats_config:
-        logger.info("Running final report generation for trait: %s", trait_name)
+        logger.info("Step 6: Running final report generation for trait: %s", trait_name)
         report_config = ReportConfig(
             workdir=config.workdir,
             sample_name=config.sample_name,
@@ -234,4 +235,7 @@ def run_pipeline(config: RunAllModeConfig):
         # Pass the run parameter dictionary to the report generation function
         run_report(report_config, run_parameters=run_parameter_dict)
 
+    end_time = time.time()
+    logger.info(f"Step 6 completed in {format_duration(end_time - start_time)}.")
+
     logger.info("Pipeline completed successfully.")

gsMap/spatial_ldsc_multiple_sumstats.py

@@ -419,7 +419,7 @@ def save_results(output_dict, config, running_chunk_number, start_chunk, end_chu
     for trait_name, out_chunk_list in output_dict.items():
         out_all = pd.concat(out_chunk_list, axis=0)
         sample_name = config.sample_name
-        if running_chunk_number == end_chunk - start_chunk + 1:
+        if running_chunk_number == determine_total_chunks(config):
             out_file_name = out_dir / f"{sample_name}_{trait_name}.csv.gz"
         else:
             out_file_name = (

gsMap/utils/generate_r2_matrix.py

@@ -9,16 +9,21 @@ https://github.com/bulik/ldsc/blob/master/ldsc/ldscore.py
 import logging
 
 import bitarray as ba
+import numba
 import numpy as np
 import pandas as pd
 import pyranges as pr
+import torch
 from tqdm import tqdm
 
+from gsMap.utils.torch_utils import torch_device, torch_sync
+
 # Configure logger
 logger = logging.getLogger("gsMap.utils.plink_ldscore_tool")
 
 
-def getBlockLefts(coords, max_dist):
+@numba.njit
+def getBlockLefts(coords: np.ndarray, max_dist: float):
     """
     Converts coordinates + max block length to a list of coordinates of the leftmost
     SNPs to be included in blocks.
@@ -34,19 +39,46 @@ def getBlockLefts(coords, max_dist):
     return block_left
 
 
-def block_left_to_right(block_left):
+@numba.njit
+def normalized_snps(X: np.ndarray, b: int, minorRef, freq, currentSNP):
     """
-    Converts block lefts to block rights.
+    Normalize the SNPs and impute the missing ones with the mean
+
+    Parameters
+    ----------
+    fam_file : str
+        Path to the FAM file
+
+    Returns
+    -------
+    pd.DataFrame
+        DataFrame containing FAM data
     """
-    M = len(block_left)
-    j = 0
-    block_right = np.zeros(M)
-    for i in range(M):
-        while j < M and block_left[j] <= i:
-            j += 1
-        block_right[i] = j
+    Y = np.zeros(X.shape, dtype="float32")
+
+    for j in range(0, b):
+        newsnp = X[:, j]
+        ii = newsnp != 9
+        avg = np.mean(newsnp[ii])
+        newsnp[np.logical_not(ii)] = avg
+        denom = np.std(newsnp)
+        if denom == 0:
+            denom = 1
 
-    return block_right
+        if minorRef is not None and freq[currentSNP + j] > 0.5:
+            denom = denom * -1
+
+        Y[:, j] = (newsnp - avg) / denom
+    return Y
+
+
+def l2_unbiased(x: torch.Tensor, n: int):
+    """
+    Calculate the unbiased estimate of L2.
+    """
+    denom = n - 2 if n > 2 else n  # allow n<2 for testing purposes
+    sq = torch.square(x)
+    return sq - (1 - sq) / denom
 
 
 class PlinkBEDFile:
@@ -94,26 +126,26 @@ class PlinkBEDFile:
         # Filter out invalid SNPs
         valid_mask = self.all_snp_info["valid_snp"]
         if num_invalid := np.sum(~valid_mask):
-            logger.warning(f"Filtering out {num_invalid} bad quality SNPs")
+            logger.warning(
+                f"Filtering out {num_invalid} bad quality SNPs: {self.bim_df.loc[~valid_mask, 'SNP'].tolist()}"
+            )
         else:
             logger.info("All SNPs passed the basic quality check")
 
-        # Only keep valid SNPs
-        self.kept_snps = np.arange(self.m_original)[valid_mask]
-
-        # Update bim_df to only include valid SNPs and reset index
-        self.bim_df = self.bim_df.loc[valid_mask].reset_index(drop=True)
-
         # Create new genotype data with only the valid SNPs
         new_geno = ba.bitarray()
-        for j in self.kept_snps:
+        for j in np.arange(self.m_original)[valid_mask]:
             new_geno += self.geno_original[
                 2 * self.nru_original * j : 2 * self.nru_original * (j + 1)
             ]
 
         # Update original data to only include valid SNPs
         self.geno_original = new_geno
-        self.m_original = len(self.kept_snps)
+
+        # Only keep valid SNPs
+        self.bim_df = self.bim_df.loc[valid_mask].reset_index(drop=True)
+        self.m_original = len(self.bim_df)
+        self.kept_snps = np.arange(self.m_original)
 
         # Initialize current state variables
         self._currentSNP = 0
@@ -292,8 +324,8 @@ class PlinkBEDFile:
 
         # Apply MAF filter using pre-calculated values
         if mafMin is not None and mafMin > 0:
-            maf_values = np.minimum(self.all_snp_info["freq"], 1 - self.all_snp_info["freq"])
-            maf_mask = (maf_values > mafMin) & self.all_snp_info["valid_snp"]
+            # Remove the redundant valid_snp check since all SNPs are already valid
+            maf_mask = self.maf > mafMin
             kept_snps = kept_snps[maf_mask]
             logger.info(f"After MAF filtering (>{mafMin}), {len(kept_snps)} SNPs remain")
 
@@ -369,9 +401,7 @@ class PlinkBEDFile:
         list
             List of SNP IDs that pass the MAF threshold
         """
-        # Use the pre-calculated MAF values
-        maf_values = np.minimum(self.all_snp_info["freq"], 1 - self.all_snp_info["freq"])
-        maf_mask = (maf_values > mafMin) & self.all_snp_info["valid_snp"]
+        maf_mask = self.maf > mafMin
 
         # Get SNP names from the BIM dataframe
         snp_pass_maf = self.bim_df.loc[maf_mask, "SNP"].tolist()
@@ -466,41 +496,18 @@ class PlinkBEDFile:
         slice = self.geno[2 * c * nru : 2 * (c + b) * nru]
         X = np.array(slice.decode(self._bedcode), dtype="float32").reshape((b, nru)).T
         X = X[0:n, :]
-        Y = np.zeros(X.shape, dtype="float32")
-
-        # Normalize the SNPs and impute the missing ones with the mean
-        for j in range(0, b):
-            newsnp = X[:, j]
-            ii = newsnp != 9
-            avg = np.mean(newsnp[ii])
-            newsnp[np.logical_not(ii)] = avg
-            denom = np.std(newsnp)
-            if denom == 0:
-                denom = 1
-
-            if minorRef is not None and self.freq[self._currentSNP + j] > 0.5:
-                denom = denom * -1
-
-            Y[:, j] = (newsnp - avg) / denom
+        Y = normalized_snps(X, b, minorRef, self.freq, self._currentSNP)
 
         self._currentSNP += b
         return Y
 
-    def _l2_unbiased(self, x, n):
-        """
-        Calculate the unbiased estimate of L2.
-        """
-        denom = n - 2 if n > 2 else n  # allow n<2 for testing purposes
-        sq = np.square(x)
-        return sq - (1 - sq) / denom
-
-    def ldScoreVarBlocks(self, block_left, c, annot=None):
+    def ldScoreVarBlocks(self, block_left: np.ndarray, c, annot=None):
         """
         Computes an unbiased estimate of L2(j) for j=1,..,M.
         """
 
         def func(x):
-            return self._l2_unbiased(x, self.n)
+            return l2_unbiased(x, self.n)
 
         snp_getter = self.nextSNPs
         return self._corSumVarBlocks(block_left, c, func, snp_getter, annot)
@@ -534,17 +541,22 @@ class PlinkBEDFile:
             b = m
 
         l_A = 0  # l_A := index of leftmost SNP in matrix A
-        A = snp_getter(b)  # This now returns float32 data
-        rfuncAB = np.zeros((b, c), dtype="float32")
-        rfuncBB = np.zeros((c, c), dtype="float32")
+
+        device = torch_device()
+        A = torch.from_numpy(snp_getter(b)).to(device)  # This now returns float32 data
+        cor_sum = torch.from_numpy(cor_sum).to(device)
+        annot = torch.from_numpy(annot).to(device)
+        rfuncAB = torch.zeros((b, c), dtype=torch.float32, device=device)
+        rfuncBB = torch.zeros((c, c), dtype=torch.float32, device=device)
+
         # chunk inside of block
         for l_B in np.arange(0, b, c):  # l_B := index of leftmost SNP in matrix B
             B = A[:, l_B : l_B + c]
             # ld matrix
-            np.dot(A.T, B / n, out=rfuncAB)
+            torch.mm(A.T, B / n, out=rfuncAB)
             # ld matrix square
             rfuncAB = func(rfuncAB)
-            cor_sum[l_A : l_A + b, :] += np.dot(rfuncAB, annot[l_B : l_B + c, :])
+            cor_sum[l_A : l_A + b, :] += torch.mm(rfuncAB, annot[l_B : l_B + c, :].float())
 
         # chunk to right of block
         b0 = b
@@ -560,33 +572,39 @@ class PlinkBEDFile:
                 # block_size can't increase more than c
                 # block_size can't be less than c unless it is zero
                 # both of these things make sense
-                A = np.hstack((A[:, old_b - b + c : old_b], B))
+                A = torch.hstack((A[:, old_b - b + c : old_b], B))
                 l_A += old_b - b + c
             elif l_B == b0 and b > 0:
                 A = A[:, b0 - b : b0]
                 l_A = b0 - b
             elif b == 0:  # no SNPs to left in window, e.g., after a sequence gap
-                A = np.array((), dtype="float32").reshape((n, 0))
+                A = torch.zeros((n, 0), dtype=torch.float32, device=device)
                 l_A = l_B
             if l_B == md:
                 c = m - md
-                rfuncAB = np.zeros((b, c), dtype="float32")
-                rfuncBB = np.zeros((c, c), dtype="float32")
+                rfuncAB = torch.zeros((b, c), dtype=torch.float32, device=device)
+                rfuncBB = torch.zeros((c, c), dtype=torch.float32, device=device)
             if b != old_b:
-                rfuncAB = np.zeros((b, c), dtype="float32")
+                rfuncAB = torch.zeros((b, c), dtype=torch.float32, device=device)
+
+            B = torch.from_numpy(snp_getter(c)).to(device)  # This now returns float32 data
 
-            B = snp_getter(c)  # This now returns float32 data
-            p1 = np.all(annot[l_A : l_A + b, :] == 0)
-            p2 = np.all(annot[l_B : l_B + c, :] == 0)
+            annot_l_A = annot[l_A : l_A + b, :].float()
+            annot_l_B = annot[l_B : l_B + c, :].float()
+            p1 = torch.all(annot_l_A == 0)
+            p2 = torch.all(annot_l_B == 0)
             if p1 and p2:
                 continue
 
-            np.dot(A.T, B / n, out=rfuncAB)
-            rfuncAB = func(rfuncAB)
-            cor_sum[l_A : l_A + b, :] += np.dot(rfuncAB, annot[l_B : l_B + c, :])
-            cor_sum[l_B : l_B + c, :] += np.dot(annot[l_A : l_A + b, :].T, rfuncAB).T
-            np.dot(B.T, B / n, out=rfuncBB)
-            rfuncBB = func(rfuncBB)
-            cor_sum[l_B : l_B + c, :] += np.dot(rfuncBB, annot[l_B : l_B + c, :])
+            B_n = B / n
+
+            rfuncAB = func(torch.mm(A.T, B_n))
+            cor_sum[l_A : l_A + b, :] += torch.mm(rfuncAB, annot_l_B)
+            cor_sum[l_B : l_B + c, :] += torch.mm(annot_l_A.T, rfuncAB).T
+
+            rfuncBB = func(torch.mm(B.T, B_n))
+            cor_sum[l_B : l_B + c, :] += torch.mm(rfuncBB, annot_l_B)
+
+        torch_sync()
 
-        return cor_sum
+        return cor_sum.cpu().numpy()

gsMap/utils/torch_utils.py

@@ -0,0 +1,23 @@
+"""
+Wrapper functions for pytorch.
+"""
+
+import torch
+
+
+def torch_device(index=-1):
+    if torch.cuda.is_available():
+        if index >= 0:
+            return torch.device(f"cuda:{index}")
+        return torch.device("cuda")
+    elif torch.backends.mps.is_available() and torch.backends.mps.is_built():
+        return torch.device("mps")
+    else:
+        return torch.device("cpu")
+
+
+def torch_sync():
+    if torch.backends.mps.is_available() and torch.backends.mps.is_built():
+        torch.mps.synchronize()
+    elif torch.cuda.is_available():
+        torch.cuda.synchronize()

{gsmap-1.73.4.dist-info → gsmap-1.73.6.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: gsMap
-Version: 1.73.4
-Summary: Genetics-informed pathogenic spatial mapping
+Version: 1.73.6
+Summary: Genetically informed spatial mapping of cells for complex traits
 Author-email: liyang <songliyang@westlake.edu.cn>, wenhao <chenwenhao@westlake.edu.cn>
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -33,6 +33,7 @@ Requires-Dist: zarr>=2,<3
 Requires-Dist: bitarray >=2.9.2, <3.0.0
 Requires-Dist: pyarrow
 Requires-Dist: scikit-misc
+Requires-Dist: numba
 Requires-Dist: sphinx ; extra == "doc"
 Requires-Dist: sphinx-argparse ; extra == "doc"
 Requires-Dist: sphinx-autobuild ; extra == "doc"
@@ -87,7 +88,7 @@ in a spatially resolved manner.
 
 ![Model Architecture](schematic.png)
 
-## Installation
+## 🛠️ Installation
 
 Install using pip:
 
@@ -119,16 +120,16 @@ Verify the installation by running the following command:
 gsmap --help
 ```
 
-## Usage
+## 📘 Usage
 
 Please check out the documentation and tutorials at [gsMap Documentation](https://yanglab.westlake.edu.cn/gsmap/document/software).
 
-## Online Visualization
+## 🌐 Online Visualization
 
 To visualize the traits-cell association spatial maps,
 please refer to [gsMap Visualization](https://yanglab.westlake.edu.cn/gsmap/visualize).
 
-## Citation
+## 📖 Citation
 
 Song, L., Chen, W., Hou, J., Guo, M. & Yang, J.
 [Spatially resolved mapping of cells associated with human complex traits.](https://doi.org/10.1038/s41586-025-08757-x)
@@ -136,6 +137,10 @@ Nature (2025).
 
 Please cite the paper and give us a STAR if you find gsMap useful for your research.
 
+## ✨ Research Highlight
+gsMap was highlighted in [Nature Methods](https://www.nature.com/articles/s41592-025-02711-5).  
+gsMap was highlighted in [Nature Review Genetics](https://www.nature.com/articles/s41576-025-00877-4).
+
 <!-- Badge links -->
 
 [codecov-badge]: https://codecov.io/gh/JianYang-Lab/gsMap/graph/badge.svg?token=NFZFXZIEUU

{gsmap-1.73.4.dist-info → gsmap-1.73.6.dist-info}/RECORD

@@ -1,18 +1,18 @@
-gsMap/__init__.py,sha256=hRDqmAAKm9MYDtkkkVvoAJQDZAlG2yZ5nafywVU2Ufo,77
+gsMap/__init__.py,sha256=3vFwQ3R-ECv5qIHITgE-yDErPkgbiPXd446zNOXuIcY,97
 gsMap/__main__.py,sha256=Vdhw8YA1K3wPMlbJQYL5WqvRzAKVeZ16mZQFO9VRmCo,62
 gsMap/cauchy_combination_test.py,sha256=SiUyqJKr4ATFtRgsCEJ43joGcSagCOnnurkB1FlQiB4,5105
-gsMap/config.py,sha256=xQQJKqe-ZLohxzEZ0L_CEXXbbUK-U6-H6BnISteqrHs,51316
+gsMap/config.py,sha256=lMK-guF8fUybq3W3QuPI2FbMKMO49hThtt8J6t7mOL0,52935
 gsMap/create_slice_mean.py,sha256=Nnmb7ACtS-9TurW5xQ4TqCinejPsYcvuT5Oxqa5Uges,5723
-gsMap/diagnosis.py,sha256=Z-zJriPge0_kUbU-S41w7cPT2xYFlDVzbp6p6QMoKQc,13025
+gsMap/diagnosis.py,sha256=hi5VjkWsdZOg8x-2pkn_Zz5O-NXWpt5GXhU87Hb2gYQ,13389
 gsMap/find_latent_representation.py,sha256=aZ5fFY2RhAsNaDeoehd5lN28556d6GGHK9xEUTvo6G4,5365
 gsMap/format_sumstats.py,sha256=1c9OgbqDQWOgXeSrbAhbJfChv_2IwXIgLE6Pbw2sx0s,13778
-gsMap/generate_ldscore.py,sha256=9Qlx8na0w82U8UsSvdPCsDbNAxNFPHKYuUjY4M04fOg,35363
+gsMap/generate_ldscore.py,sha256=af_ABnioNPSda44pwfdLMz4vpHAReDAkIvEDEo9k_sw,35375
 gsMap/latent_to_gene.py,sha256=sDPvOU4iF-HkfQY0nnkIVXpjyTQ9-PjQflwEFWrPg-A,12869
 gsMap/main.py,sha256=SzfAXhrlr4LXnSD4gkvAtUUPYXyra6a_MzVCxDBZjr0,1170
 gsMap/report.py,sha256=_1FYkzGhVGMnvHgEQ8z51iMrVEVlh48a31jLqbV2o9w,6953
-gsMap/run_all_mode.py,sha256=LhMTT85B6yoDG9MvKmclQWYdQyNIP0FFdHpYVGTCJTs,9381
+gsMap/run_all_mode.py,sha256=NPc76rDG7rD0qzazNRovgfXanUZCOl3xEvKXD_oEIaQ,9528
 gsMap/setup.py,sha256=lsIQCChHwR0ojWZs7xay8rukRaLlueuLkc83bp-B2ZE,103
-gsMap/spatial_ldsc_multiple_sumstats.py,sha256=-mawOBjn8-Y5Irl8mv8ye83hfiEJ1mkLrRIQiI-XaMM,17973
+gsMap/spatial_ldsc_multiple_sumstats.py,sha256=K5j1xQ3ncGn-chStNcqIKHHfV-T-aR_hLOasOoCBBSU,17976
 gsMap/visualize.py,sha256=N55s-xmzSd_DtIesrGewfDeoytYUcMd2acDsjEpChCA,7242
 gsMap/GNN/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gsMap/GNN/adjacency_matrix.py,sha256=MfkhgpAHJcC-3l_iZDQQYD30w4bpe29-8s6kkGxiwQw,3231
@@ -20,12 +20,13 @@ gsMap/GNN/model.py,sha256=75In9sxBkaqqpCQSrQEUO-zsQQVQnkXVbKsAgyAZjiQ,2918
 gsMap/GNN/train.py,sha256=4qipaxaz3rQOtlRpTYCfl1Oz4kz_A6vNB1aw8_gGK_k,3076
 gsMap/templates/report_template.html,sha256=QODZEbVxpW1xsLz7lDrD_DyUfzYoi9E17o2tLJlf8OQ,8016
 gsMap/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gsMap/utils/generate_r2_matrix.py,sha256=0FEbSEiZhNj3nnnt9V-fp7WWPLpfBci3tP4ydBbG280,20114
+gsMap/utils/generate_r2_matrix.py,sha256=4ewkK2Foe7TLwVYQKmuUjuJ7w3i7lvM_ddS367RpAPo,20396
 gsMap/utils/jackknife.py,sha256=w_qMj9GlqViouHuOw1U80N6doWuCTXuPoAVU4P-5mm8,17673
 gsMap/utils/manhattan_plot.py,sha256=4ok5CHAaT_MadyMPnFZMR_llmE8Vf4-KiEfametgHq0,25480
 gsMap/utils/regression_read.py,sha256=uBSKlvYVhUKmDSCBvKHQrE1wLNyvK-rbzc5TJV51oDI,5649
-gsmap-1.73.4.dist-info/entry_points.txt,sha256=s_P2Za22O077tc1FPLKMinbdRVXaN_HTcDBgWMYpqA4,41
-gsmap-1.73.4.dist-info/licenses/LICENSE,sha256=fb5WP6qQytSKO5rM0ZSqQXg_92Fdt0aAeFNwSi3Lpmc,1069
-gsmap-1.73.4.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-gsmap-1.73.4.dist-info/METADATA,sha256=fyLpDSS5SEIyPj9rZ7ymcXPIOCLcAU2j-OW0D5xC2GA,8196
-gsmap-1.73.4.dist-info/RECORD,,
+gsMap/utils/torch_utils.py,sha256=baHIoAlBcfEvoGOM2sH-oQLKVo5V0M5ZqzObgjm2I40,580
+gsmap-1.73.6.dist-info/entry_points.txt,sha256=s_P2Za22O077tc1FPLKMinbdRVXaN_HTcDBgWMYpqA4,41
+gsmap-1.73.6.dist-info/licenses/LICENSE,sha256=fb5WP6qQytSKO5rM0ZSqQXg_92Fdt0aAeFNwSi3Lpmc,1069
+gsmap-1.73.6.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+gsmap-1.73.6.dist-info/METADATA,sha256=ljuLSmjsX3isLy4T_X8b6jHVsGNqDg7pd_kfuGSFZEY,8487
+gsmap-1.73.6.dist-info/RECORD,,