RegressionEnsembleFULL.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "xCKN5sheT-la"
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "import EnsembleINIT as Ensemble # Init new models\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "qj04wvWVazY4"
   },
   "outputs": [],
   "source": [
    "data = {'real_estate' : ['https://raw.githubusercontent.com/ostapkharysh/PublicDatasets/master/Regression/Real%20estate.csv', ['X2 house age', 'X3 distance to the nearest MRT station', 'X4 number of convenience stores'], 'Y house price of unit area' ],\n",
    "        'cancer_reg' : ['https://raw.githubusercontent.com/ostapkharysh/PublicDatasets/master/Regression/cancer_reg.csv', ['avgAnnCount', 'avgDeathsPerYear', 'incidenceRate', 'medIncome', 'popEst2015', \n",
    "                        'povertyPercent', 'studyPerCap', 'MedianAge', 'AvgHouseholdSize', 'PercentMarried', 'BirthRate', 'PctWhite', 'PctBlack', 'PctAsian', 'PctOtherRace'], 'TARGET_deathRate'],\n",
    "        'insurance_charge' : ['https://raw.githubusercontent.com/ostapkharysh/PublicDatasets/master/Regression/insuranceCharge.csv', ['age', 'bmi', 'children'], 'charges'], \n",
    "        'bike' : ['https://raw.githubusercontent.com/ostapkharysh/PublicDatasets/master/Regression/bike_hour.csv', ['hr', 'holiday', 'weathersit', 'temp', 'atemp','hum', 'windspeed'], 'cnt'],\n",
    "         }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "WrWEVs0MnyE7"
   },
   "outputs": [],
   "source": [
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.svm import SVR\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn.linear_model import LinearRegression, LassoLars, ElasticNetCV, BayesianRidge, ARDRegression\n",
    "from sklearn import metrics\n",
    "\n",
    "def reg_train(x_train, y_train):\n",
    "        \"\"\"\n",
    "        Returns trained  regression models \n",
    "        \"\"\"\n",
    "        estimators = dict()\n",
    "        \n",
    "        estimators['svr'] = SVR()\n",
    "        params = {'epsilon':[0.1, 0.01, 0.2, 0.5]}\n",
    "    \n",
    "        estimators['svr'] = GridSearchCV(estimators['svr'], params)\n",
    "        estimators['svr'].fit(x_train, y_train)\n",
    "\n",
    "        estimators['rfr'] = RandomForestRegressor()\n",
    "        params = {'max_depth':[1, 1.5, 0.5, 0.1, 2, 5]}\n",
    "        estimators['rfr'] = GridSearchCV(estimators['rfr'], params)\n",
    "        estimators['rfr'].fit(x_train, y_train)\n",
    "\n",
    "        estimators['dtr'] = DecisionTreeRegressor()\n",
    "        #params = {'criterion':['squared_error', 'friedman_mse', 'absolute_error']}\n",
    "        params = {'max_depth':[1, 1.5, 0.5, 0.1, 2, 5]}\n",
    "        estimators['dtr'] = GridSearchCV(estimators['dtr'], params)\n",
    "        estimators['dtr'].fit(x_train, y_train)\n",
    "\n",
    "        estimators['lin'] = LinearRegression()\n",
    "        params = {'fit_intercept':[True, False]}\n",
    "        estimators['lin'] = GridSearchCV(estimators['lin'], params)\n",
    "        estimators['lin'].fit(x_train, y_train)\n",
    "        \n",
    "        estimators['lasso'] = LassoLars(alpha=.1, normalize=False) #Least Angle Regression\n",
    "        params = {'fit_intercept':[True, False]}\n",
    "        estimators['lasso'] = GridSearchCV(estimators['lasso'], params)\n",
    "        estimators['lasso'].fit(x_train, y_train)\n",
    "        \n",
    "        estimators['elastic'] = ElasticNetCV()\n",
    "        estimators['elastic'] = GridSearchCV(estimators['elastic'], params)\n",
    "        estimators['elastic'].fit(x_train, y_train)\n",
    "        \n",
    "        estimators['bayes'] = BayesianRidge()\n",
    "        estimators['bayes'] = GridSearchCV(estimators['bayes'], params)\n",
    "        estimators['bayes'].fit(x_train, y_train)\n",
    "        \n",
    "        estimators['ARD'] = ARDRegression()\n",
    "        estimators['ARD'] = GridSearchCV(estimators['ARD'], params)\n",
    "        estimators['ARD'].fit(x_train, y_train)\n",
    "\n",
    "        return estimators\n",
    "\n",
    "def reg_scoring(y, yhat):\n",
    "    \"\"\"\n",
    "    Returns regression scores\n",
    "    \"\"\"\n",
    "    scores = dict()\n",
    "    scores['mae'] = metrics.mean_absolute_error(y, yhat)\n",
    "    scores['mse'] = metrics.mean_squared_error(y, yhat)\n",
    "    scores['squared_error'] = np.square(np.subtract(y, yhat))\n",
    "    scores['rmse'] = scores['mse']**(0.5) \n",
    "    return scores\n",
    "\n",
    "def reg_prediction(df, df_competition, line, X, Y):\n",
    "    \"\"\"\n",
    "    Predict Y for regression and record the error\n",
    "    \"\"\"\n",
    "    # Declare the vars\n",
    "    errors = dict()\n",
    "    errors = {'svr':[], 'lin': [], 'dtr':[], 'rfr':[], 'lasso':[], 'elastic': [], 'bayes': [], 'ARD': []}\n",
    "    \n",
    "    ######### TRAIN THE MODEL ###########\n",
    "    #x_train = df.drop(columns = [target_column[line]])\n",
    "    #y_train = df[target_column[line]]\n",
    "    \n",
    "    x_train = df[X]\n",
    "    y_train = df[Y]\n",
    "    \n",
    "    estimators = reg_train(x_train.values, y_train.values) # train estimators\n",
    "\n",
    "    ######### TEST THE MODEL ###########\n",
    "    x_competition = df_competition[X]\n",
    "    y_competition = df_competition[Y]\n",
    "    \n",
    "    ######### SCORE THE MODEL ###########\n",
    "    for est in estimators.keys():\n",
    "        y_est = estimators[est].predict(x_competition.values)\n",
    "        errors[est] = reg_scoring(y=y_competition, yhat=y_est)['squared_error']\n",
    "\n",
    "    # return the data\n",
    "    return errors, estimators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "XUzlqbcI0jjb",
    "outputId": "29a5d2a9-d505-4154-e675-2c920fd0077a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset: real_estate\n",
      "worked\n",
      "real_estate\n",
      "(289, 8)\n",
      "(125, 8)\n",
      "Estimators Finished\n",
      "Beta 3\n",
      "[96, 192, 288]\n",
      "Part Completed\n",
      "Beta 3\n",
      "[96, 192, 288]\n",
      "Part Completed\n",
      "Beta 3\n",
      "[96, 192, 288]\n",
      "Part Completed\n",
      "Beta 3\n",
      "[96, 192, 288]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[57, 114, 171, 228, 285]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[57, 114, 171, 228, 285]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[57, 114, 171, 228, 285]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[57, 114, 171, 228, 285]\n",
      "Part Completed\n",
      "Assembly Finished\n",
      "Dataset: cancer_reg\n",
      "cancer_reg\n",
      "(413, 32)\n",
      "(178, 32)\n",
      "Estimators Finished\n",
      "Beta 3\n",
      "[137, 274, 411]\n",
      "Part Completed\n",
      "Beta 3\n",
      "[137, 274, 411]\n",
      "Part Completed\n",
      "Beta 3\n",
      "[137, 274, 411]\n",
      "Part Completed\n",
      "Beta 3\n",
      "[137, 274, 411]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[82, 164, 246, 328, 410]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[82, 164, 246, 328, 410]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[82, 164, 246, 328, 410]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[82, 164, 246, 328, 410]\n",
      "Part Completed\n",
      "Assembly Finished\n",
      "Dataset: insurance_charge\n",
      "insurance_charge\n",
      "(936, 4)\n",
      "(402, 4)\n",
      "Estimators Finished\n",
      "Beta 3\n",
      "[312, 624, 936]\n",
      "Part Completed\n",
      "Beta 3\n",
      "[312, 624, 936]\n",
      "Part Completed\n",
      "Beta 3\n",
      "[312, 624, 936]\n",
      "Part Completed\n",
      "Beta 3\n",
      "[312, 624, 936]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[187, 374, 561, 748, 935]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[187, 374, 561, 748, 935]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[187, 374, 561, 748, 935]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[187, 374, 561, 748, 935]\n",
      "Part Completed\n",
      "Assembly Finished\n",
      "Dataset: bike\n",
      "bike\n",
      "(12165, 15)\n",
      "(5214, 15)\n",
      "Estimators Finished\n",
      "Beta 3\n",
      "[4055, 8110, 12165]\n",
      "Part Completed\n",
      "Beta 3\n",
      "[4055, 8110, 12165]\n",
      "Part Completed\n",
      "Beta 3\n",
      "[4055, 8110, 12165]\n",
      "Part Completed\n",
      "Beta 3\n",
      "[4055, 8110, 12165]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[2433, 4866, 7299, 9732, 12165]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[2433, 4866, 7299, 9732, 12165]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[2433, 4866, 7299, 9732, 12165]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[2433, 4866, 7299, 9732, 12165]\n",
      "Part Completed\n",
      "Assembly Finished\n"
     ]
    }
   ],
   "source": [
    "results = {}\n",
    "columns_to_drop = [[],['Geography','binnedInc'],['sex','smoker','region'],['instant','dteday']]\n",
    "\n",
    "for idx, el in enumerate(data):\n",
    "        print(\"Dataset: \" + el)\n",
    "\n",
    "        results[el] = list()\n",
    "        \n",
    "        df = pd.read_csv(data[el][0], encoding=\"ISO-8859-1\")\n",
    "        df.drop(columns = columns_to_drop[idx],inplace = True)\n",
    "        df = df.dropna()\n",
    "        \n",
    "        if el == 'real_estate':\n",
    "            print(\"worked\")\n",
    "            df = df.round(1)\n",
    "        ds, competition = train_test_split(df, test_size=0.3)\n",
    "        ds = ds.reset_index(drop=True)\n",
    "        competition = competition.reset_index(drop=True)\n",
    "        print(el)\n",
    "        print(ds.shape)\n",
    "        print(competition.shape)\n",
    "        \n",
    "        #Estimators to compare\n",
    "        m_errors, estimators = reg_prediction(ds,competition,idx, X=data[el][1], Y=data[el][2])\n",
    "        print(\"Estimators Finished\")\n",
    "        \n",
    "        #Beta = 3\n",
    "        \n",
    "        #Assembly without priority\n",
    "        assembly = Ensemble.analyze_ensemble(learning_ds=ds, competition_ds=competition, X=data[el][1], Y=data[el][2],\n",
    "                                                         priority = False, beta=3)\n",
    "        m_errors[\"Ens3\"] = assembly['squared_error']\n",
    "        \n",
    "        #Assembly with priority\n",
    "        assembly = Ensemble.analyze_ensemble(learning_ds=ds, competition_ds=competition, X=data[el][1], Y=data[el][2],\n",
    "                                                         priority = True, beta=3)\n",
    "        m_errors[\"Ens3Priority\"] = assembly['squared_error']\n",
    "        \n",
    "        #Assembly without priority + exp\n",
    "        assembly = Ensemble.analyze_ensemble(learning_ds=ds, competition_ds=competition, X=data[el][1], Y=data[el][2],\n",
    "                                                         priority = False, approach='exp', beta=3)\n",
    "        m_errors[\"EXPEns3\"] = assembly['squared_error']\n",
    "        #Assembly with priority + exp\n",
    "        assembly = Ensemble.analyze_ensemble(learning_ds=ds, competition_ds=competition, X=data[el][1], Y=data[el][2],\n",
    "                                                         priority = True, approach='exp', beta=3)\n",
    "        m_errors[\"EXPEns3priority\"] = assembly['squared_error']\n",
    "        \n",
    "        \n",
    "        #Beta = 5\n",
    "        #Assembly without priority\n",
    "        assembly = Ensemble.analyze_ensemble(learning_ds=ds, competition_ds=competition, X=data[el][1], Y=data[el][2],\n",
    "                                                         priority = False, beta=5)\n",
    "        m_errors[\"Ens5\"] = assembly['squared_error']\n",
    "        \n",
    "        #Assembly with priority\n",
    "        assembly = Ensemble.analyze_ensemble(learning_ds=ds, competition_ds=competition, X=data[el][1], Y=data[el][2],\n",
    "                                                         priority = True, beta=5)\n",
    "        m_errors[\"Ens5Priority\"] = assembly['squared_error']\n",
    "        \n",
    "        #Assembly without priority + exp\n",
    "        assembly = Ensemble.analyze_ensemble(learning_ds=ds, competition_ds=competition, X=data[el][1], Y=data[el][2],\n",
    "                                                         priority = False, approach='exp', beta=5)\n",
    "        m_errors[\"EXPEns5\"] = assembly['squared_error']\n",
    "        #Assembly with priority + exp\n",
    "        assembly = Ensemble.analyze_ensemble(learning_ds=ds, competition_ds=competition, X=data[el][1], Y=data[el][2],\n",
    "                                                         priority = True, approach='exp', beta=5)\n",
    "        m_errors[\"EXPEns5priority\"] = assembly['squared_error']\n",
    "        \n",
    "        \n",
    "        #TOGETHER\n",
    "        results[el].append(m_errors)\n",
    "        print(\"Assembly Finished\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'real_estate': ['https://raw.githubusercontent.com/ostapkharysh/PublicDatasets/master/Regression/Real%20estate.csv',\n",
       "  ['X2 house age',\n",
       "   'X3 distance to the nearest MRT station',\n",
       "   'X4 number of convenience stores'],\n",
       "  'Y house price of unit area'],\n",
       " 'cancer_reg': ['https://raw.githubusercontent.com/ostapkharysh/PublicDatasets/master/Regression/cancer_reg.csv',\n",
       "  ['avgAnnCount',\n",
       "   'avgDeathsPerYear',\n",
       "   'incidenceRate',\n",
       "   'medIncome',\n",
       "   'popEst2015',\n",
       "   'povertyPercent',\n",
       "   'studyPerCap',\n",
       "   'MedianAge',\n",
       "   'AvgHouseholdSize',\n",
       "   'PercentMarried',\n",
       "   'BirthRate',\n",
       "   'PctWhite',\n",
       "   'PctBlack',\n",
       "   'PctAsian',\n",
       "   'PctOtherRace'],\n",
       "  'TARGET_deathRate'],\n",
       " 'insurance_charge': ['https://raw.githubusercontent.com/ostapkharysh/PublicDatasets/master/Regression/insuranceCharge.csv',\n",
       "  ['age', 'bmi', 'children'],\n",
       "  'charges'],\n",
       " 'bike': ['https://raw.githubusercontent.com/ostapkharysh/PublicDatasets/master/Regression/bike_hour.csv',\n",
       "  ['hr', 'holiday', 'weathersit', 'temp', 'atemp', 'hum', 'windspeed'],\n",
       "  'cnt']}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "VcfqLXFT0jjb",
    "outputId": "f65e8734-f77e-4dfb-f60f-58c5a02f4329"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "real_estate\n",
      "              svr         lin         dtr         rfr       lasso     elastic  \\\n",
      "count  125.000000  125.000000  125.000000  125.000000  125.000000  125.000000   \n",
      "mean    60.104737   71.880394   60.021217   58.511012   71.749792   74.404305   \n",
      "std     90.549145  120.017102  109.417920  105.471815  119.779597  114.537613   \n",
      "min      0.001732    0.015037    0.056982    0.000072    0.009506    0.000270   \n",
      "25%      4.267419    7.177952    4.075352    5.671454    7.264546    5.568088   \n",
      "50%     26.960345   29.047934   19.830322   20.813285   29.002519   23.709456   \n",
      "75%     70.457916   86.556692   65.306602   56.926759   87.035377  103.930294   \n",
      "max    514.851694  771.916627  711.111111  589.464713  768.971416  697.144341   \n",
      "\n",
      "            bayes          ARD        Ens3  Ens3Priority     EXPEns3  \\\n",
      "count  125.000000   125.000000  125.000000    125.000000  125.000000   \n",
      "mean    71.267757   105.827610   63.656095     70.455492   64.362693   \n",
      "std    119.057797   149.394222   96.212429    119.031516   96.670873   \n",
      "min      0.004701     0.189057    0.000301      0.000126    0.003782   \n",
      "25%      6.522384    12.689272    6.033319      6.210466    6.822484   \n",
      "50%     29.643290    50.798015   27.609997     26.757935   27.316984   \n",
      "75%     85.149802   152.048821   79.974857     83.122946   80.994798   \n",
      "max    756.313969  1005.628786  589.054414    746.987353  587.364168   \n",
      "\n",
      "       EXPEns3priority          Ens5  Ens5Priority     EXPEns5  \\\n",
      "count       125.000000  1.250000e+02    125.000000  125.000000   \n",
      "mean         70.455492  6.071175e+01     72.257239   63.373596   \n",
      "std         119.031516  9.294974e+01    121.754511   95.124841   \n",
      "min           0.000126  3.428062e-07      0.012403    0.007153   \n",
      "25%           6.210466  6.611655e+00      6.996465    6.246602   \n",
      "50%          26.757935  2.360490e+01     29.044052   26.253851   \n",
      "75%          83.122946  7.345650e+01     83.422412   78.978121   \n",
      "max         746.987353  5.660569e+02    778.897150  570.660871   \n",
      "\n",
      "       EXPEns5priority  \n",
      "count       125.000000  \n",
      "mean         72.257239  \n",
      "std         121.754511  \n",
      "min           0.012403  \n",
      "25%           6.996465  \n",
      "50%          29.044052  \n",
      "75%          83.422412  \n",
      "max         778.897150  \n",
      "svr                 7.752724\n",
      "lin                 8.478231\n",
      "dtr                 7.747336\n",
      "rfr                 7.649249\n",
      "lasso               8.470525\n",
      "elastic             8.625793\n",
      "bayes               8.442023\n",
      "ARD                10.287255\n",
      "Ens3                7.978477\n",
      "Ens3Priority        8.393777\n",
      "EXPEns3             8.022636\n",
      "EXPEns3priority     8.393777\n",
      "Ens5                7.791775\n",
      "Ens5Priority        8.500426\n",
      "EXPEns5             7.960754\n",
      "EXPEns5priority     8.500426\n",
      "dtype: float64\n",
      "cd= 11.533772666176985\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x198 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cancer_reg\n",
      "                svr          lin          dtr          rfr        lasso  \\\n",
      "count    178.000000   178.000000   178.000000   178.000000   178.000000   \n",
      "mean     817.307332   520.721464   586.677546   477.361783   519.383308   \n",
      "std     1444.447648   908.278660  1033.445806   926.661169   907.441458   \n",
      "min        0.002813     0.039072     0.006194     0.000172     0.185030   \n",
      "25%       69.842843    28.860608    35.645121    33.370812    28.740711   \n",
      "50%      299.808725   159.710862   200.594513   121.332578   149.980991   \n",
      "75%      884.772168   518.036628   771.515924   472.084413   514.437706   \n",
      "max    12785.550229  5871.137251  8708.864342  7346.935329  5849.835869   \n",
      "\n",
      "            elastic        bayes          ARD         Ens3  Ens3Priority  \\\n",
      "count    178.000000   178.000000   178.000000   178.000000    178.000000   \n",
      "mean     719.799420   528.710848   509.761736   582.044040    519.290118   \n",
      "std     1281.052983   914.073710   861.026083  1043.029542    886.728893   \n",
      "min        0.029148     0.013626     0.002092     0.002772      0.008198   \n",
      "25%       79.250713    41.695620    26.224033    35.665660     35.709642   \n",
      "50%      272.080806   167.766831   156.448900   207.943414    181.431444   \n",
      "75%      772.668193   622.921954   580.631984   644.343076    557.946961   \n",
      "max    11332.452670  5735.623086  5518.713691  8504.831139   6295.165269   \n",
      "\n",
      "           EXPEns3  EXPEns3priority         Ens5  Ens5Priority      EXPEns5  \\\n",
      "count   178.000000       178.000000   178.000000    178.000000   178.000000   \n",
      "mean    604.341038       503.876486   626.601014    708.315716   584.016154   \n",
      "std    1084.137313       957.551711  1212.342463   1256.979897  1134.350514   \n",
      "min       0.002297         0.063989     0.035985      0.000259     0.005610   \n",
      "25%      35.922924        36.764612    53.509587     69.956262    41.064314   \n",
      "50%     217.046784       144.058043   183.045587    272.121029   182.547326   \n",
      "75%     652.577210       523.643678   528.431728    798.372981   488.403242   \n",
      "max    8986.139859      7840.256561  9614.021135  11065.965641  9049.221249   \n",
      "\n",
      "       EXPEns5priority  \n",
      "count       178.000000  \n",
      "mean        708.315716  \n",
      "std        1256.979897  \n",
      "min           0.000259  \n",
      "25%          69.956262  \n",
      "50%         272.121029  \n",
      "75%         798.372981  \n",
      "max       11065.965641  \n",
      "svr                28.588587\n",
      "lin                22.819322\n",
      "dtr                24.221427\n",
      "rfr                21.848611\n",
      "lasso              22.789983\n",
      "elastic            26.829078\n",
      "bayes              22.993713\n",
      "ARD                22.577904\n",
      "Ens3               24.125589\n",
      "Ens3Priority       22.787938\n",
      "EXPEns3            24.583349\n",
      "EXPEns3priority    22.447193\n",
      "Ens5               25.032000\n",
      "Ens5Priority       26.614201\n",
      "EXPEns5            24.166426\n",
      "EXPEns5priority    26.614201\n",
      "dtype: float64\n",
      "cd= 11.533772666176985\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAADUCAYAAACI/Qg0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAAAzzklEQVR4nO3dfVyN9/8H8Ff35yRSctym3JTqdE6nE8XQnW+5a1TMKCTMjMnd5Gb7udkYxiYtxmbDzAgT+9KPGVINo0jM3IvSVxiRlO7evz98u34OlUo6dXk/H48enOv6fD7X53POud59zqdzvS8dIiIwxhgTDV1td4AxxljN4sDOGGMiw4GdMcZEhgM7Y4yJDAd2xhgTGQ7sjDEmMhzYGWNMZDiwM8aYyHBgZ4wxkeHAzhhjIsOBnTHGRIYDO6u0W7duYciQIWjfvj1cXFzQt29fXLx4EVKpFM7OzrC3t4erqyvWr1+v7a4y9kbT13YHWP1ARAgICEBISAi2bNkCADh9+jSysrLQvn17nDp1CgBw9epVBAYGgogQGhqqzS4z9sbiGTurlEOHDsHAwADjxo0Ttjk5OcHS0lKjXLt27fDVV18hMjKytrvIGPsvDuysUs6ePQsXF5dKlVWr1Th//vxr7hFjrDwc2FmN4xT/jGkXB3ZWKXK5HMnJyZUqe+rUKdjb27/mHjHGysOBnVWKt7c3njx5gm+//VbYlpqaivT0dI1yaWlp+OijjzBx4sTa7iJj7L90+NZ4rLIyMzMxefJkJCcnQyKRwNraGhEREVAqlbCzs0N+fj4aNmyI8ePHY+TIkdruLmNvLA7sjDEmMrwUIyJjx47Vdhdq1Zs2XsYqiwO7iGRmZmq7C7XqTRsvY5XFgZ0xxkSGAztjjIkM//FURNq0aQOlUqntbtSa1NRU3LhxQ9vdYKzO4SRgIqJUKrF7925td6PW+Pn5absLjNVJvBTDGGMiw4FdRFq2bKntLtSqN228jFUWr7EzxpjI8IydMcZEhgM7Y4yJDAd2xhgTGQ7sjDEmMhzYGWNMZDiwM8aYyHBgZ4wxkeHALgKjRo2CTCaDo6OjsC09PR1eXl5wcHCAXC7HihUrkJ+fD1dXVzg5OUEul2Pu3LlC+eLiYjg7OwuX6VtbW0OhUEClUqFTp04AgOzsbAwaNAh2dnawt7fH0aNHceHCBahUKuGnUaNGiIiIwPLlyyGXy+Ho6IihQ4ciPz8fK1asgJmZGfT19dGiRQvh2MHBwTA0NISRkRF8fHxw//59bNu2DWZmZtDR0UH79u2FsgqFAvr6+pBIJAgICEB2djZUKhX09fUhlUrh6+uLzMxM4Tlp3rw5dHR0cPfuXTg7O0NPTw9SqRQqlQqxsbEYNWoUGjZsCCMjI8jlcoSHh6Nt27YwMDCAVCqFtbU1VCoVUlJSIJPJhO3Hjx9Heno6OnfuDGNjY0gkEsjlcpw7dw49evSAiYkJjIyM0LFjR9y/fx/ffPMNGjRoAB0dHbRr1w4rVqxAeno62rRpAyMjI0gkEiiVSpw9exbW1taQSCSQSCSws7PDiRMnhNeydDynT58W+imRSNCqVSts2LABXl5eaN68OYyMjNC8eXOMGzcOMplMaM/c3BwqlQp79+5Fo0aNIJFIIJVKMXXqVADA6dOn0bVrVygUCrz99tt4+PDha33vsteEWL13+PBhSk5OJrlcLmzLzMyk5ORkIiJ6+PAh2djY0NmzZyknJ4eIiAoKCsjV1ZWOHj1KRERffvklDR06lPr160dERFZWVnTnzh2N44wYMYK+++47IiJ68uQJ3b9/X2N/UVERNWvWjI4dO0bW1tb0+PFjIiJ655136LPPPiO5XE779u2jP//8kxo0aECXLl0iIqIhQ4bQhx9+SHK5nBYtWkTh4eF07tw52rhxI6nVamrXrp1wjGXLltGff/5JcrmcwsPDKTw8nGJjY4Xxr1ixgt5//306fPgw7dmzhxo0aEBt2rShO3fu0MiRI2nSpEkaz9Py5cupc+fO5ODgQEREWVlZGs/n1KlTaf78+eTj40NLliyh5ORksrKyIg8PD8rMzCR7e3uKi4ujhw8fUrNmzWjYsGE0YsQIWrRoET18+JCaNGlCo0aNosOHD9Mvv/xCHh4eFBcXRzY2NhQXF0dRUVFUWFhIDx8+JDMzMxoyZAgdPnxYeN2aNm1Kb7/9NiUnJ9ONGzfI29ub9PX1aefOnTR27FhaunSp8PrGxcXR6tWrqWfPnnTnzh2ysbGhHTt2aLwPGjduTBMmTCB3d3eKjIwkIqJt27aRVCqlv/76izp16kRxcXFERPT999/TJ598UvU3JNM6nrGLgLu7O8zNzTW2tWjRAmq1GgDQsGFD2NvbIzMzEyYmJgCAwsJCFBYWQkdHBxkZGdizZw/GjBlT7jEePHiA+Ph4jB49GgBgaGiIxo0ba5Q5cOAA2rdvj9atW6OoqAh5eXkoKirC48ePkZ+fDzc3N/j6+kImk6FBgwbYsWMHAODkyZMYPnw4ACAkJAQ7d+6Evb09hg0bBgMDA41jTJs2DTKZDADQpUsXZGRkoE+fPsL4c3NzoaOjA3d3d3z99dfCDBcArKysYGxsrNHekSNHEBYWJpSRyWQaz+fWrVsxdOhQ6OjowMrKCubm5iguLkbLli3RokUL3Lx5E+7u7mjYsCGUSiUOHz6MY8eOISQkBA0bNoSLiwv27dsHd3d3BAYGAgAaNGgAe3t7FBQUYMKECdDX10fDhg3RoUMHZGVlwd3dXXjdLCwsUFJSArVajSlTpuCrr76CgYEBCgsLhU89pa9vQUEBDhw4gJkzZ8LCwgL29vYwMTER3gcmJibIz89Hp06dIJFIhOexsLAQ5ubmuHnzJi5evCgc38fHB7/88ku57wlWd3FgfwOkpaXh1KlTcHNzQ3FxMVQqFWQyGXx8fODm5obJkyfjiy++gK7u/78ddHR04OvrCxcXF3z77be4du0amjZtitDQUDg7O2PMmDHIzc3VOM6WLVswdOhQtGrVCh999BHatGmDFi1awNTUFMHBwUhISMA///yDvLw85OTkID09HQCQlZUlBJnmzZsjKyurUuP64Ycf0KdPHwDA0qVLceHCBWzatAmffvopdu3ahebNm0MikWjU+fHHH3H58mWMGjUK9+/fx8WLF3HixAlcvXoVHh4eOHHihFD28ePHaNasGWxsbBAREYHp06eja9euuHXrFhYtWgQAkMvl2LVrF9LS0nDixAncu3cPWVlZaNGiBdLS0vD3338jJydHow+ZmZnC6/Hsa3TmzBkMHToUAPDxxx+jRYsWuHz5MiIjI7Fr1y60atUKpqamKCgogIuLCwAgKioKdnZ2OHDgAGxtbXHx4kUkJCRApVJh37590Nf//wSuW7duRXFxMQIDA4XxWFpaYvLkySAiuLm5CeMBgG3btgmvEatntP2RgdWMa9euaSwxlMrJySG1Wk2//PKLxvb79++Tp6cnRUVF0QcffEBERIcOHRKWYjIyMojo6dKEUqmkNWvWkJ6eHh07doyIiMLCwjQ+pj958oSaNGlCt27donv37pGXlxfdvn2bCgoKaMCAAbRx40Zau3YtqdVq6ty5M5mZmdGkSZOIiMjU1FSj/40bNxbadXNz01iKKR2rTCYjf39/Kikp0Rj/559/TrNmzSJXV1c6ffo0yeVyYVnp1q1bdPnyZZLL5TR79mwKDQ0luVxOI0aMILlcTn/++SdZW1tTSUkJXbt2jczMzGjZsmVERDRx4kTavn07Xbt2jVq3bk09e/YkIqK///6bvLy8SCqV0uDBg8nc3JxMTU01nvdnx9O9e3eys7PTeD1ycnKoZcuW5OrqKoyntH5QUJAwnoyMDFKr1dS0aVNhPNnZ2aRWqykwMFAYz9ixY0mtVtPixYuF8eTk5JCFhQWFhIRojCcnJ4fatm1LCoVCGI+Pjw+p1WqaN28emZubV/CuY3UVB3aRKCuwFxQUkK+vL3355Zdl1pk/fz55eXlRq1atyMrKipo1a0ZSqZSCg4M1ys2dO5f+53/+h6ysrIRt8fHx1LdvX+Hxzp07ycfHh4iItm7dSqNGjRL2bdiwQfjlUdpXCwsLWrlyJRER2draCuvmmZmZZGtrK5QtK7AvXbqUpFIp5ebmvjD+69evU/v27alp06bUqlUrMjAwID09PbK0tKT//Oc/QrnSf3v16kU///yz8Ny1a9eObt++TZcuXSI9PT1KT08nIqJGjRoJAV8ul1PDhg1feI4vXLhAnTt3JhsbG/Lw8KAvv/xSYzwFBQVkZmZGkydP1niNSn/5lI7n2TZLx2NhYUESiYTMzMyE8dy4cUMoV9ovHx8f6tSpk/Cat2vXjm7evEk+Pj5kYmKiMZ4nT56Qr68vLVu2TBjPs0rHw+ofXooRKSLC6NGjYW9vL3zj4c6dO8jOzgYA5OXlYf/+/Zg6dSoyMjKQlpaGLVu2wNvbG2vWrBGWD3Jzc/Hbb7/hrbfegqWlJS5cuADg6Xq6g4ODcLzNmzcLywht2rTBsWPH8PjxYxARDhw4AHt7e9y+fRsAcPPmTTx8+BBBQUEAgP79+wtruRs2bMCAAQPKHdfevXuxevVqjfXyS5cuCft37doFlUqF27dvIzExEba2tmjdujVOnjwJeiaRaUxMDBwdHeHv74+jR48CAC5evIiCggJYWFjgjz/+gJGREVq3bg3gaYrgw4cPC8+JjY0NiAjBwcGwt7fH5MmTsWDBArz//vvCGvjUqVOF8ZS+HsbGxggODhZeoz59+iAzMxMnTpyAsbExiAjvvPOO8Lrt2rULTk5O6NOnD95//33cu3cPrVu3RnJyMqZOnSqUi4mJgVwux8OHD6Grq4upU6fi4sWLePLkCWbOnAljY2Oo1WphPC1atICfnx/s7e2hUqlgY2MDAMJrVFJSggULFmDcuHGVer+xOkaLv1RYDRkyZAg1b96c9PX1qVWrVrR27VpKSEggAKRQKMjJyYmcnJwoKiqKVCoVKRQKksvlNH/+fI12Spdirly5QkqlkpRKJTk4ONCCBQuIiOjUqVPk4uJCCoWCBgwYQPfu3SMiokePHpG5uTllZ2cLbc2ZM4c6duxIcrmchg0bRvn5+dS9e3dq1KgR6evrk56entDXgIAAMjQ0JABkZGREK1asoB07dpBUKiUAwva1a9eSiYkJ6erqEgAyMDAgDw8Pat26Nenr6xMAkkgktHTpUo3nRE9Pj5YvX05WVlYa5ZYtW0aDBw8miUQitDdt2jQaMmQISaVS0tXV1Xg+zczMSF9fn3R0dEgmk9GMGTMIABkaGpKhoSHJZDJasmQJAaAGDRqQoaEhmZiY0JYtW2jhwoUEgHR0dEhfX58aNmxIX3zxhXBciURCEomE3NzchPFKJBJq1KgRffzxxxqvpYGBAc2ZM+eFcp988gkBoMaNG5NEIiGpVEpjx44lAGRmZkatW7cmJycn2rNnD61cuVJ4HoyNjcnW1pb27NlDERERZGNjQzY2NjRjxgxhaYjVL5yPnTHGRIaXYhhjTGQ4sDPGmMhwYGeMMZHhwM4YYyLDgV1Exo4dW+1tr1q/prdxf+pGf1j9xIFdRDIzM6u97VXr1/Q27k/d6A+rnziwi5TYZ5Lcn9fbH1a/cWAXKbHPJLk/r7c/rH7jC5RExN7eXrgpRWpqKpRKpfDvy7ZVpw63U/12SpWWu3fvHp48eQIjIyN4enq+0M69e/dgbm6Oe/fuCfvj4uLg6elZ7rFL6zx7nLL6U9rOlStX8Pfff7/kXcbqAw7sjGmBn58fdu/eLfwfAPbv3w8fHx9h+7OaNWuGzp07A4BGvbLKPl+nojKVaYfVP7wUwxhjIsOBnTHGRIYDO2OMiQwHdsYYExkO7IwxJjIc2BljTGQ4sDPGmMhwYGeMMZHhwM4YYyLDgZ0xxkSGAztjjIkM54phrBZMnjwZKSkpwuMzZ85AoVAI/weA+/fvw8zMTNj+rCNHjqBhw4YAoFGvrLLP16moTHntqFQqREREvHRcrG7iwM5YLfD09MThw4e13Y1K8/DwQFxcnLa7wapJX9sdYOxNoFKpNB7Xhxk7q794xs6YFnDaXvY68R9PGWNMZDiwM8aYyHBgZ4wxkeHAzhhjIsOBnTHGRIYDO2OMiQwHdsYYExkO7Fqybds22Nvbw8vLS9tdYYyJDAd2LSAifPfdd/juu+9w6NAhjX1FRUVa6hVjta+4uFjbXRAlDuy1JC0tDR07dsSIESOgq6uL/fv3Y/To0Zg+fTrWr1+P/v37w9vbGz179tR2VxmrstzcXPTr1w9OTk5wdHTEhg0b8M477wj74+LihCtsTUxMMG3aNDg5OeHo0aPa6rKocWCvRZcuXcL48eNBRPDw8MCmTZuwdOlSAMDJkyexffv2epUoirFSe/fuRcuWLXH69GmcPXsW/v7++PPPP5GbmwsAiI6OxpAhQwA8/SXg5uaG06dPo3v37trstmhxErBaZGVlhS5dupS5z8fHB+bm5i9tY+zYscjMzKzprrFaJpVKtd0FgVQqFWbT5WnZsiW+/fbbcvcrFApMmzYNM2bMgJ+fH3r06IHevXvj3//+NwYNGoQ9e/bgiy++AADo6elh4MCBNToGpokDey1q0KBBtfY9q6KTi7Hq2LZt2yu3YWtri5MnTyI2NhaffPIJevbsiSFDhiAqKgrm5ubo1KmTkJ1SIpFAT0/vlY/JysdLMYyxV5aZmQljY2MMGzYM06dPx8mTJ+Hh4YGTJ0/iu+++E5ZhWO3gGTtj7JWdOXMG06dPh66uLgwMDPDNN99AT08Pfn5+WL9+PTZs2KDtLr5ROLDXEmtra5w9e1Z4/OzdaUaOHImRI0fWfqcYqyG9evVCr169XtgeFRWFqKgojW2PHj2qrW69sXgphjHGRIYDO2OMiQwHdsYYExkO7IwxJjIc2BljTGRea2DX09ODSqUSfhYvXozi4mK4uLggPj5eKOfr6ytcJGFtbQ2FQgGlUglfX1/cunVLY3tpW2FhYVXuT35+PlxdXeHk5AS5XI65c+dWuY1ff/0VixcvrnadnTt34ty5c1U+LmP1kbW1Ne7evVvleuvXr9e4wnrMmDF83lTBa/26o1QqRUpKygvbV61ahffeew/JycnYvn07dHV1NRIGHTp0CBYWFpg9ezY+//xzREZGamyvLiMjIxw8eBAmJiYoLCxE9+7d0adPn3Iv839eUVER+vfvj/79+1f6mM/X2blzJ/z8/ODg4FCtMTD2Jli/fj0cHR3RsmVLAMDatWu13KP6RStLMW5ubujatSvmzZuH2bNnv/A911Lu7u64fPlyhW15enpixowZcHV1ha2tLRISEgAAf/31F1xdXaFSqaBUKnHp0iXo6OjAxMQEAFBYWIjCwkLo6OgAeDqzCA8Ph0KhgKurq3DckSNHYty4cXBzc0N4eDjWr1+PDz/8EMDTjI3e3t5QKpXo2bMnbty4UWGdI0eO4Ndff8X06dOhUqlw5coVqNVqYSyXLl3SeMxYffLTTz8J59z777//Qkpef39/uLi4QC6XC6kxiouLMXLkSDg6OkKhUGD58uXYvn07kpKSEBwcDJVKhby8PHh6eiIpKQnA04RjarUaTk5OnA21HK91xp6XlweVSiU8njVrFt59910AwKJFi2BpaYnJkyejQ4cOZdbfvXs3FAqF8NjLy0vIMRESEoIpU6YAeDorPn78OGJjYzF//nz8/vvvWL16NSZNmoTg4GAUFBQIb7LSpaDLly9jwoQJcHNzE9o3NTXFmTNn8OOPP2Ly5MnYvXs3ACAjIwNHjhyBnp4e1q9fL5SfOHEiQkJCEBISgh9++AFhYWHYuXNnuXXeeust9O/fH35+fhg0aJBwzJSUFKhUKqxbtw6hoaHVfLYZ056///4b0dHR+OOPP2BgYIDx48dj06ZNGmV++OEHmJubIy8vD507d8bAgQORlpaGmzdvChfvZWdno3HjxoiKisKyZcvQqVMnjTbu3LmD9957D/Hx8Wjbti3u3btXa2OsT7SyFAMA8fHxMDU11bgas1RpAFcqlViwYIGwvbylmMDAQACAi4sL0tLSAABdu3bFwoULkZGRgcDAQNjY2AB4uu6fkpKC7OxsBAQE4OzZs3B0dAQADB06VPi39JcGALzzzjtlJi06evQoduzYAQAYPnw4wsPDX1rneWPGjMG6devw1VdfITo6GsePH39pHcbqmgMHDiA5ORmdO3cG8HRSJ5PJNMpERkYiJiYGAJCeno5Lly6hY8eOuHr1KiZOnIh+/frB19e3wuMcO3YM7u7uaNu2LQBUKiPqm0grKQVyc3MRHh6OgwcPIjQ0FLGxsejbt6+wv6pr6UZGRgCeBu3SOxAFBQXBzc0Ne/bsQd++fbFmzRp4e3sLdRo3bgwvLy/s3btXCOylyzLP/7+ymRefVdk6AwcOxPz58+Ht7Q0XFxc0adKkwvKctld8pFIp8vLyXlvbL0vJWxkvS9tLRAgJCcGiRYs0tpd+Wo2Li8Pvv/+Oo0ePwtjYGJ6ensjPz4eZmRlOnz6Nffv2YfXq1di6dSt++OGHV+7vm04rgf3TTz/F4MGDYWdnh1WrVmHIkCHw9vaGRCKpsWNcvXoV7dq1Q1hYGG7cuIHU1FQoFAoYGBigcePGyMvLw/79+zFjxgyhTnR0NGbOnIno6Gh07dr1pcd46623sGXLFgwfPhybNm1Cjx49XlqnYcOGyMnJER5LJBL06tULH3zwAb7//vuX1ue0veJUE8G3LDWRkrcyevbsiQEDBmDKlCmQyWS4d++exvv8wYMHMDMzg7GxMc6fP49jx44BAO7evQtDQ0MMHDgQHTt2xLBhwwC8eJ6U6tKlC8aPH49r164JSzE8a39Rra6x9+7dG8OHD0dMTAxOnz4NAHB2dkavXr2wZMmSl3798Nk1dqVSiR9//LHcslu3bsXGjRthYGCA5s2bY/bs2cjIyEBISAiKi4tRUlKCwYMHa5xQ9+/fh1KphJGRETZv3vzS8X399dcIDQ3F0qVL0bRpU6xbt+6ldYYMGYL33nsPkZGR2L59O9q3b4/g4GDExMS89GMoY3WVg4MDFixYAF9fX5SUlMDAwAArV64U9vfu3RurV6+Gvb09OnbsKHwT7ebNmwgNDUVJSQkACDP+0i8gSKVSjdvnNW3aFN9++y0CAwNRUlICmUyG/fv31+JI6wcdIiJtd6IusLa2RlJS0it9nbK6li1bhgcPHuCzzz6r9WOzusHPzw/79++Hj4+P8Ef7ZzVr1kxYvy7d7+fnV2bZZ+tkZWW9ng6zOo3T9mpZQEAArly5goMHD2q7K4wxkeDA/l+l36apbaXfEmCMsZrCuWIYY0xkOLAzxpjIcGBnjDGR4cDOGGMiw4G9BuzcuRM6Ojo4f/48gKd/iJVKpVCpVHBwcMCIESNQWFgI4OkVeKampnB2dkbHjh3h7u5e4VfWGKsv6lqa7ufbeT7vTGUkJSVV+djP1omLi8ORI0eqfNxXxd+KqQGbN29G9+7dsXnzZsyfPx8A0L59e6SkpKC4uBg+Pj7YunUrgoODAQA9evQQgnlKSgr8/f0hlUo5Ux2r1+pamu7n26+qoqIidOrUqUq/EJ6vExcXBxMTE7z11ltVPv6r4Bn7K3r06BESExPx/fffY8uWLS/s19PTg6urK27evFlmfZVKhTlz5pSbupix+k5babpf1s6kSZOgUqng6OgoJN+bN28ehg8fjm7dumH48OGIi4sTrk6/d+8e/P39oVQq0aVLF6SmplZYJy0tDatXr8by5cuhUqmQkJCAtm3bCp/eHz58qPG4JnFgf0W7du1C7969YWtriyZNmiA5OVljf35+Pv7880/07t273DbUarWwjMNYfVWaQqT0Jzo6Wti3aNEiREREICgoqEppukvbWr58ubC9NE13RESE8Am5NE13SkoKkpKS0Lp1awBPk/n5+vrCxcXlhTxLjx8/RkpKClatWoVRo0YJ28+dO4fff//9hbQic+fOhbOzM1JTU/H5559jxIgRFdaxtrbGuHHjMGXKFKSkpKBHjx7w9PTEnj17AABbtmxBYGAgDAwMKvcEVwEvxbyizZs3Y9KkSQCe5oHZvHkzPvzwQ1y5cgUqlQrXrl1Dv379oFQqy22jKlkdOLujOEml0hpvU1dXt8aSi70suyNQN9N0JyYmolWrVrh9+zZ8fHxgZ2cHd3d3AP+fptvd3R0PHz5EdnY2AKB///5lvh6JiYn45ZdfAADe3t74559/8PDhwwrrPG/MmDH44osv4O/vj3Xr1uG77757aZ3q4MD+Cu7du4eDBw/izJkz0NHRQXFxMXR0dDBhwgRhjf3u3bvo1q0bfv3113JvqXfq1CnY29tX6pic3VG8StNP1xQXF5c68Yd5babpbtWqFQBAJpMhICAAx48fFwL7s6m5n338OtN0d+vWDWlpaYiLi0NxcbGQMrym8VLMK9i+fTuGDx+O69evIy0tDenp6Wjbti3S09OFMhYWFli8ePELeapLpaam4rPPPsOECRNqq9uM1arn03RPmTIF+fn5NXqMZ9N0DxgwAKmpqcjNzRVS/+bm5uK3337TCKSlS0WJiYkwNTWFqalphcfo0aOHcFeouLg4WFhYoFGjRhXWKSv98IgRIxAUFPRa75bGM/ZXsHnzZo187sDTG2c8H8T9/f0xb9484Q89CQkJcHZ2xuPHjyGTyRAZGcnfiGH1Xl1L052VlYWAgAAAT9flg4KCNP7WJZFI4OzsjMLCwkrd3GPevHkYNWoUlEoljI2NsWHDhpfWefvttzFo0CDs2rULX3/9NXr06IHg4GB88sknwlLQ68BpexmrI4yMjGo0be/L9r/JPD09y7ynam3Yvn07du3ahY0bN762Y/CMnTHGasnEiRPxv//7v4iNjX2tx+HAzhh748TFxWnluF9//XWtHIf/eMoYYyLDgZ0xxkSGAztjjIlMvQnsZWWOq6rr169DrVZDpVJBLpdj9erVwr7yssw9r2/fvsIVapVVWic7OxurVq2qcr8Zqw9q4hx9vp1nL+rz9PREx44d4eTkhG7duuHChQtl1h8zZgzOnTtXpWM+W+fzzz+vVr/rFKonGjRo8MptPHnyhPLz84mIKCcnh6ysrOjmzZtERGRlZUV37twhIqJZs2bRxIkTNeqWlJRQcXFxlY73fJ1r166RXC5/lSEwETM0NKR+/fqVuU8mk1G/fv009pdXtrL7a1pNnKMVtePh4UEnTpwgIqI1a9bQ22+//UKZoqKiKh/v+To1NQ5tqjcz9vJYW1tj7ty5UKvVUCgUQjKtw4cPC7/1nZ2dkZOTA0NDQ+Fy5CdPnqCkpKTMNkuzzKWlpaFjx44YMWIEHB0dkZ6eDmtra9y9excA8NVXX8HR0RGOjo6IiIgAgArrzJw5U8ghM336dIwYMQI7d+4UjhscHIxdu3a9vieLMS2oyjlaWc9mgjQxMcG0adPg5OSEo0ePwtPTE0lJSQCeXkSoUCjg6OiocTFheXVmzpwpXGgVHByMOXPmCOc2AHz88cdYsWJFDTwrr5m2f7NUlq6uLjk5OQk/W7ZsIaKnM+3IyEgiIlq5ciWNHj2aiIj8/PwoMTGRiJ7OzgsLC4mI6MaNG6RQKEgqlVJUVJTQ/rMz9gkTJlB4eDhdu3aNdHR06OjRoy+US0pKIkdHR3r06BHl5OSQg4MDnTx5ssI6z8/Y4+LiaMCAAURElJ2dTdbW1kI/2Zunvs/Ya+oc1dPTIxcXF3Jzc6OYmBih/Wdn7F988QUNHjyYiIgAUHR09Avlbt68SZaWlnT79m0qLCwkLy8vob3y6hBpztivXbtGzs7ORERUXFxM7dq1o7t379bME/Ya1ZvvsVeUOe7ZbG87duwA8DTZztSpUxEcHIzAwEAhjaelpSVSU1ORmZkJf39/DBo0CM2aNQPwYpa57OxsWFlZoUuXLi8cMzExEQEBAULyn8DAQCQkJKB///7l1nmeh4cHxo8fjzt37uCXX37BwIEDoa9fb14SxjTU1Dl6/fp1tGrVClevXoW3tzcUCgXat28P4OmnWqlUCmtra+E74Xp6ehg4cOALxzxx4gQ8PT3RtGlToW58fDz8/f3LrfM8a2trNGnSBKdOnUJWVhacnZ3RpEmTqj0xWiCKKFJWtreZM2eiX79+iI2NRbdu3bBv3z7Y2dkJdVq2bAlHR0ckJCRg0KBBAF7MMpednf1aM70BTxMC/fTTT9iyZQvWrVv30vKctle8ns82+KqkUmmtpu2tSFXO0dKMjO3atYOnpydOnTolBPZNmza9kAZAIpEIOWUqqyp1xowZg/Xr1+PWrVsaedvrMlEE9rJcuXIFCoUCCoUCJ06cwPnz52FiYoImTZpAKpXi/v37SExMxJQpU6rVfo8ePTBy5EjMnDkTRISYmJiX5n4oK9PbyJEj4erqiubNm8PBweGlx+W0veJV+smxppTeV7SuKuscbdasGYyNjWFkZIS7d+/ijz/+QHh4eLXad3V1RVhYGO7evQszMzNs3rwZEydOfGk9AwMDFBYWCjfACAgIwJw5c1BYWIiff/65Wn2pbfUmsJeVOa6ir1NFRETg0KFD0NXVhVwuR58+fRAfH49p06ZBR0cHRISPPvpI444tVaFWq4WgDDz9re7s7Cwk/i9LkyZN0K1bNzg6OqJPnz5YunQpmjVrBnt7e/j7+1erH4zVFTVxjiYnJ+P999+Hrq4uSkpKMHPmzEpNeMrSokULLF68GF5eXiAi9OvXDwMGDHhpvbFjx0KpVEKtVmPTpk0wNDSEl5cXGjduXOVPBtrC2R217PHjx1AoFDh58uRL80EzcSvN4FhT2R1ZzSgpKYFarca2bduEOzPVdfX+64712e+//w57e3tMnDiRgzpjddC5c+fQoUMH9OzZs94EdaAeLcWI0b/+9S9cv35d291gjJXDwcEBV69e1XY3qoxn7IwxJjIc2BljTGQ4sDPGmMjwGnsVmZiY4NGjR9ruBmN1jp6ensbXh4cMGYKZM2e+Ujtt2rTBr7/+WmN9fFNwYGeM1YiKUgpoo503GS/FVNOjR4/Qs2dPIWNdaVbG3Nxc9OvXD05OTnB0dER0dDQACBdaKJVKfPTRRwCeZoL09vaGUqlEz549cePGDa2Nh7HX5XVkd2QV4xl7NUkkEsTExKBRo0a4e/cuunTpgv79+2Pv3r1o2bIl9uzZAwB48OAB/vnnH8TExOD8+fPQ0dERbtQxceJEhISEICQkBD/88APCwsI00vgyVp88f+XprFmz8O677wIALCwscPLkSaxatQrLli3D2rVrsWzZMqxcuRLdunXDo0ePIJFIAAD5+fno1KkT9PX1MXPmTL4quxp4xl5NRITZs2dDqVTiX//6F27evImsrCwoFArs378fM2bMQEJCAkxNTWFqagqJRILRo0djx44dMDY2BgAcPXoUQUFBAIDhw4cjMTFRm0Ni7JWULqGU/pQGdUAzu2Np2o3S7I6RkZHIzs4WMptev34dSUlJ+PnnnzF58mRcuXKl1sdS3/GMvZo2bdqEO3fuIDk5GQYGBrC2tkZ+fj5sbW1x8uRJxMbG4pNPPkHPnj0xZ84cHD9+HAcOHMD27dsRFRWFgwcPVuu4nN1RvHR1qzbPqsnsjS9TV7I7ssrhwF5NDx48gEwmg4GBAQ4dOiRcQZqZmQlzc3MMGzYMjRs3xtq1a/Ho0SM8fvwYffv2Rbdu3dCuXTsAwFtvvYUtW7Zg+PDh2LRpE3r06PHS43J2R/GqapCu69kbX+Z1Z3d8k3Fgr6bg4GC8/fbbUCgU6NSpk5Dr/cyZM5g+fTp0dXVhYGCAb775Bjk5ORgwYADy8/NBRPjqq68AAF9//TVCQ0OxdOlSNG3atFL52Bmrq+padsc3GWd3ZKyOKJ2xVza7I2Pl4T+eMsaYyHBgZ4wxkeHAzhhjIsOBnTHGRIYDO2OMiQwHdsYYExkO7LXExMQEwNMLmAYNGqTl3jBW8/T09ISkXiqVCosXL0ZxcTFcXFwQHx8vlPP19RUurrK2toZCoYBSqYSvry9u3bqlsb20rbCwsCr3Jz8/H66urnBycoJcLsfcuXNrZqD1AF+gVMtatmyJ7du3a7sbjNW48tLtrlq1Cu+99x6Sk5Oxfft26Orq4p133hH2Hzp0CBYWFpg9ezY+//xzREZGamyvLiMjIxw8eBAmJiYoLCxE9+7d0adPH3Tp0qXabdYXPGOvZWlpaXB0dAQArF+/HoGBgejduzdsbGz40mkmSm5ubujatSvmzZuH2bNnIyoqqsxy7u7uuHz5coVteXp6YsaMGXB1dYWtrS0SEhIAAH/99RdcXV2hUqmgVCpx6dIl6OjoCJ+UCwsLUVhYCB0dnZodXB3FgV3LUlJSEB0djTNnziA6Ohrp6ena7hJj1VKaUqD0p/ReBACwaNEiREREICgoCB06dCiz/u7duzXuwOTl5SW0tXz5cmF7UVERjh8/joiICMyfPx8AsHr1akyaNAkpKSlISkpC69atAQDFxcVQqVSQyWTw8fGBm5vb6xh6ncNLMVrWs2dPmJqaAgAcHBxw/fp1WFpallueszuKl1QqRV5e3kvL1FZGx2dVJrtjRXc+io+Ph6mpKc6ePfvCPi8vL+jp6UGpVGLBggXC9vKWYspKAdy1a1csXLgQGRkZCAwMhI2NDYCn6/4pKSnIzs5GQEAAzp49K3xiFjMO7FpWms4U0ExpWh7O7ihuLwva9TGjY25uLsLDw3Hw4EGEhoYiNjYWffv2FfZXdS29rBTAQUFBcHNzw549e9C3b1+sWbMG3t7eQp3GjRvDy8sLe/fufSMCOy/FMMZeq08//RSDBw+GnZ0dVq1ahSlTpiA/P79Gj3H16lW0a9cOYWFhGDBgAFJTU3Hnzh3hbmV5eXnYv3+/kIVV7HjGzhirEWWl7R0+fDhiYmJw+vRpAICzszN69eqFJUuWvPTrh6VLNACgVCrx448/llt269at2LhxIwwMDNC8eXPMnj0bGRkZCAkJQXFxMUpKSjB48GCtLGNpA6ftZawO8fPzqzBtL6fsZZXBSzGMMSYyHNgZY0xkOLAzxpjIcGBnjDGR4cDOGGMiw193fIm0tDT4+fmVecUcY6xs8+bNg4mJCSwsLODr64uWLVtqu0tvFJ6xM8Zem/Xr15ebAqO4uLiWe/Pm4MBeCUVFRQgODoa9vT0GDRqEx48f49NPP0Xnzp3h6OiIsWPHgohw5coVqNVqod6lS5eEx8nJyfDw8ICLiwt69eqF//znPwCAyMhIODg4QKlUYsiQIVoZH2M1YeHChbC1tUX37t1x4cIFAEBSUhKCg4OhUqmQl5cHa2trzJgxA2q1ul6mR6g3iFXo2rVrBIASExOJiCg0NJSWLl1K//zzj1Bm2LBh9OuvvxIRkaenJ506dYqIiGbNmkWRkZFUUFBAXbt2pdu3bxMR0ZYtWyg0NJSIiFq0aEH5+flERHT//v1aGhWrq/r161fmdplMVu6+uiApKYkcHR0pNzeXHjx4QO3bt6elS5eSh4cHnThxQihnZWVFS5Ys0WJP3ww8Y68ES0tLdOvWDQAwbNgwJCYm4tChQ3Bzc4NCocDBgwfx119/AQDGjBmDdevWobi4GNHR0QgKCsKFCxdw9uxZ+Pj4QKVSYcGCBcjIyADw9FLp4OBg/PTTT9DX5z95sPopISEBAQEBMDY2RqNGjdC/f/9yy7777ru12LM3E0eSSng+Ob+Ojg7Gjx+PpKQkWFpaYt68eUJSo4EDB2L+/Pnw9vaGi4sLmjRpgszMTMjlchw9evSFtvfs2YP4+Hj8+9//xsKFC3HmzJkKAzyn7RU3qVRa4T5t5TqpTNreymrQoEGNtMMqoO2PDHVd6VLMkSNHiIho9OjRtGzZMpLJZPT48WPKyckhuVxOc+fOFep8+OGH1KJFC4qNjSUioidPnlD79u2FNgoKCujs2bNUXFxM165dE7a1aNGCl2NYmWQymba7UKHk5GRSKBT0+PFjevjwIXXo0IGWLl1Kfn5+dPDgQaGclZUV3blzR4s9fTPwjL0SOnbsiJUrV2LUqFFwcHDABx98gPv378PR0RHNmzdH586dNcoHBwcjJiYGvr6+AABDQ0Ns374dYWFhePDgAYqKijB58mTY2tpi2LBhePDgAYgIYWFhaNy4sRZGyNirUavVePfdd+Hk5ASZTCacEyNHjsS4ceMglUrL/MTKXg/O7vgaLFu2DA8ePMBnn32m7a4wkWjWrBmysrK03Q1WT/CMvYYFBATgypUrOHjwoLa7whh7Q/GMnbF6gGfsrCr4646MMSYyHNgZY0xkOLAzxpjIcGBnjDGR4cBeTXp6elCpVMLP4sWLq9zG9evXoVaroVKpIJfLsXr16tfQU8ZqR1nnRHFxMVxcXBAfHy+U8/X1FRKAWVtbQ6FQQKlUwtfXF7du3dLYXtpWWFhYtfr0bDudOnV69UHWF1q9PKoea9CgwSu38eTJEyEBWE5ODllZWdHNmzdfuV0mPnX9ylOi8s+JY8eOkUKhoIKCAvr555+pV69ewr5nr0SdNWsWTZw48YXtr+JNvdKVZ+w1zNraGnPnzoVarYZCocD58+cBAIcPHxZmH87OzsjJyYGhoSGMjIwAAE+ePEFJSYk2u87Ya+Hm5oauXbti3rx5mD17NqKiosos5+7ujsuXL1fYlqenJ2bMmAFXV1fY2toiISEBAPDXX3/B1dUVKpUKSqUSly5dqvFx1Ccc2KspLy9P42NndHS0sM/CwgInT57EBx98gGXLlgF4ejXqypUrkZKSgoSEBCHZU3p6OpRKJSwtLTFjxgy+0wyrtyo6JxYtWoSIiAgEBQWhQ4cOZdbfvXs3FAqF8NjLy0toa/ny5cL2oqIiHD9+HBEREZg/fz4AYPXq1Zg0aRJSUlKQlJSE1q1bA3iasM/X1xcuLi41lsSsPuArT6tJKpUiJSWlzH2BgYEAABcXF+zYsQMA0K1bN0ydOhXBwcEIDAwU3niWlpZITU1FZmYm/P39MWjQIDRr1qzc43J2xzeTgYGB1jI7ApXL7ljROREfHw9TU9MybzHp5eUFPT09KJVKLFiwQNh+6NAhWFhYvFD+2fMrLS0NANC1a1csXLgQGRkZCAwMhI2NDQAgMTERrVq1wu3bt+Hj4wM7Ozu4u7tXZsj1Ggf216B0eUVPTw9FRUUAgJkzZ6Jfv36IjY1Ft27dsG/fPtjZ2Ql1WrZsCUdHRyQkJGDQoEHltv0mzTqYOOTm5iI8PBwHDx5EaGgoYmNj0bdvX2F/eQG8PGWdX0FBQXBzc8OePXvQt29frFmzBt7e3mjVqhUAQCaTISAgAMePH38jAjsvxdSSK1euQKFQYMaMGejcuTPOnz+PjIwM5OXlAQDu37+PxMREdOzYUcs9Zaxmffrppxg8eDDs7OywatUqTJkyRbh/QU25evUq2rVrh7CwMAwYMACpqanIzc1FTk4OgKe/XH777Tc4OjrW6HHrKp6xV1PpemKp3r17V/iVx4iICBw6dAi6urqQy+Xo06cP4uPjMW3aNOjo6ICI8NFHH2msMTJWn5R1TgwfPhwxMTE4ffo0AMDZ2Rm9evXCkiVLMHfu3ArbK12iAZ7eaezHH38st+zWrVuxceNGGBgYoHnz5pg9ezaysrIQEBAA4Om6fFBQEHr37v2Ko6wfOAkYY4yJDC/FMMaYyHBgZ4wxkeHAzhhjIsOBnTHGRIYDO2OMiQwHdsYYExkO7IwxJjIc2BljTGQ4sDPGmMhwYGeMMZHhwM4YYyLDgZ0xxkSGAztjjIkMB3bGGBMZDuyMMSYyHNgZY0xkOLAzxpjIcGBnjDGR4cDOGGMiw4GdMcZEhgM7Y4yJDAd2xhgTGQ7sjDEmMhzYGWNMZP4PWKHACy3ESKsAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 360x198 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "insurance_charge\n",
      "                svr           lin           dtr           rfr         lasso  \\\n",
      "count  4.020000e+02  4.020000e+02  4.020000e+02  4.020000e+02  4.020000e+02   \n",
      "mean   1.645628e+08  1.271388e+08  1.354179e+08  1.336829e+08  1.271390e+08   \n",
      "std    3.491868e+08  2.094327e+08  2.302933e+08  2.269399e+08  2.094329e+08   \n",
      "min    2.578710e+03  3.457943e+05  4.528184e+02  2.689363e+05  3.458532e+05   \n",
      "25%    8.280500e+06  2.665057e+07  2.268995e+07  2.122644e+07  2.664953e+07   \n",
      "50%    2.697585e+07  4.798734e+07  4.610348e+07  4.392040e+07  4.798792e+07   \n",
      "75%    6.529585e+07  8.707048e+07  1.152472e+08  9.906939e+07  8.707196e+07   \n",
      "max    1.560591e+09  1.023325e+09  1.289207e+09  1.204149e+09  1.023324e+09   \n",
      "\n",
      "            elastic         bayes           ARD          Ens3  Ens3Priority  \\\n",
      "count  4.020000e+02  4.020000e+02  4.020000e+02  4.020000e+02  4.020000e+02   \n",
      "mean   1.306701e+08  1.276504e+08  1.280672e+08  1.326972e+08  1.632627e+08   \n",
      "std    2.269578e+08  2.108061e+08  2.105177e+08  2.263606e+08  3.450098e+08   \n",
      "min    5.647929e+02  4.201883e+05  2.159380e+05  7.918108e+03  3.925082e+01   \n",
      "25%    3.136085e+07  2.741612e+07  2.708628e+07  2.962885e+07  8.248278e+06   \n",
      "50%    5.017029e+07  4.801035e+07  4.912359e+07  5.303478e+07  2.808576e+07   \n",
      "75%    7.278713e+07  8.586584e+07  8.661746e+07  8.430114e+07  6.898866e+07   \n",
      "max    1.004262e+09  1.021215e+09  1.020152e+09  1.001918e+09  1.547683e+09   \n",
      "\n",
      "            EXPEns3  EXPEns3priority          Ens5  Ens5Priority  \\\n",
      "count  4.020000e+02     4.020000e+02  4.020000e+02  4.020000e+02   \n",
      "mean   3.249764e+08     1.632627e+08  1.296443e+08  1.648476e+08   \n",
      "std    5.644118e+08     3.450098e+08  2.211045e+08  3.498048e+08   \n",
      "min    1.290361e+06     3.925082e+01  2.486353e+06  2.214306e+03   \n",
      "25%    2.029474e+07     8.248278e+06  2.421503e+07  8.243758e+06   \n",
      "50%    8.355665e+07     2.808576e+07  4.355152e+07  2.691715e+07   \n",
      "75%    2.883865e+08     6.898866e+07  9.311104e+07  6.528457e+07   \n",
      "max    2.398085e+09     1.547683e+09  1.126414e+09  1.563893e+09   \n",
      "\n",
      "            EXPEns5  EXPEns5priority  \n",
      "count  4.020000e+02     4.020000e+02  \n",
      "mean   3.249764e+08     1.648476e+08  \n",
      "std    5.644118e+08     3.498048e+08  \n",
      "min    1.290361e+06     2.214306e+03  \n",
      "25%    2.029474e+07     8.243758e+06  \n",
      "50%    8.355665e+07     2.691715e+07  \n",
      "75%    2.883865e+08     6.528457e+07  \n",
      "max    2.398085e+09     1.563893e+09  \n",
      "svr                12828.203863\n",
      "lin                11275.586319\n",
      "dtr                11636.918725\n",
      "rfr                11562.132814\n",
      "lasso              11275.594715\n",
      "elastic            11431.101183\n",
      "bayes              11298.248688\n",
      "ARD                11316.677717\n",
      "Ens3               11519.426250\n",
      "Ens3Priority       12777.427823\n",
      "EXPEns3            18027.101881\n",
      "EXPEns3priority    12777.427823\n",
      "Ens5               11386.145667\n",
      "Ens5Priority       12839.299230\n",
      "EXPEns5            18027.101881\n",
      "EXPEns5priority    12839.299230\n",
      "dtype: float64\n",
      "cd= 11.533772666176985\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x219.6 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bike\n",
      "                 svr            lin            dtr            rfr  \\\n",
      "count    5214.000000    5214.000000    5214.000000    5214.000000   \n",
      "mean    23306.332216   22150.498715   13881.632452   13118.398847   \n",
      "std     56349.103695   46658.018862   30291.588466   29162.576129   \n",
      "min         0.000297       0.000079       0.000632       0.000060   \n",
      "25%       419.401301    1452.061448     268.231605     279.750277   \n",
      "50%      3367.014717    6957.752035    2311.529437    2286.572397   \n",
      "75%     16932.343992   21541.688416   11674.044042   11266.307808   \n",
      "max    515740.962669  513208.659448  351712.576429  340289.161847   \n",
      "\n",
      "               lasso        elastic          bayes            ARD  \\\n",
      "count    5214.000000    5214.000000    5214.000000    5214.000000   \n",
      "mean    22159.430177   26643.623106   22152.910250   22154.904148   \n",
      "std     46709.804371   53139.094087   46670.443184   46713.675348   \n",
      "min         0.000137       0.001921       0.000365       0.000449   \n",
      "25%      1437.623711    2544.299174    1459.889043    1438.211759   \n",
      "50%      6938.717674    9080.017676    6971.176888    6927.481378   \n",
      "75%     21480.856521   25085.437127   21482.913352   21608.584152   \n",
      "max    513972.315542  502738.363787  513153.349030  517255.294362   \n",
      "\n",
      "               Ens3   Ens3Priority        EXPEns3  EXPEns3priority  \\\n",
      "count  5.214000e+03    5214.000000    5214.000000      5214.000000   \n",
      "mean   2.234498e+04   23719.610364   26655.732984     23719.610364   \n",
      "std    4.748668e+04   57070.177711   52974.143011     57070.177711   \n",
      "min    5.589313e-07       0.000302       0.002919         0.000302   \n",
      "25%    1.937714e+03     505.620897    2499.606951       505.620897   \n",
      "50%    7.058757e+03    3446.354717    8944.724968      3446.354717   \n",
      "75%    1.937928e+04   17099.776788   25377.873561     17099.776788   \n",
      "max    4.711872e+05  517764.422755  500489.490712    517764.422755   \n",
      "\n",
      "                Ens5   Ens5Priority        EXPEns5  EXPEns5priority  \n",
      "count    5214.000000    5214.000000    5214.000000      5214.000000  \n",
      "mean    21292.340962   23508.563432   26654.314970     23508.563432  \n",
      "std     45928.977474   56676.675165   52926.065450     56676.675165  \n",
      "min         0.000236       0.000067       0.000115         0.000067  \n",
      "25%      1784.420971     472.231609    2579.919007       472.231609  \n",
      "50%      6772.687697    3423.204721    9108.294694      3423.204721  \n",
      "75%     18347.986040   17042.104364   25279.011764     17042.104364  \n",
      "max    472710.766418  514439.312953  500919.989634    514439.312953  \n",
      "svr                152.664116\n",
      "lin                148.830436\n",
      "dtr                117.820340\n",
      "rfr                114.535579\n",
      "lasso              148.860439\n",
      "elastic            163.228745\n",
      "bayes              148.838538\n",
      "ARD                148.845236\n",
      "Ens3               149.482362\n",
      "Ens3Priority       154.011722\n",
      "EXPEns3            163.265835\n",
      "EXPEns3priority    154.011722\n",
      "Ens5               145.918953\n",
      "Ens5Priority       153.325025\n",
      "EXPEns5            163.261493\n",
      "EXPEns5priority    153.325025\n",
      "dtype: float64\n",
      "cd= 11.533772666176985\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x212.4 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import Orange\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "#RESULTS GENERATION\n",
    "\n",
    "\n",
    "for i, dataname in enumerate(data):\n",
    "    \n",
    "    df_results = pd.DataFrame.from_dict(results[dataname][0])\n",
    "    #df_results['assembly'] = errors['squared_error']\n",
    "\n",
    "    #df_results = pd.DataFrame.from_dict([results[dataname][1], results[dataname][0]])\n",
    "    print(dataname)\n",
    "    print(df_results.describe())\n",
    "    \n",
    "    names = list(df_results.columns.values)\n",
    "    #names.append('assembly')\n",
    "    avranks = df_results.mean()**(0.5)\n",
    "    #avranks = avranks.append(pd.Series(df_resultsAsm[i], index=['assembly']))\n",
    "    print(avranks)\n",
    "    cd = Orange.evaluation.compute_CD(avranks, 4,alpha=\"0.05\") #tested on 4 datasets \n",
    "    print(\"cd=\",cd)\n",
    "    Orange.evaluation.graph_ranks(avranks, names, cd=cd, width=5, textspace=1.5)\n",
    "    plt.show();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TIME SERIES PART STARTS HERE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "TPVcPIpGnJAd"
   },
   "outputs": [],
   "source": [
    "ts_data = {\n",
    "           'bike' : ['https://raw.githubusercontent.com/ostapkharysh/PublicDatasets/master/Regression/bike_hour.csv', 'cnt'], \n",
    "           'ibm' : ['https://raw.githubusercontent.com/PacktPublishing/Practical-Time-Series-Analysis/master/Data%20Files/ibm-common-stock-closing-prices.csv', 'IBM common stock closing prices'],\n",
    "            'ozone': ['https://raw.githubusercontent.com/PacktPublishing/Practical-Time-Series-Analysis/master/Data%20Files/monthly-mean-thickness-dobson-un.csv', 'Monthly mean thickness (Dobson units) ozone column Arosa, Switzerland 1926-1971'], \n",
    "            'temperature': ['https://raw.githubusercontent.com/PacktPublishing/Practical-Time-Series-Analysis/master/Data%20Files/mean-daily-temperature-fisher-river.csv', 'Mean temparature']  \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "whkcyIppnaMl"
   },
   "outputs": [],
   "source": [
    "ts_results = {}\n",
    "columns_to_drop = [[],['Geography','binnedInc'],['sex','smoker','region'],['instant','dteday'],[]]\n",
    "\n",
    "def make_dataset_from_ts(d, num_x=10, value=None):\n",
    "    \"\"\"\n",
    "    Set the amount of previous observations to predict the next observation\n",
    "    \"\"\"\n",
    "    for idx in range(num_x):\n",
    "        d['t-' + str(idx+1)] = d[value].shift(+(idx+1))\n",
    "    return d[num_x:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ljUCvCuK0jjd",
    "outputId": "7e807b15-8f9c-438e-982a-6416c1c4f881"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-9-f26a1e88bcb7>:6: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  d['t-' + str(idx+1)] = d[value].shift(+(idx+1))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bike\n",
      "Beta 3\n",
      "[4052, 8104, 12156]\n",
      "Part Completed\n",
      "Beta 3\n",
      "[4052, 8104, 12156]\n",
      "Part Completed\n",
      "Beta 3\n",
      "[4052, 8104, 12156]\n",
      "Part Completed\n",
      "Beta 3\n",
      "[4052, 8104, 12156]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[2431, 4862, 7293, 9724, 12155]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[2431, 4862, 7293, 9724, 12155]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[2431, 4862, 7293, 9724, 12155]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[2431, 4862, 7293, 9724, 12155]\n",
      "Part Completed\n",
      "Assembly Finished\n",
      "ibm\n",
      "Beta 3\n",
      "[232, 464, 696]\n",
      "Part Completed\n",
      "Beta 3\n",
      "[232, 464, 696]\n",
      "Part Completed\n",
      "Beta 3\n",
      "[232, 464, 696]\n",
      "Part Completed\n",
      "Beta 3\n",
      "[232, 464, 696]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[139, 278, 417, 556, 695]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[139, 278, 417, 556, 695]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[139, 278, 417, 556, 695]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[139, 278, 417, 556, 695]\n",
      "Part Completed\n",
      "Assembly Finished\n",
      "ozone\n",
      "Beta 3\n",
      "[118, 236, 354]\n",
      "Part Completed\n",
      "Beta 3\n",
      "[118, 236, 354]\n",
      "Part Completed\n",
      "Beta 3\n",
      "[118, 236, 354]\n",
      "Part Completed\n",
      "Beta 3\n",
      "[118, 236, 354]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[70, 140, 210, 280, 350]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[70, 140, 210, 280, 350]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[70, 140, 210, 280, 350]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[70, 140, 210, 280, 350]\n",
      "Part Completed\n",
      "Assembly Finished\n",
      "temperature\n",
      "Beta 3\n",
      "[338, 676, 1014]\n",
      "Part Completed\n",
      "Beta 3\n",
      "[338, 676, 1014]\n",
      "Part Completed\n",
      "Beta 3\n",
      "[338, 676, 1014]\n",
      "Part Completed\n",
      "Beta 3\n",
      "[338, 676, 1014]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[203, 406, 609, 812, 1015]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[203, 406, 609, 812, 1015]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[203, 406, 609, 812, 1015]\n",
      "Part Completed\n",
      "Beta 5\n",
      "[203, 406, 609, 812, 1015]\n",
      "Part Completed\n",
      "Assembly Finished\n"
     ]
    }
   ],
   "source": [
    "import warnings\n",
    "from sklearn.exceptions import ConvergenceWarning\n",
    "with warnings.catch_warnings():\n",
    "    warnings.filterwarnings(\"ignore\", category=ConvergenceWarning)\n",
    "    \n",
    "\n",
    "    for idx, el in enumerate(ts_data):\n",
    "\n",
    "        ts_results[el] = list()\n",
    "\n",
    "        Y = ts_data[el][1]\n",
    "        df = pd.read_csv(ts_data[el][0], encoding=\"ISO-8859-1\")\n",
    "        df = make_dataset_from_ts(df[[Y]], value=Y) #TS\n",
    "\n",
    "        if el =='ibm':\n",
    "            df = df[:-1] #THERE WAS A NAN in the last column during the reading\n",
    "            df = df[df[Y].notna()] # There were still some ones in the\n",
    "            df[Y] = pd.to_numeric(df[Y])\n",
    "        elif el =='precipitation':\n",
    "            df = df[:-2] #THERE WAS A NAN and String in the last columns during the reading\n",
    "            df = df[df[Y].notna()] # There were still some ones in the\n",
    "            df[Y] = pd.to_numeric(df[Y])\n",
    "        elif el =='ozone':\n",
    "            df = df[:-2] #THERE WAS A NAN and String in the last columns during the reading\n",
    "            df = df[df[Y].notna()] # There were still some nones in the\n",
    "            df[Y] = pd.to_numeric(df[Y])\n",
    "\n",
    "        X = list(df.columns[1:]) #TS\n",
    "        ds, competition = train_test_split(df, test_size=0.3, shuffle = False)\n",
    "        ds = ds.reset_index(drop=True)\n",
    "        competition = competition.reset_index(drop=True)\n",
    "        print(el)\n",
    "        \n",
    "        #Estimators to compare\n",
    "        m_errors, estimators = reg_prediction(ds, competition, idx, X=X, Y=Y)\n",
    "\n",
    "        \n",
    "        #BETA + 3\n",
    "        \n",
    "        #Assembly without priority\n",
    "        assembly = Ensemble.analyze_ensemble(learning_ds=ds, competition_ds=competition, X=X, Y=Y,\n",
    "                                                         priority = False, beta=3)\n",
    "        m_errors[\"Ens3\"] = assembly['squared_error']\n",
    "        \n",
    "        #Assembly with priority\n",
    "        assembly = Ensemble.analyze_ensemble(learning_ds=ds, competition_ds=competition, X=X, Y=Y,\n",
    "                                                         priority = True, beta=3)\n",
    "        m_errors[\"Ens3Priority\"] = assembly['squared_error']\n",
    "        \n",
    "        #Assembly without priority + exp\n",
    "        assembly = Ensemble.analyze_ensemble(learning_ds=ds, competition_ds=competition, X=X, Y=Y,\n",
    "                                                         priority = False, approach='exp', beta=3)\n",
    "        m_errors[\"EXPEns3\"] = assembly['squared_error']\n",
    "        #Assembly with priority + exp\n",
    "        assembly = Ensemble.analyze_ensemble(learning_ds=ds, competition_ds=competition, X=X, Y=Y,\n",
    "                                                         priority = True, approach='exp', beta=3)\n",
    "        m_errors[\"EXPEns3priority\"] = assembly['squared_error']\n",
    "        \n",
    "        \n",
    "        \n",
    "        #BETA = 5\n",
    "\n",
    "\n",
    "        #Assembly without priority\n",
    "        assembly = Ensemble.analyze_ensemble(learning_ds=ds, competition_ds=competition, X=X, Y=Y,\n",
    "                                                         priority = False, beta=5)\n",
    "        m_errors[\"Ens5\"] = assembly['squared_error']\n",
    "        \n",
    "        #Assembly with priority\n",
    "        assembly = Ensemble.analyze_ensemble(learning_ds=ds, competition_ds=competition, X=X, Y=Y,\n",
    "                                                         priority = True, beta=5)\n",
    "        m_errors[\"Ens5Priority\"] = assembly['squared_error']\n",
    "        \n",
    "        #Assembly without priority + exp\n",
    "        assembly = Ensemble.analyze_ensemble(learning_ds=ds, competition_ds=competition, X=X, Y=Y,\n",
    "                                                         priority = False, approach='exp', beta=5)\n",
    "        m_errors[\"EXPEns5\"] = assembly['squared_error']\n",
    "        #Assembly with priority + exp\n",
    "        assembly = Ensemble.analyze_ensemble(learning_ds=ds, competition_ds=competition, X=X, Y=Y,\n",
    "                                                         priority = True, approach='exp', beta=5)\n",
    "        m_errors[\"EXPEns5priority\"] = assembly['squared_error']\n",
    "        \n",
    "        \n",
    "        #TOGETHER\n",
    "        ts_results[el].append(m_errors)\n",
    "        print(\"Assembly Finished\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "NB6uN2jm0jje",
    "outputId": "eb469063-5aab-4d71-eff3-8dee7c86ce42"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "bike\n",
      "\n",
      "                 svr            lin            dtr            rfr  \\\n",
      "count    5211.000000    5211.000000    5211.000000    5211.000000   \n",
      "mean    26904.388763   11711.623702    9589.508698    8302.234363   \n",
      "std     62083.404575   25775.400056   24002.499603   21601.708969   \n",
      "min         0.000010       0.000023       0.000464       0.004410   \n",
      "25%       499.581091     408.898577     225.646531     205.513855   \n",
      "50%      3317.164651    2443.709298    1662.788352    1442.767341   \n",
      "75%     16589.759692    9325.964113    8050.490752    6905.812224   \n",
      "max    508844.038053  232451.939433  293712.383220  283153.208000   \n",
      "\n",
      "               lasso        elastic          bayes            ARD  \\\n",
      "count    5211.000000    5211.000000    5211.000000    5211.000000   \n",
      "mean    11711.680917   11792.750777   11712.432400   11710.317957   \n",
      "std     25775.622549   25895.625411   25773.985186   25770.983450   \n",
      "min         0.000105       0.000497       0.000035       0.000056   \n",
      "25%       408.857638     405.033676     407.497691     407.289380   \n",
      "50%      2443.203150    2478.585839    2441.952818    2440.144497   \n",
      "75%      9325.476565    9078.496446    9327.035293    9331.596174   \n",
      "max    232449.100217  228752.854159  232350.220447  232431.511673   \n",
      "\n",
      "                Ens3   Ens3Priority        EXPEns3  EXPEns3priority  \\\n",
      "count    5211.000000    5211.000000    5211.000000      5211.000000   \n",
      "mean    11250.146043   19070.063557   11734.828874     19731.195383   \n",
      "std     22592.398501   45385.387697   25827.636167     46540.912782   \n",
      "min         0.000683       0.001946       0.000584         0.001946   \n",
      "25%       370.188435     270.818525     408.262857       279.681614   \n",
      "50%      2380.489746    2190.240000    2477.735148      2276.703553   \n",
      "75%      9400.759931   13900.456776    9314.308496     14127.103628   \n",
      "max    186138.662655  418824.694444  233564.103559    396930.920848   \n",
      "\n",
      "                Ens5   Ens5Priority        EXPEns5  EXPEns5priority  \n",
      "count    5211.000000    5211.000000    5211.000000      5211.000000  \n",
      "mean    10869.230515   22414.291396   19145.326224     19378.133162  \n",
      "std     22065.169203   54795.676827   45082.386155     45077.133486  \n",
      "min         0.000229       0.001935       0.000340         0.001935  \n",
      "25%       344.663738     266.710951     265.773817       266.036365  \n",
      "50%      2210.734785    2299.778585    2221.427971      2174.234143  \n",
      "75%      8968.350634   14896.153079   13255.606987     14275.452551  \n",
      "max    184169.103358  434092.734694  380238.415741    389498.476919  \n",
      "svr                164.025574\n",
      "lin                108.220256\n",
      "dtr                 97.926037\n",
      "rfr                 91.116598\n",
      "lasso              108.220520\n",
      "elastic            108.594433\n",
      "bayes              108.223992\n",
      "ARD                108.214223\n",
      "Ens3               106.066706\n",
      "Ens3Priority       138.094401\n",
      "EXPEns3            108.327415\n",
      "EXPEns3priority    140.467773\n",
      "Ens5               104.255602\n",
      "Ens5Priority       149.714032\n",
      "EXPEns5            138.366637\n",
      "EXPEns5priority    139.205363\n",
      "dtype: float64\n",
      "cd= 11.533772666176985\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x219.6 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "ibm\n",
      "\n",
      "                svr         lin          dtr           rfr       lasso  \\\n",
      "count  3.000000e+02  300.000000   300.000000  3.000000e+02  300.000000   \n",
      "mean   4.438060e+01   16.303844    58.887088  2.746978e+01   16.315363   \n",
      "std    6.956656e+01   26.414892   144.582057  4.561138e+01   26.460549   \n",
      "min    1.095323e-09    0.000543     0.006457  2.400005e-07    0.000025   \n",
      "25%    5.123534e+00    1.028124     2.856100  1.506987e+00    1.022531   \n",
      "50%    2.245377e+01    6.333043    13.700306  1.050120e+01    6.342722   \n",
      "75%    5.662823e+01   21.568919    46.922500  3.233303e+01   21.525712   \n",
      "max    7.951083e+02  199.001430  1350.562500  3.362234e+02  199.870707   \n",
      "\n",
      "          elastic       bayes         ARD        Ens3  Ens3Priority  \\\n",
      "count  300.000000  300.000000  300.000000  300.000000    300.000000   \n",
      "mean    16.569328   16.357512   16.359557   17.116846    119.506337   \n",
      "std     26.701912   26.575951   26.866881   26.380241    181.924470   \n",
      "min      0.000796    0.000035    0.000002    0.000007      0.000004   \n",
      "25%      1.211324    1.103708    1.173832    1.440713     12.154031   \n",
      "50%      5.721971    6.422508    5.718621    7.091695     56.483764   \n",
      "75%     19.876597   21.861239   19.844262   20.556265    134.412550   \n",
      "max    212.629531  202.583197  206.358435  170.863782   1150.710269   \n",
      "\n",
      "          EXPEns3  EXPEns3priority        Ens5  Ens5Priority     EXPEns5  \\\n",
      "count  300.000000       300.000000  300.000000    300.000000  300.000000   \n",
      "mean    16.940851       119.506337   16.358657     44.294663   16.330909   \n",
      "std     26.217877       181.924470   26.499437     68.983591   26.425266   \n",
      "min      0.000439         0.000004    0.001891      0.001588    0.001691   \n",
      "25%      1.141318        12.154031    1.268032      4.485995    1.373404   \n",
      "50%      6.759466        56.483764    6.419182     21.155469    6.280417   \n",
      "75%     20.303656       134.412550   19.740126     57.167634   19.549263   \n",
      "max    167.623259      1150.710269  193.896190    731.780300  192.573999   \n",
      "\n",
      "       EXPEns5priority  \n",
      "count       300.000000  \n",
      "mean         44.294663  \n",
      "std          68.983591  \n",
      "min           0.001588  \n",
      "25%           4.485995  \n",
      "50%          21.155469  \n",
      "75%          57.167634  \n",
      "max         731.780300  \n",
      "svr                 6.661876\n",
      "lin                 4.037802\n",
      "dtr                 7.673792\n",
      "rfr                 5.241162\n",
      "lasso               4.039228\n",
      "elastic             4.070544\n",
      "bayes               4.044442\n",
      "ARD                 4.044695\n",
      "Ens3                4.137251\n",
      "Ens3Priority       10.931895\n",
      "EXPEns3             4.115927\n",
      "EXPEns3priority    10.931895\n",
      "Ens5                4.044584\n",
      "Ens5Priority        6.655424\n",
      "EXPEns5             4.041152\n",
      "EXPEns5priority     6.655424\n",
      "dtype: float64\n",
      "cd= 11.533772666176985\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x198 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "ozone\n",
      "\n",
      "               svr          lin          dtr          rfr        lasso  \\\n",
      "count   153.000000   153.000000   153.000000   153.000000   153.000000   \n",
      "mean    543.518449   373.439683   569.826179   358.599515   373.550030   \n",
      "std     858.620679   583.740947   925.324534   531.256987   584.165707   \n",
      "min       0.012821     0.000389     0.052674     0.054472     0.000699   \n",
      "25%      31.193816    46.294660    52.562500    29.836845    46.223857   \n",
      "50%     210.975414   152.834663   196.000000   136.746927   152.888734   \n",
      "75%     632.030616   514.423036   628.128906   484.573130   513.874528   \n",
      "max    5357.890187  4379.519794  4761.000000  3755.885227  4383.690876   \n",
      "\n",
      "           elastic        bayes          ARD         Ens3  Ens3Priority  \\\n",
      "count   153.000000   153.000000   153.000000   153.000000    153.000000   \n",
      "mean    386.390386   375.049066   389.177938   413.077417    703.443945   \n",
      "std     625.287908   583.950172   633.748430   666.476694   1072.149348   \n",
      "min       0.000298     0.014518     0.014908     0.000524      0.001236   \n",
      "25%      44.575838    49.557300    52.900958    28.152669     67.515406   \n",
      "50%     147.702759   156.427316   143.247633   123.844210    290.325382   \n",
      "75%     522.239993   520.427714   523.203098   587.683535    851.203244   \n",
      "max    4881.873598  4415.653561  4910.625360  5180.143079   6256.453057   \n",
      "\n",
      "           EXPEns3  EXPEns3priority         Ens5  Ens5Priority      EXPEns5  \\\n",
      "count   153.000000       153.000000   153.000000    153.000000   153.000000   \n",
      "mean    396.387177       703.443945   562.837613    610.247233   608.128562   \n",
      "std     691.831558      1072.149348   812.730741    930.443703   993.823155   \n",
      "min       0.000610         0.001236     0.032021      0.093414     0.267539   \n",
      "25%      24.234404        67.515406    41.482108     44.454692    48.766944   \n",
      "50%     155.668160       290.325382   218.768162    270.705963   225.000000   \n",
      "75%     519.121143       851.203244   770.179815    772.794026   729.000000   \n",
      "max    5552.478849      6256.453057  4670.451963   5564.433451  8281.000000   \n",
      "\n",
      "       EXPEns5priority  \n",
      "count       153.000000  \n",
      "mean        610.247233  \n",
      "std         930.443703  \n",
      "min           0.093414  \n",
      "25%          44.454692  \n",
      "50%         270.705963  \n",
      "75%         772.794026  \n",
      "max        5564.433451  \n",
      "svr                23.313482\n",
      "lin                19.324588\n",
      "dtr                23.871032\n",
      "rfr                18.936724\n",
      "lasso              19.327442\n",
      "elastic            19.656815\n",
      "bayes              19.366184\n",
      "ARD                19.727593\n",
      "Ens3               20.324306\n",
      "Ens3Priority       26.522518\n",
      "EXPEns3            19.909475\n",
      "EXPEns3priority    26.522518\n",
      "Ens5               23.724199\n",
      "Ens5Priority       24.703183\n",
      "EXPEns5            24.660263\n",
      "EXPEns5priority    24.703183\n",
      "dtype: float64\n",
      "cd= 11.533772666176985\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x198 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "temperature\n",
      "\n",
      "              svr         lin         dtr         rfr       lasso     elastic  \\\n",
      "count  436.000000  436.000000  436.000000  436.000000  436.000000  436.000000   \n",
      "mean    22.746820   16.810988   21.066863   17.864888   16.852342   16.978374   \n",
      "std     34.068137   26.808652   39.191423   28.294400   26.954481   27.181032   \n",
      "min      0.000116    0.000165    0.001162    0.000190    0.000054    0.000007   \n",
      "25%      1.828608    1.299812    1.304989    1.438957    1.267309    1.213317   \n",
      "50%      9.150517    6.874336    7.406224    6.747232    6.865453    6.864525   \n",
      "75%     30.305263   21.331559   23.681291   21.536064   21.906567   21.826451   \n",
      "max    212.123136  207.815098  451.562500  207.529320  207.433806  204.625624   \n",
      "\n",
      "            bayes         ARD        Ens3  Ens3Priority     EXPEns3  \\\n",
      "count  436.000000  436.000000  436.000000    436.000000  436.000000   \n",
      "mean    16.854435   16.870950   20.929851     26.034707   24.456240   \n",
      "std     26.850766   27.275644   37.953453     38.805872   48.882740   \n",
      "min      0.001400    0.000220    0.000175      0.000051    0.000580   \n",
      "25%      1.322067    1.314109    1.733191      2.131833    1.801369   \n",
      "50%      6.855662    6.771279    7.438375     10.646381    7.215097   \n",
      "75%     21.480734   21.503802   23.923199     33.514622   26.497316   \n",
      "max    206.375425  212.954489  339.554323    244.411805  472.318262   \n",
      "\n",
      "       EXPEns3priority        Ens5  Ens5Priority     EXPEns5  EXPEns5priority  \n",
      "count       436.000000  436.000000    436.000000  436.000000       436.000000  \n",
      "mean         26.034707   20.375212     23.070613   22.564774        23.070613  \n",
      "std          38.805872   35.216751     34.072751   44.733431        34.072751  \n",
      "min           0.000051    0.000005      0.000062    0.000295         0.000062  \n",
      "25%           2.131833    1.564979      1.758538    1.414042         1.758538  \n",
      "50%          10.646381    6.891042      9.915368    7.068030         9.915368  \n",
      "75%          33.514622   22.098542     30.291315   22.551374        30.291315  \n",
      "max         244.411805  288.347872    215.387394  399.510816       215.387394  \n",
      "svr                4.769363\n",
      "lin                4.100120\n",
      "dtr                4.589865\n",
      "rfr                4.226688\n",
      "lasso              4.105160\n",
      "elastic            4.120482\n",
      "bayes              4.105415\n",
      "ARD                4.107426\n",
      "Ens3               4.574915\n",
      "Ens3Priority       5.102422\n",
      "EXPEns3            4.945325\n",
      "EXPEns3priority    5.102422\n",
      "Ens5               4.513891\n",
      "Ens5Priority       4.803188\n",
      "EXPEns5            4.750239\n",
      "EXPEns5priority    4.803188\n",
      "dtype: float64\n",
      "cd= 11.533772666176985\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x198 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#RESULTS GENERATION\n",
    "for i, dataname in enumerate(ts_data):\n",
    "    \n",
    "    df_results = pd.DataFrame.from_dict(ts_results[dataname][0])\n",
    "    \n",
    "    print()\n",
    "    print(dataname)\n",
    "    print()\n",
    "    print(df_results.describe())\n",
    "    \n",
    "    \n",
    "    names = list(df_results.columns.values)\n",
    "    #names.append('assembly')\n",
    "    avranks = df_results.mean()**(0.5)\n",
    "    #avranks = avranks.append(pd.Series(df_resultsAsm[i], index=['assembly']))\n",
    "    print(avranks)\n",
    "    cd = Orange.evaluation.compute_CD(avranks, 4,alpha=\"0.05\") #tested on 4 datasets \n",
    "    print(\"cd=\",cd)\n",
    "    Orange.evaluation.graph_ranks(avranks, names, cd=cd, width=5, textspace=1.5)\n",
    "    plt.show();"
   ]
  }
 ],
 "metadata": {
  "accelerator": "TPU",
  "colab": {
   "collapsed_sections": [],
   "name": "FinalComparisonWeighed.ipynb",
   "provenance": []
  },
  "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.8.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}