timeawarepc 1.2.0__py2.py3-none-any.whl

timeawarepc/pcalg_helpers.py

@@ -0,0 +1,55 @@
+"""Helper functions for PC algorithm.
+"""
+import numpy as np
+from scipy import stats, linalg
+def ci_test_gauss(data,A,B,S,**kwargs):
+    """Conduct Conditional Independence Test using Fisher's Z-transform 
+    for node A conditionally independent of node B given set of nodes in S.
+
+    Args:
+        data: (numpy.array) of shape (n,p) with n samples for p nodes 
+        A: (int) node index in data
+        B: (int) node index in data
+        S: (set) set of node indices in data
+    
+    Returns:
+        pval: (float) p-value of the conditional independence test for A and B given S.
+    """
+    r = partial_corr(data,A,B,S)
+    #print(r)
+    if r==1:
+        pval = 0    
+    else:
+        z = 0.5 * np.log((1+r)/(1-r))
+        T = np.sqrt(data.shape[0]-len(S)-3)*np.abs(z)
+        pval = 2*(1 - stats.norm.cdf(T))
+    return pval
+
+def partial_corr(data,A,B,S):
+    """Find Partial Correlation of var A and var B given set of vars in S.
+
+    Args:
+        data: (numpy.array) of shape (n,p) with n samples for p nodes 
+        A: (int) node index in data
+        B: (int) node index in data
+        S: (set) set of node indices in data
+
+    Returns:
+        p_corr: Partial correlation between A and B given S.
+    """
+    p = data.shape[1]
+    idx = np.zeros(p, dtype=bool)
+
+    for i in range(p):
+        if i in S:
+            idx[i]=True
+    C=data
+    beta_A = linalg.lstsq(C[:,idx], C[:,A])[0]
+    beta_B = linalg.lstsq(C[:,idx], C[:,B])[0]
+
+    res_A = C[:,A] - C[:, idx].dot(beta_A)
+    res_B = C[:,B] - C[:, idx].dot(beta_B)
+    
+    p_corr = stats.pearsonr(res_A, res_B)[0]  
+    
+    return p_corr

timeawarepc/simulate_data.py

