Conditional Correlation Tests

README.md

@@ -140,6 +140,5 @@ Contributions of any kind are welcome!
 ## Project History
 
 hyppo is a rebranding of mgcpy, which was founded in November 2018.
-mgcpy was designed and written by Satish Palaniappan, Sambit
-Panda, Junhao Xiong, Sandhya Ramachandran, and Ronak Mehtra. hyppo
+mgcpy was designed and written by @tpsatish95, @sampan501, @junhaobearxiong, @sundaysundya, @ananyas713, and @ronakdm. hyppo
 was designed and written by Sambit Panda and first released in February 2020.

benchmarks/condi_indep_power_sampsize.py

@@ -0,0 +1,132 @@
+"""
+1D Independence Testing Power vs. Sample Size
+===============================================
+
+Here, we show finite testing power comparisons between the various tests within hyppo.
+For a test to be consistent, we would expect power to converge to 1 as sample size
+increases. Tests that converge to 1 quicker have higher finite testing power and
+are likely better to use for your use case. The simulation in the bottom right is
+used so that we know that we are properly controlling for type I error, which is
+important becase otherwise the test would be invalid (power = alpha-level = 0.05).
+"""
+
+import os
+import sys
+
+import matplotlib.pyplot as plt
+import numpy as np
+import seaborn as sns
+from hyppo.conditional import COND_INDEP_TESTS
+from hyppo.tools import COND_SIMULATIONS, power
+from joblib import Parallel, delayed
+
+sys.path.append(os.path.realpath(".."))
+
+# make plots look pretty
+sns.set(color_codes=True, style="white", context="talk", font_scale=2)
+PALETTE = sns.color_palette("Set1")
+sns.set_palette(PALETTE[1:])
+
+# constants
+MAX_SAMPLE_SIZE = 100
+STEP_SIZE = 5
+SAMP_SIZES = range(5, MAX_SAMPLE_SIZE + STEP_SIZE, STEP_SIZE)
+POWER_REPS = 5
+
+# simulation titles
+SIM_TITLES = [k for k, v in COND_SIMULATIONS.items()]
+
+# these tests only make sense for > 1 dimension data
+remove = ["fcit", "kci"]
+COND_INDEP_TESTS = dict([(k, v) for k, v in INDEP_TESTS.items() if k not in remove])
+
+
+def estimate_power(sim, test, auto=False):
+    """Compute the mean of the estimated power of 5 replications over sample sizes."""
+    if test == "MaxMargin":
+        test = ["MaxMargin", "Dcorr"]
+    est_power = np.array(
+        [
+            np.mean(
+                [
+                    power(test, pow_type="indep", sim=sim, n=i, p=1, auto=auto)
+                    for _ in range(POWER_REPS)
+                ]
+            )
+            for i in SAMP_SIZES
+        ]
+    )
+    np.savetxt(
+        "../benchmarks/conditional_vs_samplesize/{}_{}.csv".format(sim, test),
+        est_power,
+        delimiter=",",
+    )
+
+    return est_power
+
+
+# At this point, we would run this bit of code to generate the data for the figure and
+# store it under the "vs_sampsize" directory. Since this code takes a very long time,
+# we have commented out these lines of codes. If you would like to generate the data,
+# uncomment these lines and run the file.
+
+outputs = Parallel(n_jobs=-1, verbose=100)(
+    [
+        delayed(estimate_featimport)(sim_name, test)
+        for sim_name in SIMULATIONS.keys()
+        for test in INDEP_TESTS.keys()
+    ]
+)
+
+
+def plot_power():
+    fig, ax = plt.subplots(nrows=4, ncols=5, figsize=(25, 20))
+    plt.suptitle(
+        "Multivariate Independence Testing (Increasing Sample Size)",
+        y=0.93,
+        va="baseline",
+    )
+
+    for i, row in enumerate(ax):
+        for j, col in enumerate(row):
+            count = 5 * i + j
+            sim = list(SIMULATIONS.keys())[count]
+
+            for test in INDEP_TESTS.keys():
+                est_power = np.genfromtxt(
+                    "../benchmarks/vs_samplesize/{}_{}.csv".format(sim, test),
+                    delimiter=",",
+                )
+
+                col.plot(SAMP_SIZES, est_power, label=INDEP_TESTS[test].__name__, lw=2)
+                col.set_xticks([])
+                if i == 3:
+                    col.set_xticks([SAMP_SIZES[0], SAMP_SIZES[-1]])
+                col.set_ylim(-0.05, 1.05)
+                col.set_yticks([])
+                if j == 0:
+                    col.set_yticks([0, 1])
+                col.set_title(SIM_TITLES[count])
+
+    fig.text(0.5, 0.05, "Sample Size", ha="center")
+    fig.text(
+        0.07,
+        0.5,
+        "Statistical Power",
+        va="center",
+        rotation="vertical",
+    )
+    leg = plt.legend(
+        bbox_to_anchor=(0.5, 0.05),
+        bbox_transform=plt.gcf().transFigure,
+        ncol=len(INDEP_TESTS.keys()),
+        loc="upper center",
+    )
+    leg.get_frame().set_linewidth(0.0)
+    for legobj in leg.legendHandles:
+        legobj.set_linewidth(5.0)
+    plt.subplots_adjust(hspace=0.50)
+
+
+# plot the power
+plot_power()

