{ "cells": [ { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "# Feature Engineering\n", "# Klassifikation\n", "# Regression\n", "# Validierung und mehr\n", "## Sampling und Resampling\n", "## Validierungstechniken\n", "## Grid Search und Random Search\n", "## Performancemetriken\n", "### Klassifikation\n", "#### Einführung und Vorbereitung" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import sys\n", "sys.path.append('./')" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2020-04-15T20:53:02.218161Z", "start_time": "2020-04-15T20:53:02.079407Z" } }, "outputs": [], "source": [ "## import libraries\n", "import pandas as pd\n", "import seaborn as sns\n", "import matplotlib\n", "import numpy as np\n", "import matplotlib.pyplot as plt; sns.set()\n", "%matplotlib inline\n", "\n", "## load data\n", "datapath = '../3_data'\n", "from os import chdir; chdir(datapath)\n", "from bfh_cas_pml import prep_data\n", "X_train, X_test, y_train, y_test = prep_data('bank_data_prep.csv', 'y', seed = 1234)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2020-04-15T21:03:01.918701Z", "start_time": "2020-04-15T21:03:01.844142Z" } }, "outputs": [], "source": [ "## create different types of predictions\n", "from sklearn.ensemble import RandomForestClassifier \n", "model = RandomForestClassifier(random_state=1234)\n", "model.fit(X_train, y_train) \n", "\n", "## predictions: using .predict() and .predict_proba()\n", "y_pred_c = model.predict(X_test)\n", "y_pred_n = np.where(y_pred_c == 'yes', 1, 0)\n", "y_pred_p = model.predict_proba(X_test)" ] }, { "cell_type": "raw", "metadata": {}, "source": [ "## display y_pred_p\n", "print(y_pred_p[:5,])" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2020-04-15T21:03:01.918701Z", "start_time": "2020-04-15T21:03:01.844142Z" }, "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " y_pred_c y_pred_n y_pred_p_0 y_pred_p_1\n", "0 yes 1 0.09 0.91\n", "1 yes 1 0.24 0.76\n", "2 yes 1 0.39 0.61\n", "3 no 0 0.99 0.01\n", "4 no 0 0.99 0.01\n" ] } ], "source": [ "## comparison of y_pred_c, y_pred_n and y_pred_p\n", "pred_df = pd.DataFrame({\n", " 'y_pred_c': y_pred_c,\n", " 'y_pred_n' : y_pred_n,\n", " 'y_pred_p_0': y_pred_p[:,0],\n", " 'y_pred_p_1': y_pred_p[:,1]\n", "})\n", "print(pred_df.head())" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2020-04-15T21:03:01.918701Z", "start_time": "2020-04-15T21:03:01.844142Z" } }, "outputs": [], "source": [ "## for later use: the same with y_test\n", "y_test_n = np.where(y_test == 'yes', 1, 0)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " y_test y_test_n\n", "2809 yes 1\n", "4052 yes 1\n", "658 yes 1\n", "786 no 0\n", "6675 no 0\n" ] } ], "source": [ "## check\n", "print(pd.DataFrame({\n", " 'y_test': y_test,\n", " 'y_test_n': y_test_n\n", "}).head())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Metriken für nicht numerische Klassen" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "RangeIndex: 150 entries, 0 to 149\n", "Data columns (total 5 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", " 0 sepal_length 150 non-null float64\n", " 1 sepal_width 150 non-null float64\n", " 2 petal_length 150 non-null float64\n", " 3 petal_width 150 non-null float64\n", " 4 species 150 non-null object \n", "dtypes: float64(4), object(1)\n", "memory usage: 6.0+ KB\n", "None\n" ] } ], "source": [ "## example of a multi class classification\n", "iris_data = sns.load_dataset('iris')\n", "print(iris_data.info())\n", "iris_X = iris_data.drop('species', axis=1)\n", "iris_y = iris_data['species']\n", "#print(iris_X)\n", "#print(iris_y)\n", "\n", "## test - train - split\n", "from sklearn.model_selection import train_test_split\n", "iris_X_train, iris_X_test, iris_y_train, iris_y_test, = train_test_split(\n", " iris_X,\n", " iris_y,\n", " train_size=2/3,\n", " random_state=1234)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "from sklearn.tree import DecisionTreeClassifier\n", "iris_model = DecisionTreeClassifier(random_state=1234)\n", "iris_model.fit(iris_X_train, iris_y_train)\n", "iris_y_pred = iris_model.predict(iris_X_test)" ] }, { "cell_type": "code", "execution_count": 9, "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", "
speciessetosaversicolorvirginica
row_0   
setosa1700
versicolor0160
virginica0116
\n" ], "text/plain": [ "" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "## confusion matrix\n", "#print(pd.crosstab(iris_y_pred, iris_y_test))\n", "pd.crosstab(iris_y_pred, iris_y_test).style.background_gradient(axis=None) ## for all cells" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "ExecuteTime": { "end_time": "2020-04-15T20:46:52.149549Z", "start_time": "2020-04-15T20:46:52.101330Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.98\n", "0.98\n", "0.98\n" ] } ], "source": [ "## accuracy aus confusion matrix\n", "print(np.diag(pd.crosstab(iris_y_test, iris_y_pred)).sum() / iris_y_test.size)\n", "\n", "## accuracy_score from sklearn.metrics\n", "from sklearn.metrics import accuracy_score\n", "print(accuracy_score(iris_y_pred, iris_y_test))\n", "\n", "## model internal scorer\n", "print(iris_model.score(iris_X_test, iris_y_test))" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "ExecuteTime": { "end_time": "2020-04-15T20:46:52.149549Z", "start_time": "2020-04-15T20:46:52.101330Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.020000000000000018\n" ] } ], "source": [ "## classification error, calculated as 1 - accuracy_score)\n", "print(1 - accuracy_score(iris_y_pred, iris_y_test))" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "ExecuteTime": { "end_time": "2020-04-15T20:47:15.107795Z", "start_time": "2020-04-15T20:47:15.097085Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.9803921568627452\n" ] } ], "source": [ "## other multiclass scorer: balanced_accuracy_score\n", "from sklearn.metrics import balanced_accuracy_score\n", "print(balanced_accuracy_score(iris_y_test, iris_y_pred))" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.97000599880024\n" ] } ], "source": [ "## other multiclass scorer: cohen_kappa_score\n", "from sklearn.metrics import cohen_kappa_score\n", "print(cohen_kappa_score(iris_y_test, iris_y_pred))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Metriken für binär numerische Klassen" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "col_0 0 1\n", "row_0 \n", "0 1461 142\n", "1 274 1410\n", "\n", "col_0 1 0\n", "row_0 \n", "1 1410 274\n", "0 142 1461\n" ] } ], "source": [ "## confusion matrix of numerical targets\n", "print(pd.crosstab(y_pred_n, y_test_n)) ## confusion matrix\n", "print()\n", "print(pd.crosstab(y_pred_n, y_test_n).\\\n", " reindex(columns=[1, 0], index=[1, 0])) ## reindexed" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tp = 1410\n", "fn = 142\n", "fp = 274\n", "tn = 1461\n" ] } ], "source": [ "## extract confusion matrix cells\n", "from sklearn.metrics import confusion_matrix\n", "tn, fp, fn, tp = confusion_matrix(y_test_n, y_pred_n).ravel() ## .ravel() in order to flatten array\n", "print('tp =', tp)\n", "print('fn =', fn)\n", "print('fp =', fp)\n", "print('tn =', tn)" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.83729216152019\n", "0.83729216152019\n" ] } ], "source": [ "## precision - positive predictive value - PPV\n", "ppv = tp / (tp + fp)\n", "print(ppv)\n", "from sklearn.metrics import precision_score\n", "print(precision_score(y_test_n, y_pred_n))" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.9085051546391752\n", "0.9085051546391752\n" ] } ], "source": [ "## recall, hit rate, sensitivity, or true positive rate (TPR)\n", "tpr = tp / (tp + fn)\n", "print(tpr)\n", "from sklearn.metrics import recall_score\n", "print(recall_score(y_test_n, y_pred_n))" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.8714462299134734\n", "0.8714462299134734\n" ] } ], "source": [ "## F1\n", "f1 = 2 * (ppv * tpr) / (ppv + tpr)\n", "print(f1)\n", "from sklearn.metrics import f1_score\n", "print(f1_score(y_test_n, y_pred_n))" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "ExecuteTime": { "end_time": "2020-04-15T20:47:34.451273Z", "start_time": "2020-04-15T20:47:34.431963Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " precision recall f1-score support\n", "\n", " 0 0.91 0.84 0.88 1735\n", " 1 0.84 0.91 0.87 1552\n", "\n", " accuracy 0.87 3287\n", " macro avg 0.87 0.88 0.87 3287\n", "weighted avg 0.88 0.87 0.87 3287\n", "\n" ] } ], "source": [ "## classification_report\n", "from sklearn.metrics import classification_report\n", "print(classification_report(y_test_n, y_pred_n))" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "ExecuteTime": { "end_time": "2020-04-15T20:48:11.351461Z", "start_time": "2020-04-15T20:48:11.163655Z" }, "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " precision recall f1-score support\n", "\n", " no 0.91 0.84 0.88 1735\n", " yes 0.84 0.91 0.87 1552\n", "\n", " accuracy 0.87 3287\n", " macro avg 0.87 0.88 0.87 3287\n", "weighted avg 0.88 0.87 0.87 3287\n", "\n" ] } ], "source": [ "## with not numerical labels\n", "print(classification_report(y_test, y_pred_c))" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "ExecuteTime": { "end_time": "2020-04-15T20:48:11.720755Z", "start_time": "2020-04-15T20:48:11.688642Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " precision recall f1-score support\n", "\n", " setosa 1.00 1.00 1.00 17\n", " versicolor 1.00 0.94 0.97 17\n", " virginica 0.94 1.00 0.97 16\n", "\n", " accuracy 0.98 50\n", " macro avg 0.98 0.98 0.98 50\n", "weighted avg 0.98 0.98 0.98 50\n", "\n" ] } ], "source": [ "## a multiclass classification, data prepared in 4.4.1.2\n", "print(classification_report(iris_y_test, iris_y_pred))" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "precision_score: 0.9811764705882353\n", "recall_score: 0.98\n", "f1_score: 0.98\n" ] } ], "source": [ "## apply precision_score and recall_score for multiclass models\n", "from sklearn.metrics import precision_score, recall_score, f1_score\n", "print('precision_score:', precision_score(iris_y_test, iris_y_pred, average = 'weighted'))\n", "print('recall_score: ', recall_score(iris_y_test, iris_y_pred, average = 'weighted'))\n", "print('f1_score: ', f1_score(iris_y_test, iris_y_pred, average = 'weighted'))" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.9085051546391752\n", "0.9085051546391752\n" ] } ], "source": [ "## recall, sensitivity, TPR\n", "tpr = tp / (tp + fn)\n", "print(tpr)\n", "from sklearn.metrics import recall_score\n", "print(recall_score(y_test_n, y_pred_n))" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.8420749279538905\n" ] } ], "source": [ "## specificity, TNR (no sklearn function)\n", "tnr = tn / (tn + fp)\n", "print(tnr)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.1579250720461095\n" ] } ], "source": [ "## false positive rate, FPR: 1 - TNR (no sklearn function)\n", "fpr = 1 - tnr \n", "print(fpr)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "## ROC AUC - part I (binary)\n", "plt.figure(figsize=(5,4.5))\n", "sns.lineplot(x=[0, fpr, 1], y=[0, tpr, 1])\n", "plt.xlabel('fpr (1 - specificity)')\n", "plt.ylabel('tpr (recall, sensitivity)')\n", "ls = np.linspace(0, 1, 100)\n", "plt.plot(ls, ls, color='r', linestyle='--')\n", "plt.annotate('O', (fpr, tpr), ha='center', va='center')\n", "plt.annotate('O 1', (-0.01, 1), ha='left', va='center', size=10)\n", "plt.annotate('O 2', (0.3, 0.5), ha='left', va='center', size=10)\n", "plt.annotate('O 3', (0.6, 0.1), ha='left', va='center', size=10);" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "## calculate the area under the curve\n", "plt.figure(figsize=(5,4.5))\n", "sns.lineplot(x=[0, fpr, 1], y=[0, tpr, 1])\n", "plt.xlabel('fpr (1 - specificity)')\n", "plt.ylabel('tpr (recall, sensitivity)')\n", "ls = np.linspace(0, 1, 100)\n", "plt.plot(ls, ls, color='r', linestyle='--')\n", "plt.annotate('O', (fpr, tpr), ha='center', va='center')\n", "\n", "## add polygons\n", "x1 = [0, fpr, fpr, 0]\n", "y1 = [0, tpr, 0, 0]\n", "plt.fill(x1, y1, color='lightblue')\n", "x2 = [fpr, fpr, 1, 1, fpr]\n", "y2 = [0, tpr, 1, 0, 0]\n", "plt.fill(x2, y2, color='palegreen');" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.8752900412965329\n", "0.8752900412965329\n", "0.8752900412965329\n" ] } ], "source": [ "## calculated from the values of the confusion matrix\n", "print((fpr * tpr / 2) + ((1 - fpr) * ((tpr + 1) / 2)))\n", "print((tpr - fpr + 1) / 2)\n", "print(((tp / (tp + fn)) - (fp / (tn + fp)) + 1) / 2)" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.8752900412965329\n" ] } ], "source": [ "## with functions from sklearn.metrics\n", "from sklearn.metrics import roc_curve, auc\n", "fpr_arr, tpr_arr, thresholds = roc_curve(y_test_n, y_pred_n)\n", "print(auc(fpr_arr, tpr_arr))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Metriken für Wahrscheinlichkeitswerte von Klassen" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "tags": [] }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "## a graphic comparision of the values from .predict() and .predict_proba()\n", "f, axes = plt.subplots(nrows=1, ncols=2, figsize=(8, 3.5), sharex=False)\n", "ax = sns.histplot(y_pred_n, bins=20, ax=axes[0])\n", "ax = sns.histplot(y_pred_p[:,1], bins=20, ax=axes[1]);" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " y_pred_n y_pred_p_1\n", "0 1 0.91\n", "1 1 0.76\n", "2 1 0.61\n", "3 0 0.01\n", "4 0 0.01\n" ] } ], "source": [ "## ROC AUC - Part 2 (cont)\n", "print(pd.DataFrame({\n", " 'y_pred_n': y_pred_n,\n", " 'y_pred_p_1': y_pred_p[:, 1]\n", "}).head())" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " thresholds tpr_arr fpr_arr\n", "0 inf 0.000000 0.000000\n", "1 1.00 0.030928 0.000000\n", "2 0.99 0.063144 0.000576\n", "3 0.98 0.103093 0.001729\n", "4 0.97 0.136598 0.005764\n" ] } ], "source": [ "from sklearn.metrics import roc_curve\n", "fpr_arr, tpr_arr, thresholds = roc_curve(y_test_n, y_pred_p[:, 1])\n", "#auc_arr = (tpr_arr - fpr_arr + 1) / 2\n", "\n", "results = pd.DataFrame({\n", " 'thresholds' : thresholds,\n", " 'tpr_arr': tpr_arr,\n", " 'fpr_arr': fpr_arr #,\n", "# 'auc_arr': auc_arr\n", "})\n", "print(results.head())\n", "#print(results.tail())" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=(5,4.5))\n", "sns.lineplot(x=fpr_arr, y=tpr_arr)\n", "plt.xlabel('fpr')\n", "plt.ylabel('tpr');" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "auc : 0.9363025119581688\n" ] } ], "source": [ "from sklearn.metrics import auc\n", "print('auc :', auc(fpr_arr, tpr_arr))" ] }, { "cell_type": "raw", "metadata": {}, "source": [ "## manual control of the trapezoidal rule\n", "area = 0\n", "for i in range (len(tpr_arr) - 1):\n", " area = area + ((tpr_arr[i] + tpr_arr[i + 1]) / 2 * (fpr_arr[i + 1] - fpr_arr[i]))\n", "print(area)" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "## a function from sklearn.metrics which draws an calculates roc auc directly\n", "from sklearn.metrics import RocCurveDisplay\n", "RocCurveDisplay.from_predictions(y_test_n, y_pred_p[:,1]);" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAc4AAAGeCAYAAAAdaOFHAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAWidJREFUeJzt3Qd8lOXhB/BfbmZe9g5hyRYIK4iCVVtRqVaqtCpiHQW3CFq3tc5qFQuC4iponVi3tda/s24JIHvJJjuQXHJJ7nL7/3meIyEhCeSS9/Le+H0/n3gjb14en1zud894nyfK6/V6QURERF2i6dphREREJDA4iYiI/MDgJCIi8gODk4iIyA8MTiIiIj8wOImIiPzA4CQiIvIDg5OIiMgPDE4iIiI/6Pw5OFyJxZM8np4voKTRRClynnDDeukc66ZjrJfOsW4CVy/iHFFRUcc8jsEJyMquqWns0Tl0Og2Sk+NgsVjhcnkUK1uoY710jnXTMdZL51g3ga2XlJQ4aLXHDk521RIREfmBwUlEROQHBicREZEfGJxERER+YHASERH5gcFJRETkBwYnERGRHxicREREfmBwEhER+YHBSURE5AcGJxERkR8YnERERH5gcFJY7nbjqqtTuxhEFKYYnBRWvG43ql57BfvuvwfO6mq1i0NEYYjBSWHDbbOhdMkTqPvyc7gtFli3bVW7SEQUhrgfJ4UF0bosXbwQjtISRBkMyJp9FRLGjlO7WEQUhhicFBYaflotQ1ObmIjcG+Yhul9/tYtERGGKwUlhIelXU+FpaoLpxMnQp6aqXRwiCmMc46SQnTlb9+3XMiyFqKgopJ5zLkOTiAKOwUkhx+tyofKlF1D54nKUP/8MvB6P2kUiogjCrloKKW5rI8qffgrWrVtEMxOxw0YgSsPPf0TUexicFDIcB6pQ9sRCOCrKEWU0IvvKaxA/ukDtYhFRhGFwUkiw7dyBsqcWw11fD11yMnLEzNn8vmoXi4giUFD1cT377LO45JJLjnqM2WzGzTffjAkTJqCwsBD33XcfbDZbr5WR1BnTLP/HszI0jfl9kX/XPQxNIlJN0LQ4X331VSxatAjjx48/6nFz586VQfniiy/CYrHgrrvugtVqxd/+9rdeKyv1riidDjlXXwfzJx8j89IroDEa1S4SEUUw1VuclZWVuPrqq7FgwQL069fvqMeuXbsWRUVFMiRHjBiBSZMm4f7778f7778vz0Phw+N0wrZ7d8tjsaCBGNNkaBIRIr3FuXnzZuj1enzwwQd46qmnUFpa2umxq1evRnp6OgYOHNjynOiuFdfwrVmzBtOmTeulUlMguRsaULZ0CZr27kGfW+/gKkARcE2uR3x5IG+dbg8MNicabE44nG54PeL7gMfjPXxsq8eRRKvTwGJ3w2Kxwe3iZVit68UYY0DEBOdpp50mv7pCtCqzs7PbPGcwGJCUlITy8vIelUOn61njW6vVtLml7tWLvaIcxQv/DkdlJTQxMYDd1uPfTbBS+jUjQqTJ4YbN7oJN3Da5fPcPfYlAcnu8cIlbt1fed7s9cB269T32wuXxfb/1821+xuNpCTkRXodvD4XgoedEprV8X3yvzbG+oBTHR1b0UXd4PW64HDb55XRYffft4vbQfYcV/YdNxIsPXtwr7xeqB6c/xNimCMojGY1G2O32bp9Xo4lCcnIclGAyxShynnDTlXqp27QZ+x55FK76Bhgz0jHs7jsR1zcf4UKEjggwa5NThpq1yY4dZRZY5X2nDD0ZZO62gXbkY3GcOL7556zinDanPLcIqHATFQVooqLk36n8avVY9DaJ71NwcrudcNqtx/ySgXjovsfjbneeqCgN9MYY6I2x0BtifbfGWMQajNDGp0Jv7IMRQ/sjJTlOvi4CLaSCMzo6Gg6Ho93zIjRjY2O7fV7xCdhisfaobKLVIMJBdqG42YXib73UfvctypYvE39piBkwEH1unAeHKREOcyPUJl4fotuw3upAvdXXhdgouhKbxK1L3hfh5XR5Dn25ZetO3Hc4RdCJFp8bdmf7N4RAEKESE61DjEGLWHmrQ7RRC4NOC60mClptFHRazaH7vtvDj6Og1Wig0x46TtPq+/J7h3+mJdBahZhYi0I8bn3fF3atjj/0uDkEo9o8B+h1WiQmxqKhwSZbqeL71HvvM6IXQEy4bGhoQH29BfX19a1uO77f2NjYrttcPBbDcAkJJqQlJCDBlCDvJySkIiGhH0wmcb/5OXGbgPj4BPkzXSljzSf/B/OXX6DfXbfCmJSoSL2Ic3SlByikgjMrKwufffZZm+dEkNbW1iIjI6NH53YpNF4gWwYce/CrXho3bkDZ88/J+/HjJyDrijmiD17RehR/aFW1NuwutaC8phENhwJPdEEeGZKyu9PhkrcyFJtcinYnihCKMWoRY9QhPtYAgzYK0QYdDHoRSL6Aagmy1mF26L4IQBGEsUYRiDrfreHwY4NOE9JhI/6f9aK7zSteN6Lmw7AZHYC/J7fbjcbGhnah1tDQPvCan7PZrB2+VkRDJD7+cKA1B5wItrS0jHaBFxsrWnrKdJEe6+9eblb/+quo+98X8rH5m2+RPu2sTuslEEIqOMW1m2L27b59+9C3r+86PjHLVhg3jnsvhqrYEccjbnQBjLl5SJ1+nmJL6Img3LK3Blv2mrFtn1m2FHsiLlqH+Bg94mP1iIs+9BWjQ3y0XrbwRGCJN3zRYtJrNdDpouStCMXmoBT3ZSgcGlcXQwRmcyM/bEUw8eH/cLg1h1rrVp14rjkEG2C3W2G1NrVr4YnuzPj4+DahJoJO3KakpKJv336tWna+74tevFD6kOW22VD+zFOwbt4k+/DTZvweSadP7fVyBHVwik9QNTU1Lb/g0aNHY+zYsZg/fz7uvfde2Z1wzz33YPr06cjMzFS7uOQHsZiBmPwjrtEUQZlz7Q2I0mqP+XPizeJgXRP2VtS3hI2YXiK6Qi2NDtRYmmRgVpltqGts260vuh/7ZiUgPyMBCYfCrznEmon3EF/AaWXIia7OhFgD4mN0stVH1Pw6FHMuWoda65ZecxC27u4U91u3npuDT6fTt2nZtW7p5eTktLT0xOPk5ET06ZOFxkZnxH3YclYfROniRUGxWX1QB6eYKfvLX/4SDz/8MM477zz5yejJJ5+UqwVdeumlclLQmWeeiTvuuEPtopIf7GVlKFu8EDGDByPz8tm+CR6dhKZoJe4us2Dllkqs23lAjhuKyTJd7fIbmGPCsH4pGNY3Gf2zTe2CkiKLx+PxszvT0unKZDExMW1CrXVLLyMjs113ZlxcfI+7M0UvhZggKYIzktiLi1Gy8DG4LRZoE5MObVZ/9Ov+IyY4H3nkkTaP8/LysH379jbPpaamYvHixb1cMlKK2NVEXKPpEW9GUeKazXroEkwt36+oseKb9WXYtr8WB2ptHXavikDMz4yXY3rNxNieKdaApHgD0pNjkJEUi5y0WNlqpNDndDrbdGceq6UnvpzO9hMJxYc0EWAdTUpJSkpGnz757Vp+IiBDqTszHOmSkqAxRkObl4jcufOgT1F3312+q1Cvqfv6K1S++pKcORt93CBkX3MDdlS7sHPjXhRXNaDKbMX+StGd1VZmSiyG9EnESSOzkWqKRlyMHkb9sbt1SV3yutKmpk5DrqOWXnN3pl6vhVMsfnCoO1Or1XXanSkmDQ4aNLhVy0+0AuNljxSFLq/38IxqbUIC8m66BdqEeGii1b/kj8FJPbZhwzq88car2Lhxg3wjTE1Nx/jxE3DBBRfjuOMGyo2mK//1Bqo/+o88PmHiCaicfC6efmMLKmvaXgYk/kxGDUzFxOGZyEmLQ1pijBxnpN7tzrRaGzu8/KCziStivkFHoqNj2kxSad3SS0tL77A702jUc9JUhPOKzepffQnR/Qcg6eRT5HP69HQEC74jUY+88sqLePbZp1BYOAlz596E1NQ0lJYW45133sIVV8zCn/98L8ZUlKP6c9/UcePp0/CufihWv7+1ZabqiP4p6JdlQnpSDPpmxcuwJP+5XK5OZ2O2Dr7W3Zl2e1O7bkjxWFxe0DrQmsPPZEpEbm5eu5mb4vIFdmeSEtyNjSh7+knYtm1F/Q/fI37UaOiSkhFMGJzUbd999w2eeeZJXHHFlfKr2Zgx43DmmWfj3nvvxAMP/AX/eOBBePUG7J9wFt7cnwyX+6CcvXr6+D44d3J/OYs10rszzea6dmN0R5u44vV62p2nbXdm20krmZlZOO64Qa1af77QY3cmBe9m9dHIvurqoAtNIcobaaskd0BcNFtT07MVaiLxmrzZs/8gL6B+5ZU327U2RFdLlbkOF/7+NzDljkLesHNg00bL74kW5gWnHYe89HiEKvFnI1ZLOdpszCNbfuL41kSdibE8jUYnw6z1GF1n43nN3Zk6Xfh+2IjEv6WuCue6se04tFm9mDCYnCInARn75PdqvaSkxIXfykEUPMRqTdu2bcHMmZe0C82an9ai/KUX8a+cX8GQchzMJRuRP2EmJvZPwbjB6Rg3JF21bj3Rnenv7MymJluH3ZlxcXGdrq6SnZ3TrjtTHN/6POH8JkjkD8vKH1H5wj/kB26xWb0IzWBsaTZjcFK3VFSUydusrJw2zx/89FMcfOM16OHFyPJ12JaaicbKzbjv0pFISUrq9r8n1iPuKNSO1tJrvVh0c8eKRqNtN0mluaWXnp6BAQMGdtidyfE7osBxVR+UoRk3ZiyyZ18V9PvuMjipWw6veuJ7Cbldbmx4ehni1n8vd0ffkjQIWRdfgpO+eRP/2gKU7N+Dvbvd7ULOt7LK4RAUszk7Gj0wGIxtJqm07s7Mz89v1/ITx4RzdyZROEk+69fQp6XLtaqVWnIzkPjOQt2SleXbF7W8vAyORitW//VxpFXuks+9WlmLDbVrEP/3DaiuPgitVov33nunzYXnItjEOQK5WDQRBe+Smwffewfpv7sAmkPr5SYUTkSoYHBStyQnp2DEiJH48otPMWrLbqQ1VsPu8aB08vm4dvrpctECsbTZ+eefjWnTpuGuu+7jOB4RwVFRgdIn/g7ngSp4mmzInnM1Qg0/2lO3XX75HJSUluD94j1o1Ebj+cYmnHnFuTI0xQL9jz32sBybnD17ttpFJaIgYN22Ffv/+oAMTV1qKlKmnYNQxBYndYvH68XPtSlIH342vt3yH5REa5GZl43169eirKwU7733Nnbs+Bl33nkPhg4dKmeOElHkqvvuW1S+9IJvyc0BA5Bz3Y3QJSYiFDE4yS9i4k7tp59g/55y/M+cj5QBJ2PGr0/GhyuelJenzJ9/nVw9aPz4ibj99j9j0KDj1C4yEanI6/Gg+v13UfOff7fZrF5jMCBUMTipy+TO66+9grqvvoRYFC8v9wyMO/0EufrPp+8uw5tvviKXXiMiauZuaEDdt1/L+ynTzlZ0s3q1MDipS9xWK8qfXSp3XvciCl+kjcMBUzZ+OS7v0LJxNoYmEbWjM5nk/pn20hIknjQF4YDBScfkPHjAt/N6WSmgN+C/OSdjgz4HvynMR3yMHjt37pDroBIRCfayUjgPHpQLtAvR/frLr3DB4KSjsu3ehbIlT8BdbwESEvFG5inYg0T0yYjHWRP7ymOKin7EhAmhcw0WEQVO45bNKH/6STm00+fWOxHdrx/CTWh3NFPAuaqrZWhqc/Lwj6wzZGjmZ8Rj3u9Gw2jwbSa9atVKBicRofbr/6F00ePw2GyI7tsP+tRUhCO2OOmoEiYUyt2lX96lwcE9FgzIMeGWC8e0hGbz6kE5ObmqlpOI1J05e/Dtf8H8fx/LxwknTELmpVdAo9cjHLHFSW2IhZYPvLkCTrO55bkdpv5YvccCrSYKl501tE1oms01SOrB4u1EFNo8drvceLo5NFPP/S2y/nhl2IamwBYndbjzunX7duTf+Wd8tb4cr376s/z+qWNz2+2huXp1EbtpiSJY7f++QOPanxCl0yHz8j/CNHESwh2DkyRHVRVKF/8dzooKufN68jnn4pVPd+DLtaXy++OHpOP8Xwxs93OrVhXh7LN/o0KJiSgYJJ9+BhylpUic8gvEDIqM2fXsqiXYdvyM/X+9X4amLiUFafNvw7NbvDI0xS6U5/9iAK6ZfjyM+sNdtM02b96I4cOPV6XcRKTee4bX5ZL3xWIGWVfMjpjQFNjijHCWlT+g8oVlvp3X+/VHypxr8diHu1FyoFGOZV51zggUDErr8GedTqfcDoj7XhJFDvPnn+LAitdgmnSS7JqNxE3e+Y4XwURY1nz0H9/O62PHwfyrGVj24R4ZmolxBtx0QYG8XrMzmzZtwPHHj+zVMhOROsR1mQfeeA21X3zue0ITBXg8gLZ9T1S4Y3BGMDGYnzt3Pizff4tPY4bhk3e2yudjjTp5nebRQlPg9ZtEkUHsm1n+7NNo3LhBPk47/3dIPnNaRLY2BQZnBO683rh1M0yFJ8jH4gLlPYMm4ZP3NsnHvxqXh7NP7AdT3LF3LhAzai+4YGbAy0xE6nHWVKNsySLYi4sRpdfLS00Sxk9AJGNwRhBHRTlKn1go154V11jFjxkHi9WBF/+7TX7/rBPy8btTurYNmFjYva6uDomJvIaTKJwXNihd+Dgc5WXQmkzIuX4eYgYMQKRjcEbQzutlS5fAY7VCn5YOfWa2fP6jH/bBanfJZfR+O6XrfxClpSXIy8sPYImJSG1ixmz6hTNx8K1/Ief6udCndjxRMNIwOCNA3bffoPLlF307rw88DjnXzZVb/Ticbny1rkweM+OUgdBpu351km98szCApSYiNYjeJJe5BvoU3zqzcSOOR+yw4SG/h6aSWBPhvn7kO2+h8sVlMjQTCici70+3ytAUNu+tgd3pRqrJiBH9U/w6t9gRpbCQE4OIwomYYV/1yj+x79574KioaHmeodkWW5xhTGw6XfPRh/J+ytm/Qepvprf8AXi8XtlNK4wZnO737Lg9e3ajf//2KwkRUQhvVv/MU7Bu2QxERcG2awcMWVlqFysoMTjDWNzIUUg+4ywYc/NgOvGkNt/739pS7CqzINqgbdlXs6saGhoQGxsXsVPRicJzs/qFcJSVIcpgQPaV1yC+YIzaxQpaDM4w3HldZ0qENt53DWb67y5od4y53o63v9ol74v1Z5MTjH79G2vXrsGYMeMUKjERBctm9dqkJOTeME/upUmdY3CGkcbNm2RXizG/L/Lm/0kucNCRD77bA5vdjf7ZJpw6xv99NMXEoJNOOlmBEhORmmw7d6Dk8UfhdTph7JOPnBvmQZ/i33yHSMTgDBO1X32Jqldf9i2B5fXC47BD20FwVpqt+GZ9ubx/wWnHQSOWzfLTunVrce21cxUpNxGpx9i3L4x9+0EbF4fsOVdDEx2tdpFCAoMzHGbOvvkGzJ/+n3wsFl7O+MNlnW4i+85Xu+XEoFEDUzG4j/+LF3g8HjidDkTzD4woJMldTTQaOVFQozfIZTdFYHLmbNcxOEN85/Xy559B47q18nHq9POQ8utzOp2083NxLVZtqxIT5jrcW7Mrfv55OwYPHtqjchOROtwNDXKz+uj+A5A+4/fyOW1srNrFCjkMzhBWsfx5GZpy5/UrZresP9sR0cp8/fMd8v4vRucccwH3o12/yYXdiUKPo7JSzpx1VlbAvm8vkn55OvTJyWoXKySxbR7CUs/9LfSZmci75fajhqbww6YK7KuoR4xRi+l+LK13JO6IQhR6rD9v921WX+nbrL7P7XcxNHuALc4Q46qthS7JNzZpzMlFv/v/iqhj7IfX5HC1XH5y9qSu7XzSmaqqSmRmZnb754mod1l++B6V/1zesll97g03QsfNGXqELc4QYv7sU+y54xa5YHuzY4WmsOLznahtcCAtMRq/Gp/X7X//wIEDSEtL7/bPE1Hvqv7wA1Qse06GZvzYcehzy+0MTQWwxRmCO683rl+H2KHDuvSz63YcxNfryyCmC10+bRj0uu7v1i7232Q3LVHoMGT4eofEptNp583gzFmFMDiDnNvm23nduunQzuszfi+X0euKBpsTL/7X1zqdWtgHw/r2bExDTAyaMaP9SkREFJzExg6G7Gy5uAEphx8/gpizuhrFjzwkQ1OuH3nN9Ug5c1qX14j9ZkMZLFYnslNjcd7JPd98dvv2rRjaxZYuEfU+seF08aMPw2k2tzzH0FQegzNIOWtq5Cw4R2kJtImJcmwiYdz4Lv+8uPzkq7W+vTbPKMzvURetYLfbodPpoO3CmCoR9T7r1i3Y//CDsP28HQdef0Xt4oQ1dtUGKV1yshzHtJeUyJU99Km+TWW7akdxLapqbfLyk4nDej4LdsOGdRg5cnSPz0NEyqv79mtUvvzPls3qM2ZdqnaRwhqDM8h2XhcvfLGggeiOzbzsCnhdbmhjYvw+19odB+Xt2EHpMBp63kpctaoIhce4VpSI1Nms3vzxRy1jmpmX/1EupUdh3FUr1j5dvHgxpkyZgoKCAsyZMwfFxcWdHl9dXY2bb74ZJ5xwAiZOnIj58+ejsrISYbHz+ssvovy5p+UfgyBe/N0JTWH9Tl9wjj4uTZHyrVmzCmPHcisxomDhcThQ/uzSltBMOfscZM2+iqEZCcG5dOlSvPbaa3jggQewYsUKGaSzZ8+Gw+Ho8Ph58+ahrKwML7zwgvwS96+77jqEMre1EaVPLETd11+hYe1PaNq1s0fn27rPjEqzDTptFEb0T1GkJdzQUI+EBFOPz0VEyl2m5qioALRaZF0xB2nTz+flJr1E1VoW4bh8+XLMnTsXp5xyCoYOHYqFCxeioqICn3zySbvjLRYLioqKZKt02LBhGD58OK688kps3LgRtbW1CEXOAwdQ/PBDsG7djCijETnXzUXMoME9CrnmVYJ+MToXMcae98bv27cX/fr17/F5iEg5ojcqd+485N18K0wnnqR2cSKKqsG5bds2NDY2YtKkSS3PmUwmGYirVq1qd7zYyiouLg7vvfceGhoa5Nf777+P/v37y58LNbZdO30zZ8vL5GSgPrfdifiCMT0657qdB7G7zAKDToOzT+yrSDm5sDtRcGjYuAHl//F1zQr61DTEDh6iapkikaqTg0TLUsjOzm7zfEZGRsv3WjMYDHjkkUdwzz33YPz48XICjTj2lVdegaaHXRQ6Xc9+XqvVtLk9FsvqVSh95hl4XU5E9+2LPvPmQ5/cs25VcQnKe9/skfenFuYjNal746NHWrOmCDfeeFO36sjfeokkrJuOsV46VvPFF6h45SW5UX3/1EzEDOH2fmq9ZlQNTpvN1hKIrRmNRtTV1XXYDbl161aMGTNGjoO63W7ZtXvttdfi9ddfR3x897bK0miikJwcByWYTF0LK22fbJRGASmFEzD4phu7PQmotdVbK1Fc1YDYaB1mnjUMCbHKTBIoLy/FqFHDurzwQk/qJRKxbjrGejk8lrn3xZdQ8cGH8nH6qacga9yoTjerj2SmXnrNqBqcouu1eayz+X7zxfYxHQTJf//7X9m6/PLLL1tC8plnnsGpp56Kt956C5dddlm3yuHxeGGxWNET4pOO+KVZLDa43b5ZsUeVmYd+d/0Z0fn5sDR5gKZG9NR7//NNKpoyOgcuuxNmu7PH57RY6hAdHYvaWmvv1EsEYd10jPVymKepCSXPPo2Gtb7N6jPPn4GBl1yI+vomuBs6nkAZibQKvWbEObrSalU1OJu7aKuqqpCff3hZKPF4yJD2/farV6+W45mtW5aJiYnyuX379vWoLC6XMn+g4pfW1XPp8/Ihf8eHLj/pCbvDjU27q+X9k0dlK/b/s3JlEcaOHd/j8/lTL5GGddOxSK8XsWxe2ZJFsO/f17JZfcqJJ8qen0ivm870Vr2oOoggZtGKEFy5cmWbmbNbtmzBhAkT2h2flZUlA1K0SJtZrVaUlJSgX79+iGQ7S+vg9niRaopGdqoy3c4CJwYR9T4xLCXWqBahqU1I6NJm9dR7VA1OMbY5a9YsLFiwAJ9//rmcZSsWNBABOXXqVDmGKfaAbGpqksdPnz695VpOcaz4uummm+SY6HnnnYdItr3Yt6jzkHxl99rbtGkDl9oj6mWiVZk45RdIO//36HPnnxEz8Di1i0StqD5tTVzDOWPGDNx999246KKL5CLiy5Ytg16vR3l5OSZPnoyPPvJNvxYzaMViCeLT2KWXXorLL79cHieeS0hIQCTbWeKbTDW4j3LBKT64iK8jJ28RkfLE+5pYc9bdeHi+Q8pZ02BIz1C1XBSEa9WKoLzlllvk15Hy8vKwffv2Ns8NHDhQTgiitn9w+ysb5P1+Wcp9gNiyZTOGDRuh2PmIqPOZs1UrXkXdl1/A8sP3yLvpFkRxJ6KgpXpwUs/VWOyw2l3QaqIUHd9ctWolF3Yn6pXN6pfCummj6KNF3MhR4ho5tYtFR8HgDAPFB3ytTbFhtb6HCzkcGZznnhvZY8dEgd6svnTxQrnvrtisPuuPV/q17y6pg8EZBvZX1svbPhndWwCiM2ZzDVL93AeUiLqmac9ulC5ZBLfFIjerz71hHqK5JnRIYHCGwfjmqm1V8v6gPOUmBlVUlCMzM0ux8xHRYWLrwIoX/iFD05Cbh9wb50Ofwg+poYLBGeL2lNej9ECj7KItHJahaDctr98kCgyx/Vf21deh5sMPkPmHy6CJ5vKCoYQj0CHumw1l8nb8kHTERiu3dmVREYOTSOnN6m07drQ8NubkIvvKaxiaIYjBGcLEbihFW33dtJNH5Sh67p07f8agHuwLSkRHblb/dxQveATW7dvULg71ELtqQ9gBsw02u0t20w7uk6jorjUGg7HHW7UREeA4UIWyJxbCUVEuN6v3tFoylEITgzOEiS3EhLz0OGgVDLn169dizJixip2PKFLZdu5A2VOL4a6vl5vV54iZs/nKbDBP6mFwhrB9AboMheObRD1nKfoRlcv/Icc2jfl9kTt3HnRJyWoXixTAvrgQtnWfb2H3ATnKddMKa9euQUEBW5xE3WX9eTsqnntGhmZcwRj0ue1OhmYYYYszRNVbHdhTZpH3j++fouh1oTabFXFxyi3dRxRpYgYNRsLEE6AzJSLtdxfIy08ofDA4Q9TmPTXwHhrfTDFFK3beXbt2YiC3MCLym7uhAVF6PTRGo9wWTCyfx8AMT/ythqiNu6vl7cgByq42woUPiPznqKjA/r8+gIrlz8tVgQSGZvjibzZE/Vzs239zhILdtAJ3RCHyj7guc//DD8BZVYmmvXvgtvj+Nil8sas2BDXYnKi2NCm+/6ZQVlaKnJxcRc9JFK4s33+Hin8uF7u+I7r/AORcfyN0icpO1qPgw+AM4d1Q0pOiFV1mT+yGkpSk3ELxROFKdMdWf/Auaj78t3wcP34Csq6YA43BoHbRqBcwOEP4+s2+mcq2NtesWYXx4wsVPSdROKp6/VXUffm5vJ8y7WykTj+PY5oRhL/pELSv4lBwKtxNy4UPiLrGdMIkaKKjkXnZH5F23gyGZoThbzuEl9rLV7jFuXnzRowYMVLRcxKFC4/T2XI/ZuBx6P/IAiROnqJqmUgdDM4Q43S5UVljk/fz0pVbas956E1Bp2PvPdGRrFu3YO+dt8FevL/lOW28sktdUuhgcIaY8mqr3E4sLlqHpHiDoq3N449na5PoSHVff4WSRY/DZa5BzUcfql0cCgJsXoSYkgO+btrc9Hi5OolSeP0mUfuZswffeQvmjz+SjxMmTkLmZVeoXSwKAgzOEFNyoFHeiqX2lLR6dRF+97sLFT0nUagSe2ZWLHsODT+tkY9TfzMdKeecq+iHVQpdDM4QY673bYKbnhSj6Hnr6uqQxN0biOSas6Jr1r53D6J0OtnKNJ1wotrFoiDC4Awxdodb3sYYlfvVlZaWIDc3T7HzEYUyTUwMtHFx0MTHI/e6uXKnE6LWGJwhpsnhkrdGvVaxcxYV/cjrN4kOidJqkX31dXA31MOQnqF2cSgIcVZtiGk61OI0GrQKTwxicFLkqv3iM1S++pLcj1bQxsQwNKlTbHGGEPFHXXNojDNewTVqd+/ehf79Byp2PqJQmjl74I3XUfv5p/Jx/OgCxB0/Su1iUZBjcIaQsmorLI0O6HUa9M1S5uLrhoYGxMTEcrYgRRxPkw3lzz2Dxg3r5WOxdF4sV86iLmBwhpCte2vk7aC8ROh1ynTVrlv3E8aOHa/IuYhChbOmBmVLFsJeXIwovR5Zf5yDBG5wQF3E4AwhW/eZ5e2wvsmKTgw68USut0mRo2nvXpQuWQR3XS20CSbk3HAjYgZwqIK6jpODQoTb48G2/bXy/vB+KYqdd926tSgoGKPY+YiCnctSB7elDoacXOTf9WeGJvmNLc4Qsb+yATa7C7FGnWL7cHo8HjidDkRHRytyPqJQED9qNHKuvQExQ4ZCGxurdnEoBLHFGWJ7cPbPMUGjUWYiz88/b8egQUMUORdRsPK6XDjw5htwVFW1PBc/ZixDk7qNwRkiig8t7t4nQ7mtjLiwO4U7t9UqxzPN//dflD25SIYoUU8xOENs82olg9O3YhBnElJ4ch48gOJHHoJ18yZEGQxI++0MufYsUU/xVRQCxP6bJQEIzqqqSmRmZil2PqJgYdu9C2VLnoC73gJtYhJyb5iH6H791C4WhQkGZwioqLbKpfbEwgdZKcqMyxw8eBCpqWmKnIsomNSvLkLFsufhdTph7NMHOTfMhz5FuZnoRAzOEPBzie8ylIE5Jui0GsXGN7mwO4XjEnrmT/5PhmbcqNHIvvJqaKKV3YKPiMEZAn4u9gXn4D5Jip1TBOf55/9esfMRBYMojQY5181F3VdfIuXs38jHRErjqyoEFnbfvl/54Ny2bQuGDh2m2PmI1OJubETdd9+2PNYlJiL1N9MZmhQwbHEGueq6Jpjr7dBqojAwJ1GRc9rtduh0Omi1ym1NRqQGcW1m6eK/w1lRgShNFEyTTlK7SBQBGJxBbleZRd7mZyYotgfnxo3rMXLkaEXORaQW246fUfrUYngaGqBLSYExL1/tIlGEYHAGuX2VvhWD+mUrs8yeUFTEiUEU2iwrf0DlC8vkggbGfv2Re/2N0CUpN5RBdDQcBAiRpfaUWp9W+Omn1Rg3jluJUWiO+Vd/8B4qnn9Whmb82HHoc8vtDE3qVWxxBvmbxP5KZYNTnLOhoR4JCSZFzkfU292zIjiF5DOnyc2nOQmIehuDM4hVW5rQ2OSSE4Ny0uIUOee+fXuRn99XkXMR9bbYwUOQeu5voU1MRNLJp6hdHIpQqn9UE1tbLV68GFOmTEFBQQHmzJmD4uLiTo93Op14/PHHW46fNWsWtm7dinBUXOlbZi83LU6uGqQELuxOocZRXgZXne+SLCH1nHMZmhTZwbl06VK89tpreOCBB7BixQoZpLNnz4bD4ejw+HvvvRfvvPMO/vrXv+Ltt99GSkqKDNv6el+XZjgpr7HKW6VamwJXDKJQYt22FfsffhBlTy6Gx25XuzhE6genCMfly5dj7ty5OOWUUzB06FAsXLgQFRUV+OSTT9odL1qiIiwfeugh2eIcOHAgHnzwQRgMBmzatAnhpry6Ud5mpSq3b+D+/fvYVUshofabr1GycAE8VisQFQVvJx+miSJqjHPbtm1obGzEpEmTWp4zmUwYPnw4Vq1ahbPPPrvN8d999x0SEhJw8skntzn+iy++QLgu7i5kpyrT4qyvtyA+PgFRUcpshE0UqPVm9738Ksreekc+TphQiMzLZ0NjMKhdNCL1g1O0LIXs7Ow2z2dkZLR8r7U9e/agT58+sjX63HPPobKyUobs7bffLlufPaHr4Rii9tDi6823Ssx+rTjUVZuXEd/j8glr166R+28qcS616iWcsG7a8zgcKHvuOdQVFcnHaef8Bum/PY8zZw/hayY46kXV4LTZbPJWdLW2ZjQaUVdX1+74hoYG7Nu3T46L3nrrrbK1+fTTT2PmzJn46KOPkJqa2q1yaDRRSE5WplVnMimzE0N1nU3OqBWNwyED0mDU93zVoI0bf8KZZ56p2P+rGvUSjlg3h/28aLkMTbHh9HHXXY2M005Vu0hBia8ZdetF1eCMjo5uGetsvt+8lmpMTPsKEOurivAU46DNLUxx/xe/+AXeffddOamoOzweLywWX+uuu8QnHfFLs1hscLs96KmvfiqVt/2yTLA2NKFnpfNZuXIVrrnmRpjNvrHT3qB0vYQT1k17iWedDcu27Rh0/TWIyh/Qq6/VUMDXTGDrRZyjK61WVYOzuYu2qqoK+fmH15kUj4cMGdLu+KysLBmerbtlReCK7tuSkpIelcXlUuZFKH5pSpxrzfYqeVtwXKoi53O73XC5XNBodIr9v6pRL+Eo0uvGaTZDn5ws72tS0jDgoYeRmJogQzOS6+VoIv01o3a9qNpRLmbRxsfHY+XKlS3PWSwWbNmyBRMmTGh3vHhOvPlv3Lix5bmmpiY527Zv3/CZKdrkcGHLXrO8P2ZQuiLn3Lp1C4YNG6HIuYiUUvvVl9h7xy1o2LCu5TmOZ1KwU/UVKsY2xQIGCxYswOeffy5n2c6fP1+2LKdOnSpbSQcOHJDhKIwfPx4nnngibrvtNqxevRo7d+6UY51ie6xzzz0X4WLznhq43B6kJUYjN12Z8Uhev0nBNnP2wBuvo+rlf8o1ZxvXr1e7SERdpvpHO3EN54wZM3D33XfjoosukiG4bNky6PV6lJeXY/LkyXLiT7MlS5agsLAQ119/vfw5Meb50ksvyYUQwsXaHQdbWptKXToignP8+EJFzkXUE2Ihg7KlS2D+9P/kY7GEXsasP6hdLKIui/KK6x4inOgXr6np2SQEcYmHmK3a03EZt8eDeYu/lTNqb71oDIb29Y399NSFF56HFSt818X1JqXqJRxFYt24as0oXbwI9v375MzZzCtmw3TEEpCRWC9dxboJbL2kpMQF/+Qgaq/8oFWGZoxRi0F9EhU5Z2VlBTIyMhU5F1F3uSwW7H/ofrjMZmgTEpBz/Y2IGXic2sUi8huDM8g0L3qQJT75KDRJghtXUzAQYRk3qgC27duQc+N8GNIz1C4SUbcwOINMpdkXnJkpyl3IK8Y3L76YY0ikDo/TCY1eL8frM2bOkmOc2ljl1l8mirjJQdRWpdm3mlJmsnJvLDt2bMegQYMVOx9RV3jdblS99jLKnnxCzpwVorRahiaFPLY4g0zVoa7azOQYxZY1NBiM0PDaOOpFbpsN5c8+DeumDfKxdfs2xI04Xu1iESmCwRmsLc4UZT6Vr1+/DgUFYxQ5F1FXOGuq5cxZR0kxogwGZP3xSoYmhRUGZxCpa7CjrtEBceVmlkLBWVT0IycGUa9p2rsHpUsWwV1XB21iInKvvxHR/QeoXSwiRbH/Lojsrahv2bg6xqjMZxqxldiYMeMUORfR0Yhl84offViGpiE3D/l33sPQpLDkd3CKLb127doVmNJEuObgFDuiKEGsbWGzWREX1/vbiFHk0SeniIVmEXv8SPS5/S7ou7nNH1Gw87tZ8+yzz2LEiBE93jia2ttbbpG3/bMTFDnf7t07MWAAf0/UO4x98pF/+10w5OTI2bNE4crvFudxxx2HPXv2BKY0EUy0DltanNnKtDhXrSpC4RHLmREpxW1tROnihbDt3NHynLFPH4YmhT2/W5ynnnoq/v73v+Obb76Re2bGHnFNlrjI+brrrlOyjBGhtsEhJwZpoqLQJyNesYlBN998myLnImrNeeCADE1HeRkcZWXo9+DDcu1Zokjg9yv9ySeflLffffed/DoSg7Nn3bQ5aXEw6pX5xF5WVorc3DxFzkXUzLZrp1zUwF1fD11yMrKvvZ6hSRHF71e72DOTlHegzrfnaHaqMpeh1NaakZiozCLxRM3qi1aiYvnzciUgY35f5NwwD/pkZXbwIQoVPfqYuHfvXtTV1SE1NRV5eWzZ9PQaTiEp3qjI+VavLuL+m6ToGHzNf/6N6vd8W9PFFYxB9uyroImOVrtoRKERnCtWrJCXpRw4cKDluZycHNx8882YNm2akuWLGLUtwWlQbGH3adPOUeRcRPB6YS/eL+8mn34G0n53AaK4jCNFKL+D8/XXX8d9992HX/7yl5g6dapsbR48eBAff/yxDE6DwYBf/epXgSltmE8OUrLFuXnzJvzpT3coci4iEZJZV8xB4/hCJExgTwZFNr+D88UXX8TMmTNxzz33tHl++vTp8rmnnnqKwdkNYkatkKhAi9PpdMpbvV7f43NR5HJUVqDum6+Rdv7v5KQ/jdHI0CTqTnBWVFTI1mZHzjjjDLz//vtKlCvi1Nb7umoTFWhxbtmyCSO4qDb1gPXn7Sh7ajE8jY1yA+qUM85Su0hEQcPvQYqRI0fKazg7snbtWnltJ/nH4XTDancpNsbJhd2pJyw/fIeSxx+VoSnWmjWdMEntIhGFdovzmmuuwU033YTGxkace+65yMzMhNlsxueff44XXngBd955J1atWtVy/IQJE5Quc9h20+p1GsQqsLi7mFE7Y8YFCpSMIm3mbPX776Lmww/k4/hx4+W4puiiJaLD/H6X/uMf/yhv33zzTbz11ltt/uiEe++9V46HiMfiduvWrf7+ExE7ozYxziDrrKfEJULJYsFtoi7yOB2ofGE56ot+lI+Tz/o10n57PmfOEikRnC+99BIaGhoQH99+WTiLxYKmpiZkZGT4e9qIVqfgjNrS0hLk5OQqUCqKJI6SEtSvWQVotcic9QckTvmF2kUiCp/gvPTSS/HGG29g1KhR7b73448/ym7cDRs2KFW+iKDkjFpx/SYXdid/ibHMrCtmQ2dKROyw4WoXhyj0g/O2225DeXm5vC+6YEV3bEctTrGSUFpamvKlDHN1jYe7apUIziuumKNAqSjcWbdugdZkgvHQesamiZwERNQVXRrAEJeZiMBsHscUmh83f2k0GhQUFODhhx/u0j9Mh1kOtThNCgTnrl1iD87jFCgVhbO6r79CyaLH5Q4nrro6tYtDFH4tztNOO01+CZdccolscXIja+VYGp2KBKeY6RwTE6vIBCMKT16PBwffeQvmjz+Sj2OOGwRNbIzaxSIK7zHOl19+OTAliWBKddWuXbsGY8aMU6hUFG48djsqlj2Hhp/WyMcp55yL1N9M5wctIj9xE70w6qoV45uTJp2kUKkonLjqalG65AnY9+6Re2dmXnoFTJNOVLtYRCGJF2mpTIwP1x3qqk2M7Vlwrlu3FqNHj1GoZBRODrz1Lxmamvh45N50C0OTqAfY4lSZze6Cy+3pcYvT4/HA4bAjJobjVdRexoUXw2OzIf13F8KQmal2cYhCGlucQXINZ4xRC4Ne2+3z7NjxMwYN4jrB1Hah9mbauDjkXn8jQ5NIAQxOlR2obZK3KQnRPR7f5MLu1DxztmrFayh59GGYP/9U7eIQhR0Gp8rKDjbK2+y0uB7viFJYyOCMdJ6mJpQ9+QRqP/tEPvY6fD0aRKQcjnEGSXDm9jA4q6oqkZmZpVCpKBQ5a2pQtmQR7MX7EaXXy51NuPE0kfIYnCorVSA4Dx48yN1QIlzT/n1yFSB3bS20CSbkXD8XMQO5ghRRIDA4Vb4Upay65121Yv9Njm9GLnd9vRzPFN20hpwc5M6dD31autrFIgpbHONUUY3FDrvDDa0mCpnJ3b+MhDuiRDZtQoJcASh2+Aj0uf0uhiZRgDE4g6CbNislFjpt938VW7duxjBuBRVRvG43XBZLy+Ok089A7ryboY3t2Vg5ER0bgzPEZ9Q6HA5otVr5RZHBbbOhdMkilCz4G9xWq3xOrDcbpeGfM1Fv4BinisoPjW/mpMZ2+xwbN67HyJGjFSwVBTNn9UGULl4ER2kJogwG2EuKETuYC18Q9SYGp4rM9b5dUdISuz++WVTEhQ8ihW33bpQ9uQhuiwXaxCTk3jAP0f36qV0soojDvh0VmRt8wZmU0P01atesWYXx4ycoWCoKRvVrVqHksYdlaBry+iD/rj8zNIlUwhanimoPtTiT4o3dvpylvt6ChASTwiWjYGL5/jtULH9e3o8bOQrZV10DTTQX8ydSC4NTJU6XG41NLnk/OaF7wbl//z7k57PVEe5ihw+HLjkF8WPGIv2CixDFiWBEqmJwqsTc4FtDVK/TINao68H1mxzfDEdel0tuOC3okpLR95775PWaRKQ+jnGq3k1rkJcSdHdhd04MCj+Oqirsu+8eWIp+bHmOoUkUPBicKqlt6Nn4ZnNXbd++7KoNJ7YdO1D81wfgKC9D9XvvypYnEQUX1YPT4/Fg8eLFmDJlCgoKCjBnzhwUFxd36Wc/+OADDBkyBCUlJQg1tYe6ars7vikmBcXHJ3S7tUrBx7LyR5Q8/je4G+ph7NsPfW69o6W7loiCh+rBuXTpUrz22mt44IEHsGLFChmks2fPliviHE1paSnuv/9+ROqM2jVrVmPs2PEKl4rUIGZHV//7fVQ8/4xsYcaNGStDU5eUpHbRiCjYglOE4/LlyzF37lyccsopGDp0KBYuXIiKigp88olvI96OiHC95ZZbMGLECISqmvqmHgUnJwaFB6/Hg7LnnkX1++/Kx8lnnImca66Hxtj9LnwiCuPg3LZtGxobGzFp0qSW50wmE4YPH45Vq1Z1+nPPPPMMnE4nrrrqKoSqg3W+4ExPiu7Wz2/YsI5L7YUBsb6sLjkZ0GiQccllSP/dhVxzlijIqTqAIlqWQnZ2dpvnMzIyWr53pA0bNshW6ltvvYXKykrFyqLT9ezNSntod5Pm22M5UGuTt1mpcX7/2263W37FxQX/RfD+1kskaa6T7AsugGniRMRwopfE10znWDfBUS+qBqfN5gsPg6HtknNGoxF1dXXtjrdarfjTn/4kv/r166dYcGo0UUhOVmY7JpPp2GFmbXKi3uqU9wf3T0VstN6vf0N8eBg7tkCxMveGrtRLpKjbuAml73+Aobf+ST5OTIpDYkHoDjsECl8znWPdqFsvqgZndHR0y1hn833BbrcjJqZ9BTz44IPo378/LrzwQkXL4fF4YbH4tmfqLvFJR/zSLBYb3G7PUY/dV1EvbxNi9bDbHPLLH59++gVGjRoLs9m3u0ow86deIkHtN9+g7MXlotsAu157E4Muu5h1cwS+ZjrHuglsvYhzdKXVqmpwNnfRVlVVIT8/v+V58VhcZnKkt99+W7ZOx4wZIx+L7krh7LPPxtVXXy2/usvlUuZFKH5pxzpXxaHtxMSuKN35d3/88Ufcf//DipW5N3SlXsJ9ElD1e++g5qMP5eP48YVIOWuavB/pddMZ1kvnWDfq1ouqwSlm0cbHx2PlypUtwWmxWLBlyxbMmjWr3fFHzrRdv369nF373HPPYfDgwQgVB2p9E4MykrvXrVBTU420tDSFS0WB4nE4ULH8H2hYXSQfp/z6HKSe+1toDLxGkygUqfqXK1qPIiAXLFiAlJQU5Obm4rHHHkNWVhamTp0qW5Q1NTVISEiQXbl9+/Zt8/PNE4hycnKQFELXvFUdmhjUnRm1Ylw3PT0jAKWiQHDV1aHsqcVo2r1L9Cch8w+XI/GkyWoXi4h6QPWpWeIazhkzZuDuu+/GRRddBK1Wi2XLlkGv16O8vByTJ0/GRx99hHBSUtUgb7NT4rp5/eYJASgVBYKnyQZHZQU0sXHIm/8nhiZRGFC9r0gEpehuFV9HysvLw/bt2zv92YkTJx71+8HI5fZgX6VvclD/HFO3FnafOfOSAJSMAsGQmYXc6+dBmxAPQ1bby66IKDSpHpyRpuxgI5wuD2KMum6Nce7YsR2DB7efOEXBo/ar/0Gfloa4EcfLxzGDBqldJCIKp67aSLO73CJv+2cnQOPnAu1NTU3Q6w3QcGWZoJ05e+BfK1D18osof+YpOKur1S4SEQUAW5y9bE9Zc3D63027bt1aFBT4LsWh4OKx21H+j2fRuPYn+Th56pnQpaSoXSwiCgAGZy/bU+4b3xzQjeDkxKDg5KqtRemSRbDv2yu3Acu8fDZME/l7IgpX7PPrRXanG6UHfTNq+3UjONeuXYOCgrEBKBl1l714P/Y/dL8MTW18AvJuvo2hSRTm2OLsRdV1TfB6IScG+buBtdiz0WptlAtGUPCo/foruMw1csZsztz5MGTwGluicMfg7EXVFt+KQakm/xc+2LNnFwYMGBiAUlFPZFxwETTR0Ug5cxq0caGz6D4RdR+7alUJTv83KS4qWokJE7hxtdq8bjdqv/pSzqAVxJhm+vm/Y2gSRRAGZy931QqpidHdmhjE4FR/FaCyJ59A1cv/xIF/va52cYhIJeyq7UU1PeiqLS0tQV5enwCUirrCWVON0sWL4CgpRpRej5hBobOpABEpi8EZAi3O2lozEhMTA1QqOpamvXvk5SbuujpoTSbkXD8PMQMGqF0sIlIJg1OFMc4UP1uca9aswvjxhQEqFR1Nw9o1KH/+WXgdDhhy85A7dx70qdzSjSiSMTh7idvjgbne0a2uWjG+eeaZvw5Qyagz7vp6lP/jeRmascePRPZV10Ib0709VIkofHByUC+psdjh8Xqh00YhMd7g189u2rQRI0aMDFjZqGPahARkz56DxFN/idwb5jE0iUhii7OXlFc3ytuslFi/Fnd3uVxy8QOxPykFnttqlQsaGHPz5OP4MePkFxFRM7Y4e0nZQau8zUnz73q/zZvZ2uwtzoMHUPzIgyh5/FE4qw+qXRwiClJscfbiPpxCdmpcN67f5MSgQLPt2omyJxfDXW+BNikJHqsNSFW7VEQUjBicvdxV62+Lc/XqIpx//u8DVCoS6lcVoWL58/A6nTD2yUfODfOg55ZgRNQJBmcvEGOUZYeCMzs11q+fra2tRXIy38QD9Xup+ehDVL/7tnwcN7oA2XOulmvPEhF1hsHZC2obHLDZ3XJSUGZyrF+rBeXk5Aa0bJGs7n9ftIRm0q+mIv33FyJKw2F/Ijo6BmcvaG5tZiTHQK/T+NVNy/VpA8d04mTUffctEk+ajKRTf6l2cYgoRPDjda9ODPKvm7ao6EcGp8JctbWyi1bQGI3Iv+NuhiYR+YXB2QvKq7t3KcquXTsxcOBxASpV5LH+vB17/3IXav7z75bnorRaVctERKGHwdmLLc4cPy5FaWxsRHR0DKL8WCyBOmf54XuU/v0xeBob0bh+Hbwul9pFIqIQxTHO3phR2xycfrQ41637CWPHcsUaJeq/+oP3UPPv9+Xj+HHjkXXFHLkBNRFRd/DdI8DM9XY02JxyRm1OWqxfCx+ccMKJAS1buPM4Hah8YTnqi36Uj5PPnIa082Zw5iwR9QjfQQJsf2WDvBWhqdd1fTxt7dqfMHr0mACWLLx5PR6ULvq7LzS1WmT+4XKkz/g9Q5OIeowtzgDbX1kvb/tkJHT5ZzweDxwOO2K4G0e3iYA0TZwEe/F+5FxzPWKHDVe7SEQUJhicAba/ytfi7JsZ3+Wf2blzB447bnAASxW+xKSf5vHLxJN/gbgxY6BLMKldLCIKI+y36qUWZ35mgl/XbxYW8vpNf9V9+zX23ftnuQF1M4YmESmNwRlA1iYnDtY1yfv5frQ4fTuiMDj9Gc888PabqHxxORwV5aj96ku1i0REYYxdtQFUabbJ28R4A2Kju74RdUVFObKysgNYsvDhsdvlziYNa1bLxynnnIuUX5+jdrGIKIwxOAOoxmKXt6mmru+2UV1djZQUbgTZFa66WrmHZtOe3XLmbNZlV8A06SS1i0VEYY7BGUA19b5u2pQEY5d/hgu7d43oki35+wK4aqqhiYtDznVzETt4iNrFIqIIwDHOAKqxHApOP1qcXNi9a7TxCXL2rD4zC/l3/pmhSUS9hi3OXuiq9Sc4t27djDvvvCeApQoP2vh45M67GdrYWHmfiKi3sMUZRF21DocDWq1WflH7mbNVb7yO2q/+1/KcISODoUlEvY4tziBqcW7cuB7HHz8qwKUKPZ6mJpT/41k0rlsrJwHFjRgBfVq62sUiogjF4AwQt8eD2obm4DR2+frNwsITAlyy0OI0m1G2ZBHs+/fJMU2xswlDk4jUxOAMkNp6B7xeQKuJginO0KWfWbNmNWbOvCTgZQsVTfv3ydB0mc3QJiQg5/obEcONvYlIZQzOAKk+NKM2OcEotxTryr6RFksdTKbEXihd8GtYtxblzz8Dr90OQ3YOcufOhz6dLU0iUh+DM9ATg7o4vllcvB/5+f0CXKrQ4SgrlaEZO2wEsq+5FtrYrm8CTkQUSAzOAHbVNrc4u379ZmGASxU6ks/6NXRJyUgonNiy2wkRUTDg5SgB0jwxKCm+a+ObkT4xyG2zoWrFq3IGrRAVFQXTiScxNIko6PBdKeDB2bUW5759e9G3b2R21TqrD6J08SI4Skvgqq1DztXXql0kIqJOMTgDpLbB0eXgbGioR1xcvGxlRRqxQHvpkkVwWyzQJiYi5cyz1C4SEdFRMTiDoKtWXIYybtwERJr6NatRsew5eB0OGPL6IHfuPOi5MwwRBTkGZwCIS0vqmlucXZgcJCYGnXLKaYik+jF//F8cfPtf8nHcyFHIvuoaaKJj1C4aEVFoTA7yeDxYvHgxpkyZgoKCAsyZMwfFxcWdHr9jxw5ceeWVmDhxIiZNmoS5c+eirKwMwaLJ4Ybd6Zb3k+KMXVpqb9SoAkQKT2MjzJ/9n7yfdNqv5MIGDE0iChVBEZxLly7Fa6+9hgceeAArVqyQQTp79my56PmRzGYzLr/8ckRHR+Pll1/G888/j5qaGnm83e7rHg2WbtoYow5Gw9EXbHe73XC5XDAau75nZ1jsbHLDPKTPnIWMmbMQxUXtiSiEqB6cIhyXL18uW42nnHIKhg4dioULF6KiogKffPJJu+M/++wzWK1WPProoxg8eDCOP/54PPbYY9i1axd++uknBIPa+q6Pb27bthVDhgxDuHNUVaFx04aWx9H9+iP5tF+pWiYiopAMzm3btqGxsVF2uTYzmUwYPnw4Vq1a1e54cZxooYoWZzONxve/YbFYEGozaiPh+k3Ltu3Y88B9KFv6JJr27lG7OEREoT05SLQshezs7DbPZ2RktHyvtby8PPnV2nPPPSeDdMKE7s9M1el69hlCq9W03FqsjpZdUY513jVrinD//Q/1+N8PVvVFK1Hy/HPwOp2I7tsPxtSUsP1/7clrhg5jvXSOdRMc9aJ6cNpsNnlrMLTt1hRjfnV1dcf8eTHO+corr+Duu+9GSkpKt8qg0UQhOVmZtVBNphjYXB55Pyst/pjnraszY/Dg/gjHmbMlb76N4ldfl49TJk7A4JvmQduqp4AOv2aoPdZL51g36taL6sHZ3OUqxjpbd7+KiT4xMTFHfWN+4okn8PTTT+Oaa67BJZd0fzsuj0fsTGJFT4hPOuKXZrHYUG32nUuviYLZ3Njpz1RWViI5OfWox4Qij9OJ8heWo+777+TjnOm/QcpvZ8BicwO28Pp/Veo143b7PmwR6+VoWDeBrRdxjq60WlUPzuYu2qqqKuTn57c8Lx4PGTKkw59xOp2444478OGHH8rbyy67rMflcB1qJfaU+KXVW53yfoxBe9Tz/vDDDxg3rlCxfztYmL/80heaGg2yL/kD+p93jvxwEG7/n0oRrxnWTXusl86xbtStF9U7ysUs2vj4eKxcubLlOTHJZ8uWLZ2OWd566634+OOP8fjjjysSmkprbPIFZ1yM/pgTgyZMmIhwk3TKaUg4YRJyb7wJyadGzsIORBQZVG9xirHNWbNmYcGCBXKMMjc3V15ekpWVhalTp8rrHMV1mgkJCbIr95133sFHH30kw7OwsBAHDhxoOVfzMWprtLnkbVz00av355+3YciQoQgHYrasMa+P3M0kSrQ0Z1+ldpGIiMKzxSmIazhnzJghJ/hcdNFF0Gq1WLZsGfR6PcrLyzF58mQZloLonhXEdZzi+dZfzceEQouzqakJer2h5VKaUGb5/jvsf/hBVL70ghx7JiIKZ6q3OAURlLfccov8OpK49GT79u0tj8ViCcFMBMfhFmfnwbl+/ToUFIxBKPN6PKh+/13U/Off8rFHrPTkdotre9QuGhFRwPAdLgDr1HoOtbqO1lUb6uObHqcDlcv/gfpVRfJxyrSzkTr9PNlNS0QUzvgup7AGm6+bVq/TwKDvfA3Wn35ajTFjxiEUuSwWlCx41BeaWi0yL/8j0s6bwdAkoojAFqfCGg8F59Fam6I712ptlLOJQ7F7tnTR47Dv3wdNbCxyrr0BsUPDf61dIqJmbCIEqMV5tIlBe/bsQv/+AxCKRKsybcbvYcjKRv6df2ZoElHEYYtTYY1Nx54YVFQUeuObrrpa6BKT5P244SMQe9+D3A6MiCISW5wKszT6FniPP0qLc9WqopDZEUV0zR548w3s/fNdcFSUtzzP0CSiSMUWp8JqLE3yNiWh8y3FSkuLkZvbdoeXYOSx21Hxj+fQsHaNfGzdsll20RIRRTIGp8Kqm4PT1PEKRnV1tXK/0aioKAQzV20tSpcsgn3fXrkakJg5a5p4eM9UIqJIxeBUWI3F3rIXZ0fWrFmF8eMLEczsxcUoXbwQLnMNNPHxyL1uLmIGDVa7WEREQYHBGbCu2o5bnEVFP+KMM6YhWDXt24viRx+B194EfVYWcufeBENGhtrFIiIKGpwcpCC3xwtz/dFbnJs2bcTxx49CsDLk5CI6Px8xQ4ch/44/MzSJiI7AFqeCauubZHiK4cvEeEO777tcLrn4gVi8PthmzjZfo6nR65Fzw43QGIxybJOIiNpii1NBB2pt8jYp3ghtB8vPbdmyCcOHH49g4mmyoezJJ3Dw7TdbntPGxjE0iYg6weBUUPnBRnmbmRzT6cLuhYXBs/CBs6YGxX/7Kxo3rEftF5/BefDw3qZERNQxBmcAgjPjKMEZLDNqm/buxf6H7pczaLUJJuTdcjv0aelqF4uIKOixPy4gwRnb4fdra2uRnJwCtTWs/Qnlzz8Dr8MhJwPl3jgf+tQ0tYtFRBQSGJyBCM6k9i3OsrJSZGfnQG3mzz/FgRWviS1aEDvieGRfdS20sR0HPRERtcfgVFDZUbpqg2Xjap0pUYZm4i9ORcbMWVxzlojITwxOBffhrLf6FnjP7KCrVgTnZZfNhtoSJhRCl5qG6P79g37ZPyKiYMTJQQqpNDdfimKA0dC+Fbdz5w4MHHhcr5dLzJQtWbhAzqBtFjNgAEOTiKibGJwKqTJbO21tNjY2Ijo6ptfDyrZ7F/Y/9ACsmzeh6uUXe/XfJiIKV+yqVUhljS84M1Laj2+uX78WY8eO69Xy1K8uQsWy5+F1OmHsk4+MSy7r1X+fiChcMTgVcrDOt7h7egczasXC7hN7aUsusaSf+b//wcF33pKP40aNRvaV10AT3fGi80RE5B921SrE7nDL2xhj+88ia9f+hIKCsQEvg9flQuWLy1tCM+mXpyPn+hsZmkRECmKLUyEOl2+hdIOu7WcRj8cDh8OOmJiOVxNSktfllNuCiVXmMy66GEmn/Srg/yYRUaRhcCrEeSg49UcEp5hNe9xxg3qlDJroGOTeMA+O8jLEHT+yV/5NIqJIw65ahThcvq5ag07bwcLuJwTs37X+vF0u0N5Mn5rK0CQiCiAGZ4BbnGJiUKBWDLL88D1K//4Yql5/FY2bNwXk3yAiorbYVasQh9PdYXBWVJQjKytb8Zmz1R+8h5p/vy8fx48dh5he6g4mIop0DE6FW5wG/eGu2urqaqSkpCr673icDjlztn7lj/Jx8pnTkHbeDER1sHE2EREpj8Gp8Kza1i3O1auLFN1/01VvQdlTS9C0cweg1SLj4kuQdPIpip2fiIiOjc2UAF6OovTEoMYNG2RoamJikHvjTQxNIiIVsMWpEGcHs2q3bt2M22+/W7F/I/GkyXDX1SKuYAyMObmKnZeIiLqOLU6FJus4nW27ah0OBzQaDXS6nn02qS9aCXdDQ8vjlGlnMzSJiFTE4FSA2+OF99D95uDctGkDjj9+VLfP6fV45NJ55c89jbKnn5TL6RERkfrYVatQcDbTaqN6fP2mx+FAxbLn0LBmtXwcM2gwwFmzRERBgcGpAE+r4NQc2nNzzZrVmDnzEr/P5aqrQ9mTT6Bpz245czbr0itgOvEkRctLRETdx+BUuMWp0UTB6/Givt4CkynRr/PYS0tQunghXNXV0MTFIee6uYgdPCQAJSYiou5icCrA420bnHv37UNeXr7fE4wq/vGsDE19RiZyb5wPQ2ZWAEpLREQ9weBUsKtW9NKKrlrf9Zv+jW9GRUUha87VckJQ1mV/hDY+PkClJSKinuCMEwWDU6vxjW+K4OzKxCAxc9a2e3fLY3GZSe71NzI0iYiCGINTweAU120Ke/fuQb9+/Y/+M01NKFu6BMV/ewjWbVt7pZxERNRz7KpVgPvQGKdWA9TX1yMuLl52vXbGaTajbMki2PfvQ5RO12aBAyIiCm4MToVbnOIylLFjx3d6bNP+fTI0XWYztPEJyLl+LrcEIyIKIQxOJScHAfhx5Q84ecqpHR7XsH6dXAnIa7fDkJWNHDFzNj2jl0tLREQ9wTFOBa/jFL2z69etw+jRBe2Ose3eJRc2EKEZO2w4+tx5N0OTiCgEscWpgMOXcXrgcrtgNBrbHRPdfwASCiciymBA5sV/kGObREQUevjurWCLs/5gMYYMGXr4eZsNURoNNEaj7zrNK+bINWePNnGIiIiCm+pdtR6PB4sXL8aUKVNQUFCAOXPmoLi4uNPjzWYzbr75ZkyYMAGFhYW47777YLPZoCax6o9wsGQrxo/3Xb/prK5G8SMPycXaxfWaQpRWy9AkIgpxqgfn0qVL8dprr+GBBx7AihUrZJDOnj1b7mfZkblz52Lfvn148cUX8cQTT+Crr77CvffeCzX1yYjHkPwkoGEvxo8vRNPePdj/1/vhKC2BbddOuMw1qpaPiIjCJDhFOC5fvlyG4SmnnIKhQ4di4cKFqKiowCeffNLu+LVr16KoqAh/+9vfMGLECEyaNAn3338/3n//fVRWVkItBr0Wf7poDAywIqakGMWPPgx3XR0MuXnIv/Me6FPTVCsbERGFUXBu27YNjY2NMgCbmUwmDB8+HKtWrWp3/OrVq5Geno6BAwe2PCe6a0X355o1a6CmqqpKmBwOVD7zFLwOB2KPH4k+t98FfWqqquUiIqIwmhwkWpZCdnZ2m+czMjJavteaaFUeeazBYEBSUhLKy8uhpi+XLMLQhnogLR2Jp56GjAsvlmOaREQUXlQNzuZJPSL8WhOXc9TV1XV4/JHHNh9vt9t7VBadrmeNb1dGJsbn5CL9oouRNnUqJwEdohXrELa6pcNYNx1jvXSOdRMc9aJqcEZHR7eMdTbfF0QIxsTEdHh8R5OGxPGxsbHdLofYQzM5OQ49ceO9d6O6tAqpuRnQ8UXdjsnU/vdJPqybjrFeOse6UbdeVA3O5m7Xqqoq5Ocf3vhZPB4yZEi747OysvDZZ5+1eU4EaW1treze7cmSeRaLFT0hPulk5mfBYrHB7fZdfkK+ehEvZtZLe6ybjrFeOse6CWy9iHN0pdWqanCKWbTx8fFYuXJlS3BaLBZs2bIFs2bNane8uHZzwYIF8nKUvn37yufELFth3LhxPSqLy6XMi1D80pQ6VzhhvXSOddMx1kvnWDfq1ouqwSnGK0VAijBMSUlBbm4uHnvsMdmynDp1KtxuN2pqapCQkCC7aUePHo2xY8di/vz58tpNq9WKe+65B9OnT0dmZqaa/ytERBQhVB+ME9dwzpgxA3fffTcuuugiaLVaLFu2DHq9Xs6UnTx5Mj766CN5rJhw8+STTyIvLw+XXnop5s2bh5NPPln1BRCIiChyRHmb14uL8OZ9TU1jj2fliglGZnMju1BaYb10jnXTMdZL51g3ga2XlJS4Lo1xqt7iJCIiCiUMTiIiIj8wOImIiPzA4CQiIvIDg5OIiMgPDE4iIiI/MDiJiIj8wOAkIiLyAxdAACCqQCz03lPiwlkuvNwe66VzrJuOsV46x7oJXL2InbK6siUkg5OIiMgP7KolIiLyA4OTiIjIDwxOIiIiPzA4iYiI/MDgJCIi8gODk4iIyA8MTiIiIj8wOImIiPzA4CQiIvIDg5OIiMgPDE4iIiI/MDiJiIj8wOAkIiLyA4OzizweDxYvXowpU6agoKAAc+bMQXFxcafHm81m3HzzzZgwYQIKCwtx3333wWazIdLrZceOHbjyyisxceJETJo0CXPnzkVZWRnCkb9109oHH3yAIUOGoKSkBJFeL06nE48//njL8bNmzcLWrVsRjvytm+rqavk+c8IJJ8i/qfnz56OyshLh7Nlnn8Ull1xy1GMC/v4rthWjY1uyZIl34sSJ3i+//NK7detW7xVXXOGdOnWq1263d3j8rFmzvOeff75306ZN3u+//9576qmnem+99VZvJNdLTU2N96STTvLecMMN3u3bt3s3btzovfjii71nnXWWt6mpyRvpr5lmJSUl3nHjxnkHDx7sLS4u9kZ6vdx5553eE0880fv11197d+7cKV8/4nVksVi84aY77zMXXnihd8uWLd7Nmzd7f//738v3nXD1yiuveIcOHSr/v48m0O+/DM4uEC/aMWPGeF999dWW5+rq6ryjRo3y/vvf/253/E8//STf9MQfebNvvvnGO2TIEG9FRYU3UuvlX//6lzzeZrO1PFdWVibrSry4w4m/ddPM7XZ7L7roIu8f/vCHsAxOf+tl//798u9GBEnr48UbYaS/ZsT3xGvk888/b3nus88+k8+ZzWZvOKmoqPBeddVV3oKCAu+ZZ5551ODsjfdfdtV2wbZt29DY2Ci7FpuZTCYMHz4cq1atanf86tWrkZ6ejoEDB7Y8J7oLxM7ia9asQaTWizhu6dKliI6ObnlOo/G9BC0WC8KJv3XT7JlnnpFdk1dddRXCkb/18t133yEhIQEnn3xym+O/+OKLNueIxLoRf0dxcXF477330NDQIL/ef/999O/fX/5cONm8eTP0er0cwhg9evRRj+2N91+dImcJcxUVFfI2Ozu7zfMZGRkt32tNjDEceazBYEBSUhLKy8sRqfWSl5cnv1p77rnn5BuAGIsIJ/7WjbBhwwYsX74cb731VtiOU/lbL3v27EGfPn3wySefyNeKqBcRJLfffnubN8ZIrBvxnvLII4/gnnvuwfjx42UwiGNfeeWVlg+k4eK0006TX13RG++/4VW7AdI8qCwqvzWj0Qi73d7h8Ucee7TjI6VejvTyyy/LP/I//elPSElJQTjxt26sVqusB/HVr18/hCt/60W0ovbt2yd7Km666SY8/fTT0Ol0mDlzppwYE8l1I4baxCSpMWPG4NVXX8U///lP5OTk4Nprr5X1FqlsvfD+y+DsguauRYfD0eZ58UuIiYnp8Pgjj20+PjY2FpFaL63/4BctWoQHH3wQ11xzzTFnyEVC3Yi6EF1sF154IcKZv/UiQlKEwMKFCzF58mSMGjVK3hfeffddRHLd/Pe//5UfPB977DGMGzdOdkeKrv7S0lLZaxGponvh/ZfB2QXNzf6qqqo2z4vHmZmZ7Y7Pyspqd6z4RdbW1squlEitF0GM391yyy3yD/yOO+7AvHnzEI78rZu3334b33//vWw9iC9xGYJw9tlny7qK5L8lEZ6tu2XFG6Povg23S3X8rRsxlic+bMXHx7c8l5iYKJ8TrfRIldUL778Mzi4YOnSofHGuXLmy5TkxmWXLli0djs2J58SYROsXb1FRkbwVnwwjtV6EW2+9FR9//LG8Lu+yyy5DuPK3bsQY3ocffigneogv0QIVxLheOLVCu/O35HK5sHHjxpbnmpqa5LWNffv2RTjxt25EQIj3mNbdj6LLX3ygCOfu/mPpjfdfTg7qAtFfLi66XrBggRyLy83Nld0j4oU7depUuN1u1NTUyNl/4tOwmPU1duxYeTHyvffeK1/MYgB/+vTpnbbEIqFe3nnnHXz00UcyPEW30oEDB1rO1XxMpNbNkSHQPBlEjFmJSQ2RWi9i0suJJ56I2267Dffff7+sC7FAgFarxbnnnotw4m/diPeTZcuWyV6bG2+8UZ5DDIGIsbzzzjsPkcKtxvuvIhe1RACXy+V99NFHvSeccIK8lmjOnDkt19iJW3Hd0Ntvv91y/MGDB+WF2uJYcUHzX/7yl7C8yN+fern88svl446+WtddpL5mWvvxxx/D8jrO7tRLfX29/PsRf0ejR4+Wr6MdO3Z4w5G/dSOuVRTXNxYWFsqfuf7668PyNdPabbfd1uY6TjXef6PEf5SJYCIiovDHMU4iIiI/MDiJiIj8wOAkIiLyA4OTiIjIDwxOIiIiPzA4iYiI/MDgJCIi8gODkygCiJWILr74YowcOVLu99i8EwcR+Y9L7hFFALHl1Lp16+QSbmLZsaPtXkNER8fgJIoAzTtDTJs2Te2iEIU8dtUShbnTTjtNLrBfVlaGIUOGyP1Pxe23334ru2/FHpdiEfHXXnutzc+JY5588km5YLg4RtwnIoBr1RKFObEtldg1Q9yK8BPbLYkdakwmk9wx4uSTT8bnn3+O119/HX/5y18wc+bMluDU6/W4+eab5R6PYreOQYMGqf2/Q6Q6dtUShbnhw4fLbarEtlUFBQUt+zeefvrpuOuuu+T9KVOmyM1/ly5diosuughRUVHyebGt1+WXX65q+YmCDbtqiSLUb3/72zaPRXet2CN1z549Lc8NGzZMhZIRBTcGJ1GEOnJT39TUVHlbV1fX8lxsbGyvl4so2DE4iSKU2Wxu87i6urpNgBJRxxicRBHqs88+a/P4448/lhOA8vPzVSsTUSjg5CCiCPXCCy/AaDTKCUOffPIJvvzySzz++ONqF4so6DE4iSLUnXfeiXfffRfPPvssBgwYgMWLF+OMM85Qu1hEQY/BSRQBHnnkkXbPDRw4EG+++WanP7N9+/YAl4ooNHGMk4iIyA8MTiIiIj9wyT0iIiI/sMVJRETkBwYnERGRHxicREREfmBwEhER+YHBSURE5AcGJxERkR8YnERERH5gcBIREfmBwUlERISu+38zxzshKdj7awAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "## calc best_fpr and best_tpr\n", "auc_arr = (tpr_arr - fpr_arr + 1) / 2\n", "max_auc = max(auc_arr)\n", "best_tpr = tpr_arr[auc_arr == max(auc_arr)][0]\n", "best_fpr = fpr_arr[auc_arr == max(auc_arr)][0]\n", "best_th = thresholds[auc_arr == max(auc_arr)][0]\n", "\n", "plt.figure(figsize=(5,4.5))\n", "sns.lineplot(x=fpr_arr, y=tpr_arr)\n", "plt.xlabel('fpr')\n", "plt.ylabel('tpr')\n", "ls = np.linspace(0, 1, 100)\n", "plt.plot(ls, ls, color='r', linestyle='--')\n", "plt.plot([0, best_fpr], [0, best_tpr], color='black', lw=0.5)\n", "plt.plot([best_fpr, 1], [best_tpr, 1], color='black', lw=0.5)\n", "plt.annotate('O', (best_fpr, best_tpr), ha='center', va='center')\n", "x1 = best_fpr - 0.15\n", "x2 = best_fpr + 0.1\n", "y1 = best_tpr - 0.15\n", "y2 = best_tpr + 0.1\n", "plt.plot([x1, x2], [y1, y2], color='r', linestyle='--');" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "best auc : 0.881685619002347\n", "best threshold : 0.41\n" ] } ], "source": [ "print('best auc :', max(auc_arr))\n", "print('best threshold :', thresholds[auc_arr == max(auc_arr)][0])" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.30455787062978196\n" ] } ], "source": [ "## log_loss\n", "from sklearn.metrics import log_loss\n", "print(log_loss(y_test_n, y_pred_p))" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[0. 0.98 0.02]\n", " [0. 0.98 0.02]\n", " [0. 0. 1. ]\n", " [1. 0. 0. ]\n", " [0. 0.98 0.02]]\n", "0.10952457826611424\n" ] } ], "source": [ "## also applicable to multiclass models\n", "## see https://scikit-learn.org/stable/modules/model_evaluation.html#log-loss\n", "## example of a multi class classification\n", "iris_data = sns.load_dataset('iris')\n", "iris_X = iris_data.drop('species', axis=1)\n", "iris_y = iris_data['species']\n", "from sklearn.model_selection import train_test_split\n", "iris_X_train, iris_X_test, iris_y_train, iris_y_test, = train_test_split(\n", " iris_X,\n", " iris_y,\n", " train_size=2/3,\n", " random_state=1234)\n", "\n", "from sklearn.ensemble import RandomForestClassifier\n", "model = RandomForestClassifier(random_state=1234)\n", "model.fit(iris_X_train, iris_y_train)\n", "iris_y_pred_p = model.predict_proba(iris_X_test)\n", "print(iris_y_pred_p[0:5,:])\n", "\n", "#iris_y_pred_p\n", "from sklearn.metrics import log_loss\n", "print(log_loss(iris_y_test, iris_y_pred_p))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Performancemetriken - Regression\n", "#### Vorbereitung" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [], "source": [ "## import libraries\n", "import pandas as pd\n", "import seaborn as sns\n", "import matplotlib\n", "import numpy as np\n", "import matplotlib.pyplot as plt; sns.set()\n", "%matplotlib inline\n", "\n", "## load data\n", "datapath = '../3_data'\n", "from os import chdir; chdir(datapath)\n", "\n", "from bfh_cas_pml import prep_data\n", "X_train, X_test, y_train, y_test = prep_data('melb_data_prep.csv', 'Price', seed = 1234)\n", "\n", "from sklearn.tree import DecisionTreeRegressor\n", "model = DecisionTreeRegressor()\n", "model.fit(X_train, y_train)\n", "y_pred = model.predict(X_test)" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " y_test y_pred\n", "18178 3400000.0 901000.0\n", "16248 3625000.0 2100000.0\n", "7472 565000.0 580000.0\n", "11719 2525000.0 1680000.0\n", "5228 1350000.0 1200000.0\n" ] } ], "source": [ "print(pd.DataFrame({\n", " 'y_test': y_test,\n", " 'y_pred': y_pred\n", "}).head())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Einige Scorer im Überblick" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "169124790914.51215\n" ] } ], "source": [ "## mean_squared_error (mse)\n", "from sklearn.metrics import mean_squared_error\n", "print(mean_squared_error(y_test, y_pred))" ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "411247.8460910308\n" ] } ], "source": [ "## root_mean_squared_error (mse)\n", "from sklearn.metrics import root_mean_squared_error\n", "print(root_mean_squared_error(y_test, y_pred))" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "244061.39297558853\n" ] } ], "source": [ "## mean_absolute_error (mae)\n", "from sklearn.metrics import mean_absolute_error\n", "print(mean_absolute_error(y_test, y_pred))" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.22599557388412617\n" ] } ], "source": [ "## mean_absolute_percentage_error (mape)\n", "from sklearn.metrics import mean_absolute_percentage_error\n", "print(mean_absolute_percentage_error(y_test, y_pred))" ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.08469851350303957\n" ] } ], "source": [ "## mean_squared_log_error (msle)\n", "from sklearn.metrics import mean_squared_log_error\n", "print(mean_squared_log_error(y_test, y_pred))" ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "140000.0\n" ] } ], "source": [ "## median_absolute_error (medae)\n", "from sklearn.metrics import median_absolute_error\n", "print(median_absolute_error(y_test, y_pred))" ] }, { "cell_type": "code", "execution_count": 48, "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.5768009946090255\n" ] } ], "source": [ "## r2_score (r2)\n", "from sklearn.metrics import r2_score\n", "print(r2_score(y_test, y_pred))" ] } ], "metadata": { "kernelspec": { "display_name": "teaching", "language": "python", "name": "teaching" }, "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.13.0" }, "toc": { "base_numbering": "4.4", "nav_menu": { "height": "189px", "width": "303.333px" }, "number_sections": true, "sideBar": true, "skip_h1_title": false, "title_cell": "4.4 Validierung und mehr - Performance Metriken", "title_sidebar": "Contents", "toc_cell": true, "toc_position": { "height": "calc(100% - 180px)", "left": "10px", "top": "150px", "width": "208.667px" }, "toc_section_display": true, "toc_window_display": true }, "toc-autonumbering": true, "varInspector": { "cols": { "lenName": 16, "lenType": 16, "lenVar": 40 }, "kernels_config": { "python": { "delete_cmd_postfix": "", "delete_cmd_prefix": "del ", "library": "var_list.py", "varRefreshCmd": "print(var_dic_list())" }, "r": { "delete_cmd_postfix": ") ", "delete_cmd_prefix": "rm(", "library": "var_list.r", "varRefreshCmd": "cat(var_dic_list()) " } }, "position": { "height": "298.85px", "left": "783px", "right": "20px", "top": "119px", "width": "350px" }, "types_to_exclude": [ "module", "function", "builtin_function_or_method", "instance", "_Feature" ], "window_display": false } }, "nbformat": 4, "nbformat_minor": 4 }