@@ -0,0 +1,82 @@
+"""Create simulated time series dataset from three different paradigms: 
+Linear Gaussian Vector-AutoRegressive (VAR) Model,
+Non-linear Non-Gaussian VAR Model, and 
+Continuous Time Recurrent Neural Networks (CTRNN).
+"""
+import numpy as np
+from numpy.random import default_rng
+rng = default_rng(seed=111)
+
+def simulate_data(model, T = 1000, noise = 1):
+    """Simulate time seris data from one of three simulation paradigms with 4 neurons.
+
+    Args:
+        model: (string)
+            'lingauss': Linear Gaussian VAR model
+            'nonlinnongauss': Non-linear Non-Gaussian VAR model
+            'ctrnn': Continuous Time Recurrent Neural Networks
+        T: (int) Number of time recordings in the time series
+        noise: (float) Noise standard deviation
+
+    Returns: 
+        data: (numpy.array) Time series data of shape (n,p) with n time recordings for p nodes
+        CFCtruth: (numpy.array) Ground Truth adjacency matrix of shape (p,p).
+    """
+    n_neurons = 4
+    CFCtruth = np.zeros((4,4),dtype = int)
+    if model == "lingauss":
+        smspikes=np.zeros((n_neurons,T))
+        lag=1
+        for iter1 in range(n_neurons):
+            smspikes[iter1,0]=rng.normal(scale=noise)
+        for t in range(1,T):
+            smspikes[0,t]=rng.normal(scale=noise)+1
+            smspikes[1,t]=rng.normal(scale=noise)-1
+            smspikes[2,t]=2*np.sum(smspikes[0,np.max((t-lag,0)):t])+np.sum(smspikes[1,np.max((t-lag,0)):t])+rng.normal(scale=noise)
+            smspikes[3,t]=2*np.sum(smspikes[2,np.max((t-lag,0)):t])+rng.normal(scale=noise)
+        CFCtruth[0,2]=CFCtruth[1,2]=CFCtruth[2,3]=1
+    elif model == "nonlinnongauss":
+        smspikes=np.zeros((n_neurons,T))
+        lag=1
+        for iter1 in range(n_neurons):
+            smspikes[iter1,0]=np.random.uniform()
+        for t in range(1,T):
+            smspikes[0,t]=np.random.uniform(high = noise)
+            smspikes[1,t]=np.random.uniform(high = noise)
+            smspikes[2,t]=4*np.sum(np.sin(smspikes[0,np.max((t-lag,0)):t]))+3*np.sum(np.sin(smspikes[1,np.max((t-lag,0)):t]))+np.random.uniform(high = noise)
+            smspikes[3,t]=3*np.sum(np.sin(smspikes[2,np.max((t-lag,0)):t]))+np.random.uniform(high = noise)
+        CFCtruth[0,2]=CFCtruth[1,2]=CFCtruth[2,3]=1
+    elif model == 'ctrnn':
+        lag=1
+        p=4
+        w=np.zeros((p,p))
+        w[0,2]=10
+        w[1,2]=10
+        w[2,3]=10
+        n_ctrnn=T
+        tau=10
+        smspikes=simulate_ctrnn(n_ctrnn,p,w,tau,noise)
+        CFCtruth[0,2]=CFCtruth[1,2]=CFCtruth[2,3]=CFCtruth[0,0]=CFCtruth[1,1]=CFCtruth[2,2]=CFCtruth[3,3]=1
+    data = smspikes.T
+    return data,CFCtruth
+
+def simulate_ctrnn(n_ctrnn, p, w, tau, noise=1):
+    """Simulates a CTRNN.
+    
+    Args:
+        n_ctrnn: Number of time points in the CTRNN
+        p: Number of nodes.
+        w: Weight matrix.
+        tau: Time constant of the CTRNN.
+        noise: Noise level in the CTRNN.
+        
+    Returns:
+        u: (numpy.array) CTRNN time series of shape (p,n_ctrnn).
+    """
+    e=np.exp(1)
+    u=np.zeros((p,n_ctrnn))
+    for n in range(n_ctrnn-1):
+        for i in range(p):
+            In=np.random.normal(1,noise)
+            u[i,(n+1)] = u[i,n] - ((e*u[i,n])/tau) + e*np.sum(w[:,i]*np.tanh(u[:,n]))/tau + e*In/tau#np.tanh(u[:,n])
+    return u

timeawarepc/tpc.py

