diff --git a/EDS_paper/BayesianClassification_Alabama.ipynb b/EDS_paper/BayesianClassification_Alabama.ipynb deleted file mode 100644 index d5107ff..0000000 --- a/EDS_paper/BayesianClassification_Alabama.ipynb +++ /dev/null @@ -1,1268 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "d1bb37a6", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2024-02-06 15:25:53.351252: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", - "To enable the following instructions: AVX2 AVX512F FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", - "2024-02-06 15:25:53.897660: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n" - ] - } - ], - "source": [ - "import pandas as pd\n", - "\n", - "import numpy as np\n", - "import tensorflow as tf\n", - "import tensorflow_probability as tfp\n", - "from tensorflow.keras.models import Sequential\n", - "from tensorflow.keras.layers import Dense\n", - "from tensorflow.keras.optimizers import Adam\n", - "\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "id": "d9e19465", - "metadata": {}, - "source": [ - "### Setup and Configuration" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "68eb4db6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
XYAreaMedianIncomeCountyHousingUnitsCountyHousingDensityCountyImperviousAgCountCmCountGvCountEdCountInCountOsmNearestRoadBuildingType
0-86.45236932.4544462168.99750962660.024170.02.4095577710.0602.03.06.0119.0residentialEducation
1-86.45170132.4544453918.40007562660.024170.02.4095579410.0602.03.06.0119.0residentialEducation
2-86.45165232.453549501.13839762660.024170.02.4095574710.0602.03.06.0119.0residentialEducation
3-86.45614832.454743487.16257062660.024170.02.4095575610.0602.03.06.0119.0residentialEducation
4-86.45148332.45482716.44424462660.024170.02.4095578310.0602.03.06.0119.0residentialEducation
\n", - "
" - ], - "text/plain": [ - " X Y Area MedianIncomeCounty HousingUnitsCounty \\\n", - "0 -86.452369 32.454446 2168.997509 62660.0 24170.0 \n", - "1 -86.451701 32.454445 3918.400075 62660.0 24170.0 \n", - "2 -86.451652 32.453549 501.138397 62660.0 24170.0 \n", - "3 -86.456148 32.454743 487.162570 62660.0 24170.0 \n", - "4 -86.451483 32.454827 16.444244 62660.0 24170.0 \n", - "\n", - " HousingDensityCounty Impervious AgCount CmCount GvCount EdCount \\\n", - "0 2.409557 77 10.0 602.0 3.0 6.0 \n", - "1 2.409557 94 10.0 602.0 3.0 6.0 \n", - "2 2.409557 47 10.0 602.0 3.0 6.0 \n", - "3 2.409557 56 10.0 602.0 3.0 6.0 \n", - "4 2.409557 83 10.0 602.0 3.0 6.0 \n", - "\n", - " InCount OsmNearestRoad BuildingType \n", - "0 119.0 residential Education \n", - "1 119.0 residential Education \n", - "2 119.0 residential Education \n", - "3 119.0 residential Education \n", - "4 119.0 residential Education " - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Alabama data\n", - "file = \"./ML_Training_01.csv\"\n", - "\n", - "# read data into a Pandas dataframe\n", - "df = pd.read_csv(file)\n", - "\n", - "# ignore first few columns, which are FIPs codes, not needed for ML\n", - "df = df.iloc[:, 3:] \n", - "\n", - "df = df.rename( columns={\"OrnlType\":\"BuildingType\"} )\n", - "df.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "999bfa70", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Residential 2060502\n", - "Commercial 136922\n", - "Other 110849\n", - "Name: BuildingType, dtype: int64\n", - "\n", - "Residential 1.000000\n", - "Commercial 15.048728\n", - "Other 18.588368\n", - "Name: BuildingType, dtype: float64\n", - "\n" - ] - } - ], - "source": [ - "# classify a building as \"Residential\", \"Commercial\", or \"Other\"\n", - "df.loc[df[\"BuildingType\"] == \"Industrial\", \"BuildingType\"] = 'Other'\n", - "df.loc[df[\"BuildingType\"] == \"Assembly\", \"BuildingType\"] = 'Other'\n", - "df.loc[df[\"BuildingType\"] == \"Education\", \"BuildingType\"] = 'Other'\n", - "df.loc[df[\"BuildingType\"] == \"Government\", \"BuildingType\"] = 'Other'\n", - "df.loc[df[\"BuildingType\"] == \"Agriculture\", \"BuildingType\"] = 'Other'\n", - "df.loc[df[\"BuildingType\"] == \"Utility and Misc\", \"BuildingType\"] = 'Other'\n", - "\n", - "# building type distributions\n", - "x = df['BuildingType'].value_counts()\n", - "print()\n", - "print( x )\n", - "print()\n", - "print( x[0]/df['BuildingType'].value_counts() )\n", - "print()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "1e299cf1", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_33582/1358776107.py:19: DeprecationWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`\n", - " df.iloc[:, nCols-1] = le.transform( df.iloc[:, nCols-1] )\n", - "/tmp/ipykernel_33582/1358776107.py:23: DeprecationWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`\n", - " df.iloc[:, nCols-2] = le2.transform( df.iloc[:, nCols-2] )\n" - ] - } - ], - "source": [ - "from sklearn import preprocessing\n", - "\n", - "df = df.sample(frac=1) # shuffle the dataframe (technically, we randomly resample the entire df)\n", - "\n", - "# preprocess the data - scaling\n", - "scaler = preprocessing.StandardScaler()\n", - " \n", - "columns = ['X', 'Y', 'Area', 'MedianIncomeCounty', \n", - " 'HousingUnitsCounty', 'HousingDensityCounty',\n", - " 'Impervious', 'AgCount', 'CmCount', 'GvCount',\n", - " 'EdCount', 'InCount']\n", - "df[columns] = scaler.fit_transform(df[columns])\n", - "\n", - "df = df.dropna()\n", - "\n", - "nCols = df.shape[1]\n", - "le = preprocessing.LabelEncoder()\n", - "le.fit( df.iloc[:, nCols-1] ) # ornl type\n", - "df.iloc[:, nCols-1] = le.transform( df.iloc[:, nCols-1] )\n", - " \n", - "le2 = preprocessing.LabelEncoder()\n", - "le2.fit( df.iloc[:, nCols-2] ) # nearest road type\n", - "df.iloc[:, nCols-2] = le2.transform( df.iloc[:, nCols-2] )" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "958d6b5e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
XYAreaMedianIncomeCountyHousingUnitsCountyHousingDensityCountyImperviousAgCountCmCountGvCountEdCountInCountOsmNearestRoadBuildingType
1591370-1.884314-1.854621-0.105389-0.3024360.9896160.370678-1.0513832.9880460.7817501.1162290.5776601.04175242
110322-1.098579-1.958204-0.1670530.9435350.315119-1.996190-0.109315-0.2317930.214207-0.844359-0.1324760.71368622
53673-1.319796-1.860037-0.4638570.9435350.315119-1.996190-0.965740-0.2317930.214207-0.844359-0.1324760.71368642
1327463-0.0357191.2563010.2581361.5871820.8129430.5297850.190434-0.4157840.890988-0.3215361.0070440.68280942
1885751-0.2911561.129598-0.2164770.166470-0.4265740.7324980.875574-0.691770-0.417104-0.975065-0.644434-0.18174242
\n", - "
" - ], - "text/plain": [ - " X Y Area MedianIncomeCounty HousingUnitsCounty \\\n", - "1591370 -1.884314 -1.854621 -0.105389 -0.302436 0.989616 \n", - "110322 -1.098579 -1.958204 -0.167053 0.943535 0.315119 \n", - "53673 -1.319796 -1.860037 -0.463857 0.943535 0.315119 \n", - "1327463 -0.035719 1.256301 0.258136 1.587182 0.812943 \n", - "1885751 -0.291156 1.129598 -0.216477 0.166470 -0.426574 \n", - "\n", - " HousingDensityCounty Impervious AgCount CmCount GvCount \\\n", - "1591370 0.370678 -1.051383 2.988046 0.781750 1.116229 \n", - "110322 -1.996190 -0.109315 -0.231793 0.214207 -0.844359 \n", - "53673 -1.996190 -0.965740 -0.231793 0.214207 -0.844359 \n", - "1327463 0.529785 0.190434 -0.415784 0.890988 -0.321536 \n", - "1885751 0.732498 0.875574 -0.691770 -0.417104 -0.975065 \n", - "\n", - " EdCount InCount OsmNearestRoad BuildingType \n", - "1591370 0.577660 1.041752 4 2 \n", - "110322 -0.132476 0.713686 2 2 \n", - "53673 -0.132476 0.713686 4 2 \n", - "1327463 1.007044 0.682809 4 2 \n", - "1885751 -0.644434 -0.181742 4 2 " - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "61b9c6ee", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Number of classes: 3\n" - ] - } - ], - "source": [ - "nClasses = len(df['BuildingType'].unique())\n", - "print(\"Number of classes:\", nClasses)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "bb4e5f39", - "metadata": {}, - "outputs": [], - "source": [ - "buildingTypes = np.array(df['BuildingType'])\n", - "df = df.drop( columns=['BuildingType'] )" - ] - }, - { - "cell_type": "markdown", - "id": "6167606a", - "metadata": {}, - "source": [ - "### Bayesian Neural Network" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "63f8937e", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/jupyter-narock/.local/lib/python3.9/site-packages/tensorflow_probability/python/layers/util.py:98: UserWarning: `layer.add_variable` is deprecated and will be removed in a future version. Please use the `layer.add_weight()` method instead.\n", - " loc = add_variable_fn(\n", - "2024-02-06 15:26:18.259980: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1635] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 5337 MB memory: -> device: 0, name: NVIDIA GeForce GTX TITAN Black, pci bus id: 0000:65:00.0, compute capability: 3.5\n", - "/home/jupyter-narock/.local/lib/python3.9/site-packages/tensorflow_probability/python/layers/util.py:108: UserWarning: `layer.add_variable` is deprecated and will be removed in a future version. Please use the `layer.add_weight()` method instead.\n", - " untransformed_scale = add_variable_fn(\n" - ] - } - ], - "source": [ - "from keras import backend as K \n", - "\n", - "# Keras keeps models hanging around in memory. If we retrain a model, Keras will\n", - "# start from the previously concluded weight values. This resets everything.\n", - "K.clear_session()\n", - "\n", - "# KL divergence weighted by the number of training samples, using\n", - "# lambda function to pass as input to the kernel_divergence_fn on\n", - "# flipout layers.\n", - "kl_divergence_function = (lambda q, p, _: tfd.kl_divergence(q, p) / \n", - " tf.cast(df.shape[0], dtype=tf.float32))\n", - "\n", - "tfd = tfp.distributions\n", - "\n", - "# Define a logistic regression model as a Bernoulli distribution\n", - "# parameterized by logits from a single linear layer. We use the Flipout\n", - "# Monte Carlo estimator for the layer: this enables lower variance\n", - "# stochastic gradients than naive reparameterization.\n", - "input_layer = tf.keras.layers.Input(shape=df.shape[1])\n", - "\n", - "#dense_layer = tfp.layers.DenseFlipout(\n", - "# units=1,\n", - "# activation='sigmoid',\n", - "# kernel_posterior_fn=tfp.layers.default_mean_field_normal_fn(),\n", - "# bias_posterior_fn=tfp.layers.default_mean_field_normal_fn(),\n", - "# kernel_divergence_fn=kl_divergence_function)(input_layer)\n", - "\n", - "layer1 = tfp.layers.DenseFlipout(\n", - " units=26,\n", - " activation='sigmoid',\n", - " kernel_posterior_fn=tfp.layers.default_mean_field_normal_fn(),\n", - " bias_posterior_fn=tfp.layers.default_mean_field_normal_fn(),\n", - " kernel_divergence_fn=kl_divergence_function)(input_layer)\n", - "\n", - "layer2 = tfp.layers.DenseFlipout(\n", - " units=13,\n", - " activation='sigmoid',\n", - " kernel_posterior_fn=tfp.layers.default_mean_field_normal_fn(),\n", - " bias_posterior_fn=tfp.layers.default_mean_field_normal_fn(),\n", - " kernel_divergence_fn=kl_divergence_function)(layer1)\n", - "\n", - "layer3 = tfp.layers.DenseFlipout(\n", - " units=8,\n", - " activation='sigmoid',\n", - " kernel_posterior_fn=tfp.layers.default_mean_field_normal_fn(),\n", - " bias_posterior_fn=tfp.layers.default_mean_field_normal_fn(),\n", - " kernel_divergence_fn=kl_divergence_function)(layer2)\n", - "\n", - "layer4 = tfp.layers.DenseFlipout(\n", - " units=4,\n", - " activation='sigmoid',\n", - " kernel_posterior_fn=tfp.layers.default_mean_field_normal_fn(),\n", - " bias_posterior_fn=tfp.layers.default_mean_field_normal_fn(),\n", - " kernel_divergence_fn=kl_divergence_function)(layer3)\n", - "\n", - "out = tfp.layers.DenseFlipout(\n", - " units=3,\n", - " activation='softmax',\n", - " kernel_posterior_fn=tfp.layers.default_mean_field_normal_fn(),\n", - " bias_posterior_fn=tfp.layers.default_mean_field_normal_fn(),\n", - " kernel_divergence_fn=kl_divergence_function)(layer4)\n", - "\n", - "# Model compilation\n", - "#bnn = tf.keras.Model(inputs=input_layer, outputs=dense_layer)\n", - "bnn = tf.keras.Model(inputs=input_layer, outputs=out)\n", - "optimizer = tf.keras.optimizers.Adam(learning_rate=0.01)\n", - " \n", - "# We use the binary_crossentropy loss since this toy example contains\n", - "# two labels. The Keras API will then automatically add the\n", - "# Kullback-Leibler divergence (contained on the individual layers of\n", - "# the model), to the cross entropy loss, effectively\n", - "# calcuating the (negated) Evidence Lower Bound Loss (ELBO)\n", - "bnn.compile(optimizer, loss='categorical_crossentropy', metrics=['accuracy'])" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "6c70029b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model: \"model\"\n", - "_________________________________________________________________\n", - " Layer (type) Output Shape Param # \n", - "=================================================================\n", - " input_1 (InputLayer) [(None, 13)] 0 \n", - " \n", - " dense_flipout (DenseFlipout (None, 26) 728 \n", - " ) \n", - " \n", - " dense_flipout_1 (DenseFlipo (None, 13) 702 \n", - " ut) \n", - " \n", - " dense_flipout_2 (DenseFlipo (None, 8) 224 \n", - " ut) \n", - " \n", - " dense_flipout_3 (DenseFlipo (None, 4) 72 \n", - " ut) \n", - " \n", - " dense_flipout_4 (DenseFlipo (None, 3) 30 \n", - " ut) \n", - " \n", - "=================================================================\n", - "Total params: 1,756\n", - "Trainable params: 1,756\n", - "Non-trainable params: 0\n", - "_________________________________________________________________\n" - ] - } - ], - "source": [ - "bnn.summary()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "91eefec2", - "metadata": {}, - "outputs": [], - "source": [ - "bnn.load_weights(\"bnn.h5\")" - ] - }, - { - "cell_type": "markdown", - "id": "ae0a0f29", - "metadata": {}, - "source": [ - "### Analysis" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "af858d85", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "\n", - "def getPredictions( model, data, T ):\n", - "\n", - " n = data.shape[0]\n", - " preds = np.zeros( shape=(n,nClasses,T) )\n", - " \n", - " for t in range(T):\n", - " if ( t == 10 ): print(\"Iteration 10...\")\n", - " if ( t == 30 ): print(\"Iteration 30...\")\n", - " if ( t == 50 ): print(\"Iteration 50...\")\n", - " if ( t == 70 ): print(\"Iteration 70...\")\n", - " if ( t == 90 ): print(\"Iteration 90...\")\n", - " preds[:,:,t] = model(data)\n", - " \n", - " return preds" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "9bf48df9", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Iteration 10...\n", - "Iteration 30...\n", - "Iteration 50...\n", - "Iteration 70...\n", - "Iteration 90...\n" - ] - }, - { - "data": { - "text/plain": [ - "(1140006, 3, 100)" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "T = 100\n", - "preds = getPredictions( bnn, df.values, T )\n", - "preds.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "f6054b90", - "metadata": {}, - "outputs": [], - "source": [ - "def getPredictions( preds, T ):\n", - " \n", - " n = preds.shape[0]\n", - " means = np.zeros( shape=(n, nClasses) )\n", - " \n", - " for ix in range(n):\n", - " for j in range(nClasses):\n", - " \n", - " means[ix,j] = np.mean( preds[ix,j,:] )\n", - " \n", - " bnnPreds = np.argmax( means, axis=1 )\n", - " \n", - " return means, bnnPreds" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "9a7053ea", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "((1140006, 3), (1140006,))" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "means, bnnPreds = getPredictions( preds, T )\n", - "means.shape, bnnPreds.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "ea15ee5b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "((1140006,), (1140006,))" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from scipy.stats import entropy\n", - "\n", - "base = 2 # work in units of bits\n", - "en = entropy(means, base=base, axis=1)\n", - "\n", - "en.shape, buildingTypes.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "336ff55e", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Entropy of Incorrect Predictions')" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZYAAAElCAYAAADHpsRNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAkoElEQVR4nO3de7xcVX338c8XQgC5BELCRUo4II9CEUEJCKIQbFUUKdJKxUcrSCviIyiCItJHQGwliigXH6VRMEprAcGCMWJVMCjIRRBU0BS5JIhIuOQCQggEfs8fax2y2cycM3POmsycM9/36zWvmVl77bXX2pf5zd5rXxQRmJmZlbJGtytgZmbjiwOLmZkV5cBiZmZFObCYmVlRDixmZlaUA4uZmRXlwGJjnqRDJf1a0uOSQtIx3a6T9S5Js/N6MlBJOyynHdaB6Q3ksmeXLrtXObAUVFmBhnrNG+U0Rl3GeCLptcBsYG3gHOBTwPXDjLNA0tKOV24cafRj3OJ4C2rr/0pJD0r6nqR9O1Td1W6k82e8mtDtCoxT/wNc2GTYgtVYj37w5vx+aEQMGVCsa1YAM/PntYGdgf2Bt0g6JCIu7lrNVvkv0h+SP3Wg7D8COwDLOlB2T3Jg6Yz5EXFKtyvRJ7bI7w90tRY2lCfr24Ok9wLnA58Duh5YImIZHfrhj4ingfmdKLtnRYRfhV7AABDAZW3mnw1sB1xGWrkfA+YAL6nknZHzNnrNyHlOGfwO/BPwa+BJYHalnL2BHwBLgOXAb4CPAhNqdRuc3inAvsC1wOPAQ8B5wJRaO55p1m5gW+BZ4PI25sts0r/Hp4CFwNm1aTadHy2UvwBYWks7LI9/GPAm4DrgCeBB4MvAi5qU9XfAlZX5eScwC5hWy/cK4NI8/1YAdwD/Aqw3xDqxE/C9XHa0sYxfAnwduC/Pv/tyG6Y2acPrSevbYN0WAv8B7FSZX43m9eyRzOucLuDPuZwplbwLgMnAucD9eb2aUZvf80jbyXLgFuCIJtPeBrgEWAo8Cvx3Xg6z83QHGi3/0vOnukwblD2S7XE34Md5/i3OdXnBsgX+GvgR6U/Xk3k9+G/gbzrx+1d9eY+lNwyQdsN/BXyV9IPyVmBHSTtGxHLSyvsp4GTSij27Mv6CWnkfB14LfBe4gvxvXtLfA98i/WBeRFqZ3wKcDrxW0kGDv14VewKfyGVdnb8fDuwhafeIeDwiFkj6EbC/pM0jor73cDjph+S84WaEpJcB1wCbkALt/wCvAo7O5e8REQ9V5sfbSIdWziL9gIzWgaTDa5cDPwfeCHyA9GN3SK2uZwEfIgWfb5M28m2Ag4HvA/fmfK8jbdBrkv6d30f6ofhn4A2S9omIJ2v12I4UzG8Gvgb8RW14s2W8J+mHap087B5ge+BI4E2SdouIxZU2HAucQfrh/S9SMN+K9GP6C9IP3ZmkH976fL612UwchbWBq4CJpEC8Zq4bkk4n/eguJK2/TwBvAP5N0g4R8ZFKu7Ykzb8tSEHhdtJ69DPSdtaSTs6fEW6PuwHHkwLLucBewP8GtpX0msH8kt5KWv4PkNblxcDmwKuBv8nDOqfTkaufXqz6ZzKf9M+i0WuPBvkDOK5W1tdz+jtr6QHMazL9U/LwZcD2tWEbklb4PwM7VNInkH70AnhPJX1GpW7vqZV1dk4/tZL2dznt+FreNYA/kDbICY3qXcv/k1zOP9TST8rp59fSZ1P799nCNBbQfI/lqdoyWgf4HWmPa8tK+t/k/DcCG9bKWheYXGn/nXn8fWr5zstlnNRknTixzWU8kfSju7i6jPOwg/N4X6qk7ULaI7gHeHEt/wRgs9HM52bzOqcfnsu7p5Y3SIFgYi3/m/Kwy4B1Kulr5bQAdqukfzOnHVsr59TK/B2opA8u/8NKzx8a7LEwuu3x72rb15U5fc9K+ndIe1eN9mQ2aWcZjuTV0cL77VX7UWj2OqZB/ruANWpl7ZOHnVFLbyWwnN5g2HvysC80GLZLHnZlJW1wRf4doFr+TUj/su6upK0FLCL1L1XzvjmXM7OF+Tct5/1lg2HrkP59LafyozPUBj3EdBbQPLDMbpD/5DzsgEraFTltj2GmtXfO950GwzYjHaK4q8E6cT+wVpvL+G/zsI82qctNwMOV71/J+Q9pYZ61PZ8r8/pJVv2xOg2Ym8t6Fji4ljeAHRuU892cf9MGw16ex/t8/r52Xk/uq89DYD1S4G0lsBSZPzQOLCPdHl+w7QOH5mFHV9K+QwpaG7WzvEq9fCisMy6PiLe1kf/XEfFsLe2P+X2jEUz/pgZpu+T3efUBEXGrpGWVPFXXRl5TK/kfkTQfeKWkDSLisYh4Op+nf7ykvSLi2pz9H/P7+S3Ue6g6PinpetKhqpeRDkF0wi0N0hoti92Ax2L4M9F2ye/z6gMiYlGejzsPzsfK4F9F6vRtptEyfnV+f7mkUxoMXxfYRNKUiHg4twHgh0NMp4S1ScEZUnB4hLRXckZEXF3Luzwibm9QxqtJh6P+j6T6sLXy+/b5/aWkPyI31OdhRDwu6VZSv+FwOjl/dsnv8+oDhtkeW10/LwIOAm6TdGGezjURsXQklW2XA0tvaHQ2ysr8vuYIynuwQdqG+X1Rk3EeIHX61j3UJP9gORuSTjaA1BfwMVIwuVbSFOAA4KcRccdwlW6xjtV8ndDqsphE2tMcTitt2pnnz0dovAwZZvjk/H7oMOOuBzxMasOKqPS5dMiyiNioxbzN1rfJpN+rk5sMh9QuSO2C5vOw2bKo6+T8Gen22NL6GREXSVoJHAt8BDgOWClpDumoyb0jqnWLfIHk+BQN0h7N75s1GWezSp6qqUPkr5ZLRPye1MH/95LWB/6BdNx/2E77Nur4vGl20VLgxS3kG2mbGi3D4YYPlvGGiNAQr4U531JgbUmTG5TVLc3a/Sjwx2HaNbgXMvjju2mTspoti7qldG7+jHR7bFlEXBoRewFTSHv6l5D2Yr6rBrt9JTmwjD3PMrK9mFvz+971AZJeQdqNvrU+DHhNfSWUtAnpsMM9tcM3kM5qWw94B6mD9lHSCj3aOq5NOhzyJOlMsW77BbCBpD2GyXdrfm/Upk1J8/HuBvNxJG7M78PVadAv8vsbW8j7TH4fybpXwo3AlpK2aiHvHaT15NWS1qoOkLQejQ8xNdLJ+XNrfm93e2xbRCyJiO9GxDtJHf07k/ozO8aBZexZDGw5gvEuJ/3IHyFpu8FESWsCn81fv9lgvB1Iex5VJ5OO1/97g/yXko6hn0rqVP3PiHiilQrm3fOrgV0lvaM2+KOkU0cvjIinWimvw76S38+W9LxDc5LWqfzLvQa4GzhI0mtqZfwLqS+g0XwfictIZ+CdIGn3+kBJ60p6dSVpFumPymckbVHLOyEHvkGDh4NGsu6VcE5+P0/SpPpASdsM3k4lIlaQTv/eknSaetXHgY1bnGYn589It8eWSHp9/jNWTZvAqsOl9dPbi3IfS2ds36TzFNLZSGeOouyfAAdLuoh0cdwzwLeGO2YaEcskHUkKBjfnDr2lpPPmX066EK/RivxD4KuSDgB+T7qOZQbwW1ZtANXprJB0AXBMTvpam+37AOnH+FuSDib9+3wV6XTTe0g/DF0XEXMknUP64bpD0uC1AtOA/Uj9TJdFxLOSDiedRXaVpItJna37kOblzaSrz0vUaUWeZ1cA10v6IWk5TSCdmbQP6cLP/XL+WyUdD3wemC/pO6TTwl9Murju86RrNCCtdx8FzpV0CemswN9ExNwSdW+hbd+XdBrpmqo7Jf036ayvqaQ/P3uQrudYkEf5BOkalzMkzQBuA3bN+X4GvK6FaXZs/oxie2zVF4C/yPcVXEDak/rrXPa/R0Sr/Uwj041T0cbri9ZON17QIP/sIcqaXUt/MenQ0iOkf1NBgyvvh6jjDNJ58ktJ/1puJ/1Y10/LnMGqK31fz6or7x8mneHV8CruPO6r8ri/GuF83Ja0UT1Auq7kXuBLND7VdDZlTzc+rEH+oYYdAvyU9O/zCVLwPRfYqpZvF9IpoI/kNt0JfAZYv5XlXhneyjKelufXXaRrGZaQzqI7h8q1HpX8b2TV1d9P5vlzAbXTfkk/1ncBTw9Vx+Hm9TB5FwyT582k05UfzvPxj6S93OOo3Jmhsh5dSupzeZT0J2kkV96Pav4MtUwZwfbYpIznDSMdir441+eJvN7dCLyfFq4nG+1LuRJmz5P/5f0E+FS0ed+z/A/9PODDEXF28cqZWU9zH4sVlY8Rf4j0L+mCLlfHzLrAfSxWhKSdSNesvI501slnI2JJd2tlZt3gwGKl7Ar8K+k49NdIfQFm1ofcx2JmZkV5jwWYMmVKDAwMdLsaZmZjys033/xwRLzg7hwOLMDAwAA33dTonn5mZtaMpIWN0vv6rDBJB0iatWxZ3zyK2sys4/o6sETEnIg4YtKkF9whwszMRqivA4uZmZXnwGJmZkU5sJiZWVF9HVjceW9mVl5fBxZ33puZldfXgcXMzMrzBZJmZl02cMJqeV5aQwtm7l+8TO+xmJlZUQ4sZmZWVF8HFp8VZmZWXl8HFp8VZmZWXl8HFjMzK8+BxczMinJgMTOzohxYzMysKAcWMzMryoHFzMyK6uvA4utYzMzK6+vA4utYzMzK6+vAYmZm5TmwmJlZUQ4sZmZWlAOLmZkV5cBiZmZFObCYmVlRDixmZlaUA4uZmRXV14HFV96bmZXX14HFV96bmZXX14HFzMzKc2AxM7OiHFjMzKwoBxYzMyvKgcXMzIpyYDEzs6IcWMzMrCgHFjMzK8qBxczMinJgMTOzosZVYJG0QFLUXod0u15mZv1kQrcr0AG/A06tfP95typiZtaPurLHImmqpLMk3SBpRWXv4qgm+SdLOlPSwpz/fknnS9qqQfYHgbnAxRFxYUTc29HGmJnZ83TrUNiWwIeA3YGJQ2WUNAm4FvgwMC3n3wJ4L3CDpK1ro+wNPAosl/RdSZsXrruZmQ2hW4fClgJfBG4AZgBHDpH3JGD7/PlzwGeBdwFnkwLMGcDb8/Dzgd8Dj+cyDwC+VBluZtbUwAlzu12FcaErgSUiFgDHAkjaoVk+SQIOzV+fAD4ZEU8B50g6BtgWOFDSxhGxJCJOrYy7EHgz8IqONMLMzBrq9c77bYBN8uc7c1AZdDspsEwAXinpYeDzwBXAMtKhMoCfraa6mpkZvR9YNqt8rj8/uPp9U9LZYMuB44HJwCLS4bITGxUs6QjgCIBp06YVqq6ZmfV6YBmKql8i4k/Aga2OHBGzgFkA06dPj7JVMzPrX71+geSiyueNasM2rHx+sPNVMTOzVvR6YLkHeCR/3k5S9dTkHfP7SuCWkRQu6QBJs5Ytqx9lMzOzkerWBZJrSJoiaQrwosqg9SrpREQA38jD1gU+LWljSUeTOu4BLo+IJSOpR0TMiYgjJk2aNMKWmJlZXbf2WKYBD+XXxyrpMyvpg04F5ufPxwOLSZ3yAA8Ax3W0pmZm1pZePxRGRCwD9iIFk3uBp0kBZTawe0QsHGnZPhRmZlZeVwJLRCyICA31quVfHBEfjoitI2JiRGwREe+NiD+Msh4+FGZmVljP77GYmdnY0teBxYfCzMzK6+vA4kNhZmbl9XVgMTOz8hxYzMysqL4OLO5jMTMrr68Di/tYzMzKG8t3NzazcchPcRz7+nqPxczMynNgMTOzovo6sLjz3sysvL7uY4mIOcCc6dOnv6/bdTHrNe7rsJHq6z0WMzMrz4HFzMyK6utDYWa9zoejbCzyHouZmRXV14HFZ4WZmZXX14HFt3QxMyuvrwOLmZmV58BiZmZFObCYmVlRDixmZlaUA4uZmRXlwGJmZkX1dWDxdSxmZuX1dWDxdSxmZuWNOrBI2qRERczMbHxoObBIep+kj1W+7yTpPuBBSTdJ2rwjNTQzszGlnT2Wo4Hlle9fAJYCxwCTgFOL1crMzMasdm6bPw2YDyBpErAP8LaI+L6kR4DTOlA/MzMbY9rZY1kTeDZ/fi0QwLz8/Q/ApuWqZWZmY1U7geX3wP758yHAzyPiifz9xcDikhUzM7OxqZ1DYZ8HLpB0KLAxcHBl2L7Ar0tWzMzMxqaWA0tEfEvSQmAP4BcR8dPK4EXA5aUrZ2ZmY0/LgUXS3sAvI+LaBoNPB15VrFZmZjZmtdPH8hPgL5sMe1kePqb4li5mZuW1E1g0xLC1gWdGWZfVzrd0MTMrb8hDYZIGgG0rSdMlrV/Lti5wOHBv2aqZmdlYNFwfy6HAyaRrVgI4h+fvuUT+vhL4YCcqaGZmY8twgWU26SJIAVeRgsdva3lWAHdEhK9jMTOzoQNLRCwEFgJI2pd0Vthjq6NiZmY2NrVzHcvVnayImZmND+3cNn+ipJMlzZf0hKRnaq+VnayomZmNDe3c0uV0Uh/LFcB3SH0rZmZmz9NOYHk7cHJE/GunKmNmZmNfOxdIrg9c16mKmJnZ+NBOYJkD7N2pipiZ2fjQzqGwc4BvSnoW+D4Nnr8SEXeXqthISfoSqy7W3CEi5nezPmZm/aadwDJ4GOwU0tX4jaw5qtqMkqS3AEcCTwLrdLMuZmb9qp3AcjjpFi6jImkq8H9Jz3XZBZiYBx0dEV9qkH8ycBJwELA58AjwA9KJBH+o5NsU+DrwGeA9wNajrauZmbWvnQskZxea5pbAh1rJKGkScC2wfSV5C+C9wH6S9sx3BwA4H7gbOJUUWMzMrAva6bwvZSnwReAQ4Nxh8p7EqqDyOWATVgWlLYAzACS9B3gD8M/AX7AqYG4p6UWlKm5mZsNr5wmS5w+TJSLiH4crJyIWAMfmMncYYnoi3V0Z4AngkxHxFHCOpGNIt/M/UNLG+fNE4MpaMT8GDgYuGa5eZmZWRjt9LK/nhX0sk4ENSHshS8tU6TnbkPZQAO7MQWXQ7aRgMgF4JXAhcGtl+CxgKnAU8PNGhUs6AjgCYNq0aSXrbePQwAlzu10FszGjnT6WgUbpkvYmHdJ6V6E6Ddqs8rn+7ODq900j4irgudOKJZ2ZP14ZEfc3KjwiZpECENOnTx/1SQlmZpaMuo8lIn5K6jM5Z/TVadlQj0kmIgYiQr6Gxcxs9SvVeX836ZBUSYsqnzeqDduw8vnBkU5A0gGSZi1bVt8hMjOzkRp1YJE0ATgMuG/UtXm+e0jXrABsJ2liZdiO+X0lcMtIJxARcyLiiEmTJo20CDMzq2nnrLCrGiRPBF5K6mQ/ssVy1iB1+gNUTwVeT9IUgIh4OCJC0jdIZ5CtC3xa0kzg3aSOe4DLI2JJq20wM7POa2ePZQ1S30b19Rjp2Sx/FRFfbbGcacBD+fWxSvrMSvqgU1nVKX886f5kZ+fvDwDHtVH/F/ChMDOz8to5K2xGB+vRbJrLJO1FujfZ20gXRQ7e0uWk6i1dRlj+HGDO9OnT3zfaupqZWdLOdSxF5Askhzyrq5Z/MfDh/DIzsx7XVue9pJ0kXSLpIUkrJT0o6WJJO3Wqgp3kQ2FmZuW1HFgk7QbcAOwLfA84HZhLuiL/ekm7dqSGHeSzwszMymvnUNhpwG2kjvrHBhMlbUC6J9dpwBvLVs/MzMaadg6F7QGcVg0qAPn7Z4E9S1bMzMzGpnYCy3D30/L9tszMrK3AcgNwYj709RxJ6wEfB64vWbHVwZ33ZmbltdPHciIwD1go6XvAn0iPCt6fdAX9PsVr12G+jsXMrLx2LpC8UdIepKc6vol0W5bFwFXApyPiN52popmZjSVDBpZ8X6/9gXsi4raI+DXw9lqenYABwIHFzMyG7WN5N/CfwOND5HkM+E9J7yxWq9XEfSxmZuW1Eli+HhH3NMuQb9FyHqueTz9m+AJJM7PyhgssrwJ+2EI5Pwamj746ZmY21g0XWDYAWnneyZKc18zM+txwZ4U9DGwNXDNMvmk5r1nHDJwwt9tVMLMWDLfHcg2t9Z0cxvDBx8zM+sBwgeVM4K8kfbH2zHkAJK0l6SzSHY6/2IH6dZTPCjMzK2/IQ2ERcZ2k44AzgHdJ+iGwMA/eGngD6Xn3x0XEmLuli6+8NzMrb9gr7yPiTEm/BE4ADgLWzYOWk27xMjMiftaxGpqZ2ZjS0i1dIuKnwE/zlfhTcvIjEfFMx2pmZmZjUlvPvI+IZ4EHO1QXMzMbB9p65r2ZmdlwHFjMzKwoBxYzMyuqrwOLr2MxMyuvrwOL725sZlZeXwcWMzMrz4HFzMyKcmAxM7OiHFjMzKwoBxYzMyvKgcXMzIpyYDEzs6IcWMzMrCgHFjMzK6qvA4tv6WJmVl5fBxbf0sXMrLy+DixmZlaeA4uZmRXlwGJmZkU5sJiZWVEOLGZmVpQDi5mZFeXAYmZmRTmwmJlZUQ4sZmZW1IRuV2CsGzhhbtemvWDm/l2btplZM+Nqj0XSJZIWSXpK0gOSLpC0UbfrZWbWT8bbHssdwI+BFcARwLuBB4CPdbNSZmb9pCt7LJKmSjpL0g2SVkiK/DqqSf7Jks6UtDDnv1/S+ZK2quaLiBOBC0nB5beDyZ1tjZmZVXVrj2VL4EOtZJQ0CbgW2L6SvAXwXmA/SXtGxMLKsOuBl+XPPwb+dfTVNTOzVnWrj2Up8EXgEODcYfKexKqg8jlgE1YFpS2AM2r53wv8LfAj4K/zdzMzW026ElgiYkFEHBsRFwGLmuWTJODQ/PUJ4JMRsTgizgHuzukHStq4UvZ1EfFfwP/NSf9YvgVmZtZMr3feb0PaQwG4MyKeqgy7HdiW1IZXSnoS+AhwNbAcODzn+1WjgiUdQergZ9q0aeVrbmbWp3o9sGxW+Vx/fnD1+6akADIAvAmYSDob7MvAiY0KjohZwCyA6dOnu4PfzKyQXg8sQ1H1S0T8DtitS3UxM7Os1y+QrPa/bFQbtmHl84MjKVzSAZJmLVtW3xkyM7OR6vXAcg/wSP68naSJlWE75veVwC0jKTwi5kTEEZMmTRpFFc3MrKpbF0iuIWmKpCnAiyqD1qukExEBfCMPWxf4tKSNJR1N6rgHuDwilqy2ypuZ2ZC6tccyDXgov6q3W5lZSR90KjA/fz4eWAycnb8/ABw30kr4UJiZWXm9fiiMiFgG7EUKJvcCT5MCymxg99pV9+2W7UNhZmaFdeWssIhYQO2srmHyLwY+nF9mZtbDen6PxczMxpa+DizuYzEzK6+vA4v7WMzMyuvrwGJmZuU5sJiZWVF9HVjcx2JmVl5fBxb3sZiZldfXgcXMzMpzYDEzs6IcWMzMrKi+DizuvDczK6+vA4s7783MyuvrwGJmZuWN5Wfe972BE+Z2ZboLZu7flema2djgPRYzMyuqrwOLO+/NzMrr68Diznszs/L6OrCYmVl5DixmZlaUA4uZmRXlwGJmZkU5sJiZWVEOLGZmVlRfBxZfx2JmVl5fBxZfx2JmVl5fBxYzMyvPgcXMzIry3Y2tbd26q7KZjQ3eYzEzs6IcWMzMrCgHFjMzK8qBxczMinJgMTOzohxYzMysqL4OLL6li5lZeX0dWHxLFzOz8vo6sJiZWXmKiG7XoeskPQQsLFDUFODhAuX0qvHePhj/bRzv7YPx38Zeat/WETG1nujAUpCkmyJierfr0SnjvX0w/ts43tsH47+NY6F9PhRmZmZFObCYmVlRDixlzep2BTpsvLcPxn8bx3v7YPy3sefb5z4WMzMrynssZmZWlAOLmZkV5cCSSZos6UxJCyWtkHS/pPMlbdXCuK+QdJakmyUtkvSkpLsk/Yek7RvkjyFeM3uwfQPD1PnIBuMcJulGSY9LelTS1ZLe2om2VaY5mjbOHqaNIWmgkn+1LkNJU/M6dkNu2+C0jmqjjDUlfUTSbyQtl7RE0hWSXtMk/2pdhqNtY69vhwXaNya2QwAiou9fwCTgd0A0eN1PughoqPFPaDJuAMuB3Wv5m+UNYGYPtm9gmDofWcv/mSHyHtGjy3D2MG18FpjaxWW4S5NpHdVGGd9qUsbTwFt6YBmOqo1jYDscbft6fjt8btqdLHysvIAzKjP8s8Bk4OhK2iXDjP9xYC7wJmC9vAJcWRn/u7X8g+mHjZH2VVfoGcPk3Zn0IxzAbXncnUg/7gE8DmzWa21sUuY+lfG/1+VlOAB8AXgH8JUR/CgdUBnnSmBzYG/gz6wKvhO7vAxH28Ze3w5H276e3w6fm/7qmKG9/AJEuj3C4MyeWBl2F6v+0W08RBkbNEibXlkJ5teGrbYVulD72lmhqz/w766kf7KSfnSvtbFJuZdW6vyGbi3DBvU6ZQQ/StW2vLaSfl4l/YBuLcNCbezZ7bBQ+3p6O6y+3McC2wCb5M93RsRTlWG35/cJwCubFRARjzVIXqfy+Q9NRv28pKckPSbp55IObbXSbRh1+2ouznVeKunKBsdrd2tQfv1zNU8JpdtI7pc5MH/9bUT8qEnW1bEMS2hnuXRjGY5aj2+HpfXidvgcBxbYrPK5/mCW6vdNWy1Q0gTg1ErSuU2ybgKsBawP7AnMlnR6q9NpUen2TSXVeRLwemCOpA+2ML0RzcsWFV+GwAeBNfPns4fItzqWYQntLJduLMPiemw7LK0Xt8PnOLAMTW2PIK0NXAzsm5POiYhLa9lmklbgjUh9AceQdk0BjpU0bSSVHYFW2/c4aRf6lcAGpJX2s5XhMyWt02jEEUyrtJEsw3WAf8pflwAXNMjWK8twtNqZP91ahm0bY9thq8bMdujAAosqnzeqDduw8vnB4QqStAHwfeCgnPRl4MP1fBHxiYi4PiKWRcSSiDiL1MkIaZns3mLdWzHq9kXEQxHxLxFxa0T8OSIejIgTgN/nLOsDLx9mem3NyzYVW4bZu1h1aO1rEfFEPcNqXoYltLNcurEMi+nR7XDUxsB2+BwHFrgHeCR/3k7SxMqwHfP7SuCWoQqRNAW4irRbCvCpiPhg5B6zSr5m8zyafB6tUbdviDpXDdb5F5W0v2wwrXqeEoosw4qj8/szwP+rD+zCMiyhneXSjWVYRA9vh6M2BrbDSi1W89kQvfjihaeqbkyDU1WBGZW02ZXxt2LVNRTPAO8fYlpHAd8gncq6HunfxIdYdWrg08CWPda+00j9DLuROkOnkg4jDOZdAqyd8+5Mb5xu3FYbK+XsXR+nR5bhGqQHPE0BPlep48cH04dZhvXTjTfL9e+l041H28Ze3w5H276e3w6fq2unCh5LL4a+uO5P5IvrhljgpzQZ97lXJe8xw+Q9sQfbd+YQ9X2WyumMOf9QF2Y13di72cZKOZdUhr+uybS6sQwHWlnHhmofQ18guX8PLMNRtZHe3w5H274zhxi3J7bD56bdycLH0ovUeXcW6RHFT5F+jL4ObFXJU2KFfkle4DeSjoM+TboG4wf1jbuH2rcz8EXSoaSHc50fAL4D7NVkeoeRdrWfAB4Drgbe2qvLMA/binTILIBbhpjOal+GlAksE4CPAL8BngSWAlcAr+mFZTjaNtLj22GB9o2J7TAifNt8MzMry533ZmZWlAOLmZkV5cBiZmZFObCYmVlRDixmZlaUA4uZmRXlwGLWovyY12aPhV3aZlkDkk6RtG2HqmvWNRO6XQGzMehg4L5a2so2yxgATgauAe4uUCeznuHAYta+WyPiztU1MUkC1ornP8DMrGf5UJhZQZXDZXtI+g9Jj0q6X9LZg8/KkDQD+Eke5UeVw2kz8vAFkv5d0uGS5pNuT7N/HrafpOskLZe0TNJlkl5Wq8M8SddIOlDSbZJWSJov6e8red6ep7lzgzbMk3Rd+blj/cKBxax9a0qaUHvVt6ULgLuAvwW+Qnoi5SfysF/m75DuqLtnfv2yMv6+wLHAp4D9gF9L2g+YS7oj8TuAD5Cev3GNpC1r09+OdCfcM3Id7gQulDT44KvLSHe6fX91pByk9gH+reW5YVbjQ2Fm7ZvfIG0uUH3u+Lci4uT8+ceSXg28Ezg5Ih6V9Ns87HcRcX2D8jYGdo2IBwYTJF1E6o95c0SszGnXAXcAx5EC0aDNgD0Hy5b0A9Lzzk8l3bV5paSvAh+R9LGIeDyP937SzSkvamVGmDXiPRaz9h1EeiZG9XVMLc/c2vffAO086vb6WlBZD3gVcNFgUAGIiHuAa0l7GVV/qAasiHgG+Dawe2XvahbwIlLAG3wk86HANyNieRt1NXse77GYte+2FjrvF9e+rwDWbmMaf6p935j0vPJ6OqRbp29dS1vUIN8iYCLpAVGLIuJ+SZcDRwJfI53tNhkfBrNR8h6LWW+qP89iSU7bvEHezVn1aOZBmzXItxnpRICHKmlfBnaVtCvpMNjPIuK3DcY1a5kDi1l3rMjv67aSOfeB3AwcLGnNwXRJWwOvIT3AqWorSXtU8q1J2iO5MSKerZR7FenJm18A9gLObb8pZs/nQ2Fm7dtF0pQG6Te1UcYdpIsqD5e0mBRo/iciHhtinE+S+m6+J+nLwPqks8aWkc7+qloEXCTpZNIeygeAl+b3unNJT958GLi0jTaYNeTAYta+bzdJn9pqARHxiKSjgI+T9jbWJJ1iPG+IcX4gaX/SFfsXkw5rzQOOj4j7a9nvBD5Hevzu/wIWAO+MiJ/wQt8mBZbZEbGiwXCztvjRxGbjjKR5wISIeG2L+d9H6rB/6eq8o4CNX95jMetTkv4SeAnpcNplDipWigOLWf/6Mqnj/+fAUV2ui40jPhRmZmZF+XRjMzMryoHFzMyKcmAxM7OiHFjMzKwoBxYzMyvq/wOiYSy7Th7cjgAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "font = {'weight' : 'bold', 'size' : 16}\n", - "plt.rc('font', **font)\n", - "\n", - "correct = np.where( bnnPreds == buildingTypes )\n", - "incorrect = np.where( bnnPreds != buildingTypes )\n", - "\n", - "plt.hist( en[incorrect] )\n", - "plt.xlabel( 'Entropy' )\n", - "plt.ylabel( 'Counts' )\n", - "plt.yscale( 'log' )\n", - "plt.title( 'Entropy of Incorrect Predictions' )" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "dd94d995", - "metadata": {}, - "outputs": [], - "source": [ - "font = {'family' : 'normal',\n", - " 'weight' : 'bold',\n", - " 'size' : 22}\n", - "plt.rc('font', **font)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "0723dfea", - "metadata": {}, - "outputs": [], - "source": [ - "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n", - "\n", - "cm = confusion_matrix( buildingTypes, bnnPreds, normalize='true' )" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "493725d5", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "findfont: Font family ['normal'] not found. Falling back to DejaVu Sans.\n", - "findfont: Font family ['normal'] not found. Falling back to DejaVu Sans.\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(figsize=(10, 10))\n", - "disp = ConfusionMatrixDisplay( confusion_matrix=cm, display_labels=le.inverse_transform([0,1,2]))#rf.classes_)\n", - "disp.plot(ax=ax, cmap='gist_yarg')" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "1302335f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Balanced Accuracy: 0.4501\n", - "Micro F1: 0.3731\n" - ] - } - ], - "source": [ - "from sklearn.metrics import f1_score\n", - "from sklearn.metrics import balanced_accuracy_score\n", - "\n", - "print( \"Balanced Accuracy:\", np.round( balanced_accuracy_score(buildingTypes, bnnPreds), 4 ))\n", - "print( \"Micro F1:\", np.round( f1_score(buildingTypes, bnnPreds, average='micro'), 4 ))" - ] - }, - { - "cell_type": "markdown", - "id": "a5f7d01f", - "metadata": {}, - "source": [ - "#### Entropy-Accuracy Evaluation" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "e82d7568", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.2374104061521244, 1.5849621266579648)" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.min(en), np.max(en)" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "e40860ea", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Threshold: 0.3\n", - "Percent of predictions: 0.03172965756320581\n", - "Balanced Accuracy: 0.3333\n", - "Macro F1: 0.3306\n", - "Macro Precision: 0.3278\n", - "Macro Recall: 0.3333\n", - "\n", - "Threshold: 0.4\n", - "Percent of predictions: 0.05398129483529034\n", - "Balanced Accuracy: 0.3333\n", - "Macro F1: 0.3294\n", - "Macro Precision: 0.3256\n", - "Macro Recall: 0.3333\n", - "\n", - "Threshold: 0.5\n", - "Percent of predictions: 0.061199677896432124\n", - "Balanced Accuracy: 0.3333\n", - "Macro F1: 0.3292\n", - "Macro Precision: 0.3251\n", - "Macro Recall: 0.3333\n", - "\n", - "Threshold: 0.6000000000000001\n", - "Percent of predictions: 0.06651543939242426\n", - "Balanced Accuracy: 0.3333\n", - "Macro F1: 0.3291\n", - "Macro Precision: 0.325\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/tljh/user/lib/python3.9/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n", - "/opt/tljh/user/lib/python3.9/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n", - "/opt/tljh/user/lib/python3.9/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n", - "/opt/tljh/user/lib/python3.9/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n", - "/opt/tljh/user/lib/python3.9/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Macro Recall: 0.3333\n", - "\n", - "Threshold: 0.7000000000000002\n", - "Percent of predictions: 0.07208119957263383\n", - "Balanced Accuracy: 0.3333\n", - "Macro F1: 0.3289\n", - "Macro Precision: 0.3246\n", - "Macro Recall: 0.3333\n", - "\n", - "Threshold: 0.8000000000000003\n", - "Percent of predictions: 0.08999514037645416\n", - "Balanced Accuracy: 0.5081\n", - "Macro F1: 0.443\n", - "Macro Precision: 0.415\n", - "Macro Recall: 0.5081\n", - "\n", - "Threshold: 0.9000000000000001\n", - "Percent of predictions: 0.10808451885340954\n", - "Balanced Accuracy: 0.597\n", - "Macro F1: 0.5396\n", - "Macro Precision: 0.5283\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/tljh/user/lib/python3.9/site-packages/sklearn/metrics/_classification.py:1344: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n", - " _warn_prf(average, modifier, msg_start, len(result))\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Macro Recall: 0.597\n", - "\n", - "Threshold: 1.0000000000000002\n", - "Percent of predictions: 0.14903868927005648\n", - "Balanced Accuracy: 0.6315\n", - "Macro F1: 0.5453\n", - "Macro Precision: 0.5161\n", - "Macro Recall: 0.6315\n", - "\n", - "Threshold: 1.1000000000000003\n", - "Percent of predictions: 0.20843837664012294\n", - "Balanced Accuracy: 0.5884\n", - "Macro F1: 0.5101\n", - "Macro Precision: 0.5045\n", - "Macro Recall: 0.5884\n", - "\n", - "Threshold: 1.2000000000000004\n", - "Percent of predictions: 0.2573653121123924\n", - "Balanced Accuracy: 0.5621\n", - "Macro F1: 0.4659\n", - "Macro Precision: 0.4748\n", - "Macro Recall: 0.5621\n", - "\n", - "Threshold: 1.3000000000000005\n", - "Percent of predictions: 0.31933691577061873\n", - "Balanced Accuracy: 0.5398\n", - "Macro F1: 0.4281\n", - "Macro Precision: 0.4498\n", - "Macro Recall: 0.5398\n", - "\n", - "Threshold: 1.4000000000000004\n", - "Percent of predictions: 0.43262316163248266\n", - "Balanced Accuracy: 0.5134\n", - "Macro F1: 0.3789\n", - "Macro Precision: 0.4196\n", - "Macro Recall: 0.5134\n", - "\n", - "Threshold: 1.5000000000000004\n", - "Percent of predictions: 0.566924209170829\n", - "Balanced Accuracy: 0.4899\n", - "Macro F1: 0.3388\n", - "Macro Precision: 0.4005\n", - "Macro Recall: 0.4899\n", - "\n" - ] - } - ], - "source": [ - "from sklearn.metrics import recall_score\n", - "from sklearn.metrics import precision_score\n", - "\n", - "testValues = np.arange(0.3, 1.6, 0.1)\n", - "\n", - "acc = []\n", - "thr = []\n", - "pct = []\n", - "\n", - "n = bnnPreds.shape[0]\n", - "\n", - "for t in testValues:\n", - " \n", - " ixs = np.where( en <= t )\n", - " y = buildingTypes[ixs]\n", - " x = bnnPreds[ixs]\n", - " \n", - " acc.append( balanced_accuracy_score(y,x) )\n", - " thr.append( t )\n", - " pct.append( len(ixs[0])/n )\n", - "\n", - " print( \"Threshold:\", t )\n", - " print( \"Percent of predictions:\", len(ixs[0])/n )\n", - " print( \"Balanced Accuracy:\", np.round( balanced_accuracy_score(y,x), 4 ))\n", - " print( \"Macro F1:\", np.round( f1_score(y,x, average='macro'), 4 ))\n", - " print( \"Macro Precision:\", np.round( precision_score(y,x, average='macro'), 4 ))\n", - " print( \"Macro Recall:\", np.round( recall_score(y,x, average='macro'), 4 ))\n", - " print()" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "f21b1255", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.0, 1.0)" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "findfont: Font family ['normal'] not found. Falling back to DejaVu Sans.\n", - "findfont: Font family ['normal'] not found. Falling back to DejaVu Sans.\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "font = {'family' : 'normal',\n", - " 'weight' : 'bold',\n", - " 'size' : 16}\n", - "plt.rc('font', **font)\n", - "\n", - "plt.scatter( np.array(pct)*100., acc, c=thr )\n", - "plt.colorbar()\n", - "plt.xlabel('% of data used in predictions')\n", - "plt.ylabel('Prediction Accuracy')\n", - "plt.ylim(0,1)" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "671e44b4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "th = 1.0\n", - "\n", - "ixs = np.where( en <= th )\n", - "y = buildingTypes[ixs]\n", - "x = bnnPreds[ixs]\n", - " \n", - "cm = confusion_matrix( x, y, normalize='true' )\n", - "\n", - "fig, ax = plt.subplots(figsize=(10, 10))\n", - "disp = ConfusionMatrixDisplay( confusion_matrix=cm, display_labels=le.inverse_transform([0,1,2]))#rf.classes_)\n", - "disp.plot(ax=ax, cmap='gist_yarg')" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "8f1c3494", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Balanced Accuracy: 0.5161\n", - "Macro F1: 0.5453\n", - "Macro Precision: 0.6315\n", - "Macro Recall: 0.5161\n" - ] - } - ], - "source": [ - "print( \"Balanced Accuracy:\", np.round( balanced_accuracy_score(x,y), 4 ))\n", - "print( \"Macro F1:\", np.round( f1_score(x,y, average='macro'), 4 ))\n", - "print( \"Macro Precision:\", np.round( precision_score(x,y, average='macro'), 4 ))\n", - "print( \"Macro Recall:\", np.round( recall_score(x,y, average='macro'), 4 ))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "27e1d3e6", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.9.13" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -}