GLDF 0.9.0__py3-none-any.whl

GLDF/__init__.py

@@ -0,0 +1,2 @@
+from .frontend import\
+    run_hccd_temporal_regimes,  run_hccd_spatial_regimes

GLDF/bridges/causal_learn.py

@@ -0,0 +1,185 @@
+try:
+    import causallearn.search
+except ModuleNotFoundError:
+    raise RuntimeError("Causal-learn bridge could not be loaded. Is causal-learn installed?")
+
+from causallearn.utils import cit
+
+import numpy as np
+from functools import partial
+from typing import Callable
+
+from ..hccd import  CI_Identifier, abstract_cit_t, abstract_cd_t
+from ..data_management import IManageData
+
+
+# in theory pyhton can copy functions, in practise it cannot (as of v3.13), so we copy-paste the code fromcausallearn.utils instead
+def named_CIT(data, method='fisherz', **kwargs):
+    if method == cit.fisherz:
+        return cit.FisherZ(data, **kwargs)
+    elif method == cit.kci:
+        return cit.KCI(data, **kwargs)
+    elif method in [cit.chisq, cit.gsq]:
+        return cit.Chisq_or_Gsq(data, method_name=method, **kwargs)
+    elif method == cit.mv_fisherz:
+        return cit.MV_FisherZ(data, **kwargs)
+    elif method == cit.mc_fisherz:
+        return cit.MC_FisherZ(data, **kwargs)
+    elif method == cit.d_separation:
+        return cit.D_Separation(data, **kwargs)
+    else:
+        raise ValueError("Unknown method: {}".format(method))
+
+
+
+def pick_CIT(data, method, **kwargs):
+    if isinstance(method, str):
+        return named_CIT(data, method, **kwargs)
+    else:
+        return method.provide_with_cl_args(**kwargs)
+    
+cit.CIT = pick_CIT
+    
+cit.CIT_Base = object # fix "validation" in fci
+
+from causallearn.search.ConstraintBased.PC import pc as _cl_impl_pc
+from causallearn.search.ConstraintBased.FCI import fci as _cl_impl_fci
+import causallearn.search.ConstraintBased.FCI as _FCI_module
+
+# in 'get_color_edges', l. 627 of causallearn.search.ConstraintBased.FCI there is a print command
+# apparently left over from debugging, which will spam links,
+# suppress all prints from this modul by brute-force:
+_FCI_module.print = lambda *args : None 
+
+
+def causallearn_graph_to_tigramite_graph_pc(G):
+    N, validate = G.shape
+    assert validate == N
+    result = np.full_like(G, '', dtype='<U3')
+    for i in range(N):
+        for j in range(N):
+            if G[i,j] == +1:
+                if G[j,i] == +1:
+                    result[i,j] = "<->"
+                else:
+                    assert G[j,i] == -1
+                    result[i,j] = "<--"
+            elif G[i,j] == -1:
+                if G[j,i] == +1:
+                    result[i,j] = "-->"
+                else:
+                    assert G[j,i] == -1
+                    result[i,j] = "o-o"
+    return result
+    
+def _np_replace_char(data, i, j, idx, value):
+    current = list(data[i,j])
+    current[idx] = value
+    data[i,j] = "".join(current)
+
+
+def causallearn_graph_to_tigramite_graph_fci(G):
+    N, validate = G.shape
+    assert validate == N
+    result = np.full_like(G, '', dtype='<U3')
+    for i in range(N):
+        for j in range(N):
+            if G[i,j] == 0:
+                assert G[j,i] == 0
+                continue
+            result[i,j] = "?-?"
+            if G[i,j] == +1:
+                _np_replace_char( result, i, j, 0, '<' )
+            elif G[i,j] == -1:
+                _np_replace_char( result, i, j, 0, '-' )
+            elif G[i,j] == 2:
+                _np_replace_char( result, i, j, 0, 'o' )
+            else:
+                assert False
+            if G[j,i] == +1:
+                _np_replace_char( result, i, j, 2, '>' )
+            elif G[j,i] == -1:
+                _np_replace_char( result, i, j, 2, '-' )
+            elif G[j,i] == 2:
+                _np_replace_char( result, i, j, 2, 'o' )
+            else:
+                assert False
+    return result
+                    
+
+def causallearn_graph_to_tigramite_graph(graph):
+    G = None
+    if isinstance(graph, tuple):
+        general_graph, _ = graph
+        G = general_graph.graph # fci
+        return causallearn_graph_to_tigramite_graph_fci(G)
+    else:
+        G = graph.G.graph #  pc
+        return causallearn_graph_to_tigramite_graph_pc(G)
+
+ 
+class WrapCIT_CausalLearnIndexing:
+    def __init__(self, generalized_cit: abstract_cit_t):
+        self.generalized_cit = generalized_cit
+        self.method = "custom"
+
+    def __call__(self, x_idx: int, y_idx: int, Z: list[int]) -> float:
+        ci = CI_Identifier(idx_x=x_idx, idx_y=y_idx, idx_list_z=Z)
+        result = self.generalized_cit(ci)
+        # cl wants a pvalue under independence (signigicance is decided by test, cf run_pc)
+        return 0.0 if result else 1.0 
+    
+    def provide_with_cl_args(self, **args) -> Callable[[int, int, list[int]], float]:
+        return self
+    
+
+def run_pc(data_format: IManageData, generalized_cit: abstract_cit_t, **args):
+    # Note: alpha param of cl is unused (signigicance is decided by test, cf cit-wrapper)
+    data_ignored_but_need_correct_shape_and_type = np.empty(shape=(data_format.total_sample_size(), data_format.number_of_variables()), dtype=np.void)
+    result = _cl_impl_pc(data=data_ignored_but_need_correct_shape_and_type, indep_test=WrapCIT_CausalLearnIndexing(generalized_cit), show_progress=False, **args)
+    return causallearn_graph_to_tigramite_graph(result)
+
+
+
+def run_fci(data_format: IManageData, generalized_cit: abstract_cit_t, **args):
+    # Note: alpha param of cl is unused (signigicance is decided by test, cf cit-wrapper)
+    data_ignored_but_need_correct_shape_and_type = np.empty(shape=(data_format.total_sample_size(), data_format.number_of_variables()), dtype=np.void)
+    result = _cl_impl_fci(dataset=data_ignored_but_need_correct_shape_and_type, independence_test_method=WrapCIT_CausalLearnIndexing(generalized_cit), show_progress=False, **args)
+    return causallearn_graph_to_tigramite_graph(result)
+
+
+def alg_pc(data_format: IManageData, **runtime_args) -> abstract_cd_t:
+    """
+    Get PC [SG91]_ implementation from causal learn.
+    
+    :param data_format: data manager
+    :type data_format: IManageData
+    :param runtime_args: forwarded to causal-learns run_pc (together with "stable=False")
+    :return: PC as abstract CD-algorithm.
+    :rtype: abstract_cd_t
+    """
+    return partial(run_pc, data_format=data_format, stable=False, **runtime_args)
+
+def alg_pc_stable(data_format: IManageData, **runtime_args) -> abstract_cd_t:
+    """
+    Get PC-stable [CM+14]_ implementation from causal learn.
+    
+    :param data_format: data manager
+    :type data_format: IManageData
+    :param runtime_args: forwarded to causal-learns run_pc (together with "stable=True")
+    :return: PC-stable as abstract CD-algorithm.
+    :rtype: abstract_cd_t
+    """
+    return partial(run_pc, data_format=data_format, stable=True, **runtime_args)
+
+def alg_fci(data_format: IManageData, **runtime_args) -> abstract_cd_t:
+    """
+    Get FCI [SGS01]_ implementation from causal learn.
+    
+    :param data_format: data manager
+    :type data_format: IManageData
+    :param runtime_args: forwarded to causal-learns run_fci
+    :return: FCI as abstract CD-algorithm.
+    :rtype: abstract_cd_t
+    """
+    return partial(run_fci, data_format=data_format, **runtime_args)