@@ -0,0 +1,155 @@
+"""Implements the Time-Aware PC (TPC) Algorithm for finding Causal Functional Connectivity from Time Series.
+"""
+import time
+import numpy as np
+import pandas as pd
+from timeawarepc.tpc_helpers import *
+from timeawarepc.pcalg import estimate_skeleton, estimate_cpdag, ci_test_gauss
+import rpy2.robjects as robjects
+from rpy2.robjects.packages import importr
+import rpy2.rlike.container as rlc
+from rpy2.robjects import pandas2ri
+import random
+import networkx as nx
+import re
+import numpy as np
+import warnings
+import logging
+_logger = logging.getLogger(__name__)
+#%%
+def cfc_tpc(data,maxdelay=1,subsampsize=50,niter=25,alpha=0.1,thresh=0.25,isgauss=False):
+    """Estimate Causal Functional Connectivity using TPC Algorithm.
+
+    Args:
+        data: (numpy.array) of shape (n,p) with n time-recordings for p nodes .
+        maxdelay: (int) Maximum time-delay of interactions.
+        subsampsize: (int) Bootstrap window width.
+        niter: (int) Number of bootstrap iterations.
+        alpha: (float) Significance level for conditional independence tests.
+        thresh: (float) Bootstrap stability cut-off.
+        isgauss: (boolean) 
+            True: Assume Gaussian Noise distribution. 
+            False: Distribution-free.
+
+    Returns:
+        adjacency: (numpy.array) Adcajency matrix of shape (p,p) for estimated CFC by TPC Algorithm.
+        weights: (numpy.array) Connectivity Weight matrix of shape (p,p).
+
+    Biswas, Rahul and Shlizerman, Eli (2022). Statistical perspective on functional and causal neural connectomics: the time-aware pc algorithm. arXiv preprint arXiv:2204.04845.
+    """
+    C_iter=[]
+    C_cf_iter=[]
+    C_cf2_iter=[]
+    start_time = time.time()
+    data_trans = data_transformed(data, maxdelay)#Step 1: Time-Delayed Samples
+    _logger.debug("Data transformed in "+str(time.time()-start_time))
+
+    #Steps 2-6a:
+    for inneriter in range(niter):
+        start_btrstrp = time.time()
+        _logger.debug("Starting bootstrap "+str(inneriter))
+        n=data_trans.shape[0]
+
+        #Step 2: Select random Bootstrap window
+        r_idx = random.sample(range(n-subsampsize),1)[0]
+        
+        #Step 3: PC
+        if not isgauss:
+            d = {'print.me': 'print_dot_me', 'print_me': 'print_uscore_me'}
+            kpcalg = importr('kpcalg', robject_translations = d)
+            data_trans_pd=pd.DataFrame(data_trans[r_idx:(r_idx+subsampsize),:])
+            pandas2ri.activate()
+            df = robjects.conversion.py2rpy(data_trans_pd)
+            base=importr("base")
+            out=kpcalg.kpc(**{'suffStat' : rlc.TaggedList((df,"hsic.perm"),tags=('data','ic.method')),
+            'indepTest' : kpcalg.kernelCItest,
+            'alpha' : alpha,
+            'labels' : data_trans_pd.columns.astype(str),
+            'u2pd' : "relaxed",
+            'skel.method' : "stable",
+            'verbose' : robjects.r('F')})
+            dollar = base.__dict__["@"]
+            graphobj=dollar(out, "graph")
+            graph=importr("graph")
+            graphedges=graph.edges(graphobj)#, "matrix")
+            graphedgespy={int(key): np.array(re.findall(r'-?\d+\.?\d*', str(graphedges.rx2(str(key))))).astype(int) for key in graphedges.names}
+            g=nx.DiGraph(graphedgespy)
+        else:
+            data_trans_pd=data_trans[r_idx:(r_idx+subsampsize),:]
+            (g, sep_set) = estimate_skeleton(indep_test_func=ci_test_gauss,
+                                                data_matrix=data_trans_pd,
+                                                alpha=alpha,method='stable')
+            g = estimate_cpdag(skel_graph=g, sep_set=sep_set)
+        
+        #Step 4: Orient - update: not needed
+        #g=orient(g,maxdelay,data.shape[1])
+
+        #Step 5: Rolled CFC-DPGM
+        causaleff = causaleff_ida(g,data_trans)#Interventional Causal Effects in Unrolled DAG
+        G,causaleffin, causaleffin2=return_finaledges(g,causaleff,maxdelay,data.shape[1])#Rolled CFC-DPGM
+        
+        A_rr=G
+        C_iter.append(A_rr)
+        C_cf_iter.append(causaleffin)
+        C_cf2_iter.append(causaleffin2)
+        _logger.debug("Bootstrap done in "+str(time.time()-start_btrstrp))
+        #Step 6a: Repeat Steps 2-5    
+
+    #Step 6b-c: Robust Edges and Connectivity Weights
+    adjacency=(np.mean(np.asarray(C_iter),axis=0)>=thresh).astype(int)#Robust Edges
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", category=RuntimeWarning)
+        weights=np.nanmean(np.where(np.asarray(C_cf_iter)!=0,np.asarray(C_cf_iter),np.nan),axis=0)#Robust Connectivity Weights
+    _logger.debug("CE shape "+str(weights.shape))
+
+    #Step 8: Pruning
+    adjacency[np.abs(weights) <= np.nanmax(np.abs(weights))/10]=0
+
+    return adjacency, weights
+
+def cfc_pc(data,alpha,isgauss=False):
+    """Estimate Causal Functional Connectivity using PC Algorithm.
+
+    Args:
+        data: (numpy.array) of shape (n,p) with n samples for p nodes 
+        alpha: (float) Significance level for conditional independence tests
+        isgauss: (boolean) 
+            True: Assume Gaussian Noise distribution, 
+            False: Distribution free.
+
+    Returns:
+        adjacency: (numpy.array) Adcajency matrix of shape (p,p) of estimated CFC by PC Algorithm.
+        weights: (numpy.array) Connectivity Weight matrix of shape (p,p).
+
+    """
+    if not isgauss:
+        d = {'print.me': 'print_dot_me', 'print_me': 'print_uscore_me'}
+        kpcalg = importr('kpcalg', robject_translations = d)
+        data_trans_pd = pd.DataFrame(data)
+        pandas2ri.activate()
+        df = robjects.conversion.py2rpy(data_trans_pd)
+        out=kpcalg.kpc(**{'suffStat' : rlc.TaggedList((df,"hsic.perm"),tags=('data','ic.method')),#robjects.r('list(data=data_trans, ic.method="hsic.perm")'),#list(data=data_trans, ic.method="hsic.perm"),
+        'indepTest' : kpcalg.kernelCItest,
+        'alpha' : alpha,
+        'labels' : data_trans_pd.columns.astype(str),
+        'u2pd' : "relaxed",
+        'skel.method' : "stable",
+        'verbose' : robjects.r('F')})
+        base=importr("base")
+        dollar = base.__dict__["@"]
+        graphobj=dollar(out, "graph")
+        graph=importr("graph")
+        graphedges=graph.edges(graphobj)#, "matrix")
+        import re
+        graphedgespy={int(key): np.array(re.findall(r'-?\d+\.?\d*', str(graphedges.rx2(key)))[1:]).astype(int) for key in graphedges.names}
+        g=nx.DiGraph(graphedgespy)
+    else:
+        (g, sep_set) = estimate_skeleton(indep_test_func=ci_test_gauss,
+                                            data_matrix=data,
+                                            alpha=alpha,method='stable')
+        g = estimate_cpdag(skel_graph=g, sep_set=sep_set)
+
+    weights = causaleff_ida(g,data)
+    adjacency=nx.adjacency_matrix(g).toarray()
+    return adjacency, weights*adjacency
+# %%

