evaluations/model/App14/App14.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# App14"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* A complex App with 14 functions.\n",
    "* There are 2 branches, 2 parallels, 2 cycles, and 1 self-loops in App14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from io import BytesIO\n",
    "import time\n",
    "import zipfile\n",
    "import numpy as np\n",
    "import boto3\n",
    "from tqdm import tqdm\n",
    "from datetime import datetime, timezone\n",
    "from time import gmtime, strftime\n",
    "import json\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "client = boto3.client('lambda')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "function_prefix='App14'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "function_number = 14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The difference between UTC and local timezone\n",
    "timezone_offset = -7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create Functions of App14"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function Name List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['App14_f1', 'App14_f2', 'App14_f3', 'App14_f4', 'App14_f5', 'App14_f6', 'App14_f7', 'App14_f8', 'App14_f9', 'App14_f10', 'App14_f11', 'App14_f12', 'App14_f13', 'App14_f14']\n"
     ]
    }
   ],
   "source": [
    "function_name_list = [function_prefix+'_f'+str(i) for i in range(1, function_number+1)]\n",
    "print(function_name_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Send Requests to Create Lambda Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Successful', 'Successful', 'Successful', 'Successful', 'Successful', 'Successful', 'Successful', 'Successful', 'Successful', 'Successful', 'Successful', 'Successful', 'Successful', 'Successful']\n"
     ]
    }
   ],
   "source": [
    "function_creation_response = []\n",
    "for function in function_name_list:\n",
    "    response = client.create_function(\n",
    "        FunctionName=function,\n",
    "        Runtime='python3.7',\n",
    "        Role='arn:aws:iam::499537426559:role/ServerlessAppPerfOpt',\n",
    "        Handler='lambda_function.lambda_handler',\n",
    "        Code={\n",
    "            'ZipFile': b\"PK\\x03\\x04\\x14\\x00\\x00\\x00\\x00\\x00\\xf3s;P\\x84\\xf0r\\x96Z\\x00\\x00\\x00Z\\x00\\x00\\x00\\x12\\x00\\x00\\x00lambda_function.pydef lambda_handler(event, context):\\n    pass\\n    return {\\n        'statusCode': 200\\n    }\\nPK\\x03\\x04\\x14\\x00\\x00\\x00\\x00\\x00\\x05q;P\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x13\\x00\\x00\\x00.ipynb_checkpoints/PK\\x01\\x02\\x14\\x03\\x14\\x00\\x00\\x00\\x00\\x00\\xf3s;P\\x84\\xf0r\\x96Z\\x00\\x00\\x00Z\\x00\\x00\\x00\\x12\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\xb4\\x81\\x00\\x00\\x00\\x00lambda_function.pyPK\\x01\\x02\\x14\\x03\\x14\\x00\\x00\\x00\\x00\\x00\\x05q;P\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x13\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x10\\x00\\xfdA\\x8a\\x00\\x00\\x00.ipynb_checkpoints/PK\\x05\\x06\\x00\\x00\\x00\\x00\\x02\\x00\\x02\\x00\\x81\\x00\\x00\\x00\\xbb\\x00\\x00\\x00\\x00\\x00\"\n",
    "        },\n",
    "        Description='Analytical Model Evaluation {}'.format(function),\n",
    "        Timeout=60,\n",
    "        MemorySize=128\n",
    "    )\n",
    "    function_creation_response.append(response)\n",
    "    time.sleep(0.1)\n",
    "print([item['LastUpdateStatus'] for item in function_creation_response])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Update all Functions in App14"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Update Function Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "functions=[]\n",
    "for file in os.listdir('functions'):\n",
    "    path=os.path.abspath(os.path.join(os.path.dirname('__file__'), 'functions/'+file))\n",
    "    if not file.startswith('.') and os.path.isdir(path):\n",
    "        functions.append(file)\n",
    "for function_folder in functions:\n",
    "    buf = BytesIO()\n",
    "    with zipfile.ZipFile(buf, 'w') as z:\n",
    "        for file in os.listdir('functions/'+function_folder):\n",
    "            z.write(os.path.abspath(os.path.join(os.path.dirname('__file__'), 'functions/{}/{}'.format(function_folder,file))), os.path.basename(os.path.join(os.path.dirname('__file__'), 'functions/{}/{}'.format(function_folder,file))))\n",
    "    buf.seek(0)\n",
    "    pkg = buf.read()\n",
    "    client.update_function_code(FunctionName='{}_{}'.format(function_prefix, function_folder),ZipFile=pkg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Update Function Memory Configuration\n",
    "* Available Memory Configurations: 128, 192, 256, 320, 384, 448, 512, 576, 640, 704, 768, 832, 896, 960, 1024, 1088, 1152, 1216, 1280, 1344, 1408, 1472, 1536, 1600, 1664, 1728, 1792, 1856, 1920, 1984, 2048, 2112, 2176, 2240, 2304, 2368, 2432, 2496, 2560, 2624, 2688, 2752, 2816, 2880, 2944, 3008\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "mem_config_list={\n",
    "    'f1':1536,\n",
    "    'f2':1792,\n",
    "    'f3':576,\n",
    "    'f4':2240,\n",
    "    'f5':896,\n",
    "    'f6':1728,\n",
    "    'f7':128,\n",
    "    'f8':128,\n",
    "    'f9':256,\n",
    "    'f10':320,\n",
    "    'f11':1920,\n",
    "    'f12':1984,\n",
    "    'f13':1088,\n",
    "    'f14':640\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "for function in mem_config_list.keys():\n",
    "    client.update_function_configuration(FunctionName='{}_{}'.format(function_prefix, function), MemorySize=mem_config_list[function])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Execute the Application"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "sfn_client = boto3.client('stepfunctions')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "stateMachineArn='arn:aws:states:us-east-2:499537426559:stateMachine:App14'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test run"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'executionArn': 'arn:aws:states:us-east-2:499537426559:express:App14:c2b70249-e3a8-433c-b9c7-b1433dc4f398:5cf96cb3-c3b1-40ca-8207-f6909d5d1ca0',\n",
       " 'startDate': datetime.datetime(2020, 1, 29, 20, 38, 52, 312000, tzinfo=tzlocal()),\n",
       " 'ResponseMetadata': {'RequestId': 'b077c6df-da6d-4a3a-9c43-5385bc4c3da4',\n",
       "  'HTTPStatusCode': 200,\n",
       "  'HTTPHeaders': {'x-amzn-requestid': 'b077c6df-da6d-4a3a-9c43-5385bc4c3da4',\n",
       "   'content-type': 'application/x-amz-json-1.0',\n",
       "   'content-length': '173'},\n",
       "  'RetryAttempts': 0}}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sfn_client.start_execution(\n",
    "    stateMachineArn=stateMachineArn,\n",
    "    input=\"{\\\"para1\\\":96, \\\"para2\\\":[1,2,3,4,100], \\\"para3\\\":[1,100], \\\"para4\\\":64, \\\"para5\\\":[1,2,100]}\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Execute App14"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Execute App14 for 5 periods.\n",
    "* Execute App14 for 720 times in each exuection period\n",
    "* The interval between executions is 10 seconds.\n",
    "* The interval between each execution periods is 2 hours (7200 seconds)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(128)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Execution Period 1 Timestamp: 1580355679.895779 UTC: 30 Jan 2020 03:41:19 +0000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 720/720 [2:02:19<00:00, 10.19s/it]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Execution Period 2 Timestamp: 1580370220.2975037 UTC: 30 Jan 2020 07:43:40 +0000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 720/720 [2:02:18<00:00, 10.19s/it]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Execution Period 3 Timestamp: 1580384759.6063807 UTC: 30 Jan 2020 11:45:59 +0000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 720/720 [2:02:17<00:00, 10.19s/it]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Execution Period 4 Timestamp: 1580399297.7505615 UTC: 30 Jan 2020 15:48:17 +0000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 720/720 [2:02:20<00:00, 10.19s/it]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Execution Period 5 Timestamp: 1580413838.979376 UTC: 30 Jan 2020 19:50:38 +0000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 720/720 [2:02:24<00:00, 10.20s/it]  \n"
     ]
    }
   ],
   "source": [
    "for period in range(1, 6):\n",
    "    print('Execution Period {} Timestamp: {} UTC: {}'.format(period,time.time(),strftime(\"%d %b %Y %H:%M:%S +0000\", gmtime())))\n",
    "    time.sleep(1)\n",
    "    for i in tqdm(range(720)):\n",
    "        time.sleep(10)\n",
    "        input_str=\"{\"+ \"\\\"para1\\\":{}, \\\"para2\\\":{}, \\\"para3\\\":{}, \\\"para4\\\":{}, \\\"para5\\\":{}\".format(\n",
    "            np.random.randint(1, 101),\n",
    "            list(np.random.randint(1, 101, 20)), \n",
    "            list(np.random.randint(1, 101, 20)),\n",
    "            np.random.randint(1, 101),\n",
    "            list(np.random.randint(1, 101, 20))\n",
    "        ) +\"}\"\n",
    "        sfn_client.start_execution(\n",
    "            stateMachineArn=stateMachineArn,\n",
    "            input=input_str\n",
    "        )\n",
    "    if(period!=5):\n",
    "        time.sleep(7200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "## CloudWatch Logs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "logclient = boto3.client('logs')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "### Query App14 Step Functions Logs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Define Timestamps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "startTime_sfn_App14=int(datetime.timestamp(datetime(year=2020,month=1,day=30,hour=3,minute=41,second=16,tzinfo=timezone.utc)))\n",
    "endTime_sfn_App14=int(datetime.timestamp(datetime(year=2020,month=1,day=30,hour=21,minute=54,second=0,tzinfo=timezone.utc)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "execution_start_index = [60 + 720*i for i in range(5)]\n",
    "execution_end_index = [item + 600 for item in execution_start_index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[60, 780, 1500, 2220, 2940]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "execution_start_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[660, 1380, 2100, 2820, 3540]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "execution_end_index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Query CloudWatch Logs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "query_sfn_App14 = logclient.start_query(\n",
    "    logGroupName='/aws/states/{}-Logs'.format('App14'),\n",
    "    queryString=\"fields type, @timestamp| filter type = 'ExecutionStarted' or type = 'ExecutionSucceeded' | sort id desc\",\n",
    "    startTime=startTime_sfn_App14,\n",
    "    endTime=endTime_sfn_App14,\n",
    "    limit = 10000\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "query_results_sfn_App14 = logclient.get_query_results(\n",
    "    queryId=query_sfn_App14['queryId']\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "App14_starttimestamp=np.sort([datetime.timestamp(datetime.strptime(item[1]['value'], '%Y-%m-%d %H:%M:%S.%f'))+timezone_offset*3600 for item in query_results_sfn_App14['results'] if item[0]['value']=='ExecutionStarted'])\n",
    "App14_endtimestamp=np.sort([datetime.timestamp(datetime.strptime(item[1]['value'], '%Y-%m-%d %H:%M:%S.%f'))+timezone_offset*3600 for item in query_results_sfn_App14['results'] if item[0]['value']=='ExecutionSucceeded'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.DataFrame({'Start': App14_starttimestamp, 'End':App14_endtimestamp}).to_csv('App14_SFN_Logs.csv', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "App14_sfn_logs = pd.read_csv('App14_SFN_Logs.csv', error_bad_lines=False, warn_bad_lines=False,low_memory=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3600, 2)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "App14_sfn_logs.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "App14_sfn_logs_trimmed = pd.DataFrame()\n",
    "for i in range(5):\n",
    "    App14_sfn_logs_trimmed = App14_sfn_logs_trimmed.append(App14_sfn_logs[execution_start_index[i] : execution_end_index[i]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3000, 2)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "App14_sfn_logs_trimmed.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "App14_duration=pd.DataFrame((App14_sfn_logs_trimmed['End']-App14_sfn_logs_trimmed['Start'])*1000, columns=['Duration'])\n",
    "App14_duration.to_csv('App14_Duration_AWS.csv', index=True)\n",
    "App14_duration = pd.read_csv('App14_Duration_AWS.csv', error_bad_lines=False, warn_bad_lines=False,low_memory=False, index_col=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### End-to-end Response Time Distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of Executions:  3000\n",
      "Average Duration Reported by Step Function:  3235.7523324489594 ms\n",
      "Standard Deviation of Duration Reported by Step Function:  668.7047782725692 ms\n"
     ]
    }
   ],
   "source": [
    "print('Number of Executions: ', len(App14_duration['Duration']))\n",
    "App14_avg_duration_aws = np.mean(App14_duration['Duration'])\n",
    "print('Average Duration Reported by Step Function: ', App14_avg_duration_aws, 'ms')\n",
    "print('Standard Deviation of Duration Reported by Step Function: ', np.std(App14_duration['Duration']), 'ms')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rc('font', size=8)\n",
    "plt.rc('axes', titlesize=6)\n",
    "plt.rc('axes', labelsize=8)\n",
    "fig, ax = plt.subplots(figsize=(10, 6))\n",
    "App14_ExecutionTime_Bplot = ax.boxplot(App14_duration['Duration'], notch=True, patch_artist=False, labels=['App14'], showfliers=False, showmeans=False)\n",
    "ax.plot(np.average(App14_ExecutionTime_Bplot['medians'][0].get_xdata()), np.average(App14_duration['Duration']),color='red', marker='s', markeredgecolor='red')\n",
    "ax.set_ylabel('Execution Time in ms')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "### Query App14 Lambda Function Logs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Functions for parsing Logs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lambda_report_log_to_dict(log):\n",
    "    res={}\n",
    "    lis=[item.split(': ') for item in log[1]['value'].split('\\t')]\n",
    "    res['RequestId']=lis[0][1]\n",
    "    res['Duration']=float(lis[1][1].split(' ')[0])\n",
    "    res['Billed Duration']=int(lis[2][1].split(' ')[0])\n",
    "    res['Memory Size']=int(lis[3][1].split(' ')[0])\n",
    "    res['Max Memory Used']=int(lis[4][1].split(' ')[0])\n",
    "    res['UTCTimestamp'] = time.mktime(datetime.strptime(log[0]['value'], \"%Y-%m-%d %H:%M:%S.%f\").timetuple()) +timezone_offset*3600\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "query_lambda = []\n",
    "for function in function_name_list:\n",
    "    query_lambda.append(logclient.start_query(\n",
    "        logGroupName='/aws/lambda/{}'.format(function),\n",
    "        queryString=\"fields @timestamp, @message| filter @message like 'REPORT'| sort @timestamp asc\",\n",
    "        startTime=startTime_sfn_App14,\n",
    "        endTime=endTime_sfn_App14,\n",
    "        limit=10000\n",
    "        ))\n",
    "    time.sleep(4)\n",
    "time.sleep(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "query_lambda_results = []\n",
    "for q in query_lambda:\n",
    "    query_lambda_results.append(logclient.get_query_results(\n",
    "        queryId=q['queryId']\n",
    "    ))\n",
    "    time.sleep(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "App14_lambda_logs = {'f'+str(i):None for i in range(1, function_number+1)}\n",
    "for i in range(1, function_number+1):\n",
    "    App14_lambda_logs['f'+str(i)] = [lambda_report_log_to_dict(item) for item in query_lambda_results[i-1]['results']]\n",
    "    for item in App14_lambda_logs['f'+str(i)]:\n",
    "        item['Function']='f'+str(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Convert Logs into DataFrame and Save as CSV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "App14_Lambda_Logs=pd.DataFrame()\n",
    "for i in range(1, function_number+1):\n",
    "    App14_Lambda_Logs = App14_Lambda_Logs.append(pd.DataFrame(App14_lambda_logs['f'+str(i)]))\n",
    "App14_Lambda_Logs.index=range(App14_Lambda_Logs.shape[0])\n",
    "App14_Lambda_Logs=App14_Lambda_Logs[['Function', 'Memory Size', 'Max Memory Used', 'Duration', 'Billed Duration', 'UTCTimestamp', 'RequestId']]\n",
    "App14_Lambda_Logs.to_csv('App14_Lambda_Logs.csv',index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "App14_Lambda_Logs = pd.read_csv('App14_Lambda_Logs.csv', error_bad_lines=False, warn_bad_lines=False,low_memory=False)\n",
    "App14_Lambda_Logs.columns = ['Function', 'Memory_Size', 'Max_Memory_Used', 'Duration', 'Billed_Duration', 'UTCTimestamp', 'RequestId']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Function</th>\n",
       "      <th>Memory_Size</th>\n",
       "      <th>Max_Memory_Used</th>\n",
       "      <th>Duration</th>\n",
       "      <th>Billed_Duration</th>\n",
       "      <th>UTCTimestamp</th>\n",
       "      <th>RequestId</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>f1</td>\n",
       "      <td>1536</td>\n",
       "      <td>59</td>\n",
       "      <td>407.36</td>\n",
       "      <td>500</td>\n",
       "      <td>1.580356e+09</td>\n",
       "      <td>5913c347-b5fa-4b9e-aa23-bf8b9d07a700</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>f1</td>\n",
       "      <td>1536</td>\n",
       "      <td>59</td>\n",
       "      <td>419.17</td>\n",
       "      <td>500</td>\n",
       "      <td>1.580356e+09</td>\n",
       "      <td>a14d7892-564b-4bf1-80fe-e88c551cf9e3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>f1</td>\n",
       "      <td>1536</td>\n",
       "      <td>59</td>\n",
       "      <td>624.24</td>\n",
       "      <td>700</td>\n",
       "      <td>1.580356e+09</td>\n",
       "      <td>31ab284d-7d45-4187-aa5b-5642d8e46b4e</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>f1</td>\n",
       "      <td>1536</td>\n",
       "      <td>59</td>\n",
       "      <td>710.40</td>\n",
       "      <td>800</td>\n",
       "      <td>1.580356e+09</td>\n",
       "      <td>92a54c3d-4316-4f83-a973-24b2e72c60e0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>f1</td>\n",
       "      <td>1536</td>\n",
       "      <td>59</td>\n",
       "      <td>716.98</td>\n",
       "      <td>800</td>\n",
       "      <td>1.580356e+09</td>\n",
       "      <td>8b285ce7-899b-4087-bd45-8c4c1496bb23</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Function  Memory_Size  Max_Memory_Used  Duration  Billed_Duration  \\\n",
       "0       f1         1536               59    407.36              500   \n",
       "1       f1         1536               59    419.17              500   \n",
       "2       f1         1536               59    624.24              700   \n",
       "3       f1         1536               59    710.40              800   \n",
       "4       f1         1536               59    716.98              800   \n",
       "\n",
       "   UTCTimestamp                             RequestId  \n",
       "0  1.580356e+09  5913c347-b5fa-4b9e-aa23-bf8b9d07a700  \n",
       "1  1.580356e+09  a14d7892-564b-4bf1-80fe-e88c551cf9e3  \n",
       "2  1.580356e+09  31ab284d-7d45-4187-aa5b-5642d8e46b4e  \n",
       "3  1.580356e+09  92a54c3d-4316-4f83-a973-24b2e72c60e0  \n",
       "4  1.580356e+09  8b285ce7-899b-4087-bd45-8c4c1496bb23  "
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "App14_Lambda_Logs.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Trim Lambda Function Logs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "execution_start_timestamp = [App14_sfn_logs['Start'][i] for i in execution_start_index]\n",
    "execution_end_timestamp = [App14_sfn_logs['End'][i] for i in execution_end_index]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Average Duration and Number of Executions of Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "function_duration_dict = {}\n",
    "function_ne_dict = {}\n",
    "for i in range(1,function_number+1):\n",
    "    temp_df = pd.DataFrame()\n",
    "    for j in range(len(execution_start_timestamp)):\n",
    "        temp_df = temp_df.append(App14_Lambda_Logs.query(\"Function=='{}' and UTCTimestamp>{} and UTCTimestamp<{}\".format('f'+str(i), execution_start_timestamp[j]+1, execution_end_timestamp[j]-1)))\n",
    "    function_duration_dict['f'+str(i)] = temp_df['Duration'].mean()\n",
    "    function_ne_dict['f'+str(i)]  = temp_df.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average Duration of Functions:\n",
      "{'f1': 753.2851566666666, 'f2': 204.29070666666667, 'f3': 524.4368215892055, 'f4': 827.8588409854423, 'f5': 205.21185855263158, 'f6': 509.5000658879904, 'f7': 346.4966170608557, 'f8': 237.66809666666668, 'f9': 162.31541055718475, 'f10': 365.88409539473685, 'f11': 1002.8742775041052, 'f12': 789.5428243021348, 'f13': 377.3143864678899, 'f14': 231.9045553643144}\n",
      "Aboslute Number of Executions of Functions Reported by AWS:\n",
      "{'f1': 3000, 'f2': 3000, 'f3': 3335, 'f4': 1786, 'f5': 1216, 'f6': 3339, 'f7': 3763, 'f8': 3000, 'f9': 2728, 'f10': 608, 'f11': 1218, 'f12': 1218, 'f13': 1744, 'f14': 1743}\n",
      "Relative Number of Executions of Functions Reported by AWS:\n",
      "{'f1': 1.0, 'f2': 1.0, 'f3': 1.1116666666666666, 'f4': 0.5953333333333334, 'f5': 0.4053333333333333, 'f6': 1.113, 'f7': 1.2543333333333333, 'f8': 1.0, 'f9': 0.9093333333333333, 'f10': 0.20266666666666666, 'f11': 0.406, 'f12': 0.406, 'f13': 0.5813333333333334, 'f14': 0.581}\n"
     ]
    }
   ],
   "source": [
    "print('Average Duration of Functions:')\n",
    "print(function_duration_dict)\n",
    "print('Aboslute Number of Executions of Functions Reported by AWS:')\n",
    "print(function_ne_dict)\n",
    "print('Relative Number of Executions of Functions Reported by AWS:')\n",
    "function_ne_dict_relative = {func:function_ne_dict[func]/function_ne_dict['f1'] for func in function_ne_dict.keys()}\n",
    "print(function_ne_dict_relative)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Cost per 1 Million Executions Distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "pricing_model={0:0, 128:0.000000208,192:0.000000313,256:0.000000417,320:0.000000521,384:0.000000625,448:0.000000729,512:0.000000834,576:0.000000938,640:0.000001042,704:0.000001146,768:0.00000125,832:0.000001354,896:0.000001459,960:0.000001563,1024:0.000001667,1088:0.000001771,1152:0.000001875,1216:0.00000198,1280:0.000002084,1344:0.000002188,1408:0.000002292,1472:0.000002396,1536:0.000002501,1600:0.000002605,1664:0.000002709,1728:0.000002813,1792:0.000002917,1856:0.000003021,1920:0.000003126,1984:0.00000323,2048:0.000003334,2112:0.000003438,2176:0.000003542,2240:0.000003647,2304:0.000003751,2368:0.000003855,2432:0.000003959,2496:0.000004063,2560:0.000004168,2624:0.000004272,2688:0.000004376,2752:0.00000448,2816:0.000004584,2880:0.000004688,2944:0.000004793,3008:0.000004897}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "App14_avg_cost_aws_df = pd.DataFrame(columns=['1M_Exe_Cost'])\n",
    "for i in App14_sfn_logs_trimmed.index:\n",
    "    temp_df = App14_Lambda_Logs.query(\"UTCTimestamp>={} and UTCTimestamp<={}\".format(App14_sfn_logs_trimmed['Start'][i]-1, App14_sfn_logs_trimmed['End'][i]+1))\n",
    "    cost = 0\n",
    "    for index, row in temp_df.iterrows():\n",
    "        cost += pricing_model[row['Memory_Size']]*row['Billed_Duration']/100 + 0.0000002\n",
    "    App14_avg_cost_aws_df.loc[i] = [cost*1000000]\n",
    "App14_avg_cost_aws_df.to_csv('App14_Cost_AWS.csv', index=True)\n",
    "App14_avg_cost_aws_df = pd.read_csv('App14_Cost_AWS.csv', error_bad_lines=False, warn_bad_lines=False,low_memory=False, index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of Executions:  3000\n",
      "Average Cost per 1 Million Executions Reported by AWS:  109.05882933333334 USD\n",
      "Standard Deviation of Average Cost per 1 Million Executions Reported by AWS:  25.692638812460263 USD\n"
     ]
    }
   ],
   "source": [
    "print('Number of Executions: ', len(App14_avg_cost_aws_df))\n",
    "App14_avg_cost_aws =  np.mean(App14_avg_cost_aws_df['1M_Exe_Cost'])\n",
    "print('Average Cost per 1 Million Executions Reported by AWS: ', App14_avg_cost_aws, 'USD')\n",
    "print('Standard Deviation of Average Cost per 1 Million Executions Reported by AWS: ', np.std(App14_avg_cost_aws_df['1M_Exe_Cost']), 'USD')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rc('font', size=8)\n",
    "plt.rc('axes', titlesize=6)\n",
    "plt.rc('axes', labelsize=8)\n",
    "fig, ax = plt.subplots(figsize=(10, 6))\n",
    "App14_Cost_Bplot = ax.boxplot(App14_avg_cost_aws_df['1M_Exe_Cost'], notch=True, patch_artist=False, labels=['App14'], showfliers=False, showmeans=False)\n",
    "ax.plot(np.average(App14_Cost_Bplot['medians'][0].get_xdata()), np.average(App14_avg_cost_aws_df['1M_Exe_Cost']),color='red', marker='s', markeredgecolor='red')\n",
    "ax.set_ylabel('Cost per 1 Million Executions in US Dollars')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Analytical Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.append('../../../source/ServerlessAppPerfCostMdlOpt')\n",
    "import networkx as nx\n",
    "import itertools\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "from ServerlessAppWorkflow import ServerlessAppWorkflow\n",
    "from AppGenerator import AppGenerator\n",
    "from PerfOpt import PerfOpt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define App Orchestration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "App14_G = nx.DiGraph()\n",
    "App14_G.add_node('Start', pos=(0, 1))\n",
    "App14_G.add_node(1, pos=(1, 1), mem = mem_config_list['f1'], rt = function_duration_dict['f1'])\n",
    "App14_G.add_node(2, pos=(2, 2), mem = mem_config_list['f2'], rt = function_duration_dict['f2'])\n",
    "App14_G.add_node(3, pos=(2, 0), mem = mem_config_list['f3'], rt = function_duration_dict['f3'])\n",
    "App14_G.add_node(9, pos=(2.5, -0.5), mem = mem_config_list['f9'], rt = function_duration_dict['f9'])\n",
    "App14_G.add_node(10, pos=(2.5, 0.5), mem = mem_config_list['f10'], rt = function_duration_dict['f10'])\n",
    "App14_G.add_node(4, pos=(4, 2.5), mem = mem_config_list['f4'], rt = function_duration_dict['f4'])\n",
    "App14_G.add_node(5, pos=(3, 1.5), mem = mem_config_list['f5'], rt = function_duration_dict['f5'])\n",
    "App14_G.add_node(11, pos=(3.5, 2), mem = mem_config_list['f11'], rt = function_duration_dict['f11'])\n",
    "App14_G.add_node(12, pos=(3.5, 1), mem = mem_config_list['f12'], rt = function_duration_dict['f12'])\n",
    "App14_G.add_node(13, pos=(4.5, 1), mem = mem_config_list['f13'], rt = function_duration_dict['f13'])\n",
    "App14_G.add_node(14, pos=(5.5, 1), mem = mem_config_list['f14'], rt = function_duration_dict['f14'])\n",
    "App14_G.add_node(6, pos=(3, 0), mem = mem_config_list['f6'], rt = function_duration_dict['f6'])\n",
    "App14_G.add_node(7, pos=(7, 1), mem = mem_config_list['f7'], rt = function_duration_dict['f7'])\n",
    "App14_G.add_node(8, pos=(8, 1), mem = mem_config_list['f8'], rt = function_duration_dict['f8'])\n",
    "App14_G.add_node('End', pos=(9, 1))\n",
    "App14_G.add_weighted_edges_from([(1, 2, 1),(1, 3, 1),(2, 4, 0.6),(2, 5, 0.4),(4, 7, 1),(5, 11, 1),(5, 12, 1),(11, 7, 1),(12, 13, 1),(13, 14, 1),(14, 13, 0.3),(14, 7, 0.7),(3, 9, 0.8),(3, 10, 0.2),(9, 6, 1),(10, 6, 1), (6, 7, 0.9), (6, 3, 0.1), (7, 8, 0.8),(7, 7, 0.2)])\n",
    "App14_G.add_weighted_edges_from([('Start', 1, 1), (8, 'End', 1)])\n",
    "pos_App14_G = nx.get_node_attributes(App14_G, 'pos')\n",
    "nx.draw(App14_G, pos_App14_G, with_labels=True)\n",
    "labels_App14_G = nx.get_edge_attributes(App14_G, 'weight')\n",
    "nx.draw_networkx_edge_labels(App14_G, pos_App14_G, edge_labels=labels_App14_G)\n",
    "pos_higher_offset_App14_G = {}\n",
    "for k, v in pos_App14_G.items():\n",
    "    pos_higher_offset_App14_G[k] = (v[0], v[1] + 0.15)\n",
    "plt.savefig('App14_G.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Relative Number of Executions of Functions Reported by Model:\n",
      "{'Start': 0, 1: 1, 2: 1, 3: 1.1111111111111112, 9: 0.888888888888889, 10: 0.22222222222222224, 4: 0.6, 5: 0.4, 11: 0.4, 12: 0.4, 13: 0.5714285714285715, 14: 0.5714285714285715, 6: 1.1111111111111112, 7: 1.25, 8: 1, 'End': 0}\n",
      "Average End-to-end Response Time Reported by Model: 3280.655813420972\n",
      "Average Cost per 1 Million Executions Reported by Model: 110.10863492063493\n",
      "Accuracy of the End-to-end Response Time Modeling:  98.6312651029006\n",
      "Accuracy of the Cost Modeling:  99.96800013024814\n"
     ]
    }
   ],
   "source": [
    "App14 = ServerlessAppWorkflow(G=App14_G.copy(), delayType='SFN')\n",
    "App14.update_NE()\n",
    "print('Relative Number of Executions of Functions Reported by Model:')\n",
    "print(App14.ne)\n",
    "App14cost = App14.get_avg_cost()\n",
    "App14.get_simple_dag()\n",
    "App14rt = App14.get_avg_rt()\n",
    "print(\"Average End-to-end Response Time Reported by Model: {}\".format(App14rt))\n",
    "print(\"Average Cost per 1 Million Executions Reported by Model: {}\".format(App14cost))\n",
    "rt_accuracy = 100-(App14rt-App14_avg_duration_aws)/App14rt*100\n",
    "print(\"Accuracy of the End-to-end Response Time Modeling: \", rt_accuracy)\n",
    "cost_accuracy = 100-(App14cost-App14_avg_cost_aws)/App14rt*100\n",
    "print(\"Accuracy of the Cost Modeling: \", cost_accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('results.json', 'w', encoding='utf-8') as f:\n",
    "    json.dump({\"RT_Model\":App14rt, \"RT_Accuracy\":rt_accuracy,\n",
    "               \"Cost_Model\":App14cost, \"Cost_Accuracy\":cost_accuracy\n",
    "              }, f, ensure_ascii=False, indent=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of the End-to-end Response Time Modeling:  98.6312651029006\n"
     ]
    }
   ],
   "source": [
    "plt.rc('font', size=8)\n",
    "plt.rc('axes', titlesize=6)\n",
    "plt.rc('axes', labelsize=8)\n",
    "fig, ax = plt.subplots(figsize=(10, 6))\n",
    "App14_ExecutionTime_Bplot = ax.boxplot(App14_duration['Duration'], notch=True, patch_artist=False, labels=['App14'], showfliers=False, showmeans=False)\n",
    "App14_rt_aws, = ax.plot(np.average(App14_ExecutionTime_Bplot['medians'][0].get_xdata()), np.average(App14_duration['Duration']), color='red', marker='s', markeredgecolor='red')\n",
    "App14_rt_model, = ax.plot(np.average(App14_ExecutionTime_Bplot['medians'][0].get_xdata()), App14rt, color='blue', marker='x', markeredgecolor='blue')\n",
    "App14_rt_aws.set_label('Average End-to-end RT Reported by AWS')\n",
    "App14_rt_model.set_label('Average End-to-end RT Reported by Model')\n",
    "ax.set_ylabel('End-to-end Response Time in ms')\n",
    "ax.legend()\n",
    "plt.show()\n",
    "print(\"Accuracy of the End-to-end Response Time Modeling: \", rt_accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of the Cost Modeling:  99.96800013024814\n"
     ]
    }
   ],
   "source": [
    "plt.rc('font', size=8)\n",
    "plt.rc('axes', titlesize=6)\n",
    "plt.rc('axes', labelsize=8)\n",
    "fig, ax = plt.subplots(figsize=(10, 6))\n",
    "App14_Cost_Bplot = ax.boxplot(App14_avg_cost_aws_df['1M_Exe_Cost'], notch=True, patch_artist=False, labels=['App14'], showfliers=False, showmeans=False)\n",
    "App14_cost_aws, = ax.plot(np.average(App14_Cost_Bplot['medians'][0].get_xdata()), np.average(App14_avg_cost_aws_df['1M_Exe_Cost']), color='red', marker='s', markeredgecolor='red')\n",
    "App14_cost_model, = ax.plot(np.average(App14_Cost_Bplot['medians'][0].get_xdata()),App14cost, color='blue', marker='x', markeredgecolor='blue')\n",
    "App14_cost_aws.set_label('Average Cost per 1 Million Executions Reported by AWS')\n",
    "App14_cost_model.set_label('Average Cost per 1 Million Executions Reported by Model')\n",
    "ax.set_ylabel('Cost per 1 Million Executions in US Dollars')\n",
    "ax.legend()\n",
    "plt.show()\n",
    "print(\"Accuracy of the Cost Modeling: \", cost_accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.6",
   "language": "python",
   "name": "python3.7"
  },
  "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}