{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Regression Models: Performance Comparison Across Datasets\n",
    "\n",
    "This notebook compares three different approaches to modeling conditional probability distributions using Gaussian Mixture Models. We'll test them on various datasets to see which works best for different types of problems.\n",
    "\n",
    "## The Three Models\n",
    "\n",
    "**1. ConditionalGMMRegressor**\n",
    "- **What it does**: Fits a joint Gaussian mixture to all variables [X, y] together, then uses mathematical conditioning to get p(y|X)\n",
    "- **Pros**: Simple, fast, interpretable\n",
    "- **Cons**: May not be optimal for conditional prediction since it optimizes the joint distribution\n",
    "\n",
    "**2. MixtureOfExpertsRegressor** \n",
    "- **What it does**: Uses a \"gating network\" to decide which Gaussian expert should handle each input, where each expert has a linear relationship between X and y\n",
    "- **Pros**: Can capture complex, non-linear conditional relationships\n",
    "- **Cons**: More complex, requires more iterations to converge\n",
    "\n",
    "**3. DiscriminativeConditionalGMMRegressor**\n",
    "- **What it does**: Directly optimizes the conditional likelihood p(y|X) using a specialized training algorithm\n",
    "- **Pros**: Often achieves the best conditional prediction performance\n",
    "- **Cons**: More computationally intensive, requires careful regularization\n",
    "\n",
    "## Datasets\n",
    "\n",
    "We'll test on 6 diverse datasets to see how each model handles different types of problems:\n",
    "\n",
    "**Classification-style problems** (predicting features from other features + labels):\n",
    "- **Iris**: 150 flowers, predict sepal size from petal size and species\n",
    "- **Wine**: 178 wines, predict chemical properties from other measurements and wine type  \n",
    "- **Breast Cancer**: 569 samples, predict cell features from other measurements and diagnosis\n",
    "- **Digits**: 1,797 handwritten digits, predict digit appearance from digit labels\n",
    "\n",
    "**Regression problems** (predicting continuous targets):\n",
    "- **California Housing**: 20,640 houses, predict house price from location and demographics\n",
    "- **Diabetes**: 442 patients, predict diabetes progression from health measurements\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [],
   "source": [
    "import matplotlib\n",
    "matplotlib.use('module://matplotlib_inline.backend_inline')  # must be before pyplot import\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "from sklearn.datasets import (\n",
    "    load_iris, load_wine, load_breast_cancer, load_digits,\n",
    "    fetch_california_housing, load_diabetes\n",
    ")\n",
    "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import mean_squared_error, r2_score\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "from cgmm import ConditionalGMMRegressor, MixtureOfExpertsRegressor, DiscriminativeConditionalGMMRegressor\n",
    "\n",
    "# Set random seed for reproducibility\n",
    "np.random.seed(42)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset configurations:\n",
      "\n",
      "IRIS:\n",
      "  Task: Predict sepal size from petal size and flower species\n",
      "  Details: Classic dataset: 150 iris flowers, 4 measurements each. We predict sepal dimensions (length, width) from petal dimensions and species type (setosa, versicolor, virginica).\n",
      "  Setup: 2 targets, 2 conditioning vars, 5 components\n",
      "\n",
      "WINE:\n",
      "  Task: Predict wine chemistry from other measurements and wine type\n",
      "  Details: Wine quality dataset: 178 wines from 3 different cultivars, 13 chemical measurements each. We predict the first 3 chemical properties from the other 10 measurements plus wine class.\n",
      "  Setup: 3 targets, 10 conditioning vars, 5 components\n",
      "\n",
      "BREAST_CANCER:\n",
      "  Task: Predict cell features from other measurements and diagnosis\n",
      "  Details: Medical dataset: 569 breast cancer samples, 30 features from cell nuclei images. We predict the first 3 features from the other 27 measurements plus diagnosis (malignant/benign).\n",
      "  Setup: 3 targets, 27 conditioning vars, 5 components\n",
      "\n",
      "DIGITS:\n",
      "  Task: Predict digit appearance from digit labels\n",
      "  Details: Handwritten digits: 1,797 8x8 pixel images of digits 0-9. We use PCA to reduce 64 pixels to 8 components, then predict these from the digit labels. This tests how well models can learn visual patterns from categorical information.\n",
      "  Setup: 8 targets, 0 conditioning vars, 7 components\n",
      "\n",
      "CALIFORNIA_HOUSING:\n",
      "  Task: Predict house price from location and demographics\n",
      "  Details: Real estate dataset: 20,640 California housing districts, 8 features including location, demographics, and housing characteristics. We predict median house value from the other 7 features.\n",
      "  Setup: 1 targets, 7 conditioning vars, 5 components\n",
      "\n",
      "DIABETES:\n",
      "  Task: Predict diabetes progression from health measurements\n",
      "  Details: Medical dataset: 442 diabetes patients, 10 baseline measurements (age, sex, BMI, blood pressure, etc.). We predict disease progression (continuous target) from the other 9 health measurements.\n",
      "  Setup: 1 targets, 9 conditioning vars, 5 components\n"
     ]
    }
   ],
   "source": [
    "# Configure datasets for testing\n",
    "# Each dataset defines: which features are targets vs conditioning variables, and number of mixture components\n",
    "\n",
    "datasets = {\n",
    "    'iris': {\n",
    "        'loader': load_iris,\n",
    "        'type': 'classification',\n",
    "        'target_cols': [0, 1],  # sepal length, width\n",
    "        'conditioning_cols': [2, 3],  # petal length, width + species labels\n",
    "        'n_components': 5,\n",
    "        'description': 'Predict sepal size from petal size and flower species',\n",
    "        'details': 'Classic dataset: 150 iris flowers, 4 measurements each. We predict sepal dimensions (length, width) from petal dimensions and species type (setosa, versicolor, virginica).'\n",
    "    },\n",
    "    'wine': {\n",
    "        'loader': load_wine,\n",
    "        'type': 'classification', \n",
    "        'target_cols': [0, 1, 2],  # first 3 chemical features\n",
    "        'conditioning_cols': list(range(3, 13)),  # remaining features + wine class\n",
    "        'n_components': 5,\n",
    "        'description': 'Predict wine chemistry from other measurements and wine type',\n",
    "        'details': 'Wine quality dataset: 178 wines from 3 different cultivars, 13 chemical measurements each. We predict the first 3 chemical properties from the other 10 measurements plus wine class.'\n",
    "    },\n",
    "    'breast_cancer': {\n",
    "        'loader': load_breast_cancer,\n",
    "        'type': 'classification',\n",
    "        'target_cols': [0, 1, 2],  # first 3 features\n",
    "        'conditioning_cols': list(range(3, 30)),  # remaining features + diagnosis\n",
    "        'n_components': 5,\n",
    "        'description': 'Predict cell features from other measurements and diagnosis',\n",
    "        'details': 'Medical dataset: 569 breast cancer samples, 30 features from cell nuclei images. We predict the first 3 features from the other 27 measurements plus diagnosis (malignant/benign).'\n",
    "    },\n",
    "    'digits': {\n",
    "        'loader': load_digits,\n",
    "        'type': 'classification',\n",
    "        'target_cols': list(range(8)),  # 8 PCA components as targets\n",
    "        'conditioning_cols': [],  # digit labels only\n",
    "        'n_components': 7,\n",
    "        'use_pca': True,\n",
    "        'pca_components': 8,\n",
    "        'description': 'Predict digit appearance from digit labels',\n",
    "        'details': 'Handwritten digits: 1,797 8x8 pixel images of digits 0-9. We use PCA to reduce 64 pixels to 8 components, then predict these from the digit labels. This tests how well models can learn visual patterns from categorical information.'\n",
    "    },\n",
    "    'california_housing': {\n",
    "        'loader': fetch_california_housing,\n",
    "        'type': 'regression',\n",
    "        'target_cols': [0],  # median house value\n",
    "        'conditioning_cols': list(range(1, 8)),  # other features\n",
    "        'n_components': 5,\n",
    "        'description': 'Predict house price from location and demographics',\n",
    "        'details': 'Real estate dataset: 20,640 California housing districts, 8 features including location, demographics, and housing characteristics. We predict median house value from the other 7 features.'\n",
    "    },\n",
    "    'diabetes': {\n",
    "        'loader': load_diabetes,\n",
    "        'type': 'regression',\n",
    "        'target_cols': [0],  # disease progression\n",
    "        'conditioning_cols': list(range(1, 10)),  # other features\n",
    "        'n_components': 5,\n",
    "        'description': 'Predict diabetes progression from health measurements',\n",
    "        'details': 'Medical dataset: 442 diabetes patients, 10 baseline measurements (age, sex, BMI, blood pressure, etc.). We predict disease progression (continuous target) from the other 9 health measurements.'\n",
    "    }\n",
    "}\n",
    "\n",
    "print(\"Dataset configurations:\")\n",
    "for name, config in datasets.items():\n",
    "    print(f\"\\n{name.upper()}:\")\n",
    "    print(f\"  Task: {config['description']}\")\n",
    "    print(f\"  Details: {config['details']}\")\n",
    "    print(f\"  Setup: {len(config['target_cols'])} targets, {len(config['conditioning_cols'])} conditioning vars, {config['n_components']} components\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [],
   "source": [
    "# Helper functions\n",
    "\n",
    "def prepare_dataset(dataset_name, config):\n",
    "    \"\"\"Load and prepare a dataset for testing.\"\"\"\n",
    "    loader = config['loader']\n",
    "    data = loader()\n",
    "    \n",
    "    X = data.data\n",
    "    y = data.target\n",
    "    \n",
    "    # Standardize features\n",
    "    scaler = StandardScaler()\n",
    "    X_scaled = scaler.fit_transform(X)\n",
    "    \n",
    "    if config['type'] == 'classification':\n",
    "        # Special case for digits: use digit labels as conditioning, PCA-reduced pixels as targets\n",
    "        if dataset_name == 'digits':\n",
    "            # Apply PCA reduction to make the problem more manageable\n",
    "            pca = PCA(n_components=config.get('pca_components', 8))\n",
    "            X_pca = pca.fit_transform(X_scaled)\n",
    "            \n",
    "            # Use PCA-reduced pixel values as targets\n",
    "            y_target = X_pca  # (n_samples, pca_components)\n",
    "            \n",
    "            # Use one-hot encoded digit labels as conditioning variables\n",
    "            encoder = OneHotEncoder(sparse_output=False)\n",
    "            X_conditioning = encoder.fit_transform(y.reshape(-1, 1))  # (n_samples, 10)\n",
    "            \n",
    "            return y_target, X_conditioning, data.target_names if hasattr(data, 'target_names') else None\n",
    "        \n",
    "        else:\n",
    "            # For other classification datasets: use some features as targets, others as conditioning\n",
    "            # Add one-hot encoded class labels to conditioning variables\n",
    "            encoder = OneHotEncoder(sparse_output=False)\n",
    "            y_encoded = encoder.fit_transform(y.reshape(-1, 1))\n",
    "            \n",
    "            y_target = X_scaled[:, config['target_cols']]\n",
    "            X_conditioning = np.hstack([\n",
    "                X_scaled[:, config['conditioning_cols']],\n",
    "                y_encoded\n",
    "            ])\n",
    "            \n",
    "            return y_target, X_conditioning, data.target_names if hasattr(data, 'target_names') else None\n",
    "    \n",
    "    else:  # regression\n",
    "        # For regression: use target as y, features as X\n",
    "        y_target = y.reshape(-1, 1)\n",
    "        X_conditioning = X_scaled[:, config['conditioning_cols']]\n",
    "        \n",
    "        return y_target, X_conditioning, None\n",
    "\n",
    "def evaluate_model(model, X_test, y_test, model_name):\n",
    "    \"\"\"Evaluate a model and return key performance metrics.\"\"\"\n",
    "    try:\n",
    "        # Log-likelihood (higher is better)\n",
    "        log_likelihood = model.score(X_test, y_test)\n",
    "        \n",
    "        # Mean predictions\n",
    "        y_pred = model.predict(X_test)\n",
    "        \n",
    "        # Standard regression metrics\n",
    "        mse = mean_squared_error(y_test, y_pred)\n",
    "        r2 = r2_score(y_test, y_pred)\n",
    "        \n",
    "        # Normalized MSE for better comparison across datasets\n",
    "        target_variance = np.var(y_test)\n",
    "        normalized_mse = mse / target_variance if target_variance > 0 else mse\n",
    "        \n",
    "        # Training info\n",
    "        converged = getattr(model, 'converged_', 'N/A')\n",
    "        n_iter = getattr(model, 'n_iter_', 'N/A')\n",
    "        \n",
    "        return {\n",
    "            'model': model_name,\n",
    "            'log_likelihood': log_likelihood,\n",
    "            'mse': mse,\n",
    "            'normalized_mse': normalized_mse,\n",
    "            'r2': r2,\n",
    "            'converged': converged,\n",
    "            'n_iter': n_iter,\n",
    "            'n_components': model.n_components\n",
    "        }\n",
    "    except Exception as e:\n",
    "        return {\n",
    "            'model': model_name,\n",
    "            'log_likelihood': np.nan,\n",
    "            'mse': np.nan,\n",
    "            'normalized_mse': np.nan,\n",
    "            'r2': np.nan,\n",
    "            'converged': False,\n",
    "            'n_iter': 'N/A',\n",
    "            'n_components': model.n_components,\n",
    "            'error': str(e)\n",
    "        }\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [],
   "source": [
    "# Compare all three models on each dataset\n",
    "results = []\n",
    "\n",
    "for dataset_name, config in datasets.items():\n",
    "\n",
    "    # Prepare dataset\n",
    "    y_target, X_conditioning, class_names = prepare_dataset(dataset_name, config)\n",
    "        \n",
    "    # Split data\n",
    "    X_train, X_test, y_train, y_test = train_test_split(\n",
    "        X_conditioning, y_target, test_size=0.3, random_state=42\n",
    "    )\n",
    "    \n",
    "    # Test all three models\n",
    "    models_to_test = [\n",
    "        (\"ConditionalGMMRegressor\", ConditionalGMMRegressor(\n",
    "            n_components=config['n_components'],\n",
    "            covariance_type=\"full\",\n",
    "            random_state=42\n",
    "        )),\n",
    "        (\"MixtureOfExpertsRegressor\", MixtureOfExpertsRegressor(\n",
    "            n_components=config['n_components'],\n",
    "            covariance_type=\"full\",\n",
    "            mean_function=\"affine\",\n",
    "            random_state=42\n",
    "        )),\n",
    "        (\"DiscriminativeConditionalGMMRegressor\", DiscriminativeConditionalGMMRegressor(\n",
    "            n_components=config['n_components'],\n",
    "            covariance_type=\"full\",\n",
    "            reg_covar=1e-2,\n",
    "            random_state=42\n",
    "        ))\n",
    "    ]\n",
    "    \n",
    "    dataset_results = []\n",
    "    for model_name, model in models_to_test:\n",
    "        model.fit(X_train, y_train)\n",
    "        result = evaluate_model(model, X_test, y_test, model_name)\n",
    "        result['dataset'] = dataset_name\n",
    "        results.append(result)\n",
    "        dataset_results.append(result)\n",
    "\n",
    "    # Find best model for this dataset\n",
    "    best_result = max(dataset_results, key=lambda x: x['log_likelihood'])\n",
    "        \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RESULTS SUMMARY\n",
      "============================================================\n",
      "           Dataset                        Model Log-Likelihood    R²  Iterations\n",
      "              iris               ConditionalGMM         -1.915 0.582          11\n",
      "              iris             MixtureOfExperts         -3.881 0.424          38\n",
      "              iris DiscriminativeConditionalGMM         -1.786 0.604           6\n",
      "              wine               ConditionalGMM         -5.387 0.282           2\n",
      "              wine             MixtureOfExperts        -10.842 0.393          11\n",
      "              wine DiscriminativeConditionalGMM         -3.524 0.431           6\n",
      "     breast_cancer               ConditionalGMM          1.021 0.951          21\n",
      "     breast_cancer             MixtureOfExperts         -3.047 0.865          25\n",
      "     breast_cancer DiscriminativeConditionalGMM          1.212 0.962          17\n",
      "            digits               ConditionalGMM        -11.637 0.434          30\n",
      "            digits             MixtureOfExperts        -11.321 0.390          45\n",
      "            digits DiscriminativeConditionalGMM        -11.396 0.439          23\n",
      "california_housing               ConditionalGMM         -1.110 0.575          13\n",
      "california_housing             MixtureOfExperts         -1.081 0.412          52\n",
      "california_housing DiscriminativeConditionalGMM         -1.131 0.512         132\n",
      "          diabetes               ConditionalGMM         -5.508 0.385          56\n",
      "          diabetes             MixtureOfExperts         -5.626 0.241          18\n",
      "          diabetes DiscriminativeConditionalGMM         -5.704 0.472         200\n",
      "\n",
      "MODEL PERFORMANCE RANKINGS:\n",
      "========================================\n",
      "iris            → DiscriminativeConditionalGMM\n",
      "wine            → DiscriminativeConditionalGMM\n",
      "breast_cancer   → DiscriminativeConditionalGMM\n",
      "digits          → MixtureOfExperts\n",
      "california_housing → MixtureOfExperts\n",
      "diabetes        → ConditionalGMM\n",
      "\n",
      "Total wins:\n",
      "  ConditionalGMM: 1/6\n",
      "  MixtureOfExperts: 2/6\n",
      "  DiscriminativeConditionalGMM: 3/6\n"
     ]
    }
   ],
   "source": [
    "# Analyze results\n",
    "df_results = pd.DataFrame(results)\n",
    "\n",
    "print(\"RESULTS SUMMARY\")\n",
    "print(\"=\"*60)\n",
    "\n",
    "# Create a clean comparison table\n",
    "comparison_data = []\n",
    "for dataset in df_results['dataset'].unique():\n",
    "    dataset_results = df_results[df_results['dataset'] == dataset]\n",
    "    \n",
    "    for _, row in dataset_results.iterrows():\n",
    "        comparison_data.append({\n",
    "            'Dataset': dataset,\n",
    "            'Model': row['model'].replace('Regressor', ''),\n",
    "            'Log-Likelihood': f\"{row['log_likelihood']:.3f}\",\n",
    "            'R²': f\"{row['r2']:.3f}\",\n",
    "            'Iterations': row['n_iter']\n",
    "        })\n",
    "\n",
    "comparison_df = pd.DataFrame(comparison_data)\n",
    "print(comparison_df.to_string(index=False))\n",
    "\n",
    "# Count wins by model\n",
    "print(f\"\\nMODEL PERFORMANCE RANKINGS:\")\n",
    "print(\"=\"*40)\n",
    "\n",
    "wins = {'ConditionalGMMRegressor': 0, 'MixtureOfExpertsRegressor': 0, 'DiscriminativeConditionalGMMRegressor': 0}\n",
    "\n",
    "for dataset in df_results['dataset'].unique():\n",
    "    dataset_results = df_results[df_results['dataset'] == dataset]\n",
    "    best_model = dataset_results.loc[dataset_results['log_likelihood'].idxmax(), 'model']\n",
    "    wins[best_model] += 1\n",
    "    print(f\"{dataset:15} → {best_model.replace('Regressor', '')}\")\n",
    "\n",
    "print(f\"\\nTotal wins:\")\n",
    "for model, count in wins.items():\n",
    "    print(f\"  {model.replace('Regressor', '')}: {count}/{len(df_results['dataset'].unique())}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the results\n",
    "datasets_list = df_results['dataset'].unique()\n",
    "x = np.arange(len(datasets_list))\n",
    "width = 0.25\n",
    "\n",
    "# Extract data for all models\n",
    "cgmm_ll = [df_results[(df_results['dataset'] == d) & (df_results['model'] == 'ConditionalGMMRegressor')]['log_likelihood'].iloc[0] for d in datasets_list]\n",
    "moe_ll = [df_results[(df_results['dataset'] == d) & (df_results['model'] == 'MixtureOfExpertsRegressor')]['log_likelihood'].iloc[0] for d in datasets_list]\n",
    "disc_ll = [df_results[(df_results['dataset'] == d) & (df_results['model'] == 'DiscriminativeConditionalGMMRegressor')]['log_likelihood'].iloc[0] for d in datasets_list]\n",
    "\n",
    "cgmm_mse = [df_results[(df_results['dataset'] == d) & (df_results['model'] == 'ConditionalGMMRegressor')]['normalized_mse'].iloc[0] for d in datasets_list]\n",
    "moe_mse = [df_results[(df_results['dataset'] == d) & (df_results['model'] == 'MixtureOfExpertsRegressor')]['normalized_mse'].iloc[0] for d in datasets_list]\n",
    "disc_mse = [df_results[(df_results['dataset'] == d) & (df_results['model'] == 'DiscriminativeConditionalGMMRegressor')]['normalized_mse'].iloc[0] for d in datasets_list]\n",
    "\n",
    "cgmm_r2 = [df_results[(df_results['dataset'] == d) & (df_results['model'] == 'ConditionalGMMRegressor')]['r2'].iloc[0] for d in datasets_list]\n",
    "moe_r2 = [df_results[(df_results['dataset'] == d) & (df_results['model'] == 'MixtureOfExpertsRegressor')]['r2'].iloc[0] for d in datasets_list]\n",
    "disc_r2 = [df_results[(df_results['dataset'] == d) & (df_results['model'] == 'DiscriminativeConditionalGMMRegressor')]['r2'].iloc[0] for d in datasets_list]\n",
    "\n",
    "# Plot 1: Log-likelihood vs Median\n",
    "fig, ax = plt.subplots(figsize=(10, 6))\n",
    "for i, dataset in enumerate(datasets_list):\n",
    "    median_ll = np.median([cgmm_ll[i], moe_ll[i], disc_ll[i]])\n",
    "    cgmm_diff = cgmm_ll[i] - median_ll\n",
    "    moe_diff = moe_ll[i] - median_ll\n",
    "    disc_diff = disc_ll[i] - median_ll\n",
    "    \n",
    "    ax.bar(i - width, cgmm_diff, width, label='ConditionalGMM' if i == 0 else \"\", color='C0', alpha=0.8)\n",
    "    ax.bar(i, moe_diff, width, label='MixtureOfExperts' if i == 0 else \"\", color='C1', alpha=0.8)\n",
    "    ax.bar(i + width, disc_diff, width, label='Discriminative' if i == 0 else \"\", color='C2', alpha=0.8)\n",
    "\n",
    "ax.axhline(y=0, color='black', linestyle='-', alpha=0.5, linewidth=1)\n",
    "ax.set_xlabel('Dataset')\n",
    "ax.set_ylabel('Log-likelihood vs Median')\n",
    "ax.set_title('Model Performance: Log-likelihood vs Median')\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(datasets_list, rotation=45)\n",
    "ax.legend()\n",
    "ax.grid(True, alpha=0.3)\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "# Plot 2: Normalized MSE\n",
    "fig, ax = plt.subplots(figsize=(10, 6))\n",
    "ax.bar(x - width, cgmm_mse, width, label='ConditionalGMM', color='C0', alpha=0.8)\n",
    "ax.bar(x, moe_mse, width, label='MixtureOfExperts', color='C1', alpha=0.8)\n",
    "ax.bar(x + width, disc_mse, width, label='Discriminative', color='C2', alpha=0.8)\n",
    "ax.set_xlabel('Dataset')\n",
    "ax.set_ylabel('Normalized MSE (lower is better)')\n",
    "ax.set_title('Prediction Error: Normalized MSE')\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(datasets_list, rotation=45)\n",
    "ax.legend()\n",
    "ax.grid(True, alpha=0.3)\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "# Plot 3: R² Score\n",
    "fig, ax = plt.subplots(figsize=(10, 6))\n",
    "ax.bar(x - width, cgmm_r2, width, label='ConditionalGMM', color='C0', alpha=0.8)\n",
    "ax.bar(x, moe_r2, width, label='MixtureOfExperts', color='C1', alpha=0.8)\n",
    "ax.bar(x + width, disc_r2, width, label='Discriminative', color='C2', alpha=0.8)\n",
    "ax.set_xlabel('Dataset')\n",
    "ax.set_ylabel('R² Score (higher is better)')\n",
    "ax.set_title('Model Fit: R² Score')\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(datasets_list, rotation=45)\n",
    "ax.legend()\n",
    "ax.grid(True, alpha=0.3)\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "cgmm-3qL4zxqN-py3.11",
   "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.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}