timeawarepc/tpc_helpers.py

@@ -0,0 +1,129 @@
+"""Helper functions for TPC Algorithm
+"""
+import numpy as np
+import networkx as nx
+def data_transformed(data, maxdelay):
+    """Implements Step 1 (Time Delay) of TPC, 
+    to construct the data with time-delayed samples.
+    
+    Args:
+        data: (numpy.array) of shape (n,p) with n time recordings of p nodes.
+        maxdelay: (int) Maximum time-delay of interactions
+
+    Returns:
+        data2: (numpy.array) Data with columns as Unrolled DAG nodes (column index v*maxdelay+t = node (v,t)) and rows having time-delayed samples.
+    """
+    n = data.shape[0]
+    p = data.shape[1]
+    maxdelay1=maxdelay+1
+    new_n = int(np.floor((n-maxdelay)/(2*maxdelay1))*(2*maxdelay1))
+    data=data[:new_n,:]
+    data2=np.zeros((int(new_n/(2*maxdelay1)),p*maxdelay1))
+    for i in range(p):
+        for j in range(maxdelay1):
+            data2[:,maxdelay1*i+j]=data[j::(2*maxdelay1),i]
+    return data2
+
+def orient(g,maxdelay,m):
+    """Implements Step 4 (Orient) of TPC, 
+    to correct future to past edges in Estimated Unrolled DAG
+    
+    Args:
+        g: (networkx.DiGraph) Unrolled Causal DAG estimate outputted by Step 3 (PC) of TPC.
+        maxdelay: (int) Maximum time-delay of interaction
+        m: (int) Number of neurons/nodes in original data
+    
+    Returns:
+        g1: (networkx.DiGraph) Re-Oriented Unrolled Causal DAG estimate.
+    """
+    labels=np.arange(0,(maxdelay+1)*m)
+
+    edge=set([])
+    labelmat=labels.reshape((m,maxdelay+1))
+    for i in range(m):
+        for k in range(m):
+            for j in range(maxdelay+1):
+                for l in range(maxdelay+1):
+                    if j<=l:# and j>=l-maxdelay:
+                    #if j==l-1:
+                        if (labelmat[i,j],labelmat[k,l]) in g.edges or (labelmat[k,l],labelmat[i,j]) in g.edges:
+                            edge = edge | {(labelmat[i,j],labelmat[k,l])}
+    g1 = nx.DiGraph()
+    g1.add_nodes_from(g.nodes)
+    g1.add_edges_from(edge)
+    return g1
+
+def causaleff_ida(g,data):
+    """Estimate interventional causal effects in the Unrolled DAG in TPC.
+
+    Args:
+        g: (networkx.DiGraph) Estimated Unrolled Causal DAG outputted by Step 4 (Orient) of TPC. 
+        data: (numpy.array) with variables for Unrolled Causal DAG in columns and time-delayed samples in rows
+
+    Returns:
+        causaleff: (numpy.array) Interventional Causal Effects among pairs of nodes in the Unrolled Causal DAG.
+    """
+    Nodes = list(g.nodes)
+    causaleff=np.zeros((len(Nodes),len(Nodes)))
+
+    for x in Nodes:
+        for y in Nodes:
+            if x!=y:
+                pa_x = list(g.predecessors(x))
+                pa_y = list(g.predecessors(y))
+                if x not in pa_x:
+                    regressors = pa_x + [x]
+                else:
+                    regressors = pa_x
+                if y in pa_x:
+#                    causaleff[x,y] = 0#uncomment this and comment below for legacy version
+                    regressors = [item for item in regressors if item != y]
+#                else:#uncomment for legacy version
+                X=np.asarray(data[:,regressors])
+                Y=np.asarray(data[:,y])
+                X0=np.hstack((np.ones((X.shape[0],1)),X))
+                lm_out = np.linalg.lstsq(X0,Y,rcond=None)[0]
+                causaleff[x,y] = lm_out[regressors.index(x)+1]
+    return causaleff
+
+def return_finaledges(g,causaleff,maxdelay,m):
+    """Implements Step 5 (Rolled CFC-DPGM) of TPC, to obtain 
+    the Rolled CFC-DPGM and its weights from the Unrolled Causal DAG
+
+    Args:
+        g: (networkx.DiGraph) Oriented Unrolled Causal DAG estimate outputted by Step 4 (Orient) of TPC.
+        causaleff: (numpy.array) Estimated Interventional Causal Effects in Unrolled DAG
+        maxdelay: (int) Maximum time-delay of interaction
+        m: (int) Number of neurons/nodes in original data
+
+    Returns:
+        adjacency: (numpy.array) Adjacency matrix for the Rolled CFC-DPGM estimate.
+        wdir: (numpy.array) Weights for direct connections in the Rolled CFC-DPGM.
+        windir: (numpy.array) Weights for indirect/direct connections in the Rolled CFC-DPGM.
+    """
+    labels=np.arange(0,(maxdelay+1)*m)
+    labelmat=labels.reshape((m,maxdelay+1))
+    causaleff1 = np.zeros((m,m))
+    causaleff2 = np.zeros((m,m))
+    edge_mat = np.zeros((m,m))==1
+    g1=g
+    for i in range(m):
+        for k in range(m):
+            acc=[]
+            ansacc=[]
+            for j in range(maxdelay+1):
+                for l in range(maxdelay+1):
+                    if j<=l:
+                        if (labelmat[i,j],labelmat[k,l]) in g1.edges:
+                            edge_mat[i,k]=True
+                            acc.append(causaleff[labelmat[i,j],labelmat[k,l]])
+                        if labelmat[i,j] in nx.ancestors(g1,labelmat[k,l]):
+                            ansacc.append(causaleff[labelmat[i,j],labelmat[k,l]])
+            if len(acc)>0:
+                causaleff1[i,k] = np.mean(acc)
+            if len(ansacc)>0:
+                causaleff2[i,k] = np.mean(ansacc)
+    adjacency = edge_mat.astype(int)
+    wdir = causaleff1
+    windir = causaleff2
+    return adjacency, wdir, windir

