From 2d8374cccd067a7a34dee94b48e63e051816086c Mon Sep 17 00:00:00 2001 From: Laasya-73 <77721581+Laasya-73@users.noreply.github.com> Date: Mon, 31 Aug 2026 22:57:27 -0500 Subject: [PATCH 1/4] Add mixed distribution support to TrueMeasure --- demos/mixed_distributions.ipynb | 663 +++++++++++++++++++++++ docs/api/true_measures.md | 4 + mkdocs.yml | 1 + qmcpy/true_measure/__init__.py | 1 + qmcpy/true_measure/mixture.py | 185 +++++++ test/booktests/tb_mixed_distributions.py | 20 + test/test_mixed_distributions.py | 280 ++++++++++ 7 files changed, 1154 insertions(+) create mode 100644 demos/mixed_distributions.ipynb create mode 100644 qmcpy/true_measure/mixture.py create mode 100644 test/booktests/tb_mixed_distributions.py create mode 100644 test/test_mixed_distributions.py diff --git a/demos/mixed_distributions.ipynb b/demos/mixed_distributions.ipynb new file mode 100644 index 000000000..f1f7ee69e --- /dev/null +++ b/demos/mixed_distributions.ipynb @@ -0,0 +1,663 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d16dd42c", + "metadata": {}, + "source": [ + "# Mixed distributions in QMCPy\n", + "\n", + "## 1. Problem statement\n", + "\n", + "A mixed distribution combines component probability measures\n", + "$P_0,\\ldots,P_{s-1}$ as\n", + "\n", + "$$\n", + "P_{\\mathrm{mix}} = \\sum_{j=0}^{s-1} p_j P_j,\n", + "\\qquad p_j > 0,\n", + "\\qquad \\sum_{j=0}^{s-1} p_j = 1.\n", + "$$\n", + "\n", + "When the components have densities or weights $\\rho_j$ with respect to a\n", + "common reference measure, the corresponding mixture is\n", + "\n", + "$$\n", + "\\rho_{\\mathrm{mix}}(x) = \\sum_{j=0}^{s-1} p_j\\rho_j(x).\n", + "$$\n", + "\n", + "The measure-level definition also covers components with point masses, which\n", + "need not have an ordinary smooth density. This notebook focuses on sampling\n", + "and on what the extra selector coordinate means in practice." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "a56b8cb6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-01T03:01:22.653195Z", + "iopub.status.busy": "2026-09-01T03:01:22.652677Z", + "iopub.status.idle": "2026-09-01T03:01:24.071412Z", + "shell.execute_reply": "2026-09-01T03:01:24.070278Z" + } + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from qmcpy import (\n", + " DigitalNetB2,\n", + " Gaussian,\n", + " Kumaraswamy,\n", + " Mixture,\n", + " StudentT,\n", + " Triangular,\n", + " ZeroInflatedExpUniform,\n", + ")\n", + "\n", + "plt.style.use(\"seaborn-v0_8-whitegrid\")\n", + "COLORS = [\"#3366CC\", \"#E67300\", \"#2E8B57\"]" + ] + }, + { + "cell_type": "markdown", + "id": "7929f26e", + "metadata": {}, + "source": [ + "## 2. What was missing before\n", + "\n", + "Individual `TrueMeasure`s already know how to transform standard-uniform\n", + "coordinates and how to evaluate their weights. What was missing was a small\n", + "coordinator that could choose among those existing transforms without\n", + "reimplementing any component distribution." + ] + }, + { + "cell_type": "markdown", + "id": "d5f10d00", + "metadata": {}, + "source": [ + "## 3. The $d+1 \\rightarrow d$ selector transform\n", + "\n", + "For an output in $\\mathbb{R}^d$, `Mixture` consumes\n", + "$u=(u_0,u_1,\\ldots,u_d)\\in[0,1]^{d+1}$. The first coordinate selects component\n", + "$j$ through\n", + "\n", + "$$\n", + "p_0+\\cdots+p_{j-1} < u_0 \\le p_0+\\cdots+p_j,\n", + "$$\n", + "\n", + "and only $(u_1,\\ldots,u_d)$ enters that component's recursive transform. Thus\n", + "the outer sampler has dimension `d + 1`, while the returned samples have last\n", + "axis `d`." + ] + }, + { + "cell_type": "markdown", + "id": "1579d10b", + "metadata": {}, + "source": [ + "## 4. A simple two-component introduction\n", + "\n", + "Two separated Gaussians make the selector easy to see. This is the notebook's\n", + "only one-dimensional Gaussian-focused example: $u_0\\le0.3$ chooses the\n", + "left component, and $u_0>0.3$ chooses the right component." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "51b03ec2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-01T03:01:24.075080Z", + "iopub.status.busy": "2026-09-01T03:01:24.074740Z", + "iopub.status.idle": "2026-09-01T03:01:24.084040Z", + "shell.execute_reply": "2026-09-01T03:01:24.083194Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "outer sampler dimension: 2\n", + "mixture sample shape: (2048, 1)\n" + ] + } + ], + "source": [ + "intro_components = [\n", + " Gaussian(DigitalNetB2(1, seed=11), mean=-2.0, covariance=0.35),\n", + " Gaussian(DigitalNetB2(1, seed=13), mean=2.5, covariance=0.55),\n", + "]\n", + "intro_probabilities = np.array([0.3, 0.7])\n", + "intro = Mixture(\n", + " DigitalNetB2(2, seed=7), intro_components, intro_probabilities\n", + ")\n", + "\n", + "intro_x = intro(2048)[:, 0]\n", + "\n", + "assert intro.d == 1\n", + "assert intro.discrete_distrib.d == 2\n", + "assert intro_x.shape == (2048,)\n", + "print(\"outer sampler dimension:\", intro.discrete_distrib.d)\n", + "print(\"mixture sample shape: \", intro_x[:, None].shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8240596d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-01T03:01:24.086386Z", + "iopub.status.busy": "2026-09-01T03:01:24.086193Z", + "iopub.status.idle": "2026-09-01T03:01:24.474101Z", + "shell.execute_reply": "2026-09-01T03:01:24.472986Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, 2, figsize=(10.5, 3.4), layout=\"constrained\")\n", + "\n", + "axes[0].barh(0, 0.3, left=0.0, color=COLORS[0], height=0.5)\n", + "axes[0].barh(0, 0.7, left=0.3, color=COLORS[1], height=0.5)\n", + "axes[0].axvline(0.3, color=\"black\", linewidth=1)\n", + "axes[0].text(0.15, 0, \"component 0\\np = 0.30\", ha=\"center\", va=\"center\", color=\"white\")\n", + "axes[0].text(0.65, 0, \"component 1\\np = 0.70\", ha=\"center\", va=\"center\", color=\"white\")\n", + "axes[0].set(xlim=(0, 1), yticks=[], xlabel=r\"selector $u_0$\", title=\"Selector intervals\")\n", + "\n", + "bins = np.linspace(-4.5, 5.5, 65)\n", + "axes[1].hist(intro_x, bins=bins, color=\"#6A5ACD\", alpha=0.72)\n", + "axes[1].axvline(-2.0, color=COLORS[0], linewidth=1.4, label=\"component means\")\n", + "axes[1].axvline(2.5, color=COLORS[1], linewidth=1.4)\n", + "axes[1].set(xlabel=\"sample value\", ylabel=\"count\", title=\"Resulting sample\")\n", + "axes[1].legend(frameon=False)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c2517cab", + "metadata": {}, + "source": [ + "## 5. Exact boundary behavior\n", + "\n", + "`Mixture` uses left-sided cumulative-probability lookup. An exact cumulative\n", + "boundary belongs to the component on its left; the next representable number\n", + "above it belongs to the next component. The endpoints `0` and `1` select the\n", + "first and last components, respectively." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5f8a1081", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-01T03:01:24.477254Z", + "iopub.status.busy": "2026-09-01T03:01:24.477001Z", + "iopub.status.idle": "2026-09-01T03:01:24.483583Z", + "shell.execute_reply": "2026-09-01T03:01:24.482476Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "u0=0 -> component 0 -> x=-2.0\n", + "u0=0.29999999999999999 -> component 0 -> x=-2.0\n", + "u0=0.30000000000000004 -> component 1 -> x=2.5\n", + "u0=1 -> component 1 -> x=2.5\n" + ] + } + ], + "source": [ + "boundary_u = np.array([\n", + " [0.0, 0.5],\n", + " [0.3, 0.5],\n", + " [np.nextafter(0.3, 1.0), 0.5],\n", + " [1.0, 0.5],\n", + "])\n", + "boundary_x = intro._transform(boundary_u)[:, 0]\n", + "boundary_component = np.searchsorted(\n", + " np.cumsum(intro_probabilities), boundary_u[:, 0], side=\"left\"\n", + ")\n", + "boundary_component = np.minimum(boundary_component, 1)\n", + "\n", + "for selector, component, value in zip(\n", + " boundary_u[:, 0], boundary_component, boundary_x\n", + "):\n", + " print(f\"u0={selector:.17g} -> component {component} -> x={value:.1f}\")\n", + "\n", + "np.testing.assert_array_equal(boundary_component, [0, 0, 1, 1])\n", + "np.testing.assert_allclose(boundary_x, [-2.0, -2.0, 2.5, 2.5])" + ] + }, + { + "cell_type": "markdown", + "id": "aa8ac536", + "metadata": {}, + "source": [ + "## 6. Main heterogeneous mixture\n", + "\n", + "Now the components are genuinely different: a bell-shaped Gaussian, a\n", + "zero-inflated exponential, and a bounded skewed Kumaraswamy distribution.\n", + "Their selector intervals are `[0, 0.25]`, `(0.25, 0.65]`, and `(0.65, 1]`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "9af97f5f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-01T03:01:24.486037Z", + "iopub.status.busy": "2026-09-01T03:01:24.485806Z", + "iopub.status.idle": "2026-09-01T03:01:24.496767Z", + "shell.execute_reply": "2026-09-01T03:01:24.496032Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "observed total zero fraction: 0.1802\n", + "target total zero fraction: 0.18000000000000002\n" + ] + } + ], + "source": [ + "heterogeneous_components = [\n", + " Gaussian(DigitalNetB2(1, seed=21), mean=-2.2, covariance=0.22),\n", + " ZeroInflatedExpUniform(\n", + " DigitalNetB2(1, seed=22), p_zero=0.45, lam=1.2\n", + " ),\n", + " Kumaraswamy(DigitalNetB2(1, seed=23), a=0.7, b=2.8),\n", + "]\n", + "heterogeneous_probabilities = np.array([0.25, 0.40, 0.35])\n", + "heterogeneous = Mixture(\n", + " DigitalNetB2(2, seed=17),\n", + " heterogeneous_components,\n", + " heterogeneous_probabilities,\n", + ")\n", + "\n", + "heterogeneous_x = heterogeneous(4096)[:, 0]\n", + "zero_mask = heterogeneous_x == 0\n", + "\n", + "print(\"observed total zero fraction:\", round(zero_mask.mean(), 4))\n", + "print(\"target total zero fraction: \", 0.40 * 0.45)" + ] + }, + { + "cell_type": "markdown", + "id": "31d2c1cf", + "metadata": {}, + "source": [ + "## 7. Reading the heterogeneous sample\n", + "\n", + "The continuous values and the atom at zero require different visual marks.\n", + "The negative bell-shaped cluster comes from the Gaussian, values between zero\n", + "and one combine the bounded Kumaraswamy behavior with positive exponential\n", + "values, and the positive tail comes from the exponential component. The\n", + "histogram below excludes exact zeros. The adjacent bar reports the point-mass\n", + "count rather than pretending that the atom is part of a smooth density." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "7a7acf9c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-01T03:01:24.500108Z", + "iopub.status.busy": "2026-09-01T03:01:24.499852Z", + "iopub.status.idle": "2026-09-01T03:01:24.769301Z", + "shell.execute_reply": "2026-09-01T03:01:24.767784Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(\n", + " 1, 2, figsize=(10.5, 3.7), gridspec_kw={\"width_ratios\": [3.2, 1]},\n", + " layout=\"constrained\"\n", + ")\n", + "\n", + "continuous_values = heterogeneous_x[~zero_mask]\n", + "plot_low, plot_high = np.quantile(continuous_values, [0.002, 0.995])\n", + "bins = np.linspace(plot_low, plot_high, 72)\n", + "axes[0].hist(continuous_values, bins=bins, color=\"#6A5ACD\", alpha=0.72)\n", + "axes[0].axvline(0, color=\"black\", linewidth=0.9, linestyle=\"--\")\n", + "axes[0].set(\n", + " xlabel=\"continuous sample value\", ylabel=\"count\",\n", + " title=\"Continuous values (exact zeros excluded)\"\n", + ")\n", + "\n", + "zero_count = int(zero_mask.sum())\n", + "expected_zero_count = len(heterogeneous_x) * 0.40 * 0.45\n", + "axes[1].bar([\"x = 0\"], [zero_count], color=COLORS[1], width=0.55)\n", + "axes[1].axhline(expected_zero_count, color=\"black\", linestyle=\"--\", linewidth=1)\n", + "axes[1].text(0, zero_count, f\" {zero_count}\", ha=\"center\", va=\"bottom\")\n", + "axes[1].set_ylim(0, max(zero_count, expected_zero_count) * 1.18)\n", + "axes[1].set(ylabel=\"count\", title=\"Discrete atom\\n(dashed = expected)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "73bafcce", + "metadata": {}, + "source": [ + "## 8. Another pair: heavy-tailed and bounded\n", + "\n", + "This short example mixes a Student $t$ distribution with a bounded triangular\n", + "distribution. The former can generate heavy tails; the latter stays inside its\n", + "finite support and peaks at its mode." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "4d4bb5b0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-01T03:01:24.773831Z", + "iopub.status.busy": "2026-09-01T03:01:24.773465Z", + "iopub.status.idle": "2026-09-01T03:01:24.995641Z", + "shell.execute_reply": "2026-09-01T03:01:24.994456Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pair_components = [\n", + " StudentT(\n", + " DigitalNetB2(1, seed=31), loc=[-1.0], shape=[[0.8]], df=3\n", + " ),\n", + " Triangular(\n", + " DigitalNetB2(1, seed=32), c=0.25, loc=1.5, scale=3.0\n", + " ),\n", + "]\n", + "pair_probabilities = np.array([0.55, 0.45])\n", + "pair = Mixture(DigitalNetB2(2, seed=29), pair_components, pair_probabilities)\n", + "\n", + "pair_x = pair(4096)[:, 0]\n", + "pair_low, pair_high = np.quantile(pair_x, [0.004, 0.996])\n", + "pair_bins = np.linspace(pair_low, pair_high, 75)\n", + "\n", + "fig, ax = plt.subplots(figsize=(8.2, 3.4), layout=\"constrained\")\n", + "ax.hist(pair_x, bins=pair_bins, color=\"#6A5ACD\", alpha=0.72, label=\"mixture sample\")\n", + "ax.axvspan(1.5, 4.5, color=COLORS[1], alpha=0.12, label=\"triangular support\")\n", + "ax.set(xlabel=\"sample value\", ylabel=\"count\", title=\"Different families, one mixture\")\n", + "ax.legend(frameon=False)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "3e9a370b", + "metadata": {}, + "source": [ + "## 9. Multidimensional output\n", + "\n", + "For $d=2$, the outer sampler has three coordinates: one selector and two\n", + "coordinates for the chosen component. The returned sample still has only two\n", + "coordinates. A compact Gaussian example makes the two clusters easy to inspect." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a37fbccd", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-01T03:01:24.998149Z", + "iopub.status.busy": "2026-09-01T03:01:24.997899Z", + "iopub.status.idle": "2026-09-01T03:01:25.158941Z", + "shell.execute_reply": "2026-09-01T03:01:25.157963Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "outer sampler dimension: 3\n", + "output sample shape: (2048, 2)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "components_2d = [\n", + " Gaussian(\n", + " DigitalNetB2(2, seed=41), mean=[-1.5, -0.8],\n", + " covariance=[[0.45, 0.22], [0.22, 0.35]]\n", + " ),\n", + " Gaussian(\n", + " DigitalNetB2(2, seed=42), mean=[1.4, 1.1],\n", + " covariance=[[0.35, -0.12], [-0.12, 0.5]]\n", + " ),\n", + "]\n", + "mixture_2d = Mixture(DigitalNetB2(3, seed=39), components_2d, [0.4, 0.6])\n", + "x_2d = mixture_2d(2048)\n", + "\n", + "assert mixture_2d.discrete_distrib.d == 3\n", + "assert x_2d.shape == (2048, 2)\n", + "print(\"outer sampler dimension:\", mixture_2d.discrete_distrib.d)\n", + "print(\"output sample shape: \", x_2d.shape)\n", + "\n", + "fig, ax = plt.subplots(figsize=(5.8, 4.5), layout=\"constrained\")\n", + "ax.scatter(x_2d[:, 0], x_2d[:, 1], s=9, alpha=0.45, color=\"#6A5ACD\")\n", + "ax.set(xlabel=r\"$x_1$\", ylabel=r\"$x_2$\", title=\"Two-dimensional mixture output\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "a85b4b5c", + "metadata": {}, + "source": [ + "## 10. A component may itself be composed\n", + "\n", + "Components are reused through their recursive transform, not just their final\n", + "`_transform` method. Here a Kumaraswamy transform feeds a Gaussian transform.\n", + "The first probe point selects that composed component; the second selects a\n", + "direct triangular component." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "2d2830ab", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-01T03:01:25.161261Z", + "iopub.status.busy": "2026-09-01T03:01:25.161058Z", + "iopub.status.idle": "2026-09-01T03:01:25.170887Z", + "shell.execute_reply": "2026-09-01T03:01:25.169957Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mixture result: [-1.62756 2.43431]\n", + "recursive composed result: [-1.62756]\n" + ] + } + ], + "source": [ + "inner = Kumaraswamy(DigitalNetB2(1, seed=51), a=2.0, b=5.0)\n", + "composed = Gaussian(inner, mean=-1.0, covariance=0.6)\n", + "direct = Triangular(DigitalNetB2(1, seed=52), c=0.6, loc=1.0, scale=2.0)\n", + "composed_mixture = Mixture(\n", + " DigitalNetB2(2, seed=49), [composed, direct], [0.5, 0.5]\n", + ")\n", + "\n", + "probe = np.array([[0.2, 0.2], [0.8, 0.8]])\n", + "probe_result = composed_mixture._transform(probe)\n", + "recursive_result = composed._jacobian_transform_r(\n", + " probe[:1, 1:], return_weights=False\n", + ")\n", + "final_transform_only = composed._transform(probe[:1, 1:])\n", + "\n", + "np.testing.assert_allclose(probe_result[:1], recursive_result)\n", + "assert not np.allclose(recursive_result, final_transform_only)\n", + "print(\"mixture result:\", np.round(probe_result[:, 0], 5))\n", + "print(\"recursive composed result:\", np.round(recursive_result[:, 0], 5))" + ] + }, + { + "cell_type": "markdown", + "id": "5753d733", + "metadata": {}, + "source": [ + "## 11. Replicated sampling\n", + "\n", + "Replications add leading axes but do not change the selector convention. The\n", + "implementation flattens the leading axes for dispatch and restores them after\n", + "each selected component has been transformed." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e206ff5e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-01T03:01:25.174283Z", + "iopub.status.busy": "2026-09-01T03:01:25.174012Z", + "iopub.status.idle": "2026-09-01T03:01:25.180561Z", + "shell.execute_reply": "2026-09-01T03:01:25.179508Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "replicated output shape: (3, 32, 1)\n" + ] + } + ], + "source": [ + "replicated = Mixture(\n", + " DigitalNetB2(2, seed=61, replications=3),\n", + " heterogeneous_components,\n", + " heterogeneous_probabilities,\n", + ")\n", + "replicated_samples = replicated(32)\n", + "\n", + "assert replicated_samples.shape == (3, 32, 1)\n", + "print(\"replicated output shape:\", replicated_samples.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "a1945e3f", + "metadata": {}, + "source": [ + "## 12. Scope and limitations\n", + "\n", + "- Every component must have the same output dimension, and the outer sampler\n", + " must have exactly one extra coordinate.\n", + "- Probabilities must be finite, strictly positive, and sum to one.\n", + "- The reported `range` is a coordinate-wise bounding box; disconnected\n", + " component supports may make that box wider than the actual union.\n", + "- `_weight(x)` is the probability-weighted sum of component weights. It is only\n", + " as meaningful as those component weights. In particular, a distribution with\n", + " a point mass, such as `ZeroInflatedExpUniform`, is not an ordinary smooth\n", + " density with respect to Lebesgue measure; the sampling demonstration above\n", + " therefore treats its atom separately and does not draw a false density curve.\n", + "- Spawning preserves the component dimension and creates a new outer sampler;\n", + " component objects are shared because their attached samplers are not used by\n", + " mixture dispatch." + ] + }, + { + "cell_type": "markdown", + "id": "87abdc75", + "metadata": {}, + "source": [ + "## 13. Summary\n", + "\n", + "`Mixture` adds one selector coordinate around existing `TrueMeasure` behavior.\n", + "It preserves sample order and leading replication axes, supports heterogeneous\n", + "and multidimensional components, follows composed transform chains, and forms\n", + "weights by the usual probability-weighted sum. The examples deliberately span\n", + "bell-shaped, zero-inflated, bounded skewed, heavy-tailed, triangular, composed,\n", + "and multivariate behavior rather than treating the feature as only a Gaussian\n", + "mixture utility." + ] + } + ], + "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.13.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/api/true_measures.md b/docs/api/true_measures.md index 581a1e405..4e2374df0 100644 --- a/docs/api/true_measures.md +++ b/docs/api/true_measures.md @@ -24,6 +24,10 @@ jupyter: ::: qmcpy.true_measure.product_measure.ProductMeasure +## `Mixture` + +::: qmcpy.true_measure.mixture.Mixture + ## `StudentT` ::: qmcpy.true_measure.student_t.StudentT diff --git a/mkdocs.yml b/mkdocs.yml index 792731c47..9a01029b0 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -77,6 +77,7 @@ nav: - Some True Measures: demos/some_true_measures.ipynb - SciPyWrapper dependence and Custom distributions: demos/scipywrapper_dependence_custom/scipywrapper_demo.ipynb - ProductMeasure: demos/product_measure.ipynb + - Mixed Distributions: demos/mixed_distributions.ipynb - Acceptance-Rejection Sampling: demos/acceptance_rejection.ipynb - Copula TrueMeasure Examples: demos/copula_examples.ipynb - For Developers: diff --git a/qmcpy/true_measure/__init__.py b/qmcpy/true_measure/__init__.py index 429da4380..30484b7e4 100644 --- a/qmcpy/true_measure/__init__.py +++ b/qmcpy/true_measure/__init__.py @@ -14,6 +14,7 @@ from .johnsons_su import JohnsonsSU from .scipy_wrapper import SciPyWrapper from .matern_gp import MaternGP +from .mixture import Mixture from .student_t import StudentT from .student_t_copula import StudentTCopula from .uniform_triangle import UniformTriangle diff --git a/qmcpy/true_measure/mixture.py b/qmcpy/true_measure/mixture.py new file mode 100644 index 000000000..f1e3db19a --- /dev/null +++ b/qmcpy/true_measure/mixture.py @@ -0,0 +1,185 @@ +import numpy as np + +from .abstract_true_measure import AbstractTrueMeasure +from ..discrete_distribution.abstract_discrete_distribution import ( + AbstractDiscreteDistribution, +) +from ..util import DimensionError, ParameterError + + +class Mixture(AbstractTrueMeasure): + r"""Mixture of true measures with fixed component probabilities. + + A sample ``u`` has one more coordinate than the mixture output. The first + coordinate selects a component according to ``probabilities``; the + remaining coordinates are transformed by that component. + + The samplers attached to the component true measures are not sampled. + Components provide their full recursive transform and weight behavior. + For an importance-sampling composition, the caller remains responsible for + ensuring that the component's induced sampling distribution is appropriate + for the intended mixture. + + Examples: + >>> from qmcpy import DigitalNetB2, Gaussian, Mixture + >>> components = [ + ... Gaussian(DigitalNetB2(1, seed=11), mean=-2), + ... Gaussian(DigitalNetB2(1, seed=13), mean=2), + ... ] + >>> mixture = Mixture(DigitalNetB2(2, seed=7), components, [0.3, 0.7]) + >>> mixture(4).shape + (4, 1) + """ + + def __init__(self, sampler, components, probabilities): + """ + Args: + sampler (AbstractDiscreteDistribution): Standard-uniform sampler + whose dimension is one greater than the component dimension. + components (list or tuple of AbstractTrueMeasure): True measures + with a common output dimension. + probabilities (array-like): Positive component probabilities that + sum to one. + """ + if not isinstance(components, (list, tuple)) or len(components) == 0: + raise ParameterError("Mixture requires a nonempty list of components.") + if not all( + isinstance(component, AbstractTrueMeasure) for component in components + ): + raise ParameterError( + "Each Mixture component must be an AbstractTrueMeasure instance." + ) + if not isinstance(sampler, AbstractDiscreteDistribution): + raise ParameterError( + "Mixture sampler must be an AbstractDiscreteDistribution." + ) + + try: + probabilities = np.asarray(probabilities, dtype=float) + except (TypeError, ValueError) as error: + raise ParameterError("Mixture probabilities must be numeric.") from error + if probabilities.ndim != 1 or len(probabilities) != len(components): + raise ParameterError( + "Mixture requires exactly one probability per component." + ) + if not np.all(np.isfinite(probabilities)) or not np.all(probabilities > 0): + raise ParameterError("Mixture probabilities must be positive and finite.") + if not np.isclose(probabilities.sum(), 1.0, rtol=1e-12, atol=1e-12): + raise ParameterError("Mixture probabilities must sum to 1.") + + component_dimension = components[0].d + if any(component.d != component_dimension for component in components[1:]): + raise DimensionError( + "All Mixture components must have the same output dimension." + ) + if sampler.d != component_dimension + 1: + raise DimensionError( + "Mixture sampler dimension must equal the component dimension plus " + f"one ({sampler.d} != {component_dimension + 1})." + ) + + self.parameters = ["components", "probabilities"] + self.components = list(components) + self.probabilities = self._read_only_array(probabilities) + self._cumulative_probabilities = np.cumsum(self.probabilities) + self._cumulative_probabilities[-1] = 1.0 + + self.domain = np.array([[0.0, 1.0]]) + self._parse_sampler(sampler) + self.d = component_dimension + self.range = self._mixture_range() + super(Mixture, self).__init__() + + @staticmethod + def _expanded_range(component): + bounds = np.asarray(component.range) + if bounds.shape == (1, 2): + return np.tile(bounds, (component.d, 1)) + if bounds.shape == (component.d, 2): + return bounds + raise DimensionError( + "Mixture component range must have shape (1, 2) or " + f"({component.d}, 2)." + ) + + def _mixture_range(self): + ranges = np.stack( + [self._expanded_range(component) for component in self.components] + ) + return np.column_stack( + [ranges[..., 0].min(axis=0), ranges[..., 1].max(axis=0)] + ) + + def _transform(self, x): + x = np.asarray(x, dtype=float) + sampler_dimension = self.d + 1 + if x.ndim == 0 or x.shape[-1] != sampler_dimension: + received = None if x.ndim == 0 else x.shape[-1] + raise DimensionError( + f"Mixture expected last axis {sampler_dimension}, got {received}." + ) + + leading_shape = x.shape[:-1] + flat_x = x.reshape(-1, sampler_dimension) + selections = np.searchsorted( + self._cumulative_probabilities, flat_x[:, 0], side="left" + ) + selections = np.minimum(selections, len(self.components) - 1) + transformed = np.empty((len(flat_x), self.d), dtype=float) + + for component_index, component in enumerate(self.components): + selected = selections == component_index + if np.any(selected): + transformed[selected] = component._jacobian_transform_r( + flat_x[selected, 1:], return_weights=False + ) + + return transformed.reshape(*leading_shape, self.d) + + def _weight(self, x): + x = np.asarray(x, dtype=float) + if x.ndim == 0 or x.shape[-1] != self.d: + received = None if x.ndim == 0 else x.shape[-1] + raise DimensionError( + f"Mixture expected last axis {self.d}, got {received}." + ) + + weight = np.zeros(x.shape[:-1], dtype=float) + for probability, component in zip(self.probabilities, self.components): + weight += probability * component._weight(x) + return weight + + def spawn(self, s=1, dimensions=None): + """Spawn mixtures with new outer samplers and the same components. + + Mixture components have fixed output dimensions, so only the current + output dimension is supported. The spawned outer samplers retain the + required extra selector coordinate. + """ + s = int(s) + if s <= 0: + raise ParameterError("Must spawn s>0 instances") + if dimensions is None: + output_dimensions = np.tile(self.d, s) + elif isinstance(dimensions, (list, tuple, np.ndarray)): + output_dimensions = np.array(dimensions, dtype=int) + else: + output_dimensions = np.tile(dimensions, s) + if not (output_dimensions.ndim == 1 and len(output_dimensions) == s): + raise ParameterError("dimensions must be a length s np.ndarray") + if np.any(output_dimensions != self.d): + raise DimensionError( + "Mixture spawning currently preserves the component dimension." + ) + + sampler_spawns = self.discrete_distrib.spawn( + s=s, dimensions=np.tile(self.d + 1, s) + ) + return [self._spawn(sampler, sampler.d) for sampler in sampler_spawns] + + def _spawn(self, sampler, dimension): + if dimension != self.d + 1: + raise DimensionError( + "Mixture spawning currently preserves the component dimension." + ) + return Mixture(sampler, self.components, self.probabilities) diff --git a/test/booktests/tb_mixed_distributions.py b/test/booktests/tb_mixed_distributions.py new file mode 100644 index 000000000..92acb784a --- /dev/null +++ b/test/booktests/tb_mixed_distributions.py @@ -0,0 +1,20 @@ +import unittest + +from testbook import testbook + +from __init__ import TB_TIMEOUT, BaseNotebookTest + + +class NotebookTests(BaseNotebookTest): + + @testbook( + "../../demos/mixed_distributions.ipynb", + execute=True, + timeout=TB_TIMEOUT, + ) + def test_mixed_distributions_notebook(self, tb): + pass + + +if __name__ == "__main__": + unittest.main() diff --git a/test/test_mixed_distributions.py b/test/test_mixed_distributions.py new file mode 100644 index 000000000..5d8ea5b5a --- /dev/null +++ b/test/test_mixed_distributions.py @@ -0,0 +1,280 @@ +import numpy as np +import pytest + +from qmcpy import ( + AbstractTrueMeasure, + DigitalNetB2, + Gaussian, + Kumaraswamy, + Mixture, +) +from qmcpy.util import DimensionError, MethodImplementationError, ParameterError + + +class TransformOnlyMeasure(AbstractTrueMeasure): + def __init__(self, sampler): + self.parameters = [] + self.domain = np.array([[0.0, 1.0]]) + self.range = np.array([[0.0, 1.0]]) + self._parse_sampler(sampler) + super(TransformOnlyMeasure, self).__init__() + + def _transform(self, x): + return x + + +def gaussian_component(dimension, mean): + return Gaussian( + DigitalNetB2(dimension, seed=17), + mean=mean, + covariance=np.eye(dimension), + ) + + +def test_two_component_gaussian_mixture_shape(): + components = [gaussian_component(1, -2.0), gaussian_component(1, 3.0)] + mixture = Mixture(DigitalNetB2(2, seed=7), components, [0.3, 0.7]) + + samples = mixture(16) + + assert mixture.d == 1 + assert mixture.discrete_distrib.d == 2 + assert samples.shape == (16, 1) + + +def test_component_selection_at_cumulative_boundaries_preserves_order(): + components = [gaussian_component(1, -2.0), gaussian_component(1, 3.0)] + mixture = Mixture(DigitalNetB2(2, seed=7), components, [0.3, 0.7]) + just_above_boundary = np.nextafter(0.3, 1.0) + u = np.array( + [ + [0.0, 0.5], + [0.9, 0.5], + [0.3, 0.5], + [just_above_boundary, 0.5], + [0.1, 0.5], + [1.0, 0.5], + ] + ) + + samples = mixture._transform(u) + + np.testing.assert_allclose( + samples[:, 0], [-2.0, 3.0, -2.0, 3.0, -2.0, 3.0] + ) + + +def test_composed_component_applies_full_recursive_transform(): + inner = Kumaraswamy(DigitalNetB2(1, seed=19), a=2.0, b=3.0) + composed = Gaussian(inner, mean=-2.0, covariance=1.0) + direct = gaussian_component(1, 3.0) + mixture = Mixture(DigitalNetB2(2, seed=7), [composed, direct], [0.5, 0.5]) + u = np.array([[0.25, 0.2], [0.75, 0.8]]) + + samples = mixture._transform(u) + expected_composed = composed._transform(inner._transform(u[:1, 1:])) + expected_direct = direct._transform(u[1:, 1:]) + + np.testing.assert_allclose(samples[:1], expected_composed) + np.testing.assert_allclose(samples[1:], expected_direct) + assert not np.allclose(expected_composed, composed._transform(u[:1, 1:])) + + +def test_multiple_components(): + components = [ + gaussian_component(1, -4.0), + gaussian_component(1, 0.0), + gaussian_component(1, 5.0), + ] + mixture = Mixture(DigitalNetB2(2, seed=7), components, [0.2, 0.3, 0.5]) + u = np.array([[0.2, 0.5], [0.4, 0.5], [0.5, 0.5], [0.8, 0.5]]) + + samples = mixture._transform(u) + + np.testing.assert_allclose(samples[:, 0], [-4.0, 0.0, 0.0, 5.0]) + + +def test_one_component_mixture_is_valid(): + component = gaussian_component(1, 1.5) + mixture = Mixture(DigitalNetB2(2, seed=7), [component], [1.0]) + u = np.array([[0.0, 0.5], [0.4, 0.5], [1.0, 0.5]]) + + samples = mixture._transform(u) + + assert mixture(4).shape == (4, 1) + np.testing.assert_allclose(samples[:, 0], 1.5) + + +@pytest.mark.parametrize( + "probabilities", + [[0.0, 1.0], [-0.1, 1.1], [np.nan, np.nan], [np.inf, 0.5]], +) +def test_invalid_probabilities(probabilities): + components = [gaussian_component(1, 0.0), gaussian_component(1, 1.0)] + + with pytest.raises(ParameterError, match="positive and finite"): + Mixture(DigitalNetB2(2, seed=7), components, probabilities) + + +def test_probabilities_must_sum_to_one(): + components = [gaussian_component(1, 0.0), gaussian_component(1, 1.0)] + + with pytest.raises(ParameterError, match="sum to 1"): + Mixture(DigitalNetB2(2, seed=7), components, [0.2, 0.7]) + + +def test_number_of_probabilities_must_match_components(): + components = [gaussian_component(1, 0.0), gaussian_component(1, 1.0)] + + with pytest.raises(ParameterError, match="one probability per component"): + Mixture(DigitalNetB2(2, seed=7), components, [1.0]) + + +def test_requires_at_least_one_component(): + with pytest.raises(ParameterError, match="nonempty list of components"): + Mixture(DigitalNetB2(2, seed=7), [], []) + + +def test_components_must_be_true_measures(): + components = [gaussian_component(1, 0.0), object()] + + with pytest.raises(ParameterError, match="AbstractTrueMeasure"): + Mixture(DigitalNetB2(2, seed=7), components, [0.5, 0.5]) + + +def test_sampler_must_be_discrete_distribution(): + components = [gaussian_component(1, 0.0)] + + with pytest.raises(ParameterError, match="AbstractDiscreteDistribution"): + Mixture(object(), components, [1.0]) + + +def test_probabilities_must_be_numeric(): + components = [gaussian_component(1, 0.0), gaussian_component(1, 1.0)] + + with pytest.raises(ParameterError, match="numeric"): + Mixture(DigitalNetB2(2, seed=7), components, ["left", "right"]) + + +def test_probabilities_must_be_one_dimensional(): + components = [gaussian_component(1, 0.0), gaussian_component(1, 1.0)] + + with pytest.raises(ParameterError, match="one probability per component"): + Mixture(DigitalNetB2(2, seed=7), components, [[0.5, 0.5]]) + + +def test_component_dimensions_must_match(): + components = [gaussian_component(1, 0.0), gaussian_component(2, [0.0, 1.0])] + + with pytest.raises(DimensionError, match="same output dimension"): + Mixture(DigitalNetB2(2, seed=7), components, [0.5, 0.5]) + + +def test_sampler_dimension_must_be_component_dimension_plus_one(): + components = [gaussian_component(1, 0.0), gaussian_component(1, 1.0)] + + with pytest.raises(DimensionError, match="component dimension plus one"): + Mixture(DigitalNetB2(1, seed=7), components, [0.5, 0.5]) + + +def test_transform_input_dimension_is_validated(): + mixture = Mixture( + DigitalNetB2(2, seed=7), + [gaussian_component(1, 0.0)], + [1.0], + ) + + with pytest.raises(DimensionError, match="expected last axis 2"): + mixture._transform(np.zeros((3, 1))) + + +def test_weight_input_dimension_is_validated(): + mixture = Mixture( + DigitalNetB2(2, seed=7), + [gaussian_component(1, 0.0)], + [1.0], + ) + + with pytest.raises(DimensionError, match="expected last axis 1"): + mixture._weight(np.zeros((3, 2))) + + +def test_weight_is_weighted_sum_of_component_weights(): + components = [gaussian_component(1, -1.0), gaussian_component(1, 2.0)] + probabilities = np.array([0.3, 0.7]) + mixture = Mixture(DigitalNetB2(2, seed=7), components, probabilities) + x = np.array([[-2.0], [0.0], [1.5], [4.0]]) + + expected = sum( + probability * component._weight(x) + for probability, component in zip(probabilities, components) + ) + + np.testing.assert_allclose(mixture._weight(x), expected) + + +def test_component_weight_failure_propagates(): + transform_only = TransformOnlyMeasure(DigitalNetB2(1, seed=23)) + mixture = Mixture( + DigitalNetB2(2, seed=7), + [gaussian_component(1, 0.0), transform_only], + [0.5, 0.5], + ) + + with pytest.raises(MethodImplementationError, match="TransformOnlyMeasure"): + mixture._weight(np.array([[0.5]])) + + +def test_spawn_replaces_outer_sampler_and_preserves_components(): + components = [gaussian_component(1, -2.0), gaussian_component(1, 3.0)] + mixture = Mixture(DigitalNetB2(2, seed=7), components, [0.3, 0.7]) + + spawned = mixture.spawn(s=2) + explicit_same_dimension = mixture.spawn(s=1, dimensions=[1])[0] + + for child in spawned + [explicit_same_dimension]: + assert isinstance(child, Mixture) + assert child.d == 1 + assert child.discrete_distrib.d == 2 + assert child.discrete_distrib is not mixture.discrete_distrib + assert all( + child_component is parent_component + for child_component, parent_component in zip(child.components, components) + ) + assert child(4).shape == (4, 1) + + with pytest.raises(DimensionError, match="preserves the component dimension"): + mixture.spawn(s=1, dimensions=2) + + +def test_spawn_validates_count_and_dimensions_length(): + mixture = Mixture( + DigitalNetB2(2, seed=7), + [gaussian_component(1, 0.0)], + [1.0], + ) + + with pytest.raises(ParameterError, match="s>0"): + mixture.spawn(s=0) + with pytest.raises(ParameterError, match="length s"): + mixture.spawn(s=2, dimensions=[1]) + + +def test_replicated_sampler_shape_and_selection(): + components = [gaussian_component(1, -2.0), gaussian_component(1, 3.0)] + mixture = Mixture( + DigitalNetB2(2, seed=7, replications=3), components, [0.3, 0.7] + ) + + samples = mixture(8) + manual_u = np.array( + [ + [[0.1, 0.5], [0.9, 0.5]], + [[0.3, 0.5], [np.nextafter(0.3, 1.0), 0.5]], + ] + ) + manual_samples = mixture._transform(manual_u) + + assert samples.shape == (3, 8, 1) + assert manual_samples.shape == (2, 2, 1) + np.testing.assert_allclose(manual_samples[..., 0], [[-2.0, 3.0], [-2.0, 3.0]]) From 9ff4041a5b03c78c9d1be6e249e4612b26d2c355 Mon Sep 17 00:00:00 2001 From: sou-cheng-choi Date: Fri, 4 Sep 2026 20:41:33 +0800 Subject: [PATCH 2/4] Better format --- demos/mixed_distributions.ipynb | 58 +++++++------------------------- test/test_mixed_distributions.py | 8 +---- 2 files changed, 13 insertions(+), 53 deletions(-) diff --git a/demos/mixed_distributions.ipynb b/demos/mixed_distributions.ipynb index f1f7ee69e..5f901e4f7 100644 --- a/demos/mixed_distributions.ipynb +++ b/demos/mixed_distributions.ipynb @@ -25,9 +25,7 @@ "\\rho_{\\mathrm{mix}}(x) = \\sum_{j=0}^{s-1} p_j\\rho_j(x).\n", "$$\n", "\n", - "The measure-level definition also covers components with point masses, which\n", - "need not have an ordinary smooth density. This notebook focuses on sampling\n", - "and on what the extra selector coordinate means in practice." + "The measure-level definition also covers components with point masses, which need not have an ordinary smooth density. This notebook focuses on sampling and on what the extra selector coordinate means in practice." ] }, { @@ -68,10 +66,7 @@ "source": [ "## 2. What was missing before\n", "\n", - "Individual `TrueMeasure`s already know how to transform standard-uniform\n", - "coordinates and how to evaluate their weights. What was missing was a small\n", - "coordinator that could choose among those existing transforms without\n", - "reimplementing any component distribution." + "Individual `TrueMeasure`s already know how to transform standard-uniform coordinates and how to evaluate their weights. What was missing was a small coordinator that could choose among those existing transforms without reimplementing any component distribution." ] }, { @@ -197,10 +192,7 @@ "source": [ "## 5. Exact boundary behavior\n", "\n", - "`Mixture` uses left-sided cumulative-probability lookup. An exact cumulative\n", - "boundary belongs to the component on its left; the next representable number\n", - "above it belongs to the next component. The endpoints `0` and `1` select the\n", - "first and last components, respectively." + "`Mixture` uses left-sided cumulative-probability lookup. An exact cumulative boundary belongs to the component on its left; the next representable number above it belongs to the next component. The endpoints `0` and `1` select the first and last components, respectively." ] }, { @@ -256,9 +248,7 @@ "source": [ "## 6. Main heterogeneous mixture\n", "\n", - "Now the components are genuinely different: a bell-shaped Gaussian, a\n", - "zero-inflated exponential, and a bounded skewed Kumaraswamy distribution.\n", - "Their selector intervals are `[0, 0.25]`, `(0.25, 0.65]`, and `(0.65, 1]`." + "Now the components are genuinely different: a bell-shaped Gaussian, a zero-inflated exponential, and a bounded skewed Kumaraswamy distribution. Their selector intervals are `[0, 0.25]`, `(0.25, 0.65]`, and `(0.65, 1]`." ] }, { @@ -312,12 +302,7 @@ "source": [ "## 7. Reading the heterogeneous sample\n", "\n", - "The continuous values and the atom at zero require different visual marks.\n", - "The negative bell-shaped cluster comes from the Gaussian, values between zero\n", - "and one combine the bounded Kumaraswamy behavior with positive exponential\n", - "values, and the positive tail comes from the exponential component. The\n", - "histogram below excludes exact zeros. The adjacent bar reports the point-mass\n", - "count rather than pretending that the atom is part of a smooth density." + "The continuous values and the atom at zero require different visual marks. The negative bell-shaped cluster comes from the Gaussian, values between zero and one combine the bounded Kumaraswamy behavior with positive exponential values, and the positive tail comes from the exponential component. The histogram below excludes exact zeros. The adjacent bar reports the point-mass count rather than pretending that the atom is part of a smooth density." ] }, { @@ -506,10 +491,7 @@ "source": [ "## 10. A component may itself be composed\n", "\n", - "Components are reused through their recursive transform, not just their final\n", - "`_transform` method. Here a Kumaraswamy transform feeds a Gaussian transform.\n", - "The first probe point selects that composed component; the second selects a\n", - "direct triangular component." + "Components are reused through their recursive transform, not just their final `_transform` method. Here a Kumaraswamy transform feeds a Gaussian transform. The first probe point selects that composed component; the second selects a direct triangular component." ] }, { @@ -562,9 +544,7 @@ "source": [ "## 11. Replicated sampling\n", "\n", - "Replications add leading axes but do not change the selector convention. The\n", - "implementation flattens the leading axes for dispatch and restores them after\n", - "each selected component has been transformed." + "Replications add leading axes but do not change the selector convention. The implementation flattens the leading axes for dispatch and restores them after each selected component has been transformed." ] }, { @@ -607,19 +587,11 @@ "source": [ "## 12. Scope and limitations\n", "\n", - "- Every component must have the same output dimension, and the outer sampler\n", - " must have exactly one extra coordinate.\n", + "- Every component must have the same output dimension, and the outer sampler must have exactly one extra coordinate.\n", "- Probabilities must be finite, strictly positive, and sum to one.\n", - "- The reported `range` is a coordinate-wise bounding box; disconnected\n", - " component supports may make that box wider than the actual union.\n", - "- `_weight(x)` is the probability-weighted sum of component weights. It is only\n", - " as meaningful as those component weights. In particular, a distribution with\n", - " a point mass, such as `ZeroInflatedExpUniform`, is not an ordinary smooth\n", - " density with respect to Lebesgue measure; the sampling demonstration above\n", - " therefore treats its atom separately and does not draw a false density curve.\n", - "- Spawning preserves the component dimension and creates a new outer sampler;\n", - " component objects are shared because their attached samplers are not used by\n", - " mixture dispatch." + "- The reported `range` is a coordinate-wise bounding box; disconnected component supports may make that box wider than the actual union.\n", + "- `_weight(x)` is the probability-weighted sum of component weights. It is only as meaningful as those component weights. In particular, a distribution with a point mass, such as `ZeroInflatedExpUniform`, is not an ordinary smooth density with respect to Lebesgue measure; the sampling demonstration above therefore treats its atom separately and does not draw a false density curve.\n", + "- Spawning preserves the component dimension and creates a new outer sampler; component objects are shared because their attached samplers are not used by mixture dispatch." ] }, { @@ -629,13 +601,7 @@ "source": [ "## 13. Summary\n", "\n", - "`Mixture` adds one selector coordinate around existing `TrueMeasure` behavior.\n", - "It preserves sample order and leading replication axes, supports heterogeneous\n", - "and multidimensional components, follows composed transform chains, and forms\n", - "weights by the usual probability-weighted sum. The examples deliberately span\n", - "bell-shaped, zero-inflated, bounded skewed, heavy-tailed, triangular, composed,\n", - "and multivariate behavior rather than treating the feature as only a Gaussian\n", - "mixture utility." + "`Mixture` adds one selector coordinate around existing `TrueMeasure` behavior. It preserves sample order and leading replication axes, supports heterogeneous and multidimensional components, follows composed transform chains, and forms weights by the usual probability-weighted sum. The examples deliberately span bell-shaped, zero-inflated, bounded skewed, heavy-tailed, triangular, composed, and multivariate behavior rather than treating the feature as only a Gaussian mixture utility." ] } ], diff --git a/test/test_mixed_distributions.py b/test/test_mixed_distributions.py index 5d8ea5b5a..e75128fe4 100644 --- a/test/test_mixed_distributions.py +++ b/test/test_mixed_distributions.py @@ -1,13 +1,7 @@ import numpy as np import pytest -from qmcpy import ( - AbstractTrueMeasure, - DigitalNetB2, - Gaussian, - Kumaraswamy, - Mixture, -) +from qmcpy import AbstractTrueMeasure, DigitalNetB2, Gaussian, Kumaraswamy, Mixture from qmcpy.util import DimensionError, MethodImplementationError, ParameterError From b98be7d5866a4341447624b31fbd005e200dc057 Mon Sep 17 00:00:00 2001 From: sou-cheng-choi Date: Fri, 4 Sep 2026 21:43:07 +0800 Subject: [PATCH 3/4] Insert Colab badge into new demo --- demos/mixed_distributions.ipynb | 25 +++++++++++++++++++++++++ scripts/colab_notebooks_manifest.json | 1 + 2 files changed, 26 insertions(+) diff --git a/demos/mixed_distributions.ipynb b/demos/mixed_distributions.ipynb index 5f901e4f7..e8b0ba25d 100644 --- a/demos/mixed_distributions.ipynb +++ b/demos/mixed_distributions.ipynb @@ -28,6 +28,31 @@ "The measure-level definition also covers components with point masses, which need not have an ordinary smooth density. This notebook focuses on sampling and on what the extra selector coordinate means in practice." ] }, + { + "cell_type": "markdown", + "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.ipynb)" + ], + "id": "b008436d" + }, + { + "cell_type": "code", + "execution_count": null, + "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", + " !pip install -q qmcpy\n" + ], + "id": "88ea2ae6" + }, { "cell_type": "code", "execution_count": 1, diff --git a/scripts/colab_notebooks_manifest.json b/scripts/colab_notebooks_manifest.json index ed62ba8be..1864ce102 100644 --- a/scripts/colab_notebooks_manifest.json +++ b/scripts/colab_notebooks_manifest.json @@ -21,6 +21,7 @@ "demos/lattice_random_generator.ipynb", "demos/lebesgue_integration.ipynb", "demos/linear-scrambled-halton.ipynb", + "demos/mixed_distributions.ipynb", "demos/nei_demo.ipynb", "demos/plot_proj_function.ipynb", "demos/pricing_options.ipynb", From b6d48ba6bc70bfaa52a5b3b218d1dbc548a1fb64 Mon Sep 17 00:00:00 2001 From: Laasya-73 <77721581+Laasya-73@users.noreply.github.com> Date: Fri, 4 Sep 2026 18:08:18 -0500 Subject: [PATCH 4/4] Expand mixed distribution examples and tests --- demos/mixed_distributions.ipynb | 861 ++++++++++++++++++------------- test/test_mixed_distributions.py | 108 +++- 2 files changed, 595 insertions(+), 374 deletions(-) diff --git a/demos/mixed_distributions.ipynb b/demos/mixed_distributions.ipynb index e8b0ba25d..f7f40ff85 100644 --- a/demos/mixed_distributions.ipynb +++ b/demos/mixed_distributions.ipynb @@ -2,43 +2,43 @@ "cells": [ { "cell_type": "markdown", - "id": "d16dd42c", + "id": "mixture-definition", "metadata": {}, "source": [ "# Mixed distributions in QMCPy\n", "\n", - "## 1. Problem statement\n", - "\n", - "A mixed distribution combines component probability measures\n", - "$P_0,\\ldots,P_{s-1}$ as\n", + "## 1. Mixed distributions\n", "\n", + "Mixtures describe populations or systems with different regimes: normal and\n", + "stressed markets, or ordinary and severe insurance claims. If regime $j$ has\n", + "probability $p_j$ and distribution $P_j$, then\n", "$$\n", - "P_{\\mathrm{mix}} = \\sum_{j=0}^{s-1} p_j P_j,\n", - "\\qquad p_j > 0,\n", - "\\qquad \\sum_{j=0}^{s-1} p_j = 1.\n", + "P_{\\mathrm{mix}}=\\sum_{j=0}^{s-1}p_jP_j,\n", + "\\qquad p_j>0,\\qquad \\sum_j p_j=1.\n", "$$\n", - "\n", - "When the components have densities or weights $\\rho_j$ with respect to a\n", - "common reference measure, the corresponding mixture is\n", - "\n", + "When the components have densities with respect to a common reference measure,\n", "$$\n", - "\\rho_{\\mathrm{mix}}(x) = \\sum_{j=0}^{s-1} p_j\\rho_j(x).\n", + "\\rho_{\\mathrm{mix}}(x)=\\sum_j p_j\\rho_j(x).\n", "$$\n", "\n", - "The measure-level definition also covers components with point masses, which need not have an ordinary smooth density. This notebook focuses on sampling and on what the extra selector coordinate means in practice." + "QMCPy's `Mixture` samples from this target by choosing a component and reusing\n", + "its transform. After a short explanation of the selector, we use two\n", + "applications to ask why the target mixture matters for an integral, not just\n", + "how to generate its samples." ] }, { "cell_type": "markdown", + "id": "b008436d", "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.ipynb)" - ], - "id": "b008436d" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, + "id": "88ea2ae6", "metadata": {}, "outputs": [], "source": [ @@ -50,35 +50,23 @@ " IN_COLAB = False\n", "if IN_COLAB:\n", " !pip install -q qmcpy\n" - ], - "id": "88ea2ae6" + ] }, { "cell_type": "code", - "execution_count": 1, - "id": "a56b8cb6", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-01T03:01:22.653195Z", - "iopub.status.busy": "2026-09-01T03:01:22.652677Z", - "iopub.status.idle": "2026-09-01T03:01:24.071412Z", - "shell.execute_reply": "2026-09-01T03:01:24.070278Z" - } - }, + "execution_count": 2, + "id": "application-imports", + "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", - "from qmcpy import (\n", - " DigitalNetB2,\n", - " Gaussian,\n", - " Kumaraswamy,\n", - " Mixture,\n", - " StudentT,\n", - " Triangular,\n", - " ZeroInflatedExpUniform,\n", - ")\n", + "from scipy.integrate import quad\n", + "from scipy.stats import lognorm, norm\n", + "from IPython.display import Markdown, display\n", + "\n", + "from qmcpy import DigitalNetB2, Gaussian, Mixture, SciPyWrapper\n", "\n", "plt.style.use(\"seaborn-v0_8-whitegrid\")\n", "COLORS = [\"#3366CC\", \"#E67300\", \"#2E8B57\"]" @@ -86,64 +74,37 @@ }, { "cell_type": "markdown", - "id": "7929f26e", - "metadata": {}, - "source": [ - "## 2. What was missing before\n", - "\n", - "Individual `TrueMeasure`s already know how to transform standard-uniform coordinates and how to evaluate their weights. What was missing was a small coordinator that could choose among those existing transforms without reimplementing any component distribution." - ] - }, - { - "cell_type": "markdown", - "id": "d5f10d00", + "id": "selector-mechanics", "metadata": {}, "source": [ - "## 3. The $d+1 \\rightarrow d$ selector transform\n", - "\n", - "For an output in $\\mathbb{R}^d$, `Mixture` consumes\n", - "$u=(u_0,u_1,\\ldots,u_d)\\in[0,1]^{d+1}$. The first coordinate selects component\n", - "$j$ through\n", + "## 2. Sampling a mixture in QMCPy\n", "\n", + "For a $d$-dimensional observation, the outer sampler supplies\n", + "$u=(u_0,u_1,\\ldots,u_d)\\in[0,1]^{d+1}$. The selector $u_0$ chooses component $j$\n", + "using its cumulative probability interval,\n", "$$\n", - "p_0+\\cdots+p_{j-1} < u_0 \\le p_0+\\cdots+p_j,\n", + "\\sum_{k0.3$ chooses the right component." + "One compact example uses one-dimensional Gaussians centered at $-2$ and $2.5$,\n", + "with probabilities $0.3$ and $0.7$. Its outer sampler therefore needs two\n", + "coordinates, but the returned observation has only one." ] }, { "cell_type": "code", - "execution_count": 2, - "id": "51b03ec2", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-01T03:01:24.075080Z", - "iopub.status.busy": "2026-09-01T03:01:24.074740Z", - "iopub.status.idle": "2026-09-01T03:01:24.084040Z", - "shell.execute_reply": "2026-09-01T03:01:24.083194Z" - } - }, + "execution_count": 3, + "id": "selector-samples", + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "outer sampler dimension: 2\n", + "output dimension: 1\n", "mixture sample shape: (2048, 1)\n" ] } @@ -154,84 +115,34 @@ " Gaussian(DigitalNetB2(1, seed=13), mean=2.5, covariance=0.55),\n", "]\n", "intro_probabilities = np.array([0.3, 0.7])\n", - "intro = Mixture(\n", - " DigitalNetB2(2, seed=7), intro_components, intro_probabilities\n", - ")\n", - "\n", - "intro_x = intro(2048)[:, 0]\n", + "intro = Mixture(DigitalNetB2(2, seed=7), intro_components, intro_probabilities)\n", + "intro_x = intro(2048)\n", "\n", - "assert intro.d == 1\n", - "assert intro.discrete_distrib.d == 2\n", - "assert intro_x.shape == (2048,)\n", + "assert intro_x.shape == (2048, 1)\n", "print(\"outer sampler dimension:\", intro.discrete_distrib.d)\n", - "print(\"mixture sample shape: \", intro_x[:, None].shape)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "8240596d", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-01T03:01:24.086386Z", - "iopub.status.busy": "2026-09-01T03:01:24.086193Z", - "iopub.status.idle": "2026-09-01T03:01:24.474101Z", - "shell.execute_reply": "2026-09-01T03:01:24.472986Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, axes = plt.subplots(1, 2, figsize=(10.5, 3.4), layout=\"constrained\")\n", - "\n", - "axes[0].barh(0, 0.3, left=0.0, color=COLORS[0], height=0.5)\n", - "axes[0].barh(0, 0.7, left=0.3, color=COLORS[1], height=0.5)\n", - "axes[0].axvline(0.3, color=\"black\", linewidth=1)\n", - "axes[0].text(0.15, 0, \"component 0\\np = 0.30\", ha=\"center\", va=\"center\", color=\"white\")\n", - "axes[0].text(0.65, 0, \"component 1\\np = 0.70\", ha=\"center\", va=\"center\", color=\"white\")\n", - "axes[0].set(xlim=(0, 1), yticks=[], xlabel=r\"selector $u_0$\", title=\"Selector intervals\")\n", - "\n", - "bins = np.linspace(-4.5, 5.5, 65)\n", - "axes[1].hist(intro_x, bins=bins, color=\"#6A5ACD\", alpha=0.72)\n", - "axes[1].axvline(-2.0, color=COLORS[0], linewidth=1.4, label=\"component means\")\n", - "axes[1].axvline(2.5, color=COLORS[1], linewidth=1.4)\n", - "axes[1].set(xlabel=\"sample value\", ylabel=\"count\", title=\"Resulting sample\")\n", - "axes[1].legend(frameon=False)\n", - "plt.show()" + "print(\"output dimension: \", intro.d)\n", + "print(\"mixture sample shape: \", intro_x.shape)" ] }, { "cell_type": "markdown", - "id": "c2517cab", + "id": "selector-shape-reading", "metadata": {}, "source": [ - "## 5. Exact boundary behavior\n", + "The 2048 two-dimensional uniform inputs become 2048 one-dimensional\n", + "observations: $u_0$ chooses the component and $u_1$ supplies its transform.\n", + "The selector is consumed, not returned. Component 0 owns $[0,0.3]$ and component 1\n", + "owns $(0.3,1]$; the next probe checks the endpoints and the exact shared boundary.\n", "\n", - "`Mixture` uses left-sided cumulative-probability lookup. An exact cumulative boundary belongs to the component on its left; the next representable number above it belongs to the next component. The endpoints `0` and `1` select the first and last components, respectively." + "Only this deterministic boundary probe uses the internal `_transform` method;\n", + "ordinary sampling in both applications uses the public interface." ] }, { "cell_type": "code", "execution_count": 4, "id": "5f8a1081", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-01T03:01:24.477254Z", - "iopub.status.busy": "2026-09-01T03:01:24.477001Z", - "iopub.status.idle": "2026-09-01T03:01:24.483583Z", - "shell.execute_reply": "2026-09-01T03:01:24.482476Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -268,148 +179,186 @@ }, { "cell_type": "markdown", - "id": "aa8ac536", + "id": "selector-boundary-reading", "metadata": {}, "source": [ - "## 6. Main heterogeneous mixture\n", + "Both $u_0=0$ and the exact boundary $u_0=0.3$ select component 0 because the\n", + "cumulative lookup is left-sided. `np.nextafter(0.3, 1.0)`, the smallest\n", + "representable value above that boundary, selects component 1, as does $u_0=1$.\n", + "The fixed second coordinate $u_1=0.5$ maps to each Gaussian's median (its mean),\n", + "so the four results are $-2,-2,2.5,2.5$: no cumulative boundary is ambiguous." + ] + }, + { + "cell_type": "markdown", + "id": "portfolio-introduction", + "metadata": {}, + "source": [ + "## 3. Portfolio downside loss: mixture versus non-mixture sampling\n", + "\n", + "Why sample the mixture directly? This main example compares two\n", + "sampling strategies for the same expected loss, rather than two\n", + "different return models.\n", "\n", - "Now the components are genuinely different: a bell-shaped Gaussian, a zero-inflated exponential, and a bounded skewed Kumaraswamy distribution. Their selector intervals are `[0, 0.25]`, `(0.25, 0.65]`, and `(0.65, 1]`." + "### Target and proposal\n", + "\n", + "Let $X$ be portfolio return, expressed as a fraction. This illustrative model\n", + "has an 85% normal-market regime with mean $+1\\%$ and standard deviation $1.5\\%$,\n", + "and a 15% stress regime with mean $-8\\%$ and standard deviation $3\\%$.\n", + "These parameters are not a calibrated financial model.\n", + "\n", + "The alternative is a single Gaussian proposal $q=\\mathcal{N}(0,0.04^2)$.\n", + "It has support on the whole real line but cannot reproduce both regimes.\n", + "First, compare its density with the target." ] }, { "cell_type": "code", "execution_count": 5, - "id": "9af97f5f", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-01T03:01:24.486037Z", - "iopub.status.busy": "2026-09-01T03:01:24.485806Z", - "iopub.status.idle": "2026-09-01T03:01:24.496767Z", - "shell.execute_reply": "2026-09-01T03:01:24.496032Z" - } - }, + "id": "portfolio-density", + "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "observed total zero fraction: 0.1802\n", - "target total zero fraction: 0.18000000000000002\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "heterogeneous_components = [\n", - " Gaussian(DigitalNetB2(1, seed=21), mean=-2.2, covariance=0.22),\n", - " ZeroInflatedExpUniform(\n", - " DigitalNetB2(1, seed=22), p_zero=0.45, lam=1.2\n", - " ),\n", - " Kumaraswamy(DigitalNetB2(1, seed=23), a=0.7, b=2.8),\n", - "]\n", - "heterogeneous_probabilities = np.array([0.25, 0.40, 0.35])\n", - "heterogeneous = Mixture(\n", - " DigitalNetB2(2, seed=17),\n", - " heterogeneous_components,\n", - " heterogeneous_probabilities,\n", - ")\n", - "\n", - "heterogeneous_x = heterogeneous(4096)[:, 0]\n", - "zero_mask = heterogeneous_x == 0\n", - "\n", - "print(\"observed total zero fraction:\", round(zero_mask.mean(), 4))\n", - "print(\"target total zero fraction: \", 0.40 * 0.45)" + "market_probabilities = np.array([0.85, 0.15])\n", + "market_means = np.array([0.01, -0.08])\n", + "market_sds = np.array([0.015, 0.03])\n", + "proposal_mean, proposal_sd = 0.0, 0.04\n", + "\n", + "\n", + "def market_log_density(y):\n", + " return np.logaddexp(\n", + " np.log(market_probabilities[0])\n", + " + norm.logpdf(y, market_means[0], market_sds[0]),\n", + " np.log(market_probabilities[1])\n", + " + norm.logpdf(y, market_means[1], market_sds[1]),\n", + " )\n", + "\n", + "\n", + "return_grid = np.linspace(-0.20, 0.07, 900)\n", + "fig, ax = plt.subplots(figsize=(8.2, 3.6), layout=\"constrained\")\n", + "ax.plot(return_grid, np.exp(market_log_density(return_grid)),\n", + " color=COLORS[0], label=\"Target mixture density\")\n", + "ax.plot(return_grid, norm.pdf(return_grid, proposal_mean, proposal_sd),\n", + " color=COLORS[1], linestyle=\"--\", label=\"Single-Gaussian proposal density\")\n", + "ax.axvspan(return_grid[0], 0, color=\"grey\", alpha=0.08,\n", + " label=\"Negative returns: positive loss\")\n", + "ax.set(xlabel=\"portfolio return (fraction)\", ylabel=\"density\",\n", + " title=\"Two market regimes versus a single Gaussian proposal\")\n", + "ax.legend(frameon=False)\n", + "plt.show()" ] }, { "cell_type": "markdown", - "id": "31d2c1cf", + "id": "portfolio-density-reading", "metadata": {}, "source": [ - "## 7. Reading the heterogeneous sample\n", + "The target's tall mode near $0.01$ represents normal markets, while its smaller\n", + "mode near $-0.08$ allocates probability to stress returns. The single Gaussian\n", + "spreads its mass around zero and does not match both regions equally well.\n", + "The shaded negative-return region is where the loss is nonzero; the experiment\n", + "below tests the effect of this density mismatch on estimating that loss.\n", "\n", - "The continuous values and the atom at zero require different visual marks. The negative bell-shaped cluster comes from the Gaussian, values between zero and one combine the bounded Kumaraswamy behavior with positive exponential values, and the positive tail comes from the exponential component. The histogram below excludes exact zeros. The adjacent bar reports the point-mass count rather than pretending that the atom is part of a smooth density." + "### Reference expected downside loss\n", + "\n", + "We estimate expected downside loss:\n", + "$$\n", + "g(x)=\\max(-x,0), \\qquad\n", + "I=\\mathbb{E}_{\\rho_{\\mathrm{mix}}}[g(X)]\n", + "=\\int g(x)\\rho_{\\mathrm{mix}}(x)\\,dx.\n", + "$$\n", + "Positive returns contribute zero loss; negative returns contribute their loss\n", + "magnitude. This is expected downside loss over the full distribution, **not**\n", + "the conditional expectation $\\mathbb{E}[-X\\mid X<0]$." ] }, { "cell_type": "code", "execution_count": 6, - "id": "7a7acf9c", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-01T03:01:24.500108Z", - "iopub.status.busy": "2026-09-01T03:01:24.499852Z", - "iopub.status.idle": "2026-09-01T03:01:24.769301Z", - "shell.execute_reply": "2026-09-01T03:01:24.767784Z" - } - }, + "id": "portfolio-reference", + "metadata": {}, "outputs": [ { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "Reference expected downside loss: 0.013932092872\n", + "As a fraction of portfolio value: 1.393209%\n", + "Quadrature estimated absolute error: 6.64e-13\n" + ] } ], "source": [ - "fig, axes = plt.subplots(\n", - " 1, 2, figsize=(10.5, 3.7), gridspec_kw={\"width_ratios\": [3.2, 1]},\n", - " layout=\"constrained\"\n", + "loss_reference, quadrature_error = quad(\n", + " lambda x: (-x) * np.exp(market_log_density(x)),\n", + " -np.inf, 0.0, epsabs=1e-12, epsrel=1e-12,\n", ")\n", - "\n", - "continuous_values = heterogeneous_x[~zero_mask]\n", - "plot_low, plot_high = np.quantile(continuous_values, [0.002, 0.995])\n", - "bins = np.linspace(plot_low, plot_high, 72)\n", - "axes[0].hist(continuous_values, bins=bins, color=\"#6A5ACD\", alpha=0.72)\n", - "axes[0].axvline(0, color=\"black\", linewidth=0.9, linestyle=\"--\")\n", - "axes[0].set(\n", - " xlabel=\"continuous sample value\", ylabel=\"count\",\n", - " title=\"Continuous values (exact zeros excluded)\"\n", - ")\n", - "\n", - "zero_count = int(zero_mask.sum())\n", - "expected_zero_count = len(heterogeneous_x) * 0.40 * 0.45\n", - "axes[1].bar([\"x = 0\"], [zero_count], color=COLORS[1], width=0.55)\n", - "axes[1].axhline(expected_zero_count, color=\"black\", linestyle=\"--\", linewidth=1)\n", - "axes[1].text(0, zero_count, f\" {zero_count}\", ha=\"center\", va=\"bottom\")\n", - "axes[1].set_ylim(0, max(zero_count, expected_zero_count) * 1.18)\n", - "axes[1].set(ylabel=\"count\", title=\"Discrete atom\\n(dashed = expected)\")\n", - "plt.show()" + "assert np.isfinite(loss_reference) and quadrature_error < 1e-10\n", + "print(f\"Reference expected downside loss: {loss_reference:.12f}\")\n", + "print(f\"As a fraction of portfolio value: {100 * loss_reference:.6f}%\")\n", + "print(f\"Quadrature estimated absolute error: {quadrature_error:.2e}\")" ] }, { "cell_type": "markdown", - "id": "73bafcce", + "id": "portfolio-methods", "metadata": {}, "source": [ - "## 8. Another pair: heavy-tailed and bounded\n", + "Quadrature gives $I_{\\mathrm{ref}}\\approx0.01393209$, or an unconditional\n", + "expected downside loss of about $1.3932\\%$ of portfolio value. It integrates\n", + "$(-x)\\rho_{\\mathrm{mix}}(x)$ from $-\\infty$ to zero independently of either\n", + "sampling method, and is used only as the benchmark for estimator error.\n", + "\n", + "### Convergence comparison\n", + "\n", + "Direct sampling uses `Mixture` and averages $g(X)$ without importance weights.\n", + "For the single-Gaussian proposal, correcting the density mismatch gives\n", + "$$\n", + "I=\\mathbb{E}_q\\!\\left[g(Y)\\frac{\\rho_{\\mathrm{mix}}(Y)}{q(Y)}\\right].\n", + "$$\n", + "We evaluate this density ratio in log space without clipping weights.\n", + "\n", + "Both approaches estimate the same expected downside loss. The comparison\n", + "therefore isolates the sampling strategy: direct draws from the target mixture\n", + "versus draws from a single Gaussian proposal corrected with importance weights.\n", "\n", - "This short example mixes a Student $t$ distribution with a bounded triangular\n", - "distribution. The former can generate heavy tails; the latter stays inside its\n", - "finite support and peaks at its mode." + "Each method uses $R=16$ independent LMS-plus-digital-shift randomizations of\n", + "DigitalNetB2, with fixed seeds chosen before the comparison. Within each\n", + "replication, nested prefixes give $n=2^6,\\ldots,2^{14}$ samples, so the two\n", + "methods have equal sample counts; different sizes on a curve are correlated.\n", + "Direct sampling needs two uniform coordinates (selector plus transform),\n", + "whereas the Gaussian proposal needs one. This compares accuracy per sample,\n", + "not equal wall-clock cost.\n", + "\n", + "For each size, we measure\n", + "$$\n", + "\\mathrm{RMSE}(n)=\n", + "\\sqrt{\\frac1R\\sum_{r=1}^R(\\widehat I_{n,r}-I_{\\mathrm{ref}})^2}.\n", + "$$" ] }, { "cell_type": "code", "execution_count": 7, - "id": "4d4bb5b0", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-01T03:01:24.773831Z", - "iopub.status.busy": "2026-09-01T03:01:24.773465Z", - "iopub.status.idle": "2026-09-01T03:01:24.995641Z", - "shell.execute_reply": "2026-09-01T03:01:24.994456Z" - } - }, + "id": "portfolio-convergence", + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -417,67 +366,102 @@ } ], "source": [ - "pair_components = [\n", - " StudentT(\n", - " DigitalNetB2(1, seed=31), loc=[-1.0], shape=[[0.8]], df=3\n", - " ),\n", - " Triangular(\n", - " DigitalNetB2(1, seed=32), c=0.25, loc=1.5, scale=3.0\n", - " ),\n", + "loss_sample_sizes = 2 ** np.arange(6, 15)\n", + "loss_replications = 16\n", + "market_components = [\n", + " Gaussian(\n", + " DigitalNetB2(1, seed=67 + j),\n", + " mean=market_means[j], covariance=market_sds[j] ** 2,\n", + " )\n", + " for j in range(2)\n", "]\n", - "pair_probabilities = np.array([0.55, 0.45])\n", - "pair = Mixture(DigitalNetB2(2, seed=29), pair_components, pair_probabilities)\n", + "direct_market = Mixture(\n", + " DigitalNetB2(2, seed=71, replications=loss_replications, randomize=\"LMS DS\"),\n", + " market_components, market_probabilities,\n", + ")\n", + "single_proposal = Gaussian(\n", + " DigitalNetB2(1, seed=73, replications=loss_replications, randomize=\"LMS DS\"),\n", + " mean=proposal_mean, covariance=proposal_sd ** 2,\n", + ")\n", + "\n", + "# Public sampling: each row is one independently randomized replication.\n", + "market_x = direct_market(int(loss_sample_sizes[-1]))[..., 0]\n", + "proposal_y = single_proposal(int(loss_sample_sizes[-1]))[..., 0]\n", + "assert market_x.shape == proposal_y.shape == (\n", + " loss_replications, loss_sample_sizes[-1]\n", + ")\n", + "assert np.all(np.isfinite(market_x)) and np.all(np.isfinite(proposal_y))\n", + "\n", + "proposal_log_pdf = norm.logpdf(proposal_y, proposal_mean, proposal_sd)\n", + "assert np.all(np.isfinite(proposal_log_pdf))\n", + "importance_weights = np.exp(\n", + " market_log_density(proposal_y) - proposal_log_pdf\n", + ")\n", + "assert np.all(np.isfinite(importance_weights)) and np.all(importance_weights > 0)\n", "\n", - "pair_x = pair(4096)[:, 0]\n", - "pair_low, pair_high = np.quantile(pair_x, [0.004, 0.996])\n", - "pair_bins = np.linspace(pair_low, pair_high, 75)\n", + "direct_loss = np.maximum(-market_x, 0.0)\n", + "weighted_loss = np.maximum(-proposal_y, 0.0) * importance_weights\n", + "assert np.all(np.isfinite(weighted_loss))\n", + "direct_estimates = np.array([\n", + " direct_loss[:, :n].mean(axis=1) for n in loss_sample_sizes\n", + "])\n", + "proposal_estimates = np.array([\n", + " weighted_loss[:, :n].mean(axis=1) for n in loss_sample_sizes\n", + "])\n", + "direct_rmse = np.sqrt(np.mean((direct_estimates - loss_reference) ** 2, axis=1))\n", + "proposal_rmse = np.sqrt(np.mean((proposal_estimates - loss_reference) ** 2, axis=1))\n", "\n", - "fig, ax = plt.subplots(figsize=(8.2, 3.4), layout=\"constrained\")\n", - "ax.hist(pair_x, bins=pair_bins, color=\"#6A5ACD\", alpha=0.72, label=\"mixture sample\")\n", - "ax.axvspan(1.5, 4.5, color=COLORS[1], alpha=0.12, label=\"triangular support\")\n", - "ax.set(xlabel=\"sample value\", ylabel=\"count\", title=\"Different families, one mixture\")\n", + "assert direct_estimates.shape == proposal_estimates.shape == (\n", + " len(loss_sample_sizes), loss_replications\n", + ")\n", + "assert direct_rmse.shape == proposal_rmse.shape == loss_sample_sizes.shape\n", + "assert np.all(np.isfinite(direct_rmse)) and np.all(direct_rmse >= 0)\n", + "assert np.all(np.isfinite(proposal_rmse)) and np.all(proposal_rmse >= 0)\n", + "\n", + "fig, ax = plt.subplots(figsize=(8.2, 3.6), layout=\"constrained\")\n", + "ax.loglog(loss_sample_sizes, direct_rmse, \"o-\", color=COLORS[0],\n", + " label=\"Direct Mixture QMC\")\n", + "ax.loglog(loss_sample_sizes, proposal_rmse, \"s--\", color=COLORS[1],\n", + " label=\"Single-Gaussian Proposal QMC\")\n", + "ax.set(xlabel=\"sample size n (per replication)\", ylabel=\"RMSE\",\n", + " title=\"Expected downside loss: 16 randomized QMC replications\")\n", "ax.legend(frameon=False)\n", "plt.show()" ] }, { "cell_type": "markdown", - "id": "3e9a370b", + "id": "portfolio-convergence-reading", "metadata": {}, "source": [ - "## 9. Multidimensional output\n", - "\n", - "For $d=2$, the outer sampler has three coordinates: one selector and two\n", - "coordinates for the chosen component. The returned sample still has only two\n", - "coordinates. A compact Gaussian example makes the two clusters easy to inspect." + "Direct mixture sampling has lower empirical RMSE at every tested sample size\n", + "in this experiment. Both curves estimate the same expected downside loss,\n", + "but direct samples follow the target regime probabilities, whereas proposal\n", + "samples compensate for the density mismatch with variable importance weights.\n", + "Those weights can increase estimator variability, particularly for stress\n", + "returns that the proposal undersamples. The curves quantify an empirical\n", + "accuracy difference, not an asserted asymptotic convergence order; with only\n", + "16 replications, the measured RMSE itself has sampling variability." ] }, { "cell_type": "code", "execution_count": 8, - "id": "a37fbccd", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-01T03:01:24.998149Z", - "iopub.status.busy": "2026-09-01T03:01:24.997899Z", - "iopub.status.idle": "2026-09-01T03:01:25.158941Z", - "shell.execute_reply": "2026-09-01T03:01:25.157963Z" - } - }, + "id": "portfolio-results-table", + "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "outer sampler dimension: 3\n", - "output sample shape: (2048, 2)\n" - ] - }, { "data": { - "image/png": "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", + "text/markdown": [ + "| n | Direct Mixture RMSE | Single Proposal RMSE | Proposal / Mixture |\n", + "| ---: | ---: | ---: | ---: |\n", + "| 256 | 1.859824e-04 | 1.057574e-03 | 5.69 |\n", + "| 1024 | 4.471536e-05 | 7.475718e-04 | 16.72 |\n", + "| 4096 | 1.113080e-05 | 1.060660e-04 | 9.53 |\n", + "| 16384 | 2.587320e-06 | 2.127985e-05 | 8.22 |" + ], "text/plain": [ - "
" + "" ] }, "metadata": {}, @@ -485,156 +469,291 @@ } ], "source": [ - "components_2d = [\n", - " Gaussian(\n", - " DigitalNetB2(2, seed=41), mean=[-1.5, -0.8],\n", - " covariance=[[0.45, 0.22], [0.22, 0.35]]\n", - " ),\n", - " Gaussian(\n", - " DigitalNetB2(2, seed=42), mean=[1.4, 1.1],\n", - " covariance=[[0.35, -0.12], [-0.12, 0.5]]\n", - " ),\n", + "representative_sizes = [256, 1024, 4096, 16384]\n", + "table_lines = [\n", + " \"| n | Direct Mixture RMSE | Single Proposal RMSE | Proposal / Mixture |\",\n", + " \"| ---: | ---: | ---: | ---: |\",\n", "]\n", - "mixture_2d = Mixture(DigitalNetB2(3, seed=39), components_2d, [0.4, 0.6])\n", - "x_2d = mixture_2d(2048)\n", - "\n", - "assert mixture_2d.discrete_distrib.d == 3\n", - "assert x_2d.shape == (2048, 2)\n", - "print(\"outer sampler dimension:\", mixture_2d.discrete_distrib.d)\n", - "print(\"output sample shape: \", x_2d.shape)\n", - "\n", - "fig, ax = plt.subplots(figsize=(5.8, 4.5), layout=\"constrained\")\n", - "ax.scatter(x_2d[:, 0], x_2d[:, 1], s=9, alpha=0.45, color=\"#6A5ACD\")\n", - "ax.set(xlabel=r\"$x_1$\", ylabel=r\"$x_2$\", title=\"Two-dimensional mixture output\")\n", - "plt.show()" + "for n in representative_sizes:\n", + " i = int(np.flatnonzero(loss_sample_sizes == n)[0])\n", + " table_lines.append(\n", + " f\"| {n} | {direct_rmse[i]:.6e} | {proposal_rmse[i]:.6e} | \"\n", + " f\"{proposal_rmse[i] / direct_rmse[i]:.2f} |\"\n", + " )\n", + "display(Markdown(\"\\n\".join(table_lines)))" + ] + }, + { + "cell_type": "markdown", + "id": "portfolio-table-reading", + "metadata": {}, + "source": [ + "The last column divides the single-Gaussian proposal RMSE by the direct-mixture\n", + "RMSE for the same expected downside loss. The proposal's RMSE is **16.72 times**\n", + "as large at $n=1024$ and **8.22 times** as large at $n=16384$, quantifying its\n", + "lower accuracy per sample in this experiment. This is not a claim that mixture sampling always wins: a proposal\n", + "tailored to the loss integrand, or another integration problem, can behave\n", + "differently." ] }, { "cell_type": "markdown", - "id": "a85b4b5c", + "id": "insurance-introduction", "metadata": {}, "source": [ - "## 10. A component may itself be composed\n", + "## 4. Insurance stop-loss\n", + "\n", + "### Claim model and retention\n", + "\n", + "Let $X>0$ be claim severity, measured in **thousands of currency units**.\n", + "Use a 95% ordinary-claim regime with median 2 (2,000 units) and log-scale\n", + "standard deviation 0.5, and a 5% severe-claim regime with median 20 (20,000 units)\n", + "and log-scale standard deviation 0.8. The severe regime is both larger and more\n", + "dispersed. These are illustrative parameters, not calibrated insurance data.\n", "\n", - "Components are reused through their recursive transform, not just their final `_transform` method. Here a Kumaraswamy transform feeds a Gaussian transform. The first probe point selects that composed component; the second selects a direct triangular component." + "Both components are lognormal. In SciPy, `scale` is the median and `s` is the\n", + "standard deviation of the natural logarithm, not the standard deviation of $X$.\n", + "`SciPyWrapper` reuses these distributions' inverse CDFs inside `Mixture`.\n", + "\n", + "Choose retention $d=10$ (10,000 units): five times the ordinary median and half\n", + "the severe median. We estimate\n", + "$$\n", + "g(x)=(x-d)_+=\\max(x-d,0),\\qquad\n", + "I=\\mathbb{E}_{\\rho_{\\mathrm{mix}}}[(X-d)_+].\n", + "$$\n", + "Claims below the retention contribute zero; larger claims contribute only the\n", + "excess above it. Thus $I$ is the expected payment above retention **per claim\n", + "across the whole population**, not a conditional average among large claims.\n", + "Here $d$ denotes the retention threshold, not the sampler dimension.\n", + "\n", + "A model of ordinary claims alone may describe the body but omit the rarer\n", + "severe regime. That omission matters disproportionately for a payoff that\n", + "grows with large claims above the threshold." ] }, { "cell_type": "code", "execution_count": 9, - "id": "2d2830ab", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-01T03:01:25.161261Z", - "iopub.status.busy": "2026-09-01T03:01:25.161058Z", - "iopub.status.idle": "2026-09-01T03:01:25.170887Z", - "shell.execute_reply": "2026-09-01T03:01:25.169957Z" - } - }, + "id": "insurance-density", + "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "mixture result: [-1.62756 2.43431]\n", - "recursive composed result: [-1.62756]\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "inner = Kumaraswamy(DigitalNetB2(1, seed=51), a=2.0, b=5.0)\n", - "composed = Gaussian(inner, mean=-1.0, covariance=0.6)\n", - "direct = Triangular(DigitalNetB2(1, seed=52), c=0.6, loc=1.0, scale=2.0)\n", - "composed_mixture = Mixture(\n", - " DigitalNetB2(2, seed=49), [composed, direct], [0.5, 0.5]\n", - ")\n", - "\n", - "probe = np.array([[0.2, 0.2], [0.8, 0.8]])\n", - "probe_result = composed_mixture._transform(probe)\n", - "recursive_result = composed._jacobian_transform_r(\n", - " probe[:1, 1:], return_weights=False\n", - ")\n", - "final_transform_only = composed._transform(probe[:1, 1:])\n", - "\n", - "np.testing.assert_allclose(probe_result[:1], recursive_result)\n", - "assert not np.allclose(recursive_result, final_transform_only)\n", - "print(\"mixture result:\", np.round(probe_result[:, 0], 5))\n", - "print(\"recursive composed result:\", np.round(recursive_result[:, 0], 5))" + "claim_probabilities = np.array([0.95, 0.05])\n", + "claim_distributions = [\n", + " lognorm(s=0.5, scale=2.0),\n", + " lognorm(s=0.8, scale=20.0),\n", + "]\n", + "retention = 10.0\n", + "\n", + "\n", + "def claim_mixture_pdf(x):\n", + " return sum(\n", + " probability * distribution.pdf(x)\n", + " for probability, distribution in zip(\n", + " claim_probabilities, claim_distributions\n", + " )\n", + " )\n", + "\n", + "\n", + "claim_grid = np.geomspace(0.2, 200.0, 700)\n", + "fig, ax = plt.subplots(figsize=(8.2, 3.6), layout=\"constrained\")\n", + "ax.loglog(claim_grid, claim_distributions[0].pdf(claim_grid),\n", + " \"--\", color=COLORS[0], label=\"Ordinary component (conditional)\")\n", + "ax.loglog(claim_grid, claim_distributions[1].pdf(claim_grid),\n", + " \"--\", color=COLORS[1], label=\"Severe component (conditional)\")\n", + "ax.loglog(claim_grid, claim_mixture_pdf(claim_grid),\n", + " color=COLORS[2], linewidth=2, label=\"95% / 5% mixture\")\n", + "ax.axvline(retention, color=\"black\", linestyle=\":\", label=\"Retention d = 10\")\n", + "ax.set(xlabel=\"claim severity (thousands of currency units)\",\n", + " ylabel=\"density per severity unit\", ylim=(1e-7, 1.0),\n", + " title=\"Ordinary claims and the severe tail (log axes)\")\n", + "ax.legend(loc=\"upper right\", framealpha=1.0, fontsize=8.5)\n", + "plt.show()" ] }, { "cell_type": "markdown", - "id": "5753d733", + "id": "insurance-density-reading", "metadata": {}, "source": [ - "## 11. Replicated sampling\n", + "The mixture largely follows the ordinary-claim body but retains a severe tail\n", + "to the right of the retention line. Dashed curves are the conditional component\n", + "densities; the solid curve weights them by 0.95 and 0.05.\n", + "Logarithmic axes make both scales visible, the plotted values remain densities\n", + "of $X$, not of $\\log X$. The plotting window is finite, but the reference below\n", + "integrates the entire tail to infinity." + ] + }, + { + "cell_type": "markdown", + "id": "insurance-estimation", + "metadata": {}, + "source": [ + "### Expected stop-loss payment\n", "\n", - "Replications add leading axes but do not change the selector convention. The implementation flattens the leading axes for dispatch and restores them after each selected component has been transformed." + "Use direct `Mixture` sampling with 16 independent randomized digital nets and\n", + "16,384 samples per replication. Average the stop-loss payoffs within each\n", + "replication, then average those estimates; no importance weights are needed.\n", + "\n", + "Independently, quadrature computes\n", + "$$\n", + "I_{\\mathrm{ref}}=\\int_d^\\infty (x-d)\\rho_{\\mathrm{mix}}(x)\\,dx.\n", + "$$\n", + "We also decompose this same reference into ordinary and severe contributions,\n", + "$p_j\\int_d^\\infty(x-d)\\rho_j(x)\\,dx$. This isolates the effect of the rare\n", + "regime without repeating the portfolio's proposal-comparison experiment." ] }, { "cell_type": "code", "execution_count": 10, - "id": "e206ff5e", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-01T03:01:25.174283Z", - "iopub.status.busy": "2026-09-01T03:01:25.174012Z", - "iopub.status.idle": "2026-09-01T03:01:25.180561Z", - "shell.execute_reply": "2026-09-01T03:01:25.179508Z" - } - }, + "id": "insurance-estimate", + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "replicated output shape: (3, 32, 1)\n" + "Direct Mixture QMC estimate: 910.42\n", + "Quadrature reference: 908.78\n", + "Absolute error: 1.64\n", + "Replication RMSE: 9.33\n", + "Ordinary contribution: 0.94\n", + "Severe contribution: 907.85\n", + "Severe share of reference: 99.90%\n", + "All amounts are currency units per claim.\n" ] } ], "source": [ - "replicated = Mixture(\n", - " DigitalNetB2(2, seed=61, replications=3),\n", - " heterogeneous_components,\n", - " heterogeneous_probabilities,\n", + "claim_components = [\n", + " SciPyWrapper(DigitalNetB2(1, seed=81 + j), distribution)\n", + " for j, distribution in enumerate(claim_distributions)\n", + "]\n", + "claim_mixture = Mixture(\n", + " DigitalNetB2(2, seed=83, replications=16, randomize=\"LMS DS\"),\n", + " claim_components, claim_probabilities,\n", ")\n", - "replicated_samples = replicated(32)\n", - "\n", - "assert replicated_samples.shape == (3, 32, 1)\n", - "print(\"replicated output shape:\", replicated_samples.shape)" + "claim_samples = claim_mixture(2**14)[..., 0]\n", + "assert claim_samples.shape == (16, 2**14)\n", + "assert np.all(np.isfinite(claim_samples)) and np.all(claim_samples > 0)\n", + "stop_loss_by_replication = np.maximum(\n", + " claim_samples - retention, 0.0\n", + ").mean(axis=1)\n", + "stop_loss_estimate = stop_loss_by_replication.mean()\n", + "\n", + "stop_loss_reference, stop_loss_quad_error = quad(\n", + " lambda x: (x - retention) * claim_mixture_pdf(x),\n", + " retention, np.inf, epsabs=1e-10, epsrel=1e-10,\n", + ")\n", + "stop_loss_rmse = np.sqrt(\n", + " np.mean((stop_loss_by_replication - stop_loss_reference) ** 2)\n", + ")\n", + "component_stop_loss = np.array([\n", + " quad(\n", + " lambda x: (x - retention) * distribution.pdf(x),\n", + " retention, np.inf, epsabs=1e-10, epsrel=1e-10,\n", + " )[0]\n", + " for distribution in claim_distributions\n", + "])\n", + "weighted_contributions = claim_probabilities * component_stop_loss\n", + "severe_share = weighted_contributions[1] / stop_loss_reference\n", + "np.testing.assert_allclose(\n", + " weighted_contributions.sum(), stop_loss_reference, rtol=1e-10, atol=1e-10\n", + ")\n", + "assert stop_loss_quad_error < 1e-8\n", + "\n", + "# Convert from thousands to currency units only for reporting.\n", + "print(f\"Direct Mixture QMC estimate: {1000 * stop_loss_estimate:.2f}\")\n", + "print(f\"Quadrature reference: {1000 * stop_loss_reference:.2f}\")\n", + "print(f\"Absolute error: {1000 * abs(stop_loss_estimate - stop_loss_reference):.2f}\")\n", + "print(f\"Replication RMSE: {1000 * stop_loss_rmse:.2f}\")\n", + "print(f\"Ordinary contribution: {1000 * weighted_contributions[0]:.2f}\")\n", + "print(f\"Severe contribution: {1000 * weighted_contributions[1]:.2f}\")\n", + "print(f\"Severe share of reference: {100 * severe_share:.2f}%\")\n", + "print(\"All amounts are currency units per claim.\")" ] }, { "cell_type": "markdown", - "id": "a1945e3f", + "id": "insurance-estimate-reading", "metadata": {}, "source": [ - "## 12. Scope and limitations\n", - "\n", - "- Every component must have the same output dimension, and the outer sampler must have exactly one extra coordinate.\n", - "- Probabilities must be finite, strictly positive, and sum to one.\n", - "- The reported `range` is a coordinate-wise bounding box; disconnected component supports may make that box wider than the actual union.\n", - "- `_weight(x)` is the probability-weighted sum of component weights. It is only as meaningful as those component weights. In particular, a distribution with a point mass, such as `ZeroInflatedExpUniform`, is not an ordinary smooth density with respect to Lebesgue measure; the sampling demonstration above therefore treats its atom separately and does not draw a false density curve.\n", - "- Spawning preserves the component dimension and creates a new outer sampler; component objects are shared because their attached samplers are not used by mixture dispatch." + "The direct estimate is **910.42** currency units per claim, versus the\n", + "independent reference of **908.78**, an absolute difference of **1.64**.\n", + "This is the average payment of only the excess above 10,000, including zero\n", + "payments for claims below retention; it is not conditional on a claim exceeding\n", + "retention.\n", + "\n", + "The empirical RMSE across the 16 individual replication estimates is **9.33**\n", + "currency units per claim. It measures error at 16,384 samples per replication,\n", + "not the error of their average: the latter is the displayed **1.64** absolute\n", + "difference from quadrature.\n", + "\n", + "The reference assigns about **0.94** to the ordinary regime and **907.85** to the\n", + "severe regime. The displayed severe share, **99.90%**, is the fraction of the\n", + "reference payment attributable to the 5% severe-claim population. A body-only\n", + "model would miss nearly all of this expectation. These are contributions to the same mixture integral, not a\n", + "comparison of numerical estimators with different targets; the reported QMC\n", + "error is an observed error, not a guaranteed error bound." + ] + }, + { + "cell_type": "markdown", + "id": "application-limitations", + "metadata": {}, + "source": [ + "## 5. Scope and limitations\n", + "\n", + "- Components must share an output dimension; the outer sampler needs exactly\n", + " one additional selector coordinate. Probabilities must be finite, positive,\n", + " and sum to one.\n", + "- A density formula requires component densities with respect to a common\n", + " reference measure. Components with point masses need a measure-level\n", + " interpretation, not a smooth density curve.\n", + "- Direct mixture sampling is not always the most accurate strategy. The payoff,\n", + " proposal, rare-event probabilities, and tail behavior all matter; equal sample\n", + " counts also need not mean equal computational cost.\n", + "- These application parameters are illustrative. Neither numerical precision\n", + " nor a good QMC result establishes that a model fits real data." ] }, { "cell_type": "markdown", - "id": "87abdc75", + "id": "application-summary", "metadata": {}, "source": [ - "## 13. Summary\n", + "## 6. Summary\n", + "\n", + "`Mixture` represents targets composed of distinct regimes or populations and\n", + "samples them using existing component transforms.\n", + "\n", + "The portfolio example shows that direct mixture sampling can outperform a\n", + "mismatched single-Gaussian importance-sampling proposal for the same integral.\n", + "For the illustrative insurance model, a small severe-claim component dominates\n", + "a tail-sensitive quantity: expected stop-loss payment.\n", "\n", - "`Mixture` adds one selector coordinate around existing `TrueMeasure` behavior. It preserves sample order and leading replication axes, supports heterogeneous and multidimensional components, follows composed transform chains, and forms weights by the usual probability-weighted sum. The examples deliberately span bell-shaped, zero-inflated, bounded skewed, heavy-tailed, triangular, composed, and multivariate behavior rather than treating the feature as only a Gaussian mixture utility." + "These outcomes depend on the target, payoff, and sampling strategy; mixture\n", + "sampling is not universally superior." ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python (qmcpy-venv)", "language": "python", - "name": "python3" + "name": "qmcpy-venv" }, "language_info": { "codemirror_mode": { @@ -646,7 +765,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.5" + "version": "3.12.11" } }, "nbformat": 4, diff --git a/test/test_mixed_distributions.py b/test/test_mixed_distributions.py index e75128fe4..563e31a9d 100644 --- a/test/test_mixed_distributions.py +++ b/test/test_mixed_distributions.py @@ -1,7 +1,16 @@ import numpy as np import pytest - -from qmcpy import AbstractTrueMeasure, DigitalNetB2, Gaussian, Kumaraswamy, Mixture +from scipy.stats import uniform + +from qmcpy import ( + AbstractTrueMeasure, + DigitalNetB2, + Gaussian, + Kumaraswamy, + Mixture, + SciPyWrapper, + Uniform, +) from qmcpy.util import DimensionError, MethodImplementationError, ParameterError @@ -88,6 +97,51 @@ def test_multiple_components(): np.testing.assert_allclose(samples[:, 0], [-4.0, 0.0, 0.0, 5.0]) +def test_heterogeneous_components_dispatch_transform_coordinates(): + gaussian = gaussian_component(1, -2.0) + wrapped = SciPyWrapper(DigitalNetB2(1, seed=19), uniform(loc=2.0, scale=3.0)) + mixture = Mixture(DigitalNetB2(2, seed=7), [gaussian, wrapped], [0.3, 0.7]) + u = np.array([[0.8, 0.2], [0.1, 0.7], [0.6, 0.9], [0.2, 0.4]]) + + expected = np.empty((4, 1)) + expected[[1, 3]] = gaussian._transform(u[[1, 3], 1:]) + expected[[0, 2]] = wrapped._transform(u[[0, 2], 1:]) + + np.testing.assert_allclose(mixture._transform(u), expected) + + +def test_range_is_coordinate_wise_bounding_box(): + components = [ + Uniform(DigitalNetB2(2, seed=17), lower_bound=[-3, 2], upper_bound=[1, 4]), + Uniform(DigitalNetB2(2, seed=19), lower_bound=[-1, -2], upper_bound=[5, 3]), + ] + mixture = Mixture(DigitalNetB2(3, seed=7), components, [0.3, 0.7]) + + np.testing.assert_array_equal(mixture.range, [[-3, 5], [-2, 4]]) + + +def test_range_expands_shared_component_bounds(): + components = [ + TransformOnlyMeasure(DigitalNetB2(2, seed=17)), + Uniform(DigitalNetB2(2, seed=19), lower_bound=[-2, 0.25], upper_bound=[-1, 2]), + ] + mixture = Mixture(DigitalNetB2(3, seed=7), components, [0.3, 0.7]) + + np.testing.assert_array_equal(mixture.range, [[-2, 1], [0, 2]]) + + +def test_malformed_custom_component_range_is_rejected(): + class MalformedRangeMeasure(TransformOnlyMeasure): + def __init__(self, sampler): + super(MalformedRangeMeasure, self).__init__(sampler) + self.range = np.zeros((3, 2)) + + component = MalformedRangeMeasure(DigitalNetB2(2, seed=17)) + + with pytest.raises(DimensionError, match="component range must have shape"): + Mixture(DigitalNetB2(3, seed=7), [component], [1.0]) + + def test_one_component_mixture_is_valid(): component = gaussian_component(1, 1.5) mixture = Mixture(DigitalNetB2(2, seed=7), [component], [1.0]) @@ -117,6 +171,21 @@ def test_probabilities_must_sum_to_one(): Mixture(DigitalNetB2(2, seed=7), components, [0.2, 0.7]) +def test_probabilities_are_owned_and_read_only(): + probabilities = np.array([0.3, 0.7]) + components = [gaussian_component(1, -2.0), gaussian_component(1, 3.0)] + mixture = Mixture(DigitalNetB2(2, seed=7), components, probabilities) + np.testing.assert_array_equal(mixture.probabilities, [0.3, 0.7]) + + probabilities[:] = [0.8, 0.2] + + np.testing.assert_array_equal(mixture.probabilities, [0.3, 0.7]) + np.testing.assert_allclose(mixture._transform([[0.5, 0.5]]), [[3.0]]) + assert not mixture.probabilities.flags.writeable + with pytest.raises(ValueError, match="read-only"): + mixture.probabilities[0] = 0.8 + + def test_number_of_probabilities_must_match_components(): components = [gaussian_component(1, 0.0), gaussian_component(1, 1.0)] @@ -207,6 +276,36 @@ def test_weight_is_weighted_sum_of_component_weights(): np.testing.assert_allclose(mixture._weight(x), expected) +def test_public_sampling_with_return_weights(): + components = [gaussian_component(1, -1.0), gaussian_component(1, 2.0)] + mixture = Mixture(DigitalNetB2(2, seed=7), components, [0.3, 0.7]) + + samples, weights = mixture(16, return_weights=True) + + assert samples.shape == (16, 1) + assert weights.shape == (16,) + assert np.all(np.isfinite(samples)) + assert np.all(np.isfinite(weights)) + assert np.all(weights > 0) + np.testing.assert_allclose(weights, 1.0 / mixture._weight(samples)) + + +def test_weight_preserves_leading_axes(): + components = [gaussian_component(2, [-1.0, 0.0]), gaussian_component(2, [2.0, 1.0])] + probabilities = np.array([0.3, 0.7]) + mixture = Mixture(DigitalNetB2(3, seed=7), components, probabilities) + x = np.linspace(-2.0, 3.0, 12).reshape(2, 3, 2) + + expected = sum( + probability * component._weight(x) + for probability, component in zip(probabilities, components) + ) + weights = mixture._weight(x) + + assert weights.shape == (2, 3) + np.testing.assert_allclose(weights, expected) + + def test_component_weight_failure_propagates(): transform_only = TransformOnlyMeasure(DigitalNetB2(1, seed=23)) mixture = Mixture( @@ -228,7 +327,10 @@ def test_spawn_replaces_outer_sampler_and_preserves_components(): for child in spawned + [explicit_same_dimension]: assert isinstance(child, Mixture) - assert child.d == 1 + assert child.d == mixture.d == 1 + np.testing.assert_array_equal(child.probabilities, mixture.probabilities) + np.testing.assert_array_equal(child.range, mixture.range) + assert not child.probabilities.flags.writeable assert child.discrete_distrib.d == 2 assert child.discrete_distrib is not mixture.discrete_distrib assert all(