PY580_Notebook09_Random_Forests.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Notebook 9: Using Random Forests to classify phases in the Ising Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "## Learning Goal\n",
    "\n",
    "The goal of this notebook is to show how one can employ ensemble methods such as Random Forests to classify the states of the 2D Ising model according to their phases. We discuss concepts like decision trees, extreme decision trees, and out-of-bag error. The notebook also introduces the powerful scikit-learn `Ensemble` class.\n",
    "\n",
    "\n",
    "## Setting up the problem\n",
    "\n",
    "The Hamiltonian for the classical Ising model is given by\n",
    "\n",
    "$$ H = -J\\sum_{\\langle ij\\rangle}S_{i}S_j,\\qquad \\qquad S_j\\in\\{\\pm 1\\} $$\n",
    "\n",
    "where the lattice site indices $i,j$ run over all nearest neighbors of a 2D square lattice of side $L$, and $J$ is some arbitrary interaction energy scale. We adopt periodic boundary conditions. Onsager proved that this model undergoes a phase transition in the thermodynamic limit from an ordered ferromagnet with all spins aligned to a disordered phase at the critical temperature $T_c/J=1/\\log(1+\\sqrt{2})\\approx 2.26$. For any finite system size, this critical point is expanded to a critical region around $T_c$.\n",
    "\n",
    "We will use the same basic idea as we did for logistic regression. An interesting question to ask is whether one can train a statistical model to distinguish between the two phases of the Ising model. In other words, given an Ising state, we would like to classify whether it belongs to the ordered or the disordered phase, without any additional information other than the spin configuration itself. This categorical machine learning problem is well suited for ensemble methods and in particular Random Forests.\n",
    "\n",
    "To this end, we consider the 2D Ising model on a $40\\times 40$ square lattice, and use Monte-Carlo (MC) sampling to prepare $10^4$ states at every fixed temperature $T$ out of a pre-defined set. Using Onsager's criterion, we can assign a label to each state according to its phase: $0$ if the state is disordered, and $1$ if it is ordered. \n",
    "\n",
    "It is well-known that, near the critical temperature $T_c$, the ferromagnetic correlation length diverges which, among others, leads to a critical slowing down of the MC algorithm. Therefore, we expect identifying the phases to be harder in the critical region. With this in mind, consider the following three types of states: ordered ($T/J<2.0$), critical ($2.0\\leq T/J\\leq 2.5)$ and disordered ($T/J>2.5$). We use both ordered and disordered states to train the random forest and, once the supervised training procedure is complete, we shall evaluate the performance of our classifier on unseen ordered, disordered and critical states. \n",
    "\n",
    "A link to the Ising dataset can be found at [https://physics.bu.edu/~pankajm/MLnotebooks.html](https://physics.bu.edu/~pankajm/MLnotebooks.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "np.random.seed() # shuffle random seed generator\n",
    "\n",
    "# Ising model parameters\n",
    "L=40 # linear system size\n",
    "J=-1.0 # Ising interaction\n",
    "T=np.linspace(0.25,4.0,16) # set of temperatures\n",
    "T_c=2.26 # Onsager critical temperature in the TD limit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle, os\n",
    "from urllib.request import urlopen \n",
    "\n",
    "# path to data directory (for testing)\n",
    "#path_to_data=os.path.expanduser('~')+'/Dropbox/MachineLearningReview/Datasets/isingMC/'\n",
    "\n",
    "url_main = 'https://physics.bu.edu/~pankajm/ML-Review-Datasets/isingMC/';\n",
    "\n",
    "######### LOAD DATA\n",
    "# The data consists of 16*10000 samples taken in T=np.arange(0.25,4.0001,0.25):\n",
    "data_file_name = \"Ising2DFM_reSample_L40_T=All.pkl\" \n",
    "# The labels are obtained from the following file:\n",
    "label_file_name = \"Ising2DFM_reSample_L40_T=All_labels.pkl\"\n",
    "\n",
    "\n",
    "#DATA\n",
    "data = pickle.load(urlopen(url_main + data_file_name)) # pickle reads the file and returns the Python object (1D array, compressed bits)\n",
    "data = np.unpackbits(data).reshape(-1, 1600) # Decompress array and reshape for convenience\n",
    "data=data.astype('int')\n",
    "data[np.where(data==0)]=-1 # map 0 state to -1 (Ising variable can take values +/-1)\n",
    "\n",
    "#LABELS (convention is 1 for ordered states and 0 for disordered states)\n",
    "labels = pickle.load(urlopen(url_main + label_file_name)) # pickle reads the file and returns the Python object (here just a 1D array with the binary labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train shape: (104000, 1600)\n",
      "Y_train shape: (104000,)\n",
      "\n",
      "104000 train samples\n",
      "30000 critical samples\n",
      "26000 test samples\n"
     ]
    }
   ],
   "source": [
    "###### define ML parameters\n",
    "from sklearn.model_selection import train_test_split\n",
    "train_to_test_ratio=0.8 # training samples\n",
    "\n",
    "# divide data into ordered, critical and disordered\n",
    "X_ordered=data[:70000,:]\n",
    "Y_ordered=labels[:70000]\n",
    "\n",
    "X_critical=data[70000:100000,:]\n",
    "Y_critical=labels[70000:100000]\n",
    "\n",
    "X_disordered=data[100000:,:]\n",
    "Y_disordered=labels[100000:]\n",
    "\n",
    "del data,labels\n",
    "\n",
    "# define training and test data sets\n",
    "X=np.concatenate((X_ordered,X_disordered))\n",
    "Y=np.concatenate((Y_ordered,Y_disordered))\n",
    "\n",
    "# pick random data points from ordered and disordered states \n",
    "# to create the training and test sets\n",
    "X_train,X_test,Y_train,Y_test=train_test_split(X,Y,train_size=train_to_test_ratio,test_size=1.0-train_to_test_ratio)\n",
    "\n",
    "print('X_train shape:', X_train.shape)\n",
    "print('Y_train shape:', Y_train.shape)\n",
    "print()\n",
    "print(X_train.shape[0], 'train samples')\n",
    "print(X_critical.shape[0], 'critical samples')\n",
    "print(X_test.shape[0], 'test samples')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "##### plot a few Ising states\n",
    "%matplotlib inline \n",
    "\n",
    "#import ml_style as style\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "#mpl.rcParams.update(style.style)\n",
    "\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
    "\n",
    "# set colourbar map\n",
    "cmap_args=dict(cmap='plasma_r')\n",
    "\n",
    "# plot states\n",
    "fig, axarr = plt.subplots(nrows=1, ncols=3)\n",
    "\n",
    "axarr[0].imshow(X_ordered[20001].reshape(L,L),**cmap_args)\n",
    "#axarr[0].set_title('$\\\\mathrm{ordered\\\\ phase}$',fontsize=16)\n",
    "axarr[0].set_title('ordered phase',fontsize=16)\n",
    "axarr[0].tick_params(labelsize=16)\n",
    "\n",
    "axarr[1].imshow(X_critical[10001].reshape(L,L),**cmap_args)\n",
    "#axarr[1].set_title('$\\\\mathrm{critical\\\\ region}$',fontsize=16)\n",
    "axarr[1].set_title('critical region',fontsize=16)\n",
    "axarr[1].tick_params(labelsize=16)\n",
    "\n",
    "im=axarr[2].imshow(X_disordered[50001].reshape(L,L),**cmap_args)\n",
    "#axarr[2].set_title('$\\\\mathrm{disordered\\\\ phase}$',fontsize=16)\n",
    "axarr[2].set_title('disordered phase',fontsize=16)\n",
    "axarr[2].tick_params(labelsize=16)\n",
    "\n",
    "fig.subplots_adjust(right=2.0)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random Forests\n",
    "\n",
    "**Hyperparameters**\n",
    "\n",
    "We start by training with Random Forests. As discussed in Sec. VIII of the review, Random Forests are ensemble models. Here we will use the sci-kit learn implementation of random forests.  There are two main hyper-parameters that will be important in practice for the performance of the algorithm and the degree to which it overfits/underfits: the number of estimators in the ensemble and the depth of the trees used. The former is controlled by the parameter `n_estimators` whereas the latter (the complexity of the trees used) can be controlled in many distinct ways (`min_samples_split`, `min_samples_leaf`, `min_impurity_decrease`, etc). For our simple dataset, it does not really make much difference which one of these we use. We will just use the `min_samples_split` parameter that dictates how many samples need to be in each node of the classification tree. The bigger this number, the more coarse our trees and data partitioning.\n",
    "\n",
    "In the code below, we will just consider extremely fine trees (`min_samples_split=2`) or extremely coarse trees (`min_samples_split=10000`). As we will see, both of these tree complexities are sufficient to distinguish the ordered from the disordered samples. The reason for this is that the ordered and disordered phases are distinguished by the magnetization order parameter which is an equally weighted sum of all features. However, if we want to train deep in these simple phases, and then use our algorithm to distinguish critical samples it is crucial we use more complex trees even though the performance on the disordered and ordered phases is indistinguishable for coarse and complex trees.\n",
    "\n",
    "**Out of Bag (OOB) Estimates**\n",
    "\n",
    "For more complicated datasets, how can we choose the right hyperparameters? We can actually make use of one of the most important and interesting features of ensemble methods that employ Bagging: out-of-bag (OOB) estimates. Whenever we bag data, since we are drawing samples with replacement, we can ask how well our classifiers do on data points that are *not used* in the training. This is the out-of-bag prediction error and plays a similar role to cross-validation error in other ML methods. Since this is the best proxy for out-of-sample prediction, we choose hyperparameters to minimize the out-of-bag error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n_estimators: 10, leaf_size: 2\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "9.2898         1.0000         0.9935         1.0000         0.8046         \n",
      "n_estimators: 20, leaf_size: 2\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "10.6592        1.0000         0.9998         1.0000         0.8190         \n",
      "n_estimators: 30, leaf_size: 2\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "11.5031        1.0000         1.0000         1.0000         0.8251         \n",
      "n_estimators: 40, leaf_size: 2\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "13.0026        1.0000         1.0000         1.0000         0.8279         \n",
      "n_estimators: 50, leaf_size: 2\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "16.5471        1.0000         1.0000         1.0000         0.8311         \n",
      "n_estimators: 60, leaf_size: 2\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "17.3193        1.0000         1.0000         1.0000         0.8326         \n",
      "n_estimators: 70, leaf_size: 2\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "18.7276        1.0000         1.0000         1.0000         0.8323         \n",
      "n_estimators: 80, leaf_size: 2\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "21.0295        1.0000         1.0000         1.0000         0.8328         \n",
      "n_estimators: 90, leaf_size: 2\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "22.3827        1.0000         1.0000         1.0000         0.8321         \n",
      "n_estimators: 100, leaf_size: 2\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "22.8116        1.0000         1.0000         1.0000         0.8326         \n",
      "n_estimators: 10, leaf_size: 10000\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "6.8829         0.9990         0.9901         0.9992         0.6869         \n",
      "n_estimators: 20, leaf_size: 10000\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "9.5803         0.9992         0.9984         0.9995         0.6870         \n",
      "n_estimators: 30, leaf_size: 10000\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "9.7861         0.9992         0.9990         0.9995         0.6866         \n",
      "n_estimators: 40, leaf_size: 10000\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "11.4167        0.9992         0.9992         0.9995         0.6878         \n",
      "n_estimators: 50, leaf_size: 10000\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "13.7088        0.9992         0.9992         0.9995         0.6869         \n",
      "n_estimators: 60, leaf_size: 10000\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "14.7469        0.9992         0.9992         0.9995         0.6871         \n",
      "n_estimators: 70, leaf_size: 10000\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "16.5755        0.9992         0.9992         0.9995         0.6866         \n",
      "n_estimators: 80, leaf_size: 10000\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "18.9235        0.9992         0.9992         0.9995         0.6863         \n",
      "n_estimators: 90, leaf_size: 10000\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "20.5959        0.9992         0.9992         0.9995         0.6861         \n",
      "n_estimators: 100, leaf_size: 10000\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "22.3674        0.9992         0.9992         0.9995         0.6865         \n"
     ]
    }
   ],
   "source": [
    "# Apply Random Forest\n",
    "\n",
    "#This is the random forest classifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "#This is the extreme randomized trees\n",
    "from sklearn.ensemble import ExtraTreesClassifier\n",
    "\n",
    "\n",
    "\n",
    "#import time to see how perforamance depends on run time\n",
    "\n",
    "import time\n",
    "\n",
    "import warnings\n",
    "#Comment to turn on warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "#We will check \n",
    "\n",
    "min_estimators = 10\n",
    "max_estimators = 101\n",
    "classifer = RandomForestClassifier # BELOW WE WILL CHANGE for the case of extremly randomized forest \n",
    "\n",
    "n_estimator_range=np.arange(min_estimators, max_estimators, 10)\n",
    "leaf_size_list=[2,10000]\n",
    "\n",
    "m=len(n_estimator_range)\n",
    "n=len(leaf_size_list)\n",
    "\n",
    "#Allocate Arrays for various quantities\n",
    "\n",
    "RFC_OOB_accuracy=np.zeros((n,m))\n",
    "RFC_train_accuracy=np.zeros((n,m))\n",
    "RFC_test_accuracy=np.zeros((n,m))\n",
    "RFC_critical_accuracy=np.zeros((n,m))\n",
    "run_time=np.zeros((n,m))\n",
    "\n",
    "print_flag=True\n",
    "\n",
    "for i, leaf_size in enumerate(leaf_size_list):\n",
    "    # Define Random Forest Classifier\n",
    "    myRF_clf = classifer(\n",
    "        n_estimators=min_estimators,\n",
    "        max_depth=None, \n",
    "        min_samples_split=leaf_size, # minimum number of sample per leaf\n",
    "        oob_score=True,\n",
    "        random_state=0,\n",
    "        warm_start=True # this ensures that you add estimators without retraining everything\n",
    "    )\n",
    "    for j, n_estimator in enumerate(n_estimator_range):\n",
    "        \n",
    "        print('n_estimators: %i, leaf_size: %i'%(n_estimator,leaf_size))\n",
    "        \n",
    "        start_time = time.time()\n",
    "        myRF_clf.set_params(n_estimators=n_estimator)\n",
    "        myRF_clf.fit(X_train, Y_train)\n",
    "        run_time[i,j] = time.time() - start_time\n",
    "\n",
    "    # check accuracy\n",
    "        RFC_train_accuracy[i,j]=myRF_clf.score(X_train,Y_train)\n",
    "        RFC_OOB_accuracy[i,j]=myRF_clf.oob_score_\n",
    "        RFC_test_accuracy[i,j]=myRF_clf.score(X_test,Y_test)\n",
    "        RFC_critical_accuracy[i,j]=myRF_clf.score(X_critical,Y_critical)\n",
    "        if print_flag:\n",
    "            result = (run_time[i,j], RFC_train_accuracy[i,j], RFC_OOB_accuracy[i,j], RFC_test_accuracy[i,j], RFC_critical_accuracy[i,j])\n",
    "            print('{0:<15}{1:<15}{2:<15}{3:<15}{4:<15}'.format(\"time (s)\",\"train score\", \"OOB estimate\",\"test score\", \"critical score\"))\n",
    "            print('{0:<15.4f}{1:<15.4f}{2:<15.4f}{3:<15.4f}{4:<15.4f}'.format(*result))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.plot(n_estimator_range,RFC_train_accuracy[1],'--b^',label='Train (coarse)')\n",
    "plt.plot(n_estimator_range,RFC_test_accuracy[1],'--r^',label='Test (coarse)')\n",
    "plt.plot(n_estimator_range,RFC_critical_accuracy[1],'--g^',label='Critical (coarse)')\n",
    "\n",
    "plt.plot(n_estimator_range,RFC_train_accuracy[0],'o-b',label='Train (fine)')\n",
    "plt.plot(n_estimator_range,RFC_test_accuracy[0],'o-r',label='Test (fine)')\n",
    "plt.plot(n_estimator_range,RFC_critical_accuracy[0],'o-g',label='Critical (fine)')\n",
    "\n",
    "#plt.semilogx(lmbdas,train_accuracy_SGD,'*--b',label='SGD train')\n",
    "\n",
    "plt.xlabel('$N_\\mathrm{estimators}$')\n",
    "plt.ylabel('Accuracy')\n",
    "lgd=plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\n",
    "plt.savefig(\"Ising_RF.pdf\",bbox_extra_artists=(lgd,), bbox_inches='tight')\n",
    "\n",
    "plt.show()\n",
    "\n",
    "plt.plot(n_estimator_range, run_time[1], '--k^',label='Coarse')\n",
    "plt.plot(n_estimator_range, run_time[0], 'o-k',label='Fine')\n",
    "plt.xlabel('$N_\\mathrm{estimators}$')\n",
    "plt.ylabel('Run time (s)')\n",
    "\n",
    "\n",
    "plt.legend(loc=2)\n",
    "#plt.savefig(\"Ising_RF_Runtime.pdf\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extremely Randomized Trees##\n",
    "\n",
    "As discussed in the main text, the effectiveness of ensemble methods generally increases as the correlations between members of the ensemble decrease. This idea has been leveraged to make methods that introduce even more randomness into the ensemble by randomly choosing features to split on as well as randomly choosing thresholds to split on. See Section 4.3 of Louppe 2014 [arxiv:1407.7502](https://arxiv.org/pdf/1407.7502.pdf).\n",
    "\n",
    "Here we will make use of the scikit-learn function `ExtremeTreesClassifier` and we will just rerun what we did above. Since there is extra randomization compared to random forests, one can imagine that the performance of the critical samples will be much worse. Indeed, this is the case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n_estimators: 10, leaf_size: 2\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "6.9171         1.0000         0.9932         1.0000         0.8024         \n",
      "n_estimators: 20, leaf_size: 2\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "8.8079         1.0000         0.9997         1.0000         0.8180         \n",
      "n_estimators: 30, leaf_size: 2\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "10.4896        1.0000         0.9999         1.0000         0.8264         \n",
      "n_estimators: 40, leaf_size: 2\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "13.4032        1.0000         1.0000         1.0000         0.8298         \n",
      "n_estimators: 50, leaf_size: 2\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "14.5475        1.0000         0.9999         1.0000         0.8307         \n",
      "n_estimators: 60, leaf_size: 2\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "15.7837        1.0000         1.0000         1.0000         0.8318         \n",
      "n_estimators: 70, leaf_size: 2\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "18.3969        1.0000         1.0000         1.0000         0.8336         \n",
      "n_estimators: 80, leaf_size: 2\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "20.1621        1.0000         1.0000         1.0000         0.8341         \n",
      "n_estimators: 90, leaf_size: 2\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "21.5447        1.0000         1.0000         1.0000         0.8357         \n",
      "n_estimators: 100, leaf_size: 2\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "25.8101        1.0000         1.0000         1.0000         0.8357         \n",
      "n_estimators: 10, leaf_size: 10000\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "6.5247         0.9991         0.9900         0.9993         0.6834         \n",
      "n_estimators: 20, leaf_size: 10000\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "8.3836         0.9992         0.9983         0.9995         0.6851         \n",
      "n_estimators: 30, leaf_size: 10000\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "9.8547         0.9992         0.9990         0.9995         0.6859         \n",
      "n_estimators: 40, leaf_size: 10000\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "11.0481        0.9992         0.9992         0.9995         0.6870         \n",
      "n_estimators: 50, leaf_size: 10000\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "13.4941        0.9992         0.9992         0.9995         0.6866         \n",
      "n_estimators: 60, leaf_size: 10000\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "15.2564        0.9992         0.9992         0.9995         0.6869         \n",
      "n_estimators: 70, leaf_size: 10000\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "17.3889        0.9992         0.9992         0.9995         0.6860         \n",
      "n_estimators: 80, leaf_size: 10000\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "18.4751        0.9992         0.9992         0.9995         0.6858         \n",
      "n_estimators: 90, leaf_size: 10000\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "20.0756        0.9992         0.9992         0.9995         0.6859         \n",
      "n_estimators: 100, leaf_size: 10000\n",
      "time (s)       train score    OOB estimate   test score     critical score \n",
      "21.8532        0.9992         0.9992         0.9995         0.6862         \n"
     ]
    }
   ],
   "source": [
    "#This is the extreme randomized trees\n",
    "from sklearn.ensemble import ExtraTreesClassifier\n",
    "\n",
    "#import time to see how perforamance depends on run time\n",
    "\n",
    "import time\n",
    "\n",
    "import warnings\n",
    "#Comment to turn on warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "#We will check \n",
    "\n",
    "\n",
    "min_estimators = 10\n",
    "max_estimators = 101\n",
    "classifer = ExtraTreesClassifier # only changing this\n",
    "\n",
    "n_estimator_range=np.arange(min_estimators, max_estimators, 10)\n",
    "leaf_size_list=[2,10000]\n",
    "\n",
    "m=len(n_estimator_range)\n",
    "n=len(leaf_size_list)\n",
    "\n",
    "#Allocate Arrays for various quantities\n",
    "\n",
    "ETC_OOB_accuracy=np.zeros((n,m))\n",
    "ETC_train_accuracy=np.zeros((n,m))\n",
    "ETC_test_accuracy=np.zeros((n,m))\n",
    "ETC_critical_accuracy=np.zeros((n,m))\n",
    "run_time=np.zeros((n,m))\n",
    "\n",
    "print_flag=True\n",
    "\n",
    "for i, leaf_size in enumerate(leaf_size_list):\n",
    "    # Define Random Forest Classifier\n",
    "    myRF_clf = classifer(\n",
    "        n_estimators=min_estimators,\n",
    "        max_depth=None, \n",
    "        min_samples_split=leaf_size, # minimum number of sample per leaf\n",
    "        oob_score=True,\n",
    "        bootstrap=True,\n",
    "        random_state=0,\n",
    "        warm_start=True # this ensures that you add estimators without retraining everything\n",
    "    )\n",
    "    for j, n_estimator in enumerate(n_estimator_range):\n",
    "        \n",
    "        print('n_estimators: %i, leaf_size: %i'%(n_estimator,leaf_size))\n",
    "        \n",
    "        start_time = time.time()\n",
    "        myRF_clf.set_params(n_estimators=n_estimator)\n",
    "        myRF_clf.fit(X_train, Y_train)\n",
    "        run_time[i,j] = time.time() - start_time\n",
    "\n",
    "    # check accuracy\n",
    "        ETC_train_accuracy[i,j]=myRF_clf.score(X_train,Y_train)\n",
    "        ETC_OOB_accuracy[i,j]=myRF_clf.oob_score_\n",
    "        ETC_test_accuracy[i,j]=myRF_clf.score(X_test,Y_test)\n",
    "        ETC_critical_accuracy[i,j]=myRF_clf.score(X_critical,Y_critical)\n",
    "        if print_flag:\n",
    "            result = (run_time[i,j], ETC_train_accuracy[i,j], ETC_OOB_accuracy[i,j], ETC_test_accuracy[i,j], ETC_critical_accuracy[i,j])\n",
    "            print('{0:<15}{1:<15}{2:<15}{3:<15}{4:<15}'.format(\"time (s)\",\"train score\", \"OOB estimate\",\"test score\", \"critical score\"))\n",
    "            print('{0:<15.4f}{1:<15.4f}{2:<15.4f}{3:<15.4f}{4:<15.4f}'.format(*result))\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgwAAAEOCAYAAADlpk+ZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvqOYd8AAAIABJREFUeJzs3Xlc1NX+P/DXmQWGTQTZZVOZGRjADcLcNc3UXNMWS62sa+a1uraYXcrKtbpmq+XSTy3rm3a1q2ammRuapQ4qm6ACyo6i7MLALOf3x8zQAAMzLIOY7+fjMQ/nc875fD5vh9HPm89y3oxzDkIIIYSQ5ghudwCEEEII6fwoYSCEEEKIRZQwEEIIIcQiShgIIYQQYhElDIQQQgixiBIGQgghhFhECQMhhBBCLKKEgRBCCCEWUcJACCGEEIsoYSCEEEKIRaLbHUB78fDw4MHBwbc7DEIIuaPEx8ff4Jx7tnEbXiKR6CsAEaBfRO9UOgDJGo3m2aioqOvmBvxtEobg4GAolcrbHQYhhNxRGGNZbd2GSCT6ysfHJ8zT07NEIBBQgaI7kE6nY0VFRYrCwsKvAEwyN4YyQUIIIW0V4enpWU7Jwp1LIBBwT0/PMujPEpkf04HxEEII+XsSULJw5zP8DJvMCyhhIIQQckcrLCwUhoaGKkJDQxUeHh59vLy8ehuXVSoVs2Yb06dPD05ISLBvyX43b97stnjxYp/WRd3+tm7d2vW1117ztdX2Ged/j6QwOjqa0z0MhBDSMoyxeM55dFu2kZCQcLVPnz43WrJOVhbE06ej586dyAgMhKYt+zf18ssv+zk7O2uXLl16zbRdp9OBcw6hUNheu0Lv3r1DDx06dNnT01Pbbhs1odFoIBJZf6uhTqeDQqFQnD17NtXR0bFVB/eEhASPPn36BJvrs9kZBsbYJsbYdcZYchP9jDH2KWMsnTGWyBjrb9L3JGPssuH1pK1iBIAT879DrigYOiZArigYJ+Z/Z8vdddoYKA6K406IozPEQHG0j9hY+MbHwzk2Fn622kdycrK9VCoNf/zxxwPDw8MV2dnZ4hkzZgRFRESEhYSEhL/66qt1v41HRUXJT5486aBWq+Hi4tJ3/vz53eVyuaJv376heXl5jY7a8fHxEmdnZ50xWcjOzhaNGjWql0wmU8jlcsXhw4edAODNN9/0lkql4VKpNHzFihVexvXvu+++kPDw8LCQkJDwNWvWeACAcd8vvviiX2RkZNjRo0ednnvuOf9evXqFy2QyxfPPP98dAHJyckRjxozpFRERERYZGRl26NAhJwAQCAQYMGBAxX//+19Xm3ygnHObvAAMA9AfQHIT/eMB/AKAAbgXwClDuzuATMOfbob3bpb2FxUVxVvq+PPf8ko4cg7UvSrhyI8//22Lt9VanSEGioPiuBPi6Awx/B3jAKDkbfz//vz581c550rj6557eEXD16pVPItzriwv52f79OGVjOnDZozzPn145Sef8Cucc2V+Pj/fcF3TbVt6LVy4MP+tt97K4Zwrk5KSkhhj/OjRoxeM/YWFhec458ra2lpl//79K5RKZTLnXNm/f/+K33//PaW2tlYJgG/fvv0S51z5zDPPFL7xxhu5DfezevXqq/PmzSswLo8ZM6ZkxYoVWcZt37x58+zhw4cvyGSyqvLy8rPFxcVne/ToUf3nn3+mmMZRXl5+tmfPntXXr18/Z9z3li1b0jnnyuzs7PO9evWq1mq1Ss65sqio6BznXDl+/Pji3377LZVzrkxLS0sMCQmpNsbx6aefXpkzZ861lnxmpi/Dz9Lsz9lmj1VyzuMYY8HNDJkM4BvDF/ZPxlhXxpgvgBEADnLOiwGAMXYQwFgA37d3jMEbYuGEqnptTqhC9JfP4Pz/bWzv3ZkVXfYnJKi5rTFQHBTHnRBHZ4jhTogjeEMs8MUTHRZHa+Tnw6655fYUEBBQM3z48Lr/6Ddt2uS+detWD41Gw4qKisSJiYkOUVFRKtN1JBKJ7pFHHikHgKioqKrjx487N9xuQUGB2NPTs+5SyqlTp1z27NmTCQBisRju7u66o0ePukycOLHExcVFBwDjxo0rPXLkiPOAAQOqV65c6b1///6uAHDt2jW71NRU+4EDB1aJxWI+a9asUgDw8vLSCgQCPmPGjKAHH3yw7NFHHy0DgN9//71LRkaGxLjvsrIyYWVlJXN2dube3t7qwsJCcXt+hka3cx6G7gByTJZzDW1NtTfCGJsLYC4ABAYGtjgAP2222XZ71EBXVg44OkEgFkKrqoWgprrROO7kAoFIAE1VLYRqM/3OLhAIBdDcqoFQY/w+mlxWcnGFfYN/8KYxcOhPv2gqqyHS1h/HwcBc9WedNBVVEOlqm+zXlt+CkKvr9esggMC1i6G/stk4tGWVEDa4xKiFCEJX/b8hXVkFBKh/CU/LxBB2cTL0l0MAXZP9vKwMzPC5NBcHykrrljVCe4icHcA5wMpLG43XCCUQOUvAdRysoqxxv8gBIid76DQ6CG6Vm99fM3Fo7RwhdLCDtlYDYXVlo3FaeycIJWJoazQQqsz0S5whtBdBq1JDWHOrcb+DC4R2wubjAKCpqoHIzHdP59zF8N1TQaRRNernLq5gAgZNpQoirZl+1671vnvW/lyAln/3hFzToF8IgauLvt/ku2dtDK397hlpBHYQuTga+kvR8I45S3G09bunETtA5GgPnVoLQVVFo37jd6+pOJr6f60jnT6Ni031FRdDWF4OkfH2Oc6B8nKIpkxBGQD4+kLT3Pot5eDgUPcFSEpKsl+/fr23UqlM9fDw0E6ePLlHdXV1o5siRSJR3ZdCKBRyrVbbaIyDg4NOpVLVu6zf8EkR3sQ9grt27XI5efKkS3x8fKqzszOPioqSV1dXCwDA3t5eJxDoN2tvb88TEhJSd+3a1WXbtm3u69ev9/z9998vG87qpEokkkY7UKlUAolEomvY3h5uZ8Jg7s5V3kx740bONwDYAOhvemxpAPnCQPhrG89Zkgt/5Hv3h2zzG5CN64U/Vv+OojVbAcbAGasLsf/OWAQM8MPx5cdwc+OPjfqHHHgLnjI3HH3rEIq/PwAwVm/MA8ffRJ6foskYIq8dgsheiF9f3IvyQ2fqDxCJMD3hLQDAL//4EbdOJtTvd3TE9DOvAwD2PvE9VOfT6nUzdzdMO/4vAMCeaV/D68c3EYDcRnHkCYOQPeY5aLPq94l6BGDK3mcBAD/e9zl014rq9dspQjDpv7MAADsGrwFK6//H6RClwIPfPKrvj14FVOsPWt0u3DQbRy78ka6YXLfsOmYA7v9oPGpvqbEnZnmj8d2mDMXIFaNRXnALv47+oFG/9xOjMfTfQ3E9rRhx0z5pvH5aCQJ0jf/jNcYRvHAq+j7bFxlHsnFuwf9rNE625DH0fjQMF3ZfxoV/f9uoP+KD2Qh9sBfOf5eC9JU/NOqP+vJZ9BgWgBxhkNk48gSB6Ft6FCfX/Imr/++XRv0j9yxEt15dcWxZHIq2HWrUP/boYjh7OuDwGwdRvOdEo/4pZ5fU++41+XNhAUgPm1y/sYXfvdq0zHr9Qj9vTD04HwDwv/Eb67571n43WvvdM3Ia0g/j1k/R90e+C+jq/9/bLbUYATwHDRnjaOt3z/+5BxH9YgxyzhTi1FNfNuo3fvdyhUHwN/PdyBcGwr9Ra+cRGwvfBh8pdDogNhZ+W7fCptlOaWmp0MnJSevm5qbNysoSx8XFdXnggQcaZ3VWUCgUqh07drgZl++9997y//znP57//ve/izQaDcrLywUjR46smD9/fvA777xTqNVq2f79+7t+//33mRcuXLDv2rWrxtnZmSuVSklSUpKTuX2UlJQIqqurBTNmzCgbPnz4rfDw8HAAGDx4cPn777/v+fbbb18HgJMnTzoMGjSoGgAuXrwoCQ8Pb/xbRHto67Wr5l4AgtH0PQzrAcwwWb4IwBfADADrmxrX1Ks19zAceHg9r4RDg2uADvzXhze0eFut1RlioDgojjshjs4Qw98xDtjgHobmXnI5v2USct1LLue3rN1Gc6+G9zDI5fIqY59Wq1VOnjz5Zs+ePatHjBhROmrUqJK1a9dm8gb3MDg7O2uM66xfvz7jkUceKWq4n9LS0rOm9w5kZWWdHzlyZKlUKq0KDQ2tOnz48AXOuTI2NjYnJCSkOiQkpHr58uXZnHPlrVu34gcPHlwmk8mqxo8fXxwVFVWxf//+tIb7Tk9PT4iIiLglk8mqpFJp1eeff57JOVfm5eWdf+CBB4qlUmlVz549q2fOnHnduM6QIUPKjPdltOZ1W+5hsMIeAAsYY9sADABQxjkvYIwdALCSMWbM3MYAeMMWAdhfOA8l+qMXrsIP+ciHHzIQDLsL522xu04bA8VBcdwJcXSGGCiOtktLQ6ott79mzZp84/uIiIiatLS0C8ZlgUCAXbt2XTG3Xnx8fN1lkIqKiroPce7cuSVz584taTje1dVVd++991bs3bvXZcKECRWBgYGaw4cPpzcct3z58mvLly+v94ino6MjP3HixGVzcZjuu1evXuqkpKRGn5efn59m//79mQ3br169KtbpdGh4T0Z7sVnCwBj7HvobGD0YY7kA3gYgBgDO+ToA+6B/UiIdQBWApw19xYyxZQCM5+CXcsMNkO3NO+MPhOKvf1z+yIM/8pCW0fiasq10hhgoDorjToijM8RAcRBTy5cvLzh58qTj7Y7DKDMz027NmjWNr9u1E5q4iRBC7mK3a+Im0jndlombCCGEEPL3QQkDIYQQQiyihIEQQgghFlHCQAghhBCLKGEghBByR2uP8tYA8PHHH3fLzs5u8unB2bNnBx48eNDsJEu3w5w5cwJ++eWXRtNW2wolDIQQQjpeVpYY99wjRzMHaGv5+Pho09LSLqSlpV2YPXt20bx5864Zl81Nn9yUrVu3euTm5pqtw5Cfny9KTk52vP/++23y3KparbY8qIFXXnnl+qpVq3wtj2wflDAQQgjpeLGxvoiPd0ZsrM3KWwPAZ5991i0yMjIsNDRUMXPmzECtVgu1Wo0pU6b0kMlkCqlUGr58+XKvjRs3uqWmpjo+/vjjvcydmfjmm2/cRo8eXTeN9OHDh5369u0bKpfLFb179w6tqKgQVFZWsoceeihYJpMpFApFmPG3/5SUFPuoqCh5WFiYIjw8PMxY+nrXrl0ugwYNkk2YMKFneHi4oqSkRDBs2DCpXC5XSKXS8M2bN7sBwLFjxxzvueceeXh4eNiwYcOkOTk5IgAIDw+vuX79ujg/P79DJmG8nTM9EkII+TuKiZE3anvooWIsXlyEigoBhg6VITHRCZwD333niaQkR8yZU4QXX7yJggIRJk/uVW/d06dbVYzqzJkzkt27d3c9e/ZsqlgsxowZM4I2btzoLpPJaoqLi0WXLl26AAA3btwQenh4aNetW+f12WefZRvrMpg6efKk88yZM28CQFVVFZs1a1bP7du3ZwwZMqTq5s2bQgcHB93bb7/tY2dnxy9dunRBqVRKJk2aJM3MzEwODAxUHz9+/JKjoyM/d+6c5MknnwxOTExMA4Dz5887JSQkpEil0tqNGze6BQQE1MTFxV0GgJs3bwqrq6vZv/71r8B9+/al+/r6ar788kv3RYsWdf/++++zACAiIqLq8OHDzjNnzmxcha+dUcJACCGkY+Xn2zW73E5++eWXLomJiU6RkZEKQF/J0d/fv3bKlCllmZmZkqeffjpgwoQJZVOnTm1cNrSB69evi318fDQAcO7cOYmfn1/tkCFDqgCgW7duWgD4448/nF977bVCAIiOjlZ5eXmpU1JS7AMDA9XPPPNMUGpqqqNQKOQ5OTn2xu327du3UiqV1gJAVFRU9TvvvOM/f/787lOmTCkdM2bMrZMnTzqkp6dLRo4cKQMAnU4HHx+fuusXnp6e6ry8PJuUs26IEgZCCCHtq7kzAsXFQpSXi1C/vrUIU6boT/f7+mpae0ahIc45ZsyYceOTTz7Jb9iXkpKSsnPnTtfPPvvMa8eOHW7G39ibIpFIdMYS1Jxzxljjeymbmjl52bJl3v7+/rW7du26Ultby1xcXPoZ+xwdHetqd/bv318VHx9/YefOna6vv/56wOHDh0snTpxYJpPJqk1rXZhSqVQC0xLetkT3MBBCCOk4sbG+DUuGG+pbt/u9DOPGjavYvXu3e0FBgQjQP01x+fJlu/z8fJFOp8OcOXNKli5dmp+UlOQIAE5OTrry8nKhuW3JZDLVxYsX7QH9mYC8vDy7EydOOAJAcXGxQKPRYPDgwRVbt27tBgBnz56VFBUVicPDw2vKysqEvr6+aoFAgLVr13ZrKrG4cuWK2NXVVffPf/6z+MUXX7x2/vx5x/79+6uuXbtmd+TIEUcAUKlUTKlUSozrZGRkSPr27WubctYN0BkGQgghHUepdIJaXf/Xc7Wa4cyZdn9cMSYmpnrx4sX5I0eOlOl0OojFYv7FF19kCYVC/OMf/wjmnIMxhhUrVuQCwOzZs2/MmzcvWCKR6M6fP59q+oTFxIkTy7Zs2dLtxRdfvOng4MC/+eabzPnz5wfW1NQIJBKJ7sSJE5cWL158fdasWUEymUwhEon4V199dUUikfCXX375+sMPP9xrx44d7sOHDy+3s7MzmzGcPn3a8a233uouEAggFov5l19+meXg4MC3bduW8dJLLwVUVlYKtVotW7BgQWF0dLSqurqa5ebm2g0aNKiqvT87c6j4FCGE3MWo+JR1dDodoqOjQ3/77bdL7u7uHXIJwJJNmza5paSkSD788MOC9tomFZ8ihBBC2kAgEOCDDz7IycjIsMkNmq2h0+kQGxt7raP2R5ckCCGEECuMHj3aJpM2tdazzz5b0pH7ozMMhBBCCLGIEgZCCCGEWEQJAyGEEEIsooSBEEIIIRZRwkAIIeSOl52dLZowYULPgICAiF69eoUPHz48JDEx0d7c2H79+oUCwMWLF+3WrVvnbmyPi4tzfOqppwJas/+YmBh5XFyco7m+sWPH9rxw4UKnebpiwoQJPZOSksx+Ns2hhIEQQkiHyyrNEt+z8R55dlnby1vrdDpMmjQpZNiwYRU5OTnJGRkZKatWrcrLz8+vV2NBo9EAAM6dO5cGAJcvX7bfvn17XcIwbNiwqi1btuS0NR5TSqVSotVqmUKhqG3P7Rq1piz2888/f33FihU+LV2PEgZCCCEdLvZwrG98frxz7OG2Twm9d+9eF5FIxBctWlRkbBs0aFD12LFjK/fu3esyYMAA2cSJE3vI5fJwAHB0dOwHALGxsd2VSqVzaGio4t133/Xau3evy8iRI0MAoKysTDB9+vRgmUymkMlkii1btnQFgCeeeCIwIiIiLCQkJHzhwoUWY9+yZUu3iRMn1lWS3LFjRxeFQhEml8sVAwcOlAHAtWvXhKNHj+4lk8kUffr0CT116pQDABw5csSxX79+oWFhYYp+/fqFJiQk2APAp59+2m3cuHE977vvvpChQ4fKsrKyxNHR0fLQ0FCFVCoN379/vzMA/Pjjj1369u0bqlAowsaNG9ezrKxMAABjx46tPH78eJeWJhs2nYeBMTYWwCcAhAC+4py/16A/CMAmAJ4AigHM5JznGvq0AJIMQ7M555NsGSshhJD2EbOxcXnrh8IeKl48ZHFRRU2FYOjmobLEa4lOHBzfJX7nmXQtyXFOvzlFLw548WZBRYFo8rb65a1P/6P5YlSJiYkOffr0aXJ65MTERKdz586lhIaG1vstf8WKFXkffvih95EjR9IBfeJh7Fu8eLFvly5dtMYS2EVFRUIAWLNmTZ63t7dWo9Fg0KBB8lOnTjkMGDCgyVoOp06dcp49e3YxAOTn54sWLFgQfPTo0bTQ0NDaa9euCQFg0aJFfn369Kn67bffMvbs2ePy5JNP9khLS7vQp08f1enTp9PEYjF27drlsmjRIv8DBw5kAMDZs2edExMTU7y9vbVvv/2296hRo8ref//9Qo1Gg4qKCkFBQYFo5cqVvnFxcZe6dOmii42N9Vm2bJn36tWrC4RCIYKCglR//vmn49ChQ62eVtpmCQNjTAhgLYD7AeQCOMMY28M5v2AybDWAbzjnXzPG7gOwCsAsQ18157yvreIjhBBye+RX1C9n3XC5vfXu3ftWw2TBkri4uC7btm3LNC57enpqAeDrr79237Jli4dGo2FFRUXihIQESXMJQ1FRkdhYjvro0aNOMTExFcZYvL29tQBw+vRpl507d6YDwKRJkyrmzp0runnzprCkpETw6KOP9rh69aqEMcbVJjU4hg4dWm5c/95777313HPPBavVasH06dNLBg0aVP3999+7ZGRkSGJiYkIBQK1Ws6ioqErj+h4eHpqcnJwWlcW25RmGGADpnPNMAGCMbQMwGYBpwqAAsNDw/giAXTaMhxBCSAdo7oxAcXWxsLymXMShr2PEwVFeUy6aEqovb+3r4quxdEahocjIyOpdu3a5NdVvWkLaWsbCVKbS0tLsPv/8c+/4+PhUT09P7bRp04JVKlWzl/bt7e1Ny2I32qaxvSHGGH/99de7Dx8+vOLgwYMZFy9etLvvvvvqztyY/p3GjRtXGRcXd3Hnzp2uTz31VI8XX3zxmru7u2bIkCHlP/300xVzcdXU1Aha+rnY8h6G7gBMbx7JNbSZSgAwzfB+KgAXxlg3w7KEMaZkjP3JGJtiwzgJIYR0kNjDsb46Xv84peM6tOVehokTJ1bU1tayDz/80MPYduzYMceff/7Zubn1XF1dtZWVlWbLWY8YMaJ8zZo1XsbloqIiYUlJidDBwUHn7u6uzcnJER09etTVUmxSqVSVmppqDwAjR468derUKZe0tDQ7QH/vAgDce++9FZs3b+4G6C+LuLm5adzd3XXl5eVCf3//WgBYv369R1P7uHTpkl337t3Vr7zyyo2ZM2feOHv2rOOIESNuKZVK5+TkZHsAqKioEJg+NXLlyhX7fv36qSzFb8qWCUPjNApomEa9CmA4Y+wcgOEA8gBoDH2BhgpqjwP4mDHWq8G6YIzNNSQVyqKioobdhBBCOhllvtJJratf3lqtU7Mzea0vby0QCLBnz56MQ4cOdQkICIgICQkJf/vtt/0CAwObvasvJiamWiQScblcrnj33Xe9TPtWrVpVUFpaKpRKpeFyuVyxb98+l4EDB1ZHRERUSaXS8FmzZgWbnuJvyrhx40oPHz7sAgB+fn6aTz/99OrUqVND5HK5YurUqT0B4P33388/e/aso0wmU8TGxnbfsmXLFQB4/fXXC9955x3//v37h2q12ib3ceDAAReFQhEeFham2L17t9uiRYuu+fn5adavX3/1scce6ymTyRRRUVGhSUlJEgDIyckR2dvb86CgoBbd9Wiz8taMsYEA3uGcP2BYfgMAOOermhjvDCCNc+5vpm8LgL2c8x1N7Y/KWxNCSMtReWvbqqysZIMHD5bHx8eniUSdo97ju+++69WlSxfdwoULG/3Mbld56zMApIyxHowxOwCPAdhjOoAx5sEYM8bwBvRPTIAx5sYYszeOATAY9e99IIQQQjo9Z2dnvmTJkvwrV650mombunbtql2wYEGLEzybpTuccw1jbAGAA9A/VrmJc57CGFsKQMk53wNgBIBVjDEOIA7APw2rhwFYzxjTQZ/UvNfg6QpCCCHkjjBt2rTy2x2DqZdeeulma9az6fkRzvk+APsatC0xeb8DQKPLDJzzkwAibRkbIYQQQqxHMz0SQgghxCJKGAghhBBiESUMhBBCCLGIEgZCCCF3tMLCQmFoaKgiNDRU4eHh0cfLy6u3cVmlUpmbE6iR6dOnBxuLO1lr8+bNbosXL/YB9HMbREZGhoWFhSkOHjzoNGTIEGlJSUmrjrFLly71Wrt2rbvlkR3LZvMwdDSah4EQQlrudszDsG4d3JcuRffCQtj5+KB2yRLkzZuH4rbEYPTyyy/7OTs7a5cuXXrNtF2n04FzDqHQ7MSOrdK7d+/QQ4cOXfb09NR+8cUX7kePHnX54Ycfstq63bKyMsHAgQPlFy5cSG2POFvids3DQAghhNSzbh3cFy5EUEEB7DgHCgpgt3AhgtatQ7v/Rp2cnGwvlUrDH3/88cDw8HBFdna2eMaMGUHG8tSvvvqqr3FsVFSU/OTJkw5qtRouLi5958+f310ulyv69u0bmpeX1+iJwvj4eImzs7PO09NTGxcX57hs2bLuBw8e7Go8q+Ht7d37xo0bQmMMjzzySFBISEj4sGHDpFVVVQwAkpKS7IcMGSINDw8Pi46OlhunbnZ1ddX5+PioT5w44djen0lbdI5ppwghhPwtzJmDgORkNHmgS0iAU21t/dIBKhUEL72E4E2b4GlunYgIVG3aVK82kdUyMjIkX3311ZXhw4dnA8DHH3+c6+3trVWr1bj33nvl8fHxJVFRUfVqKlRWVgpHjBhR8cUXX+Q9++yz/mvXrvVYuXJloemYo0ePOvfp0+cWAAwbNqzqtddeK0hOTnbYtGlTozivXLli/91332XGxMRkjRkzpte3337bde7cuSXPPvts0KZNm7LCw8Nrfv31V6fnn38+8Pfff78MAP369bt15MgR5yFDhlhdftrWKGEghBDSYRomC5ba2yogIKBm+PDhdQfdTZs2uW/durWuPHViYqJDw4RBIpHoHnnkkXIAiIqKqjp+/HijIlYFBQViT09PTcN2cwIDA2tiYmKqAX0icPXqVfsbN24IExISnKdNm1ZXJ0mr1dZ9Bl5eXpqrV692mtkhAUoYCCGEtCNLZwL8/BBZUIBGB0JfX9SePo0WlbW2hoODQ11pzKSkJPv169d7K5XKVA8PD+3kyZN7VFdXN0pURCJR3c19QqGQmx7ITbdrqbS1kZ2dnen2oNFoGOccXbt21aSlpZmdxVilUjEHB4dOdZMh3cNACCGkwyxZgjyJBPXqW0sk0C1Zgjxb77u0tFTo5OSkdXNz02ZlZYnj4uK6tHZbCoVClZGR0aKnKkx5enpqPT091d98801XANBqtfjjjz8cjP2XLl2SREZGVrd2+7ZACQMhhJAOM28eij/6CFm+vqhlTH9m4aOPkNVeT0k0Z/DgwVVSqVQlk8nCn3rqqSBrylM3Zfz48RVGJGU4AAAgAElEQVSJiYmtLskNANu3b8/YsGGDp1wuV0il0vBdu3a5Gvvi4+OdJ0yY0KlqUNBjlYQQchej8tatN2vWrMBHH320ZMKECRXtud1jx445fvbZZ147duy42p7btQY9VkkIIYS0s+XLlxdUVFS0+3H0xo0bolWrVuW393bbim56JIQQQlohKChIHRQUVNbe2+1s5bCN6AwDIYQQQiyihIEQQgghFlHCQAghhBCLKGEghBBCiEWUMBBCCLmjtUd5awD4+OOPu2VnZzf5MMDs2bMDDx486AQAe/fudQkJCQkPCwtTXLp0ye7BBx/s2dr4x40b1/PChQudahpocyhhIIQQ0rHWrXOHn18kBIIo+PlFYt26NlWq9PHx0aalpV1IS0u7MHv27KJ58+ZdMy5LJBKrJxvaunWrR25urthcX35+vig5Odnx/vvvv2UY675w4cKC1NTUCzKZrPbnn3/ObG388+bNK1qxYoVPa9fvKJQwEEII6Tjr1rlj4cIgFBTYQV/f2g4LFwa1NWloymeffdYtMjIyLDQ0VDFz5sxArVYLtVqNKVOm9JDJZAqpVBq+fPlyr40bN7qlpqY6Pv74473MnZn45ptv3EaPHl0GAB988IHn/v373VauXNl96tSpwcnJyfahoaEKAFizZo3H2LFjew4ZMkQaFBQU8c9//rO7cRs//PBDl759+4YqFIqwBx98sGd5ebkAAB588MGKo0ePumo0VtWyum1oHgZCCCHtZ86cACQnN1neGgkJTqitrX+ZQKUS4KWXgrFpk9ny1oiIqIKZstGWnDlzRrJ79+6uZ8+eTRWLxZgxY0bQxo0b3WUyWU1xcbHo0qVLFwDgxo0bQg8PD+26deu8Pvvss+xBgwY1quFw8uRJ55kzZ94EgEWLFhX9/vvvztOnTy+ZNWtWaXJycr2aEqmpqY7nz5+/IBaLeUhISORrr712XSwW8//85z++x48fv+Ti4qJ7/fXXfVauXOn13nvvFYpEIvj7+9ecOXPGYeDAgZ2qfoQpmyYMjLGxAD4BIATwFef8vQb9QQA2AfAEUAxgJuc819D3JIA3DUOXc86/tmWshBBCOkDDZMFSexv88ssvXRITE50iIyMVAKBSqQT+/v61U6ZMKcvMzJQ8/fTTARMmTCibOnWqxYmSrl+/Lvbx8bHqFMCQIUPK3dzcdADQs2fP6oyMDLv8/Hxxenq65J577gkFALVazWJiYupqWXh4eGhycnLEd2XCwBgTAlgL4H4AuQDOMMb2cM5NS3muBvAN5/xrxth9AFYBmMUYcwfwNoBoABxAvGHdElvFSwghpB1YOhPg5xeJgoLGN/j5+tbi9Ol2LW/NOceMGTNufPLJJ42mWU5JSUnZuXOnq6Fmg9v333+f1dy2JBKJrrq62qrL+Pb29mbLWQ8fPrx8165dV8yto1KpmKOjY6cu7mTLexhiAKRzzjM557UAtgGY3GCMAsAhw/sjJv0PADjIOS82JAkHAYy1YayEEEI6wpIleZBI6pW3hkSiw5Il7V7eety4cRW7d+92LygoEAH6pykuX75sl5+fL9LpdJgzZ07J0qVL85OSkhwBwMnJSVdeXi40ty2ZTKa6ePFiq8tZjxw5svLUqVPOxqchysvLBUlJSXXbu3r1qqR///6d9uwCYNuEoTsA00wz19BmKgHANMP7qQBcGGPdrFyXEELInWbevGJ89FEWfH1roa9vXYuPPsrCvHntXt46JiamevHixfkjR46UyWQyxahRo2T5+fmizMxMu0GDBoWGhoYqnnvuueClS5fmAcDs2bNvzJs3L9jcTY8TJ04sO3bsmEtrYwkICNB88cUXWY888kgvuVyuuOeee0JTUlIkAHD16lWxi4uL1s/Pr1Pf9Wiz8taMsYcBPMA5f9awPAtADOf8BZMxfgA+B9ADQBz0yUM4gLkA7Dnnyw3j3gJQxTn/sME+5hrGIjAwMCorq9kzSoQQQhqg8tbW0el0iI6ODv3tt98uubu76yyvYb233nrL28vLS/PCCy/cbM/ttsbtKm+dCyDAZNkfQL3rSJzzfM75Q5zzfgBiDW1l1qxrGLuBcx7NOY/29DR/cy0hhBDSVgKBAB988EFORkZGu0+w1K1bN83zzz9/25MFS2z5lMQZAFLGWA8AeQAeA/C46QDGmAeAYs65DsAb0D8xAQAHAKxkjLkZlscY+gkhhJDbYvTo0bdssd1//etfnT5ZAGx4hoFzrgGwAPqDfyqAHzjnKYyxpYyxSYZhIwBcZIxdAuANYIVh3WIAy6BPOs4AWGpoI4QQQshtYNN5GDjn+wDsa9C2xOT9DgA7mlh3E/4640AIIYSQ24imhiaEEEKIRZQwEEIIIcQiShgIIYTc8bKzs0UTJkzoGRAQENGrV6/w4cOHhyQmJpqdaKlfv36hAHDx4kW7dSZFr+Li4hyfeuqpAHPrWBITEyOPi4szW0Nj7NixdeWrN23a5NazZ8/wAQMGyNqyPwAYNGiQrKioyOxEU7ZACQMhhJAOte7MOne/D/0iBe8Kovw+9Itcd6ZtlSp1Oh0mTZoUMmzYsIqcnJzkjIyMlFWrVuXl5+fXK1VtrAZ57ty5NAC4fPmy/fbt2+v2PWzYsKotW7a0uMhVc5RKpUSr1TKFQlELAJs3b/b45JNPsk+dOnWprfubMWPGzdWrV3fYnAKUMBBCCOkw686sc1/468KggsoCOw6OgsoCu4W/LgxqS9Kwd+9eF5FIxBctWlRkbBs0aFD12LFjK/fu3esyYMAA2cSJE3vI5fJwAHB0dOwHALGxsd2VSqVzaGio4t133/Xau3evy8iRI0MAoKysTDB9+vRgmUymkMlkii1btnQFgCeeeCIwIiIiLCQkJHzhwoV+lmLbsmVLt4kTJ5YCwKuvvuobHx/v/MILLwQ999xz/qb7e/nll/0efvjh4JiYGLm/v3/k8uXLvYzb+OKLL9yNJboff/zxIGPi89hjj5X++OOP3Vr7ubUUlbcmhBDSbubsnhOQfL3p8tYJhQlOtbr6lSlVGpXgpf0vBW86b768dYRXRNWmyU0XtUpMTHTo06dPVTP9TufOnUsJDQ2tNW1fsWJF3ocffuh95MiRdECfeBj7Fi9e7NulSxetsQS28dT/mjVr8ry9vbUajQaDBg2Snzp1ymHAgAFN1oA4deqU8+zZs4sBYPXq1QVxcXFdVq9enTNs2LAq0/0BQHp6uuTkyZMXS0tLhWFhYRGvvfZaUUpKiv2OHTvclUplmr29PZ85c2bgunXrui1YsOCmp6entra2lhUWFgp9fHy0TcXQXihhIIQQ0mEaJguW2ttD7969bzVMFiyJi4vrsm3btkzjsqenpxYAvv76a/ctW7Z4aDQaVlRUJE5ISJA0lzAUFRWJfXx81Nbsc8yYMaUODg7cwcFB4+7urs7NzRXt37/fJTk52bFPnz5hgL5Et5eXV13NiW7dummys7PtfHx8bF64ihIGQggh7aa5MwEA4PehX2RBZePy1r7OvrWn/9G68taRkZHVu3btcmuq39HRscW1HzjnYKx+DpOWlmb3+eefe8fHx6d6enpqp02bFqxSqZq9tG9vb9/Wstjs4Ycfvrl27Vqz1TxrampYa/5+rUH3MBBCCOkwS4YtyZOI6pe3logkuiXDWl/eeuLEiRW1tbXsww8/9DC2HTt2zPHnn392bm49V1dXbWVlpdmnDEaMGFG+Zs2auvsIioqKhCUlJUIHBwedu7u7NicnR3T06FFXS7FJpVJVampqq8tijx07tnzv3r1ueXl5IgC4du2a8NKlS3aA/mbPoqIisVwur2nt9luCEgZCCCEdZt4984o/GvNRlq+zby0Dg6+zb+1HYz7KmndP68tbCwQC7NmzJ+PQoUNdAgICIkJCQsLffvttv8DAwGYvBcTExFSLRCIul8sV7777rpdp36pVqwpKS0uFUqk0XC6XK/bt2+cycODA6oiIiCqpVBo+a9as4KioqEpLsY0bN6708OHDrS6LHRUVpXrzzTfzRo0aJZPJZIr77rtPlpOTIwaAEydOOPbr1++WWCy2tJl2YbG8NWNsAYDvOOclHRJRK0VHR3OlUnm7wyCEkDsKlbe2rcrKSjZ48GB5fHx8mkjUvncBPP300wFTpkwpnTx5ckV7bbOt5a19AJxhjP3AGBvLGl7UIYQQQohZzs7OfMmSJflXrlxp97LYERER1e2ZLFhiMWHgnL8JQArg/wF4CsBlxthKxlgvG8dGCCGE3PGmTZtWLpVKW/SUhjVeeeWVDj2rY9U9DFx/3aLQ8NIAcAOwgzH2gQ1jI4QQQkgnYfGCCmPsRQBPArgB4CsAr3HO1YwxAYDLABbZNkRCCCGdnE6n0zGBQND8TXGkU9PpdAxAk49oWnMHhgeAhzjnWaaNnHMdY2xCG+MjhBBy50suKipSeHp6llHScGfS6XSsqKjIFUByU2OsSRj2Aah73IUx5gJAwTk/xTlPbXuYhBBC7mQajebZwsLCrwoLCyNAj+vfqXQAkjUazbNNDbAmYfgSQH+T5Vtm2gghhNyloqKirgOYdLvjILZlTSbIuMlkDZxzHWhKaUIIIeSuYk3CkMkYe5ExJja8XgKQaXEtQgghhPxtWJMwzAMwCEAegFwAAwDMtWVQhBBCCOlcLF5a4JxfB/BYB8RCCCGEkE7KmnkYJACeARAOQGJs55zPsWLdsQA+ASAE8BXn/L0G/YEAvgbQ1TBmMed8H2MsGEAqAGOp0z855/Os+PsQQgghxAasuSSxFfp6Eg8AOAbAH4DFuasZY0IAawGMA6AAMIMxpmgw7E0AP3DO+0F/FuMLk74Mznlfw4uSBUIIIeQ2siZhCOGcvwXgFuf8awAPAoi0Yr0YAOmc80zOeS2AbQAmNxjDAXQxvHcFkG9d2IQQQgjpSNYkDMZ64qWMsQjoD+zBVqzXHUCOyXKuoc3UOwBmMsZyoZ8g6gWTvh6MsXOMsWOMsaFW7I8QQgghNmJNwrCBMeYG/eWDPQAuAHjfivXMlcFuOGXoDABbOOf+AMYD2GqoUVEAINBwqeJlAP/HGOvSYF0wxuYyxpSMMWVRUZEVIRFCCCGkNZq96dFw8C7nnJcAiAPQswXbzgUQYLLsj8aXHJ4BMBYAOOd/GG6w9DA8mVFjaI9njGUAkAFQmq7MOd8AYAMAREdH0/zlhBBCiI00e4bBMKvjglZu+wwAKWOsB2PMDvqbGvc0GJMNYBQAMMbCoH8Ko4gx5mm4aRKMsZ4ApKDJogghhJDbxpopng8yxl4FsB36OhIAAM55cdOrAJxzDWNsAYAD0D8yuYlznsIYWwpAyTnfA+AVABsZYwuhv1zxFOecM8aGAVjKGNMA0AKYZ2l/hBBCCLEdZlImwvwAxq6Yaeac85ZcnrC56OhorlQqLQ8khBBShzEWzzmPvt1xkM7Pmpkee3REIIQQQgjpvCw+JcEYm23u1RHBEUJIZ/Rd0ncI/jgYgncFCP44GN8lfXdXx0HuDtY8VnmPyWso9HMnUN1zQu4yneHg1FlimPvTXGSVZYGDI6ssC3N/mtvhsXSWOMjdw+I9DI1WYMwVwFbOeadKGugeBvJ39V3Sd4g9FIvssmwEugZixagVeCLyiQ6PYe5Pc1GlrqprcxQ7YsPEDR0WS2ti0Og0UGlUqNHUQKVR6d9ra+q1GZfNtZlbb1vyNtxS32q0L4lIghHBI2z112/k6NWjUGlUjdqDXINw9V9Xrd4O3cNArGXNUxINVUH/mCMhf2ud8UBt/C0SQJtj4ZxDrVOjWl0NlUaFao3hTzPLL/3yUr0DNQBUqauwYN8C5JTlQMd19V5anbb+MtdaHKND8+sdSD+Aak11oxie3vU0lsctN3tw13Fdmz4jABAyISQiCSQiCexF9maTBQBQaVQoru64h7nMJQsAkF2W3WExkLuLNdUqf8JfMzQKoC8k9YMtgyJ3t7/zgZpzDi3XQq1Vo1ZbC7XO8GcTy68ceMXsgfqFfS8gvzy/6YO8mfaGY9rjgFqqKsUbh95o1M7AIBQIIWCCei8hq9/WkjENkwUjtU6NSK9I/QFdaF/v4G7aZlw219bUevYie4gE9f+bDP44GFllWY3iCHINwqlnT7Xp82yJpuIIdA3ssBjI3cWaxyqHmyxqAGRxznNtGlUr0CWJvwdzp50dRA74eOzHmBo6FWqdGhqdpu6l1jZYbkF/c32fnf4M5TXljeJzFDtiXMg4iwf65pZ5oxnS20YsEMNB7ACJSAIHkeFPS8vWjjMsj/tuHPIrGteGC+gSgIsLLtY7sDMwMGZuZvi2ae5A3ZJT8G3VGS7PtGccdEmCWMuaSxLZAAo45yoAYIw5MMaCOedXbRoZ6XDt+Zs95xyVtZUoVZWirKYMparSeq8ylUlbzV/L5wrPQaPT1NtWtaYaz+19Ds/tfa49/poWCZkQWq4121elrkLqjVTYCe0gFoj1fwr1B+yGbXYCw58N25tZbtg263+zcO3WtUZx+HfxR9o/0yARSSAUCG39keCD+z8we3BaNXoVHMQONt8/AKwYtcJsDCtGreiQ/RsZ/03c7rNgnSUOcvew5gyDEsAgQ4lqGKZ5/p1zfk8HxGc1OsPQNk39Zr9y1EqMCB5h1cG+rt+QIFg63e0gckBXSVe4SlzRVdIVXSVdsT99f5PjPx/3OUQCEUQCEcRCcd17kUAEsaDBskl/c30N+42/JdNvs+Zjud0Hp84Qw98NnWEg1rImYTjPOe/boC2Bc97HppG1ECUMLXer9hYu3byEtBtpeP7n51FWU9ai9V3sXOod7I0vV3vX5pclrnC1d4W9yL7RNulAbT4WOkgSW6GEgVjLmksSRYyxSYbaD2CMTQZww7ZhkfbCOUdBZQHSbqQh7UYaLt64iLSb+vfW3k394yM/1jvYd5V0RRf7Lo1uBmsPdNrZfCyUIBBCbjdrzjD0AvAdAD9DUy6A2ZzzdBvH1iJ3+xmGGk0N0ovTcfHmxbrkwPiqqK2oG+ckdkKoR2ij1/jvxiOnPKfRdjv6N3uAfqMmpCPRGQZiLasnbmKMORvGV1gcfBvcyQlDSw6QN6pu6M8SGBMCw9mCzJLMevcM+Hfx1ycD3f5KCuQecnR36W72DvbOdAqeENJxKGEg1rJmHoaVAD7gnJcalt0AvMI5f9PWwd0Nmnre/1rlNci6yRqdLbhZfbNuXXuhPWTdZOjn0w8zImZA3k2OUI9QyLrJ4GLv0qI4OtMpeEIIIZ2PNZckznHO+zVoO8s572/TyFroTj3D0NRNfqa8nLzqzhbIPeR1ZwyCXIM65JE6QsjfF51hINay5q41IWPMnnNeA+jnYQDQ+PZ2YrUaTQ1OZJ/Avsv7mk0WTs45CbmHHO4O7h0YHSGEENKYNQnDtwAOMcY2G5afBvC17UL6e8opy8Ev6b9g3+V9+C3zN9xS34Kd0A4SkaTJAjIDAwbehkgJIYSQxiwmDJzzDxhjiQBGA2AA9gMIsnVgdzq1Vo3fc37Hvsv78Ev6L0i+ngxAP8/7rN6zMF46HiN7jMTui7s7xWOEhBBCSHOsfZC+EIAOwCMArgDYabOI7mB55XnYn74f+9L1ZxHKa8ohFogxNGgo/nP/fzBeOh5hHmH1nlKgmw0JIYTcCZpMGBhjMgCPAZgB4CaA7dDfJDmyg2Lr9DQ6Df7I+aPuUkPCtQQAQHeX7ng0/FGMl47HqB6jLD6xQBPzEEII6eyaO8OQBuA4gInGSZoYYws7JKpOrLCyUH8W4fI+HMw8iFJVKYRMiCGBQ/DeqPcwXjoeEV4RNqnWRwghhNwuzSUM06A/w3CEMbYfwDbo72G4q2h1WpzKO4VfLv+Cfen7cLbgLADA19kXD4U+hHHScRjdczS6Srre5kgJIYQQ22kyYeCc/w/A/xhjTgCmAFgIwJsx9iWA/3HOf7W0ccbYWACfABAC+Ipz/l6D/kDon7joahizmHO+z9D3BoBnAGgBvMg5P9CKv59F5mZZvL/n/TiQfgD70vfh14xfUVxdDAETYFDAIKy4bwXGS8ejj3cfOotACCHkrmH11NAAwBhzB/AwgEc55/dZGCsEcAnA/dDXnzgDYAbn/ILJmA0AznHOv2SMKQDs45wHG95/DyAG+hoWvwGQcc61Te2vNRM3mZsOWcAEdVMsezl5YVzIOIwLGYcxvcbAzcGtRdsnhJDOjiZuItZqUblBznkxgPWGlyUxANI555kAwBjbBmAygAsmYziALob3rgDyDe8nA9hmmCzqCmMs3bC9P1oSryWxh2LrJQsAoOM6uNq74tDsQ+jn2w8CJmjPXRJCCCF3JFseDbsDMC1/mGtoM/UOgJmMsVwA+wC80IJ126yp8s7lNeWI8ouiZIEQQggxsOUR0dwF/obXP2YA2MI59wcwHsBWxpjAynXBGJvLGFMyxpRFRUUtDjDQNbBF7YQQQsjdypYJQy6AAJNlf/x1ycHoGQA/AADn/A8AEgAeVq4LzvkGznk05zza09OzxQGuGLUCjmLHem00yyIhhBDSmC0ThjMApIyxHowxO+gf0dzTYEw2gFEAwBgLgz5hKDKMe4wxZs8Y6wFACuB0ewf4ROQT2DBxA4Jcg8DAEOQahA0TN9AkSoQQQkgDLbrpsSU45xrG2AIAB6B/ZHIT5zyFMbYUgJJzvgfAKwA2GiaE4gCe4vrHNlIYYz9Af4OkBsA/m3tCoi1olkVCCCHEshY9VtmZteaxSkIIudvRY5XEWvQYACGEEEIsooSBEEIIIRZRwkAIIYQQiyhhIIQQQohFlDAQQgghxCJKGAghhBBiESUMhBBCCLGIEgZCCCGEWEQJAyGEEEIsooSBEEIIIRZRwkAIIYQQiyhhIIQQQohFlDAQQgghxCJKGAghhBBiESUMhBBCCLGIEgZCCCGEWEQJAyGEEEIsooSBEEIIIRZRwkAIIYQQiyhhIIQQQohFlDAQQgghxCJKGAghhBBiESUMhBBCCLHIpgkDY2wsY+wiYyydMbbYTP9HjLHzhtclxlipSZ/WpG+PLeMkhBBCSPNEttowY0wIYC2A+wHkAjjDGNvDOb9gHMM5X2gy/gUA/Uw2Uc0572ur+AghhBBiPVueYYgBkM45z+Sc1wLYBmByM+NnAPjehvEQQgghpJVsmTB0B5BjspxraGuEMRYEoAeAwybNEsaYkjH2J2Nsiu3CJIQQQoglNrskAYCZaeNNjH0MwA7OudakLZBzns8Y6wngMGMsiXOeUW8HjM0FMBcAAgMD2yNmQgghhJhhyzMMuQACTJb9AeQ3MfYxNLgcwTnPN/yZCeAo6t/fYByzgXMezTmP9vT0bI+YCSGEEGKGLROGMwCkjLEejDE76JOCRk87MMbkANwA/GHS5sYYsze89wAwGMCFhusSQgghpGPY7JIE51zDGFsA4AAAIYBNnPMUxthSAErOuTF5mAFgG+fc9HJFGID1jDEd9EnNe6ZPVxBCCCGkY7H6x+k7V3R0NFcqlbc7DEIIuaMwxuI559G3Ow7S+dFMj4QQQgixiBIGQgghhFhECQMhhBBCLKKEgRBCCCEWUcJACCGEEIsoYSCEEEKIRZQwEEIIIcQiShgIIYQQYhElDIQQQgixiBIGQgghhFhECQMhhBBCLKKEgRBCCCEWUcJACCGEEIsoYSCEEEKIRZQwEEIIIcQiShgIIYQQYhElDIQQQgixiBIGQgghhFhECQMhhBBCLKKEgRBCCCEWUcJACCGEEIsoYSCEEEKIRTZNGBhjYxljFxlj6YyxxWb6P2KMnTe8LjHGSk36nmSMXTa8nrRlnIQQQghpnshWG2aMCQGsBXA/gFwAZxhjezjnF4xjOOcLTca/AKCf4b07gLcBRAPgAOIN65bYKl5CCCGENM2WZxhiAKRzzjM557UAtgGY3Mz4GQC+N7x/AMBBznmxIUk4CGCsDWMlhBBCSDNsmTB0B5BjspxraGuEMRYEoAeAwy1dlxBCCCG2Z8uEgZlp402MfQzADs65tiXrMsbmMsaUjDFlUVFRK8MkhBBCiCW2TBhyAQSYLPsDyG9i7GP463KE1etyzjdwzqM559Genp5tDJcQQgghTbFlwnAGgJQx1oMxZgd9UrCn4SDGmByAG4A/TJoPABjDGHNjjLkBGGNoI4QQQshtYLOnJDjnGsbYAugP9EIAmzjnKYyxpQCUnHNj8jADwDbOOTdZt5gxtgz6pAMAlnLOi20VKyGEEEKax0yO03e06OhorlQqb3cYhBByR2GMxXPOo293HKTzo5keSadUUFGA4VuGo7CykOKgOEgz6GdCOgolDJ1EZ/lH31niWBa3DCeyT2DZsWUUB8VRT2f5jnaWODrDz4TcHeiSBPT/8B/b+Ri2T98OH2efdo7MOvN/no/18esxL2oe1j64tt23zzmHjuug0Wmg0WnAweFs5wwAuFF1A9Xqamh0GsQejsW25G14PPJxfPvQtwAAZb4SJdUlUOvUqNXWQq1Vo5tjN9zX4z4AwNaErbhZfRO12tq6fmk3KWb2ngkAeO3X11BcXfzX+jo1hgQMwcKB+ok+R30zCpW1lXXrVqmrkFOeA41OAweRAzydPGEntIOACSBkQgiYAE/3fRqvDHoFlbWVGPn1SAiYoN7r2X7P4sm+T+JG1Q088eMTjfqf6fcMJsknIa88D6/8+kqj/qf7Pg1ZNxl6fNIDNdoaCJkQj4Q/AolIAg6O56OfR0z3GCRfT8aqE6ug47q6z5iD440hb6C/b3/8mfsnVh5fWdduHLd6zGpEeEXgYMbBv9Y39Ou4Dlsmb4G0mxQ7LuzAsrhlSLqWBA4OARMgpnsM/vvwf+HfxR87L+zE1wlfQywUQyQQ1b0+GfsJukq64udLP+Ng5sF6fSKBCP8e+m/YCe1w9OpRnC88X69PLBDjyb762djPFpxFTlkORAIRymrK8PTup1GrrYWDyAGZL2WiuLoYN6pugIGBMQYGBolIgii/KABA2pgUMxAAAA0tSURBVI00lKnK6voYY3AQOSDcKxwAkF6cjlu1t+r1O4od0dOtJwDgSskV1GhrIGCCuv5lx5bh26RvMS9qHl4f8jrUWnW977qTnVPdv+MrJVegrXtaW8/FzgXezt4AgMs3L4M3eGLb1d4V3s7e4Jzj0s1Ljf4tuTu4w9PJE/P2zsOG+A14NPxRxA6Lrfv5ezt7w8fZBzWaGiRcS6j33dBxHXq69UT3Lt1RWVuJP3P/bNTf27s3AlwDUFxdjKNXj9a1G8cMDhyMQNdA5Ffk44eUH7Do4CKodeq6n0lL/w+jSxLEWja76fFOYpqhW3Ow5pxDrVNDJBBBwAQoU5Xh+q3rUGlUUGlUqNHWQKVRYWjgUNiL7HG+8DzOFpyt6ze+3hz2JuyEdlh3Zh02xG+AjuuwPn49MkoyIBaK8dOMnwAAq0+uxu6Lu6HRaaDVaaHRaWAvsscfz+gfLHnpl5ew6+KuumRAq9PC08kTqf9MBQBM+n4Sfrr0U72/g6ybDBcXXAQATPthGuKy4ur1/1/S/2H1mNXwcfbB3J/m4lzhuXr9I4JH1CUMy+KW4XLx5Xr9k+WT6xKG/Rn7UVJdAjuhHcRCMeyEdpC5y+rGOogcIBbo2+2Edki4lgBjIqvlWkhEEkT7RUOr09b95+np9NdjtF5OXnXtxpeA6U+eaXValNeU1+sztgFAtaYa5wvP/9XH9fsYGzIW21O2Q8d1dXHsubgHbg5uEDABHgp9CABQUVOB03mnwcD0BzWm/7OytlK/fXU1cstz69qN44wHOWMSZ+wXCUR1B0bjZ1NS/deM6JxzZJdm1/39Kmsr65Ir05dWpz9Ini88jy3nt9Tv41osHqIv7fK/1P/h09Of1vvZiQSiuoTh89OfY/P5zWhIy7VYdmwZrlddx44LO+r1BXQJQPbCbADAv/b/Cwcy6j/gpPBUIGV+CgDgyV1P4mTOyXr9Md1jcOrZUwCAKdunIPFaYr1+ARNAx3XYfH4zfrr0/9u79+AqyjOO498nOSQBKsRAtAqEwAwjSRWNilAFBdSxHR2hox07XqoijRVnikpH26rjKDNObyo6Ii2CFFEJeBexXkYtyEiVu4C04o2LBojcRIiJIU//2M3hnIR0KZScM9nfZyZzsvvunvOc97x79tn33T07l41fb0wrH9V/FM9f9jwAg6YOomZv+m+0XDXgKh7/yeMADPjLAL5t+Dat/IbTb+CRCx9hn++j/6T+Ld77rWfeyk2Db2LGyhk4TtWaKqrWVCXLJwyfwB1n38GWPVsYNHVQi/UnXjCRcYPHsX7nes6feX6L8mkXT2N0xWg+2vYRl8y5pEX5nEvnUNK1hDVb13Dza8lf109+JkfigEME1MNA9e5qSh8spX5fPTmWw9CSoThOXUMdj418jPLicmatmsUtr99CXUNdcmfvOGtvXEv/7v25f9H9jH99fIvn3njzRnp26ck98+/hrn/c1aJ8x207KCwo5IwpZ7C4enFyfreO3ehd2JvFv1hMjuVw37v38crHr5BrucmjwM55nZl1SfDTFZMXT+b9L99PKz+64GgmjAi6KJ/44AnWbVtHIidBbk6wTPdO3RldMRqAuf+ey9Y9W3ly1ZO8s+EdGhobSOQkqDy1kkkXTmLpl0upbagNdvg5HeiQ24Eu+V0o6VoCwPba7eRYTrI8kZNI7vAO5fPo+1DftC/xQz1yOhztOY6mbd7Mku25ecJRWlgKwMZdG/lq71ds/mYzo2aPon5ffVoc8y6fl+wdcXccJz83n3NKzwFg8ReLqdlbkyxzD3q2hvcZDsD8z+ezrXZbWnlRxyLO7XsuAK9+HCSbTb0v05dPZ8GGBTQ0NpCXm8eI0hFcftLlae+vV9deDCsdBsDTa56mbl9dWnmfwj6cVXIWAFWrq5JJYZN+Rf0Y2GMgjd7I7NWzW9RfWXEZU5ZOYdryadTvqyeRk2BE6QgqT6skx3IoLy7nhO4nUPtdLW999laL3qt+3fpR0rWEvd/tZVn1smQS2fRXWlhKcedi9tTv4ZMdn7QoP/6o4zkq/yg+3fEp5ZPK097fobQN9TDIwYp9wjB23lgeXfYoDY0NQHC0Wta9jIJEAQ9c8ABlxWUs3LCQmStnkp/IpyBRQEGigPzcfCpPq6S4czEf1nzIsuplybKm8oE9BlKQKGB77Xa+qf8mOb8gUUBebh5m1q53TIdi7LyxyS/iJnm5eYypGNOmR06KI/viyJY2mi1x/L8+EyUMcrBiPSRRvbua6SumJ5MFCLqYqy6tStvwh5QMYUjJkFafp7y4nPLi8lbLizoWUdSx6IBlExZMaHGEk4muxWyJY9GmRWlfgAD1++p5d9O7rayhOOISR7a00WyJIxs+E4mXWCcM2bDhZ8tGny1xLL9+efRCbUBxpMuGOLKljWZLHNnwmUi8xHpIouKvFazYvKLF/FO+f4o2RhGJBQ1JyMGKdQ+DkgIREZGDox9uEhERkUhKGERERCSSEgYRERGJpIRBREREIilhEBERkUjt5rJKM6sB1mc6jsPUHfgq00FkEdVHOtXHfqqLdIdTH73dvTh6MYm7dpMwtAdmtkTXQ++n+kin+thPdZFO9SFtQUMSIiIiEkkJg4iIiERSwpBdpmQ6gCyj+kin+thPdZFO9SFHnM5hEBERkUjqYRAREZFIShgyxMx6mdnbZrbWzNaY2bhwfpGZvWFm68LHozMda1sxs1wzW25mL4fTfczsvbAuZptZXqZjbCtmVmhmz5jZv8I28sOYt42bw+1ktZnNMrOCOLUPM3vMzLaa2eqUeQdsDxZ4yMw+NrMPzOzUzEUu7YkShsxpAMa7exkwGLjRzMqB3wBvuns/4M1wOi7GAWtTpv8APBDWxQ7guoxElRkPAq+6e3/gZIJ6iWXbMLMewK+A0939RCAX+Bnxah9/A37UbF5r7eHHQL/wrxKY3EYxSjunhCFD3L3a3ZeF/+8m2CH0AEYCM8LFZgCjMhNh2zKznsCFwNRw2oARwDPhInGqiy7A2cA0AHevd/edxLRthBJARzNLAJ2AamLUPtx9AbC92ezW2sNI4HEP/BMoNLPj2iZSac+UMGQBMysFKoD3gGPdvRqCpAI4JnORtamJwK1AYzjdDdjp7g3h9CaChCoO+gI1wPRwiGaqmXUmpm3D3b8A/gxsIEgUdgFLiW/7aNJae+gBbExZLo51I0eAEoYMM7PvAc8CN7n715mOJxPM7CJgq7svTZ19gEXjcklPAjgVmOzuFcAeYjL8cCDh2PxIoA9wPNCZoNu9ubi0jyhx3nbkCFLCkEFm1oEgWXjS3Z8LZ29p6j4MH7dmKr42dBZwsZl9DlQRdDVPJOhKTYTL9AS+zEx4bW4TsMnd3wunnyFIIOLYNgDOAz5z9xp3/w54DjiT+LaPJq21h01Ar5Tl4lg3cgQoYciQcIx+GrDW3e9PKXoJuDr8/2rgxbaOra25+2/dvae7lxKczPaWu18BvA1cGi4Wi7oAcPfNwEYzOyGcdS7wITFsG6ENwGAz6xRuN031Ecv2kaK19vAS8PPwaonBwK6moQuRw6EfbsoQMxsCvAOsYv+4/e8IzmOYA5QQfFH+1N2bn+zUbpnZMODX7n6RmfUl6HEoApYDV7p7XSbjaytmdgrBCaB5wKfAtQQJfizbhpndDVxGcHXRcmAMwbh8LNqHmc0ChhHclXILcBfwAgdoD2FS9TDBVRV7gWvdfUkm4pb2RQmDiIiIRNKQhIiIiERSwiAiIiKRlDCIiIhIJCUMIiIiEkkJg4iIiERSwiAiIiKRlDCIiIhIJCUMIs2Y2fVm5mZWljJvbXiTMBGRWFLCINLSAGAFwe22MbN84FhgfSaDEhHJJCUMIi2dBPyeMGEAfkBwzw/9LKqIxJYSBpGWyglu4HOMmXUlSCBWZTYkEZHMUsIgksLMegHb3L0WeAO4gGCI4oODWPcaM7so/P9iMxv6P752cv3/soy2WRHJiET0IiKxMoD9vQmvAFcAxwEvmFlvYDxgwCfAVoI7CO4muNPoEKBTcLNAioBGM7sGGA7UAtVAB+BEgrsNXkZwbsRUd1+Usn4pMBj4Fpjr7i+Gz3MesMTM0l63vd6hUUSyi45WRNKlDj/MB4ayP4kYS7Dj3xYu15Og52FiuNNeCDzl7i83e87X3P2XwNnufgfwPsFtqwsIblV8VbjcQuApoBS4093HAFemPM/f3X3iAV5XROSIUw+DSLqTgGcB3L3OzFYBFe6+MxwOmOnuyeEJMzsZ+JOZ3Qk0tvKcX4ePNeFjPXAvcB1Bb8Xd4fym9Q1oOsEy9UTLXWFcf0x9XXdfd2hvVUTk4ClhEEnh7lc0mx6ZMvkwcK+ZVRMMB1QD/Qh29NuAlcDtZnYw29XbwG0EPQxNVgK3A0uACWa2F5jVfEUzq2z2uiIiR5zpSjERERGJonMYREREJJISBhEREYmkhEFEREQiKWEQERGRSEoYREREJJISBhEREYmkhEFEREQiKWEQERGRSEoYREREJNJ/AIvLJumzGhFXAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.plot(n_estimator_range,ETC_train_accuracy[1],'--b^',label='Train (coarse)')\n",
    "plt.plot(n_estimator_range,ETC_test_accuracy[1],'--r^',label='Test (coarse)')\n",
    "plt.plot(n_estimator_range,ETC_critical_accuracy[1],'--g^',label='Critical (coarse)')\n",
    "\n",
    "plt.plot(n_estimator_range,ETC_train_accuracy[0],'o-b',label='Train (fine)')\n",
    "plt.plot(n_estimator_range,ETC_test_accuracy[0],'o-r',label='Test (fine)')\n",
    "plt.plot(n_estimator_range,ETC_critical_accuracy[0],'o-g',label='Critical (fine)')\n",
    "\n",
    "#plt.semilogx(lmbdas,train_accuracy_SGD,'*--b',label='SGD train')\n",
    "\n",
    "plt.xlabel('$N_\\mathrm{estimators}$')\n",
    "plt.ylabel('Accuracy')\n",
    "lgd=plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\n",
    "plt.savefig(\"Ising_RF.pdf\",bbox_extra_artists=(lgd,), bbox_inches='tight')\n",
    "\n",
    "plt.show()\n",
    "\n",
    "plt.plot(n_estimator_range, run_time[1], '--k^',label='Coarse')\n",
    "plt.plot(n_estimator_range, run_time[0], 'o-k',label='Fine')\n",
    "plt.xlabel('$N_\\mathrm{estimators}$')\n",
    "plt.ylabel('Run time (s)')\n",
    "\n",
    "\n",
    "plt.legend(loc=2)\n",
    "#plt.savefig(\"Ising_ETC_Runtime.pdf\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Exercises: ###  \n",
    "<ul>\n",
    "\n",
    "<li> [Random Forest] Consider $B$ random variables, each with variance $\\sigma^2$. Show that: \n",
    "    \n",
    "   **(1)** If these random variables are i.i.d., then their average has a variance $\\frac{1}{B}\\sigma^2$. \n",
    "    \n",
    "   **(2)** If they are only i.d. (i.e. identically distributed but not necessarily independent) with positive pairwise correlation $\\rho$, then the variance of their average is  $\\rho\\sigma^2+\\frac{1-\\rho}{B}\\sigma^2$. In this case, what does $B\\gg 1$ imply? Justify that *\"by random selection of input features, random forest improves the variance reduction of bagging by reducing the correlation between the trees without dramatic increase of variance\"*.\n",
    "\n",
    "<li> [Random Forest] Consider a random forest $G$ consisting of $K$ binary classification trees, $\\{g_k| k=1,\\cdots K\\}$, where $K$ is an odd integer. Suppose each tree evaluates classification error based on binary counts (i.e. 0/1 error) with $E_{out}(g_k)=e_k$, prove or disprove that $\\frac{2}{K+1}\\sum_{k=1}^K e_k$ upper bounds $E_{out}(G)$.\n",
    "\n",
    "\n",
    "<li> [OOB] For a data set with $N$ samples, what's the probability that one of samples, say $(\\boldsymbol{x}_n,y_n)$, is never sampled after bootstrapping $N'$ times? Show that if $N'=N$ and $N\\gg 1$, this probability is approximately $e^{-1}$. \n",
    "\n",
    "<li> [OOB] Following the previous question, if $N'=pN$ and assuming $N\\gg 1$, argue that $Ne^{-p}$ examples in the data set will never be sampled at all.\n",
    "\n",
    "<li> [OOB- programming] We argued that OOB is a good proxy for out-of-sample prediction due to bootstrapping. However, in practice OOB tends to give overly pessimistic estimate. To explore this, now instead of using OOB, try to cross-validation and redo all the analysis. You may find [this tutorial](http://scikit-learn.org/stable/modules/cross_validation.html) on Scikit useful. \n",
    "    \n",
    "</ul>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}