timeawarepc/tutorial.py

@@ -0,0 +1,60 @@
+"""
+Use this tutorial to try out main functionalities of this library and test if it has installed properly. 
+In this tutorial, you will be estimating causal functional connectivity (CFC) from simulated datasets.
+"""
+#%%
+import networkx as nx
+import numpy as np
+from numpy.random import default_rng
+rng = default_rng(seed=111)
+from timeawarepc.tpc import cfc_tpc, cfc_pc
+from timeawarepc.simulate_data import *
+from timeawarepc.find_cfc import *
+#%%
+# Simulate a dataset. 
+# Specify a data generating model: model = "lingauss" for Linear Gaussian VAR, "nonlinnongauss" for Non-Linear Non-Gaussian VAR, "ctrnn" for Continuous Time Recurrent Neural Network.
+# T is the number of time recordings (default 1000), noise is the noise std. deviation (default 1). 
+# Note that number of neurons = 4 and max delay of interaction = 1 indices are fixed in this tutorial.
+model = 'lingauss'
+T=1000
+noise = 1
+
+data, CFCtruth = simulate_data(model, T = 1000, noise = 1)
+
+#%%Estimate CFC by find_cfc(), a convenient wrapper around different methods in this library.
+#TODO: Specify a method_name. 'TPC' for Time-Aware PC Algorithm, 'PC' for PC Algorithm, 'GC' for Granger Causality.
+method_name = 'TPC'#'GC'#'PC'
+
+alpha = 0.05
+maxdelay=1
+isgauss = (model == 'lingauss')
+adjmat, causaleffmat = find_cfc(data,method_name,alpha=alpha,maxdelay=maxdelay,isgauss=isgauss)
+
+#%%Compare the Ground Truth and Estimated CFC.
+print('Ground Truth CFC adjacency:')
+print(CFCtruth)
+print('Estimated CFC adjacency by '+method_name+':')
+print(adjmat)
+
+#%%Alternatively, you may estimate CFC using the python functions for individual methods.
+#TODO: Specify a method_name. 'TPC' for Time-Aware PC Algorithm, 'PC' for PC Algorithm, 'GC' for Granger Causality.
+method_name = 'TPC'#'GC'#'PC'
+
+alpha = 0.05
+isgauss = (model == 'lingauss')
+if method_name == 'TPC':
+    maxdelay=1
+    niter = 50
+    thresh = 0.25
+    adjmat, causaleffmat = cfc_tpc(data,maxdelay=maxdelay,alpha=alpha,niter=niter,thresh=thresh,isgauss=isgauss)
+elif method_name == 'PC':
+    adjmat, causaleffmat = cfc_pc(data,alpha,isgauss=isgauss)
+elif method_name == 'GC':
+    from timeawarepc.gc import cfc_gc
+    adjmat, causaleffmat = cfc_gc(data,maxdelay,alpha)
+#%%Compare the Ground Truth and Estimated CFC.
+print('Ground Truth CFC adjacency:')
+print(CFCtruth)
+print('Estimated CFC adjacency by '+method_name+':')
+print(adjmat)
+

