gwaslab 3.5.7__py3-none-any.whl → 3.6.0__py3-none-any.whl

gwaslab/g_SumstatsMulti.py

@@ -0,0 +1,287 @@
+import pandas as pd
+import numpy as np
+import copy
+import gc
+from gwaslab.util_in_filter_value import filtervalues
+from gwaslab.g_Log import Log
+from math import floor
+from gwaslab.g_Sumstats import Sumstats
+from gwaslab.g_Sumstats_polars import Sumstatsp
+from gwaslab.hm_casting import _merge_mold_with_sumstats_by_chrpos
+from gwaslab.hm_casting import _align_with_mold
+from gwaslab.hm_casting import _fill_missing_columns
+from gwaslab.hm_casting import _check_daf
+from gwaslab.hm_casting import _assign_warning_code
+from gwaslab.hm_casting import _renaming_cols
+from gwaslab.hm_casting import _sort_pair_cols
+
+from gwaslab.hm_casting_polars import _merge_mold_with_sumstats_by_chrposp
+from gwaslab.hm_casting_polars import _align_with_moldp
+from gwaslab.hm_casting_polars import _fill_missing_columnsp
+from gwaslab.hm_casting_polars import _renaming_colsp
+from gwaslab.hm_casting_polars import _sort_pair_colsp
+
+from gwaslab.qc_fix_sumstats import flipallelestats
+from gwaslab.qc_fix_sumstats_polars import flipallelestatsp
+from gwaslab.qc_check_datatype_polars import check_datatype
+from gwaslab.qc_check_datatype_polars import check_dataframe_shape
+from gwaslab.util_ex_calculate_ldmatrix import tofinemapping
+from gwaslab.util_ex_run_coloc import _run_coloc_susie
+from gwaslab.viz_plot_miamiplot2 import plot_miami2
+from gwaslab.viz_plot_compare_af import  plotdaf
+from gwaslab.util_ex_run_2samplemr import _run_two_sample_mr
+from gwaslab.util_ex_run_clumping import _clump
+from gwaslab.util_ex_ldproxyfinder import _extract_with_ld_proxy
+from gwaslab.g_headers import _get_headers
+from gwaslab.util_ex_match_ldmatrix import tofinemapping_m
+from gwaslab.util_ex_run_mesusie import _run_mesusie
+from gwaslab.util_in_meta import meta_analyze_multi
+from gwaslab.util_ex_run_hyprcoloc import _run_hyprcoloc
+from gwaslab.util_in_get_sig import getsig
+from gwaslab.util_in_fill_data import _get_multi_min
+from gwaslab.g_meta import _init_meta
+from gwaslab.g_meta_update import _update_meta
+from gwaslab.qc_fix_sumstats import _process_build
+from gwaslab.util_ex_run_mtag import _run_mtag
+
+
+
+class SumstatsMulti( ):
+    def __init__(self, 
+                 sumstatsObjects, 
+                 group_name=None, 
+                 build="99",
+                 engine="pandas",
+                 merge_mode="outer",
+                 verbose=True ):
+        
+        for i,sumstatsObject in enumerate(sumstatsObjects):
+            if not isinstance(sumstatsObject, Sumstats):
+                if not isinstance(sumstatsObject, Sumstatsp):
+                    raise ValueError("Please provide GWASLab Sumstats Object #{}.".format(i+1))
+        
+        self.log = Log()
+        self.meta = _init_meta(object="SumstatsMulti") 
+        
+        if engine=="polars":
+            import polars as pl
+            merge_mode="full"
+
+
+        self.engine=engine
+            
+        self.meta["gwaslab"]["number_of_studies"] = len(sumstatsObjects)
+        self.meta["gwaslab"]["genome_build"] = _process_build(build, log=self.log, verbose=False)
+        self.meta["gwaslab"]["objects"] =  dict()
+        self.meta["gwaslab"]["study_index"] =  dict()
+
+        if group_name is None:
+            self.group_name = "Group1" 
+            self.meta["gwaslab"]["group_name"] =  "Group1" 
+        else:
+            self.group_name = group_name
+            self.meta["gwaslab"]["group_name"] =  group_name
+
+        self.names=[]
+        self.hyprcoloc = {}
+
+        self.snp_info_cols = dict()
+        self.stats_cols =  dict()
+        self.other_cols= dict()
+
+        self.log.write( "Start to create SumstatsMulti object..." )
+
+        for i,sumstatsObject in enumerate(sumstatsObjects):
+            self.log.write( " -Checking sumstats Object #{}...".format(i+1), verbose=verbose)
+            check_datatype(sumstatsObject.data, log=self.log, verbose=verbose)
+            check_dataframe_shape(sumstats=sumstatsObject.data, 
+                            log=self.log, 
+                            verbose=verbose)
+            
+            if sumstatsObject.meta["gwaslab"]["study_name"] in self.names:
+                new_study_name = "{}_{}".format(sumstatsObject.meta["gwaslab"]["study_name"],i+1)
+                self.log.write( "  -Sumstats Object #{} name: {}".format(i+1,new_study_name), verbose=verbose)
+                self.names.append(new_study_name)
+            else:
+                self.log.write( "  -Sumstats Object #{} name: {}".format(i+1, sumstatsObject.meta["gwaslab"]["study_name"]), verbose=verbose)
+                self.names.append(sumstatsObject.meta["gwaslab"]["study_name"])
+            self.meta["gwaslab"]["objects"][i+1] = sumstatsObject.meta
+            self.meta["gwaslab"]["study_index"][i+1] = self.names[-1]
+
+            self.snp_info_cols[i] = list()
+            self.stats_cols[i] = list()
+            self.other_cols[i] = list()
+
+            for col in sumstatsObject.data.columns:
+
+                if col in _get_headers(mode="info"):
+                    # extract SNP info columns from sumstats1
+                    self.snp_info_cols[i].append(col)
+                elif col in _get_headers(mode="stats"):
+                    self.stats_cols[i].append(col)
+                else:
+                    self.other_cols[i].append(col)
+
+        self.meta["gwaslab"]["study_names_in_group"] = ",".join(self.names)
+        
+
+
+        self.log.write( " -Variant Info columns: {}".format(self.snp_info_cols[0]) , verbose=verbose)
+        for i in range(len(sumstatsObjects)):
+            self.log.write( " -Sumstats #{} variant statistics columns: {}".format(i+1, self.stats_cols[i]) , verbose=verbose)
+            self.log.write( " -Sumstats #{} other columns: {}".format(i+1, self.other_cols[i]) , verbose=verbose)
+        
+        #for i,sumstatsObject in enumerate(sumstatsObjects):
+        #    sumstatsObject.data["_RAW_INDEX_{}".format(i+1)] = range(len(sumstatsObject.data))
+
+        # extract only info and stats cols
+        self.data = sumstatsObjects[0].data
+        
+        #rename with _1
+        if engine=="polars":
+            self.data = self.data.rename({"EA":"EA_1","NEA":"NEA_1","STATUS":"STATUS_1"})
+            self.data = self.data.rename({i:i + "_1" for i in self.stats_cols[0]})
+            self.data = self.data.rename({i:i + "_1" for i in self.other_cols[0]})
+        else:
+            self.data = self.data.rename(columns={"EA":"EA_1","NEA":"NEA_1","STATUS":"STATUS_1"})
+            self.data = self.data.rename(columns={i:i + "_1" for i in self.stats_cols[0]})
+            self.data = self.data.rename(columns={i:i + "_1" for i in self.other_cols[0]})        
+
+        if engine=="polars":
+            self.data = pl.DataFrame(self.data)
+            for i, sumstatsObject in enumerate(sumstatsObjects):
+                if i >0:
+                    self.log.write("Merging Sumstats #{} to main DataFrame...".format(i+1))
+                    self.data = self._merge_two_sumstats(sumstatsObject.data,i=i,merge_mode=merge_mode,engine=engine)
+                    self.log.write("Finished merging Sumstats #{} to main DataFrame.".format(i+1))
+        else:
+            for i, sumstatsObject in enumerate(sumstatsObjects):
+                if i >0:
+                    self.log.write("Merging Sumstats #{} to main DataFrame...".format(i+1))
+                    self.data = self._merge_two_sumstats(sumstatsObject.data,i=i,merge_mode=merge_mode,engine=engine)
+                    self.log.write("Finished merging Sumstats #{} to main DataFrame.".format(i+1))
+        
+
+    def _merge_two_sumstats(self, 
+                            sumstatsObject2, 
+                            verbose=True,
+                            merge_mode="outer",
+                            engine="pandas",
+                            i=0):
+
+        # _1 _2 
+        # add suffix
+        if engine=="polars":
+            if "EA" in self.data.columns:
+                self.data = self.data.rename({"EA":"EA_1","NEA":"NEA_1"})
+        else:
+            self.data = self.data.rename(columns={"EA":"EA_1","NEA":"NEA_1"})
+
+        #sumstats1 with suffix _1, sumstats2 with no suffix
+        if engine=="polars":
+            molded_sumstats = _merge_mold_with_sumstats_by_chrposp(mold=self.data, 
+                                                        sumstats=sumstatsObject2, 
+                                                        log=self.log,
+                                                        verbose=verbose,
+                                                        merge_mode=merge_mode,
+                                                        stats_cols1 = self.other_cols[0],
+                                                        stats_cols2 = self.other_cols[i],
+                                                        suffixes=("_1",""),
+                                                        return_not_matched_mold = False)
+            molded_sumstats = _align_with_moldp(molded_sumstats, log=self.log, verbose=verbose,suffixes=("_1",""))
+            molded_sumstats = flipallelestatsp(molded_sumstats, log=self.log, verbose=verbose)
+            molded_sumstats = molded_sumstats.drop(["EA","NEA"] )
+            molded_sumstats = molded_sumstats.rename({"EA_1":"EA","NEA_1":"NEA"})
+        else:
+            molded_sumstats = _merge_mold_with_sumstats_by_chrpos(mold=self.data, 
+                                                        sumstats=sumstatsObject2, 
+                                                        log=self.log,
+                                                        verbose=verbose,
+                                                        merge_mode=merge_mode,
+                                                        stats_cols1 = self.other_cols[0],
+                                                        stats_cols2 = self.other_cols[i],
+                                                        suffixes=("_1",""),
+                                                        return_not_matched_mold = False)    
+            molded_sumstats = _align_with_mold(molded_sumstats, log=self.log, verbose=verbose,suffixes=("_1",""))
+            molded_sumstats = flipallelestats(molded_sumstats, log=self.log, verbose=verbose)        
+            molded_sumstats = molded_sumstats.drop(columns=["EA","NEA"] )
+            molded_sumstats = molded_sumstats.rename(columns={"EA_1":"EA","NEA_1":"NEA"})
+            
+        if not set(self.stats_cols[i]) == set(self.stats_cols[0]):
+            cols_to_fill = set(self.stats_cols[0]).difference(set(self.stats_cols[i]))
+            molded_sumstats = _fill_missing_columns(molded_sumstats, cols_to_fill, log=self.log, verbose=verbose)
+        
+        if engine=="polars":
+            # rename sumstast2 with _2
+            molded_sumstats = _renaming_colsp(molded_sumstats, 
+                                            self.stats_cols[0] + self.other_cols[i], 
+                                            log=self.log, 
+                                            verbose=verbose, 
+                                            suffixes=("_1","_{}".format(i+1)))
+        else:
+            molded_sumstats = _renaming_cols(molded_sumstats, 
+                                            self.stats_cols[0] + self.other_cols[i], 
+                                            log=self.log, 
+                                            verbose=verbose, 
+                                            suffixes=("_1","_{}".format(i+1)))   
+                     
+        molded_sumstats = _sort_pair_cols(molded_sumstats, verbose=verbose, log=self.log, suffixes=["_{}".format(j) for j in range(1,i+2)])
+        return molded_sumstats
+    
+    def update_meta(self,**kwargs):
+        self.meta = _update_meta(self.meta, self.data, log = self.log, **kwargs)
+
+    def run_meta_analysis(self, **kwargs):
+        if self.engine == "polars":
+            from gwaslab.util_in_meta_polars import meta_analyze_polars
+            return meta_analyze_polars(self.data,nstudy = self.meta["gwaslab"]["number_of_studies"] ,**kwargs)
+        else:
+            return meta_analyze_multi(self.data,nstudy = self.meta["gwaslab"]["number_of_studies"] ,**kwargs)
+    
+    def run_hyprcoloc(self,**kwargs):
+        hyprcoloc_res_combined = _run_hyprcoloc(self.data,
+                       nstudy = self.meta["gwaslab"]["number_of_studies"], 
+                       study= self.meta["gwaslab"]["group_name"], 
+                       traits=self.names, **kwargs)
+        self.hyprcoloc = hyprcoloc_res_combined
+
+    def run_mtag(self,**kwargs):
+        _run_mtag(     self.data,
+                       nstudy = self.meta["gwaslab"]["number_of_studies"], 
+                       study= self.meta["gwaslab"]["group_name"], 
+                       traits=self.names, 
+                       **kwargs)
+
+    def get_lead(self, build=None, gls=False, **kwargs):
+        
+        if "SNPID" in self.data.columns:
+            id_to_use = "SNPID"
+        else:
+            id_to_use = "rsID"
+        
+        # extract build information from meta data
+        if build is None:
+            build = self.meta["gwaslab"]["genome_build"]
+
+        self.data = _get_multi_min(self.data,
+                                   col="P", 
+                                   nstudy=self.meta["gwaslab"]["number_of_studies"])
+
+        output = getsig(self.data,
+                            id=id_to_use,
+                            chrom="CHR",
+                            pos="POS",
+                            p="P_MIN",
+                            log=self.log,
+                            build=build,
+                            **kwargs)
+        # return sumstats object    
+
+        if gls == True:
+            new_Sumstats_object = copy.deepcopy(self)
+            new_Sumstats_object.data = output
+            gc.collect()
+            return new_Sumstats_object
+        
+        return output
+    

