{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# STK player bot detector with SageMaker Linear Regression - Logistic Regression\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We'll look at a cool video game example where we're looking for cheaters, e.g., players who write bots to play on their behalf or coordinate with other players to gain advantage over legitimate players. We'll show which ML models can detect these cheats and how to run the analysis from the customer application using SQL. The scenario we simulate is a successful multiplayer game you launched few months ago on AWS. The game is fun, but the customer care team recently received many complaints about players cheating in the game. The task is to catch the cheaters and remove them from the game. You need to build a cheat detection system that will extend the customer-care application to hint with good efficacy about cheaters to improve the playing experience. We assume the customer care application uses Aurora MySQL, so you would like to minimize the changes to the application and use Aurora MySQL tools to detect the cheaters. \n", "\n", "We assume thegame server (https://github.com/aws-samples/amazon-aurora-call-to-amazon-sagemaker-sample/tree/master/stk-sample/env-build/eks) runs in Elastic Kubernetes Service and streams the server stdout to Kinesis Firehose using Fluentbit (https://fluentbit.io/) project. Kinesis Firehose stores the player actions in S3 that loads (https://github.com/aws-samples/amazon-aurora-call-to-amazon-sagemaker-sample/tree/master/stk-sample/env-build/lambda/stk-player-events-loader) in bulks the data to Aurora table actions. \n", "The game play actions defined as the struct Action. \n", "\n", "```\n", "struct Action\n", " {\n", " int m_ticks;\n", " int m_kart_id;\n", " PlayerAction m_action;\n", " int m_value;\n", " int m_value_l;\n", " int m_value_r;\n", " }; \n", "```\n", "\n", "The game server emits player game actions logs in near real-time as the game progressed. m_ticks is a counter that increments upon any player action. m_kart_id is the player kart unique id. The m_value, m_value_l, and m_value_r indicates the action magnitude e.g., when player attempt to slow down abruptly, the brake action carries the max integer 32768. Similarly for accelerating and kart steer.\n", "\n", "```\n", "+-----------+--------------+------+-----+---------+----------------+\n", "| Field | Type | Null | Key | Default | Extra |\n", "+-----------+--------------+------+-----+---------+----------------+\n", "| id | mediumint(9) | NO | PRI | NULL | auto_increment |\n", "| m_ticks | double | YES | | NUL | |\n", "| m_kart_id | double | YES | | NUL | |\n", "| m_action | double | YES | | NUL | |\n", "| m_value | double | YES | | NUL | |\n", "| m_value_l | double | YES | | NUL | |\n", "| m_value_r | double | YES | | NUL | |\n", "| class | int(11)| YES | | NUL | |\n", "+-----------+--------------+------+-----+---------+----------------+\n", "```\n", "\n", "We facilitated hundreds of legitimate multiplayer game sessions and bot simulated game sessions. Game sessions were manually classified by updating sequence of player actions after the game session. e.g., we captured the last game sequence id prior the game session and updated the class value with 1 in the case of bot simulated session or 0 in the case of legitimate game session. e.g. update actions set class=1 where id>Num and class is null\n", "\n", "## Formulating the ML problem\n", "\n", "The game we use is SuperTuxKart, a free and open-source kart racing game.\n", "Players take actions during the game like collecting and using cans of Nitro. Players also use of various power-up (https://en.wikipedia.org/wiki/Power-up) items obtained by driving into item boxes laid out on the course. These power-ups include mushrooms (https://en.wikipedia.org/wiki/Super_Mario_(series)#Mushrooms) to give players a speed boost, Koopa (https://en.wikipedia.org/wiki/Koopa_Troopa) Shells to be thrown at opponents, and banana peels (https://en.wikipedia.org/wiki/Banana_peel) and fake item boxes that can be laid on the course as hazards. \n", "Player actions (https://github.com/supertuxkart/stk-code/blob/master/src/input/input.hpp) are defined as a collection of game actions such as kart steer, brake, drift, look back etc. Cheating allows bots to benefit from power-up items while steering or braking the karts. Below we will classify the player behavior and distinct between human and bot actions. We will classify the suspicious player actions and then cross-reference it with other customer records already stored in the application database schema. e.g., customer care application that stores players' records in-game micro-transactions and customer care events. Therefore, we will train two models. The first is tracking bots by player moves and the second is to detect suspicious in-game micro-transactions.\n", "\n", "The rest of the notebook Implements the data exploration, preparation, model trainning, deployments and testing. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Install packages" ] }, { "cell_type": "code", "execution_count": 283, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Requirement already satisfied: mysql-connector-python in /home/ec2-user/anaconda3/envs/pytorch_latest_p36/lib/python3.6/site-packages (8.0.21)\n", "Requirement already satisfied: protobuf>=3.0.0 in /home/ec2-user/anaconda3/envs/pytorch_latest_p36/lib/python3.6/site-packages (from mysql-connector-python) (3.13.0)\n", "Requirement already satisfied: setuptools in /home/ec2-user/anaconda3/envs/pytorch_latest_p36/lib/python3.6/site-packages (from protobuf>=3.0.0->mysql-connector-python) (45.2.0.post20200210)\n", "Requirement already satisfied: six>=1.9 in /home/ec2-user/anaconda3/envs/pytorch_latest_p36/lib/python3.6/site-packages (from protobuf>=3.0.0->mysql-connector-python) (1.14.0)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "bash: line 2: /home/ec2-user/SageMaker/amazon-aurora-call-to-amazon-sagemaker-sample/stk-sample/env-build/sagemaker/env: No such file or directory\n", "WARNING: You are using pip version 20.0.2; however, version 20.3.1 is available.\n", "You should consider upgrading via the '/home/ec2-user/anaconda3/envs/pytorch_latest_p36/bin/python -m pip install --upgrade pip' command.\n" ] } ], "source": [ "%%bash \n", "home=`pwd`\n", ". $home/env\n", "pip3 install mysql-connector-python" ] }, { "cell_type": "code", "execution_count": 284, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "arn:aws:iam::163538056407:role/service-role/AmazonSageMaker-ExecutionRole-20200913T212219\n" ] } ], "source": [ "import sagemaker\n", "execution_role = sagemaker.get_execution_role()\n", "print(execution_role)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Data Exploration" ] }, { "cell_type": "code", "execution_count": 506, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 6.71 ms, sys: 0 ns, total: 6.71 ms\n", "Wall time: 5.96 ms\n" ] } ], "source": [ "%%time\n", "\n", "import json\n", "import boto3\n", "import csv\n", "import mysql.connector\n", "import sys\n", "import os\n", "import configparser\n", "\n", "config = configparser.ConfigParser()\n", "\n", "config.read('rds.ini')\n", "\n", "ENDPOINT=config['default']['ENDPOINT']\n", "USR=config['default']['USR']\n", "PASWD=config['default']['PASWD']\n", "REGION=config['default']['REGION']\n", "DBNAME=config['default']['DBNAME']\n", "\n", "client = boto3.client('rds')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Getting the right size of the grouping" ] }, { "cell_type": "code", "execution_count": 286, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 42.8 ms, sys: 0 ns, total: 42.8 ms\n", "Wall time: 434 ms\n" ] } ], "source": [ "%%time\n", "import pandas as pd\n", "\n", "try:\n", " conn = mysql.connector.connect(host=ENDPOINT, user=USR, passwd=PASWD, port=3306, database=DBNAME)\n", " cur = conn.cursor()\n", " \n", " cur.execute(\"\"\"select id,c_v,vel,vel_l,vel_r,class from v_actions_m_value_velocity where class=0 and party_size=2\"\"\")\n", " human_vel_m_value_list=cur.fetchall()\n", " \n", " cur.execute(\"\"\"select id,c_v,vel,vel_l,vel_r,class from v_actions_m_value_velocity where class=1 and party_size=2\"\"\")\n", " bot_vel_m_value_list=cur.fetchall() \n", "\n", " cur.execute(\"\"\"select id,accel,accel_l,accel_r,class from v_actions_m_value_accel where class=0 and party_size=2\"\"\")\n", " human_accel_m_value_list=cur.fetchall()\n", " \n", " cur.execute(\"\"\"select id,accel,accel_l,accel_r,class from v_actions_m_value_accel where class=1 and party_size=2\"\"\")\n", " bot_accel_m_value_list=cur.fetchall()\n", " \n", " cur.execute(\"\"\"select id,c_t,vel,class from v_actions_ticks_velocity where class=0\"\"\")\n", " human_vel_ticks_list=cur.fetchall()\n", " \n", " cur.execute(\"\"\"select id,c_t,vel,class from v_actions_ticks_velocity where class=1\"\"\")\n", " bot_vel_ticks_list=cur.fetchall()\n", " \n", " cur.execute(\"\"\"select id,accel,class from v_actions_ticks_accel where class=0\"\"\")\n", " human_accel_ticks_list=cur.fetchall()\n", " \n", " cur.execute(\"\"\"select id,accel,class from v_actions_ticks_accel where class=1\"\"\")\n", " bot_accel_ticks_list=cur.fetchall()\n", " \n", "except Exception as e:\n", " print(\"Database connection failed due to {}\".format(e))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Investigate and process the data" ] }, { "cell_type": "code", "execution_count": 287, "metadata": {}, "outputs": [], "source": [ "import pandas as pd\n", "\n", "human_vel_m_value=pd.DataFrame(human_vel_m_value_list)\n", "bot_vel_m_value=pd.DataFrame(bot_vel_m_value_list)\n", "\n", "human_vel_m_value.rename(columns={0:'id',\n", " 1:'c_v',\n", " 2:'vel',\n", " 3:'vel_l',\n", " 4:'vel_r',\n", " 5:'class'\n", " }, \n", " inplace=True)\n", "bot_vel_m_value.rename(columns={0:'id',\n", " 1:'c_v',\n", " 2:'vel',\n", " 3:'vel_l',\n", " 4:'vel_r',\n", " 5:'class'\n", " }, \n", " inplace=True)\n", "\n", "\n", "human_accel_m_value=pd.DataFrame(human_accel_m_value_list)\n", "bot_accel_m_value=pd.DataFrame(bot_accel_m_value_list)\n", "\n", "human_accel_m_value.rename(columns={0:'id',\n", " 1:'accel',\n", " 2:'accel_l',\n", " 3:'accel_r',\n", " 4:'class'\n", " }, \n", " inplace=True)\n", "bot_accel_m_value.rename(columns={0:'id',\n", " 1:'accel',\n", " 2:'accel_l',\n", " 3:'accel_r',\n", " 4:'class'\n", " }, \n", " inplace=True)\n", "\n", "\n", "human_vel_ticks=pd.DataFrame(human_vel_ticks_list)\n", "bot_vel_ticks=pd.DataFrame(bot_vel_ticks_list)\n", "\n", "human_vel_ticks.rename(columns={0:'id',\n", " 1:'c_t',\n", " 2:'vel',\n", " 3:'class'\n", " }, \n", " inplace=True)\n", "bot_vel_ticks.rename(columns={0:'id',\n", " 1:'c_t',\n", " 2:'vel',\n", " 3:'class'\n", " }, \n", " inplace=True)\n", "\n", "\n", "human_accel_ticks=pd.DataFrame(human_accel_ticks_list)\n", "bot_accel_ticks=pd.DataFrame(bot_accel_ticks_list)\n", "\n", "human_accel_ticks.rename(columns={0:'id',\n", " 1:'accel',\n", " 2:'class'\n", " }, \n", " inplace=True)\n", "bot_accel_ticks.rename(columns={0:'id',\n", " 1:'accel',\n", " 2:'class'\n", " }, \n", " inplace=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Let's look for interesting data patterns\n", "#### first look at player ticks " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The game simulates car's motions that move at a dynamic acceleration along a non-straight line. We can use fundamental kinematic physics to calculate the average velocity and acceleration changes and train a linear regression-based model that predicts bot or human kart velocity and acceleration.\n", "We found that the values of the actions generated by bot distributed differently than the human player. We attribute the findings to a naively written bot, but the methodology we propose is not limited to the bot implementation. This behavior can be attributed to the specific player level that tends to generate more hectic action values than a bot that knows the right path to take.\n", "\n", "Lets first calculate the player actions velocity, vel in a session for bot and human `(prev.class=curr.class)` as follow:\n", "\n", "```sql\n", "create or replace view v_actions_m_value_velocity as\n", "select id,m_action,m_kart_id,c_v,p_v,(c_v-p_v) vel,c_v_l,p_v_l,(c_v_l-p_v_l) vel_l,c_v_r,p_v_r,(c_v_r-p_v_r) vel_r,party_size,session,class\n", "from\n", "(\n", "select curr.id,curr.m_action,curr.m_kart_id,curr.m_value c_v,prev.m_value p_v,curr.m_value_l c_v_l,prev.m_value_l p_v_l,curr.m_value_r c_v_r,prev.m_value_r p_v_r,curr.party_size,curr.session,curr.class\n", "from actions prev, actions curr\n", "where prev.id=curr.id-1 and prev.class=curr.class and curr.m_kart_id=prev.m_kart_id and curr.m_action=prev.m_action and curr.party_size=prev.party_size and curr.session=prev.session and party_size=2\n", "order by curr.m_kart_id,curr.id\n", ") v\n", "\n", "create or replace view v_actions_m_value_accel as\n", "select id,m_action,m_kart_id,c_v,p_v,c_vel,p_vel,(c_vel-p_vel) accel,c_v_l,p_v_l,c_vel_l,p_vel_l,(c_vel_l-p_vel_l) accel_l,c_v_r,p_v_r,c_vel_r,p_vel_r,(c_vel_r-p_vel_r) accel_r,party_size,session,class\n", "from\n", "(\n", "select curr.id,curr.m_action,curr.m_kart_id,curr.c_v,curr.p_v,curr.vel c_vel,prev.vel p_vel,curr.c_v_l,curr.p_v_l,curr.vel_l c_vel_l,prev.vel_l p_vel_l,curr.c_v_r,curr.p_v_r,curr.vel_r c_vel_r,prev.vel_r p_vel_r,curr.party_size,curr.session,curr.class\n", " from v_actions_m_value_velocity prev,v_actions_m_value_velocity curr\n", " where prev.id=curr.id-1 and prev.class=curr.class and curr.m_kart_id=prev.m_kart_id and curr.m_action=prev.m_action and curr.party_size=prev.party_size and curr.session=prev.session and curr.party_size=2\n", " order by curr.m_kart_id,curr.id\n", ") v\n", "```\n", "\n", "We are going to look for patterns in the velocity and acceleration rates" ] }, { "cell_type": "code", "execution_count": 288, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import pandas as pd" ] }, { "cell_type": "code", "execution_count": 289, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "id 1372\n", "c_t 1372\n", "vel 1372\n", "class 1372\n", "dtype: int64\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "print(bot_vel_ticks.count())\n", "bot_vel_ticks[100:200].plot(kind='scatter',x='id',y='c_t',color='red')\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 290, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "id 5140\n", "c_t 5140\n", "vel 5140\n", "class 5140\n", "dtype: int64\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "print(human_vel_ticks.count())\n", "human_vel_ticks[100:200].plot(kind='scatter',x='id',y='c_t',color='blue')\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 291, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "id 1250\n", "accel 1250\n", "class 1250\n", "dtype: int64\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "print(bot_accel_ticks.count())\n", "bot_accel_ticks[100:200].plot(kind='scatter',x='id',y='accel',color='red')\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 292, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "id 2034\n", "accel 2034\n", "class 2034\n", "dtype: int64\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "print(human_accel_ticks.count())\n", "human_accel_ticks[100:200].plot(kind='scatter',x='id',y='accel',color='blue')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can see different patterns for `m_ticks` in bot and human. But `m_ticks` average velocity and acceleration seems to be similar so we need to look for more patterns. Lets look at `m_values` of those player ticks. Specifically for `actions=0 or 1`" ] }, { "cell_type": "code", "execution_count": 293, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "id 4721\n", "c_v 4721\n", "vel 4721\n", "vel_l 4721\n", "vel_r 4721\n", "class 4721\n", "dtype: int64\n", "Index(['id', 'c_v', 'vel', 'vel_l', 'vel_r', 'class'], dtype='object')\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "print(human_vel_m_value.count())\n", "print(human_vel_m_value.columns)\n", "human_vel_m_value[100:200].plot(kind='scatter',x='id',y='c_v',color='blue')\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 294, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "id 198\n", "c_v 198\n", "vel 198\n", "vel_l 198\n", "vel_r 198\n", "class 198\n", "dtype: int64\n", "Index(['id', 'c_v', 'vel', 'vel_l', 'vel_r', 'class'], dtype='object')\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "print(bot_vel_m_value.count())\n", "print(bot_vel_m_value.columns)\n", "bot_vel_m_value[100:200].plot(kind='scatter',x='id',y='c_v',color='red')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can see the bot `m_value` distrubition is different than human. Lets see the average velocity changes. " ] }, { "cell_type": "code", "execution_count": 295, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/plain": [ "Index(['id', 'c_v', 'vel', 'vel_l', 'vel_r', 'class'], dtype='object')" ] }, "execution_count": 295, "metadata": {}, "output_type": "execute_result" } ], "source": [ "human_vel_m_value[100:200].plot(kind='scatter',x='id',y='vel_r',color='blue')\n", "plt.show()\n", "human_vel_m_value.columns" ] }, { "cell_type": "code", "execution_count": 296, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/plain": [ "Index(['id', 'c_v', 'vel', 'vel_l', 'vel_r', 'class'], dtype='object')" ] }, "execution_count": 296, "metadata": {}, "output_type": "execute_result" } ], "source": [ "bot_vel_m_value[100:200].plot(kind='scatter',x='id',y='vel_r',color='red')\n", "plt.show()\n", "bot_vel_m_value.columns" ] }, { "cell_type": "code", "execution_count": 297, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/plain": [ "Index(['id', 'accel', 'accel_l', 'accel_r', 'class'], dtype='object')" ] }, "execution_count": 297, "metadata": {}, "output_type": "execute_result" } ], "source": [ "human_accel_m_value[600:2500].plot(kind='scatter',x='id',y='accel', label='human-acceleration',color='blue')\n", "plt.show()\n", "human_accel_m_value.columns" ] }, { "cell_type": "code", "execution_count": 298, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZkAAAEGCAYAAAC3lehYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3de5RU5Znv8e8j96gtip3EANpoSCIKXmiJohlFQDFxCebAiqyl6SgTVrycXDyzVI4TycRZs4y6QkLGXDxpBVkKGsYLZ44Jg8Y5Tk5UaIyXiCKtonZMYiva8QJy8Tl/7LewKKqrq7v6rb2r+/dZa6/a9e5373qqatd+6t3vW7vM3REREYlhn7QDEBGRvktJRkREolGSERGRaJRkREQkGiUZERGJZmDaAWTNwQcf7A0NDWmHISJSU9avX/+Gu9cXlivJFGhoaKClpSXtMEREaoqZvVysXKfLREQkGiUZERGJRklGRESiSa1PxsyGAg8DQ0IcK919oZmNAVYABwGPAxe4+3YzGwLcBkwE3gS+4u6bw7YWAPOAXcA33X11KJ8B/BgYAPzS3a/rSaw7duygra2Nbdu29fj5SnYMHTqUUaNGMWjQoLRDEenz0uz4/wA43d3fNbNBwO/M7NfA5cAid19hZj8nSR4/C7dvufunzew84AfAV8xsHHAecBTwKeABM/tMeIybgOlAG7DOzFa5+4buBtrW1sb+++9PQ0MDZlbZs5ZUuTtvvvkmbW1tjBkzJu1wRPq81E6XeeLdcHdQmBw4HVgZypcCs8L8zHCfsHyqJUf8mcAKd//A3V8CWoFJYWp19xfdfTtJ62hmT2Ldtm0bI0aMUILpA8yMESNGqFUq1dHeDuvWJbf9VKp9MmY2wMyeAF4H1gAvAG+7+85QpQ0YGeZHAq8ChOUdwIj88oJ1OisvFsd8M2sxs5b2TnYGJZi+Q++lVMXy5XDYYTB9enK7fHnaEaUi1STj7rvc/VhgFEnL48hi1cJtsSOD96C8WBw3u3ujuzfW1+/1WyIRke5pb4d582DrVujoSG7nzeuXLZpMjC5z97eB/wROBIabWa6vaBTwWphvA0YDhOUHAFvyywvW6ay85mzevJmjjz66W+v86Ec/4v33348UUee+973vceONN/bKtp544gnuv//+3fdXrVrFddf1aOyGSHVt3gyDB+9ZNmhQUt7PpJZkzKzezIaH+WHANOBZ4CFgdqjWBNwX5leF+4Tlv/XkH9dWAeeZ2ZAwMm0ssBZYB4w1szFmNphkcMCq+M8sG9JKMt21c+fOTpcVJplzzjmHq666qhphiVSmoQG2b9+zbMeOpLyfSbMlcwjwkJk9RZIQ1rj7vwNXApebWStJn0tzqN8MjAjllwNXAbj7M8BdwAbgN8Cl4TTcTuAyYDVJ8ror1K2OXu7w27lzJ01NTUyYMIHZs2fvTiAPPvggxx13HOPHj+eiiy7igw8+YPHixbz22mtMmTKFKVOm7LWt73//+5xwwgkcffTRzJ8/n9y/o7a2tjJt2jSOOeYYjj/+eF544QUArr/+esaPH88xxxyz+yD/wgsvMGPGDCZOnMgXvvAFnnvuub0ep7M6X/va17j88suZMmUKV155JWvXrmXy5Mkcd9xxTJ48mY0bN7J9+3auueYa7rzzTo499ljuvPNOlixZwmWXXQbAyy+/zNSpU5kwYQJTp07llVde2b3tb37zm0yePJnDDz+clStX7hWXSHT19dDcDMOGQV1dctvcnJT3N+6uKW+aOHGiF9qwYcNeZSXdcYf7sGHuBxyQ3N5xR/fWL/DSSy854L/73e/c3f3CCy/0G264wbdu3eqjRo3yjRs3urv7BRdc4IsWLXJ398MOO8zb29uLbu/NN9/cPX/++ef7qlWr3N190qRJfvfdd7u7+9atW/29997z+++/30866SR/77339lj39NNP9+eff97d3R999FGfMmWKu7svXLjQb7jhhpJ1mpqa/Etf+pLv3LnT3d07Ojp8x44d7u6+Zs0a//KXv+zu7rfeeqtfeumlu2PNv3/22Wf7kiVL3N29ubnZZ86cuXvbs2fP9l27dvkzzzzjRxxxRNHXoNvvqUhPvP66+9q1yW0fB7R4kWOqLpDZ2/I7/LZuTcrmzYNp0yr6FjN69GhOPvlkAM4//3wWL17M9OnTGTNmDJ/5TPKzoKamJm666Sa+/e1vl9zWQw89xPXXX8/777/Pli1bOOqoozjttNP405/+xLnnngskP1gEeOCBB7jwwgv52Mc+BsBBBx3Eu+++y+9//3vmzJmze5sffPDBHo/RVZ05c+YwYMAAADo6OmhqamLTpk2YGTt27Ojy9XjkkUe4++67Abjgggu44oordi+bNWsW++yzD+PGjeOvf/1rl9sSiaa+vn+2XvIoyfS2XIdfLsHARx1+FexshcNuzWz3aa7u2LZtG5dccgktLS2MHj2a733ve2zbtq3Tbbn7Xo/94YcfMnz4cJ544olOH6erOvvuu+/u+e9+97tMmTKFe+65h82bN3Paaad1+3nlxzhkyJA94heR9GRidFmfEqnD75VXXuGRRx4BYPny5Zxyyil87nOfY/PmzbS2tgKwbNkyTj31VAD2339/3nnnnb22k/sR4sEHH8y77767u8+irq6OUaNGce+99wJJq+P999/njDPO4JZbbtndB7Rlyxbq6uoYM2YMv/rVr4DkQP7kk0/u8Tjl1Mnp6Ohg5MjkJ0xLlizZXd7ZcwCYPHkyK1asAOD222/nlFNO6fS1E5H0KMn0tkgdfkceeSRLly5lwoQJbNmyhYsvvpihQ4dy6623MmfOHMaPH88+++zDN77xDQDmz5/PWWedtVfH//Dhw/n617/O+PHjmTVrFieccMLuZcuWLWPx4sVMmDCByZMn85e//IUZM2Zwzjnn0NjYyLHHHrt7ePLtt99Oc3MzxxxzDEcddRT33XcfhcqpA3DFFVewYMECTj75ZHbt2rW7fMqUKWzYsGF3x3++xYsXc+uttzJhwgSWLVvGj3/84569sCISlel0wp4aGxu98E/Lnn32WY48stjvREtob09OkTU09PtzslnUo/dURDplZuvdvbGwXH0ysajDT0REp8tERCQeJZky6bRi36H3UqR6lGTKMHToUN58800dnPoAD/8nk/sdkIjEpT6ZMowaNYq2tjY6+xsAqS25f8YUkfiUZMowaNAg/YuiiEgP6HSZiIhEoyQjIiLRKMmIiEg0SjIiIhKNkoyIiESjJCMiItEoyYiISDRKMiIiEo2SjIiIRKMkIyIi0SjJiIhINEoyIiISjZKMiIhEoyQjIiLRKMmIiEg0qSUZMxttZg+Z2bNm9oyZfSuUH2Rma8xsU7g9MJSbmS02s1Yze8rMjs/bVlOov8nMmvLKJ5rZ02GdxWZm1X+mIiL9V5otmZ3A/3D3I4ETgUvNbBxwFfCgu48FHgz3Ac4CxoZpPvAzSJISsBD4PDAJWJhLTKHO/Lz1ZlTheYmISJBaknH3P7v742H+HeBZYCQwE1gaqi0FZoX5mcBtnngUGG5mhwBnAmvcfYu7vwWsAWaEZXXu/oi7O3Bb3rZERKQKMtEnY2YNwHHAY8An3P3PkCQi4OOh2kjg1bzV2kJZqfK2IuXFHn++mbWYWUt7e3ulT0dERILUk4yZ7Qf8G/Btd/9bqapFyrwH5XsXut/s7o3u3lhfX99VyCIiUqZUk4yZDSJJMLe7+92h+K/hVBfh9vVQ3gaMzlt9FPBaF+WjipSLiEiVpDm6zIBm4Fl3/2HeolVAboRYE3BfXvlXwyizE4GOcDptNXCGmR0YOvzPAFaHZe+Y2Ynhsb6aty0REamCgSk+9snABcDTZvZEKPufwHXAXWY2D3gFmBOW3Q98EWgF3gcuBHD3LWZ2LbAu1Pu+u28J8xcDS4BhwK/DJCIiVWLJwCvJaWxs9JaWlrTDEBGpKWa23t0bC8tT7/gXEZG+S0lGRESiUZIREZFolGRERCQaJRkREYlGSUZERKJRkhERkWiUZEREJBolGRERiUZJRkREolGSERGRaJRkREQkGiUZERGJRklGRESiUZIREZFolGRERCQaJRkREYlGSUZERKJRkhERkWiUZEREJBolGRERiUZJRkREolGSERGRaJRkREQkGiUZERGJRklGRESiSTXJmNktZva6mf0xr+wgM1tjZpvC7YGh3MxssZm1mtlTZnZ83jpNof4mM2vKK59oZk+HdRabmVX3GYqI9G9pt2SWADMKyq4CHnT3scCD4T7AWcDYMM0HfgZJUgIWAp8HJgELc4kp1Jmft17hY4mISESpJhl3fxjYUlA8E1ga5pcCs/LKb/PEo8BwMzsEOBNY4+5b3P0tYA0wIyyrc/dH3N2B2/K2JSIiVZB2S6aYT7j7nwHC7cdD+Ujg1bx6baGsVHlbkfK9mNl8M2sxs5b29vZeeRIiIpLNJNOZYv0p3oPyvQvdb3b3RndvrK+vryBEERHJl8Uk89dwqotw+3oobwNG59UbBbzWRfmoIuUicbW3w7p1ya1IP5fFJLMKyI0QawLuyyv/ahhldiLQEU6nrQbOMLMDQ4f/GcDqsOwdMzsxjCr7at62ROJYvhwOOwymT09uly9POyKRVKU9hHk58AjwWTNrM7N5wHXAdDPbBEwP9wHuB14EWoH/BVwC4O5bgGuBdWH6figDuBj4ZVjnBeDX1Xhe0k+1t8O8ebB1K3R0JLfz5qlFI/3awDQf3N3ndrJoapG6DlzayXZuAW4pUt4CHF1JjCJl27wZBg9OkkvOoEFJufr6pJ/K4ukykdrU0ADbt+9ZtmNHUi7STynJiPSW+npoboZhw6CuLrltblYrRtKV8kAUJRmR3jR3Lrz8MjzwQHI7t7MzwiJVkIGBKJZ0dUhOY2Ojt7S0pB2GiEhl2tuTxJLfRzhsWPLlJ0Lr2szWu3tjYblaMiIifVFuIEq+3ECUKlKSEemMflQZn17jeDIyEEVJRqSYDJzL7vP0GseVkYEo6pMpoD4Zqfa57H5Jr3H1tLcnp8gaGqK+tuqTESlXRs5l92l6jaunvh5OOCG15K0kI1IoI+ey+zS9xv2Gkoz0T6U6nNM6l93XOsGz+BpLoor7mpKM9D/ldDhX+0eVfa0TPIuvsSSqvK+p47+AOv77uCx2OGcxpkr0tefTl0R8b9TxLwLZ7HDOYkyV6GvPpy9J4b1RkpH+JYsdzt2NKet9N1l8jSWRwntTMsmY2fGlpmhRicSSxQ7n7sTUm+fTy01W3U1qWXyNJZHCe1OyT8bMHiqxrrv76b0fUrrUJ9NPVOkHat3SVUzdOZ/e1baWL0/+tXPw4OSbbXNz8Y73cuv15PlIeiK8N531yajjv4CSjGTWunVJC6aj46OyurpkdNYJJ3xU1lViKDdZqQO/9qSY2Cvq+Dezj5nZP5rZzeH+WDM7u7eD7HOyfu5caks559Pb25MEs3Vrkoy2bk3u5++D5Xb+qgO/tmR0GHy5Hf+3AtuByeF+G/DPUSLqKzL6hksNK+d8ejmJodzOX3Xg145yvlykpNwkc4S7Xw/sAHD3rYBFi6rWZfgNlxrX1Q8Yy0kM5Xb+qgO/dmS41TmwzHrbzWwY4ABmdgTwQbSoal3uDc8/l517w/UBja+vdzjX13f+vHKJYd68ZJ/bsaN4Ypg7F6ZN6/p1KreepCvDrc5yk8xC4DfAaDO7HTgZ+FqsoGped97wvn5ArLZKRkP1FeUmhlLJqif1eos+E91X7peLFJQ9uszMRgAnkpwme9Td34gZWFp6bXRZ7mCX/4YXHux0QOye3hziK9mkz0RlMji6rKwkY2bnAr91945wfzhwmrvf2+uRpqxXhzCXesN1QNxTb/yuo9whvpJNlX4mstACykIMKan02mULcwkGwN3fJjmFJqWU+rOgDHfUVV1XI/HKHUiR4fPSUoZKPhO9PZqznJ8fFNbRiNKiyk0yxeqV25+TKjObYWYbzazVzK5KO57dsnRATPP3PL35uw6NhqptPf1MlNqHYiWLwjq/+IVGlHbG3bucgFuAHwJHAIcDi4Al5ayb5gQMAF4IMQ8GngTGlVpn4sSJXjV33OE+bJh7XV1ye8cd1XvswhgOOCBODK+/7r52bXJbrGzt2uSx4aOprs599eqP6rz+ehJbfp1hw/bcZlePKbWhJ5+Jzvaha6/de98u3DcK9/+f/7zrfa3Y/jhkiPv+++8dw9q1cV6nDAJavNhxuFjhXpVgX+A6oCVM/wLsW866aU7AScDqvPsLgAWl1qlqknFP94DY3YN3dxVLYOV8qAcN6ny9NBOyJGLvs119MSlWv3AfGjq06/2q2L5XTrIoltT22y9ZN9ZnqQZUlGRqdQJmA7/Mu38B8K9F6s3PJdBDDz200tc628ppRfTGt69yP/j5H/a6uqTO4MHFP6zdPfhI74vd8i33MTtrkeS+hFx77d77duFULKF0liw2bOi6ZZ2/H/fDL0KVtmTWAMPz7h+Y30LI6gTMKZJkflJqnegtmTQPij05NdBTxRLYvvsmU7GklntdVq8uP/GlccDrz2K3fMt9zGIt3VzdUomgcOosoRQmi8suK79l3Y+/9FSaZP5QTlnWpsydLkvzoFjtb1/dacl0db672IEsjQNefxez5dudxyycOnvf8xNBZy3kzvb/XLLYsKHz/awfJ5RiKk0y64FD8+43AI+Xs26aE8kIuBeBMXkd/0eVWidakkn7oFjqABHrw1Ls2145fSvl1EnjgNffZaUlUziVet/z9+2etD60n5Wt0iQzA3gFWBaml4Ezy1k37Qn4IvB8GGV2dVf1e5xkujpQp72zppXketqP0lWdtJN2f5XGAIxyWiTlvu/d/UKl/axsFXf8Ax8H/hE4O3So/12569bS1KMkU85psCzsrH1thFa5z0enNRK99Tqk8XqW0yKJpa99biKptCXz98DTwFvAQ8BWksvMpJ4UenvqdpLpTvLIws7a1w64XT0fDQ5I9LXXodr7cV/73ETQWZIp99plTwMnkFwY81gz+xzwT+7+lS5XrjHdvnZZd6+X1Y+vbVR1feH6cL2xv3TnddD+KT1U6bXLtrn7trChIe7+HPDZ3gywZnX3UhilrmcmvStL14crdnmTri550lvXwir3ddC1tySCcpNMW7jy8r3AGjO7D3gtXlg1RNfLyq6sXB+u2MG7ty4KmqtbKlmV8zro31wllmLn0EpNwKnAOcDg7q5bC1O00WWSjrT7wXr6e6FyRyOW29fS1etQ6ehH7f/9HpX0yfQnvfp/MpIN5fYzxOiPKNZnt+++ye17731UVtiPV04/Snf7nGL9v5H+aEyovE9GpHaV0w8Wqz+i2KmqXbvgww/3LCs8fVXOadju9jmVeh16etpXp9mkC2rJFFBLph+KPQqt2F9xQ9d/z52LrZr/rtrd1pz+jVSCzloyNfHHYyJR5VoE+QfrXIugN5LM3LkwbdreB+9iZYXq60sva27eO1lVEnOpxysmK4MrJLOUZESqcaAsdvDu7gG9mM4SWLXESHTSpyjJiNT6gbI3klUl0k500jsi/RBXSUYEdKCsVNqJTioTcYSgOv4LqONfStJlV6Sv6aUBJBrCLFIpXXZF+qLIl19SkhEph34PIn1V5IEvSjIi5Sj1ba+ra4eJZFnk6y+q41+kHJ1923v8cTj1VF1SRWpbxIEvasmIlKPYt71Fi+A739EpNOkbIv0NiZKMSLnmzk1G3DzwQHJ7/PHZ+b8akYzS6TKR7ij8PYguqSJSkloyIj2lP6wT6ZJaMiKV0JUCREpSkhGplC6pUj5dMaHf0ekyEakOXTGhX1KSEZH4dMWEfktJRkTii3x9LMmuVJKMmc0xs2fM7EMzayxYtsDMWs1so5mdmVc+I5S1mtlVeeVjzOwxM9tkZnea2eBQPiTcbw3LG6r1/ESkgP5Bs99KqyXzR+DLwMP5hWY2DjgPOAqYAfzUzAaY2QDgJuAsYBwwN9QF+AGwyN3HAm8B80L5POAtd/80sCjUE5E0aLh3v5VKknH3Z919Y5FFM4EV7v6Bu78EtAKTwtTq7i+6+3ZgBTDTzAw4HVgZ1l8KzMrb1tIwvxKYGuqLSBoKr5iga7z1C1kbwjwSeDTvflsoA3i1oPzzwAjgbXffWaT+yNw67r7TzDpC/TcKH9TM5gPzAQ499NBeeSIiUoSGe/c70ZKMmT0AfLLIoqvd/b7OVitS5hRvcXmJ+qW2tXeh+83AzZD8M2YnsYmISDdFSzLuPq0Hq7UBo/PujwJeC/PFyt8AhpvZwNCaya+f21abmQ0EDgC29CAmERHpoawNYV4FnBdGho0BxgJrgXXA2DCSbDDJ4IBV7u7AQ8DssH4TcF/etprC/Gzgt6G+iIhUSVpDmM81szbgJOD/mNlqAHd/BrgL2AD8BrjU3XeFVsplwGrgWeCuUBfgSuByM2sl6XNpDuXNwIhQfjmwe9iziIhUh+nL/Z4aGxu9paUl7TBERGqKma1398bC8qydLhMRkT5ESUZERKJRkhERkWiUZEREJBolGRERiUZJRkREolGSERGRaJRkREQkGiUZERGJRklGRESiUZIREZFolGRERCQaJRkREYlGSUZERKJRkhERkWiUZEREJBolGRERiUZJRkREolGSERGRaJRkREQkGiUZERGJRklGRESiUZIREZFolGRERCQaJRkREYlGSUZERKJJJcmY2Q1m9pyZPWVm95jZ8LxlC8ys1cw2mtmZeeUzQlmrmV2VVz7GzB4zs01mdqeZDQ7lQ8L91rC8oZrPUURE0mvJrAGOdvcJwPPAAgAzGwecBxwFzAB+amYDzGwAcBNwFjAOmBvqAvwAWOTuY4G3gHmhfB7wlrt/GlgU6omISBWlkmTc/T/cfWe4+ygwKszPBFa4+wfu/hLQCkwKU6u7v+ju24EVwEwzM+B0YGVYfykwK29bS8P8SmBqqC8iIlWShT6Zi4Bfh/mRwKt5y9pCWWflI4C38xJWrnyPbYXlHaH+Xsxsvpm1mFlLe3t7xU9IREQSA2Nt2MweAD5ZZNHV7n5fqHM1sBO4PbdakfpO8WToJeqX2tbehe43AzcDNDY2Fq0jIiLdFy3JuPu0UsvNrAk4G5jq7rkDexswOq/aKOC1MF+s/A1guJkNDK2V/Pq5bbWZ2UDgAGBLz5+RiIh0V1qjy2YAVwLnuPv7eYtWAeeFkWFjgLHAWmAdMDaMJBtMMjhgVUhODwGzw/pNwH1522oK87OB3+YlMxERqYJoLZku/CswBFgT+uIfdfdvuPszZnYXsIHkNNql7r4LwMwuA1YDA4Bb3P2ZsK0rgRVm9s/AH4DmUN4MLDOzVpIWzHnVeWoiIpJj+nK/p8bGRm9paUk7DBGRmmJm6929sbA8C6PLRESkj1KSERGRaJRkREQkGiUZERGJRklGRESiUZIREZFolGRERCQaJRkREYlGSUZERKJRkhERkWiUZEREJBolGRERiUZJRkREolGSERGRaJRkREQkGiUZERGJRklGRKRWtbfDunXJbUYpyYiI1KLly+Gww2D69OR2+fK0IypKSUZEpNa0t8O8ebB1K3R0JLfz5mWyRaMkIyJSazZvhsGD9ywbNCgpzxglGRGRWtPQANu371m2Y0dSnjFKMiIitaa+HpqbYdgwqKtLbpubk/KMGZh2ACIi0gNz58K0ackpsoaGTCYYUJIREald9fWZTS45Ol0mIiLRKMmIiEg0SjIiIhKNkoyIiESjJCMiItGYu6cdQ6aYWTvwcpnVDwbeiBhOLLUaNyj2tCj26qu1uA9z972GuinJVMDMWty9Me04uqtW4wbFnhbFXn21GnchnS4TEZFolGRERCQaJZnK3Jx2AD1Uq3GDYk+LYq++Wo17D+qTERGRaNSSERGRaJRkREQkmn6XZMxstJk9ZGbPmtkzZvatguX/YGZuZgeH+wea2T1m9pSZrTWzo7vajpkda2aPmtkTZtZiZpNCuZnZYjNrDds7PoOxH2Nmj5jZ02b2v82sLm/ZghD7RjM7M6XYh4b7T4bt/FPeNsaY2WNmtsnM7jSzwaF8SLjfGpY3ZDD2y0J8u7cTyrOyz5SK/fawT/zRzG4xs0GVxl6luJtD+VNmttLM9gvlmd9f8rb1EzN7N+9+RbFH4e79agIOAY4P8/sDzwPjwv3RwGqSH2MeHMpuABaG+c8BD5axnf8AzgrzXwT+M2/+14ABJwKPZTD2dcCpYf4i4NowPw54EhgCjAFeAAakELsB+4X5QcBjwInh/l3AeWH+58DFYf4S4Odh/jzgzpRe91KxHwc0AJtz28nYPlMq9i+G5QYsz3vdexx7leKuy3u8HwJX1cr+EsoagWXAu3llFcUeY+p3LRl3/7O7Px7m3wGeBUaGxYuAK4D80RDjgAdD/eeABjP7RBfbcSDXAjgAeC3MzwRu88SjwHAzOyRjsX8WeDjMrwH+W17sK9z9A3d/CWgFJqUQu7t77pvboDC5mRlwOrAyLFsKzMqLfWmYXwlMDfUzEXuo9wd331zk4bOyz5SK/f6w3IG1wKhKY69S3H+DpMUFDMvbXub3FzMbQJKcrih4+Ipij6HfJZl8oSl5HPCYmZ0D/Mndnyyo9iTw5VB/EnAYH32I9tpOKPo2cIOZvQrcCCwI5SOBV/NWbeOjnS8rsf8ROCfMzyH55pWp2M1sgJk9AbwOrHH3x4ARwNvuvrNIfLtjD8s7Qv2sxF5K1l/3/O0PAi4AftObsceM28xuBf5C0oL4SWHcGd5fLgNWufufC7bVa7H3ln6bZML5138jSQg7gauBa4pUvQ44MLzR/x34Q6i/13Zy34yAi4HvuPto4DtAc656ke13ewx55NgvAi41s/UkTf3tWYvd3Xe5+7EkH8RJ4Rx2qfiyHnvJh62h2H8KPOzu/9VbsceO290vBD5F0tr4Sm/FHTN2M/sUyRfAnxTZVq/E3qvKPa/WlyaSZudq4PJwfzzJN4XNYdoJvAJ8smA9C8vrim0nr14HH/0GyYC/hflfAHPz6m0EDslS7AXrfAZYG+YXAAvylq0GTkoj9oJlC4F/CHXeAAaG8pOA1YWxkvzl+Bu59ycLsReUbWbPPpnM7DOlYg/37wX26a3Yq/Wah/JTgb7aV0cAAAItSURBVH+vhf0F+BJJ6yu3rQ+B1t6Kvben1B44tSecvIm3AT8qUWf3Bx0YDgwO818nOcdccjsk34pOC/NTgfVh/kvs2RG6NoOxfzzc7hPqXBTuH8WeHf8v0r2O/96KvR4YHuaHAf8FnB3u/4o9O/4vCfOXsmdn6F0pve6dxl5sOxnbZ0q97n8P/B4YVrDdHsceO+6w/U/nPdaNwI21tr+EZfkd/xXFHmNK9cFTecJwCknz8SngiTB9scQOcBKwCXgOuBs4sKvthGXrSQ7KjwET83a+m0hGZj0NNGYw9m+RjIZ5nqQZb3nbvjrEvpEwei6F2CeQnE54iqT/6Jq89Q8n6XhuJUk4Q0L50HC/NSw/PIOxf5Okz2InyUCRX2ZsnykV+84QX27711Qae+y4Sb5E/b8Q1x+B2/molZ/5/aVgW/lJpqLYY0y6rIyIiETTbzv+RUQkPiUZERGJRklGRESiUZIREZFolGRERCQaJRmRDDOz33dSvsTMZlc7HpHuUpIRyTB3n5x2DCKVGJh2ACLSOTN71933C1fS/QnJlaZfovg1qkQyRy0ZkdpwLsnfMIwnufSIWjhSE5RkRGrD3wHLPbkq72vAb9MOSKQcSjIitUPXgJKaoyQjUhseBs4Lf2J1CDAl7YBEyqGOf5HacA9Jp//TJFfI/r/phiNSHl2FWUREotHpMhERiUZJRkREolGSERGRaJRkREQkGiUZERGJRklGRESiUZIREZFo/j9wPppwmeYQfQAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "text/plain": [ "Index(['id', 'accel', 'accel_l', 'accel_r', 'class'], dtype='object')" ] }, "execution_count": 298, "metadata": {}, "output_type": "execute_result" } ], "source": [ "bot_accel_m_value[100:1500].plot(kind='scatter',x='id',y='accel',label='bot acceleration',color='red')\n", "plt.show()\n", "bot_accel_m_value.columns" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Data preparation " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Alright, enough with the graphs, we noticed `m_value` and its `accel` as well as `m_value_l` and `m_value_r` and its `accel_l`, `accel_r` behave diffrently for `party_size=2`. lets build a data structure that includes these fields. " ] }, { "cell_type": "code", "execution_count": 496, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 27 ms, sys: 0 ns, total: 27 ms\n", "Wall time: 174 ms\n" ] }, { "data": { "text/plain": [ "class\n", "0 1264\n", "1 153\n", "dtype: int64" ] }, "execution_count": 496, "metadata": {}, "output_type": "execute_result" } ], "source": [ "%%time\n", "import pandas as pd\n", "\n", "try:\n", " conn = mysql.connector.connect(host=ENDPOINT, user=USR, passwd=PASWD, port=3306, database=DBNAME)\n", " cur = conn.cursor()\n", " \n", " cur.execute(\"\"\"select class,m_action,\n", " c_v value,c_vel velocity,accel,\n", " c_v_l value_l,c_vel_l velocity_l,accel_l,\n", " c_v_r value_r,c_vel_r velocity_r,accel_r\n", " from v_actions_m_value_accel where party_size=2\"\"\")\n", " actions_m_value_accel_list=cur.fetchall()\n", " \n", "except Exception as e:\n", " print(\"Database connection failed due to {}\".format(e))\n", "\n", "\n", "actions_m_value_accel=pd.DataFrame(actions_m_value_accel_list)\n", "\n", "actions_m_value_accel.rename(columns={\n", " 0:'class',\n", " 1:'m_action',\n", " 2:'value',\n", " 3:'velocity',\n", " 4:'accel',\n", " 5:'value_l',\n", " 6:'velocity_l',\n", " 7:'accel_l',\n", " 8:'value_r',\n", " 9:'velocity_r',\n", " 10:'accel_r'\n", " }, \n", " inplace=True)\n", "actions_m_value_accel.groupby('class').size()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Encoding the categorical feature m_action " ] }, { "cell_type": "code", "execution_count": 497, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "sample of the one hot encoding [1. 0. 0. 0. 0. 0. 0.]\n", "the length of the m_action onehot encoding is 1417\n" ] }, { "data": { "text/plain": [ "(1417, 7)" ] }, "execution_count": 497, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from numpy import argmax\n", "from numpy import array\n", "import numpy\n", "from sklearn.preprocessing import OneHotEncoder\n", "from sklearn.preprocessing import LabelEncoder\n", "label_encoder = LabelEncoder()\n", "actions_m_value_accel_array=array(actions_m_value_accel.m_action)\n", "# integer encode\n", "label_encoder = LabelEncoder()\n", "integer_encoded = label_encoder.fit_transform(actions_m_value_accel_array)\n", "# binary encode\n", "onehot_encoder = OneHotEncoder(sparse=False)\n", "integer_encoded = integer_encoded.reshape(len(integer_encoded), 1)\n", "onehot_encoded = onehot_encoder.fit_transform(integer_encoded)\n", "\n", "print('sample of the one hot encoding {}'.format(onehot_encoded[10]))\n", "print('the length of the m_action onehot encoding is {}'.format(len(onehot_encoded)))\n", "onehot_encoded.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Preparing the `actions_m_value_accel` dataframe with the 7xn encoded `m_action` array.\n", "\n", "* Removing the `m_action` column\n", "* Convert the `actions_m_value_accel` to array \n", "* Append the 7xn `onehot_encoded` array with `actions_m_value_accel_arr` " ] }, { "cell_type": "code", "execution_count": 494, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Index(['class', 'm_action', 'value', 'velocity', 'accel', 'value_l',\n", " 'velocity_l', 'accel_l', 'value_r', 'velocity_r', 'accel_r'],\n", " dtype='object')\n", "Index(['class', 'value', 'velocity', 'accel', 'value_l', 'velocity_l',\n", " 'accel_l', 'value_r', 'velocity_r', 'accel_r'],\n", " dtype='object')\n", "actions_m_value_accel_arr.shape=(1417, 10)\n" ] }, { "data": { "text/plain": [ "(1417, 17)" ] }, "execution_count": 494, "metadata": {}, "output_type": "execute_result" } ], "source": [ "print(actions_m_value_accel.columns)\n", "actions_m_value_accel=actions_m_value_accel.drop(columns=['m_action'])\n", "print(actions_m_value_accel.columns)\n", "actions_m_value_accel_arr=array(actions_m_value_accel)\n", "print(\"actions_m_value_accel_arr.shape=\"+str(actions_m_value_accel_arr.shape))\n", "all_data = numpy.append(actions_m_value_accel_arr, onehot_encoded, 1)\n", "all_data.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Create a mapping table between player `m_action` and the onehotencoding used for training\n", "```\n", "create table if not exists m_action_encoding (\n", " m_action int,\n", " i_0 int,\n", " i_1 int,\n", " i_2 int,\n", " i_3 int,\n", " i_4 int,\n", " i_5 int,\n", " i_6 int\n", ");\n", "```\n" ] }, { "cell_type": "code", "execution_count": 507, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "insert_stmt = INSERT INTO m_action_encoding(m_action,i_0,i_1,i_2,i_3,i_4,i_5,i_6) VALUES (1,0.,1.,0.,0.,0.,0.,0.),(0,1.,0.,0.,0.,0.,0.,0.),(3,0.,0.,0.,1.,0.,0.,0.),(2,0.,0.,1.,0.,0.,0.,0.),(5,0.,0.,0.,0.,0.,1.,0.),(6,0.,0.,0.,0.,0.,0.,1.),(4,0.,0.,0.,0.,1.,0.,0.)\n" ] } ], "source": [ "m_action_encoded_dict={}\n", "#dedup m_action_encoded\n", "for i in range(0,len(onehot_encoded),1):\n", " key=str(onehot_encoded[i])+';'+str(integer_encoded[i])\n", " m_action_encoded_dict[key]=1\n", " \n", "values='' \n", "for j in m_action_encoded_dict:\n", " m_action_encode=j.split(';')\n", " m_action_onehot=m_action_encode[0].replace('[','').replace(']','').split()\n", " m_action_int=m_action_encode[1].replace('[','').replace(']','')\n", " #print('{},{}'.format(m_action_onehot,m_action_int))\n", " i_0=m_action_onehot[0]\n", " i_1=m_action_onehot[1]\n", " i_2=m_action_onehot[2]\n", " i_3=m_action_onehot[3]\n", " i_4=m_action_onehot[4]\n", " i_5=m_action_onehot[5]\n", " i_6=m_action_onehot[6]\n", " value='('+m_action_int+','+i_0+','+i_1+','+i_2+','+i_3+','+i_4+','+i_5+','+i_6+')'\n", " if(values):\n", " values=values+','+value\n", " else:\n", " values=value\n", " \n", "#print('values = {}'.format(values))\n", "insert_stmt=(\n", " \"INSERT INTO m_action_encoding(m_action,i_0,i_1,i_2,i_3,i_4,i_5,i_6)\"\n", " \" VALUES \"+values\n", ") \n", "print('insert_stmt = {}'.format(insert_stmt))\n", "\n", "try:\n", " conn = mysql.connector.connect(host=ENDPOINT, user=USR, passwd=PASWD, port=3306, database=DBNAME)\n", " cur = conn.cursor()\n", " cur.execute('DELETE FROM m_action_encoding')\n", " cur.execute(insert_stmt)\n", " conn.commit()\n", "except Exception as e:\n", " print(\"Database connection failed due to {}\".format(e))\n" ] }, { "cell_type": "code", "execution_count": 512, "metadata": {}, "outputs": [], "source": [ "df=pd.DataFrame(all_data) \n", "df.head()\n", "df.rename(columns={\n", " 0:'class',\n", " 1:'value',\n", " 2:'velocity',\n", " 3:'accel',\n", " 4:'value_l',\n", " 5:'velocity_l',\n", " 6:'accel_l',\n", " 7:'value_r',\n", " 8:'velocity_r',\n", " 9:'accel_r',\n", " 10:'m_action_0',\n", " 11:'m_action_1',\n", " 12:'m_action_2',\n", " 13:'m_action_3',\n", " 14:'m_action_4',\n", " 15:'m_action_5',\n", " 16:'m_action_6'\n", " }, \n", " inplace=True)" ] }, { "cell_type": "code", "execution_count": 522, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Index(['class', 'value', 'velocity', 'accel', 'value_l', 'velocity_l',\n", " 'accel_l', 'value_r', 'velocity_r', 'accel_r', 'm_action_0',\n", " 'm_action_1', 'm_action_2', 'm_action_3', 'm_action_4', 'm_action_5',\n", " 'm_action_6'],\n", " dtype='object')" ] }, "execution_count": 522, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df.columns" ] }, { "cell_type": "code", "execution_count": 514, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
classvaluevelocityaccelvalue_lvelocity_laccel_lvalue_rvelocity_raccel_rm_action_0m_action_1m_action_2m_action_3m_action_4m_action_5m_action_6
00.032768.032768.065536.00.00.00.00.032768.065536.00.01.00.00.00.00.00.0
10.00.0-32768.0-65536.00.00.00.0-32768.0-32768.0-65536.00.01.00.00.00.00.00.0
20.032768.032768.065536.00.00.00.00.032768.065536.00.01.00.00.00.00.00.0
30.00.0-32768.0-65536.00.00.00.0-32768.0-32768.0-65536.00.01.00.00.00.00.00.0
40.032768.032768.065536.00.00.00.00.032768.065536.00.01.00.00.00.00.00.0
\n", "
" ], "text/plain": [ " class value velocity accel value_l velocity_l accel_l value_r \\\n", "0 0.0 32768.0 32768.0 65536.0 0.0 0.0 0.0 0.0 \n", "1 0.0 0.0 -32768.0 -65536.0 0.0 0.0 0.0 -32768.0 \n", "2 0.0 32768.0 32768.0 65536.0 0.0 0.0 0.0 0.0 \n", "3 0.0 0.0 -32768.0 -65536.0 0.0 0.0 0.0 -32768.0 \n", "4 0.0 32768.0 32768.0 65536.0 0.0 0.0 0.0 0.0 \n", "\n", " velocity_r accel_r m_action_0 m_action_1 m_action_2 m_action_3 \\\n", "0 32768.0 65536.0 0.0 1.0 0.0 0.0 \n", "1 -32768.0 -65536.0 0.0 1.0 0.0 0.0 \n", "2 32768.0 65536.0 0.0 1.0 0.0 0.0 \n", "3 -32768.0 -65536.0 0.0 1.0 0.0 0.0 \n", "4 32768.0 65536.0 0.0 1.0 0.0 0.0 \n", "\n", " m_action_4 m_action_5 m_action_6 \n", "0 0.0 0.0 0.0 \n", "1 0.0 0.0 0.0 \n", "2 0.0 0.0 0.0 \n", "3 0.0 0.0 0.0 \n", "4 0.0 0.0 0.0 " ] }, "execution_count": 514, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df.head()" ] }, { "cell_type": "code", "execution_count": 523, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Index(['value', 'velocity', 'accel', 'value_l', 'velocity_l', 'accel_l',\n", " 'value_r', 'velocity_r', 'accel_r', 'm_action_0', 'm_action_1',\n", " 'm_action_2', 'm_action_3', 'm_action_4', 'm_action_5', 'm_action_6'],\n", " dtype='object')" ] }, "execution_count": 523, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df.columns[1:17]" ] }, { "cell_type": "code", "execution_count": 524, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'class'" ] }, "execution_count": 524, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df.columns[0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Build a model - m_value velocity and acceleration" ] }, { "cell_type": "code", "execution_count": 525, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "feature_columns=Index(['value', 'velocity', 'accel', 'value_l', 'velocity_l', 'accel_l',\n", " 'value_r', 'velocity_r', 'accel_r', 'm_action_0', 'm_action_1',\n", " 'm_action_2', 'm_action_3', 'm_action_4', 'm_action_5', 'm_action_6'],\n", " dtype='object')\n", "label_column=class\n", "[ 0.0000e+00 -3.2768e+04 -6.5536e+04 0.0000e+00 0.0000e+00 0.0000e+00\n", " -3.2768e+04 -3.2768e+04 -6.5536e+04 0.0000e+00 1.0000e+00 0.0000e+00\n", " 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00]\n" ] }, { "data": { "text/plain": [ "0.0" ] }, "execution_count": 525, "metadata": {}, "output_type": "execute_result" } ], "source": [ "feature_columns = df.columns[1:17]\n", "label_column = df.columns[0]\n", "\n", "print('feature_columns={}'.format(feature_columns))\n", "print('label_column={}'.format(label_column))\n", "\n", "features = df[feature_columns].values.astype('float32')\n", "labels = (df[label_column].values).astype('float32')\n", "print(features[3])\n", "labels[3]" ] }, { "cell_type": "code", "execution_count": 526, "metadata": {}, "outputs": [], "source": [ "import io\n", "import sagemaker.amazon.common as smac\n", "\n", "buf = io.BytesIO()\n", "smac.write_numpy_to_dense_tensor(buf, features, labels)\n", "buf.seek(0);" ] }, { "cell_type": "code", "execution_count": 527, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Uploaded training data location: s3://stk-events/bot-detect-ticks-model/train/recordio-pb-data\n", "Training artifacts will be uploaded to: s3://stk-events/bot-detect-ticks-model/output\n" ] } ], "source": [ "import boto3\n", "import os\n", "import sagemaker\n", "\n", "session = sagemaker.Session()\n", "bucket = 'stk-events'\n", "\n", "prefix = 'bot-detect-ticks-model'\n", "key = 'recordio-pb-data'\n", "\n", "boto3.resource('s3').Bucket(bucket).Object(os.path.join(prefix, 'train', key)).upload_fileobj(buf)\n", "\n", "s3_train_data = 's3://{}/{}/train/{}'.format(bucket, prefix, key)\n", "print('Uploaded training data location: {}'.format(s3_train_data))\n", "\n", "output_location = 's3://{}/{}/output'.format(bucket, prefix)\n", "print('Training artifacts will be uploaded to: {}'.format(output_location))" ] }, { "cell_type": "code", "execution_count": 528, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "'get_image_uri' method will be deprecated in favor of 'ImageURIProvider' class in SageMaker Python SDK v2.\n", "Parameter image_name will be renamed to image_uri in SageMaker Python SDK v2.\n", "'s3_input' class will be renamed to 'TrainingInput' in SageMaker Python SDK v2.\n" ] } ], "source": [ "from sagemaker.amazon.amazon_estimator import get_image_uri\n", "\n", "container = get_image_uri(boto3.Session().region_name, 'linear-learner')\n", "\n", "from sagemaker import get_execution_role\n", "\n", "linear = sagemaker.estimator.Estimator(container,\n", " get_execution_role(), \n", " train_instance_count=1, \n", " train_instance_type='ml.c4.xlarge',\n", " output_path=output_location,\n", " sagemaker_session=session)\n", "linear.set_hyperparameters(feature_dim=features.shape[1],\n", " predictor_type='binary_classifier',\n", " mini_batch_size=200)\n", "\n", "linear.fit({'train': s3_train_data},wait=False)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#delete old endpoint\n", "sagemaker.Session().delete_endpoint(\"stk-bot-detect-actions\")" ] }, { "cell_type": "code", "execution_count": 532, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Parameter image will be renamed to image_uri in SageMaker Python SDK v2.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "---------------!Endpoint name: stk-bot-detect-actions\n" ] } ], "source": [ "from sagemaker.predictor import csv_serializer, json_deserializer\n", "\n", "\n", "linear_predictor = linear.deploy(initial_instance_count=1,\n", " endpoint_name='stk-bot-detect-actions',\n", " instance_type='ml.c4.large')\n", "# Specify input and output formats.\n", "linear_predictor.content_type = 'text/csv'\n", "linear_predictor.serializer = csv_serializer\n", "linear_predictor.deserializer = json_deserializer\n", "print('Endpoint name: {}'.format(linear_predictor.endpoint))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Lets test the model with existing data. Pull classified data and see if the model predicted the correct classification. e.g., calls with `where class=1` returns `'predicted_label': 1` \n", "\n", "Another way is to let two players play the game, wait two minutes for the game events to stream to Aurora and look for events with `class is null` instead of `class=1` or `class=0`" ] }, { "cell_type": "code", "execution_count": 562, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 19.5 ms, sys: 0 ns, total: 19.5 ms\n", "Wall time: 94.3 ms\n" ] } ], "source": [ "%%time\n", "import pandas as pd\n", "\n", "try:\n", " conn = mysql.connector.connect(host=ENDPOINT, user=USR, passwd=PASWD, port=3306, database=DBNAME)\n", " cur = conn.cursor()\n", " cur.execute(\"\"\"\n", " SELECT c_v,c_vel,accel,c_v_l,c_vel_l,accel_l,c_v_r,c_vel_r,accel_r,\n", " t2.i_0,t2.i_1,t2.i_2,t2.i_3,t2.i_4,t2.i_5,t2.i_6 \n", " FROM v_actions_m_value_accel t1,m_action_encoding t2 \n", " WHERE t1.m_action=t2.m_action and class=1\n", " LIMIT 3\n", " \"\"\")\n", " result_list=cur.fetchall() \n", "except Exception as e:\n", " print(\"Database connection failed due to {}\".format(e))\n", "#sample=''.join(sample_list[0])" ] }, { "cell_type": "code", "execution_count": 563, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(924.0, 87.0, 34.0, 837.0, 53.0, -101.0, 0.0, 0.0, 0.0, 1, 0, 0, 0, 0, 0, 0)\n", "{'predictions': [{'score': 0.9363782405853271, 'predicted_label': 1}]}\n", "(588.0, -336.0, -423.0, 924.0, 87.0, 34.0, 0.0, 0.0, 0.0, 1, 0, 0, 0, 0, 0, 0)\n", "{'predictions': [{'score': 0.9387953877449036, 'predicted_label': 1}]}\n", "(534.0, -54.0, 282.0, 588.0, -336.0, -423.0, 0.0, 0.0, 0.0, 1, 0, 0, 0, 0, 0, 0)\n", "{'predictions': [{'score': 0.9430064558982849, 'predicted_label': 1}]}\n" ] } ], "source": [ "for sample in result_list:\n", " print(sample)\n", " ret=linear_predictor.predict(sample)\n", " print(ret)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Clean up\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We will leave the prediction endpoint running at the end of this notebook so we can handle incoming event streams. However, don't forget to delete the prediction endpoint when you're done. You can do that at the Amazon SageMaker console in the Endpoints page. Or you can run linear_predictor.delete_endpoint()" ] } ], "metadata": { "kernelspec": { "display_name": "conda_pytorch_latest_p36", "language": "python", "name": "conda_pytorch_latest_p36" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.6.10" } }, "nbformat": 4, "nbformat_minor": 4 }