timeawarepc-1.2.0.dist-info/METADATA

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: timeawarepc
+Version: 1.2.0
+Summary: Time-Aware PC Python Package
+Home-page: https://github.com/biswasr/TimeAwarePC
+Author: Rahul Biswas
+Author-email: rahul.biswas@ucsf.edu
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: ==3.10.*
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: rpy2==3.5.11
+Requires-Dist: networkx
+Requires-Dist: scipy
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# TimeAwarePC: A Python Package for Finding Causal Connectivity from Time Series Data [![image](https://img.shields.io/pypi/v/timeawarepc.svg)](https://pypi.python.org/pypi/timeawarepc) [![Documentation Status](https://readthedocs.org/projects/timeawarepc/badge/?version=latest)](https://timeawarepc.readthedocs.io/en/latest/?badge=latest)
+**TimeAwarePC** is a Python package that implements the Time-Aware PC Algorithm for finding the **Causal Functional Connectivity** from time series data, based on recent research in directed probabilistic graphical modeling with time series [[1]](#Citation). The package also includes implementations of Granger Causality and the PC algorithm.
+
+<div align="center">
+  <a href="https://github.com/shlizee/TimeAwarePC"><img src="https://github.com/shlizee/TimeAwarePC/blob/main/imgs/Schematic-msgs.png?raw=true" width="500px" height="250px"></a>
+</div>
+
+## Installation
+
+You can get the latest version of TimeAwarePC as follows.
+
+```
+$ pip install timeawarepc
+```
+
+## Requirements
+- Python == 3.10
+- Python packages automatically checked and installed as part of the setup. To use Granger Causality, additional dependency of ```nitime``` which can be installed by ```pip install nitime```.
+- R == 4.4.2
+- R package ```kpcalg``` and its dependencies. They can be installed in R or RStudio as follows:
+```
+> install.packages("BiocManager")
+> BiocManager::install("graph")
+> BiocManager::install("RBGL")
+> install.packages("pcalg")
+> install.packages("https://cran.r-project.org/src/contrib/Archive/kpcalg/kpcalg_1.0.1.tar.gz")
+```
+<!-- - In addition, if you like to use Granger Causality functions in this package, please separately install nitime as follows:
+```
+pip install nitime
+``` -->
+
+## Documentation
+
+[Documentation is available at readthedocs.org](https://timeawarepc.readthedocs.io/en/latest/)
+
+## Tutorial
+
+See the [Quick Start Guide](https://timeawarepc.readthedocs.io/en/latest/gettingstarted.html) for a quick tutorial of the main functionalities of this library and check if it is installed properly. 
+<!-- 
+## Documentation
+
+[Documentation is available at readthedocs.org](https://timeaware-pc.readthedocs.io/en/latest/) -->
+
+## Contributing
+
+Your help is absolutely welcome! Please do reach out or create a feature branch!
+
+## Citation
+
+Biswas, R., & Shlizerman, E. (2022). Statistical Perspective on Functional and Causal Neural Connectomics: The Time-Aware PC Algorithm. https://arxiv.org/abs/2204.04845
+
+Biswas, R., & Shlizerman, E. (2021). Statistical Perspective on Functional and Causal Neural Connectomics: A Comparative Study. Frontiers in Systems Neuroscience. https://doi.org/10.3389/fnsys.2022.817962
+
+
+## References
+
+R Clay Reid. (2012) From functional architecture to functional connectomics. Neuron, 75(2):209–217.
+
+Smith, S. M., Miller, K. L., Salimi-Khorshidi, G., Webster, M., Beckmann, C. F., Nichols, T. E., ... & Woolrich, M. W. (2011). Network modelling methods for FMRI. Neuroimage, 54(2), 875-891.
+
+Judea Pearl. (2009) Causality. Cambridge University press.
+
+Markus Kalisch and Peter Bhlmann. (2007) Estimating high-dimensional directed acyclic graphs with the pc-algorithm. In The Journal of Machine Learning Research, Vol. 8, pp. 613-636.
+
+Peter Spirtes, Clark N Glymour, Richard Scheines, and David Heckerman. (2000) Causation, prediction, and search. MIT press.
+
+
+

timeawarepc-1.2.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+timeawarepc/__init__.py,sha256=F2EpzcGvg2i3vTRyKh06f2vUseuzW7lJdTk3qCIoGhY,200
+timeawarepc/find_cfc.py,sha256=pdAyJZLs83lJqnOhmX7TVYSSue2GUhUVK2MbKmB8SWk,1811
+timeawarepc/gc.py,sha256=X7TsZEL5Yx7DN6Df25s_tBJjpk0rBvxI62nmqt7UOic,1222
+timeawarepc/pcalg.py,sha256=ymhW0Cm4ooeDFIEt116zFeU0qThykCUWFlJnKGzo9y0,73496
+timeawarepc/pcalg_helpers.py,sha256=0QtTlyPco-4840a-Nf0ctP-BT7ANOOdCh7LTKO2pQe0,1613
+timeawarepc/simulate_data.py,sha256=17uI0zj5ubOtj9wEbKxcVdAPy-ZjKvNlwkCqUUCiAVQ,3267
+timeawarepc/tpc.py,sha256=_VheKz4fVNm369q-bj77Esdf_ylru983VmI1_vIreVM,6780
+timeawarepc/tpc_helpers.py,sha256=Y-DWGNcnUuUvlZ8a25s4KWX-_PEsMFPJXkNhbRdl21g,5124
+timeawarepc/tutorial.py,sha256=8vo2sqhgQh01aSk_6y0FrO2_x0YhVOObGIlFj09E65c,2362
+timeawarepc-1.2.0.dist-info/licenses/LICENSE,sha256=XF8u-3WEhRnvXx2JgSJBDcZkBybyCxMJdohxsmylehM,1069
+timeawarepc-1.2.0.dist-info/METADATA,sha256=A_5G0RjyogE65D9oyHjjhUybCiG5fWQNkpWeYnaEJ2E,4199
+timeawarepc-1.2.0.dist-info/WHEEL,sha256=7mLNlhqgufj7fxENZhtzRraBDfDi3AITas5GqZGp0zk,109
+timeawarepc-1.2.0.dist-info/top_level.txt,sha256=fWRzwrasctBHFwZkVXNFkWwllx1vLtaQyUBHfAJSzjQ,12
+timeawarepc-1.2.0.dist-info/RECORD,,

timeawarepc-1.2.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.0.1)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

timeawarepc-1.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Rahul Biswas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

timeawarepc-1.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+timeawarepc