From fe950d2dd753dc45fc72988dcbf16360fc481d71 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Sat, 3 Aug 2019 12:22:52 -0700 Subject: [PATCH 1/3] ENH: empirical distribution for chi2 based on random permutations --- esda/join_counts.py | 133 ++++++-- esda/tests/test_join_counts.py | 8 +- notebooks/joincounts.ipynb | 584 +++++++++++++++++++++++++++++++-- 3 files changed, 651 insertions(+), 74 deletions(-) diff --git a/esda/join_counts.py b/esda/join_counts.py index 60b536d7..ceb8a171 100644 --- a/esda/join_counts.py +++ b/esda/join_counts.py @@ -2,7 +2,7 @@ Spatial autocorrelation for binary attributes """ -__author__ = "Sergio J. Rey , Luc Anselin " +__author__ = "Serge Rey , Luc Anselin " from libpysal.weights.spatial_lag import lag_spatial from .tabular import _univariate_handler @@ -10,8 +10,9 @@ from scipy.stats import chi2 import numpy as np import pandas as pd +import warnings -__all__ = ['Join_Counts'] +__all__ = ["Join_Counts"] PERMUTATIONS = 999 @@ -74,21 +75,17 @@ class Join_Counts(object): minimum of permuted bw values max_bw : float maximum of permuted bw values - chi2 : float - Chi-square statistic on contingency table for join counts - chi2_p : float - Analytical p-value for chi2 - chi2_dof : int - Degrees of freedom for analytical chi2 crosstab : DataFrame Contingency table for observed join counts expected : DataFrame Expected contingency table for the null + chi2 : float + Observed value of chi2 for join count contingency table (see Notes). p_sim_chi2 : float p-value for chi2 under random spatial permutations - + Examples -------- @@ -105,7 +102,7 @@ class Join_Counts(object): >>> jc.bw 4.0 >>> jc.ww - 10.0 + 10. 0 >>> jc.J 24.0 >>> len(jc.sim_bb) @@ -128,25 +125,31 @@ class Join_Counts(object): 24.0 >>> np.min(jc.sim_bw) 7.0 - >>> round(jc.chi2_p, 3) - 0.004 >>> jc.p_sim_chi2 - 0.002 + 0.008 Notes ----- - Technical details and derivations can be found in :cite:`cliff81`. + Analytical inference using the chi2 is approximate and is thus not used in esda. The independence assumption is clearly violated for join counts even if the data is free from spatial autocorrelation as neighboring join counts will be correlated by construction. Thus only, the chi2 attribute is reported, no analytical p-values are reported. + + Instead, `p_sim_chi2` is reported which uses the sampling distribution of the chi2 statistic under the null based on random spatial permutations of the data. + + Warnings will be issued when zero values for specific expected values of join counts are encountered in the sample or when carrying out the permutations. In the former case, no inference related attributes are set on the object, while in the latter, realizations with zero expected counts are not used in constructing the sampling distribution for the chi2 statistic. + + Technical details and derivations can be found in :cite:`cliff81`. """ + def __init__(self, y, w, permutations=PERMUTATIONS): y = np.asarray(y).flatten() - w.transformation = 'b' # ensure we have binary weights + w.transformation = "b" # ensure we have binary weights self.w = w - self.adj_list = self.w.to_adjlist(remove_symmetric=True) + self.adj_list = self.w.to_adjlist() # full symmetry needed for tables self.y = y self.permutations = permutations - self.J = w.s0 / 2. + self.J = w.s0 / 2.0 results = self.__calc(self.y) +<<<<<<< HEAD self.bb = results[0] self.ww = results[1] self.bw = results[2] @@ -206,6 +209,52 @@ def __init__(self, y, w, permutations=PERMUTATIONS): self.p_sim_chi2 = p_sim_chi2 self.p_sim_autocorr_pos = p_sim_autocorr_pos self.p_sim_autocorr_neg = p_sim_autocorr_neg +======= + if results: + self.bb = results[0] + self.ww = results[1] + self.bw = results[2] + self.chi2 = results[3] + crosstab = pd.DataFrame(data=results[-2]) + id_names = ["W", "B"] + idx = pd.Index(id_names, name="Focal") + crosstab.set_index(idx, inplace=True) + crosstab.columns = pd.Index(id_names, name="Neighbor") + self.crosstab = crosstab + expected = pd.DataFrame(data=results[-1]) + expected.set_index(idx, inplace=True) + expected.columns = pd.Index(id_names, name="Neighbor") + self.expected = expected + self.calc = self.__calc + + if permutations: + sim = [] + i = 0 + while i < permutations: + try: + res = self.__calc(np.random.permutation(self.y)) + sim.append(res) + i += 1 + except ValueError: + warnings.warn('Zero expected joins encountered, ignoring realization.') + pass + sim_jc = np.array(sim) + self.sim_bb = sim_jc[:, 0] + self.min_bb = np.min(self.sim_bb) + self.mean_bb = np.mean(self.sim_bb) + self.max_bb = np.max(self.sim_bb) + self.sim_bw = sim_jc[:, 2] + self.min_bw = np.min(self.sim_bw) + self.mean_bw = np.mean(self.sim_bw) + self.max_bw = np.max(self.sim_bw) + self.sim_chi2 = sim_jc[:, 3] + p_sim_bb = self.__pseudop(self.sim_bb, self.bb) + p_sim_bw = self.__pseudop(self.sim_bw, self.bw) + p_sim_chi2 = self.__pseudop(self.sim_chi2, self.chi2) + self.p_sim_bb = p_sim_bb + self.p_sim_bw = p_sim_bw + self.p_sim_chi2 = p_sim_chi2 +>>>>>>> ENH: empirical distribution for chi2 based on random permutations def __calc(self, z): adj_list = self.adj_list @@ -214,20 +263,25 @@ def __calc(self, z): neighbor = zseries.loc[adj_list.neighbor].values sim = focal == neighbor dif = 1 - sim - bb = (focal * sim).sum() - ww = ((1-focal) * sim).sum() - bw = (focal * dif).sum() - wb = ((1-focal) * dif).sum() - table = [[ww, wb], - [bw, bb]] - chi2 = chi2_contingency(table) + bb = (focal * sim).sum() / 2. + ww = ((1 - focal) * sim).sum() / 2. + bw = (focal * dif).sum() / 2. + wb = ((1 - focal) * dif).sum() / 2. + table = [[ww, wb], [bw, bb]] + try: + chi2 = chi2_contingency(table) + except ValueError: + msg = 'Zero expected join count encountered. No inference made.' + msg += str(table) + warnings.warn(msg) + return None stat, pvalue, dof, expected = chi2 - return (bb, ww, bw+wb, stat, pvalue, dof, expected, np.array(table)) + return (bb, ww, bw + wb, stat, np.array(table), expected) def __pseudop(self, sim, jc): - above = sim >=jc + above = sim >= jc larger = sum(above) - psim = (larger + 1.) / (self.permutations + 1.) + psim = (larger + 1.0) / (self.permutations + 1.0) return psim @property @@ -235,7 +289,9 @@ def _statistic(self): return self.bw @classmethod - def by_col(cls, df, cols, w=None, inplace=False, pvalue='sim', outvals=None, **stat_kws): + def by_col( + cls, df, cols, w=None, inplace=False, pvalue="sim", outvals=None, **stat_kws + ): """ Function to compute a Join_Count statistic on a dataframe @@ -271,11 +327,16 @@ def by_col(cls, df, cols, w=None, inplace=False, pvalue='sim', outvals=None, **s """ if outvals is None: outvals = [] - outvals.extend(['bb', 'p_sim_bw', 'p_sim_bb']) - pvalue = '' - return _univariate_handler(df, cols, w=w, inplace=inplace, pvalue=pvalue, - outvals=outvals, stat=cls, - swapname='bw', **stat_kws) - - - + outvals.extend(["bb", "p_sim_bw", "p_sim_bb"]) + pvalue = "" + return _univariate_handler( + df, + cols, + w=w, + inplace=inplace, + pvalue=pvalue, + outvals=outvals, + stat=cls, + swapname="bw", + **stat_kws + ) diff --git a/esda/tests/test_join_counts.py b/esda/tests/test_join_counts.py index 682064a7..598992da 100644 --- a/esda/tests/test_join_counts.py +++ b/esda/tests/test_join_counts.py @@ -34,12 +34,8 @@ def test_Join_Counts(self): self.assertAlmostEqual(np.mean(jc.sim_bw), 12.811811811811811) self.assertAlmostEqual(np.max(jc.sim_bw), 24.0) self.assertAlmostEqual(np.min(jc.sim_bw), 7.0) - self.assertAlmostEqual(8.479632255856034, jc.chi2) - self.assertAlmostEqual(0.003591446953916693, jc.chi2_p) - self.assertAlmostEqual(0.002, jc.p_sim_chi2) - self.assertAlmostEqual(1.0, jc.p_sim_autocorr_neg) - self.assertAlmostEqual(0.001, jc.p_sim_autocorr_pos) - self.assertAlmostEqual(0.2653504320039377, jc.sim_autocorr_chi2) + self.assertAlmostEqual(8.16666666666666, jc.chi2) + self.assertAlmostEqual(0.008, jc.p_sim_chi2) @unittest.skipIf(PANDAS_EXTINCT, 'missing pandas') def test_by_col(self): diff --git a/notebooks/joincounts.ipynb b/notebooks/joincounts.ipynb index c7357ee4..eeb9d549 100644 --- a/notebooks/joincounts.ipynb +++ b/notebooks/joincounts.ipynb @@ -15,7 +15,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -24,7 +24,7 @@ "10.0" ] }, - "execution_count": 3, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -41,7 +41,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -78,11 +78,11 @@ " \n", " W\n", " 10.0\n", - " 1.0\n", + " 2.0\n", " \n", " \n", " B\n", - " 3.0\n", + " 2.0\n", " 10.0\n", " \n", " \n", @@ -92,11 +92,11 @@ "text/plain": [ "Neighbor W B\n", "Focal \n", - "W 10.0 1.0\n", - "B 3.0 10.0" + "W 10.0 2.0\n", + "B 2.0 10.0" ] }, - "execution_count": 4, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -107,7 +107,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -143,26 +143,26 @@ " \n", " \n", " W\n", - " 5.958333\n", - " 5.041667\n", + " 6.0\n", + " 6.0\n", " \n", " \n", " B\n", - " 7.041667\n", - " 5.958333\n", + " 6.0\n", + " 6.0\n", " \n", " \n", "\n", "" ], "text/plain": [ - "Neighbor W B\n", - "Focal \n", - "W 5.958333 5.041667\n", - "B 7.041667 5.958333" + "Neighbor W B\n", + "Focal \n", + "W 6.0 6.0\n", + "B 6.0 6.0" ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -171,6 +171,26 @@ "jc.expected" ] }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8.166666666666666" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "jc.chi2" + ] + }, { "cell_type": "code", "execution_count": 6, @@ -179,7 +199,7 @@ { "data": { "text/plain": [ - "8.479632255856034" + "0.008" ] }, "execution_count": 6, @@ -188,7 +208,7 @@ } ], "source": [ - "jc.chi2" + "jc.p_sim_chi2" ] }, { @@ -199,7 +219,7 @@ { "data": { "text/plain": [ - "0.003591446953916693" + "0.003" ] }, "execution_count": 7, @@ -208,7 +228,47 @@ } ], "source": [ - "jc.chi2_p" + "round(jc.p_sim_bb, 3)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "10.0" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.max(jc.sim_bb)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.0" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.min(jc.sim_bb)" ] }, { @@ -219,7 +279,7 @@ { "data": { "text/plain": [ - "0.002" + "1.0" ] }, "execution_count": 10, @@ -228,16 +288,27 @@ } ], "source": [ - "jc.p_sim_chi2" + "jc.p_sim_bw" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "12.811811811811811" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "import seaborn as sns" + "np.mean(jc.sim_bw)" ] }, { @@ -248,16 +319,72 @@ { "data": { "text/plain": [ - "" + "24.0" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" + } + ], + "source": [ + "np.max(jc.sim_bw)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "7.0" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.min(jc.sim_bw)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "import seaborn as sns" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -291,7 +418,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -311,7 +438,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -320,13 +447,13 @@ "Text(0.5, 1.0, 'WW Counts')" ] }, - "execution_count": 15, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -344,6 +471,399 @@ "plt.title('WW Counts')\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Handle zero cell values" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.stats import chi2_contingency\n", + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "table = [ [0, 1], [2, 3]]\n", + "r = chi2_contingency(table)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.15000000000000002, 0.6985353583033386, 1, array([[0.33333333, 0.66666667],\n", + " [1.66666667, 3.33333333]]))" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "r\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'[[0.33333333 0.66666667]\\n [1.66666667 3.33333333]]'" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "str(r[-1])" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "def calc(y, w):\n", + " adj_list = w.to_adjlist(remove_symmetric=True)\n", + " zseries = pd.Series(y, index=w.id_order)\n", + " focal = zseries.loc[adj_list.focal].values\n", + " neighbor = zseries.loc[adj_list.neighbor].values\n", + " sim = focal == neighbor\n", + " dif = 1 - sim\n", + " bb = (focal * sim).sum()\n", + " ww = ((1 - focal) * sim).sum()\n", + " bw = (focal * dif).sum()\n", + " wb = ((1 - focal) * dif).sum()\n", + " table = [[ww, wb], [bw, bb]]\n", + " print(table)\n", + " try:\n", + " chi2 = chi2_contingency(table)\n", + " except ValueError:\n", + " print('inadmissible expected counts')\n", + " warnings.warn('Zero expected joins encountered, no inference possible.')\n", + " return None\n", + " stat, pvalue, dof, expected = chi2\n", + " return (bb, ww, bw + wb, stat, pvalue, dof, expected, np.array(table))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[5.0, 2.0], [2.0, 3.0]]\n" + ] + }, + { + "data": { + "text/plain": [ + "(3.0,\n", + " 5.0,\n", + " 4.0,\n", + " 0.2448979591836734,\n", + " 0.6206907170753546,\n", + " 1,\n", + " array([[4.08333333, 2.91666667],\n", + " [2.91666667, 2.08333333]]),\n", + " array([[5., 2.],\n", + " [2., 3.]]))" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "w = lps.weights.lat2W(3,3)\n", + "y = np.ones((w.n,))\n", + "y[0:5] = 0\n", + "calc(y, w)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[10.0, 2.0], [0.0, 0.0]]\n", + "inadmissible expected counts\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/serge/anaconda3/envs/esda/lib/python3.7/site-packages/ipykernel_launcher.py:19: UserWarning: Zero expected joins encountered, no inference possible.\n" + ] + } + ], + "source": [ + "w = lps.weights.lat2W(3,3)\n", + "y = np.ones((w.n,))\n", + "y[0:8] = 0\n", + "calc(y, w)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "jc = esda.Join_Counts(y, w)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2.4793388429752072" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "jc.chi2" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "jc" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'[[0, 1], [2, 3]]'" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "str(table)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
NeighborWB
Focal
W10.0833330.916667
B0.9166670.083333
\n", + "
" + ], + "text/plain": [ + "Neighbor W B\n", + "Focal \n", + "W 10.083333 0.916667\n", + "B 0.916667 0.083333" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "jc.expected" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "24.0" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "w.s0" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
NeighborWB
Focal
W10.01.0
B1.00.0
\n", + "
" + ], + "text/plain": [ + "Neighbor W B\n", + "Focal \n", + "W 10.0 1.0\n", + "B 1.0 0.0" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "jc.crosstab" + ] + }, { "cell_type": "code", "execution_count": null, From 641780a4721baa40d9eccd2fe1e77b4debeee003 Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Sat, 3 Aug 2019 13:42:16 -0700 Subject: [PATCH 2/3] removing pos and neg tail conflicts --- esda/join_counts.py | 62 ---------------------------------- esda/tests/test_join_counts.py | 2 -- 2 files changed, 64 deletions(-) diff --git a/esda/join_counts.py b/esda/join_counts.py index ceb8a171..58962ff6 100644 --- a/esda/join_counts.py +++ b/esda/join_counts.py @@ -149,67 +149,6 @@ def __init__(self, y, w, permutations=PERMUTATIONS): self.permutations = permutations self.J = w.s0 / 2.0 results = self.__calc(self.y) -<<<<<<< HEAD - self.bb = results[0] - self.ww = results[1] - self.bw = results[2] - self.chi2 = results[3] - self.chi2_p = results[4] - self.chi2_dof = results[5] - self.autocorr_pos = self.bb + self.ww - self.autocorr_neg = self.bw - - crosstab = pd.DataFrame(data=results[-1]) - id_names = ['W', 'B'] - idx = pd.Index(id_names, name='Focal') - crosstab.set_index(idx, inplace=True) - crosstab.columns = pd.Index(id_names, name='Neighbor') - self.crosstab = crosstab - expected = pd.DataFrame(data=results[6]) - expected.set_index(idx, inplace=True) - expected.columns = pd.Index(id_names, name='Neighbor') - self.expected = expected - self.calc = self.__calc - - if permutations: - sim = [] - i = 0 - while i < permutations: - try: - res = self.__calc(np.random.permutation(self.y)) - sim.append(res) - i += 1 - except ValueError: - # expected count of 0 -> inadmissible - pass - sim_jc = np.array(sim) - self.sim_bb = sim_jc[:, 0] - self.min_bb = np.min(self.sim_bb) - self.mean_bb = np.mean(self.sim_bb) - self.max_bb = np.max(self.sim_bb) - self.sim_bw = sim_jc[:, 2] - self.min_bw = np.min(self.sim_bw) - self.mean_bw = np.mean(self.sim_bw) - self.max_bw = np.max(self.sim_bw) - self.sim_autocurr_pos = sim_jc[:, 0]+sim_jc[:, 1] - self.sim_autocurr_neg = sim_jc[:, 2] - self.sim_chi2 = sim_jc[:, 3] - - stat = ((self.autocorr_pos - np.mean(self.sim_autocurr_pos))**2 / np.mean(self.sim_autocurr_pos)**2 + - (self.autocorr_neg - np.mean(self.sim_autocurr_neg))**2 / np.mean(self.sim_autocurr_pos)**2) - self.sim_autocorr_chi2 = 1 - chi2.cdf(stat, 1) - - p_sim_bb = self.__pseudop(self.sim_bb, self.bb) - p_sim_bw = self.__pseudop(self.sim_bw, self.bw) - p_sim_chi2 = self.__pseudop(self.sim_chi2, self.chi2) - p_sim_autocorr_pos = self.__pseudop(self.sim_autocurr_pos, self.autocorr_pos) - p_sim_autocorr_neg = self.__pseudop(self.sim_autocurr_neg, self.autocorr_neg) - self.p_sim_bb = p_sim_bb - self.p_sim_bw = p_sim_bw - self.p_sim_chi2 = p_sim_chi2 - self.p_sim_autocorr_pos = p_sim_autocorr_pos - self.p_sim_autocorr_neg = p_sim_autocorr_neg -======= if results: self.bb = results[0] self.ww = results[1] @@ -254,7 +193,6 @@ def __init__(self, y, w, permutations=PERMUTATIONS): self.p_sim_bb = p_sim_bb self.p_sim_bw = p_sim_bw self.p_sim_chi2 = p_sim_chi2 ->>>>>>> ENH: empirical distribution for chi2 based on random permutations def __calc(self, z): adj_list = self.adj_list diff --git a/esda/tests/test_join_counts.py b/esda/tests/test_join_counts.py index 598992da..29fab113 100644 --- a/esda/tests/test_join_counts.py +++ b/esda/tests/test_join_counts.py @@ -21,8 +21,6 @@ def test_Join_Counts(self): self.assertAlmostEqual(jc.bb, 10.0) self.assertAlmostEqual(jc.bw, 4.0) self.assertAlmostEqual(jc.ww, 10.0) - self.assertAlmostEqual(jc.autocorr_neg, 4.0) # jc.bw - self.assertAlmostEqual(jc.autocorr_pos, 20.0) self.assertAlmostEqual(jc.J, 24.0) self.assertAlmostEqual(len(jc.sim_bb), 999) self.assertAlmostEqual(jc.p_sim_bb, 0.0030000000000000001) From 59dd1e284b6e340d28041854e742bd2e33d4ed1e Mon Sep 17 00:00:00 2001 From: Serge Rey Date: Sat, 3 Aug 2019 14:36:39 -0700 Subject: [PATCH 3/3] ENH: adding tail tests for pos=bb+ww --- Makefile | 14 ++++++++++++++ esda/join_counts.py | 47 +++++++++++++++++++++++++++++++++------------ 2 files changed, 49 insertions(+), 12 deletions(-) create mode 100644 Makefile diff --git a/Makefile b/Makefile new file mode 100644 index 00000000..0172c49e --- /dev/null +++ b/Makefile @@ -0,0 +1,14 @@ +# build the container +container: + docker build -t libpysal . + +# run jupyter notebook for development +nb: + docker run --rm -p 8888:8888 -v ${PWD}:/home/jovyan libpysal + +# run a shell for development +cli: + docker run -it -p 8888:8888 -v ${PWD}:/home/jovyan libpysal /bin/bash + +cov: + pytest --cov-report html --cov=esda diff --git a/esda/join_counts.py b/esda/join_counts.py index 58962ff6..41ca886f 100644 --- a/esda/join_counts.py +++ b/esda/join_counts.py @@ -75,17 +75,20 @@ class Join_Counts(object): minimum of permuted bw values max_bw : float maximum of permuted bw values + pos : float + bb+ww + p_sim_pos : float + p-value based on permutations (one-sided) for pos crosstab : DataFrame Contingency table for observed join counts expected : DataFrame - Expected contingency table for the null + Expected contingency table under the null chi2 : float Observed value of chi2 for join count contingency table (see Notes). p_sim_chi2 : float p-value for chi2 under random spatial permutations - Examples -------- @@ -102,7 +105,7 @@ class Join_Counts(object): >>> jc.bw 4.0 >>> jc.ww - 10. 0 + 10.0 >>> jc.J 24.0 >>> len(jc.sim_bb) @@ -127,15 +130,30 @@ class Join_Counts(object): 7.0 >>> jc.p_sim_chi2 0.008 + >>> jc.pos + 20.0 + >>> jc.p_sim_pos + 0.001 Notes ----- - Analytical inference using the chi2 is approximate and is thus not used in esda. The independence assumption is clearly violated for join counts even if the data is free from spatial autocorrelation as neighboring join counts will be correlated by construction. Thus only, the chi2 attribute is reported, no analytical p-values are reported. + Analytical inference using the chi2 is approximate and is thus not used. + The independence assumption is clearly violated for join counts even + if the data is free from spatial autocorrelation as neighboring join counts + will be correlated by construction. Thus only, the chi2 attribute is + reported, no analytical p-values are reported. - Instead, `p_sim_chi2` is reported which uses the sampling distribution of the chi2 statistic under the null based on random spatial permutations of the data. + Instead, `p_sim_chi2` is reported which uses the sampling distribution of + the chi2 statistic under the null based on random spatial permutations of + the data. - Warnings will be issued when zero values for specific expected values of join counts are encountered in the sample or when carrying out the permutations. In the former case, no inference related attributes are set on the object, while in the latter, realizations with zero expected counts are not used in constructing the sampling distribution for the chi2 statistic. + Warnings will be issued when zero values for specific expected values of + join counts are encountered in the sample or when carrying out the + permutations. In the former case, no inference related attributes are set + on the object, while in the latter, realizations with zero expected counts + are not used in constructing the sampling distribution for the chi2 + statistic. Technical details and derivations can be found in :cite:`cliff81`. """ @@ -153,6 +171,8 @@ def __init__(self, y, w, permutations=PERMUTATIONS): self.bb = results[0] self.ww = results[1] self.bw = results[2] + self.pos = self.bb + self.ww + self.neg = self.bw # bw==wb self.chi2 = results[3] crosstab = pd.DataFrame(data=results[-2]) id_names = ["W", "B"] @@ -179,20 +199,23 @@ def __init__(self, y, w, permutations=PERMUTATIONS): pass sim_jc = np.array(sim) self.sim_bb = sim_jc[:, 0] + self.sim_ww = sim_jc[:, 1] + self.sim_pos = self.sim_bb + self.sim_ww self.min_bb = np.min(self.sim_bb) self.mean_bb = np.mean(self.sim_bb) self.max_bb = np.max(self.sim_bb) self.sim_bw = sim_jc[:, 2] + self.sim_neg = self.sim_bw self.min_bw = np.min(self.sim_bw) self.mean_bw = np.mean(self.sim_bw) self.max_bw = np.max(self.sim_bw) self.sim_chi2 = sim_jc[:, 3] - p_sim_bb = self.__pseudop(self.sim_bb, self.bb) - p_sim_bw = self.__pseudop(self.sim_bw, self.bw) - p_sim_chi2 = self.__pseudop(self.sim_chi2, self.chi2) - self.p_sim_bb = p_sim_bb - self.p_sim_bw = p_sim_bw - self.p_sim_chi2 = p_sim_chi2 + self.p_sim_bb = self.__pseudop(self.sim_bb, self.bb) + self.p_sim_bw = self.__pseudop(self.sim_bw, self.bw) + self.p_sim_ww = self.__pseudop(self.sim_ww, self.ww) + self.p_sim_pos = self.__pseudop(self.sim_pos, self.pos) + self.p_sim_neg = self.__pseudop(self.sim_neg, self.neg) + self.p_sim_chi2 = self.__pseudop(self.sim_chi2, self.chi2) def __calc(self, z): adj_list = self.adj_list