GLDF/bridges/tigramite.py

@@ -0,0 +1,143 @@
+try:
+    from tigramite.pcmci import PCMCI
+    from tigramite.lpcmci import LPCMCI
+except ModuleNotFoundError:
+    raise RuntimeError("Tigramite bridge could not be loaded. Is tigramite installed?")
+
+import numpy as np
+from typing import Literal
+np.fastCopyAndTranspose = lambda a: a.T.copy() # this was deprecated since 1.24.0, removed in 2.0.0, but is used in some places in tigramite
+
+from ..hccd import IHandleExplicitTransitionToMCI, CI_Identifier_TimeSeries, abstract_cit_t, abstract_cd_t
+from ..data_management import IManageData
+
+class WrapCIT_TigramiteIndexing:
+    def __init__(self, generalized_cit: abstract_cit_t):
+        self.generalized_cit = generalized_cit
+        self.method = "custom"
+        self.measure = "custom" # used only on higher verbosity of PCMCI(?)
+        self.confidence = None
+        self.significance = "custom"
+    def run_test(self, X: list[tuple[int,int]], Y: list[tuple[int,int]], Z: list[tuple[int,int]], tau_max: int, alpha_or_thres: float) -> tuple[float, float, bool]:
+        if len(X) != 1 or len(Y) != 1:
+            raise NotImplementedError("Currently this implementation supports only univariate X, Y.")
+        ci = CI_Identifier_TimeSeries(idx_x=X[0], idx_y=Y[0], idx_list_z=Z)
+        result = self.generalized_cit(ci)
+        # return dependency-score, pvalue, dependent (yes/no)
+        return 1.0 if result else 0.0, 0.0 if result else 1.0, result
+    def get_confidence(*args, **args_dict):
+        return None # run_mci with val_only=True does not seem to work
+
+class WrapPCMCI(PCMCI):
+    def __init__(self, data_format: IManageData, mode: Literal["PCMCI", "PCMCI+"]="PCMCI", mci_transition_callback: IHandleExplicitTransitionToMCI=None, pcmci_obj_init_args: dict={}, pcmci_obj_run_args: dict={}):
+        class PlaceholderTest:
+            def set_dataframe(self, not_a_dataframe):
+                pass
+        class PlaceholderDataframe:
+            def __init__(self):
+                self.var_names = None
+                self.T = None
+                self.N = None
+
+        super().__init__(dataframe=PlaceholderDataframe(), cond_ind_test=PlaceholderTest(), **pcmci_obj_init_args)
+        self.data_format = data_format
+        self.mci_transition_callback = mci_transition_callback
+        self.runtime_args = pcmci_obj_run_args
+        if mode == "PCMCI":
+            self.run = self.run_pcmci
+        elif mode == "PCMCIplus" or mode == "PCMCI+":
+            self.run = self.run_pcmciplus
+        else:
+            raise ValueError("Unknown mode for PCMCI, supported values are 'PCMCI' or 'PCMCI+'. Did you want to use WrapLPCMCI instead?")
+
+    def run_pc_stable(self, *args_tuple, **args_dict):
+        self.mci_transition_callback.enter_pc1()
+        return super().run_pc_stable(*args_tuple, **args_dict)
+    def run_mci(self, *args_tuple, **args_dict):
+        self.mci_transition_callback.enter_mci()
+        return super().run_mci(*args_tuple, **args_dict)
+    def _pcmciplus_mci_skeleton_phase(self, *args_tuple, **args_dict):
+        self.mci_transition_callback.enter_mci()
+        return super()._pcmciplus_mci_skeleton_phase(*args_tuple, **args_dict)
+
+    def __call__(self, generalized_cit: abstract_cit_t):
+        self.T, self.N = {0: self.data_format.total_sample_size()}, self.data_format.number_of_variables()
+        self.cond_ind_test = WrapCIT_TigramiteIndexing(generalized_cit)
+        result = self.run(**self.runtime_args)
+        return result['graph']
+
+
+class WrapLPCMCI(LPCMCI):
+    def __init__(self, data_format: IManageData, lpcmci_obj_init_args: dict={}, lpcmci_obj_run_args: dict={}):
+        class PlaceholderTest:
+            def set_dataframe(self, not_a_dataframe):
+                pass
+        class PlaceholderDataframe:
+            def __init__(self):
+                self.var_names = None
+                self.T = None
+                self.N = None
+        super().__init__(dataframe=PlaceholderDataframe(), cond_ind_test=PlaceholderTest(), **lpcmci_obj_init_args)
+        self.data_format = data_format
+        self.runtime_args = lpcmci_obj_run_args
+
+    def __call__(self, generalized_cit: abstract_cit_t):
+        self.T, self.N = {0: self.data_format.total_sample_size()}, self.data_format.number_of_variables()
+        self.cond_ind_test = WrapCIT_TigramiteIndexing(generalized_cit)
+        result = self.run_lpcmci(**self.runtime_args)
+        return result['graph']
+
+
+def alg_pcmci(data_format: IManageData, mci_transition_callback: IHandleExplicitTransitionToMCI=None, pcmci_obj_init_args: dict={}, pcmci_obj_run_args: dict={}) -> abstract_cd_t:
+    """
+    Get PCMCI [RNK+19]_ implementation from tigramite. Use with :py:class:`ControllerTimeseries<GLDF.hccd.ControllerTimeseries>`.
+
+    :param data_format: data manager
+    :type data_format: IManageData
+    :param mci_transition_callback: transition callback (typically :py:class:`IndependenceAtoms_TimeSeries<GLDF.independence_atoms.IndependenceAtoms_TimeSeries>`)
+    :type mci_transition_callback: IHandleExplicitTransitionToMCI
+    :param pcmci_obj_init_args: forwarded to tigramites PCMCI constructor
+    :type pcmci_obj_init_args: dict
+    :param pcmci_obj_run_args: forwarded to tigramites PCMCI.run_pcmci
+    :type pcmci_obj_run_args: dict
+    :return: PCMCI as abstract CD-algorithm.
+    :rtype: abstract_cd_t
+    """
+    return WrapPCMCI(data_format=data_format, mode="PCMCI", mci_transition_callback=mci_transition_callback,
+                     pcmci_obj_init_args=pcmci_obj_init_args, pcmci_obj_run_args=pcmci_obj_run_args)
+
+def alg_pcmciplus(data_format: IManageData, mci_transition_callback: IHandleExplicitTransitionToMCI=None, pcmci_obj_init_args: dict={}, pcmci_obj_run_args: dict={}) -> abstract_cd_t:
+    """
+    Get PCMCI+ [R20]_ implementation from tigramite. Use with :py:class:`ControllerTimeseries<GLDF.hccd.ControllerTimeseries>`.
+
+    :param data_format: data manager
+    :type data_format: IManageData
+    :param mci_transition_callback: transition callback (typically :py:class:`IndependenceAtoms_TimeSeries<GLDF.independence_atoms.IndependenceAtoms_TimeSeries>`)
+    :type mci_transition_callback: IHandleExplicitTransitionToMCI
+    :param pcmci_obj_init_args: forwarded to tigramites PCMCI constructor
+    :type pcmci_obj_init_args: dict
+    :param pcmci_obj_run_args: forwarded to tigramites PCMCI.run_pcmciplus
+    :type pcmci_obj_run_args: dict
+    :return: PCMCI+ as abstract CD-algorithm.
+    :rtype: abstract_cd_t
+    """
+    return WrapPCMCI(data_format=data_format, mode="PCMCI+", mci_transition_callback=mci_transition_callback,
+                     pcmci_obj_init_args=pcmci_obj_init_args, pcmci_obj_run_args=pcmci_obj_run_args)
+
+def alg_lpcmci(data_format: IManageData, lpcmci_obj_init_args: dict={}, lpcmci_obj_run_args: dict={}) -> abstract_cd_t:
+    """
+    Get LPCMCI [GR20]_ implementation from tigramite. Use with :py:class:`ControllerTimeseriesLPCMCI<GLDF.hccd.ControllerTimeseriesLPCMCI>`.
+
+    *Note: In this case a transition callback* :py:class:`IHandleExplicitTransitionToMCI<GLDF.hccd.IHandleExplicitTransitionToMCI>` *is*
+    *notified by the controller* :py:class:`ControllerTimeseriesLPCMCI<GLDF.hccd.ControllerTimeseriesLPCMCI>`\\ *.*
+
+    :param data_format: data manager
+    :type data_format: IManageData
+    :param lpcmci_obj_init_args: forwarded to tigramites LPCMCI constructor
+    :type lpcmci_obj_init_args: dict
+    :param lpcmci_obj_run_args: forwarded to tigramites LPCMCI.run_lpcmci
+    :type lpcmci_obj_run_args: dict
+    :return: LPCMCI as abstract CD-algorithm.
+    :rtype: abstract_cd_t
+    """
+    return WrapLPCMCI(data_format=data_format, lpcmci_obj_init_args=lpcmci_obj_init_args, lpcmci_obj_run_args=lpcmci_obj_run_args)