{ "cells": [ { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "# Single Objective Optimization with Credit Risk Analysis " ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "%%capture\n", "#Cell magic to hide outputs \n", "\n", "#Install dependencies\n", "from io import StringIO\n", "import os\n", "import time\n", "import sys\n", "import IPython\n", "from time import gmtime, strftime\n", "\n", "import boto3\n", "import numpy as np\n", "import pandas as pd\n", "import urllib\n", "\n", "import sagemaker\n", "from sagemaker.s3 import S3Uploader\n", "from sagemaker.processing import ProcessingInput, ProcessingOutput\n", "from sagemaker.sklearn.processing import SKLearnProcessor\n", "from sagemaker.inputs import TrainingInput\n", "from sagemaker.xgboost import XGBoost\n", "from sagemaker.s3 import S3Downloader\n", "from sagemaker.s3 import S3Uploader\n", "from sagemaker import Session\n", "from sagemaker import get_execution_role\n", "from sagemaker.xgboost import XGBoostModel\n", "from sagemaker.sklearn import SKLearnModel\n", "from sagemaker.pipeline import PipelineModel\n", "from sagemaker.inputs import TrainingInput\n", "\n", "\n", "session = Session()\n", "bucket = session.default_bucket()\n", "prefix = \"sagemaker/sagemaker-amt-credit-risk-model\"\n", "region = session.boto_region_name\n", "\n", "# Define IAM role\n", "role = get_execution_role()" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "## Train XGBoost Model\n", "In this step, we will train an XGBoost model on the preprocessed data. We will use our own training script with the built-in XGBoost container provided by SageMaker.\n", "\n", "Alternatively, for your own use case, you can also bring your own model (trained elsewhere) to SageMaker for processing with SageMaker Clarify\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Set up XGBoost Estimator\n", "\n", "Next, let us set up: \n", " 1. Pre-defined values for Hyperparameters for XGBoost algorithm\n", " 1. XGBoost Estimator for SageMaker\n", "\n", " " ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "hyperparameters = {\n", " \"max_depth\": \"5\",\n", " \"eta\": \"0.1\",\n", " \"gamma\": \"4\",\n", " \"min_child_weight\": \"6\",\n", " \"silent\": \"1\",\n", " \"objective\": \"binary:logistic\",\n", " \"num_round\": \"100\",\n", " \"subsample\": \"0.8\",\n", " \"eval_metric\": \"auc\",\n", " \"early_stopping_rounds\": \"20\",\n", " \"output_data_dir\": \"/opt/ml/output/data/\",\n", "}\n", "\n", "entry_point = \"train_xg_amt_single.py\"\n", "source_dir = \"training/\"\n", "output_path = \"s3://{0}/{1}/{2}\".format(bucket, prefix, \"xgb_model\")\n", "code_location = \"s3://{0}/{1}/code\".format(bucket, prefix)\n", "\n", "estimator = XGBoost(\n", " entry_point=entry_point,\n", " source_dir=source_dir,\n", " output_path=output_path,\n", " code_location=code_location,\n", " hyperparameters=hyperparameters,\n", " instance_type=\"ml.c5.xlarge\",\n", " instance_count=1,\n", " framework_version=\"0.90-2\",\n", " py_version=\"py3\",\n", " role=role,\n", ")" ] }, { "cell_type": "markdown", "metadata": { "tags": [] }, "source": [ "### SageMaker AMT (HPO)\n", "\n", "Now it's time to run the HPO job to train and find the best model \n", "\n", "#### NOTE: THIS CELL WILL RUN FOR APPROX. 5-8 MINUTES! PLEASE BE PATIENT." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "#Retrieve variables stored in first notebook \n", "%store -r train_data_path\n", "%store -r val_data_path\n", "%store -r model_path" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "No finished training job found associated with this estimator. Please make sure this estimator is only used for building workflow config\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "...................................................................................!\n", "!\n" ] } ], "source": [ "# Automatic Model Tuning (HPO)\n", "from sagemaker.tuner import IntegerParameter, CategoricalParameter, ContinuousParameter, HyperparameterTuner\n", "\n", "hyperparameter_ranges = {'eta': ContinuousParameter(1e-3, 1, 'Logarithmic'),\n", " 'min_child_weight': ContinuousParameter(1e-6, 10, 'Logarithmic'),\n", " 'gamma': ContinuousParameter(1e-6, 10, 'Logarithmic'),\n", " 'max_depth': IntegerParameter(2, 10, 'Linear')}\n", "\n", "objective_metric_name = 'validation:auc'\n", "\n", "tuner = HyperparameterTuner(estimator,\n", " objective_metric_name,\n", " hyperparameter_ranges,\n", " max_jobs=100, # 100\n", " max_parallel_jobs=10, #16\n", " )\n", "\n", "tuning_job_name = \"xgb-tuner-{}\".format(strftime(\"%d-%H-%M-%S\", gmtime()))\n", "\n", "inputs = {'train': train_data_path, 'validation': val_data_path}\n", "\n", "tuner.fit(inputs, job_name=tuning_job_name)\n", "\n", "tuner.wait()\n", "\n", "tuner_metrics = sagemaker.HyperparameterTuningJobAnalytics(tuning_job_name)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### The best Area Under Curve (AUC) score, alongside the Disparate Impact was found by going into the SageMaker logs where they are saved. You can find the logs by following the image guide below" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the SageMaker console page navigate the left menu and find Training -> Hyperparameter Tuning Jobs. That will bring up all the recent Tuuning jobs and you can click the latest one. \n", "![Step1](images/Step1A.jpg)\n", "\n", "Scrolling down the tuning job page will bring you to “Best training job summary”. Here you can see the name of the best training job and the optimized value of the metric specified. In this case you can see that the AUC value is optimized at 0.91. Click on the best training job name.\n", "![Step2](images/Step2A.jpg)\n", "\n", "Scrolling down the page of the best training job, you will find a section under “Monitor” called “View logs”. Click on this to take you to CloudWatch logs.\n", "![Step3](images/Step3A.jpg)\n", "\n", "Scrolling down this current page you will encounter a section called “Log streams”. Click the name of your training job under this section.\n", "![Step4](images/Step4A.jpg)\n", "\n", "On this current page we can scroll all the way down and view all of the values the AI model has tried, the final values are at the bottom and are the optimized ones. \n", "![Step5](images/Step5A.jpg)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### As can be seen we have a very high AUC Score which is due to the optimization of the tuning job. The tuning was not optimized for DI therefor the value is not the best (lowest) as can be. Please refer back to these values as you will require them to complete the lab in the next notebook. \n", "\n" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "#Best AUC Score for single Metric Optimization \n", "auc_score = 0.74\n", "#Acompanying Disparate Impact\n", "dppl = 0.75" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Lets now create a model endpoint to make predictions based on the best training job we have obtained" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'s3://sagemaker-us-east-2-921553072635/sagemaker/sagemaker-amt-credit-risk-model/data/preprocessed/val/val_features.csv'" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#Get Processed Validation Dataset\n", "n = val_data_path+\"val_features.csv\"\n", "test_dataset = S3Downloader.read_file(n)\n", "n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "44154\n", "221\n" ] } ], "source": [ "print(len(test_dataset))\n", "test_dataset = test_dataset.split(\"\\n\")\n", "print(len(test_dataset))" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "for i in range(len(test_dataset)-1):\n", " test_dataset[i] = np.fromstring(test_dataset[i], dtype=float, sep=',')" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "0\n" ] } ], "source": [ "count0 = 0\n", "count1 = 0\n", "for i in range(len(test_dataset)-1):\n", " if test_dataset[i][40] == 0:\n", " count0=count0+1\n", " if test_dataset[i][40] == 1:\n", " count1=count1+1\n", "print(count0)\n", "print(count1)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'xgb-tuner-26-17-19-04-033-b11b1c0f'" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#TESTING ABOVE\n", "tuner.best_training_job()" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "xgboost_model_data = (\n", " \"s3://{}/{}/{}/{}\".format(bucket, prefix, \"xgb_model\", tuner.best_training_job()) + \"/output/model.tar.gz\"\n", ")" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "#TESTING\n", "xgboost_inference_code_location = \"s3://{}/{}/{}/code\".format(bucket, prefix, \"xgb_model\")\n", "\n", "xgboost_model = XGBoostModel(\n", " name=\"xgb-model-{0}\".format(str(int(time.time()))),\n", " model_data=xgboost_model_data,\n", " entry_point=\"inference.py\",\n", " source_dir=\"inference/xgboost/\",\n", " code_location=xgboost_inference_code_location,\n", " framework_version=\"0.90-2\",\n", " py_version=\"py3\",\n", " role=role,\n", " sagemaker_session=session,\n", ")" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "EndpointName = SINGLE-2023-01-26-1726\n" ] } ], "source": [ "from datetime import datetime\n", "\n", "endpoint_name = f\"SINGLE-{datetime.utcnow():%Y-%m-%d-%H%M}\"\n", "print(\"EndpointName =\", endpoint_name)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-----!" ] } ], "source": [ "#Create Endpoint Instance\n", "\n", "#Instance Count\n", "initial_instance_count=1 # Example\n", "#instance Type\n", "instance_type='ml.m5.large' # Example\n", "\n", "FinalModel = xgboost_model.deploy(\n", " initial_instance_count=initial_instance_count,\n", " instance_type=instance_type,\n", " endpoint_name=endpoint_name\n", ")" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "#Set up predictor \n", "from sagemaker.serializers import CSVSerializer\n", "predictor = sagemaker.predictor.Predictor(\n", " endpoint_name,\n", " session,\n", " serializer=sagemaker.serializers.CSVSerializer(),\n", " deserializer=sagemaker.deserializers.CSVDeserializer(),\n", ")" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "#Make Predictions on the test dataset\n", "Single_Optimized_Predictions = []\n", "for i in range(len(test_dataset)-1):\n", " Single_Optimized_Predictions.append(predictor.predict(test_dataset[i]))" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[['0.7337338']]\n", "[['0.94518006']]\n", "[['0.9456592']]\n" ] } ], "source": [ "#See first 3 predictions and how they look. We have the double brackets meaning each element is a 3 dimensional element, we will make them a single dimension in the next cell \n", "print(Single_Optimized_Predictions[0])\n", "print(Single_Optimized_Predictions[1])\n", "print(Single_Optimized_Predictions[2])" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "#Turn each item into a single dimension element in the list \n", "Predictions = []\n", "for i in range(len(Single_Optimized_Predictions)):\n", " Predictions.append(Single_Optimized_Predictions[i][0][0])" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.7337338\n", "0.94518006\n", "0.9456592\n" ] } ], "source": [ "#Look at first 3 processed predictions. They are now i nthe format we want\n", "print(Predictions[0])\n", "print(Predictions[1])\n", "print(Predictions[2])" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "#Each prediction value is between 0 - 1. But the target variable \"Credit Risk\" is either bad (0) or good (1) there for we will round up/down to ensure every value is either 0 or 1\n", "for i in range(len(Predictions)):\n", " if (float(Predictions[i]) >= float(0.5)):\n", " Predictions[i] = 1 \n", " elif (float(Predictions[i]) < float(0.5)):\n", " Predictions[i] = 0" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n", "1\n", "1\n" ] } ], "source": [ "#Look at first 3 predictions now to confirm we will be able to see they are either 0 or 1 \n", "print(Predictions[0])\n", "print(Predictions[1])\n", "print(Predictions[2])" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "68\n", "152\n" ] } ], "source": [ "#Check how many predictions were 0 (Bad Credit) and 1(Good Credit)\n", "print(Predictions.count(0))\n", "print(Predictions.count(1))" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUEAAAD3CAYAAACD6ubtAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAtmUlEQVR4nO3dZ3gc5fX38e9P0q6qC9hgm2aDKabaARtCSUIzNbTQQkwooQRCS2/PnwRSSEglVBNCCyV0CHEogYBNh1BMMb0YDG4YcFNblfO8uEewlnalVdvRas/nunRJmpmdObs7e/Zuc4/MDOecK1YlcQfgnHNx8iTonCtqngSdc0XNk6Bzrqh5EnTOFTVPgs65ohZ7EpQ0TpJJKov+v1vS0X24/59K+lsO282UdHxfHbc7JE2XdGYcx86HvnpP258rA0Fvnlt/vO+SjpH0SF/usy+PKekqSb/qx1jmSto9+vssSdd29ZickqCkr0l6WtJKSQuiN36n3gaciZntbWZXR8ft8sWNkldDFNsSSbdJGpO2v3PMrE+TW/RC10fHXBi9sTU5PrbDczKzk8zslz2Ioy0prEz7eb67++kL0ZfNO1EM70u6sW1d+nsaJ0mbSbpT0jJJKyQ9KGmHbjy+w4eqN8+tp+97T6WdL8+2Wz5SUkrS3HzF0huSqqPz7K6+2F+XSVDSd4HzgHOAUcB6wMXAAVm2j+Nb+lQzqwE2BGqAP+ThmPtFx5wEfA74SR6Omc1wM6uJfiZ298G9fc+iktDXgd2j12Qy8N/e7LOvSRoPPAq8CKwPrAXcDvxH0vZxxhaDaklbpP3/NeCduILpgUOARmCP9AJPT3WaBCUNA34BnGJmt5lZrZk1mdm/zOwH0TZnSbpF0rWSlgPHSBom6fKo1PiBpF9JKo22L5X0h6jU9jawb7tjzpR0vKRNgenA9lHWX9rVkzGzpcAdhMTUtr9Pv70lVURxfiRpqaT/SRqV4XmPkfSCpO/ncMyFwL3tjvljSW9FpY2XJR0ULc/4nNpXESSdIOlNSR9HJZe1uoojw3NYK3rsx9G+Tmj3mqzynmV4/L6SnpO0XNI8SWd1crgpwL1m9lbba2Jmf03b16dNDW0l4egc+CQqPe6dtu36kh6KXrv7JV3UvvSVtm3W8yyDs4DHzez/mdnHZrbCzM4HrgHOjfbXVlI6UdL8aL/fi9btBfwUODy9xJ3huT0q6c/R+fW2pB2i5fMkLVZa1Tn9fZf0L61aom+VdEy0boKk+6L38jVJh6XtY0T0Pi+X9BQwvpP3qc01QHoV/ijg7+1e202j57ZU0hxJ++d6zM7i7SNHEz5HLwDTeruzrkqC2wMVhG/MzhwA3AIMB64DrgaaCSWzzwF7AG1V0hOAL0fLJxOyegdm9gpwEuHErTGz4V3EgKQRwFeAN7NscjQwDFgXGBHtv77dPsYBs4ALzazLEqWkdYC92x3zLeAL0bHOBq6VNCaX5yRpV+A3wGHAGOBd4Iau4sjgH8D7hBLPIcA5knZLW9/+PWuvlvDhGE74ojpZ0oFZjvUEcJSkH0ia3EkiarMd8BowEvgdcLkkReuuB54ivD9nEUqY2XR2nrU3Fbg5w/KbgB0lVaUt2wXYKNrfjyXtbmb3EGpDN3ZR4t6O8OEcET2XGwhfEhsCRwIXKkPTiZnt11aaJ7xfC4H/SqoG7ov2tSZwBHCxpM2jh14ENBDOlW9EP125FviqQoFkU2AI8GTbSkkJ4F/Af6JjngZcJ2mTro6ZQ7y9Imk9YGfCOXsd4Rztla6S4AhgiZk1d7Hd42Z2h5m1AkMJSeHbUclxMfBn4KvRtocB55nZPDP7mPCB763zJS0DlhA+WKdl2a6J8Jw2NLMWM3vGzJanrd8MmAn8PL0kk8UdklYA84DFwM/bVpjZzWY238xazexG4A1g2xyfyzTgCjN71swaCdXs7aPknM2S6Bt7qaTvS1oX2An4kZk1mNls4G+smlA+fc/MrL79Ds1sppm9GK1/gZBUv5Tp4GZ2LeE135PwBbJY0o87ifddM7vMzFoIiWwMMCo6wacAPzOzlJk9AtyZaQcKJfjOzrP2RgILMixfQPgcrJa27Oxony8CVxI+yLl6x8yujJ7bjYQv3F+YWaOZ/QdIERJiRpI2JpTKDjezeYQCw9xon81m9ixwK3BI9GVzMOH1qjWzlwivZ1feJ3wJ7U4oGPy93frPE5qVfhu9Dw8AM4Ajcjhm1nhziCsXRwEvmNnLhHNyc0mf680Ou0qCHwEj1XWb0by0v8cCCWBB2wcTuJTwrQChZJK+/bu5h5vV6WY2DNiKcDKvk2W7awhV1xui6s7vom+9NtOADwglpK4caGZDCN9KEwgfMgAkHSVpdtrz3yJ9fRfWIu01MbOVhPdh7U4eM9LMhkc/f4j28bGZrUjb5t12+5hHJyRtp9Bx8GH0BXNSZ8/BzK4zs90JJceTgF9I2jPL5gvTHlcX/VmTFndd2rbZ4uzqPGtvCSHZtjcGaAU+yXLMd6O4crUo7e96ADNrvyxjJ5pC89M/gTPN7OFo8Vhgu7QvuaWE83Q0sAZQliHeXPyd0AxyBKFkmG4tYF5UqEnf79o5HLOzeDsVVbvbmgO+kGWzo4hqLmY2n/Cl26uRB10lwccJxd4Du9gufSqaeYRGy/QP5lAzaysOLyB8O7ZZL8f9din65v4VcFFa9Sp9fZOZnW1mmwE7EL610ovTZxE+LNfnUKVr2+cs4CqizhhJY4HLgFOBEVGV9yWgLZ6untN8wolEtL9qQun1g1ziSdvH6pKGpC1br90+uorjekIpbN3oC2Y6nz2HrKLX+GZClXCLrrZvZwEh7vSq6bpZtu3qPGvvfuDQDMsPI5SK0xNv+/NzfvR3v025JKmE8Jo/aGaXpq2aB8xKe45tnWAnAx8SmgNy/Tylu5XQzPG2mbVPnPOBdaOY0vf7QQ7H7CzeTpnZ5vZZB9/D7dcr9ORvBPxEYVTGQkLzwxE5FNSy6jQJmtky4GeEpHKgpCpJCUl7S/pdlscsILQl/FHSUEklksZLaqtK3QScLmkdSasBnVWbFgHrSEp24zldTSgN7N9+haRdJG0ZJbjlhOpxS9omTYQPSjVwTbuToDPnAVMlTYoea4STBUnHsmoy6Oo5XQ8cK2mSpHJCO9STZjY3x1iIqlGPAb9R6AzaCjiOzG1/2QwhlMoaJG1L6EHMSKHhf19JQ6L3e29gc9LamXKM+13gaeAsSUmFXtv9smzb1XnW3tnADpJ+LWn1KNbTCF+CP2q37ZnRub45cCyhWgvhvRvXjfOiO35NOHfOaLd8BrCxpK9Hn72EpCmSNo2q3LcRXq8qSZuRY6nIzGqBXcnchvokoU34h9Hxdia8DzfkcMys8eb4OnTmaEJ742aEjshJhM9WFaFppEe6fDPN7E/Ad4H/I3yw5xFKOXd08rCjgCTwMqGacQufVUUuI1RJnweeJbyg2TwAzAEWSlrSVaxRvCngfCDTINTRUSzLgVcIRen2475ShM6VNYErcjnhzexDQvXizKit4o+EUvQiYEvC0IycnpOZ/TeK/VZCyWg82du5OnMEMI7wrX47oZ3zvm48/luEKu0KwhfhTZ1su5zQc/oesJTQ2XFy1KbXXdMIHXIfEUr1NxJKfJl0dp6twszeILSTTgTmEl7bg4E9zezRdpvPInR0/Rf4Q9SWB591rHykdmPt+sARhLa4T9KqhNOiJo09COfAfEJTwrlAefS4UwnV64WEGsmVuR7QzJ62qEe/3fIUoRCxN6FmdDFwlJm92tUxc4i3RyRVEErtF1gYfdD28w4de7u7t2/zSVXdAKYw6PpVM/t5lxv3/ljjCOPlEtZ1Z6AbJGK/bM65dFHVaXxUvd2LMJTnjpjDcoPYgLkG07nIaEITyQjCUI6Tzey5eENyg5lXh51zRc2rw865ouZJ0DlX1DwJOueKmidB51xR8yTonCtqngSdc0XNk6Bzrqh5EnTOFTVPgs65ouZJ0DlX1DwJOueKmidB51xR8yTonCtqngSdc0XNk6Bzrqh5EnTOFTVPgs65ouZJ0DlX1DwJOueKmidB51xR8yTonCtqngSdc0XN7zvs+pWkEmAMMBaoIHzxtv2o3f9ty5qARcBCYJGZNeY/clcsPAm6XpEkYDVg/bafIbBZEiY0wdgyWKMKmtaBVDUdM18pq2Q/lQINYAuADyGxHCoqpYZy+KgM3qmHOXXwKvBW9POGmbXk/Ym7QcNvvu66RVICmFIKuw6D/VfCliVQsg40jAcmQOWGkGjLiOOAql4crxX4GJgPvE3Ieq9Bw8vQ+CaULoWyanh2Kfy7FR4C/uclR9cdngRdpySVAluXwK7DQ9LbZj1o3Acqdofk9sAIQukuDouBR4AHIfUfaHgHKobAyyvgriaYCTxuZitjCs8VAE+CrgNJGwm+vBrsXwvbjYbmvSE5Fcq/REh6A9Vy4DFgJjTfC7VzoKoa3qmDm1JwpZm9HXOIboDxJOgAkDRCcPgwOMVg/a+A9oSKnYFRcQfXCw3Ak8CN0HgNWBm8shQuBG42sxX9fXxJLcCLhMJyC3CqmT3WjcefBaw0sz9kWHcU8MNo3wKuyLRdjscZB8wwsy0kTQaOMrPTJe0MpLoTc8ExM/8p4h9gveHwn3JoOBBW/husCcwG4U8j2G1ge8CKcqgfCrcCuwOl/fj6rkz7e09gVjcffxbw/QzL9waeBdaK/q8ATsiwXVmOxxkHvJTr8QfTj48TdNsMgy8ugvLboXofBu+QgSRwEHAv1MyDirPhoI3htmpYVCmdK2njfg5hKPAJgKQaSf+V9KykFyUd0LaRpP8n6TVJ9wObZNnXTwjJaT6AmTWY2WXR42dKOkfSLOAMSdtImiXpGUn3ShoTbbeNpOclPQ6cknb8nSXNiEqHJwHfkTRb0hf6/BUZCOLOwv4T7w9QXgkr3hwAJbW4fp4HOx0ah0HdMJgFbNOHr28LMJswrGdZ274J3zVDo79HAm8SqrTbEKrPVYSk+SaZS4IfA8OyHHMmcHH0d4LQTLpG9P/hhGozwAvAl6K/f09UEgR2JlSNwUuCbrAzs8YS+Ptl0Bx3LHHZCvgLJBdB5a9gp+Hw8DDpbkmb98Hu681skplNAPYC/h6NrRRwjqQXgPuBtQnNr18AbjezOjNbDtzZw+PeGP3eBNgCuE/SbOD/gHUkDQOGm9msaLtrenicgudJ0FELl/wVmoo2C0bKgVOh5AOo/ClMHQL/GybdKmnDvti/mT1OKPWtAUyLfm9jZpMIV8hUtG2aw+7mEEqN2dRGvwXMiRLxJDPb0sz2iJbncpxBz5Ogw8xeMnj7nrgDGSCqgB9B6ftQ+R3YvxpeHCr9XdK6vdmvpAmEi2Q+AoYBi82sSdIuhMsKIQz4PkhSpaQhwH5Zdvcb4HeSRkf7Lpd0eobtXgPWkLR9tF1C0uZmthRYJmmnaLtpWY6zAhjSrSdaYDwJOgCWwnkXgA8qTjMUOAvK3oWKb8LhlfB6jXSJpO6MGqqMOhVmE6qoR1u4zO86YLKkpwkJ6FUAM3s22m42off64Uw7NbO7gIuA+yXNAZ4hQ5+WmaWAQ4BzJT0f7XeHaPWxwEVRx0h9lvj/RUjKg7ZjxMcJFhFJawG1ZrYsw7ohFbDoHagcHUNshWAh8EtovBKaU/DtFrjc/ANU8LwkOMhJKpG0lyp0H6XMpZwHM21nZisScNtV4XJdl8Fo4CIofxyqN4HzhsKj0TASV8A8CQ5SUdvPUSR5h9W5mansxvdJABOyjYdbARddCHVetOncROB5qP4xTKmCOUnpjGjKMFeAvDo8yEiqQhxPGWcyigp2pobxfDbDwb008TQXWsq+m+GxGgpz/wXrfTG/YRes14AjoPYteGE5HGLR4GVXOPzba5CQVKEy/YQyFjKecziakRxPDRuy6hQv25DAOC6aEmsVZma18JeLoC5/kRe2TYCnoPrbMLkKXpF0YMwhuW7ykmCBi6phh5PgL4ylmj2oYs0uHnQpK1jAUWZ2R4b9jayA9xdA+fD+CHgQexz4CtSthFtWwslm5l8mBcBLggVM0hcp5yXW4K9MYw2OzCEBAmzHECr4dqZVZrakAv57vQ+k7bbtgdegai84tAaeaRvD5wY2LwkWIEmjKedvlLILe1HFFnTv6ywF/J4GmtjIzN7PsP89NoFbXh3kg2T7iwFnQ9Mf4JPacG3uq3HH5LLzkmABkSSV6FjKeIPJTOU7VLEV3X8Xk4SrSUs5LssW978Pjc/1KtriJeAsSFwY7q/y1GAdZDxYeBIsEJLWp5xHGMEFHEcNU0nSoWujGyZTQSnfyjS0w8xam+CS6WFOUtdDx4DugCE1cE+JdFjc8bjMPAkOcJKkUp1KgpfYiW05mWrG9MGO1wJqqAR2ybQ6BX+7juzXUrncTAUegarV4cpK6YfRDDJuAPEkOIBJGkaSGazOb/kmVXyBMkr7aufAdtRQTqaL7jGz9xLwzK19dLhiNhF4DqrWgp/XwPTo5lVugPAkOEBJmkyCV9mSXfkm1Yzsh4NshWhhT0kZ7520NEyq0O/34SgG6wLPQNWWMG0IzJDUmzuRuj7kSXCAkSSV6QwSPMSBjGI/KnrV9teZSmAjWhBHZtnizheBN/rp8MVmOPAgVE+FLw2BuzINWHf550lwAJGUJMkNrMavOYlKNs/D7Xy3pYokZ2RqqzKzlODqy6Cp3+MoEuXADVA5GabUwNXeRhg/T4IDhKTVSfIw6/FlTqQ6bzf3HQskWBOYnGl1HVxyGTQX+6zTfSkB3AlVY2H/Kjgn7niKnSfBAUDSeJLM5nNM5GtUkczjwUuAbakgyamZVpvZy8Cbd+UxpGJQAzwA1cPh9KR0ctzxFDNPgjGTtD0JnmF31mZvymN5RyZRSiuHSqrOtHqpzzrdL9YEZkFVFfxR0v5xx1OsPAnGSNJuJLifwxjGtjG+F0OBdWkBDs2yxU2PQKnPEdX3NgTug8pq+EfbfUBcfnkSjImkPUhwJ9OoYqO4oyGMGazgO5lWmdnKBNxyZbiHrutjU4CbQ4nwHknZbrbu+oknwRhI2oskt3MkVYyLO5pISMQbSdo00+oVcNFF0OBz7/ePvYELoKYaZvnsM/nlSTDPJO1Dklv5OlWf3mRxICgFtqaMBN/MssVTtbDkoXzGVGS+ASVnwIghcJtP158//kLnkaSdSXIzR1FFr+5g20/CrNPfkNShf9rMbCWc57NO96+zoWwD2CpJ5ssZXd/zJJgnkrYgwZ18lSrWiTuaLEZANClrxht+t8I1M6D0k3zGVGTKgFugugzOkbRZ3PEUA0+CeSBpbRI8yH7UsEHc0XSh81mnPyqH+67zWaf71YbAn6A8qhbnc9RoUfIk2M+imWBm8UWGs1UeLoPrrU2BFiZLylhhXwZ/+QvUehbsXydCybawbiX8Mu5YBjtPgv1IUhnl3M2WrMNOlMUdT06SwJZAKcdn2eKBhVD/bB5DKkYCroWqBJzm4wf7lyfB/pTgT4xmIvtSXgBlwM9MpoKS7LNOp+Bin3W6/40GrgoDqW+VVBN3PIOVJ8F+IulwyjmOw6kquFd5LWAo5cBumVan4PLrQXF3EzcA2xImLd0c+Hm0/GPCjM4bRb+zdeT8hXCrlc2B89KW/wjYCjgqbdk10fb5dhBwAAyvgYtiOHxRKLSPZ0GQNIEEVzCNKgp16szOZ52el4Snbsl3TO2UAw8AzwOzgXuAJ4DfErL3G9Hv32Z47EvAZcBT0eNnRNsvAx4DXiBcHvMi4RYDVwHf6q8n0oVLQmnwEEl7xxTCoOZJsI9JqiLJXexFRZ/cCyQuWyJamCop45zWS+G882OedVqE2VggTHjYFC37J3B0tPxo4I4Mj30F+DxQRRiW8iXgdsIHIkXo/q4nTHv1e8KgvbhmQB0KXAlVNfBXn4i173kS7GtJLmBDRrN1gb+2lcAmtCC+nmWLGS+DvZ7PmDJoASYRhjdOBbYDFsGn3z9jgMUZHrcF8BDwEWH0913APMKNlg8GPgesDwwD/gcc0F9PIEd7ARNhtTI4MeZQBp3C/qAOMJJ2o5Svsh+VBdURks2UzmedBq78ayg4xaaUUBV+n1C1fSnHx21KaPubyqcJ5tPu+x9G+/wjcCbwC+BvwGHAr/om7G4TcCFUJ8Ig6qExhTEoeRLsI5KGkOAffIUqKuOOpo+MBZKMJPQ/dFAP0/8GLQNh7v3hwM6EdsFRwIJo+QLaLoLp6DjgWUKJcHXoMJlP283nNwb+DtxESLJx3XNlEnAQJCrh/2IKYVDyJNhXklzApgwZENNi9RXR1azTrwpe/3eew2rzIbA0+rseuB+YAOwPXB0tv5rsVdm2avJ7wG3AEe3Wt5UCm/hsDrES4r14+tzQUHGqpEJucR5QPAn2AUm7U8ah7ENF3LH0uTDr9MHZxqktjXHW6QWEO8dvRZiTbyrwZeDHwH2Ekt190f8A84F90h5/MLAZ4ULpi4DV0tbdEe1zLUIpc3vCGHIRqs5xWQc4Hkqq4WcxhjGoyMwvgOoNSRUkmMthjBpUpcB017CStzjDzK5ov0pSdQV8+CZUrh1HbEVoIbAB1NfDhmbmE373kpcEe6uU7zF2kFWD29u201mnaxNw0xU+63TejAZOgJIaLw32CS8J9oKkMZTxJidTlbdbZMahBfg99TQwxczmtF8tacooeHA+VPu3an5EpcGGqDT4QdzxFDI/Z3sjyR+ZQtmgToAQxqFsQxkJst0a8ul6WDwzjyEVu9HAMVBSAafFHUuh8yTYQ5K2QRzIl/J6l+D4bE0C4yhJ5e1X+azT8TgZkqVwgqTSuGMpZJ4Ee6qcS9iDikHYH5zZCMIAvDACpYNWuPYuKP04nzEVuS2BdcPVfBknunC58STYA5J2IsFmTBoU14XkLsw6na2D5ONyuOdan3U6r06FmmFeJe4VT4I9Uc657EIVxVYJCbNOf05SxvvkLYPzfdbp/PoaqBGmSlo97lgKlSfBbpK0LaVMYmKRlQIhVLwmIko5IcsWMxdD3dP5jKnIrQbsDc3qeMGLy5Enwe4q5zfsTGWBTJbf97ahnBJOytQYH806fZHPOp1fJ0H1UL9FZ495EuwGSVshtudzRVgKbDMGGEYS2D3T6hRcfgNQm9egittuQALWkbRV3LEUIk+C3ZHke2xPMrbZNQeKMOv0GZlWmdkHSXjy5nzHVMRKgRMhWQMnxR1LIfIkmCNJQ2nlULYuuu6QjsKs07tKWiPT6qUDYNbpYvMNKGuBI/0+xd3nSTB309iAVobEHcYAUAFMoAWtci+idP9+DVpfzWdMRW48MC4MT9oh5lAKjifBHEgS5fyAz1MddywDRuezTjcZXHFpzLNOF5t9oLIszC7musGTYG4+T5I1GBd3GAPIekA5qxGm2uugHqZfAS2eBfNnV0gMDVMqum7wJJiLJCezbQHeP7g/hVmnqyjPOuv06yXw6ow8h1XMdgJWwBaZru922fnHuguSymjlILbw16qDiZTQwoHZbvyzNMw67R0keTIUGP/ZPeldjvyD3bUvMpzWVeZed8EQYBwtwOFZtrjlCSidl8eQit1eoV1w17jjKCSeBLuSZBoTyXh/DUfbrNPfzrTKzOrK4AafdTp/dgvtgvvGHUch8STYCUmltHIIm/nrlNV4QIyTtGWm1Svh4ouhoTXPYRWrnYCVMNHHC+bOP9yd25GhMOhnju6NMOt0spNZp59thIUP5DOmIjYcGBfaBafEG0nh8CTYmVL2YTOq4g5jwNuaMoyvZ5t1ejn8+UK/nDhv9oKK0nAvepcDT4KdSfBlNija+WJytzowGgMOzLTa4Pp7ofSjvAZVvL4AyeE+23TOPAlmIWkITWzMunFHUiA6n3X6k3K4+xqfdTovNgBa8KH9ufIkmN1OjKK+6GeMydUEoIWJktbPtHoZnH++zzqdF2OB+nBDOpcDT4LZlLEnG/u1wjlLAJMQpRyfZYtZH8LKp/IZU5FaHTAokzQs7lgKgSfBbMrYi3E+bVa3dD7rtDXChZdAfRyhFRMBo8PrnPFeMG5VngQzkFRGig0YE3ckBWY0MJwEsEem1U1w5U1QsjK/URWl9UP7qyfBHHgSzGxjqmjEL0Pvvu2ooSLrrNPzy+Gxm/IdUxHaCJJ450hOPAlmNpEx3pPZI1sgmtlZ0qhMq5fCeX/xSRX63YZQWR6u53Fd8CSYSSlbs453ivRIBbAprZ3MOn3Xm9Dycj5jKkLjgOrQZ++64EkwkyQ7Mtpfmx6bQiWJrLNONxtc7rNO96+xgEHG4UpuVf5Bz6SZTVgz7iAK2LpABcOAHTOtrodLr4RWz4L9ZyzQgHft5cKTYDuSymlmGBmnCXU5EbAdVZRzWqbVZvZGGcy5M89hFZMhQDPetZcLT4IdrUsV9T5CsJcmUkIz+2cbsPuJ35azXyWBFvwszoUnwY7GMcwnAe21GmADmoGvZtni1v9B6bt5DKmYJIBWKM3ULutW5Umwo7UZ5t+gfWJbaijPOqlCfRlcfwU05zusYiCgJAyY9lmQuuAvUEdrsRoVcQcxKIwHSlhX0kQze7796pVw8YUwbQ0/D/tTAmiKO4iBzE++9hKsQ42/Ln2iBJhCksc5GTip/Woze65K+uVPfVBvv6iAeXVhlmnXCZn5hRHpVKnrmMrX2CbuSAaJT4CLqKWZkWbmH0g34HibYHtiGH6Lmr6zGjCGVuCguENxLhNPgh0N9STYxzqZddq5uHkS7KjGZ5PuYxOAVraU5G1/bsDxJNieUeMlwT5WRph1uowT4g7Fufa8F7SjhI8S7AfbUM5znCjpbvyGS/1huZnNjjuIQuRJsD3RRGvcQQxCo4CtSPIB/4w7lEFpMVWSxpvZvLhDKTSeBDtq8ovm+sl+Pkdjv/kdtdT557knvE2wI0+CrvCEBgY/c3vAk2BHKT+VXMFpoQRojDuMQuRJsD2R8jZBV1AMaKKccH2O6yZPgu0Zy/371BWUFCCazcwn6+4BT4LttfA+fmNcV0jqgTI/a3vKk2B7Kd6j1lsFXQGpB0pYHncYhcqTYEeLWObTD7kCUg/I2wN7ypNgR4tY4bMduwISKsILYo6iYHkS7Gih3/7HFZSPMRp5Ie4wCpUnwY7eZYXfqtAVkA+po5U34g6jUHkS7GgxLbRSG3cYzuVoCc3AW3GHUag8CbZjZkaSuXwYdyTO5WgpSTwJ9pgnwUxaeZElcQfhXA5SQBMJYH7coRQqT4KZNPIMi/HR927gWwQkedfM/GLPHvIkmNmrLKA+7iCc69J8wHg07jAKmSfBzJ5mIRU+kYIb8N6jlkYejjuMQuZJMAMzW4BYxkdxR+JcF+bRCjwddxiFzJNgNiU8yntxB+FcJxqBlZQDc+IOpZB5EsymgfuYS13cYTiX1XwgyRtm1hR3KIXMk2B2jzLXZ5NxA9hbNNPEjLjDKHSeBLObQx1lfh2xG7BeoY4W7oo7jELnSTALM2shwQN+RaYbkFbSdqXI43GHUug8CXamgRuY42VBNwC9DSR51NsDe8+TYOfu5l2S+GnmBprXqKOeW+IOYzDwJNgJM/uIMl7lnbgjcS5NC/AGJcA9cYcyGHgS7Eoj1/OKT7fvBpC3gRLeNrO5cYcyGHgS7IpxGy9jPljGDRizqaOB6XGHMVh4EuyCmb2JeN17id2AkAJeoxS4Ke5QBgtPgrlo4AKe9vu6ugHgdaCMZ81sUdyhDBaeBHNzM+/47a3dAPAsK70q3Lc8CebAzJZTxgxexOKOxRWxpcB7lAC3xRzJoOJJMFeNXMKT1HoadLF5ihTiSjPzOkkf8iSYuwep4xMfM+hikQKeppUm/hR3KIONJ8EcmZmR4pc87C2DLgYvYpTwmJm9HXcog40nwe65lnmY347T5ZUBD1NLA+fEHcpg5EmwG8ysHuOPPOQ3YXJ59AZQxxLggbhDGYw8CXZXC+fzCsbSuANxRcGA/7CSFN83M++W6wdlcQdQaMzsEyV1CQ/yLQ6iMu54qAfuBBYDAg4AEsAMQmP6cOArQEWGx95BGHxbDZyStvw+QuljdPRYgOejY32+j+N3nXsVWMFC4Pa4QxmsvCTYE038ijm0sDjuQAjziGwInAacBIwkJMXdgW8BE4DHsjx2EnBku2UNwLzosUa4uXcTMBuY0qeRu660Av+hlka+4zdX7z+eBHvAzJbSytncQ22sgTQA7wJbR/+XAZXAEmBstGw88HKWx4+Ltk8nwlRNRkh+JcCjwHZAaR/F7XIzB6hjLvDvmCMZ1DwJ9lQrFzKPOt6NMYZPgCpCtXY68E9CFXhN4LVomznA8m7ssxzYNNrfaoRq9HxCidLlTzNtpcDveltg//Ik2ENm1kAT3+MuVsZ2FUkrsIBQTT0JSAKPENoFnwIuJSTF7pbgdgJOBvYk9EfuAjxDmLdkVl8E7rr0JC2keJrQQuv6kSfB3rmOT/iAF2JKg0Ojn3Wi/zcjJMU1gKOAbwJbEEp0PbEg+j2C0DFyGKED5qMe7s/lZgUwkxSNnOilwP7nSbAXzKyVFEdyFw2xtA4OAYYR2gAhzDi8Bnx6TUsr8BAwuYf7bysFtrURQmgz9Huu9K+7qQemm9nrcYdSDORfNL2npC5kE77BITEMmVlA6A1uIZT4DiSU2p6K1m9K6CkWoW3wTj7rEb4FmAvUEYbJ7MJnnSyvEHqGd47+vxd4CxgFHNw/T8URXuMbWEwTG5hZvB1vRcKTYB+QVEOCt/kqazA+7mhcwUoBF1DLCr5qZjPiDqdYeHW4D5jZSpo4hjuoIxV3NK5g3UMDjdztCTC/PAn2ETO7ixT3ci+NccfiCtDrwIusIMXxcYdSbDwJ9qVGjuUFlvJK3IG4grISuI16mjjEzJbFHU6x8STYh8xsGU0cwO3U+wQLLicG3E4dLUw3s4fiDqcYeRLsY2b2JC38khup9XsVuy49RQvz+IAmfhx3KMXKk2B/aOFcPuY5HvARda4Tc4H7qSPF3mbmXWox8STYD8yslUYO4SmW8ZLfmsllsBT4B/U0cbCZvRV3OMXMk2A/MbNFNDGVf1LP+3FH4waUFHAttTRzlpn5tcEx8yTYj8xsNk0cwbXeUeIiBtxBPcu5lxZ+H3c4zpNgvzOzO2nmbK6h1kcQOu4jxZu8RYqv++QIA4MnwXxo5nes4A6up47muINxsXmEZp5mASl2NrO6uMNxgSfBPIjuWXwMC5jJDdT50Jki9CytzOITUuxkZj4Z2QDiSTBPzKyZFAfxHk9wM/X4HSOKx8sYd7OcJnYyM+8mG2A8CeaRmaVIsS9v8yy30eCJsAi8AtxOLU3s6vMDDkw+lVYMJFWRZBYT2IIDqPAbGA1Sz2PMYHmUAJ+NOxyXmSfBmEiqIcndrMfWHE4Vibgjcn3qKVq5j09o4otmlu1+f24A8CQYI0lJkvyDkezJ16keALdyd33hYZp5iCU0sYOZvRN3OK5zngRjJqmEBOdTwzEcSzVD447I9VgLcA+NPM9CUuxoZh/EHZLrmifBAUCSKONHlHMm06hirbgjct1WD/yDOhbxDI3sb2ZL4w7J5caT4AAi6VASXMW+VDIJxR2Py9GHwDXU0cBVpDjDzHxIfAHxJDjASNqcBPeyFSPYmwrK4o7IdeoN4GbqaeY0a7HL4w7HdZ8nwQFI0jCS3MLqbM/XvJ1wQGoG7ifFM9TSxH5m9mjcIbme8SQ4QEkqoYyfUcoPOYhKJsQdkfvUEuAGalnO46Q4wsyWxB2S6zlPggOcpB1JcCubMYx9qKA87oiKmBGuAb6HBlr4Aa1c4jPBFD5PggVA0lCSXEyCg/gKVX6D9xgsBf5FHfOYT4oDfAD04OFJsIBI2osE17Ip1exBBTVxR1QEWoAnaGEmKYzf08w5ZuYzQw4ingQLjKRhJPg14hvsQjnbUuLXHveT94A7qKWW52nkaDN7M+6QXN8rqFlkJI2SdL2ktyU9I+lxSQf10b5nSpqcYXlC0m8lvSHpJUlPSdq7F8c5RtKF0d8nSToqbXmXw6TNbJml7FRSTGYmT3IBtbzd02hcRsuB22jgGpbyMcfRyE6eAAevghmFJknAHcDVZva1aNlYYP9+PvQvgTHAFmbWKGkU8KUM8ZWaWbemSzWz6Wn/HgO8BMzP8bEvS9qRRg7kH0xnLDXsRhVjuhOBW0U98AhNPEkz4lKaONuv/Bj8CqY6LGk34Gdm1iEBResrgEuAyYRRXN81swc7WV4JXAlsRpj1bRxwipk9nbbPKmAesL6ZLc9wzJXAn4A9ge9F+zgdSAJPAt8ysxZJxwI/ARYArwONZnaqpLOAlYQ70F4FfED4KG5vZvXdeG0qKeFkSjmTcSTYjWpG5/poRyPwBM08ShPinzTyQzObF3dYLj8KqTq8OdDZnGynAJjZlsARwNVRAsy2/GSgzsy2An4NbJNhnxsC72VKgJFq4CUz2w74CDgc2NHMJhGa1KdJGgOcDewITCUk3VWY2S3A08A0M5vUnQQYPb7eWuxPNLE2b/EzLmcp11HLgu7spQgtB+6niT9Sz2P8ixSTrMGO8ARYXAqmOtyepIuAnYCUmU2J/r4AwMxelfQusHEny78InB8tf0HSCz0IowW4Nfp7N0Ii/V+ouVMJLAa2A2aa2YdR3DdGx+9z0c17/iRpOm9xEnP5P9agjB0YwqbgHSiRBcAj1PMaooRrSfE7M3sj7rBcPAopCc4BDm77x8xOkTSSUIICsk440NlEBF21BbwJrCdpiJmtyLC+Ia0dUIT2yp+scnDpwByO06fSkuEFzOcgZvBjZjCBbUkwmbKivAyvCXgVeIKVLKaJFn5PK5ea2cdxh+biVUjV4QeACkknpy2rSvv7IWAagKSNgfWA13JcvgWwVfsDRsnkcuB8Sclo2zGSjswQ33+BQyStGW23etRx8ySws6QRkhLAoVme3wpgSFcvQneYWZOZ3WT1tjUNbMcTXMP51HM1K3geaOjLow1ArcA7wG3Ucy6N/Jsn+IATaWKUtdhvPAE6KKCOEQgJCPgzoYr5IVALTDezG6N2vumEKmn7jpFMy9M7RmYT2v9OT+8YiY6ZBH4FfIWQNmoJHTT3SlppZjVp2x5O6AApIZQ9TjGzJ9p1jMwGStM7RszsD5IOBs6hBx0j3SFpCHAAFRxHE9uzPk1MooaNCd05ha6F0L30Gk08RxMtLCLFJRjXmVlOPe+uuBRUEnR9S9JqwEFUcDxNbMNaNDCBIWyAGEXh1BNqCQ0Xr1DLW5RSynyauJUWrjOz5+MOzw1sngQdAJKGAzuTZF/EPhirsz7NbEgNY4BRMCBuBtVK6Id/H3iPBuaSYjlJEjxCAzcCd/u09q47PAm6jCStB+xOObshtiPFegylnnUoZR2qGQkMB4bRP8mxldBK+lH0s4Qm5lPHAiooYRklPEkD9wNPALPNLNUPUbgi4EnQ5URSOWGs5tYk2ZFStqCVdUkxknIaGUoTIyhhCOVUkaQSKCe0M7YlSSMkt7bfrYQW0DqMlaSin1ZWIlZQSQl1lDGXVl6ikRcIg9qfNLPF+X7+bvDyJOh6RVIp4bLC9QlXzKyBWJ0EoyllNWAon/V6t0Q/zdHvJlr5kBTzMD4kTFe6hDC+8q1OBqk712c8CTrnilqh9P8551y/8CTonCtqngSdc0XNk6Bzrqh5EnTOFTVPgs65ouZJ0DlX1DwJOueKmidB51xR8yTonCtqngSdc0XNk6Bzrqh5EnTOFTVPgs65ouZJ0DlX1DwJOueKmidB51xR8yTonCtqngSdc0XNk6Bzrqj9f9RiB2K3CH76AAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "#Graph the predictions as a pie graph\n", "from matplotlib import pyplot as plt\n", "\n", "slices = [Predictions.count(0),Predictions.count(1)]\n", "labels = ['Bad Credit', 'Good Credit']\n", "colors = ['red', 'green']\n", "explode = [0, 0.1]\n", "plt.pie(slices, labels=labels, autopct='%1.1f%%', explode=explode, colors=colors, wedgeprops={'edgecolor': 'black'})\n", "plt.title(\"Credit Risk Ratio For a Single Optimized Model - All\")\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2.0" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "test_dataset[0][-1]" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "36" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#Now let us take a look at Foreign worker predictions only. the last element in the list represents Foreign workers (1 means foreign 2 means non-foreign)\n", "filtered_dataset=[]\n", "for i in range(len(test_dataset)-1):\n", " if test_dataset[i][-1] == 1:\n", " filtered_dataset.append(test_dataset[i])\n", "len(filtered_dataset)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [], "source": [ "#Make Predictions on the filtered test dataset with only Foreign Workers\n", "Single_F_Predictions = []\n", "for i in range(len(filtered_dataset)):\n", " Single_F_Predictions.append(predictor.predict(filtered_dataset[i]))" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "#Turn each item into a single dimension element in the list \n", "for i in range(len(Single_F_Predictions)):\n", " Single_F_Predictions[i]=(Single_F_Predictions[i][0][0])" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "['0.2862774',\n", " '0.06912269',\n", " '0.29497668',\n", " '0.075319745',\n", " '0.24426395',\n", " '0.036359027',\n", " '0.02628616',\n", " '0.12667994',\n", " '0.030781768',\n", " '0.02682332',\n", " '0.2110773',\n", " '0.19238576',\n", " '0.22990663',\n", " '0.081512764',\n", " '0.3376731',\n", " '0.028388042',\n", " '0.061994657',\n", " '0.8415497',\n", " '0.37680793',\n", " '0.019338168',\n", " '0.48963562',\n", " '0.1564905',\n", " '0.015742503',\n", " '0.14973402',\n", " '0.118518226',\n", " '0.21958497',\n", " '0.053401366',\n", " '0.0205502',\n", " '0.7068394',\n", " '0.07206859',\n", " '0.06789858',\n", " '0.82920635',\n", " '0.72153616',\n", " '0.13628021',\n", " '0.011861026',\n", " '0.03210104']" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Single_F_Predictions" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "#Each prediction value is between 0 - 1. But the target variable \"Credit Risk\" is either bad (0) or good (1) there for we will round up/down to ensure every value is either 0 or 1\n", "for i in range(len(Single_F_Predictions)):\n", " if (float(Single_F_Predictions[i]) >= float(0.5)):\n", " Single_F_Predictions[i] = 1 \n", " elif (float(Single_F_Predictions[i]) < float(0.5)):\n", " Single_F_Predictions[i] = 0" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "32\n", "4\n" ] } ], "source": [ "#Check how many predictions were 0 (Bad Credit) and 1(Good Credit)\n", "print(Single_F_Predictions.count(0))\n", "print(Single_F_Predictions.count(1))" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "#Pie Graph\n", "slices = [Single_F_Predictions.count(0),Single_F_Predictions.count(1)]\n", "labels = ['Bad Credit', 'Good Credit']\n", "colors = ['red', 'green']\n", "explode = [0, 0.1]\n", "plt.pie(slices, labels=labels, autopct='%1.1f%%', explode=explode, colors=colors, wedgeprops={'edgecolor': 'black'})\n", "plt.title(\"Credit Risk Ratio For a Single Optimized Model - Foreign\")\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'s3://sagemaker-us-east-2-921553072635/sagemaker/sagemaker-amt-credit-risk-model/data/preprocessed/val/val_labels.csv'" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#Read labels of validation set\n", "m = val_data_path+\"val_labels.csv\"\n", "test_labels = S3Downloader.read_file(m)\n", "m" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [], "source": [ "test_labels = test_labels.split(\"\\n\")" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "221\n" ] }, { "data": { "text/plain": [ "''" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#See length of test_labels\n", "print(len(test_labels))\n", "#Take out last element in test labels since it is an empty quote\n", "test_labels.pop()" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "100\n", "120\n" ] } ], "source": [ "#See ratio of labels\n", "print(test_labels.count('0'))\n", "print(test_labels.count('1'))" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "36\n", "148\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "#TESTING - Non Foreign Workers\n", "filtered_dataset=[]\n", "for i in range(len(test_dataset)-1):\n", " if test_dataset[i][-1] == 2:\n", " filtered_dataset.append(test_dataset[i])\n", "len(filtered_dataset)\n", "\n", "Single_F_Predictions = []\n", "for i in range(len(filtered_dataset)):\n", " Single_F_Predictions.append(predictor.predict(filtered_dataset[i]))\n", " \n", "for i in range(len(Single_F_Predictions)):\n", " Single_F_Predictions[i]=(Single_F_Predictions[i][0][0])\n", " \n", "for i in range(len(Single_F_Predictions)):\n", " if (float(Single_F_Predictions[i]) >= float(0.5)):\n", " Single_F_Predictions[i] = 1 \n", " elif (float(Single_F_Predictions[i]) < float(0.5)):\n", " Single_F_Predictions[i] = 0\n", "\n", "print(Single_F_Predictions.count(0))\n", "print(Single_F_Predictions.count(1))\n", "\n", "#Pie Graph\n", "slices = [Single_F_Predictions.count(0),Single_F_Predictions.count(1)]\n", "labels = ['Bad Credit', 'Good Credit']\n", "colors = ['red', 'green']\n", "explode = [0, 0.1]\n", "plt.pie(slices, labels=labels, autopct='%1.1f%%', explode=explode, colors=colors, wedgeprops={'edgecolor': 'black'})\n", "plt.title(\"Credit Risk Ratio For a Single Optimized Model - Non-Foreign\")\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [], "source": [ "#CLEAN UP - Uncomment code in this cell to Spin Down Endpoint\n", "\n", "# Create a low-level SageMaker service client.\n", "#sagemaker_client = boto3.client('sagemaker', region_name=\"us-east-2\")\n", "\n", "# Delete endpoint\n", "#sagemaker_client.delete_endpoint(EndpointName=endpoint_name)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### You may now move onto \"3-Multi-Objective-AMT.ipynb\" to explore Multi Objective Optimization tuning jobs to optimize both AUC & DI" ] } ], "metadata": { "instance_type": "ml.t3.medium", "kernelspec": { "display_name": "Python 3 (Data Science 2.0)", "language": "python", "name": "python3__SAGEMAKER_INTERNAL__arn:aws:sagemaker:us-east-2:429704687514:image/sagemaker-data-science-38" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.13" } }, "nbformat": 4, "nbformat_minor": 4 }