gwaslab/g_SumstatsPair.py

@@ -24,6 +24,12 @@ from gwaslab.util_ex_run_2samplemr import _run_two_sample_mr
 from gwaslab.util_ex_run_clumping import _clump
 from gwaslab.util_ex_ldproxyfinder import _extract_with_ld_proxy
 from gwaslab.g_headers import _get_headers
+from gwaslab.util_ex_match_ldmatrix import tofinemapping_m
+from gwaslab.util_ex_run_mesusie import _run_mesusie
+from gwaslab.io_read_pipcs import _read_pipcs
+from gwaslab.g_meta import _init_meta
+from gwaslab.viz_plot_stackedregional import plot_stacked_mqq
+from gwaslab.util_ex_run_ccgwas import _run_ccgwas
 
 class SumstatsPair( ):
     def __init__(self, sumstatsObject1, sumstatsObject2, study=None, suffixes = ("_1","_2") ,verbose=True ):
@@ -32,11 +38,29 @@ class SumstatsPair( ):
             raise ValueError("Please provide GWASLab Sumstats Object #1.")
         if not isinstance(sumstatsObject2, Sumstats):
             raise ValueError("Please provide GWASLab Sumstats Object #2.")
+        
+        self.meta = _init_meta(object="SumstatsPair") 
+
         if sumstatsObject1.meta["gwaslab"]["study_name"]!=sumstatsObject2.meta["gwaslab"]["study_name"]:
             self.study_name = "{}_{}".format(sumstatsObject1.meta["gwaslab"]["study_name"], sumstatsObject2.meta["gwaslab"]["study_name"])
