gsMap 1.65__tar.gz → 1.67__tar.gz

{gsmap-1.65 → gsmap-1.67}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gsMap
-Version: 1.65
+Version: 1.67
 Summary: Genetics-informed pathogenic spatial mapping
 Author-email: liyang <songliyang@westlake.edu.cn>, wenhao <chenwenhao@westlake.edu.cn>
 Requires-Python: >=3.8
@@ -27,7 +27,7 @@ Requires-Dist: pyfiglet
 Requires-Dist: plotly
 Requires-Dist: kaleido
 Requires-Dist: jinja2
-Requires-Dist: scanpy
+Requires-Dist: scanpy >=1.8.0
 Requires-Dist: zarr
 Requires-Dist: bitarray
 Requires-Dist: pyarrow

{gsmap-1.65 → gsmap-1.67}/docs/source/mouse_example.md

@@ -209,7 +209,7 @@ gsmap run_cauchy_combination \
     --annotation 'annotation'
 ```
 
-### 6. report generation
+### 6. report generation (optional)
 
 **Objective**: Generate gsMap reports, including visualizations of mapping results and diagnostic plots.
 

{gsmap-1.65 → gsmap-1.67}/pyproject.toml

@@ -35,7 +35,7 @@ dependencies = [
     'plotly',
     'kaleido',
     'jinja2',
-    'scanpy',
+    'scanpy >=1.8.0',
     'zarr',
     'bitarray',
     'pyarrow',

gsmap-1.67/src/gsMap/GNN_VAE/adjacency_matrix.py

@@ -0,0 +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

gsmap-1.67/src/gsMap/GNN_VAE/model.py

@@ -0,0 +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

gsmap-1.67/src/gsMap/GNN_VAE/train.py

@@ -0,0 +1,86 @@
+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()

{gsmap-1.65 → gsmap-1.67}/src/gsMap/__init__.py

@@ -2,4 +2,4 @@
 Genetics-informed pathogenic spatial mapping
 '''
 
-__version__ = '1.65'
+__version__ = '1.67'

{gsmap-1.65 → gsmap-1.67}/src/gsMap/config.py

@@ -55,7 +55,8 @@ def add_find_latent_representations_args(parser):
     add_shared_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', required=True, type=str, help='Data layer for gene expression (e.g., "counts", "log1p").')
+    parser.add_argument('--data_layer', type=str, default='counts', required=True,
+                        help='Data layer for gene expression (e.g., "count", "counts", "log1p").')
     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.')
     parser.add_argument('--feat_hidden2', type=int, default=128, help='Neurons in the second hidden layer.')
@@ -66,7 +67,6 @@ def add_find_latent_representations_args(parser):
     parser.add_argument('--n_neighbors', type=int, default=11, help='Number of neighbors for GAT.')
     parser.add_argument('--n_comps', type=int, default=300, help='Number of principal components for PCA.')
     parser.add_argument('--weighted_adj', action='store_true', help='Use weighted adjacency in GAT.')
-    parser.add_argument('--var', action='store_true', help='Enable variance calculations.')
     parser.add_argument('--convergence_threshold', type=float, default=1e-4, help='Threshold for convergence.')
     parser.add_argument('--hierarchically', action='store_true', help='Enable hierarchical latent representation finding.')
 
@@ -236,8 +236,8 @@ def add_run_all_mode_args(parser):
                         help='Path to the input spatial transcriptomics data (H5AD format).')
     parser.add_argument('--annotation', type=str, required=True,
                         help='Name of the annotation in adata.obs to use.')
-    parser.add_argument('--data_layer', type=str, default='X',
-                        help='Data layer of h5ad for gene expression (e.g., "counts", "log1p", "X").')
+    parser.add_argument('--data_layer', type=str, default='counts', required=True,
+                        help='Data layer for gene expression (e.g., "count", "counts", "log1p").')
 
     # GWAS Data Parameters
     parser.add_argument('--trait_name', type=str, help='Name of the trait for GWAS analysis (required if sumstats_file is provided).')

gsmap-1.67/src/gsMap/find_latent_representation.py

@@ -0,0 +1,145 @@
+import logging
+import random
+import numpy as np
+import scanpy as sc
+import torch
+from sklearn.decomposition import PCA
+from sklearn.preprocessing import LabelEncoder
+from gsMap.GNN_VAE.adjacency_matrix import construct_adjacency_matrix
+from gsMap.GNN_VAE.train import ModelTrainer
+from gsMap.config import FindLatentRepresentationsConfig
+
+logger = logging.getLogger(__name__)
+
+
+def set_seed(seed_value):
+    """
+    Set seed for reproducibility in PyTorch and other libraries.
+    """
+    torch.manual_seed(seed_value)
+    np.random.seed(seed_value)
+    random.seed(seed_value)
+    if torch.cuda.is_available():
+        logger.info('Using GPU for computations.')
+        torch.cuda.manual_seed(seed_value)
+        torch.cuda.manual_seed_all(seed_value)
+    else:
+        logger.info('Using CPU for computations.')
+
+def preprocess_data(adata, params):
+    """
+    Preprocess the AnnData
+    """
+    logger.info('Preprocessing data...')
+    adata.var_names_make_unique()
+
+    sc.pp.filter_genes(adata, min_cells=30)
+    if params.data_layer in adata.layers.keys():
+        adata.X = adata.layers[params.data_layer]
+    else:
+        raise ValueError(f'Invalid data layer: {params.data_layer}, please check the input data.')
+
+    if params.data_layer in ['count', 'counts']:
+
+        sc.pp.normalize_total(adata, target_sum=1e4)
+        sc.pp.log1p(adata)
+
+        # Identify highly variable genes
+        sc.pp.highly_variable_genes(
+            adata,
+            flavor="seurat_v3",
+            n_top_genes=params.feat_cell,
+        )
+
+    elif params.data_layer in adata.layers.keys():
+        logger.info(f'Using {params.data_layer} data...')
+        sc.pp.highly_variable_genes(
+            adata,
+            flavor="seurat",
+            n_top_genes=params.feat_cell,
+        )
+
+    return adata
+
+
+class LatentRepresentationFinder:
+    def __init__(self, adata, args: FindLatentRepresentationsConfig):
+        self.params = args
+
+        self.expression_array = adata[:, adata.var.highly_variable].X.copy()
+
+        if self.params.data_layer in ['count', 'counts']:
+            self.expression_array = sc.pp.scale(self.expression_array, max_value=10)
+
+        # Construct the neighboring graph
+        self.graph_dict = construct_adjacency_matrix(adata, self.params)
+
+    def compute_pca(self):
+        self.latent_pca = PCA(n_components=self.params.feat_cell).fit_transform(self.expression_array)
+        return self.latent_pca
+
+    def run_gnn_vae(self, label, verbose='whole ST data'):
+
+        # Use PCA if specified
+        if self.params.input_pca:
+            node_X = self.compute_pca()
+        else:
+            node_X = self.expression_array
+
+        # Update the input shape
+        self.params.n_nodes = node_X.shape[0]
+        self.params.feat_cell = node_X.shape[1]
+
+        # Run GNN
+        logger.info(f'Finding latent representations for {verbose}...')
+        gvae = ModelTrainer(node_X, self.graph_dict, self.params, label)
+        gvae.run_train()
+
+        del self.graph_dict
+
+        return gvae.get_latent()
+
+
+def run_find_latent_representation(args: FindLatentRepresentationsConfig):
+    set_seed(2024)
+
+    # Load the ST data
+    logger.info(f'Loading ST data of {args.sample_name}...')
+    adata = sc.read_h5ad(args.input_hdf5_path)
+    logger.info(f'The ST data contains {adata.shape[0]} cells, {adata.shape[1]} genes.')
+
+    # Load the cell type annotation
+    if args.annotation is not None:
+        # Remove cells without enough annotations
+        adata = adata[~adata.obs[args.annotation].isnull()]
+        num = adata.obs[args.annotation].value_counts()
+        valid_annotations = num[num >= 30].index.to_list()
+        adata = adata[adata.obs[args.annotation].isin(valid_annotations)]
+
+        le = LabelEncoder()
+        adata.obs['categorical_label'] = le.fit_transform(adata.obs[args.annotation])
+        label = adata.obs['categorical_label'].to_numpy()
+    else:
+        label = None
+
+    # Preprocess data
+    adata = preprocess_data(adata, args)
+
+    latent_rep = LatentRepresentationFinder(adata, args)
+    latent_gvae = latent_rep.run_gnn_vae(label)
+    latent_pca = latent_rep.compute_pca()
+
+    # Add latent representations to the AnnData object
+    logger.info('Adding latent representations...')
+    adata.obsm["latent_GVAE"] = latent_gvae
+    adata.obsm["latent_PCA"] = latent_pca
+
+    # Run UMAP based on latent representations
+    for name in ['latent_GVAE', 'latent_PCA']:
+        sc.pp.neighbors(adata, n_neighbors=10, use_rep=name)
+        sc.tl.umap(adata)
+        adata.obsm['X_umap_' + name] = adata.obsm['X_umap']
+
+    # Save the AnnData object
+    logger.info('Saving ST data...')
+    adata.write(args.hdf5_with_latent_path)

{gsmap-1.65 → gsmap-1.67}/src/gsMap/format_sumstats.py

@@ -150,10 +150,10 @@ def gwas_checkname(gwas, config):
         'Pos': 'SNP positions.'
     }
 
-    print(f'\nIterpreting column names as follows:')
+    logger.info(f'\nIterpreting column names as follows:')
     for key, value in interpreting.items():
         if key in new_name:
-            print(f'{name_dict[key]}: {interpreting[key]}')
+            logger.info(f'{name_dict[key]}: {interpreting[key]}')
 
     return gwas
 
@@ -242,7 +242,7 @@ def gwas_qc(gwas, config):
     Filter out SNPs based on INFO, FRQ, MAF, N, and Genotypes. 
     '''
     old = len(gwas)
-    print(f'\nFiltering SNPs as follows:')
+    logger.info(f'\nFiltering SNPs as follows:')
     # filter: SNPs with missing values
     drops = {'NA': 0, 'P': 0, 'INFO': 0, 'FRQ': 0, 'A': 0, 'SNP': 0, 'Dup': 0, 'N': 0}
 
@@ -250,28 +250,28 @@ def gwas_qc(gwas, config):
         lambda x: x != 'INFO', gwas.columns)).reset_index(drop=True)
 
     drops['NA'] = old - len(gwas)
-    print(f'Removed {drops["NA"]} SNPs with missing values.')
+    logger.info(f'Removed {drops["NA"]} SNPs with missing values.')
 
     # filter: SNPs with Info < 0.9
     if 'INFO' in gwas.columns:
         old = len(gwas)
         gwas = gwas.loc[filter_info(gwas['INFO'], config)]
         drops['INFO'] = old - len(gwas)
-        print(f'Removed {drops["INFO"]} SNPs with INFO <= 0.9.')
+        logger.info(f'Removed {drops["INFO"]} SNPs with INFO <= 0.9.')
 
     # filter: SNPs with MAF <= 0.01
     if 'FRQ' in gwas.columns:
         old = len(gwas)
         gwas = gwas.loc[filter_frq(gwas['FRQ'], config)]
         drops['FRQ'] += old - len(gwas)
-        print(f'Removed {drops["FRQ"]} SNPs with MAF <= 0.01.')
+        logger.info(f'Removed {drops["FRQ"]} SNPs with MAF <= 0.01.')
 
     # filter: P-value that out-of-bounds [0,1]
     if 'P' in gwas.columns:
         old = len(gwas)
         gwas = gwas.loc[filter_pvals(gwas['P'], config)]
         drops['P'] += old - len(gwas)
-        print(f'Removed {drops["P"]} SNPs with out-of-bounds p-values.')
+        logger.info(f'Removed {drops["P"]} SNPs with out-of-bounds p-values.')
 
     # filter: Variants that are strand-ambiguous
     if 'A1' in gwas.columns and 'A2' in gwas.columns:
@@ -279,21 +279,21 @@ def gwas_qc(gwas, config):
         gwas.A2 = gwas.A2.str.upper()
         gwas = gwas.loc[filter_alleles(gwas.A1 + gwas.A2)]
         drops['A'] += old - len(gwas)
-        print(f'Removed {drops["A"]} variants that were not SNPs or were strand-ambiguous.')
+        logger.info(f'Removed {drops["A"]} variants that were not SNPs or were strand-ambiguous.')
 
     # filter: Duplicated rs numbers
     if 'SNP' in gwas.columns:
         old = len(gwas)
         gwas = gwas.drop_duplicates(subset='SNP').reset_index(drop=True)
         drops['Dup'] += old - len(gwas)
-        print(f'Removed {drops["Dup"]} SNPs with duplicated rs numbers.')
+        logger.info(f'Removed {drops["Dup"]} SNPs with duplicated rs numbers.')
 
     # filter:Sample size
     n_min = gwas.N.quantile(0.9) / 1.5
     old = len(gwas)
     gwas = gwas[gwas.N >= n_min].reset_index(drop=True)
     drops['N'] += old - len(gwas)
-    print(f'Removed {drops["N"]} SNPs with N < {n_min}.')
+    logger.info(f'Removed {drops["N"]} SNPs with N < {n_min}.')
 
     return gwas
 
@@ -302,7 +302,7 @@ def variant_to_rsid(gwas, config):
     '''
     Convert variant id (Chr, Pos) to rsid
     '''
-    print("\nConverting the SNP position to rsid. This process may take some time.")
+    logger.info("\nConverting the SNP position to rsid. This process may take some time.")
     unique_ids = set(gwas['id'])
     chr_format = gwas['Chr'].unique().astype(str)
     chr_format = [re.sub(r'\d+', '', value) for value in chr_format][1]
@@ -347,7 +347,7 @@ def clean_SNP_id(gwas, config):
             gwas = gwas.loc[matching_id.id]
             gwas['SNP'] = matching_id.dbsnp
             num_fail = old - len(gwas)
-            print(f'Removed {num_fail} SNPs that did not convert to rsid.')
+            logger.info(f'Removed {num_fail} SNPs that did not convert to rsid.')
 
     return gwas
 
@@ -356,27 +356,27 @@ def gwas_metadata(gwas, config):
     '''
     Report key features of GWAS data
     '''
-    print('\nMetadata:')
+    logger.info('\nSummary of GWAS data:')
     CHISQ = (gwas.Z ** 2)
     mean_chisq = CHISQ.mean()
-    print('Mean chi^2 = ' + str(round(mean_chisq, 3)))
+    logger.info('Mean chi^2 = ' + str(round(mean_chisq, 3)))
     if mean_chisq < 1.02:
         logger.warning("Mean chi^2 may be too small.")
 
-    print('Lambda GC = ' + str(round(CHISQ.median() / 0.4549, 3)))
-    print('Max chi^2 = ' + str(round(CHISQ.max(), 3)))
-    print('{N} Genome-wide significant SNPs (some may have been removed by filtering).'.format(N=(CHISQ > 29).sum()))
+    logger.info('Lambda GC = ' + str(round(CHISQ.median() / 0.4549, 3)))
+    logger.info('Max chi^2 = ' + str(round(CHISQ.max(), 3)))
+    logger.info('{N} Genome-wide significant SNPs (some may have been removed by filtering).'.format(N=(CHISQ > 29).sum()))
 
 
 def gwas_format(config: FormatSumstatsConfig):
     '''
     Format GWAS data
     '''
-    print(f'------Formating gwas data for {config.sumstats}...')
+    logger.info(f'------Formating gwas data for {config.sumstats}...')
     compression_type = get_compression(config.sumstats)
     gwas = pd.read_csv(config.sumstats, delim_whitespace=True, header=0, compression=compression_type,
                        na_values=['.', 'NA'])
-    print(f'Read {len(gwas)} SNPs from {config.sumstats}.')
+    logger.info(f'Read {len(gwas)} SNPs from {config.sumstats}.')
 
     # Check name and format
     gwas = gwas_checkname(gwas, config)
@@ -402,6 +402,6 @@ def gwas_format(config: FormatSumstatsConfig):
     gwas = gwas[keep]
     out_name = config.out + appendix + '.gz'
 
-    print(f'\nWriting summary statistics for {len(gwas)} SNPs to {out_name}.')
+    logger.info(f'\nWriting summary statistics for {len(gwas)} SNPs to {out_name}.')
     gwas.to_csv(out_name, sep="\t", index=False,
                 float_format='%.3f', compression='gzip')