docs/changelog/v0.3.3.md

@@ -0,0 +1,17 @@
+# hyppo v0.3.3
+
+> **Note:** hyppo v0.3.3 has not been released yet!
+
+This is a minor release for general bug fixes, documentation improvements, and general package maintenance.
+
+## Authors
+
+<a href="https://github.com/sampan501">
+  <img src="https://github.com/sampan501.png" width="50">
+</a>
+
+## Issues Closed
+
+## PRs Merged
+
+* [#232](https://github.com/neurodata/hyppo/pull/310): run pytest in parallel

hyppo/conditional/__init__.py

@@ -1,7 +1,15 @@
+from .cdcorr import ConditionalDcorr
 from .FCIT import FCIT
 from .kci import KCI
-
+from .pcorr import PartialCorr
+from .pdcorr import PartialDcorr
 
 __all__ = [s for s in dir()]  # add imported tests to __all__
 
-COND_INDEP_TESTS = {"fcit": FCIT, "kci": KCI}
+COND_INDEP_TESTS = {
+    "fcit": FCIT,
+    "kci": KCI,
+    "conditionaldcorr": ConditionalDcorr,
+    "partialcorr": PartialCorr,
+    "partialdcorr": PartialDcorr,
+}

hyppo/conditional/_utils.py

@@ -0,0 +1,95 @@
+import numpy as np
+
+from ..tools import check_ndarray_xyz, check_reps, contains_nan, convert_xyz_float64
+
+
+class _CheckInputs:
+    """Checks inputs for all independence tests"""
+
+    def __init__(self, x, y, z, reps=None, max_dims=None, ignore_z_var=False):
+        self.x = x
+        self.y = y
+        self.z = z
+        self.reps = reps
+        self.max_dims = max_dims
+        self.ignore_z_var = ignore_z_var # to allow for constant z input
+
+    def __call__(self):
+        check_ndarray_xyz(self.x, self.y, self.z)
+        contains_nan(self.x)
+        contains_nan(self.y)
+        contains_nan(self.z)
+        self.x, self.y, self.z = self.check_dim_xyz(max_dims=self.max_dims)
+        self.x, self.y, self.z = convert_xyz_float64(self.x, self.y, self.z)
+        self._check_min_samples()
+        self._check_variance()
+
+        if self.reps:
+            check_reps(self.reps)
+
+        return self.x, self.y, self.z
+
+    def check_dim_xyz(self, max_dims):
+        """Check and convert x and y to proper dimensions"""
+        if self.x.ndim == 1:
+            self.x = self.x[:, np.newaxis]
+        elif self.x.ndim != 2:
+            raise ValueError(
+                "Expected a 2-D array `x`, found shape " "{}".format(self.x.shape)
+            )
+        if self.y.ndim == 1:
+            self.y = self.y[:, np.newaxis]
+        elif self.y.ndim != 2:
+            raise ValueError(
+                "Expected a 2-D array `y`, found shape " "{}".format(self.y.shape)
+            )
+        if self.z.ndim == 1:
+            self.z = self.z[:, np.newaxis]
+        elif self.z.ndim != 2:
+            raise ValueError(
+                "Expected a 2-D array `z`, found shape " "{}".format(self.z.shape)
+            )
+
+        if max_dims is not None:
+            _, dx = self.x.shape
+            _, dy = self.y.shape
+            _, dz = self.z.shape
+
+            if np.any(np.array([dx, dy, dz]) > max_dims):
+                raise ValueError(
+                    f"x, y, z must have be univariate and have shape [n,{max_dims}]"
+                )
+
+        self._check_nd_indeptest()
+
+        return self.x, self.y, self.z
+
+    def _check_nd_indeptest(self):
+        """Check if number of samples is the same"""
+        nx, _ = self.x.shape
+        ny, _ = self.y.shape
+        nz, _ = self.z.shape
+        if not np.all(np.array([nx, ny, nz]) == nx):
+            raise ValueError(
+                "Shape mismatch, x, y and z must have shape "
+                + "[n, p], [n, q] and [n, r]."
+            )
+
+    def _check_min_samples(self):
+        """Check if the number of samples is at least 3"""
+        nx = self.x.shape[0]
+        ny = self.y.shape[0]
+        nz = self.z.shape[0]
+
+        if nx <= 3 or ny <= 3 or nz <= 3:
+            raise ValueError("Number of samples is too low")
+
+    def _check_variance(self):
+        if np.var(self.x) == 0:
+        # or np.var(self.y) == 0 or np.var(self.z) == 0:
+            raise ValueError("Test cannot be run. Input array x has 0 variance.")
+        if np.var(self.y) == 0:
+            raise ValueError("Test cannot be run. Input array y has 0 variance")
+        if not self.ignore_z_var:
+            if np.var(self.z) == 0:
+                raise ValueError("Test cannot be run. Input array z has 0 variance")

hyppo/conditional/base.py

@@ -13,7 +13,11 @@ class ConditionalIndependenceTest(ABC):
 
     """
 
-    def __init__(self):
+    def __init__(self, **kwargs):
+        self.stat = None
+        self.pvalue = None
+        self.kwargs = kwargs
+
         super().__init__()
 
     @abstractmethod