+            self.study_names = [sumstatsObject1.meta["gwaslab"]["study_name"], sumstatsObject2.meta["gwaslab"]["study_name"]]
         else:
-            self.study_name = "{}_{}".format("STUDY1", "STUDY2")
+            self.study_name = "{}_{}".format(sumstatsObject1.meta["gwaslab"]["study_name"]+"1", sumstatsObject2.meta["gwaslab"]["study_name"]+"2")
+            self.study_names = [sumstatsObject1.meta["gwaslab"]["study_name"]+"1", sumstatsObject2.meta["gwaslab"]["study_name"]+"2"]
+        
+        self.meta["gwaslab"]["objects"] =  dict()
+        self.meta["gwaslab"]["objects"][0] = sumstatsObject1.meta
+        self.meta["gwaslab"]["objects"][1] = sumstatsObject2.meta
+
+        #self.meta["gwaslab"]["study_name"] = self.study_name
+        self.meta["gwaslab"]["group_name"] = self.study_name
         
+        self.ldsc =  dict()
+        self.ldsc[0] = sumstatsObject1.ldsc_h2
+        self.ldsc[1] = sumstatsObject2.ldsc_h2
+        self.ldsc_rg = sumstatsObject1.ldsc_rg
+
+
         self.snp_info_cols = []
         self.stats_cols =[]
         self.stats_cols2 =[]
