From 1738826b878aacd02fbf433f4112ad61a8d6f638 Mon Sep 17 00:00:00 2001 From: Davide Piras Date: Mon, 24 Jul 2023 15:01:21 +0100 Subject: [PATCH 01/14] Bump version --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index eaa207a..fbedd89 100644 --- a/setup.py +++ b/setup.py @@ -10,7 +10,7 @@ setup( name='gmm_mi', - version="0.8.0", + version="0.9.0", author='Davide Piras', author_email='dr.davide.piras@gmail.com', description='Estimate mutual information distribution with Gaussian mixture models', From 049b59de9ad42c9afe3cf884d53b9064f228457d Mon Sep 17 00:00:00 2001 From: Davide Piras Date: Mon, 24 Jul 2023 15:01:54 +0100 Subject: [PATCH 02/14] Implement MI between high-dim variables --- gmm_mi/gmm.py | 33 +++++++++++++++++ gmm_mi/mi.py | 101 ++++++++++++++++++++++++++++++++------------------ 2 files changed, 98 insertions(+), 36 deletions(-) diff --git a/gmm_mi/gmm.py b/gmm_mi/gmm.py index e839b55..02a4ad0 100644 --- a/gmm_mi/gmm.py +++ b/gmm_mi/gmm.py @@ -382,6 +382,39 @@ def estimate_cMI_MC(self, MC_samples=1e5): MI = np.mean(marginal_zs + joint - marginal_xz - marginal_yz) self.MI = MI return MI + + def estimate_MI_MC_highdim(self, split, MC_samples=1e5): + """Compute the conditional mutual information (cMI) associated with a particular GMM model, + using MC integration. The order of variables matters: we compute MI(X, Y | Z_1, ..., z_n), + where the Zs are the conditional variables. + + Parameters + ---------- + split : int + This integer controls which features belong to the first variable, and which ones belong to the second variable. + MC_samples : integer, default=1e5 + Number of Monte Carlo (MC) samples to perform numerical integration of the MI integral. + + Returns + ------- + MI : float + The value of mutual information. + """ + points, _ = self.sample(MC_samples) + # evaluate the log-likelihood for the joint probability + joint = self.score_samples(points) + # and the marginals (x) and (y) too, but this time they are multidimensional + gmm_x = GMMWithMI(n_components=self.n_components, weights_init=self.weights_, + means_init=self.means_[:, :split], covariances_init=self.covariances_[:, :split, :split]) + marginal_x = gmm_x.score_samples(points[:, :split]) + # and for y + gmm_y = GMMWithMI(n_components=self.n_components, weights_init=self.weights_, + means_init=self.means_[:, split:], covariances_init=self.covariances_[:, split:, split:]) + marginal_y = gmm_y.score_samples(points[:, split:]) + # finally, we put everything together + MI = np.mean(joint - marginal_x - marginal_y) + self.MI = MI + return MI def estimate_KL_MC(self, kl_order='forward', MC_samples=1e5): """Compute the KL-divergence (KL) associated with a particular GMM model, diff --git a/gmm_mi/mi.py b/gmm_mi/mi.py index 1f92a9f..e642426 100644 --- a/gmm_mi/mi.py +++ b/gmm_mi/mi.py @@ -116,22 +116,26 @@ def __getattr__(self, attr): pass def _check_shapes(self, X, Y): - """ Check that the shapes of the arrays given as input to GMM-MI are either 2D or 1D, - and return the correct array to give as input. + """ Check that the shapes of the arrays given as input to GMM-MI are 2D, 1D, + or with the correct conditional structure. Return the correct array to give as input. Parameters ---------- - X : array-like of shape (n_samples, 2), (n_samples, 1), (n_samples) or (n_samples, 2+n_var) + X : array-like of shape (n_samples, n_features), with n_features taking multiple possibilities. Samples from the joint distribution of the two variables whose MI or KL is calculated. - If Y is None, must be of shape (n_samples, 2); otherwise, it must be either (n_samples, 1) or (n_samples). - The (n_samples, 2+n_var) case is for the conditional MI(X, Y | Z_1, ..., z_n), where conditional MI is computed. - Y : array-like of shape (n_samples, 1) or (n_samples), default=None + If Y is None, must be of shape (n_samples, 2) for standard MI, or (n_samples, 2+n_var) + for conditional MI, or (n_samples, features_1 + features_2) for multidimensional variables. + otherwise, it must be either (n_samples, 1) or (n_samples) for the standard case, + or (n_samples, features_1) in the high-dimensional case. + The case (n_samples, 2+n_var) is reserved for the conditional MI(X, Y | Z_1, ..., Z_n); + the variables must be given in this order. + Y : array-like of shape (n_samples, n_features), default=None Samples from the marginal distribution of one of the two variables whose MI or KL is calculated. - If None, X must be of shape (n_samples, 2); otherwise, X and Y must be (n_samples, 1) or (n_samples). - + If None, all features must be already in X; otherwise, Y must be (n_samples, features_2). + Returns ---------- - X : array-like of shape (n_samples, 2) or (n_samples, 2+n_var) + X : array-like of shape (n_samples, n_features) The 2D (or higher-dimensional) array that is used to estimate MI or KL, with the expected shape. """ if len(X.shape) == 1: @@ -139,19 +143,18 @@ def _check_shapes(self, X, Y): if Y is None: if X.shape[1] < 2: raise ValueError(f"Y is None, but the input array X is not 2- (or higher-) dimensional. "\ - f"In this case, both X and Y should be 1-dimensional.") + f"Please input a Y array or increase the dimensionality of X.") else: return X # if Y is not None, we can manipulate it else: if len(Y.shape) == 1: Y = np.reshape(Y, (Y.shape[0], 1)) # add extra dimension - if X.shape[1] == 1 and Y.shape[1] == 1: - X = np.hstack((X, Y)) - return X - else: - raise ValueError(f"Y is not None, but the input arrays X or Y are not 1-dimensional. "\ - f"Shapes found: {X.shape}, {Y.shape}.") + if not self.split: + self.split = X.shape[1] + X = np.hstack((X, Y)) + return X + def _select_best_metric(self, n_components): """Select best metric to choose the number of GMM components. @@ -281,18 +284,21 @@ def _calculate_MI(self, gmm, tol_int=1.49e-8, limit=np.inf): The value of MI, in the units specified by the base provided as input to the `estimate` method. """ if self.integral_method == 'MC': - if self.conditional == False: - MI = gmm.estimate_MI_MC(MC_samples=self.MC_samples) - else: + if self.conditional == True: MI = gmm.estimate_cMI_MC(MC_samples=self.MC_samples) + elif self.split is not None: + MI = gmm.estimate_MI_MC_highdim(split=self.split, MC_samples=self.MC_samples) + else: + MI = gmm.estimate_MI_MC(MC_samples=self.MC_samples) elif self.integral_method == 'quad': - if self.conditional == False: + if self.conditional == False and self.split is None: MI = gmm.estimate_MI_quad(tol_int=tol_int, limit=limit) else: raise NotImplementedError( - "Estimating conditional MI with quadrature methods is currently not implemented. " + "Estimating conditional MI, or MI between multivariate variables, with quadrature methods " + "is currently not implemented. " "Please use `MC` method, or write to dr.davide.piras@gmail.com if you would like " - "this feature added." + "this feature added, or raise an issue here: https://github.com/dpiras/GMM-MI/issues." ) return MI @@ -413,22 +419,28 @@ def _set_units(self, MI_mean, MI_std, base): MI_std /= np.log(base) return MI_mean, MI_std - def fit(self, X, Y=None, verbose=False): + def fit(self, X, Y=None, conditional=False, split=None, verbose=False): """Performs density estimation of the data using GMMs and k-fold cross-validation. The fitted model will be used to estimate MI and/or KL. Parameters ---------- - X : array-like of shape (n_samples, 2), (n_samples, 1), (n_samples) or (n_samples, 3) + X : array-like of shape (n_samples, n_features), with n_features taking multiple possibilities. Samples from the joint distribution of the two variables whose MI or KL is calculated. - If Y is None, must be of shape (n_samples, 2) or (n_samples, 3); - otherwise, it must be either (n_samples, 1) or (n_samples). + If Y is None, must be of shape (n_samples, 2) for standard MI, or (n_samples, 2+n_var) + for conditional MI, or (n_samples, features_1 + features_2) for multidimensional variables. + otherwise, it must be either (n_samples, 1) or (n_samples) for the standard case, + or (n_samples, features_1) in the high-dimensional case. The case (n_samples, 2+n_var) is reserved for the conditional MI(X, Y | Z_1, ..., Z_n); the variables must be given in this order. - Y : array-like of shape (n_samples, 1) or (n_samples), default=None + Y : array-like of shape (n_samples, n_features), default=None Samples from the marginal distribution of one of the two variables whose MI or KL is calculated. - If None, X must be of shape (n_samples, 2) or (n_samples, 2+n_var); - otherwise, X and Y must be (n_samples, 1) or (n_samples). + If None, all features must be already in X; otherwise, Y must be (n_samples, features_2). + conditional : bool, default=False + Whether to compute conditional MI between unidimensional variables given a set of other unidimensional variables. + split : int, default=None + When computing MI between multidimensional variables, this integer controls which features belong to + the first variable, and which ones belong to the second variable. verbose : bool, default=False Whether to print useful procedural statements. @@ -437,6 +449,8 @@ def fit(self, X, Y=None, verbose=False): None """ self.verbose = verbose + self.conditional = conditional + self.split = split # if fit was already done, exit without doing anything if self.fit_done: if self.verbose: @@ -447,11 +461,24 @@ def fit(self, X, Y=None, verbose=False): X = self._check_shapes(X, Y) self.X = X if X.shape[1] >= 3: - self.conditional = True - if self.verbose: - print('Shape of input array is 3-D or higher, so conditional mutual information ' - 'will be computed.') - + if self.conditional: + if self.split: + raise NotImplementedError("Both conditional and a split were indicated, but conditional MI "\ + "between multidimensional variables is not implemented yet. "\ + "Feel free to open an issue here if you need it: "\ + "\https://github.com/dpiras/GMM-MI/issues.") + if self.verbose: + print('Shape of input array is 3-D or higher and conditional=True, so conditional ' + 'mutual information will be computed. Any split will be ignored.') + else: + if self.split: + if self.verbose: + print('Shape of input array is 3-D or higher and a split was indicated, so ' + 'mutual information between multivariate variables will be computed.') + else: + raise ValueError(f"Shape of input array is 3-D or higher, but nor conditional nor a split was indicated. "\ + f"Please indicate one of the two to proceed with the fit, or include a Y array to infer the split value.") + if self.verbose: if not self.fixed_components: print('Starting cross-validation procedure to select the number of GMM components...') @@ -593,11 +620,13 @@ def estimate(self, mi_dist_params=None, base=np.exp(1), include_kl=False, kl_ord self.KL_mean, self.KL_std = self._set_units(self.KL_mean, self.KL_std, base) return MI_mean, MI_std - def fit_estimate(self, X, Y=None, mi_dist_params=None, include_kl=False, kl_order='forward', base=np.exp(1), verbose=False): + def fit_estimate(self, X, Y=None, conditional=False, split=None, + mi_dist_params=None, include_kl=False, kl_order='forward', + base=np.exp(1), verbose=False): """Combine the `fit` and `estimate` methods for easier calculation of MI. See the respective methods for all information. """ - self.fit(X=X, Y=Y, verbose=verbose) + self.fit(X=X, Y=Y, conditional=conditional, split=split, verbose=verbose) MI_mean, MI_std = self.estimate(mi_dist_params=mi_dist_params, include_kl=include_kl, kl_order=kl_order, base=base, verbose=verbose) return MI_mean, MI_std From bcadde35b8aefd33b5941963cba9924153f00535 Mon Sep 17 00:00:00 2001 From: Davide Piras Date: Mon, 24 Jul 2023 16:00:41 +0100 Subject: [PATCH 03/14] Update README --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 0c22602..b74909c 100644 --- a/README.md +++ b/README.md @@ -44,7 +44,7 @@ Once you installed GMM-MI, calculating the distribution of mutual information on mi_estimator = EstimateMI() MI_mean, MI_std = mi_estimator.fit_estimate(X) -This yields (0.21 ± 0.04) nat, well in agreement with the theoretical value of 0.22 nat. There are many things that you can do: for example, you can also pass two 1D arrays instead of a single 2D array, and even calculate the KL divergence between the marginals (as shown in the walkthrough notebook). If you want to visualize the fitted model over your input data, you can run: +This yields (0.21 ± 0.04) nat, well in agreement with the theoretical value of 0.22 nat. There are many things that you can do: for example, you can also pass two 1D arrays instead of a single 2D array, and even calculate the KL divergence between the marginals. With the same syntax, you can now also compute MI between multivariate variables, as we show in the walkthrough notebook. If you want to visualize the fitted model over your input data, you can run: import matplotlib.pyplot as plt fig, ax = plt.subplots(1, 1, figsize=(10, 10)) From 52be4a4dd55590c67f72332eda2284803cc255db Mon Sep 17 00:00:00 2001 From: Davide Piras Date: Mon, 24 Jul 2023 16:01:15 +0100 Subject: [PATCH 04/14] Re-run walkthrough notebook --- notebooks/walkthrough_and_pitfalls.ipynb | 244 ++++++++++++++++++++--- 1 file changed, 218 insertions(+), 26 deletions(-) diff --git a/notebooks/walkthrough_and_pitfalls.ipynb b/notebooks/walkthrough_and_pitfalls.ipynb index 4b4e1e7..ff36c70 100644 --- a/notebooks/walkthrough_and_pitfalls.ipynb +++ b/notebooks/walkthrough_and_pitfalls.ipynb @@ -146,7 +146,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:01<00:00, 25.66it/s]" + "100%|██████████| 50/50 [00:01<00:00, 25.29it/s]" ] }, { @@ -221,7 +221,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:02<00:00, 17.40it/s]" + "100%|██████████| 50/50 [00:03<00:00, 16.08it/s]" ] }, { @@ -333,7 +333,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:09<00:00, 5.10it/s]" + "100%|██████████| 50/50 [00:10<00:00, 4.75it/s]" ] }, { @@ -400,7 +400,7 @@ "id": "c6f3a2ae", "metadata": {}, "source": [ - "We can also plot the contours of the two distributions, using the original samples and samples from the fitted GMM. This becomes particularly useful when computing the conditional MI (see below), namely when we have a higher-dimensional distribution being fitted, as it becomes harder to visualise the individual GMM components in higher dimensions." + "We can also plot the contours of the two distributions, using the original samples and samples from the fitted GMM. This becomes particularly useful when computing MI between multivariate variables or conditional MI (see below), namely when we have a higher-dimensional distribution being fitted, as it becomes harder to visualise the individual GMM components in higher dimensions." ] }, { @@ -462,7 +462,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:13<00:00, 3.79it/s]" + "100%|██████████| 50/50 [00:14<00:00, 3.52it/s]" ] }, { @@ -561,7 +561,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:06<00:00, 7.63it/s]" + "100%|██████████| 50/50 [00:07<00:00, 7.01it/s]" ] }, { @@ -655,7 +655,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:27<00:00, 1.85it/s]" + "100%|██████████| 50/50 [00:29<00:00, 1.71it/s]" ] }, { @@ -763,7 +763,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/dpiras/.conda/envs/MI/lib/python3.9/site-packages/gmm_mi/mi.py:499: ConvergenceWarning: All CV GMM fits converged only after their second iteration for all components; this is usually suspicious, and might be a symptom of a bad fit. Plot the loss curves as described in the walkthrough, and try reducing threshold_fit, or with a different init_type.\n", + "/home/dpiras/.conda/envs/MI/lib/python3.9/site-packages/gmm_mi/mi.py:526: ConvergenceWarning: All CV GMM fits converged only after their second iteration for all components; this is usually suspicious, and might be a symptom of a bad fit. Plot the loss curves as described in the walkthrough, and try reducing threshold_fit, or with a different init_type.\n", " warnings.warn(\n" ] }, @@ -780,7 +780,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:11<00:00, 4.37it/s]" + "100%|██████████| 50/50 [00:12<00:00, 4.05it/s]" ] }, { @@ -901,7 +901,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:22<00:00, 2.21it/s]" + "100%|██████████| 50/50 [00:23<00:00, 2.11it/s]" ] }, { @@ -1014,7 +1014,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:13<00:00, 3.70it/s]" + "100%|██████████| 50/50 [00:13<00:00, 3.68it/s]" ] }, { @@ -1139,7 +1139,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1/1 [00:00<00:00, 5.81it/s]" + "100%|██████████| 1/1 [00:00<00:00, 5.54it/s]" ] }, { @@ -1221,7 +1221,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1/1 [00:00<00:00, 5.44it/s]" + "100%|██████████| 1/1 [00:00<00:00, 5.21it/s]" ] }, { @@ -1304,7 +1304,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1/1 [00:00<00:00, 5.95it/s]" + "100%|██████████| 1/1 [00:00<00:00, 5.62it/s]" ] }, { @@ -1410,7 +1410,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:01<00:00, 31.68it/s]\n" + "100%|██████████| 50/50 [00:01<00:00, 30.51it/s]\n" ] }, { @@ -1480,7 +1480,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/dpiras/.conda/envs/MI/lib/python3.9/site-packages/gmm_mi/mi.py:513: ConvergenceWarning: Convergence in the number of GMM components was not reached. Try increasing max_components or threshold_components, or decreasing the patience.\n", + "/home/dpiras/.conda/envs/MI/lib/python3.9/site-packages/gmm_mi/mi.py:540: ConvergenceWarning: Convergence in the number of GMM components was not reached. Try increasing max_components or threshold_components, or decreasing the patience.\n", " warnings.warn(f\"Convergence in the number of GMM components was not reached. \"\\\n" ] }, @@ -1495,7 +1495,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:15<00:00, 3.30it/s]\n" + "100%|██████████| 50/50 [00:15<00:00, 3.13it/s]\n" ] }, { @@ -1589,7 +1589,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:33<00:00, 1.48it/s]\n" + "100%|██████████| 50/50 [00:35<00:00, 1.42it/s]\n" ] }, { @@ -1638,6 +1638,197 @@ "The estimate is now less than 3 standard deviations away from 0!" ] }, + { + "cell_type": "markdown", + "id": "e2fdca9f", + "metadata": {}, + "source": [ + "# Mutual information between high-dimensional variables" + ] + }, + { + "cell_type": "markdown", + "id": "08b6cf19", + "metadata": {}, + "source": [ + "With GMM-MI, you can now also calculate the MI between high-dimensional variables. In this case, just pass `X` and `Y` as the two arrays with the features, with shape respectively `(n_samples, n_features_1)` and `(n_samples, n_features_2)`; alternatively, pass a single array `X` with `(n_samples, n_features)` and a single `split` integer indicating at which point the two sets of features should be separated. An example is as below, where we compute the MI between two sets of 2D Gaussian variables." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "54fd200a", + "metadata": {}, + "outputs": [], + "source": [ + "# create mock tetra-variate Gaussian data, which we will then split in 2\n", + "N=int(1e4)\n", + "mean, cov = np.array([0, 0, 0, 0]), np.array([[1, 0.6, 0.3, -0.2], \n", + " [0.6, 1, 0.4, -0.2], \n", + " [0.3, 0.4, 1, 0.5], \n", + " [-0.2, -0.2, 0.5, 1]])\n", + "rng = np.random.default_rng(1)\n", + "X = rng.multivariate_normal(mean, cov, N) # has shape (N, 4)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "1a70400d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Analytic MI between 2D variables: 0.258 nat\n" + ] + } + ], + "source": [ + "# the analytic MI is computed by simply considering the sub-covariance matrices\n", + "det1 = np.linalg.det(cov[:2, :2])\n", + "det2 = np.linalg.det(cov[2:, 2:])\n", + "det = np.linalg.det(cov)\n", + "\n", + "analytic_MI = 0.5*np.log(det1*det2 / det)\n", + "print(f'Analytic MI between 2D variables: {analytic_MI:.3f} nat')" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "e9050baa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Shape of input array is 3-D or higher and a split was indicated, so mutual information between multivariate variables will be computed.\n", + "Starting cross-validation procedure to select the number of GMM components...\n", + "Current number of GMM components: 1. Current metric: -5.027. Adding one component...\n", + "Metric change is less than threshold; patience counter increased by 1...\n", + "Reached patience limit, stop adding components.\n", + "Convergence reached at 1 GMM components.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 50/50 [00:02<00:00, 19.02it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MI estimation completed, returning mean and standard deviation.\n", + "Estimated MI: 0.257 \\pm 0.007 nat\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# comparison with GMM-MI, in 2 ways\n", + "mi_estimator = EstimateMI()\n", + "# X is your data, which here has shape (n_samples, 4).\n", + "# We specify split=2 to indicate that the first variable is made of two features \n", + "mi_estimator.fit(X, split=2, verbose=True)\n", + "MI_mean, MI_std = mi_estimator.estimate(verbose=True)\n", + "print(f'Estimated MI: {MI_mean:.3f} \\pm {MI_std:.3f} nat')" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "b935fdc7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Shape of input array is 3-D or higher and a split was indicated, so mutual information between multivariate variables will be computed.\n", + "Starting cross-validation procedure to select the number of GMM components...\n", + "Current number of GMM components: 1. Current metric: -5.027. Adding one component...\n", + "Metric change is less than threshold; patience counter increased by 1...\n", + "Reached patience limit, stop adding components.\n", + "Convergence reached at 1 GMM components.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 50/50 [00:02<00:00, 19.07it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MI estimation completed, returning mean and standard deviation.\n", + "Estimated MI: 0.257 \\pm 0.007 nat\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# same as above, just with a different syntaxmi_estimator = EstimateMI()\n", + "# You can also pass two 2D arrays as X and Y, equivalently\n", + "mi_estimator = EstimateMI()\n", + "mi_estimator.fit(X=X[:, :2], Y=X[:, 2:], verbose=True)\n", + "MI_mean, MI_std = mi_estimator.estimate(verbose=True)\n", + "print(f'Estimated MI: {MI_mean:.3f} \\pm {MI_std:.3f} nat')" + ] + }, + { + "cell_type": "markdown", + "id": "571e092d", + "metadata": {}, + "source": [ + "There is great agreement with the ground truth! We can also check how good the GMM fit by plotting the following contours." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "3c726e0b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = mi_estimator.plot_fitted_contours(parameters=['X1', 'X2', 'X3', 'X4'], \n", + " shade_alpha=0.4, linewidths=2, \n", + " kde=True, # smooths contours, set this to False to accelerate plotting\n", + " )\n", + "fig.set_size_inches(7, 7)" + ] + }, { "cell_type": "markdown", "id": "646fd424", @@ -1651,7 +1842,7 @@ "id": "1d833e65", "metadata": {}, "source": [ - "With GMM-MI, you can also compute the conditional mutual information between continuous variables, defined for three variables as:\n", + "With GMM-MI, you can also compute the conditional mutual information between unidimensional continuous variables, defined for three variables as:\n", "\n", "$$I(X; Y \\mid Z) = \\int_{z \\in Z} \\int_{x \\in X} \\int_{y \\in Y} p(x,y,z) \\log \\frac{p(z) p(x,y, z)}{p(x, z)p(y, z)} \\ dx \\ dy \\ dz$$\n", "\n", @@ -1666,7 +1857,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 38, "id": "cef6ab69", "metadata": {}, "outputs": [ @@ -1674,7 +1865,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Shape of input array is 3-D or higher, so conditional mutual information will be computed.\n", + "Shape of input array is 3-D or higher and conditional=True, so conditional mutual information will be computed. Any split will be ignored.\n", "Starting cross-validation procedure to select the number of GMM components...\n", "Current number of GMM components: 1. Current metric: -3.937. Adding one component...\n", "Metric change is less than threshold; patience counter increased by 1...\n", @@ -1686,7 +1877,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:02<00:00, 21.00it/s]" + "100%|██████████| 50/50 [00:02<00:00, 18.47it/s]" ] }, { @@ -1713,7 +1904,8 @@ "X = rng.multivariate_normal(mean, cov, N) # has shape (N, 3)\n", "mi_estimator = EstimateMI()\n", "\n", - "MI_mean, MI_std = mi_estimator.fit_estimate(X, verbose=True)\n", + "# to estimate the conditional MI, just add `condition=True`\n", + "MI_mean, MI_std = mi_estimator.fit_estimate(X, verbose=True, conditional=True)\n", "print(f'Estimated conditional MI: {MI_mean:.3f} \\pm {MI_std:.3f} nat')" ] }, @@ -1727,7 +1919,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 39, "id": "e69b8931", "metadata": {}, "outputs": [], @@ -1744,7 +1936,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 40, "id": "d2caead6", "metadata": {}, "outputs": [ @@ -1781,7 +1973,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 41, "id": "6dcef47d", "metadata": {}, "outputs": [ From adef60291eb70ab5fd8898647ce44acae33ba322 Mon Sep 17 00:00:00 2001 From: Davide Piras Date: Tue, 15 Aug 2023 13:58:59 +0100 Subject: [PATCH 05/14] Include cov regulariser in initialisation --- gmm_mi/cross_validation.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/gmm_mi/cross_validation.py b/gmm_mi/cross_validation.py index a1dc8db..d1eb0e5 100644 --- a/gmm_mi/cross_validation.py +++ b/gmm_mi/cross_validation.py @@ -71,7 +71,8 @@ def _run_cross_validation(self, X): w_init, m_init, c_init, p_init = initialize_parameters(X, random_state=random_state, n_components=self.n_components, init_type=self.init_type, - scale=self.scale) + scale=self.scale, + reg_covar=self.reg_covar) # perform k-fold CV for k_id, (train_indices, valid_indices) in enumerate(self.kf.split(X)): X_training = X[train_indices] From cf7ed1064dfa86f89d4a5cf84553a508349a3687 Mon Sep 17 00:00:00 2001 From: Davide Piras Date: Tue, 15 Aug 2023 13:59:25 +0100 Subject: [PATCH 06/14] We now also use cov reg for initialisation; seems needed in high dimension --- gmm_mi/initializations.py | 1 - 1 file changed, 1 deletion(-) diff --git a/gmm_mi/initializations.py b/gmm_mi/initializations.py index c161b20..3bdd699 100644 --- a/gmm_mi/initializations.py +++ b/gmm_mi/initializations.py @@ -206,7 +206,6 @@ def initialize_parameters(X, random_state=None, n_components=1, init_type='rando If scale is not given, it will be set such that the volume of all components completely fills the space covered by data. reg_covar : float, default=0 Constant regularisation term added to the diagonal of each covariance matrix, to avoid singular matrices. - In GMM-MI, the regularisation term is added during training only, and not in the initializations. Returns ---------- From 10eb790532fbf1c5c0065d9de4cbbb38453daa5a Mon Sep 17 00:00:00 2001 From: Davide Piras Date: Tue, 15 Aug 2023 22:47:32 +0100 Subject: [PATCH 07/14] Fix bug for wrong management of patience --- gmm_mi/mi.py | 1 + 1 file changed, 1 insertion(+) diff --git a/gmm_mi/mi.py b/gmm_mi/mi.py index e642426..45c40b1 100644 --- a/gmm_mi/mi.py +++ b/gmm_mi/mi.py @@ -251,6 +251,7 @@ def _check_convergence(self, n_components): Number of GMM components being fitted. """ if self.metric - self.best_metric > self.threshold_components: + self.patience_counter = 0 # reset patience counter self.best_metric = self.metric if self.verbose: print(f'Current number of GMM components: {n_components}. Current metric: {self.best_metric:.3f}. Adding one component...') From 4195e6c831e35a31c92ed298979ebe3ae38e177c Mon Sep 17 00:00:00 2001 From: Davide Piras Date: Thu, 31 Aug 2023 10:47:14 +0100 Subject: [PATCH 08/14] Fix reg covar back to how it was --- gmm_mi/mi.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/gmm_mi/mi.py b/gmm_mi/mi.py index 45c40b1..48ae214 100644 --- a/gmm_mi/mi.py +++ b/gmm_mi/mi.py @@ -380,9 +380,9 @@ def _perform_bootstrap(self, n_components, random_state, w_init, m_init, p_init, X_bs = rng.choice(self.X, self.X.shape[0]) else: X_bs = self.X - gmm = single_fit(X=X_bs, n_components=n_components, reg_covar=self.reg_covar, - threshold_fit=self.threshold_fit, max_iter=self.max_iter, - random_state=random_state, w_init=w_init, m_init=m_init, p_init=p_init) + gmm = single_fit(X=X_bs, n_components=n_components, reg_covar=self.reg_covar, + threshold_fit=self.threshold_fit, max_iter=self.max_iter, + random_state=random_state, w_init=w_init, m_init=m_init, p_init=p_init) current_MI_estimate = self._calculate_MI(gmm) MI_estimates[n_b] = current_MI_estimate if include_kl: @@ -714,7 +714,7 @@ def plot_fitted_contours(self, parameters=None, extents=None, n_samples=None, ** def _calculate_MI_categorical(self): """Calculate mutual information (MI) integral given a Gaussian mixture model in 2D. Use only Monte Carlo (MC) method. - The complete formula can be found in Appendix B of Piras et al. (2022). + The complete formula can be found in Appendix B of Piras et al. (2023). Returns ------- From 2685a9d20471b0b0a14ef9dd46fba14506f3d19a Mon Sep 17 00:00:00 2001 From: Davide Piras Date: Thu, 31 Aug 2023 10:50:09 +0100 Subject: [PATCH 09/14] Add warning --- gmm_mi/mi.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/gmm_mi/mi.py b/gmm_mi/mi.py index 48ae214..18e0797 100644 --- a/gmm_mi/mi.py +++ b/gmm_mi/mi.py @@ -470,12 +470,16 @@ def fit(self, X, Y=None, conditional=False, split=None, verbose=False): "\https://github.com/dpiras/GMM-MI/issues.") if self.verbose: print('Shape of input array is 3-D or higher and conditional=True, so conditional ' - 'mutual information will be computed. Any split will be ignored.') + 'mutual information will be computed. Any split will be ignored.' + 'Warning: this feature is experimental and has not been thoroughly tested; ' + 'make sure the data distribution is captured properly.') else: if self.split: if self.verbose: print('Shape of input array is 3-D or higher and a split was indicated, so ' - 'mutual information between multivariate variables will be computed.') + 'mutual information between multivariate variables will be computed.' + 'Warning: this feature is experimental and has not been thoroughly tested; ' + 'make sure the data distribution is captured properly.') else: raise ValueError(f"Shape of input array is 3-D or higher, but nor conditional nor a split was indicated. "\ f"Please indicate one of the two to proceed with the fit, or include a Y array to infer the split value.") From 19a6fa51676360f680a9ec872ee1466bd3c64c1a Mon Sep 17 00:00:00 2001 From: Davide Piras Date: Thu, 31 Aug 2023 11:49:16 +0100 Subject: [PATCH 10/14] Add space in warning --- gmm_mi/mi.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/gmm_mi/mi.py b/gmm_mi/mi.py index 18e0797..6cec481 100644 --- a/gmm_mi/mi.py +++ b/gmm_mi/mi.py @@ -380,9 +380,9 @@ def _perform_bootstrap(self, n_components, random_state, w_init, m_init, p_init, X_bs = rng.choice(self.X, self.X.shape[0]) else: X_bs = self.X - gmm = single_fit(X=X_bs, n_components=n_components, reg_covar=self.reg_covar, - threshold_fit=self.threshold_fit, max_iter=self.max_iter, - random_state=random_state, w_init=w_init, m_init=m_init, p_init=p_init) + gmm = single_fit(X=X_bs, n_components=n_components, reg_covar=self.reg_covar, + threshold_fit=self.threshold_fit, max_iter=self.max_iter, + random_state=random_state, w_init=w_init, m_init=m_init, p_init=p_init) current_MI_estimate = self._calculate_MI(gmm) MI_estimates[n_b] = current_MI_estimate if include_kl: @@ -470,14 +470,14 @@ def fit(self, X, Y=None, conditional=False, split=None, verbose=False): "\https://github.com/dpiras/GMM-MI/issues.") if self.verbose: print('Shape of input array is 3-D or higher and conditional=True, so conditional ' - 'mutual information will be computed. Any split will be ignored.' + 'mutual information will be computed. Any split will be ignored. ' 'Warning: this feature is experimental and has not been thoroughly tested; ' 'make sure the data distribution is captured properly.') else: if self.split: if self.verbose: print('Shape of input array is 3-D or higher and a split was indicated, so ' - 'mutual information between multivariate variables will be computed.' + 'mutual information between multivariate variables will be computed. ' 'Warning: this feature is experimental and has not been thoroughly tested; ' 'make sure the data distribution is captured properly.') else: From 27fa5f5e4f193634e514d3a19ff8c2af991e51fa Mon Sep 17 00:00:00 2001 From: Davide Piras Date: Thu, 31 Aug 2023 15:06:23 +0100 Subject: [PATCH 11/14] Re-run walkthrough notebook --- notebooks/walkthrough_and_pitfalls.ipynb | 54 ++++++++++++------------ 1 file changed, 27 insertions(+), 27 deletions(-) diff --git a/notebooks/walkthrough_and_pitfalls.ipynb b/notebooks/walkthrough_and_pitfalls.ipynb index ff36c70..cd60df5 100644 --- a/notebooks/walkthrough_and_pitfalls.ipynb +++ b/notebooks/walkthrough_and_pitfalls.ipynb @@ -146,7 +146,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:01<00:00, 25.29it/s]" + "100%|██████████| 50/50 [00:01<00:00, 34.91it/s]" ] }, { @@ -221,7 +221,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:03<00:00, 16.08it/s]" + "100%|██████████| 50/50 [00:04<00:00, 11.05it/s]" ] }, { @@ -333,7 +333,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:10<00:00, 4.75it/s]" + "100%|██████████| 50/50 [00:07<00:00, 6.67it/s]" ] }, { @@ -411,7 +411,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -462,7 +462,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:14<00:00, 3.52it/s]" + "100%|██████████| 50/50 [00:10<00:00, 4.69it/s]" ] }, { @@ -561,7 +561,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:07<00:00, 7.01it/s]" + "100%|██████████| 50/50 [00:04<00:00, 10.01it/s]" ] }, { @@ -655,7 +655,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:29<00:00, 1.71it/s]" + "100%|██████████| 50/50 [00:16<00:00, 3.00it/s]" ] }, { @@ -763,7 +763,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/dpiras/.conda/envs/MI/lib/python3.9/site-packages/gmm_mi/mi.py:526: ConvergenceWarning: All CV GMM fits converged only after their second iteration for all components; this is usually suspicious, and might be a symptom of a bad fit. Plot the loss curves as described in the walkthrough, and try reducing threshold_fit, or with a different init_type.\n", + "/home/dpiras/.conda/envs/MI/lib/python3.9/site-packages/gmm_mi/mi.py:531: ConvergenceWarning: All CV GMM fits converged only after their second iteration for all components; this is usually suspicious, and might be a symptom of a bad fit. Plot the loss curves as described in the walkthrough, and try reducing threshold_fit, or with a different init_type.\n", " warnings.warn(\n" ] }, @@ -780,7 +780,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:12<00:00, 4.05it/s]" + "100%|██████████| 50/50 [00:08<00:00, 5.69it/s]" ] }, { @@ -901,7 +901,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:23<00:00, 2.11it/s]" + "100%|██████████| 50/50 [00:15<00:00, 3.27it/s]" ] }, { @@ -1014,7 +1014,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:13<00:00, 3.68it/s]" + "100%|██████████| 50/50 [00:08<00:00, 5.57it/s]" ] }, { @@ -1139,7 +1139,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1/1 [00:00<00:00, 5.54it/s]" + "100%|██████████| 1/1 [00:00<00:00, 8.30it/s]" ] }, { @@ -1221,7 +1221,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1/1 [00:00<00:00, 5.21it/s]" + "100%|██████████| 1/1 [00:00<00:00, 8.24it/s]" ] }, { @@ -1304,7 +1304,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 1/1 [00:00<00:00, 5.62it/s]" + "100%|██████████| 1/1 [00:00<00:00, 8.62it/s]" ] }, { @@ -1410,7 +1410,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:01<00:00, 30.51it/s]\n" + "100%|██████████| 50/50 [00:01<00:00, 47.69it/s]\n" ] }, { @@ -1480,7 +1480,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/dpiras/.conda/envs/MI/lib/python3.9/site-packages/gmm_mi/mi.py:540: ConvergenceWarning: Convergence in the number of GMM components was not reached. Try increasing max_components or threshold_components, or decreasing the patience.\n", + "/home/dpiras/.conda/envs/MI/lib/python3.9/site-packages/gmm_mi/mi.py:545: ConvergenceWarning: Convergence in the number of GMM components was not reached. Try increasing max_components or threshold_components, or decreasing the patience.\n", " warnings.warn(f\"Convergence in the number of GMM components was not reached. \"\\\n" ] }, @@ -1495,7 +1495,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:15<00:00, 3.13it/s]\n" + "100%|██████████| 50/50 [00:10<00:00, 4.84it/s]\n" ] }, { @@ -1589,7 +1589,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:35<00:00, 1.42it/s]\n" + "100%|██████████| 50/50 [00:20<00:00, 2.48it/s]\n" ] }, { @@ -1705,7 +1705,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Shape of input array is 3-D or higher and a split was indicated, so mutual information between multivariate variables will be computed.\n", + "Shape of input array is 3-D or higher and a split was indicated, so mutual information between multivariate variables will be computed. Warning: this feature is experimental and has not been thoroughly tested; make sure the data distribution is captured properly.\n", "Starting cross-validation procedure to select the number of GMM components...\n", "Current number of GMM components: 1. Current metric: -5.027. Adding one component...\n", "Metric change is less than threshold; patience counter increased by 1...\n", @@ -1717,7 +1717,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:02<00:00, 19.02it/s]" + "100%|██████████| 50/50 [00:03<00:00, 12.87it/s]" ] }, { @@ -1756,7 +1756,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Shape of input array is 3-D or higher and a split was indicated, so mutual information between multivariate variables will be computed.\n", + "Shape of input array is 3-D or higher and a split was indicated, so mutual information between multivariate variables will be computed. Warning: this feature is experimental and has not been thoroughly tested; make sure the data distribution is captured properly.\n", "Starting cross-validation procedure to select the number of GMM components...\n", "Current number of GMM components: 1. Current metric: -5.027. Adding one component...\n", "Metric change is less than threshold; patience counter increased by 1...\n", @@ -1768,7 +1768,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:02<00:00, 19.07it/s]" + "100%|██████████| 50/50 [00:01<00:00, 25.71it/s]" ] }, { @@ -1788,7 +1788,7 @@ } ], "source": [ - "# same as above, just with a different syntaxmi_estimator = EstimateMI()\n", + "# same as above, just with a different syntax\n", "# You can also pass two 2D arrays as X and Y, equivalently\n", "mi_estimator = EstimateMI()\n", "mi_estimator.fit(X=X[:, :2], Y=X[:, 2:], verbose=True)\n", @@ -1812,7 +1812,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1865,7 +1865,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Shape of input array is 3-D or higher and conditional=True, so conditional mutual information will be computed. Any split will be ignored.\n", + "Shape of input array is 3-D or higher and conditional=True, so conditional mutual information will be computed. Any split will be ignored. Warning: this feature is experimental and has not been thoroughly tested; make sure the data distribution is captured properly.\n", "Starting cross-validation procedure to select the number of GMM components...\n", "Current number of GMM components: 1. Current metric: -3.937. Adding one component...\n", "Metric change is less than threshold; patience counter increased by 1...\n", @@ -1877,7 +1877,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 50/50 [00:02<00:00, 18.47it/s]" + "100%|██████████| 50/50 [00:01<00:00, 28.59it/s]" ] }, { @@ -1979,7 +1979,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] From 9812cbc7e08b04e7bd9d2b4a0879f57f19c418b6 Mon Sep 17 00:00:00 2001 From: Davide Piras Date: Thu, 31 Aug 2023 15:09:14 +0100 Subject: [PATCH 12/14] Update docstring --- gmm_mi/gmm.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/gmm_mi/gmm.py b/gmm_mi/gmm.py index 02a4ad0..aca4a80 100644 --- a/gmm_mi/gmm.py +++ b/gmm_mi/gmm.py @@ -384,9 +384,8 @@ def estimate_cMI_MC(self, MC_samples=1e5): return MI def estimate_MI_MC_highdim(self, split, MC_samples=1e5): - """Compute the conditional mutual information (cMI) associated with a particular GMM model, - using MC integration. The order of variables matters: we compute MI(X, Y | Z_1, ..., z_n), - where the Zs are the conditional variables. + """Compute the mutual information among multidimensional variables associated with a particular GMM model, + using MC integration. Parameters ---------- From 3a9060066519e6c15708089fcf7df2e27f01793c Mon Sep 17 00:00:00 2001 From: Davide Piras Date: Tue, 5 Sep 2023 09:31:44 +0100 Subject: [PATCH 13/14] Make class pickable --- gmm_mi/mi.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/gmm_mi/mi.py b/gmm_mi/mi.py index 6cec481..48c91b9 100644 --- a/gmm_mi/mi.py +++ b/gmm_mi/mi.py @@ -115,6 +115,10 @@ def __getattr__(self, attr): except: pass + # this is only to make the class pickable, to save/load MI estimator + def __getstate__(self): return self.__dict__ + def __setstate__(self, d): self.__dict__.update(d) + def _check_shapes(self, X, Y): """ Check that the shapes of the arrays given as input to GMM-MI are 2D, 1D, or with the correct conditional structure. Return the correct array to give as input. From 2e7a605e1f0c343d6e05d6c8c59e6a6b27948340 Mon Sep 17 00:00:00 2001 From: Davide Piras Date: Wed, 20 Sep 2023 15:28:11 +0100 Subject: [PATCH 14/14] Add check that number of samples is the same --- gmm_mi/mi.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/gmm_mi/mi.py b/gmm_mi/mi.py index 48c91b9..0ed3449 100644 --- a/gmm_mi/mi.py +++ b/gmm_mi/mi.py @@ -114,7 +114,7 @@ def __getattr__(self, attr): return getattr(self.mi_dist_params, attr) except: pass - + # this is only to make the class pickable, to save/load MI estimator def __getstate__(self): return self.__dict__ def __setstate__(self, d): self.__dict__.update(d) @@ -152,6 +152,8 @@ def _check_shapes(self, X, Y): return X # if Y is not None, we can manipulate it else: + if X.shape[0] != Y.shape[0]: + raise ValueError(f"X and Y have different numbers of samples. Found {X.shape[0]} and {Y.shape[0]}.") if len(Y.shape) == 1: Y = np.reshape(Y, (Y.shape[0], 1)) # add extra dimension if not self.split: