{
"cells": [
{
"cell_type": "markdown",
"id": "185576bc",
"metadata": {},
"source": [
"# OT in linear ICA\n",
"\n",
"## Experiment 1: The \"Full Hybrid\" Stress Test\n",
"### Benchmarking Robustness Against Statistical Heterogeneity\n",
"\n",
"While isolating specific failure modes is scientifically useful, real-world data is rarely statistically uniform. This experiment introduces a **Full Hybrid** environment to test the limits of algorithmic robustness in high-dimensional spaces (30-40 dimensions).\n",
"\n",
"#### The Challenge: A Statistical Cocktail\n",
"We challenge the algorithms to simultaneously unmix a chaotic mixture of 8 distinct statistical \"flavors\":\n",
"* **Super-Gaussian (Heavy Tails):** Laplace, Student-t\n",
"* **Sub-Gaussian (Bounded):** Uniform\n",
"* **Skewed / Strictly Positive:** Chi-square, Exponential\n",
"* **Discrete / Stepped:** Bernoulli, Poisson, Binomial\n",
"\n",
"#### Why Hybrid Mixtures Break Traditional ICA\n",
"Parametric algorithms like **FastICA** rely on a specific contrast function (e.g., `logcosh`) to approximate non-Gaussianity. This assumes a somewhat uniform \"type\" of non-Gaussianity across all latent sources. In a hybrid mixture, the parametric approximations clash—FastICA’s Newton solver often becomes confused by the conflicting local curvatures of skewed vs. sub-Gaussian signals, leading to erratic convergence and high **Amari Error**.\n",
"\n",
"#### The Geometric Solution (OT-ICA)\n",
"**OT-ICA** utilizes the Wasserstein-2 distance to measure the global geometric discrepancy between the data and a Gaussian target. Theoretically, this metric is agnostic to the \"type\" of non-Gaussianity (skewed, heavy-tailed, or discrete). This experiment benchmarks whether this geometric approach can maintain stability where local density approximations fail."
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "5c7f35b1",
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"import torch\n",
"import pandas as pd\n",
"import time\n",
"import warnings\n",
"import seaborn as sns\n",
"import matplotlib.pyplot as plt\n",
"from sklearn.decomposition import FastICA\n",
"from sklearn.exceptions import ConvergenceWarning\n",
"from joblib import Parallel, delayed\n",
"from tqdm.notebook import tqdm\n",
"import gc\n",
"\n",
"from wasserstein_ica import WassersteinICA"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "86e14cd4",
"metadata": {},
"outputs": [],
"source": [
"# ==========================================\n",
"# 1. Global Thesis Configuration & Helpers\n",
"# ==========================================\n",
"def set_thesis_theme():\n",
" thesis_colors = ['#0173B2', '#DE8F05', '#029E73', '#D55E00', '#CC78BC', '#CA9161']\n",
" plt.rcParams.update({\n",
" 'figure.figsize': (24, 10), # Doubled figure size\n",
" 'figure.dpi': 300,\n",
" 'axes.prop_cycle': plt.cycler(color=thesis_colors),\n",
" 'axes.grid': True,\n",
" 'grid.alpha': 0.3,\n",
" 'grid.linestyle': '--',\n",
" 'axes.axisbelow': True,\n",
" 'axes.spines.top': False,\n",
" 'axes.spines.right': False,\n",
" 'font.size': 24, # Doubled base font size\n",
" 'axes.titlesize': 28, # Doubled title size\n",
" 'axes.labelsize': 24, # Doubled label size\n",
" 'legend.frameon': True,\n",
" 'legend.fontsize': 22, # Doubled legend font size\n",
" 'lines.linewidth': 4.5 # Thicker lines for huge plots\n",
" })\n",
"\n",
"set_thesis_theme()"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "e93046ce",
"metadata": {},
"outputs": [],
"source": [
"def amari_error(W, A):\n",
" if W is None or np.any(np.isnan(W)): return np.nan\n",
" P = np.abs(np.dot(W, A))\n",
" n = P.shape[0]\n",
" row_sum = np.sum(P / np.max(P, axis=1, keepdims=True), axis=1) - 1.0\n",
" col_sum = np.sum(P / np.max(P, axis=0, keepdims=True), axis=0) - 1.0\n",
" return (np.sum(row_sum) + np.sum(col_sum)) / (2 * n)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "59aa403d",
"metadata": {},
"outputs": [],
"source": [
"# ==========================================\n",
"# 2. Unified Data Generators\n",
"# ==========================================\n",
"def generate_mixture(n_dim, n_samples, config_type, param=None, seed=None):\n",
" if seed is not None: np.random.seed(seed)\n",
" \n",
" # Standard Generators\n",
" def gen_laplace(): return np.random.laplace(0, 1/np.sqrt(2), size=n_samples)\n",
" def gen_bernoulli(): return np.random.choice([-1.0, 1.0], size=n_samples)\n",
" def gen_uniform(): return np.random.uniform(-np.sqrt(3), np.sqrt(3), size=n_samples)\n",
" def gen_student_t(): s = np.random.standard_t(df=3, size=n_samples); return s / np.std(s)\n",
" \n",
" # Parameterized Discrete Generators\n",
" def gen_poisson(lam=3.0): s = np.random.poisson(lam=lam, size=n_samples); return (s - np.mean(s)) / np.std(s)\n",
" def gen_binomial(n=10, p=0.5): s = np.random.binomial(n=n, p=p, size=n_samples); return (s - np.mean(s)) / np.std(s)\n",
" \n",
" # Positive continuous\n",
" def gen_chisquare(): s = np.random.chisquare(df=2, size=n_samples); return (s - np.mean(s)) / np.std(s)\n",
" def gen_exponential(): s = np.random.exponential(scale=1.0, size=n_samples); return (s - np.mean(s)) / np.std(s)\n",
"\n",
" pools = {\n",
" 'Full Hybrid': [gen_laplace, gen_bernoulli, gen_uniform, gen_student_t, gen_poisson, gen_binomial, gen_chisquare, gen_exponential],\n",
" 'Continuous Only': [gen_laplace, gen_uniform, gen_student_t, gen_chisquare, gen_exponential],\n",
" 'Discrete Only': [gen_bernoulli, gen_poisson, gen_binomial],\n",
" 'Strictly Super-Gaussian': [gen_laplace, gen_student_t, gen_chisquare, gen_exponential],\n",
" 'Zero Gaussian': [gen_laplace, gen_bernoulli, gen_uniform, gen_student_t, gen_poisson, gen_binomial, gen_chisquare, gen_exponential]\n",
" }\n",
" \n",
" sources = []\n",
" \n",
" # Mode A: Ablation Pools\n",
" if config_type in pools:\n",
" active_pool = pools[config_type]\n",
" if config_type != 'Zero Gaussian':\n",
" sources.append(np.random.normal(0, 1, size=n_samples)) # Add Gaussian\n",
" n_to_gen = n_dim - 1\n",
" else:\n",
" n_to_gen = n_dim\n",
" for _ in range(n_to_gen): sources.append(np.random.choice(active_pool)())\n",
" \n",
" # Mode B: Single Isolated Discrete Type\n",
" else:\n",
" sources.append(np.random.normal(0, 1, size=n_samples)) # Baseline Gaussian\n",
" for _ in range(n_dim - 1):\n",
" if config_type == 'Bernoulli': sources.append(gen_bernoulli())\n",
" elif config_type == 'Poisson': sources.append(gen_poisson(lam=param if param else 3.0))\n",
" elif config_type == 'Binomial': sources.append(gen_binomial(n=param if param else 10))\n",
" \n",
" S = np.stack(sources)\n",
" np.random.shuffle(S) # Hide the Gaussian\n",
" \n",
" cond_num = 1000\n",
" while cond_num > 100:\n",
" A = np.random.randn(n_dim, n_dim)\n",
" cond_num = np.linalg.cond(A)\n",
" return A @ S, A"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "194f8427",
"metadata": {},
"outputs": [],
"source": [
"# ==========================================\n",
"# 3. Unified Worker Function (UPDATED)\n",
"# ==========================================\n",
"def run_ica_trial(dim, trial, n_samples, config_type, method, param=None):\n",
" torch.set_num_threads(1)\n",
" X_np, A_true = generate_mixture(dim, n_samples, config_type, param, seed=trial)\n",
" \n",
" score = np.nan\n",
" converged = False\n",
"\n",
" if method == 'FastICA':\n",
" # --- Oracle Restarts added for FastICA ---\n",
" best_score = np.inf\n",
" best_conv = False\n",
" with warnings.catch_warnings():\n",
" warnings.simplefilter(\"ignore\", ConvergenceWarning)\n",
" for r in range(50): # 50 Random initializations\n",
" try:\n",
" seed_r = trial * 1000 + r\n",
" fast_ica = FastICA(n_components=dim, max_iter=10000, tol=1e-4, random_state=seed_r)\n",
" fast_ica.fit(X_np.T)\n",
" current_score = amari_error(fast_ica.components_, A_true)\n",
" \n",
" if current_score < best_score:\n",
" best_score = current_score\n",
" if not np.isnan(current_score) and current_score < 1.0: \n",
" best_conv = True\n",
" except Exception: \n",
" pass\n",
" \n",
" if not np.isinf(best_score):\n",
" score = best_score\n",
" converged = best_conv\n",
"\n",
" elif method == 'OT-ICA':\n",
" try:\n",
" device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
" print(\"Running on: \", device)\n",
" X_torch = torch.tensor(X_np, dtype=torch.float32).to(device)\n",
" ica = WassersteinICA(X_torch)\n",
" ica.whiten()\n",
" W_white = ica.W_white.cpu().numpy()\n",
" \n",
" extracted = []\n",
" n_restarts = min(dim * 4, 150)\n",
" for _ in range(dim):\n",
" prev = torch.stack(extracted) if extracted else None\n",
" w, _ = ica.optimize_wasserstein2(prev_components=prev, max_iter=200, n_restarts=n_restarts, dither_sigma=0.01)\n",
" extracted.append(w)\n",
" \n",
" W_stiefel = ica.optimize_symmetric(n_components=dim, max_iter=400, lr=0.25, init_w=torch.stack(extracted), optimizer='stiefel', dither_sigma=0.01, batch_size=1024)\n",
" score = amari_error(W_stiefel.cpu().numpy() @ W_white, A_true)\n",
" if not np.isnan(score) and score < 1.0: converged = True\n",
" except Exception: pass\n",
" \n",
" # --- Aggressive Memory Cleanup ---\n",
" try:\n",
" del X_np\n",
" del A_true\n",
" if 'X_torch' in locals():\n",
" del X_torch\n",
" if 'ica' in locals():\n",
" del ica\n",
" if 'fast_ica' in locals():\n",
" del fast_ica\n",
" except NameError:\n",
" pass\n",
" \n",
" gc.collect() # Force the OS to reclaim the RAM immediately\n",
"\n",
" return {'Dim': dim, 'Config': config_type, 'Config_Param': param, 'Method': method, 'Error': score, 'Conv': int(converged)}"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "4a5da210",
"metadata": {},
"outputs": [],
"source": [
"def plot_results(df, title, palette, x_col='Config'):\n",
" # 1. Prepare Amari Error Data\n",
" df_plot = df.copy()\n",
" df_plot['Error'] = df_plot['Error'].fillna(1.5) \n",
"\n",
" # 2. Prepare Convergence Data\n",
" df_conv_raw = df[df['Method'] == 'FastICA'].copy()\n",
" df_conv_raw['Success Rate (%)'] = df_conv_raw['Conv'] * 100\n",
"\n",
" # --- Massive Font Size Controls ---\n",
" TITLE_FS = 30 \n",
" LABEL_FS = 30 \n",
" TICK_FS = 28 \n",
" LEGEND_FS = 28 \n",
" ANNOT_FS = 22 # Font size for the percentage text on bars\n",
" # --------------------------------------\n",
"\n",
" fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(24, 10))\n",
" \n",
" # --- Subplot 1: Amari Error (Barplot with alpha) ---\n",
" # Default total width is 0.8, split across 2 hues = ~0.4 width per bar\n",
" sns.barplot(data=df_plot, x=x_col, y='Error', hue='Method', ax=ax1, \n",
" palette=palette, edgecolor='black', errorbar='ci', alpha=0.7)\n",
" \n",
" ax1.set_title(f\"Amari Error: {title}\", fontsize=TITLE_FS, pad=20, fontweight='bold')\n",
" ax1.set_xlabel(x_col, fontsize=LABEL_FS, labelpad=15)\n",
" ax1.set_ylabel('Error', fontsize=LABEL_FS, labelpad=15)\n",
" ax1.tick_params(axis='both', labelsize=TICK_FS)\n",
" ax1.set_xticklabels(ax1.get_xticklabels(), rotation=30, ha=\"right\")\n",
" ax1.legend(title='Method', fontsize=LEGEND_FS, title_fontsize=LEGEND_FS)\n",
" ax1.set_ylim(0, 2.0) \n",
"\n",
" # --- FIXED: Bolder Good Separation Threshold Line ---\n",
" #ax1.axhline(0.3, color='black', linestyle=':', linewidth=3, alpha=0.6)\n",
" # Added a white bbox so the text pops out over the bars\n",
" #ax1.text(ax1.get_xlim()[0] + 0.1, 0.32, 'Good Separation', color='black', \n",
" # fontsize=ANNOT_FS, fontweight='bold', \n",
" # bbox=dict(facecolor='white', alpha=0.8, edgecolor='none', pad=3))\n",
"\n",
" # --- Subplot 2: Convergence Rate (Barplot with matching width, no error band) ---\n",
" fast_palette = {'FastICA': palette['FastICA']}\n",
" sns.barplot(data=df_conv_raw, x=x_col, y='Success Rate (%)', hue='Method', ax=ax2, \n",
" palette=fast_palette, edgecolor='black', errorbar=None, alpha=0.7, width=0.4)\n",
" \n",
" ax2.set_title(f\"FastICA Convergence: {title}\", fontsize=TITLE_FS, pad=20, fontweight='bold')\n",
" ax2.set_xlabel(x_col, fontsize=LABEL_FS, labelpad=15)\n",
" ax2.set_ylabel('Success Rate (%)', fontsize=LABEL_FS, labelpad=15)\n",
" ax2.tick_params(axis='both', labelsize=TICK_FS)\n",
" ax2.set_xticklabels(ax2.get_xticklabels(), rotation=30, ha=\"right\")\n",
" \n",
" # --- FIXED: Only annotate the actual FastICA bars ---\n",
" # Seaborn generates patches for all hue levels. Since FastICA is the first hue, \n",
" # its patches are the first N elements in ax2.patches (where N is the number of x categories)\n",
" n_categories = df_conv_raw[x_col].nunique()\n",
" for p in ax2.patches[:n_categories]:\n",
" height = p.get_height()\n",
" if not np.isnan(height):\n",
" ax2.annotate(f'{height:.0f}%', \n",
" (p.get_x() + p.get_width() / 2., height), \n",
" ha='center', va='bottom', \n",
" fontsize=ANNOT_FS, fontweight='bold', color='black', \n",
" xytext=(0, 5), textcoords='offset points')\n",
" \n",
" # Explicitly remove the legend from the right plot\n",
" if ax2.get_legend() is not None:\n",
" ax2.get_legend().remove()\n",
" \n",
" ax2.set_ylim(0, 115) # Slightly increased to leave room for the 100% text\n",
"\n",
" plt.tight_layout()\n",
" \n",
" # Generate automatic safe file name for PDF\n",
" file_name = f\"{title.replace(' ', '_').replace(':', '').replace('(', '').replace(')', '').replace('-', '_').lower()}.pdf\"\n",
" plt.savefig(file_name, format='pdf', bbox_inches='tight')\n",
" plt.show()\n",
" \n",
" display(df.groupby(['Method', x_col, 'Dim'])[['Error', 'Conv']].mean().round(4))"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "297451e6",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"--- Step 1: Sub-Pool Ablation Study ---\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "77ad76b9e233456fb21ded7fd3ff7f3d",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/100 [00:00"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"\n",
"\n",
"
\n",
" \n",
" \n",
" | \n",
" | \n",
" | \n",
" Error | \n",
" Conv | \n",
"
\n",
" \n",
" | Method | \n",
" Config | \n",
" Dim | \n",
" | \n",
" | \n",
"
\n",
" \n",
" \n",
" \n",
" | FastICA | \n",
" Continuous Only | \n",
" 30 | \n",
" 0.2658 | \n",
" 1.0 | \n",
"
\n",
" \n",
" | 40 | \n",
" 0.3535 | \n",
" 1.0 | \n",
"
\n",
" \n",
" | Discrete Only | \n",
" 30 | \n",
" 3.7108 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | 40 | \n",
" 4.8902 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | Full Hybrid | \n",
" 30 | \n",
" 0.6605 | \n",
" 0.8 | \n",
"
\n",
" \n",
" | 40 | \n",
" 0.8695 | \n",
" 0.8 | \n",
"
\n",
" \n",
" | Strictly Super-Gaussian | \n",
" 30 | \n",
" 0.2773 | \n",
" 1.0 | \n",
"
\n",
" \n",
" | 40 | \n",
" 0.3745 | \n",
" 1.0 | \n",
"
\n",
" \n",
" | Zero Gaussian | \n",
" 30 | \n",
" 0.5269 | \n",
" 1.0 | \n",
"
\n",
" \n",
" | 40 | \n",
" 0.6444 | \n",
" 1.0 | \n",
"
\n",
" \n",
" | OT-ICA | \n",
" Continuous Only | \n",
" 30 | \n",
" 0.1600 | \n",
" 1.0 | \n",
"
\n",
" \n",
" | 40 | \n",
" 0.2247 | \n",
" 1.0 | \n",
"
\n",
" \n",
" | Discrete Only | \n",
" 30 | \n",
" 3.6984 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | 40 | \n",
" 6.1671 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | Full Hybrid | \n",
" 30 | \n",
" 0.2454 | \n",
" 1.0 | \n",
"
\n",
" \n",
" | 40 | \n",
" 0.6118 | \n",
" 0.8 | \n",
"
\n",
" \n",
" | Strictly Super-Gaussian | \n",
" 30 | \n",
" 0.1758 | \n",
" 1.0 | \n",
"
\n",
" \n",
" | 40 | \n",
" 0.2329 | \n",
" 1.0 | \n",
"
\n",
" \n",
" | Zero Gaussian | \n",
" 30 | \n",
" 0.1574 | \n",
" 1.0 | \n",
"
\n",
" \n",
" | 40 | \n",
" 0.2429 | \n",
" 1.0 | \n",
"
\n",
" \n",
"
\n",
"
\n",
"\n",
"
\n",
" \n",
" \n",
" | \n",
" | \n",
" | \n",
" Error | \n",
" Conv | \n",
"
\n",
" \n",
" | Method | \n",
" Config | \n",
" Dim | \n",
" | \n",
" | \n",
"
\n",
" \n",
" \n",
" \n",
" | FastICA | \n",
" Bernoulli | \n",
" 30 | \n",
" 0.1219 | \n",
" 1.0 | \n",
"
\n",
" \n",
" | 40 | \n",
" 0.1619 | \n",
" 1.0 | \n",
"
\n",
" \n",
" | Binomial | \n",
" 30 | \n",
" 7.7648 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | 40 | \n",
" 11.3407 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | Poisson | \n",
" 30 | \n",
" 7.3501 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | 40 | \n",
" 9.9201 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | OT-ICA | \n",
" Bernoulli | \n",
" 30 | \n",
" 0.1434 | \n",
" 1.0 | \n",
"
\n",
" \n",
" | 40 | \n",
" 0.2601 | \n",
" 1.0 | \n",
"
\n",
" \n",
" | Binomial | \n",
" 30 | \n",
" 9.6036 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | 40 | \n",
" 12.4609 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | Poisson | \n",
" 30 | \n",
" 3.7443 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | 40 | \n",
" 7.2947 | \n",
" 0.0 | \n",
"
\n",
" \n",
"
\n",
"
"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# ==========================================\n",
"# Main execution to build the 2x2 grid\n",
"# ==========================================\n",
"n_samples = 10000\n",
"device = 'cpu' \n",
"\n",
"target_quantiles = get_analytical_gaussian_target(n_samples, device=device)\n",
"\n",
"v_large = np.random.normal(0, 1, 100000)\n",
"C_gauss_static = np.mean(np.log(np.cosh(v_large)))\n",
"\n",
"s_gauss_src = np.random.normal(0, 1, n_samples)\n",
"\n",
"plots_spec = [\n",
" {'title': r'Highly Non-Gaussian Poisson' + '\\n' + r'($\\lambda=0.5$)', 'dist_name': 'Poisson', 'param_name': r'\\lambda', 'param_val': 0.5, 'pos': (0,0)},\n",
" \n",
" {'title': r'Standard Poisson' + '\\n' + r'($\\lambda=3.0$)', 'dist_name': 'Poisson', 'param_name': r'\\lambda', 'param_val': 3.0, 'pos': (0,1)},\n",
" \n",
" {'title': r'Highly Non-Gaussian Binomial' + '\\n' + r'($n=2$)', 'dist_name': 'Binomial', 'param_name': 'n', 'param_val': 2, 'pos': (1,0)},\n",
" \n",
" {'title': r'Standard Binomial' + '\\n' + r'($n=10$)', 'dist_name': 'Binomial', 'param_name': 'n', 'param_val': 10, 'pos': (1,1)}\n",
"]\n",
"\n",
"fig, axs = plt.subplots(2, 2, figsize=(24, 16), sharex=True)\n",
"\n",
"axs_flat = axs.flatten()\n",
"final_handles = []\n",
"\n",
"for i, spec in enumerate(plots_spec):\n",
" ax = axs[spec['pos']]\n",
" np.random.seed(i) \n",
" \n",
" if spec['dist_name'] == 'Poisson':\n",
" s_src = np.random.poisson(spec['param_val'], n_samples)\n",
" else: \n",
" s_src = np.random.binomial(spec['param_val'], 0.5, n_samples)\n",
" \n",
" s_std_src = (s_src - np.mean(s_src)) / np.std(s_src)\n",
" \n",
" S_mixed = np.vstack([s_std_src, s_gauss_src])\n",
" \n",
" ax_fast_returned = plot_surface_on_ax(ax, spec['title'], spec['dist_name'], spec['param_name'], spec['param_val'], S_mixed, target_quantiles, C_gauss_static)\n",
" \n",
" if i == len(plots_spec) - 1:\n",
" lines_w2, labels_w2 = ax.get_legend_handles_labels()\n",
" lines_fast, labels_fast = ax_fast_returned.get_legend_handles_labels()\n",
" final_handles = lines_w2 + lines_fast\n",
"\n",
"for i, ax in enumerate(axs.flatten()):\n",
" if i >= 2: \n",
" ax.set_xlabel('Projection Angle $\\\\theta$ (Radians)', fontsize=LABEL_FS, labelpad=15) \n",
"\n",
"fig.suptitle(\"Discrete Mixture Optimization Landscape: OT-ICA vs.FastICA\", fontsize=SUPTITLE_FS, y=1.05, fontweight='bold') \n",
"fig.legend(final_handles, ['OT-ICA ($W_2^2$ Distance)', 'FastICA (Logcosh Negentropy)'], loc='lower center', ncol=2, bbox_to_anchor=(0.5, -0.05), fontsize=LEGEND_FS, frameon=True) \n",
"fig.tight_layout()\n",
"\n",
"fig.savefig('all_optimization_surfaces.pdf', format='pdf', bbox_inches='tight')\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "d52a9ce3",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"--- Step 4: Harsh Discrete Test (λ=0.5, n=3) ---\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "567ff8718a874c958b48a88ef5fb7f21",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/40 [00:00"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"\n",
"\n",
"
\n",
" \n",
" \n",
" | \n",
" | \n",
" | \n",
" Error | \n",
" Conv | \n",
"
\n",
" \n",
" | Method | \n",
" Config | \n",
" Dim | \n",
" | \n",
" | \n",
"
\n",
" \n",
" \n",
" \n",
" | FastICA | \n",
" Binomial (n=3, p=0.5) | \n",
" 30 | \n",
" 0.4912 | \n",
" 1.0 | \n",
"
\n",
" \n",
" | 40 | \n",
" 0.6732 | \n",
" 1.0 | \n",
"
\n",
" \n",
" | Poisson (λ=0.5) | \n",
" 30 | \n",
" 1.5469 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | 40 | \n",
" 1.8279 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | OT-ICA | \n",
" Binomial (n=3, p=0.5) | \n",
" 30 | \n",
" 7.9102 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | 40 | \n",
" 11.2890 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | Poisson (λ=0.5) | \n",
" 30 | \n",
" 0.1179 | \n",
" 1.0 | \n",
"
\n",
" \n",
" | 40 | \n",
" 0.1549 | \n",
" 1.0 | \n",
"
\n",
" \n",
"
\n",
"
\n",
"\n",
"
\n",
" \n",
" \n",
" | \n",
" | \n",
" | \n",
" Error | \n",
" Conv | \n",
"
\n",
" \n",
" | Method | \n",
" Config | \n",
" Dim | \n",
" | \n",
" | \n",
"
\n",
" \n",
" \n",
" \n",
" | FastICA | \n",
" Binomial (n=3, p=0.5) | \n",
" 30 | \n",
" 0.4912 | \n",
" 1.0 | \n",
"
\n",
" \n",
" | 40 | \n",
" 0.6732 | \n",
" 1.0 | \n",
"
\n",
" \n",
" | Poisson (λ=0.5) | \n",
" 30 | \n",
" 1.5469 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | 40 | \n",
" 1.8279 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | OT-ICA | \n",
" Binomial (n=3, p=0.5) | \n",
" 30 | \n",
" 7.4221 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | 40 | \n",
" 11.6660 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | Poisson (λ=0.5) | \n",
" 30 | \n",
" 0.1179 | \n",
" 1.0 | \n",
"
\n",
" \n",
" | 40 | \n",
" 0.1549 | \n",
" 1.0 | \n",
"
\n",
" \n",
"
\n",
"