@@ -45,18 +69,26 @@ class SumstatsPair( ):
         self.log = Log()
         self.suffixes = suffixes
         self.colocalization=pd.DataFrame()
+        
         self.sumstats1 = pd.DataFrame()
         self.sumstats2 = pd.DataFrame()
+        self.ns = None
         
+        # TwosampleMR
         self.mr =dict()
+        
+        # clumping
         self.clumps =dict()
-        self.ns = None
-        self.finemapping = dict()
-        #self.to_finemapping_file_path = ""
-        #self.plink_log = ""
+        
+        # MESuSiE
+        self.mesusie = dict()
+        self.mesusie_res = pd.DataFrame()
+        
+        # Coloc and Coloc SuSiE 
+        self.coloc = dict()
+        self.coloc_susie_res = pd.DataFrame()
 
         self.log.write( "Start to create SumstatsPair object..." )
-        
         self.log.write( " -Checking sumstats 1..." , verbose=verbose)
         check_datatype(sumstatsObject1.data, log=self.log, verbose=verbose)
         check_dataframe_shape(sumstats=sumstatsObject1.data, 
@@ -77,6 +109,7 @@ class SumstatsPair( ):
                 self.stats_cols.append(i)
             else:
                 self.other_cols.append(i)
+
         for i in sumstatsObject2.data.columns:
             if i in _get_headers(mode="info"):
                 continue
@@ -90,6 +123,8 @@ class SumstatsPair( ):
         self.log.write( " -Sumstats1 other columns: {}".format(self.other_cols) , verbose=verbose)
         self.log.write( " -Sumstats2 other columns: {}".format(self.other_cols2) , verbose=verbose)
         
+        sumstatsObject1.data["_RAW_INDEX_1"] = range(len(sumstatsObject1.data))
+        sumstatsObject2.data["_RAW_INDEX_2"] = range(len(sumstatsObject2.data))
         # extract only info and stats cols
         self.data = sumstatsObject1.data
         
@@ -98,7 +133,7 @@ class SumstatsPair( ):
         self.data = self.data.rename(columns={i:i + suffixes[0] for i in self.stats_cols})
         self.data = self.data.rename(columns={i:i + suffixes[0] for i in self.other_cols})
 
-        self.data, self.sumstats1 = self._merge_two_sumstats(sumstatsObject2, suffixes=suffixes)
+        self.data, self.sumstats1, self.sumstats2 = self._merge_two_sumstats(sumstatsObject2, suffixes=suffixes)
 
         if "N{}".format(self.suffixes[0]) in self.data.columns and "N{}".format(self.suffixes[1]) in self.data.columns:
             n1 = int(floor(self.data["N{}".format(self.suffixes[0])].mean()))
@@ -106,14 +141,24 @@ class SumstatsPair( ):
             self.ns=(n1, n2)
         else:
             self.ns = None
+        sumstatsObject1.data = sumstatsObject1.data.drop(columns=["_RAW_INDEX_1"])
+        sumstatsObject2.data = sumstatsObject2.data.drop(columns=["_RAW_INDEX_2"])
 
-    def _merge_two_sumstats(self, sumstatsObject2, threshold=0.2, verbose=True,windowsizeb=10, ref_path=None,suffixes=("_1","_2")):
+    def _merge_two_sumstats(self, 
+                            sumstatsObject2, 
+                            threshold=0.2, 
+                            verbose=True,
+                            windowsizeb=10, 
+                            ref_path=None,
+                            suffixes=("_1","_2")):
 
         # sumstats1 with suffix _1, sumstats2 with no suffix
-        molded_sumstats, sumstats1 = _merge_mold_with_sumstats_by_chrpos(mold=self.data, 
+        molded_sumstats, sumstats1, sumstats2 = _merge_mold_with_sumstats_by_chrpos(mold=self.data, 
                                                     sumstats=sumstatsObject2.data, 
                                                     log=self.log,
                                                     verbose=verbose,
+                                                    stats_cols1 = self.stats_cols,
+                                                    stats_cols2 = self.stats_cols2,
                                                     suffixes=(suffixes[0],""),
                                                     return_not_matched_mold = True)
 
@@ -137,21 +182,53 @@ class SumstatsPair( ):
         
         molded_sumstats = _sort_pair_cols(molded_sumstats, verbose=verbose, log=self.log)
         
-        return molded_sumstats, sumstats1
+        return molded_sumstats, sumstats1, sumstats2
 
 
     def clump(self,**kwargs):
-        self.clumps["clumps"],self.clumps["clumps_raw"],self.clumps["plink_log"] = _clump(self.data, log=self.log, p="P_1",mlog10p="MLOG10P_1", study = self.study_name, **kwargs)
+        self.clumps["clumps"],self.clumps["clumps_raw"],self.clumps["plink_log"] = _clump(self.data, log=self.log, p="P_1",mlog10p="MLOG10P_1", study = self.meta["gwaslab"]["group_name"], **kwargs)
 
     def to_coloc(self,**kwargs):
-        self.finemapping["path"],self.finemapping["file"],self.finemapping["plink_log"] = tofinemapping(self.data,study=self.study_name,suffixes=self.suffixes,log=self.log,**kwargs)
+        self.coloc["path"],self.coloc["file"],self.coloc["plink_log"] = tofinemapping(self.data,study=self.meta["gwaslab"]["group_name"],suffixes=self.suffixes,log=self.log,**kwargs)
+
+    def to_mesusie(self,**kwargs):
+        self.mesusie["path"],self.mesusie["file"],self.mesusie["plink_log"] = tofinemapping_m(self.data,
+                                                                                                             studies = self.study_names,
+                                                                                                             group = self.meta["gwaslab"]["group_name"],
+                                                                                                             suffixes=self.suffixes,
+                                                                                                             log=self.log,
+                                                                                                             **kwargs)
+        
+    def run_mesusie(self,**kwargs):
+        prefix = _run_mesusie(self.mesusie["path"],log=self.log,ncols=self.ns,**kwargs)
+        self.mesusie_res = _read_pipcs(self.data[["SNPID","CHR","POS"]], 
+                                   prefix, 
+                                   studie_names = self.study_name,
+                                   group=self.meta["gwaslab"]["group_name"])
+    
+    def run_ccgwas(self,**kwargs):
+         _run_ccgwas(self.data, 
+                      meta = self.meta,
+                      ldsc = self.ldsc,
+                      ldsc_rg = self.ldsc_rg,
+                      group=self.meta["gwaslab"]["group_name"],
+                      studies = self.study_names,
+                      log=self.log,
+                      **kwargs)
 
+    def read_pipcs(self,prefix,**kwargs):
+        self.mesusie_res = _read_pipcs(self.data[["SNPID","CHR","POS"]], 
+                                   prefix, 
+                                   group=self.meta["gwaslab"]["group_name"], 
+                                   studie_names = self.study_name,
+                                   **kwargs)
+         
     def run_coloc_susie(self,**kwargs):
-        self.colocalization = _run_coloc_susie(self.finemapping["path"],log=self.log,ncols=self.ns,**kwargs)
+        self.coloc_susie_res = _run_coloc_susie(self.coloc["path"],log=self.log,ncols=self.ns,**kwargs)
 
     def run_two_sample_mr(self, clump=False, **kwargs):
-        exposure1 = self.study_name.split("_")[0]
-        outcome2 = self.study_name.split("_")[1]
+        exposure1 = self.meta["gwaslab"]["group_name"].split("_")[0]
+        outcome2 = self.meta["gwaslab"]["group_name"].split("_")[1]
         _run_two_sample_mr(self,exposure1=exposure1,outcome2=outcome2, clump=clump,**kwargs)
 
     def extract_with_ld_proxy(self,**arg):
@@ -166,9 +243,17 @@ class SumstatsPair( ):
             self.data = filtervalues(self.data, expr,log=self.log,**kwargs)
         gc.collect()
 
+    def stacked_mqq(self, **kwargs):
+        
+        objects=[self.data[["SNPID","CHR","POS","EA","NEA","P_1"]].rename(columns={"P_1":"P"}), 
+                 self.data[["SNPID","CHR","POS","EA","NEA","P_2"]].rename(columns={"P_2":"P"}), 
+                 self.mesusie_res]
+
+        plot_stacked_mqq(objects=objects, 
+                         **kwargs)
+
     ## Visualization #############################################################################################################################################
     def plot_miami(self,**kwargs):
-
         plot_miami2(merged_sumstats=self.data, 
                     suffixes=self.suffixes,
                     **kwargs)