N4_SDMetrics_review.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SDMetrics review"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notebook to perform reviewing experiments of metrics of sdv. The goal is to check that the metrics are relevant, robust and well implemented. To do this we perform the following experiment :\n",
    "* Code review : check if the metrics are well implemented.\n",
    "* Real data experiment : Test if the metrics give a good score when receiving only real data.\n",
    "* Correlation analysis : Study the correlations between the metrics to determine if some give the same information about the data.\n",
    "* Robutness experiment : Test if the metrics value are robust, does not vary when receiving the same data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sdv.tabular import GaussianCopula, CTGAN, CopulaGAN, TVAE\n",
    "import pandas as pd\n",
    "import os \n",
    "from os import path as pa\n",
    "import numpy as np\n",
    "import sdmetrics\n",
    "metrics = sdmetrics.single_table.SingleTableMetric.get_subclasses()\n",
    "import json\n",
    "from tqdm.notebook import tqdm\n",
    "import copy\n",
    "from collections import Counter\n",
    "import scipy\n",
    "from preferencefig import *\n",
    "from scipy.stats import chisquare,ks_2samp\n",
    "import seaborn as sns\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# List quality metrics (Statistical + Machine Learning Efficacy metrics)\n",
    "\n",
    "list_metric = ['LogisticDetection','SVCDetection','BinaryDecisionTreeClassifier','BinaryAdaBoostClassifier',\n",
    "'BinaryLogisticRegression','BinaryMLPClassifier','MulticlassDecisionTreeClassifier','MulticlassMLPClassifier','LinearRegression',\n",
    "'MLPRegressor','GMLogLikelihood','CSTest','KSTest','KSTestExtended','ContinuousKLDivergence','DiscreteKLDivergence']\n",
    "\n",
    "dict_metric = {}\n",
    "for met in list_metric : \n",
    "    dict_metric[met] = metrics[met]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load datasets names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_data = pd.read_csv('../Results/Result_7/Data/List_data_preprocessing2.csv',index_col=[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code review"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Identity experiment "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "l_metric = ['LogisticDetection', 'SVCDetection', 'BinaryDecisionTreeClassifier',\n",
    "       'BinaryAdaBoostClassifier', 'BinaryLogisticRegression',\n",
    "       'BinaryMLPClassifier', 'MulticlassDecisionTreeClassifier',\n",
    "       'MulticlassMLPClassifier', 'LinearRegression', 'MLPRegressor',\n",
    "       'GMLogLikelihood', 'CSTest',  'KSTest', 'KSTestExtended',\n",
    "       'ContinuousKLDivergence', 'DiscreteKLDivergence']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1d0983b8d1db4259a35e62975be84ddf",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/140 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sage_table = pd.read_csv('../Results/Result_02/Data/Table_balance.csv',index_col=[0])\n",
    "list_data = pd.Series(pd.read_csv('../Results/Result_7/Data/List_data_preprocessing2.csv',index_col=[0]).values.reshape(-1))\n",
    "experiment = 'Result_6.json'\n",
    "directory = '../T_Data/'\n",
    "not_work_mod = None\n",
    "#tab_data = pd.DataFrame(columns=['Dataset']+list(tt['metric']))\n",
    "\n",
    "j = 0\n",
    "for path in tqdm(list_data[:140]) : \n",
    "            f = open(directory+path+'/'+'metadata.json')\n",
    "            metadata1 = json.load(f)\n",
    "            f.close()\n",
    "\n",
    "            real_data = pd.read_csv(directory+path+'/Data/'+path+'.csv',index_col=[0])\n",
    "            m = np.random.permutation(len(real_data))\n",
    "\n",
    "            real_data_1 = real_data.iloc[m[:int(0.5*len(m))]]\n",
    "            real_data_2 = real_data.iloc[m[int(0.5*len(m)):]]\n",
    "            tt= sdmetrics.compute_metrics(dict_metric,real_data_1,real_data_2,metadata=metadata1[path])\n",
    "            if j==0 : \n",
    "                tab_data = pd.DataFrame(columns=['Dataset']+list(tt['metric']))\n",
    "                tab_data.loc[j] = [path]+list(tt['normalized_score'])\n",
    "                j+=1\n",
    "            else : \n",
    "                prov= pd.DataFrame(columns=['Dataset']+list(tt['metric']))\n",
    "                prov.loc[0] = [path]+list(tt['normalized_score'])\n",
    "                tab_data = pd.concat([tab_data,prov])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "tab_data.dropna(1,how='all',inplace=True)\n",
    "y_m = []\n",
    "y_std = []\n",
    "col_name = []\n",
    "for c in tab_data.columns : \n",
    "    if c!='Dataset':\n",
    "        y_m.append(tab_data[c].mean())\n",
    "        y_std.append(tab_data[c].std())\n",
    "        col_name.append(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig,ax = plt.subplots(figsize=(10,5))\n",
    "ax.errorbar(np.arange(1,len(y_m)+1),np.array(y_m),yerr = np.array(y_std),marker='o',linestyle='',label='Data')\n",
    "ax.set_xticks(np.arange(1,len(y_m)+1))\n",
    "xlim = ax.get_xlim()\n",
    "ax.plot([xlim[0],xlim[1]],[0.5,0.5],'--',color='red',label='Score = 0.5 ')\n",
    "n_columns = ['LD','SVCD','BDTC','BABC','BLR','BMLPC','MCDTC','MMLPC','LR','MLPR','GMLL','CSTest','KSTest','KSTestE','CKLD','DKLD']\n",
    "ax.set_xticklabels(n_columns)\n",
    "ax.grid(True)\n",
    "ax.set_ylabel('Mean Score over selected datasets')\n",
    "ax.set_xlim(xlim)\n",
    "plt.xticks(rotation=45)\n",
    "ax.legend()\n",
    "fig.savefig('../Results/Result_12/Figures/Score_real_3.jpeg',dpi=250)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Correlation analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use 'tab_data' from the previous part 'Identity experiment'.\n",
    "Section just after re-generate the table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ee0e77dd52e641ccb9dfd41d0c0a89e3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/140 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sage_table = pd.read_csv('../Results/Result_02/Data/Table_balance.csv',index_col=[0])\n",
    "list_data = list_data_imp = pd.Series(pd.read_csv('../Results/Result_7/Data/List_data_preprocessing2.csv',index_col=[0]).values.reshape(-1))\n",
    "experiment = 'Result_6.json'\n",
    "directory = '../T_Data/'\n",
    "not_work_mod = None\n",
    "tab_data = pd.DataFrame(columns=['Dataset']+list_metric)\n",
    "\n",
    "j = 0\n",
    "for path in tqdm(list_data[:140]) : \n",
    "            f = open(directory+path+'/'+'metadata.json')\n",
    "            metadata1 = json.load(f)\n",
    "            f.close()\n",
    "\n",
    "            real_data = pd.read_csv(directory+path+'/Data/'+path+'.csv',index_col=[0])\n",
    "            #synt_data = pd.read_csv(directory+path+'/Data/'+path+'_GC.csv',index_col=[0])\n",
    "            m = np.random.permutation(len(real_data))\n",
    "\n",
    "            real_data_1 = real_data.iloc[m[:int(0.5*len(m))]]\n",
    "            real_data_2 = real_data.iloc[m[int(0.5*len(m)):]]\n",
    "            tt= sdmetrics.compute_metrics(dict_metric,real_data_1,real_data_2,metadata=metadata1[path])\n",
    "            if j==0 : \n",
    "                tab_data.loc[j] = [path]+list(tt['normalized_score'])\n",
    "                j+=1\n",
    "            else : \n",
    "                prov= pd.DataFrame(columns=['Dataset']+list(tt['metric']))\n",
    "                prov.loc[0] = [path]+list(tt['normalized_score'])\n",
    "                tab_data = pd.concat([tab_data,prov])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "metrics_name = ['LD','SVCD','BDTC','BABC','BLR','BMLPC','MCDTC','MMLPC','LR','MLPR','GMLL','CSTest','KSTest','KSTestE','CKLD','DKLD']\n",
    "tab_data.corr()\n",
    "fig,ax = plt.subplots()\n",
    "sns.heatmap(tab_data.corr(),\n",
    "        xticklabels=metrics_name,\n",
    "        yticklabels=metrics_name)\n",
    "fig.savefig('../Results/Result_12/Figures/heatmap_2.jpeg')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Robutness experiment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check if the metrics give the same score when receiving the same data.  \n",
    " * To do this, for each dataset and every SDMetrics compute 30 time the score. \n",
    " * Then compute the standard deviation of the score.  \n",
    " * Compute the mean standard deviation and the standard deviation of the score across the datasets  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6726208633a34c278131dda48f0bff93",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/140 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m/Users/romainpalazzo/Desktop/Master_thesis/code_final/N4_SDMetrics_review.ipynb Cellule 20\u001b[0m in \u001b[0;36m<cell line: 14>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     <a href='vscode-notebook-cell:/Users/romainpalazzo/Desktop/Master_thesis/code_final/N4_SDMetrics_review.ipynb#X26sZmlsZQ%3D%3D?line=26'>27</a>\u001b[0m     dict_prov[met] \u001b[39m=\u001b[39m metrics[met]\n\u001b[1;32m     <a href='vscode-notebook-cell:/Users/romainpalazzo/Desktop/Master_thesis/code_final/N4_SDMetrics_review.ipynb#X26sZmlsZQ%3D%3D?line=27'>28</a>\u001b[0m     \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m  \u001b[39mrange\u001b[39m(num_try) : \n\u001b[0;32m---> <a href='vscode-notebook-cell:/Users/romainpalazzo/Desktop/Master_thesis/code_final/N4_SDMetrics_review.ipynb#X26sZmlsZQ%3D%3D?line=28'>29</a>\u001b[0m         t \u001b[39m=\u001b[39m sdmetrics\u001b[39m.\u001b[39;49mcompute_metrics(dict_prov,real_data,synthetic_data,metadata\u001b[39m=\u001b[39;49mmetadata[path])\n\u001b[1;32m     <a href='vscode-notebook-cell:/Users/romainpalazzo/Desktop/Master_thesis/code_final/N4_SDMetrics_review.ipynb#X26sZmlsZQ%3D%3D?line=29'>30</a>\u001b[0m         result[k,j,i] \u001b[39m=\u001b[39m t[\u001b[39m'\u001b[39m\u001b[39mnormalized_score\u001b[39m\u001b[39m'\u001b[39m]\u001b[39m.\u001b[39miloc[\u001b[39m0\u001b[39m]\n\u001b[1;32m     <a href='vscode-notebook-cell:/Users/romainpalazzo/Desktop/Master_thesis/code_final/N4_SDMetrics_review.ipynb#X26sZmlsZQ%3D%3D?line=30'>31</a>\u001b[0m k\u001b[39m+\u001b[39m\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m\n",
      "File \u001b[0;32m/opt/homebrew/Caskroom/miniforge/base/envs/master_thesis_env/lib/python3.8/site-packages/sdmetrics/__init__.py:56\u001b[0m, in \u001b[0;36mcompute_metrics\u001b[0;34m(metrics, real_data, synthetic_data, metadata, **kwargs)\u001b[0m\n\u001b[1;32m     54\u001b[0m error \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m     55\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m---> 56\u001b[0m     raw_score \u001b[39m=\u001b[39m metric\u001b[39m.\u001b[39;49mcompute(real_data, synthetic_data, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m     57\u001b[0m     normalized_score \u001b[39m=\u001b[39m metric\u001b[39m.\u001b[39mnormalize(raw_score)\n\u001b[1;32m     58\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m \u001b[39mas\u001b[39;00m err:\n",
      "File \u001b[0;32m/opt/homebrew/Caskroom/miniforge/base/envs/master_thesis_env/lib/python3.8/site-packages/sdmetrics/single_table/gaussian_mixture.py:134\u001b[0m, in \u001b[0;36mGMLogLikelihood.compute\u001b[0;34m(cls, real_data, synthetic_data, metadata, n_components, covariance_type, iterations, retries)\u001b[0m\n\u001b[1;32m    132\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39misinstance\u001b[39m(n_components, \u001b[39mint\u001b[39m) \u001b[39mor\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39misinstance\u001b[39m(covariance_type, \u001b[39mstr\u001b[39m):\n\u001b[1;32m    133\u001b[0m     LOGGER\u001b[39m.\u001b[39mdebug(\u001b[39m'\u001b[39m\u001b[39mSelecting best GMM parameters\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m--> 134\u001b[0m     best_gmm \u001b[39m=\u001b[39m \u001b[39mcls\u001b[39;49m\u001b[39m.\u001b[39;49m_select_gmm(real_data, n_components, covariance_type)\n\u001b[1;32m    135\u001b[0m     \u001b[39mif\u001b[39;00m best_gmm \u001b[39mis\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[1;32m    136\u001b[0m         \u001b[39mreturn\u001b[39;00m np\u001b[39m.\u001b[39mnan\n",
      "File \u001b[0;32m/opt/homebrew/Caskroom/miniforge/base/envs/master_thesis_env/lib/python3.8/site-packages/sdmetrics/single_table/gaussian_mixture.py:62\u001b[0m, in \u001b[0;36mGMLogLikelihood._select_gmm\u001b[0;34m(cls, real_data, n_components, covariance_type)\u001b[0m\n\u001b[1;32m     60\u001b[0m gmm \u001b[39m=\u001b[39m GaussianMixture(n_components\u001b[39m=\u001b[39mn_components, covariance_type\u001b[39m=\u001b[39mcovariance_type)\n\u001b[1;32m     61\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m---> 62\u001b[0m     gmm\u001b[39m.\u001b[39;49mfit(real_data)\n\u001b[1;32m     63\u001b[0m     bic \u001b[39m=\u001b[39m gmm\u001b[39m.\u001b[39mbic(real_data)\n\u001b[1;32m     64\u001b[0m     LOGGER\u001b[39m.\u001b[39mdebug(\u001b[39m'\u001b[39m\u001b[39m%s\u001b[39;00m\u001b[39m, \u001b[39m\u001b[39m%s\u001b[39;00m\u001b[39m: \u001b[39m\u001b[39m%s\u001b[39;00m\u001b[39m'\u001b[39m, n_components, covariance_type, bic)\n",
      "File \u001b[0;32m/opt/homebrew/Caskroom/miniforge/base/envs/master_thesis_env/lib/python3.8/site-packages/sklearn/mixture/_base.py:193\u001b[0m, in \u001b[0;36mBaseMixture.fit\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m    171\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mfit\u001b[39m(\u001b[39mself\u001b[39m, X, y\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m):\n\u001b[1;32m    172\u001b[0m     \u001b[39m\"\"\"Estimate model parameters with the EM algorithm.\u001b[39;00m\n\u001b[1;32m    173\u001b[0m \n\u001b[1;32m    174\u001b[0m \u001b[39m    The method fits the model ``n_init`` times and sets the parameters with\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    191\u001b[0m \u001b[39m    self\u001b[39;00m\n\u001b[1;32m    192\u001b[0m \u001b[39m    \"\"\"\u001b[39;00m\n\u001b[0;32m--> 193\u001b[0m     \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfit_predict(X, y)\n\u001b[1;32m    194\u001b[0m     \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\n",
      "File \u001b[0;32m/opt/homebrew/Caskroom/miniforge/base/envs/master_thesis_env/lib/python3.8/site-packages/sklearn/mixture/_base.py:238\u001b[0m, in \u001b[0;36mBaseMixture.fit_predict\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m    235\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_print_verbose_msg_init_beg(init)\n\u001b[1;32m    237\u001b[0m \u001b[39mif\u001b[39;00m do_init:\n\u001b[0;32m--> 238\u001b[0m     \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_initialize_parameters(X, random_state)\n\u001b[1;32m    240\u001b[0m lower_bound \u001b[39m=\u001b[39m (\u001b[39m-\u001b[39mnp\u001b[39m.\u001b[39minfty \u001b[39mif\u001b[39;00m do_init \u001b[39melse\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mlower_bound_)\n\u001b[1;32m    242\u001b[0m \u001b[39mfor\u001b[39;00m n_iter \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(\u001b[39m1\u001b[39m, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mmax_iter \u001b[39m+\u001b[39m \u001b[39m1\u001b[39m):\n",
      "File \u001b[0;32m/opt/homebrew/Caskroom/miniforge/base/envs/master_thesis_env/lib/python3.8/site-packages/sklearn/mixture/_base.py:147\u001b[0m, in \u001b[0;36mBaseMixture._initialize_parameters\u001b[0;34m(self, X, random_state)\u001b[0m\n\u001b[1;32m    145\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39minit_params \u001b[39m==\u001b[39m \u001b[39m'\u001b[39m\u001b[39mkmeans\u001b[39m\u001b[39m'\u001b[39m:\n\u001b[1;32m    146\u001b[0m     resp \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mzeros((n_samples, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_components))\n\u001b[0;32m--> 147\u001b[0m     label \u001b[39m=\u001b[39m cluster\u001b[39m.\u001b[39;49mKMeans(n_clusters\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mn_components, n_init\u001b[39m=\u001b[39;49m\u001b[39m1\u001b[39;49m,\n\u001b[1;32m    148\u001b[0m                            random_state\u001b[39m=\u001b[39;49mrandom_state)\u001b[39m.\u001b[39;49mfit(X)\u001b[39m.\u001b[39mlabels_\n\u001b[1;32m    149\u001b[0m     resp[np\u001b[39m.\u001b[39marange(n_samples), label] \u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n\u001b[1;32m    150\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39minit_params \u001b[39m==\u001b[39m \u001b[39m'\u001b[39m\u001b[39mrandom\u001b[39m\u001b[39m'\u001b[39m:\n",
      "File \u001b[0;32m/opt/homebrew/Caskroom/miniforge/base/envs/master_thesis_env/lib/python3.8/site-packages/sklearn/cluster/_kmeans.py:1016\u001b[0m, in \u001b[0;36mKMeans.fit\u001b[0;34m(self, X, y, sample_weight)\u001b[0m\n\u001b[1;32m   1012\u001b[0m best_inertia \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m   1014\u001b[0m \u001b[39mfor\u001b[39;00m i \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_n_init):\n\u001b[1;32m   1015\u001b[0m     \u001b[39m# Initialize centers\u001b[39;00m\n\u001b[0;32m-> 1016\u001b[0m     centers_init \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_init_centroids(\n\u001b[1;32m   1017\u001b[0m         X, x_squared_norms\u001b[39m=\u001b[39;49mx_squared_norms, init\u001b[39m=\u001b[39;49minit,\n\u001b[1;32m   1018\u001b[0m         random_state\u001b[39m=\u001b[39;49mrandom_state)\n\u001b[1;32m   1019\u001b[0m     \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mverbose:\n\u001b[1;32m   1020\u001b[0m         \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39mInitialization complete\u001b[39m\u001b[39m\"\u001b[39m)\n",
      "File \u001b[0;32m/opt/homebrew/Caskroom/miniforge/base/envs/master_thesis_env/lib/python3.8/site-packages/sklearn/cluster/_kmeans.py:934\u001b[0m, in \u001b[0;36mKMeans._init_centroids\u001b[0;34m(self, X, x_squared_norms, init, random_state, init_size)\u001b[0m\n\u001b[1;32m    931\u001b[0m     n_samples \u001b[39m=\u001b[39m X\u001b[39m.\u001b[39mshape[\u001b[39m0\u001b[39m]\n\u001b[1;32m    933\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(init, \u001b[39mstr\u001b[39m) \u001b[39mand\u001b[39;00m init \u001b[39m==\u001b[39m \u001b[39m'\u001b[39m\u001b[39mk-means++\u001b[39m\u001b[39m'\u001b[39m:\n\u001b[0;32m--> 934\u001b[0m     centers, _ \u001b[39m=\u001b[39m _kmeans_plusplus(X, n_clusters,\n\u001b[1;32m    935\u001b[0m                                   random_state\u001b[39m=\u001b[39;49mrandom_state,\n\u001b[1;32m    936\u001b[0m                                   x_squared_norms\u001b[39m=\u001b[39;49mx_squared_norms)\n\u001b[1;32m    937\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39misinstance\u001b[39m(init, \u001b[39mstr\u001b[39m) \u001b[39mand\u001b[39;00m init \u001b[39m==\u001b[39m \u001b[39m'\u001b[39m\u001b[39mrandom\u001b[39m\u001b[39m'\u001b[39m:\n\u001b[1;32m    938\u001b[0m     seeds \u001b[39m=\u001b[39m random_state\u001b[39m.\u001b[39mpermutation(n_samples)[:n_clusters]\n",
      "File \u001b[0;32m/opt/homebrew/Caskroom/miniforge/base/envs/master_thesis_env/lib/python3.8/site-packages/sklearn/cluster/_kmeans.py:123\u001b[0m, in \u001b[0;36m_kmeans_plusplus\u001b[0;34m(X, n_clusters, x_squared_norms, random_state, n_local_trials)\u001b[0m\n\u001b[1;32m    119\u001b[0m np\u001b[39m.\u001b[39mclip(candidate_ids, \u001b[39mNone\u001b[39;00m, closest_dist_sq\u001b[39m.\u001b[39msize \u001b[39m-\u001b[39m \u001b[39m1\u001b[39m,\n\u001b[1;32m    120\u001b[0m         out\u001b[39m=\u001b[39mcandidate_ids)\n\u001b[1;32m    122\u001b[0m \u001b[39m# Compute distances to center candidates\u001b[39;00m\n\u001b[0;32m--> 123\u001b[0m distance_to_candidates \u001b[39m=\u001b[39m euclidean_distances(\n\u001b[1;32m    124\u001b[0m     X[candidate_ids], X, Y_norm_squared\u001b[39m=\u001b[39;49mx_squared_norms, squared\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m)\n\u001b[1;32m    126\u001b[0m \u001b[39m# update closest distances squared and potential for each candidate\u001b[39;00m\n\u001b[1;32m    127\u001b[0m np\u001b[39m.\u001b[39mminimum(closest_dist_sq, distance_to_candidates,\n\u001b[1;32m    128\u001b[0m            out\u001b[39m=\u001b[39mdistance_to_candidates)\n",
      "File \u001b[0;32m/opt/homebrew/Caskroom/miniforge/base/envs/master_thesis_env/lib/python3.8/site-packages/sklearn/utils/validation.py:63\u001b[0m, in \u001b[0;36m_deprecate_positional_args.<locals>._inner_deprecate_positional_args.<locals>.inner_f\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     61\u001b[0m extra_args \u001b[39m=\u001b[39m \u001b[39mlen\u001b[39m(args) \u001b[39m-\u001b[39m \u001b[39mlen\u001b[39m(all_args)\n\u001b[1;32m     62\u001b[0m \u001b[39mif\u001b[39;00m extra_args \u001b[39m<\u001b[39m\u001b[39m=\u001b[39m \u001b[39m0\u001b[39m:\n\u001b[0;32m---> 63\u001b[0m     \u001b[39mreturn\u001b[39;00m f(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m     65\u001b[0m \u001b[39m# extra_args > 0\u001b[39;00m\n\u001b[1;32m     66\u001b[0m args_msg \u001b[39m=\u001b[39m [\u001b[39m'\u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m=\u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m'\u001b[39m\u001b[39m.\u001b[39mformat(name, arg)\n\u001b[1;32m     67\u001b[0m             \u001b[39mfor\u001b[39;00m name, arg \u001b[39min\u001b[39;00m \u001b[39mzip\u001b[39m(kwonly_args[:extra_args],\n\u001b[1;32m     68\u001b[0m                                  args[\u001b[39m-\u001b[39mextra_args:])]\n",
      "File \u001b[0;32m/opt/homebrew/Caskroom/miniforge/base/envs/master_thesis_env/lib/python3.8/site-packages/sklearn/metrics/pairwise.py:272\u001b[0m, in \u001b[0;36meuclidean_distances\u001b[0;34m(X, Y, Y_norm_squared, squared, X_norm_squared)\u001b[0m\n\u001b[1;32m    202\u001b[0m \u001b[39m@_deprecate_positional_args\u001b[39m\n\u001b[1;32m    203\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39meuclidean_distances\u001b[39m(X, Y\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, \u001b[39m*\u001b[39m, Y_norm_squared\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, squared\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m,\n\u001b[1;32m    204\u001b[0m                         X_norm_squared\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m):\n\u001b[1;32m    205\u001b[0m     \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m    206\u001b[0m \u001b[39m    Considering the rows of X (and Y=X) as vectors, compute the\u001b[39;00m\n\u001b[1;32m    207\u001b[0m \u001b[39m    distance matrix between each pair of vectors.\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    270\u001b[0m \u001b[39m           [1.41421356]])\u001b[39;00m\n\u001b[1;32m    271\u001b[0m \u001b[39m    \"\"\"\u001b[39;00m\n\u001b[0;32m--> 272\u001b[0m     X, Y \u001b[39m=\u001b[39m check_pairwise_arrays(X, Y)\n\u001b[1;32m    274\u001b[0m     \u001b[39m# If norms are passed as float32, they are unused. If arrays are passed as\u001b[39;00m\n\u001b[1;32m    275\u001b[0m     \u001b[39m# float32, norms needs to be recomputed on upcast chunks.\u001b[39;00m\n\u001b[1;32m    276\u001b[0m     \u001b[39m# TODO: use a float64 accumulator in row_norms to avoid the latter.\u001b[39;00m\n\u001b[1;32m    277\u001b[0m     \u001b[39mif\u001b[39;00m X_norm_squared \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n",
      "File \u001b[0;32m/opt/homebrew/Caskroom/miniforge/base/envs/master_thesis_env/lib/python3.8/site-packages/sklearn/utils/validation.py:63\u001b[0m, in \u001b[0;36m_deprecate_positional_args.<locals>._inner_deprecate_positional_args.<locals>.inner_f\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     61\u001b[0m extra_args \u001b[39m=\u001b[39m \u001b[39mlen\u001b[39m(args) \u001b[39m-\u001b[39m \u001b[39mlen\u001b[39m(all_args)\n\u001b[1;32m     62\u001b[0m \u001b[39mif\u001b[39;00m extra_args \u001b[39m<\u001b[39m\u001b[39m=\u001b[39m \u001b[39m0\u001b[39m:\n\u001b[0;32m---> 63\u001b[0m     \u001b[39mreturn\u001b[39;00m f(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m     65\u001b[0m \u001b[39m# extra_args > 0\u001b[39;00m\n\u001b[1;32m     66\u001b[0m args_msg \u001b[39m=\u001b[39m [\u001b[39m'\u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m=\u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m'\u001b[39m\u001b[39m.\u001b[39mformat(name, arg)\n\u001b[1;32m     67\u001b[0m             \u001b[39mfor\u001b[39;00m name, arg \u001b[39min\u001b[39;00m \u001b[39mzip\u001b[39m(kwonly_args[:extra_args],\n\u001b[1;32m     68\u001b[0m                                  args[\u001b[39m-\u001b[39mextra_args:])]\n",
      "File \u001b[0;32m/opt/homebrew/Caskroom/miniforge/base/envs/master_thesis_env/lib/python3.8/site-packages/sklearn/metrics/pairwise.py:149\u001b[0m, in \u001b[0;36mcheck_pairwise_arrays\u001b[0;34m(X, Y, precomputed, dtype, accept_sparse, force_all_finite, copy)\u001b[0m\n\u001b[1;32m    145\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m    146\u001b[0m     X \u001b[39m=\u001b[39m check_array(X, accept_sparse\u001b[39m=\u001b[39maccept_sparse, dtype\u001b[39m=\u001b[39mdtype,\n\u001b[1;32m    147\u001b[0m                     copy\u001b[39m=\u001b[39mcopy, force_all_finite\u001b[39m=\u001b[39mforce_all_finite,\n\u001b[1;32m    148\u001b[0m                     estimator\u001b[39m=\u001b[39mestimator)\n\u001b[0;32m--> 149\u001b[0m     Y \u001b[39m=\u001b[39m check_array(Y, accept_sparse\u001b[39m=\u001b[39;49maccept_sparse, dtype\u001b[39m=\u001b[39;49mdtype,\n\u001b[1;32m    150\u001b[0m                     copy\u001b[39m=\u001b[39;49mcopy, force_all_finite\u001b[39m=\u001b[39;49mforce_all_finite,\n\u001b[1;32m    151\u001b[0m                     estimator\u001b[39m=\u001b[39;49mestimator)\n\u001b[1;32m    153\u001b[0m \u001b[39mif\u001b[39;00m precomputed:\n\u001b[1;32m    154\u001b[0m     \u001b[39mif\u001b[39;00m X\u001b[39m.\u001b[39mshape[\u001b[39m1\u001b[39m] \u001b[39m!=\u001b[39m Y\u001b[39m.\u001b[39mshape[\u001b[39m0\u001b[39m]:\n",
      "File \u001b[0;32m/opt/homebrew/Caskroom/miniforge/base/envs/master_thesis_env/lib/python3.8/site-packages/sklearn/utils/validation.py:63\u001b[0m, in \u001b[0;36m_deprecate_positional_args.<locals>._inner_deprecate_positional_args.<locals>.inner_f\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     61\u001b[0m extra_args \u001b[39m=\u001b[39m \u001b[39mlen\u001b[39m(args) \u001b[39m-\u001b[39m \u001b[39mlen\u001b[39m(all_args)\n\u001b[1;32m     62\u001b[0m \u001b[39mif\u001b[39;00m extra_args \u001b[39m<\u001b[39m\u001b[39m=\u001b[39m \u001b[39m0\u001b[39m:\n\u001b[0;32m---> 63\u001b[0m     \u001b[39mreturn\u001b[39;00m f(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m     65\u001b[0m \u001b[39m# extra_args > 0\u001b[39;00m\n\u001b[1;32m     66\u001b[0m args_msg \u001b[39m=\u001b[39m [\u001b[39m'\u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m=\u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m'\u001b[39m\u001b[39m.\u001b[39mformat(name, arg)\n\u001b[1;32m     67\u001b[0m             \u001b[39mfor\u001b[39;00m name, arg \u001b[39min\u001b[39;00m \u001b[39mzip\u001b[39m(kwonly_args[:extra_args],\n\u001b[1;32m     68\u001b[0m                                  args[\u001b[39m-\u001b[39mextra_args:])]\n",
      "File \u001b[0;32m/opt/homebrew/Caskroom/miniforge/base/envs/master_thesis_env/lib/python3.8/site-packages/sklearn/utils/validation.py:720\u001b[0m, in \u001b[0;36mcheck_array\u001b[0;34m(array, accept_sparse, accept_large_sparse, dtype, order, copy, force_all_finite, ensure_2d, allow_nd, ensure_min_samples, ensure_min_features, estimator)\u001b[0m\n\u001b[1;32m    716\u001b[0m         \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mFound array with dim \u001b[39m\u001b[39m%d\u001b[39;00m\u001b[39m. \u001b[39m\u001b[39m%s\u001b[39;00m\u001b[39m expected <= 2.\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[1;32m    717\u001b[0m                          \u001b[39m%\u001b[39m (array\u001b[39m.\u001b[39mndim, estimator_name))\n\u001b[1;32m    719\u001b[0m     \u001b[39mif\u001b[39;00m force_all_finite:\n\u001b[0;32m--> 720\u001b[0m         _assert_all_finite(array,\n\u001b[1;32m    721\u001b[0m                            allow_nan\u001b[39m=\u001b[39;49mforce_all_finite \u001b[39m==\u001b[39;49m \u001b[39m'\u001b[39;49m\u001b[39mallow-nan\u001b[39;49m\u001b[39m'\u001b[39;49m)\n\u001b[1;32m    723\u001b[0m \u001b[39mif\u001b[39;00m ensure_min_samples \u001b[39m>\u001b[39m \u001b[39m0\u001b[39m:\n\u001b[1;32m    724\u001b[0m     n_samples \u001b[39m=\u001b[39m _num_samples(array)\n",
      "File \u001b[0;32m/opt/homebrew/Caskroom/miniforge/base/envs/master_thesis_env/lib/python3.8/site-packages/sklearn/utils/validation.py:96\u001b[0m, in \u001b[0;36m_assert_all_finite\u001b[0;34m(X, allow_nan, msg_dtype)\u001b[0m\n\u001b[1;32m     91\u001b[0m \u001b[39m# First try an O(n) time, O(1) space solution for the common case that\u001b[39;00m\n\u001b[1;32m     92\u001b[0m \u001b[39m# everything is finite; fall back to O(n) space np.isfinite to prevent\u001b[39;00m\n\u001b[1;32m     93\u001b[0m \u001b[39m# false positives from overflow in sum method. The sum is also calculated\u001b[39;00m\n\u001b[1;32m     94\u001b[0m \u001b[39m# safely to reduce dtype induced overflows.\u001b[39;00m\n\u001b[1;32m     95\u001b[0m is_float \u001b[39m=\u001b[39m X\u001b[39m.\u001b[39mdtype\u001b[39m.\u001b[39mkind \u001b[39min\u001b[39;00m \u001b[39m'\u001b[39m\u001b[39mfc\u001b[39m\u001b[39m'\u001b[39m\n\u001b[0;32m---> 96\u001b[0m \u001b[39mif\u001b[39;00m is_float \u001b[39mand\u001b[39;00m (np\u001b[39m.\u001b[39misfinite(_safe_accumulator_op(np\u001b[39m.\u001b[39;49msum, X))):\n\u001b[1;32m     97\u001b[0m     \u001b[39mpass\u001b[39;00m\n\u001b[1;32m     98\u001b[0m \u001b[39melif\u001b[39;00m is_float:\n",
      "File \u001b[0;32m/opt/homebrew/Caskroom/miniforge/base/envs/master_thesis_env/lib/python3.8/site-packages/sklearn/utils/extmath.py:686\u001b[0m, in \u001b[0;36m_safe_accumulator_op\u001b[0;34m(op, x, *args, **kwargs)\u001b[0m\n\u001b[1;32m    663\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_safe_accumulator_op\u001b[39m(op, x, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[1;32m    664\u001b[0m     \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m    665\u001b[0m \u001b[39m    This function provides numpy accumulator functions with a float64 dtype\u001b[39;00m\n\u001b[1;32m    666\u001b[0m \u001b[39m    when used on a floating point input. This prevents accumulator overflow on\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    684\u001b[0m \u001b[39m        The output of the accumulator function passed to this function.\u001b[39;00m\n\u001b[1;32m    685\u001b[0m \u001b[39m    \"\"\"\u001b[39;00m\n\u001b[0;32m--> 686\u001b[0m     \u001b[39mif\u001b[39;00m np\u001b[39m.\u001b[39;49missubdtype(x\u001b[39m.\u001b[39;49mdtype, np\u001b[39m.\u001b[39;49mfloating) \u001b[39mand\u001b[39;00m x\u001b[39m.\u001b[39mdtype\u001b[39m.\u001b[39mitemsize \u001b[39m<\u001b[39m \u001b[39m8\u001b[39m:\n\u001b[1;32m    687\u001b[0m         result \u001b[39m=\u001b[39m op(x, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs, dtype\u001b[39m=\u001b[39mnp\u001b[39m.\u001b[39mfloat64)\n\u001b[1;32m    688\u001b[0m     \u001b[39melse\u001b[39;00m:\n",
      "File \u001b[0;32m/opt/homebrew/Caskroom/miniforge/base/envs/master_thesis_env/lib/python3.8/site-packages/numpy/core/numerictypes.py:417\u001b[0m, in \u001b[0;36missubdtype\u001b[0;34m(arg1, arg2)\u001b[0m\n\u001b[1;32m    358\u001b[0m \u001b[39m@set_module\u001b[39m(\u001b[39m'\u001b[39m\u001b[39mnumpy\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[1;32m    359\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39missubdtype\u001b[39m(arg1, arg2):\n\u001b[1;32m    360\u001b[0m     \u001b[39mr\u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m    361\u001b[0m \u001b[39m    Returns True if first argument is a typecode lower/equal in type hierarchy.\u001b[39;00m\n\u001b[1;32m    362\u001b[0m \n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    415\u001b[0m \n\u001b[1;32m    416\u001b[0m \u001b[39m    \"\"\"\u001b[39;00m\n\u001b[0;32m--> 417\u001b[0m     \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m issubclass_(arg1, generic):\n\u001b[1;32m    418\u001b[0m         arg1 \u001b[39m=\u001b[39m dtype(arg1)\u001b[39m.\u001b[39mtype\n\u001b[1;32m    419\u001b[0m     \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m issubclass_(arg2, generic):\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "list_metrics = ['LogisticDetection', 'SVCDetection', 'BinaryDecisionTreeClassifier',\n",
    "       'BinaryAdaBoostClassifier', 'BinaryLogisticRegression',\n",
    "       'BinaryMLPClassifier', 'MulticlassDecisionTreeClassifier',\n",
    "       'MulticlassMLPClassifier', 'LinearRegression', 'MLPRegressor',\n",
    "       'GMLogLikelihood', 'CSTest',  'KSTest', 'KSTestExtended',\n",
    "       'ContinuousKLDivergence', 'DiscreteKLDivergence']\n",
    "metrics = sdmetrics.single_table.SingleTableMetric.get_subclasses()\n",
    "num_dataset = len(list_data)\n",
    "num_met = len(list_metrics)\n",
    "num_try = 30\n",
    "\n",
    "result = np.zeros((num_dataset,num_met,num_try))\n",
    "k = 0\n",
    "for path in tqdm(list_data[:140]): \n",
    "    f = open(directory+'/'+path+'/'+'metadata.json') \n",
    "    metadata=json.load(f)\n",
    "    f.close()\n",
    "\n",
    "    f = open(directory+'/'+path+'/'+'dict_info.json') \n",
    "    dict_info=json.load(f)\n",
    "    f.close()\n",
    "    \n",
    "    real_data = pd.read_csv(directory+path+'/Data/'+path+'.csv',index_col=[0])\n",
    "    synthetic_data = pd.read_csv(directory+path+'/Data/'+path+'_GC.csv',index_col=[0])\n",
    "    for j,met in enumerate(list_metric) : \n",
    "        dict_prov = {}\n",
    "        dict_prov[met] = metrics[met]\n",
    "        for i in  range(num_try) : \n",
    "            t = sdmetrics.compute_metrics(dict_prov,real_data,synthetic_data,metadata=metadata[path])\n",
    "            result[k,j,i] = t['normalized_score'].iloc[0]\n",
    "    k+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "result2 = result[~np.all(np.all(result == 0, axis=2),axis=1)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot robutness"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x_n = ['LD','SVCD','BDTC','BABC','BLR','BMLPC','MCDTC','MMLPC','LR','MLPR','GMLL','CSTest','KSTest','KSTestE','CKLD','DKLD']\n",
    "x = np.arange(len(x_n))\n",
    "y = np.nanmean(result2.std(axis=2),axis=0)\n",
    "y_err = np.nanstd(result2.std(axis=2),axis=0)\n",
    "fig,ax = plt.subplots()\n",
    "ax.errorbar(x,y,yerr=y_err,marker='o',linestyle='')\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(x_n,rotation=45)\n",
    "ax.set_ylabel('Mean Standard \\\\newline deviation across datasets')\n",
    "ax.grid(True)\n",
    "fig.savefig('../Results/Result_12/Figures/MET_ROB.jpeg',dpi=250)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.12 ('master_thesis_env')",
   "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.8.12"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "fb94901783c70338e2565c51f5548ab85eea424b621152c27cc477f4c97d257c"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}