diff --git a/demos/mixed_distributions_blog_analysis.ipynb b/demos/mixed_distributions_blog_analysis.ipynb new file mode 100644 index 000000000..c3a33e35c --- /dev/null +++ b/demos/mixed_distributions_blog_analysis.ipynb @@ -0,0 +1,1214 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "blog-analysis-00", + "metadata": {}, + "source": [ + "# Mixed Distributions Blog Analysis\n", + "\n", + "This notebook accompanies the mixed-distributions blog article. It supplements [the public mixed-distributions demo](mixed_distributions.ipynb) with equal-cost comparisons between hierarchical mixture sampling and probability-weighted component integration, including numerical results and figures.\n", + "\n", + "**Hierarchical Mixture** first selects a component according to its probability and then applies that component's transform. We use the current repository's `Mixture`: its first uniform coordinate is the selector $V$, the remaining coordinates are $U$, and the driver dimension is $d+1$ for $d$-dimensional observations. **Probability-Weighted Component Integration** instead estimates each component expectation and combines the estimates using the mixture probabilities.\n", + "\n", + "For two components,\n", + "\n", + "$$\n", + "\\widehat I_{\\rm hier}=\\frac1N\\sum_{i=1}^N f(T_{C(V_i)}(U_i)),\n", + "\\qquad\n", + "\\widehat I_{\\rm comp}=p\\widehat I_1+(1-p)\\widehat I_2.\n", + "$$\n", + "\n", + "Both methods have **$N$ total evaluations of the chosen function**: Hierarchical Mixture uses $N$ samples; component integration uses $N/2$ samples per component. For example, $N=1024$ means 1024 versus $512+512$ evaluations. The half-budget allocation does **not** change the mixture weights to $1/2,1/2$, and is not claimed to be an optimal allocation." + ] + }, + { + "cell_type": "markdown", + "id": "blog-analysis-01", + "metadata": {}, + "source": [ + "## 1. Imports and Reproducibility\n", + "\n", + "Run from this repository or its `demos` directory with the Quasi-Monte Carlo Python (QMCPy) development environment. No downloads or external data are required. All convergence calculations use randomized quasi-Monte Carlo (QMC) sampling via `DigitalNetB2`, with 32 independent randomizations using linear matrix scrambling (LMS) and digital shift (DS), total budgets $2^6,\\ldots,2^{15}$, and slopes fitted to the largest five budgets.\n", + "\n", + "A full run takes about four minutes and writes four Portable Network Graphics (PNG) files to `demos/mixed_distributions_blog_outputs/`. The matching booktest executes every cell with smaller budgets and two mixture cases in memory, writing figures to a temporary directory; it does not replace the full-run results saved here. In Google Colaboratory (Colab), run the dependency cell first to install QMCPy from `develop`.\n", + "\n", + "\n", + "\n", + "The means, covariances, parameter seeds, and hierarchical QMC seeds below reproduce the merged demo's choices. There is an intentional implementation difference: the demo's exploratory convergence code puts $V$ last and uses the originally generated dense factor $A$. Here the actual `Mixture` application programming interface (API) puts $V$ first, and both methods use `Gaussian`'s default principal component analysis (PCA) square root of the **same covariance** $AA^\\mathsf{T}$. Thus the distributions and exact expectations agree, but the transformed QMC integrands and finite-budget errors need not reproduce the exploratory values. New fixed component-integration seeds are recorded explicitly." + ] + }, + { + "cell_type": "markdown", + "id": "edacf780", + "metadata": {}, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/QMCSoftware/QMCSoftware/blob/develop/demos/mixed_distributions_blog_analysis.ipynb)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8dfdb826", + "metadata": {}, + "outputs": [], + "source": [ + "# @title Execute this cell to install dependencies\n", + "try:\n", + " import google.colab\n", + " IN_COLAB = True\n", + "except ImportError:\n", + " IN_COLAB = False\n", + "if IN_COLAB:\n", + " import sys\n", + " import os\n", + " repo_root = \"/content/QMCSoftware\"\n", + " notebook_dir = f\"{repo_root}/demos\"\n", + " if not os.path.isdir(repo_root):\n", + " !git clone -q --depth 1 --branch develop https://github.com/QMCSoftware/QMCSoftware {repo_root}\n", + " !pip install -q -e {repo_root}\n", + " os.chdir(notebook_dir)\n", + " if notebook_dir not in sys.path:\n", + " sys.path.insert(0, notebook_dir)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "blog-analysis-02", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "QMCPy checkout: C:\\Users\\Owner\\.codex\\visualizations\\2026\\08\\29\\01a04e5d-e21b-7ef1-bda1-771ee826f954\\mixed-distribution-worktree\\qmcpy\\__init__.py\n", + "NumPy: 2.3.2 SciPy: 1.16.1\n", + "Total budgets: [ 64 128 256 512 1024 2048 4096 8192 16384 32768]\n", + "Randomizations: 32 | slope-fit budgets: [ 2048 4096 8192 16384 32768]\n" + ] + } + ], + "source": [ + "from pathlib import Path\n", + "from time import perf_counter\n", + "import sys\n", + "\n", + "repo_root = Path.cwd().resolve()\n", + "if not (repo_root / \"qmcpy\").is_dir():\n", + " repo_root = repo_root.parent\n", + "if not (repo_root / \"qmcpy\").is_dir():\n", + " raise RuntimeError(\"Run this notebook from the repository or its demos directory.\")\n", + "sys.path.insert(0, str(repo_root))\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import scipy\n", + "from IPython.display import display\n", + "from scipy.stats import norm\n", + "\n", + "import qmcpy\n", + "from qmcpy import DigitalNetB2, Gaussian, Mixture\n", + "\n", + "assert Path(qmcpy.__file__).resolve() == repo_root / \"qmcpy\" / \"__init__.py\"\n", + "plt.style.use(\"seaborn-v0_8-whitegrid\")\n", + "pd.set_option(\"display.precision\", 8)\n", + "output_dir = repo_root / \"demos\" / \"mixed_distributions_blog_outputs\"\n", + "output_dir.mkdir(exist_ok=True)\n", + "\n", + "sample_sizes = 2 ** np.arange(6, 16)\n", + "replications = 32\n", + "n_max = int(sample_sizes[-1])\n", + "fit = slice(-5, None)\n", + "method_names = (\"Hierarchical Mixture\", \"Probability-Weighted Component Integration\")\n", + "plot_labels = (\"Hierarchical Mixture\", \"Probability-Weighted\\nComponent Integration\")\n", + "started_notebook = perf_counter()\n", + "\n", + "assert np.all(sample_sizes // 2 + sample_sizes // 2 == sample_sizes)\n", + "print(\"QMCPy checkout:\", qmcpy.__file__)\n", + "print(\"NumPy:\", np.__version__, \"SciPy:\", scipy.__version__)\n", + "print(\"Total budgets:\", sample_sizes)\n", + "print(\"Randomizations:\", replications, \"| slope-fit budgets:\", sample_sizes[fit])" + ] + }, + { + "cell_type": "markdown", + "id": "blog-analysis-03", + "metadata": {}, + "source": [ + "## 2. Shared Helper Functions\n", + "\n", + "For a Gaussian component, $E[X^\\mathsf{T}X]=\\mu^\\mathsf{T}\\mu+\\operatorname{tr}(\\Sigma)$ and, in one dimension (1D), $E[\\cos(X)]=e^{-\\sigma^2/2}\\cos(\\mu)$. For the nonlinear ten-dimensional (10D) example we retain the demo's analytical reference:\n", + "\n", + "$$\n", + "E[e^{iX^\\mathsf{T}X}]=\\det(I-2i\\Sigma)^{-1/2}\n", + "\\exp\\!\\left(i\\mu^\\mathsf{T}(I-2i\\Sigma)^{-1}\\mu\\right).\n", + "$$\n", + "\n", + "Its real part is $E[\\cos(X^\\mathsf{T}X)]$. The implementation sums complex logarithms in the covariance eigenbasis, preserving the square-root branch continuously from zero rather than taking a potentially ambiguous square root of a complex determinant.\n", + "\n", + "Each root mean square error (RMSE) is computed across the 32 independent randomized estimates, relative to its analytical expectation. Nested prefixes provide the different budgets; fitted log-log slopes are descriptive, finite-budget statistics. The same samples are reused for the two integrands, and replayed hierarchical seeds and shared component estimates keep both probabilities paired within each random case." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "blog-analysis-04", + "metadata": {}, + "outputs": [], + "source": [ + "def replay_seed(seed):\n", + " \"\"\"Recreate a seed without advancing a shared SeedSequence.\"\"\"\n", + " if isinstance(seed, np.random.SeedSequence):\n", + " return np.random.SeedSequence(\n", + " seed.entropy, spawn_key=seed.spawn_key, pool_size=seed.pool_size\n", + " )\n", + " return np.random.SeedSequence(seed)\n", + "\n", + "\n", + "def gaussian_pair(dimension, parameter_seed):\n", + " \"\"\"Use the demo's mean/factor draws, in the same order.\"\"\"\n", + " rng = np.random.default_rng(replay_seed(parameter_seed))\n", + " means = [rng.standard_normal(dimension) for _ in range(2)]\n", + " factors = [\n", + " rng.standard_normal((dimension, dimension)) / np.sqrt(dimension)\n", + " for _ in range(2)\n", + " ]\n", + " covariances = [factor @ factor.T for factor in factors]\n", + " return dict(means=means, factors=factors, covariances=covariances)\n", + "\n", + "\n", + "def gaussian_cos_squared_norm(mean, covariance):\n", + " \"\"\"Analytical E[cos(X.T @ X)], using the demo's eigenbasis formula.\"\"\"\n", + " eigenvalues, eigenvectors = np.linalg.eigh(covariance)\n", + " rotated_mean = eigenvectors.T @ mean\n", + " factors = 1 - 2j * eigenvalues\n", + " log_characteristic = (\n", + " -0.5 * np.sum(np.log1p(-2j * eigenvalues))\n", + " + 1j * np.sum(rotated_mean**2 / factors)\n", + " )\n", + " return float(np.exp(log_characteristic).real)\n", + "\n", + "\n", + "def exact_gaussian_expectations(mean, covariance, univariate=False):\n", + " quadratic = mean @ mean + np.trace(covariance)\n", + " cosine = (\n", + " np.exp(-covariance[0, 0] / 2) * np.cos(mean[0])\n", + " if univariate\n", + " else gaussian_cos_squared_norm(mean, covariance)\n", + " )\n", + " return np.array([quadratic, cosine])\n", + "\n", + "\n", + "def exact_mixture_expectations(pair, probability, univariate=False):\n", + " component_values = [\n", + " exact_gaussian_expectations(mean, covariance, univariate)\n", + " for mean, covariance in zip(pair[\"means\"], pair[\"covariances\"])\n", + " ]\n", + " return probability * component_values[0] + (1 - probability) * component_values[1]\n", + "\n", + "\n", + "def make_components(pair, seeds=(11, 13), n_rep=1):\n", + " dimension = len(pair[\"means\"][0])\n", + " return [\n", + " Gaussian(\n", + " DigitalNetB2(dimension, seed=replay_seed(seed), replications=n_rep, randomize=\"LMS DS\"),\n", + " mean=mean,\n", + " covariance=covariance,\n", + " decomp_type=\"PCA\",\n", + " )\n", + " for mean, covariance, seed in zip(pair[\"means\"], pair[\"covariances\"], seeds)\n", + " ]\n", + "\n", + "\n", + "def prefix_estimates(samples, budgets, univariate=False):\n", + " squared_norm = np.sum(samples**2, axis=-1)\n", + " cosine = np.cos(samples[..., 0] if univariate else squared_norm)\n", + " values = (squared_norm, cosine)\n", + " # Axes: integrand, independent randomization, budget.\n", + " return np.stack([\n", + " np.stack([value[:, :int(n)].mean(axis=1) for n in budgets], axis=-1)\n", + " for value in values\n", + " ])\n", + "\n", + "\n", + "def hierarchical_estimates(pair, probability, seed, univariate=False):\n", + " \"\"\"Use the public Mixture sampler, not a hand-written selector transform.\"\"\"\n", + " dimension = len(pair[\"means\"][0])\n", + " mixture = Mixture(\n", + " DigitalNetB2(\n", + " dimension + 1, seed=replay_seed(seed), replications=replications,\n", + " randomize=\"LMS DS\",\n", + " ),\n", + " make_components(pair),\n", + " [probability, 1 - probability],\n", + " )\n", + " assert mixture.d == dimension and mixture.discrete_distrib.d == dimension + 1\n", + " # Independently verify the quadratic reference using public mixture moments.\n", + " moment_check = np.sum(np.asarray(mixture.mean)**2) + np.trace(mixture.covariance)\n", + " np.testing.assert_allclose(moment_check, exact_mixture_expectations(pair, probability)[0])\n", + " samples = mixture(n_max)\n", + " assert samples.shape == (replications, n_max, dimension)\n", + " assert np.isfinite(samples).all()\n", + " return prefix_estimates(samples, sample_sizes, univariate)\n", + "\n", + "\n", + "def component_estimates(pair, seeds, univariate=False):\n", + " \"\"\"Each component uses N/2 evaluations, not N, at total budget N.\"\"\"\n", + " components = make_components(pair, seeds, replications)\n", + " estimates = []\n", + " for component in components:\n", + " samples = component(n_max // 2)\n", + " assert samples.shape == (replications, n_max // 2, component.d)\n", + " assert np.isfinite(samples).all()\n", + " estimates.append(prefix_estimates(samples, sample_sizes // 2, univariate))\n", + " return np.stack(estimates)\n", + "\n", + "\n", + "def rmse_across_replications(estimates, exact):\n", + " return np.sqrt(np.mean((estimates - exact[:, None, None])**2, axis=1))\n", + "\n", + "\n", + "def empirical_slopes(curves):\n", + " assert np.isfinite(curves).all() and np.all(curves > 0)\n", + " fitted = np.polyfit(\n", + " np.log(sample_sizes[fit]), np.log(curves[..., fit]).reshape(-1, 5).T, 1\n", + " )[0]\n", + " return fitted.reshape(curves.shape[:-1])\n", + "\n", + "\n", + "def compare_methods(pair, probabilities, hierarchical_seed, component_seeds, univariate=False):\n", + " \"\"\"Return paired curves: probability, integrand, method, budget.\"\"\"\n", + " separate = component_estimates(pair, component_seeds, univariate)\n", + " curves = np.empty((len(probabilities), 2, 2, len(sample_sizes)))\n", + " references = []\n", + " for index, probability in enumerate(probabilities):\n", + " exact = exact_mixture_expectations(pair, probability, univariate)\n", + " hierarchical = hierarchical_estimates(pair, probability, hierarchical_seed, univariate)\n", + " weighted_components = probability * separate[0] + (1 - probability) * separate[1]\n", + " curves[index, :, 0] = rmse_across_replications(hierarchical, exact)\n", + " curves[index, :, 1] = rmse_across_replications(weighted_components, exact)\n", + " references.append(exact)\n", + " assert np.isfinite(curves).all() and np.all(curves >= 0)\n", + " return dict(rmse=curves, slopes=empirical_slopes(curves), exact=np.array(references))\n", + "\n", + "\n", + "def plot_comparison(ax, curves, title):\n", + " for method, label in enumerate(plot_labels):\n", + " ax.loglog(sample_sizes, curves[method], \"o-\", label=label, linewidth=1.8)\n", + " ax.set(xlabel=\"Total function evaluations N\", ylabel=\"RMSE\", title=title)\n", + " ax.legend(frameon=False, fontsize=9)\n", + "\n", + "\n", + "def export_figure(fig, name):\n", + " path = output_dir / name\n", + " fig.savefig(path, dpi=300, bbox_inches=\"tight\", facecolor=\"white\")\n", + " plt.show()\n", + " print(\"Exported:\", path.name)" + ] + }, + { + "cell_type": "markdown", + "id": "blog-analysis-05", + "metadata": {}, + "source": [ + "## 3. One-Dimensional Gaussian Mixture\n", + "\n", + "We retain $0.3N(-2,0.7^2)+0.7N(2.5,1.1^2)$ and test $f(x)=x^2$ and $f(x)=\\cos(x)$. The analytical quadratic expectation is $6.569$; the cosine reference is computed from the Gaussian identity above. Each component-integration estimate still has weights $0.3,0.7$, although it uses half of the total evaluations per component." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "blog-analysis-06", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Exact E[X^2]: 6.568999999999999\n", + "Exact E[cos(X)]: -0.4039548336232325\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Exported: mixture_density_1d.png\n" + ] + } + ], + "source": [ + "mu1, sigma1 = -2.0, 0.7\n", + "mu2, sigma2 = 2.5, 1.1\n", + "p = 0.3\n", + "pair1 = dict(\n", + " means=[np.array([mu1]), np.array([mu2])],\n", + " factors=[np.array([[sigma1]]), np.array([[sigma2]])],\n", + " covariances=[np.array([[sigma1**2]]), np.array([[sigma2**2]])],\n", + ")\n", + "exact1 = exact_mixture_expectations(pair1, p, univariate=True)\n", + "np.testing.assert_allclose(exact1[0], 6.569, rtol=0, atol=1e-12)\n", + "print(\"Exact E[X^2]:\", exact1[0])\n", + "print(\"Exact E[cos(X)]:\", exact1[1])\n", + "\n", + "illustration = Mixture(\n", + " DigitalNetB2(2, seed=20260914), make_components(pair1), [p, 1 - p]\n", + ")(4096)[:, 0]\n", + "grid = np.linspace(-5.5, 7, 700)\n", + "weighted_densities = (\n", + " p * norm.pdf(grid, loc=mu1, scale=sigma1),\n", + " (1 - p) * norm.pdf(grid, loc=mu2, scale=sigma2),\n", + ")\n", + "fig, ax = plt.subplots(figsize=(9, 4.3), layout=\"constrained\")\n", + "ax.hist(illustration, bins=60, density=True, alpha=0.3, label=\"4096 Mixture samples\")\n", + "ax.plot(grid, sum(weighted_densities), linewidth=2, label=\"Mixture density\")\n", + "ax.plot(grid, weighted_densities[0], \"--\", label=\"Weighted component 1 density\")\n", + "ax.plot(grid, weighted_densities[1], \":\", label=\"Weighted component 2 density\")\n", + "ax.set(xlabel=\"x\", ylabel=\"Density\", title=\"One-dimensional Gaussian mixture (p = 0.3)\")\n", + "ax.legend(frameon=False)\n", + "export_figure(fig, \"mixture_density_1d.png\")" + ] + }, + { + "cell_type": "markdown", + "id": "blog-analysis-07", + "metadata": {}, + "source": [ + "The two modes are associated with the components centered at $-2$ and $2.5$. Their integrated contributions are $0.3$ and $0.7$, not their peak heights. The histogram is one reusable sample set generated by `Mixture`; the lines are the analytical density and its probability-weighted components." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "blog-analysis-08", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Exported: equal_cost_1d.png\n" + ] + } + ], + "source": [ + "result1 = compare_methods(\n", + " pair1, [p], hierarchical_seed=20260922,\n", + " component_seeds=(20260923, 20260924), univariate=True,\n", + ")\n", + "fig, axes = plt.subplots(1, 2, figsize=(12.8, 4.4), layout=\"constrained\")\n", + "for index, (ax, title) in enumerate(zip(axes, [r\"$f(x)=x^2$\", r\"$f(x)=\\cos(x)$\"])):\n", + " plot_comparison(ax, result1[\"rmse\"][0, index], title)\n", + "fig.suptitle(\"1D mixture: equal total function-evaluation budgets\")\n", + "export_figure(fig, \"equal_cost_1d.png\")" + ] + }, + { + "cell_type": "markdown", + "id": "blog-analysis-09", + "metadata": {}, + "source": [ + "These panels compare the methods at equal total evaluations, not equal points per component. The exact references are different for the two functions, but the distributions, budgets, randomization count, and slope-fitting range are unchanged. Generated slopes and final RMSEs are reported in Table A below." + ] + }, + { + "cell_type": "markdown", + "id": "blog-analysis-10", + "metadata": {}, + "source": [ + "## 4. Fixed Correlated Gaussian Mixtures\n", + "\n", + "As in the demo, standard-normal means and dense factors $A_j/\\sqrt d$ are generated with parameter seed 123 in the five-dimensional (5D) case and 321 in 10D; $\\Sigma_j=A_jA_j^\\mathsf{T}$. We test the quadratic function in 5D at $p=0.3$, in 10D at $p=0.3$ and $p=0.1$, and $\\cos(x^\\mathsf{T}x)$ on the same 10D components at $p=0.3$.\n", + "\n", + "The cosine is smooth and bounded but oscillatory, unlike the quadratic moment. An independent million-sample ordinary-normal check validates its analytical reference; this check is **not** a third method in the QMC plots or an RMSE reference. The check retains the demo's original dense factors, while both QMC methods use the same PCA component transforms." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "blog-analysis-11", + "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", + "
analytical_referencemc_estimateabsolute_differencemc_standard_error
0-0.00395265-0.00407680.000124150.00070818
\n", + "
" + ], + "text/plain": [ + " analytical_reference mc_estimate absolute_difference mc_standard_error\n", + "0 -0.00395265 -0.0040768 0.00012415 0.00070818" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pair5 = gaussian_pair(5, 123)\n", + "pair10 = gaussian_pair(10, 321)\n", + "for pair in (pair5, pair10):\n", + " for factor, covariance in zip(pair[\"factors\"], pair[\"covariances\"]):\n", + " np.testing.assert_allclose(covariance, factor @ factor.T)\n", + " assert np.any(np.abs(covariance - np.diag(np.diag(covariance))) > 1e-10)\n", + "\n", + "# Preserve the demo's independent nonlinear-reference sanity check.\n", + "mc_rng = np.random.default_rng(854)\n", + "mc_n = 1_000_000\n", + "z_mc = mc_rng.standard_normal((mc_n, 10))\n", + "choose1_mc = mc_rng.random(mc_n) < 0.3\n", + "x_mc = np.empty_like(z_mc)\n", + "for index, selected in enumerate((choose1_mc, ~choose1_mc)):\n", + " x_mc[selected] = z_mc[selected] @ pair10[\"factors\"][index].T + pair10[\"means\"][index]\n", + "values_mc = np.cos(np.sum(x_mc**2, axis=-1))\n", + "reference_cos10 = exact_mixture_expectations(pair10, 0.3)[1]\n", + "mc_estimate = values_mc.mean()\n", + "mc_standard_error = values_mc.std(ddof=1) / np.sqrt(mc_n)\n", + "mc_difference = abs(mc_estimate - reference_cos10)\n", + "if mc_difference > 5 * mc_standard_error:\n", + " raise RuntimeError(\"Analytical cosine reference failed the independent MC sanity check.\")\n", + "display(pd.DataFrame([dict(\n", + " analytical_reference=reference_cos10, mc_estimate=mc_estimate,\n", + " absolute_difference=mc_difference, mc_standard_error=mc_standard_error,\n", + ")]))\n", + "del z_mc, x_mc, choose1_mc, values_mc" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "blog-analysis-12", + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + "
caseexact_expectation
05D quadratic, p=0.36.56556862
110D quadratic, p=0.312.59553367
210D quadratic, p=0.110.45085478
310D cosine quadratic, p=0.3-0.00395265
\n", + "
" + ], + "text/plain": [ + " case exact_expectation\n", + "0 5D quadratic, p=0.3 6.56556862\n", + "1 10D quadratic, p=0.3 12.59553367\n", + "2 10D quadratic, p=0.1 10.45085478\n", + "3 10D cosine quadratic, p=0.3 -0.00395265" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Exported: equal_cost_fixed_10d.png\n" + ] + } + ], + "source": [ + "# Fixed hierarchical seeds are those used in the merged demo.\n", + "result5 = compare_methods(pair5, [0.3], 124, (125, 126))\n", + "result10 = compare_methods(pair10, [0.3], 322, (323, 324))\n", + "result10_imbalanced = compare_methods(pair10, [0.1], 422, (423, 424))\n", + "\n", + "fixed_rows = [\n", + " (\"5D quadratic, p=0.3\", result5, 0),\n", + " (\"10D quadratic, p=0.3\", result10, 0),\n", + " (\"10D quadratic, p=0.1\", result10_imbalanced, 0),\n", + " (\"10D cosine quadratic, p=0.3\", result10, 1),\n", + "]\n", + "display(pd.DataFrame([\n", + " dict(case=name, exact_expectation=result[\"exact\"][0, integrand])\n", + " for name, result, integrand in fixed_rows\n", + "]))\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(13, 4.7), layout=\"constrained\")\n", + "for result, probability, line_style in (\n", + " (result10, 0.3, \"-\"), (result10_imbalanced, 0.1, \"--\")\n", + "):\n", + " # Restart the default color cycle: color identifies method, style identifies p.\n", + " axes[0].set_prop_cycle(None)\n", + " for method, label in enumerate(plot_labels):\n", + " axes[0].loglog(\n", + " sample_sizes, result[\"rmse\"][0, 0, method],\n", + " marker=\"o\", linestyle=line_style, linewidth=1.8,\n", + " label=f\"{label} (p={probability})\",\n", + " )\n", + "axes[0].set(xlabel=\"Total function evaluations N\", ylabel=\"RMSE\", title=r\"$f(x)=x^\\mathsf{T}x$\")\n", + "axes[0].legend(frameon=False, fontsize=8)\n", + "plot_comparison(axes[1], result10[\"rmse\"][0, 1], r\"$f(x)=\\cos(x^\\mathsf{T}x)$, p=0.3\")\n", + "fig.suptitle(\"Fixed correlated 10D mixture: equal total function-evaluation budgets\")\n", + "export_figure(fig, \"equal_cost_fixed_10d.png\")" + ] + }, + { + "cell_type": "markdown", + "id": "blog-analysis-13", + "metadata": {}, + "source": [ + "The fixed cases are a stepping stone, not a population-level ranking. Table B retains the 5D evidence as well as the plotted 10D cases. Variation among individual cases motivates the paired 100-mixture study below." + ] + }, + { + "cell_type": "markdown", + "id": "blog-analysis-14", + "metadata": {}, + "source": [ + "## 5. One Hundred Random 10D Mixture Instances\n", + "\n", + "We reproduce the merged demo's population: `SeedSequence(20260925).spawn(100)`, with each case spawning a parameter seed and a hierarchical QMC seed. Two component QMC seeds are spawned from a **replayed copy** of that QMC seed; doing so does not advance or alter the hierarchical seed. All cases use the same parameter-generation order and $AA^\\mathsf{T}$ covariance construction as the fixed experiments.\n", + "\n", + "Within a case, both methods use exactly the same component parameters. Both integrands reuse each method's samples; both probabilities reuse identical hierarchical uniform points through deterministic seed replay and the same component estimates. The original component factors and both reference expectations are computed once per case. Only compact RMSE/reference arrays are retained between cases.\n", + "\n", + "The panels show median RMSE and the 25th–75th percentile **across mixture instances**, not confidence intervals. Slope quantiles summarize individual-case fits rather than a fit to the median RMSE curve." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "blog-analysis-15", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Completed 10/100 cases\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Completed 20/100 cases\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Completed 30/100 cases\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Completed 40/100 cases\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Completed 50/100 cases\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Completed 60/100 cases\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Completed 70/100 cases\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Completed 80/100 cases\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Completed 90/100 cases\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Completed 100/100 cases\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100-case calculation: 198.0 seconds\n" + ] + } + ], + "source": [ + "n_cases100 = 100\n", + "p_values100 = (0.3, 0.1)\n", + "master_seed100 = 20260925\n", + "case_seeds100 = np.random.SeedSequence(master_seed100).spawn(n_cases100)\n", + "# Axes: case, probability, integrand, method, budget.\n", + "rmse_random = np.empty((n_cases100, 2, 2, 2, len(sample_sizes)))\n", + "slopes_random = np.empty((n_cases100, 2, 2, 2))\n", + "references_random = np.empty((n_cases100, 2, 2))\n", + "started_random = perf_counter()\n", + "\n", + "for case_index, case_seed in enumerate(case_seeds100):\n", + " parameter_seed, qmc_seed = replay_seed(case_seed).spawn(2)\n", + " pair = gaussian_pair(10, parameter_seed)\n", + " component_seeds = replay_seed(qmc_seed).spawn(2)\n", + " result = compare_methods(pair, p_values100, qmc_seed, component_seeds)\n", + " rmse_random[case_index] = result[\"rmse\"]\n", + " slopes_random[case_index] = result[\"slopes\"]\n", + " references_random[case_index] = result[\"exact\"]\n", + " if (case_index + 1) % 10 == 0:\n", + " print(f\"Completed {case_index + 1}/{n_cases100} cases\", flush=True)\n", + " del pair, result\n", + "\n", + "elapsed_random = perf_counter() - started_random\n", + "rmse_quantiles_random = np.quantile(rmse_random, [0.25, 0.5, 0.75], axis=0)\n", + "slope_quantiles_random = np.quantile(slopes_random, [0.25, 0.5, 0.75], axis=0)\n", + "final_rmse_ratios = rmse_random[..., 0, -1] / rmse_random[..., 1, -1]\n", + "print(f\"100-case calculation: {elapsed_random:.1f} seconds\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "blog-analysis-16", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Exported: equal_cost_random_10d.png\n" + ] + } + ], + "source": [ + "fig, axes = plt.subplots(2, 2, figsize=(13, 8.2), layout=\"constrained\", sharex=True)\n", + "integrand_titles = (r\"$x^\\mathsf{T}x$\", r\"$\\cos(x^\\mathsf{T}x)$\")\n", + "for integrand, title in enumerate(integrand_titles):\n", + " for probability_index, probability in enumerate(p_values100):\n", + " ax = axes[integrand, probability_index]\n", + " for method, label in enumerate(plot_labels):\n", + " lower, median, upper = rmse_quantiles_random[:, probability_index, integrand, method]\n", + " line, = ax.loglog(sample_sizes, median, \"o-\", linewidth=1.8, label=label)\n", + " ax.fill_between(sample_sizes, lower, upper, color=line.get_color(), alpha=0.18)\n", + " ax.set(xlabel=\"Total function evaluations N\", ylabel=\"RMSE\", title=f\"{title}, p={probability}\")\n", + " ax.legend(frameon=False, fontsize=9)\n", + "fig.suptitle(\"100 paired 10D mixtures: median RMSE and middle 50% of cases\")\n", + "export_figure(fig, \"equal_cost_random_10d.png\")" + ] + }, + { + "cell_type": "markdown", + "id": "blog-analysis-17", + "metadata": {}, + "source": [ + "## 6. Generated Blog Tables\n", + "\n", + "Every entry below comes from the executed experiment arrays. Final RMSE means $N=32768$ **total** function evaluations per randomization, including both components for component integration. Table C reports medians across cases; all slope and RMSE quartiles are also available in `slope_quantiles_random` and `rmse_quantiles_random`.\n", + "\n", + "The final-error ratio is calculated **within each paired case**, then summarized by its median. A ratio above one favors component integration for that statistic; below one favors hierarchical sampling. It is not the ratio of the two marginal medians." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "blog-analysis-18", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Table A — 1D\n" + ] + }, + { + "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", + " \n", + " \n", + " \n", + " \n", + "
integrandhierarchical slopecomponent slopehierarchical final RMSEcomponent final RMSE
0x^2-0.91199417-1.026372840.000387350.00015722
1cos(x)-0.94987311-1.083107430.000034470.00001179
\n", + "
" + ], + "text/plain": [ + " integrand hierarchical slope component slope hierarchical final RMSE \\\n", + "0 x^2 -0.91199417 -1.02637284 0.00038735 \n", + "1 cos(x) -0.94987311 -1.08310743 0.00003447 \n", + "\n", + " component final RMSE \n", + "0 0.00015722 \n", + "1 0.00001179 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Table B — fixed higher-dimensional cases\n" + ] + }, + { + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
casehierarchical slopecomponent slopehierarchical final RMSEcomponent final RMSE
05D quadratic, p=0.3-0.96055400-1.040068540.000349060.00031918
110D quadratic, p=0.3-1.05307225-0.958426530.000518150.00053577
210D quadratic, p=0.1-0.95044642-1.011857630.000495480.00057509
310D cosine quadratic, p=0.3-0.48135522-0.474730120.003825410.00385641
\n", + "
" + ], + "text/plain": [ + " case hierarchical slope component slope \\\n", + "0 5D quadratic, p=0.3 -0.96055400 -1.04006854 \n", + "1 10D quadratic, p=0.3 -1.05307225 -0.95842653 \n", + "2 10D quadratic, p=0.1 -0.95044642 -1.01185763 \n", + "3 10D cosine quadratic, p=0.3 -0.48135522 -0.47473012 \n", + "\n", + " hierarchical final RMSE component final RMSE \n", + "0 0.00034906 0.00031918 \n", + "1 0.00051815 0.00053577 \n", + "2 0.00049548 0.00057509 \n", + "3 0.00382541 0.00385641 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Table C — 100 paired random 10D mixtures\n" + ] + }, + { + "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", + " \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", + " \n", + " \n", + " \n", + "
integrandphierarchical median slopecomponent median slopehierarchical median final RMSEcomponent median final RMSEmedian paired final RMSE ratio H/C
0x^T x0.3-0.96724987-0.986868480.000668640.000586501.12662488
1x^T x0.1-0.99522484-0.983686080.000596700.000710810.83291770
2cos(x^T x)0.3-0.52641012-0.517761100.003604230.004012850.92258009
3cos(x^T x)0.1-0.50872464-0.512064980.003686710.004747730.76682532
\n", + "
" + ], + "text/plain": [ + " integrand p hierarchical median slope component median slope \\\n", + "0 x^T x 0.3 -0.96724987 -0.98686848 \n", + "1 x^T x 0.1 -0.99522484 -0.98368608 \n", + "2 cos(x^T x) 0.3 -0.52641012 -0.51776110 \n", + "3 cos(x^T x) 0.1 -0.50872464 -0.51206498 \n", + "\n", + " hierarchical median final RMSE component median final RMSE \\\n", + "0 0.00066864 0.00058650 \n", + "1 0.00059670 0.00071081 \n", + "2 0.00360423 0.00401285 \n", + "3 0.00368671 0.00474773 \n", + "\n", + " median paired final RMSE ratio H/C \n", + "0 1.12662488 \n", + "1 0.83291770 \n", + "2 0.92258009 \n", + "3 0.76682532 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Notebook calculations: 208.0 seconds\n", + "Validated finite results, nonnegative RMSEs, equal cost, and all four PNG exports.\n" + ] + } + ], + "source": [ + "def fixed_table_row(label, result, integrand):\n", + " return {\n", + " \"case\": label,\n", + " \"hierarchical slope\": result[\"slopes\"][0, integrand, 0],\n", + " \"component slope\": result[\"slopes\"][0, integrand, 1],\n", + " \"hierarchical final RMSE\": result[\"rmse\"][0, integrand, 0, -1],\n", + " \"component final RMSE\": result[\"rmse\"][0, integrand, 1, -1],\n", + " }\n", + "\n", + "\n", + "table_a = pd.DataFrame([\n", + " fixed_table_row(label, result1, index)\n", + " for index, label in enumerate((\"x^2\", \"cos(x)\"))\n", + "]).rename(columns={\"case\": \"integrand\"})\n", + "table_b = pd.DataFrame([\n", + " fixed_table_row(label, result, integrand)\n", + " for label, result, integrand in fixed_rows\n", + "])\n", + "rows_c = []\n", + "for integrand, label in enumerate((\"x^T x\", \"cos(x^T x)\")):\n", + " for probability_index, probability in enumerate(p_values100):\n", + " rows_c.append({\n", + " \"integrand\": label,\n", + " \"p\": probability,\n", + " \"hierarchical median slope\": slope_quantiles_random[1, probability_index, integrand, 0],\n", + " \"component median slope\": slope_quantiles_random[1, probability_index, integrand, 1],\n", + " \"hierarchical median final RMSE\": rmse_quantiles_random[1, probability_index, integrand, 0, -1],\n", + " \"component median final RMSE\": rmse_quantiles_random[1, probability_index, integrand, 1, -1],\n", + " \"median paired final RMSE ratio H/C\": np.median(final_rmse_ratios[:, probability_index, integrand]),\n", + " })\n", + "table_c = pd.DataFrame(rows_c)\n", + "\n", + "print(\"Table A — 1D\")\n", + "display(table_a)\n", + "print(\"Table B — fixed higher-dimensional cases\")\n", + "display(table_b)\n", + "print(\"Table C — 100 paired random 10D mixtures\")\n", + "display(table_c)\n", + "\n", + "for values in (\n", + " rmse_random, slopes_random, references_random, final_rmse_ratios,\n", + " rmse_quantiles_random, slope_quantiles_random,\n", + "):\n", + " assert np.isfinite(values).all()\n", + "assert np.all(rmse_random >= 0)\n", + "for table in (table_a, table_b, table_c):\n", + " assert np.isfinite(table.select_dtypes(include=\"number\").to_numpy()).all()\n", + "expected_figures = (\n", + " \"mixture_density_1d.png\", \"equal_cost_1d.png\",\n", + " \"equal_cost_fixed_10d.png\", \"equal_cost_random_10d.png\",\n", + ")\n", + "assert all((output_dir / name).is_file() for name in expected_figures)\n", + "elapsed_notebook = perf_counter() - started_notebook\n", + "print(f\"Notebook calculations: {elapsed_notebook:.1f} seconds\")\n", + "print(\"Validated finite results, nonnegative RMSEs, equal cost, and all four PNG exports.\")" + ] + }, + { + "cell_type": "markdown", + "id": "blog-analysis-19", + "metadata": {}, + "source": [ + "## 7. Interpretation\n", + "\n", + "Hierarchical Mixture introduces a discontinuity at the component-selection threshold, but that discontinuity alone does not determine the observed performance. Component integration has lower final RMSE in the 1D examples and the fixed 5D quadratic case. Across the random 10D quadratic cases, it has a modest median advantage at $p=0.3$, but not at $p=0.1$ in this PCA-based comparison. For $\\cos(x^\\mathsf{T}x)$, both methods have empirical slopes near $-0.5$ and hierarchical sampling has smaller median final RMSE at both probabilities.\n", + "\n", + "There is no universal numerical winner here. Performance depends on the integrand, dimension, mixture parameters, component transforms, and budget range. In particular, the earlier dense-factor, last-selector exploratory errors are not interchangeable with these public-API, PCA-based results: the covariance matrices and analytical expectations are unchanged, but the QMC mappings differ. The generated tables are the values to use for this implementation-based comparison.\n", + "\n", + "Hierarchical Mixture directly produces a reusable sample set from the full mixture. Probability-Weighted Component Integration is especially natural when a particular expectation is the goal; it is not itself a direct mixture-sampling construction. All fitted slopes here are finite-budget numerical observations, not theoretical convergence rates or a theorem." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/mkdocs.yml b/mkdocs.yml index dc7470b71..c78f31b58 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -83,6 +83,7 @@ nav: - SciPyWrapper dependence and Custom distributions: demos/scipywrapper_dependence_custom/scipywrapper_demo.ipynb - ProductMeasure: demos/product_measure.ipynb - Mixed Distributions: demos/mixed_distributions.ipynb + - Mixed Distributions Blog Analysis: demos/mixed_distributions_blog_analysis.ipynb - Acceptance-Rejection Sampling: demos/acceptance_rejection.ipynb - Copula TrueMeasure Examples: demos/copula_examples.ipynb - Cube-to-Simplex Transforms and SimplexUniform: demos/simplex_uniform.ipynb diff --git a/scripts/colab_notebooks_manifest.json b/scripts/colab_notebooks_manifest.json index ff4db1c1e..20e023c9e 100644 --- a/scripts/colab_notebooks_manifest.json +++ b/scripts/colab_notebooks_manifest.json @@ -23,6 +23,7 @@ "demos/linear-scrambled-halton.ipynb", "demos/makefile_dev_tools.ipynb", "demos/mixed_distributions.ipynb", + "demos/mixed_distributions_blog_analysis.ipynb", "demos/nei_demo.ipynb", "demos/performance_optimizations_demo.ipynb", "demos/plot_proj_function.ipynb", diff --git a/test/booktests/tb_mixed_distributions_blog_analysis.py b/test/booktests/tb_mixed_distributions_blog_analysis.py new file mode 100644 index 000000000..91c669e45 --- /dev/null +++ b/test/booktests/tb_mixed_distributions_blog_analysis.py @@ -0,0 +1,69 @@ +import tempfile +import unittest +from pathlib import Path + +import nbformat + +from __init__ import BaseNotebookTest + + +class NotebookTests(BaseNotebookTest): + + def test_saved_results(self): + notebook_path, _ = self.locate_notebook( + "../../demos/mixed_distributions_blog_analysis.ipynb" + ) + notebook = nbformat.read(notebook_path, as_version=4) + nbformat.validate(notebook) + code_cells = [ + cell for cell in notebook.cells + if cell.cell_type == "code" + and not cell.source.startswith("# @title Execute this cell") + ] + self.assertEqual( + [cell.execution_count for cell in code_cells], + list(range(1, len(code_cells) + 1)), + ) + outputs = [output for cell in code_cells for output in cell.outputs] + self.assertFalse(any(output.output_type == "error" for output in outputs)) + self.assertEqual( + sum("image/png" in output.get("data", {}) for output in outputs), 4 + ) + + def test_mixed_distributions_blog_analysis_notebook(self): + """Exercise every cell without rerunning the full publication study.""" + notebook_path, _ = self.locate_notebook( + "../../demos/mixed_distributions_blog_analysis.ipynb" + ) + original = Path(notebook_path).read_bytes() + notebook = nbformat.read(notebook_path, as_version=4) + source = "\n".join( + cell.source for cell in notebook.cells if cell.cell_type == "code" + ) + with tempfile.TemporaryDirectory() as output_dir: + replacements = { + "sample_sizes = 2 ** np.arange(6, 16)": + "sample_sizes = 2 ** np.arange(6, 11)", + "n_cases100 = 100": "n_cases100 = 2", + "mc_n = 1_000_000": "mc_n = 20_000", + 'output_dir = repo_root / "demos" / "mixed_distributions_blog_outputs"': + f"output_dir = Path({output_dir!r})", + } + # Fail if a notebook edit makes a workload override stop matching. + for old in replacements: + self.assertEqual(source.count(old), 1, old) + self.run_notebook(notebook_path, replacements=replacements) + self.assertEqual( + {path.name for path in Path(output_dir).iterdir()}, + { + "mixture_density_1d.png", + "equal_cost_1d.png", + "equal_cost_fixed_10d.png", + "equal_cost_random_10d.png", + }, + ) + self.assertEqual(Path(notebook_path).read_bytes(), original) + + +if __name__ == "__main__": + unittest.main()