From 4a06d0883258e8bd5e5f46481e1bce05b5f336de Mon Sep 17 00:00:00 2001 From: James Harrison Date: Fri, 24 Jul 2020 18:07:04 +0100 Subject: [PATCH 1/3] Framework of 'mobility indicators' worked example --- mobility-indicators.ipynb | 2268 +++++++++++++++++++++++++++++++++++++ 1 file changed, 2268 insertions(+) create mode 100644 mobility-indicators.ipynb diff --git a/mobility-indicators.ipynb b/mobility-indicators.ipynb new file mode 100644 index 0000000..3eee303 --- /dev/null +++ b/mobility-indicators.ipynb @@ -0,0 +1,2268 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Mobility indicators\n", + "## Assessing the impact of mobility restrictions during a virus outbreak\n", + "\n", + "In this worked example...\n", + "\n", + "(Include link to COVID website)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Introduction\n", + "\n", + "- What we aim to do\n", + "- Summary of where we're heading, what prior knowledge is required, and what the end result will be" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run aggregates\n", + "\n", + "- Define queries\n", + "- Set aggregates running\n", + "- Get results" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [], + "source": [ + "import flowclient as fc\n", + "import pandas as pd\n", + "import geopandas as gpd\n", + "import matplotlib.pyplot as plt\n", + "from collections import Counter" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [], + "source": [ + "token = " + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [], + "source": [ + "conn = fc.connect(\n", + " url=\"https://api.flowcloud-ghana.flowminder.org\",\n", + " token=token,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": {}, + "outputs": [], + "source": [ + "# Define date range\n", + "start_date = \"2016-02-01\"\n", + "end_date = \"2016-06-01\"\n", + "all_dates = pd.date_range(start_date, end_date, closed=\"left\")" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [], + "source": [ + "# Total subscribers per day\n", + "\n", + "# E.g. query for 1 day\n", + "total_subscribers_20160101_query = fc.unique_subscriber_counts(\n", + " connection=conn,\n", + " start_date=\"2016-01-01\",\n", + " end_date=\"2016-01-02\",\n", + " aggregation_unit=\"admin0\",\n", + ")\n", + "\n", + "# Queries for all dates\n", + "total_subscribers_per_day_queries = {}\n", + "\n", + "for day in all_dates:\n", + " total_subscribers_per_day_queries[day] = fc.unique_subscriber_counts(\n", + " connection=conn,\n", + " start_date=str(day),\n", + " end_date=str(day + pd.Timedelta(\"1 day\")),\n", + " aggregation_unit=\"admin0\",\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [], + "source": [ + "# Set them running\n", + "for query in total_subscribers_per_day_queries.values():\n", + " query.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [], + "source": [ + "# Subscribers per admin1 per day\n", + "subscribers_per_admin1_per_day_queries = {\n", + " day: fc.unique_subscriber_counts(\n", + " connection=conn,\n", + " start_date=str(day),\n", + " end_date=str(day + pd.Timedelta(\"1 day\")),\n", + " aggregation_unit=\"admin1\",\n", + " )\n", + " for day in all_dates\n", + "}\n", + "\n", + "for query in subscribers_per_admin1_per_day_queries.values():\n", + " query.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 146, + "metadata": {}, + "outputs": [], + "source": [ + "# Subscribers per admin2 per day\n", + "subscribers_per_admin2_per_day_queries = {\n", + " day: fc.unique_subscriber_counts(\n", + " connection=conn,\n", + " start_date=str(day),\n", + " end_date=str(day + pd.Timedelta(\"1 day\")),\n", + " aggregation_unit=\"admin2\",\n", + " )\n", + " for day in all_dates\n", + "}\n", + "\n", + "for query in subscribers_per_admin2_per_day_queries.values():\n", + " query.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [], + "source": [ + "# OD matrix (admin2)\n", + "od_matrix_admin2_per_day_queries = {\n", + " day: fc.trips_od_matrix(\n", + " connection=conn,\n", + " start_date=str(day),\n", + " end_date=str(day + pd.Timedelta(\"1 day\")),\n", + " aggregation_unit=\"admin2\",\n", + " )\n", + " for day in all_dates\n", + "}\n", + "\n", + "for query in od_matrix_admin2_per_day_queries.values():\n", + " query.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "metadata": {}, + "outputs": [], + "source": [ + "# Total events per day\n", + "\n", + "total_events_per_day_query = fc.location_event_counts(\n", + " connection=conn,\n", + " start_date=start_date,\n", + " end_date=end_date,\n", + " count_interval=\"day\",\n", + " aggregation_unit=\"admin0\",\n", + ")\n", + "\n", + "total_events_per_day_query.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": {}, + "outputs": [], + "source": [ + "# Event counts (admin2 per day)\n", + "events_per_admin2_per_day_query = fc.location_event_counts(\n", + " connection=conn,\n", + " start_date=start_date,\n", + " end_date=end_date,\n", + " count_interval=\"day\",\n", + " aggregation_unit=\"admin2\",\n", + ")\n", + "\n", + "events_per_admin2_per_day_query.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total subscribers: Counter({'completed': 121})\n", + "Subscribers per admin1: Counter({'completed': 121})\n" + ] + }, + { + "ename": "FlowclientConnectionError", + "evalue": "Something went wrong: . API returned with status code: 500 and status 'errored'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFlowclientConnectionError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 7\u001b[0m ]:\n\u001b[1;32m 8\u001b[0m print(\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0;34mf\"{label}: {Counter([query.status for query in query_group.values()])}\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 10\u001b[0m )\n\u001b[1;32m 11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 7\u001b[0m ]:\n\u001b[1;32m 8\u001b[0m print(\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0;34mf\"{label}: {Counter([query.status for query in query_group.values()])}\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 10\u001b[0m )\n\u001b[1;32m 11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/share/virtualenvs/FlowKit-tutorials-Ghana-XGVjzS5J/lib/python3.8/site-packages/flowclient/api_query.py\u001b[0m in \u001b[0;36mstatus\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 83\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"_query_id\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 84\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0;34m\"not_running\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 85\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mget_status\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconnection\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconnection\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mquery_id\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_query_id\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 86\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 87\u001b[0m def get_result(\n", + "\u001b[0;32m~/.local/share/virtualenvs/FlowKit-tutorials-Ghana-XGVjzS5J/lib/python3.8/site-packages/flowclient/client.py\u001b[0m in \u001b[0;36mget_status\u001b[0;34m(connection, query_id)\u001b[0m\n\u001b[1;32m 117\u001b[0m \"\"\"\n\u001b[1;32m 118\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 119\u001b[0;31m \u001b[0mready\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreply\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mquery_is_ready\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconnection\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mconnection\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mquery_id\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mquery_id\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 120\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mFileNotFoundError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 121\u001b[0m \u001b[0;31m# Can't distinguish 'known', 'cancelled', 'resetting' and 'awol' from the error,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/share/virtualenvs/FlowKit-tutorials-Ghana-XGVjzS5J/lib/python3.8/site-packages/flowclient/client.py\u001b[0m in \u001b[0;36mquery_is_ready\u001b[0;34m(connection, query_id)\u001b[0m\n\u001b[1;32m 75\u001b[0m \u001b[0;34mf\"Polling server on {connection.url}/api/{connection.api_version}/poll/{query_id}\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 76\u001b[0m )\n\u001b[0;32m---> 77\u001b[0;31m \u001b[0mreply\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconnection\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_url\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mroute\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34mf\"poll/{query_id}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 78\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 79\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mreply\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstatus_code\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m303\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.local/share/virtualenvs/FlowKit-tutorials-Ghana-XGVjzS5J/lib/python3.8/site-packages/flowclient/connection.py\u001b[0m in \u001b[0;36mget_url\u001b[0;34m(self, route, data)\u001b[0m\n\u001b[1;32m 137\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mValueError\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 138\u001b[0m \u001b[0mstatus\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"Unknown status\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 139\u001b[0;31m raise FlowclientConnectionError(\n\u001b[0m\u001b[1;32m 140\u001b[0m \u001b[0;34mf\"Something went wrong: {error}. API returned with status code: {response.status_code} and status '{status}'\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 141\u001b[0m )\n", + "\u001b[0;31mFlowclientConnectionError\u001b[0m: Something went wrong: . API returned with status code: 500 and status 'errored'" + ] + } + ], + "source": [ + "# Check statuses\n", + "for label, query_group in [\n", + " (\"Total subscribers\", total_subscribers_per_day_queries),\n", + " (\"Subscribers per admin1\", subscribers_per_admin1_per_day_queries),\n", + " (\"Subscribers_per_admin2\", subscribers_per_admin2_per_day_queries),\n", + " (\"OD matrix\", od_matrix_admin2_per_day_queries),\n", + "]:\n", + " print(\n", + " f\"{label}: {Counter([query.status for query in query_group.values()])}\"\n", + " )\n", + "\n", + "print(f\"Total events: {total_events_per_day_query.status}\")\n", + "print(f\"Events per admin2: {events_per_admin2_per_day_query.status}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pcodvalue
0GH2136902
\n", + "
" + ], + "text/plain": [ + " pcod value\n", + "0 GH 2136902" + ] + }, + "execution_count": 93, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Get results\n", + "\n", + "# Get one result\n", + "first_result = total_subscribers_per_day_queries[all_dates[0]].get_result()\n", + "first_result" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pcodvaluedate
0GH21369022016-02-01
\n", + "
" + ], + "text/plain": [ + " pcod value date\n", + "0 GH 2136902 2016-02-01" + ] + }, + "execution_count": 94, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Add date column\n", + "first_result[\"date\"] = all_dates[0]\n", + "first_result" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "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", + "
pcodvaluedate
0GH21369022016-02-01
1GH21369172016-02-02
2GH21382072016-02-03
3GH21366912016-02-04
4GH21375452016-02-05
............
116GH21367742016-05-27
117GH21372982016-05-28
118GH21375512016-05-29
119GH21377482016-05-30
120GH21374702016-05-31
\n", + "

121 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " pcod value date\n", + "0 GH 2136902 2016-02-01\n", + "1 GH 2136917 2016-02-02\n", + "2 GH 2138207 2016-02-03\n", + "3 GH 2136691 2016-02-04\n", + "4 GH 2137545 2016-02-05\n", + ".. ... ... ...\n", + "116 GH 2136774 2016-05-27\n", + "117 GH 2137298 2016-05-28\n", + "118 GH 2137551 2016-05-29\n", + "119 GH 2137748 2016-05-30\n", + "120 GH 2137470 2016-05-31\n", + "\n", + "[121 rows x 3 columns]" + ] + }, + "execution_count": 95, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Get all results with date columns\n", + "all_total_subscribers_results = [\n", + " query.get_result().assign(date=day)\n", + " for day, query in total_subscribers_per_day_queries.items()\n", + "]\n", + "\n", + "total_subscribers_per_day_results = pd.concat(all_total_subscribers_results, ignore_index=True)\n", + "\n", + "total_subscribers_per_day_results" + ] + }, + { + "cell_type": "code", + "execution_count": 157, + "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", + "
valuedate
021369022016-02-01
121369172016-02-02
221382072016-02-03
321366912016-02-04
421375452016-02-05
.........
11621367742016-05-27
11721372982016-05-28
11821375512016-05-29
11921377482016-05-30
12021374702016-05-31
\n", + "

121 rows × 2 columns

\n", + "
" + ], + "text/plain": [ + " value date\n", + "0 2136902 2016-02-01\n", + "1 2136917 2016-02-02\n", + "2 2138207 2016-02-03\n", + "3 2136691 2016-02-04\n", + "4 2137545 2016-02-05\n", + ".. ... ...\n", + "116 2136774 2016-05-27\n", + "117 2137298 2016-05-28\n", + "118 2137551 2016-05-29\n", + "119 2137748 2016-05-30\n", + "120 2137470 2016-05-31\n", + "\n", + "[121 rows x 2 columns]" + ] + }, + "execution_count": 157, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Don't need \"pcod\" column, so let's drop it now\n", + "total_subscribers_per_day_results = total_subscribers_per_day_results.drop(columns=\"pcod\")\n", + "total_subscribers_per_day_results" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "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", + "
pcodvaluedate
0GHA.10_12276802016-02-01
1GHA.1_14701412016-02-01
2GHA.2_12046972016-02-01
3GHA.3_12222212016-02-01
4GHA.4_12467792016-02-01
............
1205GHA.5_14559082016-05-31
1206GHA.6_12996732016-05-31
1207GHA.7_11175762016-05-31
1208GHA.8_1723022016-05-31
1209GHA.9_12485452016-05-31
\n", + "

1210 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " pcod value date\n", + "0 GHA.10_1 227680 2016-02-01\n", + "1 GHA.1_1 470141 2016-02-01\n", + "2 GHA.2_1 204697 2016-02-01\n", + "3 GHA.3_1 222221 2016-02-01\n", + "4 GHA.4_1 246779 2016-02-01\n", + "... ... ... ...\n", + "1205 GHA.5_1 455908 2016-05-31\n", + "1206 GHA.6_1 299673 2016-05-31\n", + "1207 GHA.7_1 117576 2016-05-31\n", + "1208 GHA.8_1 72302 2016-05-31\n", + "1209 GHA.9_1 248545 2016-05-31\n", + "\n", + "[1210 rows x 3 columns]" + ] + }, + "execution_count": 96, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Get admin1 subscriber counts\n", + "subscribers_per_admin1_per_day_results = pd.concat(\n", + " [\n", + " query.get_result().assign(date=day)\n", + " for day, query in subscribers_per_admin1_per_day_queries.items()\n", + " ],\n", + " ignore_index=True,\n", + ")\n", + "\n", + "subscribers_per_admin1_per_day_results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Get admin2 subscriber counts\n", + "subscribers_per_admin2_per_day_results = pd.concat(\n", + " [\n", + " query.get_result().assign(date=day)\n", + " for day, query in subscribers_per_admin2_per_day_queries.items()\n", + " ],\n", + " ignore_index=True,\n", + ")\n", + "\n", + "subscribers_per_admin2_per_day_results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Get admin2 OD matrix results\n", + "od_matrix_admin2_per_day_results = pd.concat(\n", + " [\n", + " query.get_result().assign(date=day)\n", + " for day, query in od_matrix_admin2_per_day_queries.items()\n", + " ],\n", + " ignore_index=True,\n", + ")\n", + "\n", + "od_matrix_admin2_per_day_results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Get total event counts\n", + "total_events_per_day_results = total_events_per_day_query.get_result()\n", + "\n", + "# Don't need to add a date column because it already has one, but...\n", + "total_events_per_day_results.info()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Date column is 'object' type (i.e. string) - need to convert to datetime\n", + "total_events_per_day_results[\"date\"] = pd.to_datetime(total_events_per_day_results[\"date\"])\n", + "\n", + "total_events_per_day_results" + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "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", + "
pcoddatevalue
0GHA.10.10_12016-02-01136114
1GHA.10.1_12016-02-0128901
2GHA.10.11_12016-02-0118318
3GHA.10.12_12016-02-0129705
4GHA.10.13_12016-02-0147380
............
16500GHA.9.5_12016-05-3131992
16501GHA.9.6_12016-05-3113468
16502GHA.9.7_12016-05-3134588
16503GHA.9.8_12016-05-3153798
16504GHA.9.9_12016-05-3124071
\n", + "

16505 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " pcod date value\n", + "0 GHA.10.10_1 2016-02-01 136114\n", + "1 GHA.10.1_1 2016-02-01 28901\n", + "2 GHA.10.11_1 2016-02-01 18318\n", + "3 GHA.10.12_1 2016-02-01 29705\n", + "4 GHA.10.13_1 2016-02-01 47380\n", + "... ... ... ...\n", + "16500 GHA.9.5_1 2016-05-31 31992\n", + "16501 GHA.9.6_1 2016-05-31 13468\n", + "16502 GHA.9.7_1 2016-05-31 34588\n", + "16503 GHA.9.8_1 2016-05-31 53798\n", + "16504 GHA.9.9_1 2016-05-31 24071\n", + "\n", + "[16505 rows x 3 columns]" + ] + }, + "execution_count": 121, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Get admin2 event counts\n", + "events_per_admin2_per_day_results = events_per_admin2_per_day_query.get_result()\n", + "events_per_admin2_per_day_results[\"date\"] = pd.to_datetime(events_per_admin2_per_day_results[\"date\"])\n", + "\n", + "events_per_admin2_per_day_results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### QA checks\n", + "\n", + "- Additional queries (define, run, get results)\n", + "- Run checks\n", + " - Subscriber counts in urban vs rural\n", + " - sum(admin2 counts) / admin1 count ? (Maybe not - this might be an indicator)\n", + " - Stable over time (total, and per locality)\n", + " - Weekly variation (except there won't actually be any in the synthetic data)\n", + " - Events per subscriber - check sensible value and stable over time\n", + " - Missing data (temporal or spatial)\n", + "- Explain results (and how to tell whether they 'passed')\n", + "\n", + "**Note:** Don't need all checks, because some are covered by FlowKit tests (i.e. we need to QA check the data, not the implementation)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Time-series plots\n", + "Should be stable over time and show weekly variation" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 98, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "total_subscribers_per_day_results.plot(x=\"date\", y=\"value\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Should be stable over time except for possible small changes due to new mobility restrictions\n", + "- Should show weekly variation (but not in the synthetic data)" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "subscribers_per_admin1_per_day_results.pivot(index=\"date\", columns=\"pcod\", values=\"value\").plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 142, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "subscribers_per_admin2_per_day_results.pivot(index=\"date\", columns=\"pcod\", values=\"value\").plot(legend=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 152, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 152, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# May be clearer to plot sum\n", + "plt.figure()\n", + "subscribers_per_admin2_per_day_results.groupby(\"date\").sum().plot(ax=plt.gca(), y=\"value\", label=\"sum(subscribers per admin2)\")\n", + "\n", + "# Similar for OD matrix\n", + "od_matrix_admin2_per_day_results.groupby(\"date\").sum().plot(ax=plt.gca(), y=\"value\", label=\"sum(OD matrix)\")\n", + "\n", + "# Show total subscribers for comparison\n", + "total_subscribers_per_day_results.plot(ax=plt.gca(), x=\"date\", y=\"value\", label=\"total subscribers\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Should be stable over time except for changes due to new mobility restrictions (in this case, sharp changes are due to start of simulated \"disaster\" on 2016-03-01 and start of recovery period on 2016-03-10)\n", + "- Should show weekly variation (but not in the synthetic data)\n", + "- Explain why sum of admin2 is larger than total" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Spatial distribution of subscriber counts\n", + "Should be larger in urban districts, smaller in rural" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Calculate median daily subscriber count per admin2\n", + "median_subscribers_per_admin2 = subscribers_per_admin2_per_day_results.groupby(\"pcod\").median()" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "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", + "
geometrypcodcentroid
0MULTIPOLYGON (((-1.41637 6.32333, -1.43242 6.3...GHA.1.1_1{'type': 'Point', 'coordinates': [-1.585607706...
1MULTIPOLYGON (((-1.54145 5.93492, -1.53550 5.9...GHA.1.2_1{'type': 'Point', 'coordinates': [-1.394701237...
2MULTIPOLYGON (((-1.41025 6.86558, -1.42795 6.8...GHA.1.3_1{'type': 'Point', 'coordinates': [-1.557937016...
3MULTIPOLYGON (((-2.29597 6.71882, -2.29462 6.7...GHA.1.4_1{'type': 'Point', 'coordinates': [-2.201639978...
4MULTIPOLYGON (((-1.81879 6.98329, -1.83513 6.9...GHA.1.5_1{'type': 'Point', 'coordinates': [-1.957634046...
............
132MULTIPOLYGON (((-2.36110 6.08630, -2.36740 6.0...GHA.10.9_1{'type': 'Point', 'coordinates': [-2.609585309...
133MULTIPOLYGON (((-1.82511 5.57554, -1.82662 5.5...GHA.10.11_1{'type': 'Point', 'coordinates': [-2.009582598...
134MULTIPOLYGON (((-1.70347 4.94569, -1.70347 4.9...GHA.10.10_1{'type': 'Point', 'coordinates': [-1.658353642...
135MULTIPOLYGON (((-2.59935 5.44091, -2.59728 5.4...GHA.10.12_1{'type': 'Point', 'coordinates': [-2.332295004...
136MULTIPOLYGON (((-1.97473 4.91827, -1.98106 4.9...GHA.10.13_1{'type': 'Point', 'coordinates': [-1.990833941...
\n", + "

137 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " geometry pcod \\\n", + "0 MULTIPOLYGON (((-1.41637 6.32333, -1.43242 6.3... GHA.1.1_1 \n", + "1 MULTIPOLYGON (((-1.54145 5.93492, -1.53550 5.9... GHA.1.2_1 \n", + "2 MULTIPOLYGON (((-1.41025 6.86558, -1.42795 6.8... GHA.1.3_1 \n", + "3 MULTIPOLYGON (((-2.29597 6.71882, -2.29462 6.7... GHA.1.4_1 \n", + "4 MULTIPOLYGON (((-1.81879 6.98329, -1.83513 6.9... GHA.1.5_1 \n", + ".. ... ... \n", + "132 MULTIPOLYGON (((-2.36110 6.08630, -2.36740 6.0... GHA.10.9_1 \n", + "133 MULTIPOLYGON (((-1.82511 5.57554, -1.82662 5.5... GHA.10.11_1 \n", + "134 MULTIPOLYGON (((-1.70347 4.94569, -1.70347 4.9... GHA.10.10_1 \n", + "135 MULTIPOLYGON (((-2.59935 5.44091, -2.59728 5.4... GHA.10.12_1 \n", + "136 MULTIPOLYGON (((-1.97473 4.91827, -1.98106 4.9... GHA.10.13_1 \n", + "\n", + " centroid \n", + "0 {'type': 'Point', 'coordinates': [-1.585607706... \n", + "1 {'type': 'Point', 'coordinates': [-1.394701237... \n", + "2 {'type': 'Point', 'coordinates': [-1.557937016... \n", + "3 {'type': 'Point', 'coordinates': [-2.201639978... \n", + "4 {'type': 'Point', 'coordinates': [-1.957634046... \n", + ".. ... \n", + "132 {'type': 'Point', 'coordinates': [-2.609585309... \n", + "133 {'type': 'Point', 'coordinates': [-2.009582598... \n", + "134 {'type': 'Point', 'coordinates': [-1.658353642... \n", + "135 {'type': 'Point', 'coordinates': [-2.332295004... \n", + "136 {'type': 'Point', 'coordinates': [-1.990833941... \n", + "\n", + "[137 rows x 3 columns]" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Get admin2 boundaries\n", + "admin2_geojson = fc.get_geography(connection=conn, aggregation_unit=\"admin2\")\n", + "admin2_gdf = gpd.GeoDataFrame.from_features(admin2_geojson)\n", + "admin2_gdf" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Join median subscriber counts to admin boundaries, and plot\n", + "median_subscribers_per_admin2_with_geo = admin2_gdf.merge(\n", + " median_subscribers_per_admin2, left_on=\"pcod\", right_index=True\n", + ")\n", + "\n", + "median_subscribers_per_admin2_with_geo.plot(column=\"value\", legend=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Should have larger subscriber counts in urban districts, and smaller in rural districts" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Events per subscriber (for each admin2, then for whole country)" + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 124, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Total events per day\n", + "average_events_per_subscriber = total_events_per_day_results.set_index(\"date\").value / total_subscribers_per_day_results.set_index(\"date\").value\n", + "\n", + "average_events_per_subscriber.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Values should be reasonable (e.g. not 500 events per subscriber per day)\n", + "- Values should be >= 1 (because every active subscriber has at least 1 event\n", + "- Values should be fairly stable over time" + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 141, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Per admin2\n", + "events_per_subscriber_per_admin2 = (\n", + " events_per_admin2_per_day_results.set_index([\"date\", \"pcod\"]) / subscribers_per_admin2_per_day_results.set_index([\"date\", \"pcod\"])\n", + ").reset_index()\n", + "events_per_subscriber_per_admin2.pivot(index=\"date\", columns=\"pcod\", values=\"value\").plot(legend=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Missing data\n", + "- Total events per day, over time" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 135, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "total_events_per_day_results.plot(x=\"date\", y=\"value\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- If there's an anomaly, show a map of events per admin2 on that day, to see if there's a spatial effect" + ] + }, + { + "cell_type": "code", + "execution_count": 156, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 156, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# E.g. if total event count was lower on 13 March, can plot event count per admin2 on that day\n", + "admin2_gdf.merge(\n", + " events_per_admin2_per_day_results[events_per_admin2_per_day_results.date == \"2016-03-14\"],\n", + " on=\"pcod\",\n", + ").plot(column=\"value\", legend=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If no data for parts of the country, suggests the CDR data are incomplete." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Indicators\n", + "\n", + "- Calculate indicators from aggregates\n", + " - Scaled subscriber count per admin2 (including baseline calculation)\n", + " - Average admin2 visited per subscriber for each admin1\n", + " - Scaled OD matrix subscriber count\n", + "- Produce visualisations (not sure exactly what to show for OD matrix - maybe pick a few pairs and show line plots; could also do a before vs after map of Accra -> other)\n", + "- Explain what we see" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Scaled subscriber count per admin2\n", + "\n", + "- Divide subscriber count by total, to mitigate effects of changes in calling behaviour (i.e. assume actual number of people is ~ constant, so changes in total are due to people calling more/less)\n", + "- Calculate baseline average\n", + "- % of baseline" + ] + }, + { + "cell_type": "code", + "execution_count": 181, + "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", + "
pcodvaluedatetotal_subscribersscaled_subscriber_count
0GHA.10.10_1649822016-02-0321382070.030391
1GHA.10.1_1138682016-02-0321382070.006486
2GHA.10.11_189342016-02-0321382070.004178
3GHA.10.12_1144852016-02-0321382070.006774
4GHA.10.13_1227582016-02-0321382070.010643
..................
5580GHA.9.5_1153982016-04-1121370140.007205
5581GHA.9.6_164032016-04-1121370140.002996
5582GHA.9.7_1164602016-04-1121370140.007702
5583GHA.9.8_1254062016-04-1121370140.011889
5584GHA.9.9_1118492016-04-1121370140.005545
\n", + "

5585 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " pcod value date total_subscribers \\\n", + "0 GHA.10.10_1 64982 2016-02-03 2138207 \n", + "1 GHA.10.1_1 13868 2016-02-03 2138207 \n", + "2 GHA.10.11_1 8934 2016-02-03 2138207 \n", + "3 GHA.10.12_1 14485 2016-02-03 2138207 \n", + "4 GHA.10.13_1 22758 2016-02-03 2138207 \n", + "... ... ... ... ... \n", + "5580 GHA.9.5_1 15398 2016-04-11 2137014 \n", + "5581 GHA.9.6_1 6403 2016-04-11 2137014 \n", + "5582 GHA.9.7_1 16460 2016-04-11 2137014 \n", + "5583 GHA.9.8_1 25406 2016-04-11 2137014 \n", + "5584 GHA.9.9_1 11849 2016-04-11 2137014 \n", + "\n", + " scaled_subscriber_count \n", + "0 0.030391 \n", + "1 0.006486 \n", + "2 0.004178 \n", + "3 0.006774 \n", + "4 0.010643 \n", + "... ... \n", + "5580 0.007205 \n", + "5581 0.002996 \n", + "5582 0.007702 \n", + "5583 0.011889 \n", + "5584 0.005545 \n", + "\n", + "[5585 rows x 5 columns]" + ] + }, + "execution_count": 181, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Merge admin2 and total subscribers\n", + "merged_subscriber_counts = subscribers_per_admin2_per_day_results.merge(\n", + " total_subscribers_per_day_results.rename(columns={\"value\": \"total_subscribers\"}), on=\"date\"\n", + ")\n", + "\n", + "# Divide sub count by total subs to get scaled sub count\n", + "merged_subscriber_counts[\"scaled_subscriber_count\"] = (\n", + " merged_subscriber_counts.value / merged_subscriber_counts.total_subscribers\n", + ")\n", + "\n", + "merged_subscriber_counts" + ] + }, + { + "cell_type": "code", + "execution_count": 182, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "pcod\n", + "GHA.1.10_1 0.004650\n", + "GHA.1.11_1 0.009366\n", + "GHA.1.12_1 0.005379\n", + "GHA.1.13_1 0.011214\n", + "GHA.1.14_1 0.006864\n", + " ... \n", + "GHA.9.5_1 0.005901\n", + "GHA.9.6_1 0.002443\n", + "GHA.9.7_1 0.006250\n", + "GHA.9.8_1 0.009675\n", + "GHA.9.9_1 0.004555\n", + "Name: scaled_subscriber_count, Length: 137, dtype: float64" + ] + }, + "execution_count": 182, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Baseline median\n", + "baseline_start = \"2016-02-01\"\n", + "baseline_end = \"2016-02-29\"\n", + "\n", + "scaled_subscriber_count_baseline = merged_subscriber_counts[\n", + " (merged_subscriber_counts.date >= baseline_start)\n", + " & (merged_subscriber_counts.date < baseline_end)\n", + "].groupby(\"pcod\").median().scaled_subscriber_count\n", + "scaled_subscriber_count_baseline" + ] + }, + { + "cell_type": "code", + "execution_count": 183, + "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", + "
pcodvaluedatetotal_subscribersscaled_subscriber_countscaled_subscriber_count_baseline
0GHA.10.10_1649822016-02-0321382070.0303910.030399
137GHA.10.10_1651102016-02-0421366910.0304720.030399
274GHA.10.10_1649112016-02-0721371920.0303720.030399
411GHA.10.10_1649482016-02-1021368680.0303940.030399
548GHA.10.10_1651592016-02-1121370270.0304900.030399
.....................
5036GHA.9.9_1118122016-04-0721373040.0055270.004555
5173GHA.9.9_1117962016-04-0821377080.0055180.004555
5310GHA.9.9_1117702016-04-0921370870.0055070.004555
5447GHA.9.9_1118642016-04-1021359130.0055550.004555
5584GHA.9.9_1118492016-04-1121370140.0055450.004555
\n", + "

5585 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " pcod value date total_subscribers \\\n", + "0 GHA.10.10_1 64982 2016-02-03 2138207 \n", + "137 GHA.10.10_1 65110 2016-02-04 2136691 \n", + "274 GHA.10.10_1 64911 2016-02-07 2137192 \n", + "411 GHA.10.10_1 64948 2016-02-10 2136868 \n", + "548 GHA.10.10_1 65159 2016-02-11 2137027 \n", + "... ... ... ... ... \n", + "5036 GHA.9.9_1 11812 2016-04-07 2137304 \n", + "5173 GHA.9.9_1 11796 2016-04-08 2137708 \n", + "5310 GHA.9.9_1 11770 2016-04-09 2137087 \n", + "5447 GHA.9.9_1 11864 2016-04-10 2135913 \n", + "5584 GHA.9.9_1 11849 2016-04-11 2137014 \n", + "\n", + " scaled_subscriber_count scaled_subscriber_count_baseline \n", + "0 0.030391 0.030399 \n", + "137 0.030472 0.030399 \n", + "274 0.030372 0.030399 \n", + "411 0.030394 0.030399 \n", + "548 0.030490 0.030399 \n", + "... ... ... \n", + "5036 0.005527 0.004555 \n", + "5173 0.005518 0.004555 \n", + "5310 0.005507 0.004555 \n", + "5447 0.005555 0.004555 \n", + "5584 0.005545 0.004555 \n", + "\n", + "[5585 rows x 6 columns]" + ] + }, + "execution_count": 183, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "merged_subscriber_counts = merged_subscriber_counts.merge(\n", + " scaled_subscriber_count_baseline,\n", + " left_on=\"pcod\",\n", + " right_index=True,\n", + " suffixes=(\"\", \"_baseline\")\n", + ")\n", + "\n", + "merged_subscriber_counts" + ] + }, + { + "cell_type": "code", + "execution_count": 184, + "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", + "
pcodvaluedatetotal_subscribersscaled_subscriber_countscaled_subscriber_count_baselinepercent_change
0GHA.10.10_1649822016-02-0321382070.0303910.030399-0.027144
137GHA.10.10_1651102016-02-0421366910.0304720.0303990.240851
274GHA.10.10_1649112016-02-0721371920.0303720.030399-0.088948
411GHA.10.10_1649482016-02-1021368680.0303940.030399-0.016840
548GHA.10.10_1651592016-02-1121370270.0304900.0303990.300517
........................
5036GHA.9.9_1118122016-04-0721373040.0055270.00455521.333545
5173GHA.9.9_1117962016-04-0821377080.0055180.00455521.146293
5310GHA.9.9_1117702016-04-0921370870.0055070.00455520.914395
5447GHA.9.9_1118642016-04-1021359130.0055550.00455521.947058
5584GHA.9.9_1118492016-04-1121370140.0055450.00455521.730128
\n", + "

5585 rows × 7 columns

\n", + "
" + ], + "text/plain": [ + " pcod value date total_subscribers \\\n", + "0 GHA.10.10_1 64982 2016-02-03 2138207 \n", + "137 GHA.10.10_1 65110 2016-02-04 2136691 \n", + "274 GHA.10.10_1 64911 2016-02-07 2137192 \n", + "411 GHA.10.10_1 64948 2016-02-10 2136868 \n", + "548 GHA.10.10_1 65159 2016-02-11 2137027 \n", + "... ... ... ... ... \n", + "5036 GHA.9.9_1 11812 2016-04-07 2137304 \n", + "5173 GHA.9.9_1 11796 2016-04-08 2137708 \n", + "5310 GHA.9.9_1 11770 2016-04-09 2137087 \n", + "5447 GHA.9.9_1 11864 2016-04-10 2135913 \n", + "5584 GHA.9.9_1 11849 2016-04-11 2137014 \n", + "\n", + " scaled_subscriber_count scaled_subscriber_count_baseline \\\n", + "0 0.030391 0.030399 \n", + "137 0.030472 0.030399 \n", + "274 0.030372 0.030399 \n", + "411 0.030394 0.030399 \n", + "548 0.030490 0.030399 \n", + "... ... ... \n", + "5036 0.005527 0.004555 \n", + "5173 0.005518 0.004555 \n", + "5310 0.005507 0.004555 \n", + "5447 0.005555 0.004555 \n", + "5584 0.005545 0.004555 \n", + "\n", + " percent_change \n", + "0 -0.027144 \n", + "137 0.240851 \n", + "274 -0.088948 \n", + "411 -0.016840 \n", + "548 0.300517 \n", + "... ... \n", + "5036 21.333545 \n", + "5173 21.146293 \n", + "5310 20.914395 \n", + "5447 21.947058 \n", + "5584 21.730128 \n", + "\n", + "[5585 rows x 7 columns]" + ] + }, + "execution_count": 184, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "merged_subscriber_counts[\"percent_change\"] = (\n", + " merged_subscriber_counts.scaled_subscriber_count / merged_subscriber_counts.scaled_subscriber_count_baseline - 1\n", + ") * 100\n", + "merged_subscriber_counts" + ] + }, + { + "cell_type": "code", + "execution_count": 190, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-100.0, 31.561113800097285)" + ] + }, + "execution_count": 190, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Choose a few districts to show\n", + "display_districts = {\n", + " \"Accra\": \"GHA.5.1_1\",\n", + " \"Kumasi\": \"GHA.1.16_1\",\n", + " \"Tamale\": \"GHA.6.13_1\",\n", + "}\n", + "\n", + "# Plot % change over time for the chosen districts\n", + "plt.figure()\n", + "for name, pcod in display_districts.items():\n", + " merged_subscriber_counts[merged_subscriber_counts.pcod == pcod].plot(\n", + " ax=plt.gca(), x=\"date\", y=\"percent_change\", marker=\".\", ls=\"\", label=name\n", + " )\n", + "plt.axhline(0, ls=\":\", c='k')\n", + "plt.ylim(bottom=-100)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Average admin2 per subscriber in each admin1\n", + "\n", + "- Add admin1 pcode column to admin2 counts\n", + "- Sum admin2 counts per admin1\n", + "- Join to admin1 counts\n", + "- Divide\n", + "- Plot over time for all admin1 regions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Scaled OD matrix counts\n", + "- Same process as for scaled admin2 counts\n", + "- Show a map of before vs after for either Accra or Kumasi (not sure which will look better)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Summary\n", + "\n", + "- What we did\n", + "- What it showed\n", + "- Maybe some advice on how this could be modified to do other things" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.0" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From d877dd70b905ba0978edbb6b898129b87d0c49c0 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Sat, 1 Aug 2020 20:20:02 +0100 Subject: [PATCH 2/3] Add descriptions --- mobility-indicators.ipynb | 3189 +++++++++++++++---------------------- 1 file changed, 1284 insertions(+), 1905 deletions(-) diff --git a/mobility-indicators.ipynb b/mobility-indicators.ipynb index 3eee303..02dd7bc 100644 --- a/mobility-indicators.ipynb +++ b/mobility-indicators.ipynb @@ -7,9 +7,7 @@ "# Mobility indicators\n", "## Assessing the impact of mobility restrictions during a virus outbreak\n", "\n", - "In this worked example...\n", - "\n", - "(Include link to COVID website)" + "In this worked example we will assume the role of an analyst in Ghana monitoring the effects of government restrictions on mobility patterns during a virus outbreak. This is based on material produced during the COVID-19 pandemic, which can be found on Flowminder's [COVID-19 website](https://covid19.flowminder.org/) and [GitHub repository](https://github.com/Flowminder/COVID-19)." ] }, { @@ -18,58 +16,84 @@ "source": [ "### Introduction\n", "\n", - "- What we aim to do\n", - "- Summary of where we're heading, what prior knowledge is required, and what the end result will be" + "This example is written assuming that the reader has worked through the following tutorials, to gain familiarity with the use of FlowKit to produce CDR aggregates:\n", + "\n", + "- [Getting started with FlowClient](01-getting-started-with-flowclient.ipynb)\n", + "- [Running a query](02-running-a-query.ipynb)\n", + "- [Geography](03-geography.ipynb)\n", + "\n", + "In this example, we will first use FlowKit to produce some aggregates from CDR data. We will then perform some checks on these aggregates, to identify any potential issues with the underlying data. Finally, we will use the aggregates to produce some mobility indicators, which will give us insights into changes in population density and movements around the country over time." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Run aggregates\n", + "### Connect to FlowKit server\n", "\n", - "- Define queries\n", - "- Set aggregates running\n", - "- Get results" + "We'll start by creating a connection to the Ghana FlowCloud FlowKit server, following the instructions in the [\"Getting started with FlowClient\" tutorial](01-getting-started-with-flowclient.ipynb). First we import the FlowClient library, along with pandas, geopandas and matplotlib which we'll use later for further analysis." ] }, { "cell_type": "code", - "execution_count": 81, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import flowclient as fc\n", - "import pandas as pd\n", "import geopandas as gpd\n", "import matplotlib.pyplot as plt\n", - "from collections import Counter" + "import pandas as pd" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can get a token from [FlowAuth](https://auth.flowcloud-ghana.flowminder.org/) and use it to create a FlowKit connection:" ] }, { "cell_type": "code", - "execution_count": 82, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "token = " + "token =" ] }, { "cell_type": "code", - "execution_count": 83, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "conn = fc.connect(\n", - " url=\"https://api.flowcloud-ghana.flowminder.org\",\n", - " token=token,\n", - ")" + "conn = fc.connect(url=\"https://api.flowcloud-ghana.flowminder.org\", token=token)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run aggregates\n", + "\n", + "The first step is to run the aggregate queries that we will need for this analysis. The aggregates we will need are:\n", + "\n", + "1. Total subscriber count per day, for the whole country (admin0). This is the total number of unique subscribers who used their phone anywhere in the country, each day.\n", + "2. Subscriber count per region per day (admin1). This is similar to \"subscriber count per day\", but with a separate unique subscriber count for each region.\n", + "3. Subscriber count per district per day (admin2). This is similar to \"subscriber count per region per day\", but will count subscribers per district (admin2) instead of per region (admin1).\n", + "4. District-level OD matrix per day. For each pair of districts A and B each day, the OD matrix contains the count of subscribers who were active in district A and then active in district B later the same day.\n", + "5. Count of CDR events per day, for the whole country (admin0). This will not be used in the final analysis in this example, but will be useful when we check the aggregate results to ensure there are no issues with the underlying CDR data.\n", + "6. Count of CDR events per district per day (admin2). This is similar to \"count of CDR events per day\", but with a separate event count for each district. Again, this will be useful when we perform some quality checks on the query results.\n", + "\n", + "We need to specify the date range for which we want to run the queries. The mobility restrictions started on 1 March 2016, so we'll get results from the beginning of February (1 month before restrictions began) until the end of May (3 months after restrictions began). In a real-world scenario we could update this analysis every few days using the latest available CDR data, to get a near-real-time picture of mobility in Ghana. We'll make a list of all dates in our date range, using the pandas `date_range` function.\n", + "\n", + "**Note:** We will use the FlowKit convention that date intervals include the lower bound (start date) and exclude the upper bound (end date)." ] }, { "cell_type": "code", - "execution_count": 108, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -79,26 +103,50 @@ "all_dates = pd.date_range(start_date, end_date, closed=\"left\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now define and run our FlowKit queries, following instructions in the [\"Running a query\" tutorial](02-running-a-query.ipynb).\n", + "\n", + "#### 1. Total subscriber count per day\n", + "\n", + "For \"total subscriber count per day\", we can use `unique_subscriber_counts` queries and set `aggregation_unit=\"admin0\"` - this will count the total number of unique active subscribers in the country in a specified time period. We will need a separate query for each day in our date range. For example, to count the total number of active subscribers on 2 February 2016 we can use the following query:" + ] + }, { "cell_type": "code", - "execution_count": 85, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# Total subscribers per day\n", - "\n", - "# E.g. query for 1 day\n", - "total_subscribers_20160101_query = fc.unique_subscriber_counts(\n", + "total_subscribers_20160201_query = fc.unique_subscriber_counts(\n", " connection=conn,\n", - " start_date=\"2016-01-01\",\n", - " end_date=\"2016-01-02\",\n", + " start_date=\"2016-02-01\",\n", + " end_date=\"2016-02-02\",\n", " aggregation_unit=\"admin0\",\n", - ")\n", - "\n", - "# Queries for all dates\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's create a dictionary of \"total subscribers per day\" queries for all the days in our date range. To specify a 1-day time interval for each query, we need the `end_date` to be the day _after_ the `start_date` - we can do this by looping over the dates in `all_dates`, setting each date as the `start_date` of a query, and adding `pd.Timedelta(\"1 day\")` to that date to get the `end_date`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Create an empty dictionary\n", "total_subscribers_per_day_queries = {}\n", "\n", + "# Loop over the days in our date range\n", "for day in all_dates:\n", + " # Create a query object for this day, and add it to the dictionary\n", " total_subscribers_per_day_queries[day] = fc.unique_subscriber_counts(\n", " connection=conn,\n", " start_date=str(day),\n", @@ -107,25 +155,43 @@ " )" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have defined our \"total subscribers per day\" queries, we can ask the FlowKit server to run them by calling the `run()` method of each query object." + ] + }, { "cell_type": "code", - "execution_count": 86, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# Set them running\n", "for query in total_subscribers_per_day_queries.values():\n", " query.run()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These queries may take a while to run, so we can continue to define and run the other queries we need while waiting for the results to become available.\n", + "\n", + "#### 2. Subscriber count per region per day\n", + "\n", + "For \"subscriber count per region per day\", we can use `unique_subscriber_counts` queries again, but this time set `aggregation_unit=admin1` (the admin1 divisions are the regions of Ghana). These queries will count the number of active subscribers in each region during the specified time interval.\n", + "\n", + "Let's create a dictionary of \"subscribers per region per day\" query objects, like we did for \"total subscribers per day\". We can use a dictionary comprehension to express this in a more compact form:" + ] + }, { "cell_type": "code", - "execution_count": 87, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# Subscribers per admin1 per day\n", - "subscribers_per_admin1_per_day_queries = {\n", + "subscribers_per_region_per_day_queries = {\n", " day: fc.unique_subscriber_counts(\n", " connection=conn,\n", " start_date=str(day),\n", @@ -133,20 +199,42 @@ " aggregation_unit=\"admin1\",\n", " )\n", " for day in all_dates\n", - "}\n", - "\n", - "for query in subscribers_per_admin1_per_day_queries.values():\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And again, we can now use the `run()` method to ask FlowKit to run these queries:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for query in subscribers_per_region_per_day_queries.values():\n", " query.run()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3. Subscriber count per district per day\n", + "\n", + "Similar to \"subscriber count per region per day\", we can calculate the subscriber count per district per day using `unique_subscriber_counts` queries with `aggregation_unit=admin2` (district level). We can define and run these queries as we did for \"subscriber count per region per day\":" + ] + }, { "cell_type": "code", - "execution_count": 146, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# Subscribers per admin2 per day\n", - "subscribers_per_admin2_per_day_queries = {\n", + "subscribers_per_district_per_day_queries = {\n", " day: fc.unique_subscriber_counts(\n", " connection=conn,\n", " start_date=str(day),\n", @@ -156,18 +244,28 @@ " for day in all_dates\n", "}\n", "\n", - "for query in subscribers_per_admin2_per_day_queries.values():\n", + "for query in subscribers_per_district_per_day_queries.values():\n", " query.run()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 4. District-level OD matrix per day\n", + "\n", + "For the OD (origin-destination) matrix, we can use `trips_od_matrix` queries. For each pair of locations A and B, a `trips_od_matrix` query will count the number of unique subscribers who were active in A and then later active in B during the specified time period.\n", + "\n", + "The parameters of `trips_od_matrix` are the same as the parameters of `unique_subscriber_counts`: a `start_date` and `end_date` specifying a time interval, and an `aggregation_unit`. We'll set `aggregation_unit=\"admin2\"`, to get counts of subscribers moving between districts. We will create a dictionary of query objects and set them all running, as we did with the previous queries." + ] + }, { "cell_type": "code", - "execution_count": 89, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# OD matrix (admin2)\n", - "od_matrix_admin2_per_day_queries = {\n", + "od_matrix_district_per_day_queries = {\n", " day: fc.trips_od_matrix(\n", " connection=conn,\n", " start_date=str(day),\n", @@ -177,18 +275,32 @@ " for day in all_dates\n", "}\n", "\n", - "for query in od_matrix_admin2_per_day_queries.values():\n", + "for query in od_matrix_district_per_day_queries.values():\n", " query.run()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 5. Total event count per day\n", + "\n", + "The total number of CDR events (calls, SMS, data sessions, etc.) per day will be useful information for checking whether there are any issues with the underlying CDR data within FlowKit. For example, this would help to identify any periods with missing data. We can use a `location_event_counts` query to count the number of events per day. This query has the following parameters:\n", + "\n", + "- `start_date`: the first date in the time period\n", + "- `end_date`: the day _after_ the end of the time period\n", + "- `count_interval`: the length of time intervals within which events should be counted (e.g. `\"minute\"`, `\"hour\"`, `\"day\"`)\n", + "- `aggregation_unit`: the level of spatial aggregation unit for which events will be counted\n", + "\n", + "By setting `count_interval=\"day\"`, we can get the event count for each day using a single query (unlike the `unique_subscriber_counts` and `trips_od_matrix` queries we defined earlier, where a separate query was required for each day). We will set `start_date` and `end_date` to be the start and end dates of the full date range, as we defined them at the beginning of this notebook, and we will set `aggregation_unit=\"admin0\"` to get the total event count for the entire country." + ] + }, { "cell_type": "code", - "execution_count": 111, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# Total events per day\n", - "\n", "total_events_per_day_query = fc.location_event_counts(\n", " connection=conn,\n", " start_date=start_date,\n", @@ -200,14 +312,22 @@ "total_events_per_day_query.run()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 6. Event count per district per day\n", + "\n", + "We can also use a `location_event_counts` query to get a separate event count per day for each district, which will be useful to identify whether there are any data issues that only affect certain geographic areas. This query is identical to the \"total events per day\" query above, except that we've changed the aggregation unit to `\"admin2\"` to get an event count for each district." + ] + }, { "cell_type": "code", - "execution_count": 112, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# Event counts (admin2 per day)\n", - "events_per_admin2_per_day_query = fc.location_event_counts(\n", + "events_per_district_per_day_query = fc.location_event_counts(\n", " connection=conn,\n", " start_date=start_date,\n", " end_date=end_date,\n", @@ -215,581 +335,32 @@ " aggregation_unit=\"admin2\",\n", ")\n", "\n", - "events_per_admin2_per_day_query.run()" - ] - }, - { - "cell_type": "code", - "execution_count": 147, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total subscribers: Counter({'completed': 121})\n", - "Subscribers per admin1: Counter({'completed': 121})\n" - ] - }, - { - "ename": "FlowclientConnectionError", - "evalue": "Something went wrong: . API returned with status code: 500 and status 'errored'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mFlowclientConnectionError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 7\u001b[0m ]:\n\u001b[1;32m 8\u001b[0m print(\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0;34mf\"{label}: {Counter([query.status for query in query_group.values()])}\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 10\u001b[0m )\n\u001b[1;32m 11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 7\u001b[0m ]:\n\u001b[1;32m 8\u001b[0m print(\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0;34mf\"{label}: {Counter([query.status for query in query_group.values()])}\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 10\u001b[0m )\n\u001b[1;32m 11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.local/share/virtualenvs/FlowKit-tutorials-Ghana-XGVjzS5J/lib/python3.8/site-packages/flowclient/api_query.py\u001b[0m in \u001b[0;36mstatus\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 83\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"_query_id\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 84\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0;34m\"not_running\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 85\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mget_status\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconnection\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconnection\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mquery_id\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_query_id\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 86\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 87\u001b[0m def get_result(\n", - "\u001b[0;32m~/.local/share/virtualenvs/FlowKit-tutorials-Ghana-XGVjzS5J/lib/python3.8/site-packages/flowclient/client.py\u001b[0m in \u001b[0;36mget_status\u001b[0;34m(connection, query_id)\u001b[0m\n\u001b[1;32m 117\u001b[0m \"\"\"\n\u001b[1;32m 118\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 119\u001b[0;31m \u001b[0mready\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreply\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mquery_is_ready\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mconnection\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mconnection\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mquery_id\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mquery_id\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 120\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mFileNotFoundError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 121\u001b[0m \u001b[0;31m# Can't distinguish 'known', 'cancelled', 'resetting' and 'awol' from the error,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.local/share/virtualenvs/FlowKit-tutorials-Ghana-XGVjzS5J/lib/python3.8/site-packages/flowclient/client.py\u001b[0m in \u001b[0;36mquery_is_ready\u001b[0;34m(connection, query_id)\u001b[0m\n\u001b[1;32m 75\u001b[0m \u001b[0;34mf\"Polling server on {connection.url}/api/{connection.api_version}/poll/{query_id}\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 76\u001b[0m )\n\u001b[0;32m---> 77\u001b[0;31m \u001b[0mreply\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconnection\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_url\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mroute\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34mf\"poll/{query_id}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 78\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 79\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mreply\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstatus_code\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m303\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/.local/share/virtualenvs/FlowKit-tutorials-Ghana-XGVjzS5J/lib/python3.8/site-packages/flowclient/connection.py\u001b[0m in \u001b[0;36mget_url\u001b[0;34m(self, route, data)\u001b[0m\n\u001b[1;32m 137\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mValueError\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 138\u001b[0m \u001b[0mstatus\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"Unknown status\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 139\u001b[0;31m raise FlowclientConnectionError(\n\u001b[0m\u001b[1;32m 140\u001b[0m \u001b[0;34mf\"Something went wrong: {error}. API returned with status code: {response.status_code} and status '{status}'\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 141\u001b[0m )\n", - "\u001b[0;31mFlowclientConnectionError\u001b[0m: Something went wrong: . API returned with status code: 500 and status 'errored'" - ] - } - ], - "source": [ - "# Check statuses\n", - "for label, query_group in [\n", - " (\"Total subscribers\", total_subscribers_per_day_queries),\n", - " (\"Subscribers per admin1\", subscribers_per_admin1_per_day_queries),\n", - " (\"Subscribers_per_admin2\", subscribers_per_admin2_per_day_queries),\n", - " (\"OD matrix\", od_matrix_admin2_per_day_queries),\n", - "]:\n", - " print(\n", - " f\"{label}: {Counter([query.status for query in query_group.values()])}\"\n", - " )\n", - "\n", - "print(f\"Total events: {total_events_per_day_query.status}\")\n", - "print(f\"Events per admin2: {events_per_admin2_per_day_query.status}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 93, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
pcodvalue
0GH2136902
\n", - "
" - ], - "text/plain": [ - " pcod value\n", - "0 GH 2136902" - ] - }, - "execution_count": 93, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Get results\n", - "\n", - "# Get one result\n", - "first_result = total_subscribers_per_day_queries[all_dates[0]].get_result()\n", - "first_result" + "events_per_district_per_day_query.run()" ] }, { - "cell_type": "code", - "execution_count": 94, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
pcodvaluedate
0GH21369022016-02-01
\n", - "
" - ], - "text/plain": [ - " pcod value date\n", - "0 GH 2136902 2016-02-01" - ] - }, - "execution_count": 94, - "metadata": {}, - "output_type": "execute_result" - } - ], + "cell_type": "markdown", + "metadata": {}, "source": [ - "# Add date column\n", - "first_result[\"date\"] = all_dates[0]\n", - "first_result" - ] - }, - { - "cell_type": "code", - "execution_count": 95, - "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", - "
pcodvaluedate
0GH21369022016-02-01
1GH21369172016-02-02
2GH21382072016-02-03
3GH21366912016-02-04
4GH21375452016-02-05
............
116GH21367742016-05-27
117GH21372982016-05-28
118GH21375512016-05-29
119GH21377482016-05-30
120GH21374702016-05-31
\n", - "

121 rows × 3 columns

\n", - "
" - ], - "text/plain": [ - " pcod value date\n", - "0 GH 2136902 2016-02-01\n", - "1 GH 2136917 2016-02-02\n", - "2 GH 2138207 2016-02-03\n", - "3 GH 2136691 2016-02-04\n", - "4 GH 2137545 2016-02-05\n", - ".. ... ... ...\n", - "116 GH 2136774 2016-05-27\n", - "117 GH 2137298 2016-05-28\n", - "118 GH 2137551 2016-05-29\n", - "119 GH 2137748 2016-05-30\n", - "120 GH 2137470 2016-05-31\n", - "\n", - "[121 rows x 3 columns]" - ] - }, - "execution_count": 95, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Get all results with date columns\n", - "all_total_subscribers_results = [\n", - " query.get_result().assign(date=day)\n", - " for day, query in total_subscribers_per_day_queries.items()\n", - "]\n", + "#### Check status of queries\n", "\n", - "total_subscribers_per_day_results = pd.concat(all_total_subscribers_results, ignore_index=True)\n", - "\n", - "total_subscribers_per_day_results" + "We can check the status of a query by looking at the value of its `status` property. Once the result of a query is ready, its status will be `'completed'`. For example, we can check the status of `total_events_per_day_query` like this:" ] }, { "cell_type": "code", - "execution_count": 157, - "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", - "
valuedate
021369022016-02-01
121369172016-02-02
221382072016-02-03
321366912016-02-04
421375452016-02-05
.........
11621367742016-05-27
11721372982016-05-28
11821375512016-05-29
11921377482016-05-30
12021374702016-05-31
\n", - "

121 rows × 2 columns

\n", - "
" - ], - "text/plain": [ - " value date\n", - "0 2136902 2016-02-01\n", - "1 2136917 2016-02-02\n", - "2 2138207 2016-02-03\n", - "3 2136691 2016-02-04\n", - "4 2137545 2016-02-05\n", - ".. ... ...\n", - "116 2136774 2016-05-27\n", - "117 2137298 2016-05-28\n", - "118 2137551 2016-05-29\n", - "119 2137748 2016-05-30\n", - "120 2137470 2016-05-31\n", - "\n", - "[121 rows x 2 columns]" - ] - }, - "execution_count": 157, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Don't need \"pcod\" column, so let's drop it now\n", - "total_subscribers_per_day_results = total_subscribers_per_day_results.drop(columns=\"pcod\")\n", - "total_subscribers_per_day_results" - ] - }, - { - "cell_type": "code", - "execution_count": 96, - "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", - "
pcodvaluedate
0GHA.10_12276802016-02-01
1GHA.1_14701412016-02-01
2GHA.2_12046972016-02-01
3GHA.3_12222212016-02-01
4GHA.4_12467792016-02-01
............
1205GHA.5_14559082016-05-31
1206GHA.6_12996732016-05-31
1207GHA.7_11175762016-05-31
1208GHA.8_1723022016-05-31
1209GHA.9_12485452016-05-31
\n", - "

1210 rows × 3 columns

\n", - "
" - ], - "text/plain": [ - " pcod value date\n", - "0 GHA.10_1 227680 2016-02-01\n", - "1 GHA.1_1 470141 2016-02-01\n", - "2 GHA.2_1 204697 2016-02-01\n", - "3 GHA.3_1 222221 2016-02-01\n", - "4 GHA.4_1 246779 2016-02-01\n", - "... ... ... ...\n", - "1205 GHA.5_1 455908 2016-05-31\n", - "1206 GHA.6_1 299673 2016-05-31\n", - "1207 GHA.7_1 117576 2016-05-31\n", - "1208 GHA.8_1 72302 2016-05-31\n", - "1209 GHA.9_1 248545 2016-05-31\n", - "\n", - "[1210 rows x 3 columns]" - ] - }, - "execution_count": 96, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Get admin1 subscriber counts\n", - "subscribers_per_admin1_per_day_results = pd.concat(\n", - " [\n", - " query.get_result().assign(date=day)\n", - " for day, query in subscribers_per_admin1_per_day_queries.items()\n", - " ],\n", - " ignore_index=True,\n", - ")\n", - "\n", - "subscribers_per_admin1_per_day_results" + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(\"Total event counts:\", total_events_per_day_query.status)" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "# Get admin2 subscriber counts\n", - "subscribers_per_admin2_per_day_results = pd.concat(\n", - " [\n", - " query.get_result().assign(date=day)\n", - " for day, query in subscribers_per_admin2_per_day_queries.items()\n", - " ],\n", - " ignore_index=True,\n", - ")\n", - "\n", - "subscribers_per_admin2_per_day_results" + "For the subscriber counts and OD matrix queries we have a separate query for each day, and each query could have a different status. A convenient way to check the status of all the queries in the `total_subscribers_per_day_queries` dictionary is to use a [Counter](https://docs.python.org/2/library/collections.html#collections.Counter):" ] }, { @@ -798,29 +369,19 @@ "metadata": {}, "outputs": [], "source": [ - "# Get admin2 OD matrix results\n", - "od_matrix_admin2_per_day_results = pd.concat(\n", - " [\n", - " query.get_result().assign(date=day)\n", - " for day, query in od_matrix_admin2_per_day_queries.items()\n", - " ],\n", - " ignore_index=True,\n", - ")\n", + "from collections import Counter\n", "\n", - "od_matrix_admin2_per_day_results" + "print(\n", + " \"Total subscriber counts:\",\n", + " Counter([query.status for query in total_subscribers_per_day_queries.values()]),\n", + ")" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "# Get total event counts\n", - "total_events_per_day_results = total_events_per_day_query.get_result()\n", - "\n", - "# Don't need to add a date column because it already has one, but...\n", - "total_events_per_day_results.info()" + "Let's check the status of all our queries:" ] }, { @@ -829,1407 +390,1221 @@ "metadata": {}, "outputs": [], "source": [ - "# Date column is 'object' type (i.e. string) - need to convert to datetime\n", - "total_events_per_day_results[\"date\"] = pd.to_datetime(total_events_per_day_results[\"date\"])\n", + "for label, query_group in [\n", + " (\"Total subscriber counts\", total_subscribers_per_day_queries),\n", + " (\"Subscriber counts per region\", subscribers_per_region_per_day_queries),\n", + " (\"Subscriber counts per district\", subscribers_per_district_per_day_queries),\n", + " (\"OD matrix (district level)\", od_matrix_district_per_day_queries),\n", + "]:\n", + " print(label, Counter([query.status for query in query_group.values()]))\n", "\n", - "total_events_per_day_results" - ] - }, - { - "cell_type": "code", - "execution_count": 121, - "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", - "
pcoddatevalue
0GHA.10.10_12016-02-01136114
1GHA.10.1_12016-02-0128901
2GHA.10.11_12016-02-0118318
3GHA.10.12_12016-02-0129705
4GHA.10.13_12016-02-0147380
............
16500GHA.9.5_12016-05-3131992
16501GHA.9.6_12016-05-3113468
16502GHA.9.7_12016-05-3134588
16503GHA.9.8_12016-05-3153798
16504GHA.9.9_12016-05-3124071
\n", - "

16505 rows × 3 columns

\n", - "
" - ], - "text/plain": [ - " pcod date value\n", - "0 GHA.10.10_1 2016-02-01 136114\n", - "1 GHA.10.1_1 2016-02-01 28901\n", - "2 GHA.10.11_1 2016-02-01 18318\n", - "3 GHA.10.12_1 2016-02-01 29705\n", - "4 GHA.10.13_1 2016-02-01 47380\n", - "... ... ... ...\n", - "16500 GHA.9.5_1 2016-05-31 31992\n", - "16501 GHA.9.6_1 2016-05-31 13468\n", - "16502 GHA.9.7_1 2016-05-31 34588\n", - "16503 GHA.9.8_1 2016-05-31 53798\n", - "16504 GHA.9.9_1 2016-05-31 24071\n", - "\n", - "[16505 rows x 3 columns]" - ] - }, - "execution_count": 121, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Get admin2 event counts\n", - "events_per_admin2_per_day_results = events_per_admin2_per_day_query.get_result()\n", - "events_per_admin2_per_day_results[\"date\"] = pd.to_datetime(events_per_admin2_per_day_results[\"date\"])\n", - "\n", - "events_per_admin2_per_day_results" + "print(f\"Total event counts: {total_events_per_day_query.status}\")\n", + "print(f\"Event counts per district: {events_per_district_per_day_query.status}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### QA checks\n", + "### Get query results\n", "\n", - "- Additional queries (define, run, get results)\n", - "- Run checks\n", - " - Subscriber counts in urban vs rural\n", - " - sum(admin2 counts) / admin1 count ? (Maybe not - this might be an indicator)\n", - " - Stable over time (total, and per locality)\n", - " - Weekly variation (except there won't actually be any in the synthetic data)\n", - " - Events per subscriber - check sensible value and stable over time\n", - " - Missing data (temporal or spatial)\n", - "- Explain results (and how to tell whether they 'passed')\n", + "#### 1. Total subscriber count per day\n", "\n", - "**Note:** Don't need all checks, because some are covered by FlowKit tests (i.e. we need to QA check the data, not the implementation)" + "Once our queries have finished running, we can get the results using the `get_result` method. For example, to get the result of the \"total subscribers per day\" query for the first day in our date range:" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "#### Time-series plots\n", - "Should be stable over time and show weekly variation" - ] - }, - { - "cell_type": "code", - "execution_count": 98, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 98, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAEdCAYAAADn46tbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOy9ebgk110leG4sub791at9k63NkmUtFl5wA8aGwZjuwU2Dh6UZMHRjvqYBd+NpN0xPd8NAwwBN9wANjGmz+WOxsY0BbzLGNpZtyVJJlkoqSVZpq73qVdVbMl9usd35I+J348bNG5mRy3uVSsX5Pn169V4ukZER93fPOb+Fcc6RI0eOHDlyyDCu9QHkyJEjR47JQx4ccuTIkSNHF/LgkCNHjhw5upAHhxw5cuTI0YU8OOTIkSNHji7kwSFHjhw5cnRhaoIDY+wPGGOrjLHHMz7+7YyxJxhjJxhjf7bdx5cjR44cLyawaalzYIx9I4AtAH/COX9ln8feAOCDAN7EOV9njO3mnK/uxHHmyJEjx4sBU8McOOdfALAm/44x9nLG2KcYYw8xxu5ljN0c/elfAvgfnPP16Ll5YMiRI0cOCVMTHFLwXgA/yTl/NYB3A/id6Pc3AriRMfYlxtj9jLG3XLMjzJEjR44JhHWtD2C7wBibAfD1AP6SMUa/Lkb/twDcAOCNAA4C+AJj7DbO+cZOH2eOHDlyTCKmNjggZEUbnPM7NH87C+ArnHMXwPOMsacRBosHd/IAc+TIkWNSMbWyEue8hnDh/x4AYCFuj/78UYSsAYyxXQhlpueuxXHmyJEjxyRiaoIDY+zPAdwH4CbG2FnG2I8C+AEAP8oYexTACQDfGT38HgBXGWNPAPgcgP+Dc371Whx3jhw5ckwipiaVNUeOHDlyjA9Twxxy5MiRI8f4kAeHHDly5MjRhanIVtq1axc/evTotT6MHDly5HhR4aGHHrrCOV/R/W0qgsPRo0dx7Nixa30YOXLkyPGiAmPsVNrfclkpR44cOXJ0IQ8OOXLkyJGjC3lwyJEjR44cXciDQ44cOXLk6EIeHHLkyJEjRxfy4JAjR44cObqQB4ccOXLkmGB4fnBN3jcPDjly5MgxoWh0PNz9S5/Bpx6/sOPvnQeHHDly5JhQPH+lgY2mizNrrR1/7zw45MiRI8eE4sxaEwDgBjsvLU1tcPjPf3MCX372yrU+jBw5cuQYGqej4OD5Oz9aYWqDw/vvP4XPf+3ytT6MHDly5BgaFBzca2BKT2Vw8AMOP+DX5ITmyJEjx7gQB4ecOYwFjhcGhTw45MiR48WMMzlzGC+c6ES6Xj4CVUbT8fCeDx3HRtO51oeSI0eOPvADjrPrYZbStah1mM7gQMzhGjj8k4wT52v4wLEzOPbC+rU+lBw5cvTBhc0WvCDc4LpBLiuNBUTBroVON8mgoNn2/Gt8JDly5OgH8hsAwPVy5jAW0CJ4rcrOJxUkt7Xd/LzkyDHpIL/BNplgEDuJqQwOMXPIF0EZgjm4OXPIkWPScXqtCctgOLBQFhu7ncRUBoeOl8tKOrh+Hhxy5Hix4PRaCwcWyyhaZm5Ijws5c9CDmEPnGuiXOXKMEy3HR63tXuvD2FacXmvi8FIFtsXyCulxIfYccuYgI2cOOaYFv/SJJ/Ajf/jgtT6MbcWZtSYOLVVgGUYuK40LJCddixM6ycg9hxzTgoubHVysta/1YWwb6m0Xaw0Hh5cqKJhGzhzGBccPF79cVkqi4+XZSjmmA64fTLU8Si26Dy9VYJksr5AeF5yoMjqXlZIgRpUzhxwvdjheMNXXMdU4hMHBmMwiOMbYIcbY5xhjTzDGTjDGflrzmJsZY/cxxjqMsXdLvy8xxh5gjD0aPffnpb+9mTH2MGPsEcbYFxlj10e/LzLGPsAYe4Yx9hXG2NFBP5STG9JaxEVw+XnJ8eKGM/XMIQwOh5YqKJhsYrOVPAA/wzm/BcDrAPwEY+wW5TFrAH4KwK8rv+8AeBPn/HYAdwB4C2PsddHffhfAD3DO7wDwZwD+Q/T7HwWwzjm/HsB/A/D/DPiZRDVh3j4jCQqWnSneceV4acDxAjheAM6nUx04vdbEfNnGfNmGZRiTKStxzi9wzh+Ofq4DeBLAAeUxq5zzBwG4yu8553wr+qcd/UffJgcwF/08D+B89PN3Avjj6OcPAXgzY4wN8qGuZeM9xwvwFw+cRnANaGA/iArpKd5x5XhpQGx0pvRapjRWALCtF4EhHUk8dwL4ygDPMRljjwBYBfB3nHN67r8A8AnG2FkAPwjgV6LfHwBwBgA45x6ATQDLmtf9McbYMcbYscuXk0N9RCrrNWAO9z13Ff/+I4/hkbMbO/7e/ZBnK+WYFoianSlNrji73sTBxTIAwDbYZKeyMsZmAHwYwLs457Wsz+Oc+5F0dBDAaxhjr4z+9G8AvJVzfhDAHwL4jeyHDXDO38s5v5tzfvfKykrib7SrcHrsKlZrbTx+bnOQt8yEluMBALba3thfe1Q4uayUY4fxXz/9NXz19Pi7AHemvInkVsfDfNkGAFjmBBfBMcZshIHhTznnHxnmjTjnGwA+h9B3WAFwu8QiPgDg66OfzwE4FL2vhVByujrIe2Vpn/H//v1JvPP9Dw3yspngRO/ZmsAF2MlTWXPsIDjn+K3PPoNPPX5x7K8db3Sm81puOT5KtgkAsE3jmqggWbKVGID3AXiScz7Q7p4xtsIYW4h+LgP4VgBPAVgHMM8YuzF66Lci9DIA4G8A/FD083cD+Cwf0HUi5tDrhF6qdbZl6A0twC1n8oKDqJCe0t1WjskCLeDbsVGKPYfpvJbbXpAIDr1UkO2CleExb0DoCTwWeQcA8HMADgMA5/z3GGN7ARxDaDAHjLF3AbgFwD4Af8wYMxEGog9yzj8GAIyxfwngw4yxAGGw+JHotd8H4P2MsWcQZkF976AfypGYA+ccOj97vemg5fqpfx8W9N7NCQwOueeQYyfR2caN0jSzYD/gcLwAJTvcu1+rlt19gwPn/IsAeq6enPOLCD0FFccRGti65/wVgL/S/L4N4Hv6HVcvyGlfXsBhm/rgEPDwAqYIPQ440U5mEmUlN5/nkGMHITZK23AvxE0kJ+8+GxX0mcrRumSZE5rK+mKETMHSTup6I5SUxr2rIZ+DjOlJQidnDjl2EOJ6G/M9FgRc7KSncaNDa5KQlQwmVJCdxHQGB8mI1pnSfsCx2QpLMsa9wyeddRJlJTk3fFqLh3JMDigrbrvuMWA6mQPVIZUlzwEI162dxHQGhz7ModZyQed53Iu40FkncHcun5dpLR7KMTnYLkM6GRym7zom5lCMPAcrCg47PbxsKoNDwnPQnNB1KUtp3LLSJGcryTdVLi3l2G5Qmul23WPAdF7H9Jli5hB6pjvdDmgqg0M/5iAHh+aYvYFJzlaS24lMo1abY3R89Kvn8J2//cWxvNa2MYcpZ8AUHEqKrOTu8GedyuAgBwRd2fl6I24BNe4L193G3O5RkTOHHP3w1dPrePTs5lh6g20Xc3Cn/DqmjVu5QNlKIXPY6XTWqQwOTh9Zae2lKit5ASrRBZcXwuXQYb0ZbpzG0cuns01p3dPOHOh8lSyFOexwOut0Boc+stJGQlbarmylyUtldfwAc6WwX8tOy0qr9Tbue3agLig5rgFIch3HQjRo0eVP/OnD+OVPPtn3cXJAmMb2GcJzKMRFcEBuSI8F8q5Hd5GvSbLSuAt0BHOYwIvW9QPMlsK6x52m43/y5VN4xx89sKPvmWNwxMFhDLKS1KkgS7A5cX4Tx8/0b4aZkEenkAETcygqzGGnB/5MZ3DwAhSt9PSvjaYTyyvbxBwmsQjO8QLMlYk57OxN1XR8tN3gmvSI0cH1A3zgwdPXZMLWJIP8uHEyByCbtNRy/USySJbXnUbm0BHMIfIcjHAt2+m23VMZHFw/QLUY7pB1N/9aw8H+hbBX+thlpUnOVkowh5290KgJ4qR4MQ88v4b3fPgx/P1Tq9f6UCYKa1HngHEEcblALcsmrOX42Gi6fR/nJuocJuN6GidaXdlKkSGdy0qjQzZeddF2o+liuVpAwTLQdLcnlXXSspWCgMP1ufAcdvqmIgY37vM9LOrRvI1HzkzeUKZrhbbri+t2HMyhswPMYRpTsukzlSzyHCJZKa9zGB2uzzETMQedrLTedLBULaBSMMefreRP1g6ZQMd1rTwHz58sRkWffzsG0bxYIS/M48lWyh4cXD+A63N0vKDvvZPMVpqM62mcaLk+bJOJymhKZXV2eOzxVAaHjsQcdLLSetPBQqWAsr0NwUGMKOUTo68D8U4w9hx2WlaKmENnMm5mClKPnd3c8Z41kwq5/mcc89fl4NBvUyBvVtb6sAcKXEXLmFLm4Cc6RRdy5jA+yJ6DugPinGO96WKxYqNcMMeerSTT8UmSlihQxamsOy0rTVaKLx1Hw/FxcrV+jY9mMjBu5pCQf/oEB/leoY7J/V53tmRPJHM4cX4THzt+fujnq8HByuscxgcnwRySO6Ba24Mf8O2TlWQqPSESChDLa9fMkBaew2ScEzk4fvV07jsAsRkNjMtziM9xv41S24nfr58pTYFrrmRNZBHc73/hOfznvzkx9PPbbiD6KgGAZYyvzuFvHz2PH/uTY5keO5XBwfUDVAuW+FkGFcAtVAqo2NbYF/COF8CMvsxJ2SUDcdAq2SZsk+14fvikZSs1HR+WwbBYsfFIHhwAJItDd9qQlhMV+pnSMXOwRNrnJOFSrYPGCPJpOD86XpoL1viYw6cev4hPP3Ep09o0dcGBBoFUimHkdRU9mXZHS1UbpW2QlRw/wHyk60+UrBRdWAXLQMkyh5aV1hoO7j15eeDniWylCQoO5YKJ2w8t4KtnclMaSBaHjrvOod/3Lm8a+s12T8pKk8ccVutttFx/6P5Ubc/XModxpLI+fSmUUM9vtPo+duqCAy2Cgjl4KnMIb4CQOZhjL1Zz/QALFBwmZCEE4huqYDIUbXNoWekvHjyNH/qDBwYOLsQcJoVNtV0flYKJOw8t4uTqFurt/vn11xrPrNbxhacHD8xZkfAcxlLnkL0iP+E59JGV4uQKayIb763WOwCGr95uOT6KUnAYV28lxwvw/JUGAODcRrvv46c2OFSi4KA6/II5VELPYTuK4CgjaFJ2yYDCHGxjaDrecnwEvD/1VzGRzME2ccfhBXAOHD/bv23DtcZvf/YZvOfDx7ft9ZOG9Di6svpYqGTbKLUTwaE/c2AsvMcnjTm0XV/U0AwrLbW9pOdgj2nYzwtXGyJr8CXJHIgpVElWUk4oXXiLlQJKheHllTQ4XhDfEBO0q6Fdh20aKNlm164mKwWmIJOlklXGpNU5hLKShTsOLgB4cRTDXdlyUGttH8NZazhYrhYAjGd2wCASazMhK/X+jB0/iK5jY+KCw2qtI34eVjloK55D3LJ7tM968tKW+Pnc+kswOKjMQaXH600HpsEwW7JQscfLHMjvmJ9oWSm8qWRZ6dfueQpv+50vZQoQlP8+cHCIXnsUGe/jxy/gH8Ykq5CsNF+x8bKV6ouiGO5qw0HDGV7L7oeNpouV2SKAMRnSUdZN0TL6Bge6VxYqdibmUDQNFEfwzrYLl+qxXDNsNwDVcyDmMKrU9/SlOhgDds0UXqrMIbxxipYB02Bd0Xa96WKhbMMwWJjK6vrgfDw3GwWmhUmXlZSb6skLdRw/u4nPP92/zxAtGputnZeVfvHjT+B/3vvc0M+X0XQ8cQPecWgBj5zZGNt1sF2g/P/GNvk2aw0He+ZKAMZkSPsBipaJcoaUcboe982XM3kOQh6dYOYw7LUeZivJwWE8w35OrtZxZKmC63ZVcfalGBwcP/xCCpYB22TdslLDwWJEncsFC5yPL+efFuB5ERwmw3wF4l2HkJVcmcaHi87/vPf5vq9Di0a/G1jFqLLSla0OLmy2x8bGKFsJAK7fPYMrW85EyYAqOOfCLxslTfJjx8/j+Fm9hLbRdLA7Yg5j8Rw8HwXLyNSJgM79gYVSpmylghUyBz/gE9VZd1ViDkPLSq4aHMbTsvvpS1u4Yc8sDiyUX5rMoSMtgrZhdO2A1psOFiNPoBzpeuNaFGgBnq+EwWeSKC+dh6LVLSttNF1YBsOXn72KE+d7G7P0GYeVlYYNmI+d24yeP55zSrISEA9yn+T2z1sdT2w+tjrD+w6/+LEn8UdffqHr923XR8PxBXMYS7aSG7bOL9tmBlkpfL998+VMFdK2aYi2/O0JYg+UqQQMf6223SBZIR2lso4SsB0vwAtXGrhxzwz2L5RxcbPdt23M1AUHYgpFy4BtaYJDw8VitHiTLzGuHT7dUNWCCctgkyUrSUGzqBjSGy0Xb71tHyoFE+/7Ym/2IAzpgWWl0ZjD41E20bgCLmUrAfFQle2UKPyA9w28vSBXL2+NUmDl+tpzSMF+z9z4PIdQVjJQzpD40XQ9FCwDS9UCam2v5y7ZEbISBfVrd581Osm141JN8hyGWFf8gMPxk9lKjDFYBhuJOVCm0o17ZrF/oQwv4AmWo8PUBQdhvFpGdEK7s5UoOJCsMC6pQn7v8jakyY4C+dhKlil2yUHAsdF0cHipgrfffQh/++j5xAWuQngOA8tKZEgPGRyihXVcLK8lyUpiB7qNi8w9Jy7iH//WF3Fhsz+d1+GqHBzaw29m2q6vlVHJBN41U4TBxmdIk6zUt/FeFKyJ1W/2yMpyPI7CBDCHcxst3P7zn06Mv71c74gAO8y1TtegnK0EhJu6Ub4TKn67fvcMDiyGs2z6SUtTFxzklE3bNBINxMKme7HnQLLCuBZx+b3L9mRlUiRTWQ1xbPWOh4CHWSLveMNReAHHT/75V/EXD5zGOc3FQ8xs0DoHSgxoDBscztUAjO+7akmyktiBbuMic3GzDc6Bq1uDnTfC2pbMHIYLDpyHLbF11yVJOYvVQtd9MywShnSGIriybYp7s5enNSnM4VS0G39YynRbrXVwZLkKYLhrNZ4fbSZ+b2n800Hw9KUtGAx4+coMDkSDzvoVwk1dcJB3yKoh3XB8uD6XPIeIOYzp4upI770dBXajQD422ZDelCrGjyxX8Z633IxTVxv49x95DG/4lc/ik49dSLwOBZlBPQfXHz6Vda3h4NxGK1NKZBY4XgAv4JKsFN4G29nhsxZVYA97/ElZabjgQNeANjhE3+dipYCCaYynZbfri+utvyEdoFwwsVCh4JAeRB3PTzCHa5WxRC3OT16Ku/qu1ts4ulwBMNx3LabAWcngUDCNkeocnlmt48hyFSXbFFMw+9U6TF9wEDtkBts0Ejqd2B1tl6zky7KSNVHBQfZiSrYhqDjdhJR+++Pf9HLc/7Nvxt/+638EADi11ky8DgXfXrRfh1GylciMvuPQAhwvGHn+An3f5chzKtrbv8jUWlQ1O9zCLs842Bqy1QcFBZ2sRK+/WLW1Xt0w6HixId23fYYiK/UypUW2kr39cmAv0L3zdFRc1vF8rDddHFyswDJY6nfdcnz8wt8+ob2HxBQ4HXMYIWA/fWkLN+yeAQDMFC3Ml+2XnqxEi1fRMrp0OlEdXVUN6fF6DkXTQFmSbiYBiVTWKAXQ9QNsRBfoYtUWj2WM4eZ9s4nnEeJU1gEN6WB4z+HxKDh83dGl8DVGPK9UnFQpKIb0NmYr0UIw7LW21nBEvvuw0hwtPLqePxsN2iQUYJts5GwlPyoILVqmqCcicM67zNqW66FcMMXGrRczFbLSDiQS9AIFsGcvb8EPOC5HmUq7Z4s9PcdHzmzgD770PD7zxKWuvwnPwUouzZZhwB2SOVCm0g17ZsTv9mdIZ5264JD0HJKy0ppgDtsjK4kF2DJQKVgTVefg+mErcdNgQqttu77IKZ8vFxKPtwwGxnTBYcgKaWIOKUWHWx0P3/N7X8Yzq1tdf3v83CaOLFdGMvpkCOZgk+ew/TtQkpWGZQ5XtxyszBRRMA3Ru2dQ0OfTBcG1poPZohXJsaMzB0eRMeWF8p4Tl3D3L35GnBMgZg7UeqbX5sMlQ3rE7+1t/+NL+P0vDF9USVJcxwtwZq0p0lh3zxV7zoqh4z1xvpb6N9VzKFjG0J6DnKlEOLBQ1nqKMqYuOCQ9h+RFTgtaXARHstJ4FnF6r4I5gdlKfiB2nvFiGMTnpGInHs8YC7VnZZGg85tmbOoQBBwBD8+LH3DtTu+FKw08+MK6tsfRY+c28cr984mgNgqaTvIG3IlUVuqJNLzn0MHSTAEzJWvoAEOMIc2QpvuiYI1uSMsMXk1lfWa1jqbji502EHoOJdvETNGCZbC+hrQdFcEBw31vnHM8cb4msniGgRzATq5uiero3bOlcHOY8l3T9adLbRaeg63ISiOkstKG6/rdMXM4sFAaPTgwxg4xxj7HGHuCMXaCMfbTmsfczBi7jzHWYYy9W/p9iTH2AGPs0ei5Py/97V7G2CPRf+cZYx+Nfv9Gxtim9Lf/mOHzC8jMwTKTqazUlpnaCI87WymRyjph2UqOF4hZtEVpkV0XzMHuek7B7G5PoAu2/UB0eK5Hzyk6V+rCt95wcHa9hVcemB9aBnzs7CZOX429E7oBK4WdM6RJVhq2unmt4WCpWkS1aA5tSAtZKcWQpg2CblMwKOhc0r3g+ly8JqXlyk0E226YWswYw2K10LNKmq7lksYr8gOeqQ1Kxwvg+MFI81zWmw6u2xVmJp1creNyVDewe64YVYWneA7Rez5xodZ1rPQdlZXgEG50h2MOp6Jrn7KogFBW6sdAszAHD8DPcM5vAfA6AD/BGLtFecwagJ8C8OvK7zsA3sQ5vx3AHQDewhh7HQBwzr+Bc34H5/wOAPcB+Ij0vHvpb5zzX8hwjPEbKsxB3gGpJ57+P7bgIBnSk5atFOq0auqmj42mi9mSJebUytDtIB0/EDdlVt+BAvRcOVrcNTck3TBq3yCi3rcdmEe5MFxF+7/54CP41Xueit9LkZV2wpCmG3FYqfFq1DF1pmiPEBwi5qD5nHKKt24h+r733o/33/dC5vfqSMyBgjC9P2n18uLUcnxUou9jsU/zvY7UPkN+3abj4c5f+DTuOdGt5augwNQc8lwC4ec4uFjG/vkSTl7awqVaBwYDlqvFnvc/Xb/1toczay3t37rrHNjQAfvMehNL1QJmipb4HdU69ELf4MA5v8A5fzj6uQ7gSQAHlMescs4fBOAqv+eccxKR7ei/xFXHGJsD8CYAH+17tBlAF3UhqnOQ079UymYYDEVrfMaxCEyRrDRpXVkLJCtZsqzkCJ1XRcEytIb07tmwxUJW5iCCQ4mYQ/cNSedKZQ6UqXTr/jnxvQ16XtcbTiIVNE1W2lbPYQzMYbFSwEzRHLoIjj4fJSPIkItDdQvRI2c28NCp7J1rRXCwzfh7i95fMAfJc2g6nvg+FiqFnrKSG1Veq0H94mYbtbaHJy50a/kqhAc0wj263nSxVC3g+j2zOLlax2q9jV0zRZgG6ykrt6Xfq9JSO01WGiGV9cxaE4eUYEDprL0wkOfAGDsK4E4AXxngOSZj7BEAqwD+jnOuPvdtAP6ecy5/o6+PpKhPMsZuHeQY5awcW0n/arm+SHEljHOH7/pJWWmSGrlRJ0sASUO6FbcTUVHQpDS6PhdtnbN2ZlVlJd35FsxBWTxPrzWxXC1gsVoQslJrwFbI9baXSBtsiWyl8PV08sQ44Qcc9SjoDXrsQPg9NR0fyzPh7m9UWYleU4bcVsZW5ETOOdqejysDFPAJWSkqCAXioL6mYQ5yP6HFit1fVpI9B2IkUUCRvYw0bEapxepG41KtjZ/7q8cySYwUUG/YPYNnVrdwsdbB7ihpopchTde/wbpN6bTgoK5lg+DMWhOHliqJ3x0YZ3BgjM0A+DCAdykLeU9wzv1IOjoI4DWMsVcqD/k+AH8u/fthAEciKeq3kMIoGGM/xhg7xhg7dvly3ONfzsqxFO1UbYULIMoqGrPnYIZU2gv4WBqYjQPUrAyQg0OA9aar9RuAcJHoYg5eIDp3Ds4cwsVYt3tOYw5bHU8ElXiRyX5O264Pxw+SwcFJyovkxWxXKqs8gnQY5hDPPS9gpmQPbUjLC54cKBwvwFbHiz0HZVPg+hych51xs0IY0rYRJ364yeBAbMrzg0Q/ocU+zIGSK9QiONqsXFZ6Bn3oobN4069/PjEHI2YOyXN578kr+LOvnNZmzclw/QD1tofFSgE37plB2w3wyOl17IlYdWhIp3sOBdPA9btnuliOyFbSeQ5DMAc/4Di30eoKDiszRZGgkoZMwYExZiMMDH/KOf9Iv8frwDnfAPA5AG+RXncXgNcA+Lj0uBpJUZzzTwCwo8epr/dezvndnPO7V1ZWxO8dPzZeC8oJbbt+10kPS/vH23iPiuCAyRn4k2QOcQrgpiQnqChogoPjx8Eha9tuWmjiqWAaWUnoxsnztdV2hVY6TOox7U5l85N0f1q0LDPsw9Vrt7jecIYeskMFcPJ7E/7kvhfwwWNnej4/ERyKpmAhg0JmC7qW7SJbSdlU0XkZJDgIWck0EsWmnHMhK9F3Qx4IeUoLldCQ1hnLfsDhBxwF04yDg/Ay9Mzh4dPreO5KA1vSuY89h+R3Tt9PP+kuzny0cf3uMEW01vYSzEF9bQKZ77fun++SlWjj0s0cjK4+cVlwsdaG63McWkwGB8Ng2Dffmz1kyVZiAN4H4EnO+W8McmCMsRXG2EL0cxnAtwJ4SnrIdwP4GOe8LT1nb/SeYIy9JjrGq8gIopxANxVruX5X/nCWXvODvDcQy0r0npOAjo45RBWdPT2HLlkpwGzJRsEyMndmpXbdWWQlVTJpdHwx8nWY1GPatdc7nljc6fuuSNdC0UofHHO53sHrf+Xvcc+Ji5nfV0atB3P48wfO4C/7BAdaTJcjU3HoVFa3e8EH4uroJdmQlu4bet5aw8lcnd6RmYN0LzQdX9wnoqWIUrG+WLHh+lzrB8jSLWORZ6hU+6vB4dJmuLxsNOLvoUZznp1upir/Pw3yuGE5RXRFMIcehnRU03Hr/jlcqnUSQbcdtQYxjeSu3jKGM6TPRB0ODi11B4L9C6Wez83CHN4A4AcBvElKL30rY+zHGWM/DogF/SyAfwvgPzDGzkZG8yWbuE8AACAASURBVD4An2OMHQfwIELP4WPSa38vkpISEAaMxxljjwL4TQDfywcY0eX48SKomjj0pcgYZz0CfXlWNGUOmJyBPwnmYMVZWrW2K/rZqFCZg0/1CpaBhbKduTMr5WeTIa0NDk6ccSKj3vEwU4xkpUJ3wN1sufjhP3wAFzf1TcRod8p5/HPL9WEZSe9JHYAk4/jZDbTdoG9eeBpI0irZRvfna7t9GdhaI1w8lqoFVIuhDDpMC5Ekc5DbylB/rfA8q+0zKJAEPHuGWlznYCY8BzkxQHwfSvYYMVldCw05GxEIvzdiDnSeL291EqzjYtRlWN7MiLoTJ1mU2cgaHKRWPPNlG3ujORjEqssFCy1XP9KVNqm37J8DkPQdWo4vjHYZwxYmUnA4rMhKAPBr3317z+daPf8KgHP+RQA9xSnO+UWEnoKK4wgN7LTnvVHzu98G8Nv9jisNTtTPBehe3NpeoPEczMQFOwo60QLMGBML2aSkszpegGoxacBernfAedxXSUXBMhI7K9nsX6jY2esclFRWHVOj36mzChodDzPEHDSew5MXavj81y7joVPr+I5X7et6Xfkmr7VdzFfsxBQ4Qi/mQDfvsAyTFqL98+Wu66He9vq+LnVyXa4WhcTWcDwRbLMizZCmRZVkP9tkCcYon5crWx3smin2fS+5zoHQcv1E63G1MJC+XwpSG00Xh5aSrxv7euGSJH9vFLhcn2Oj6QqZjFrQy0GYWIsXzU8gc5uYXb8agHWpFxUA3LBnBhdrbTEsSaTver5IfCA0I+/z1n3zAMKMpW+6MZTGO173BhZAV7eHrDiz1oTB9NlJqg+hYuoqpF2pEtgyWGLuatvxu/KHs/SazwoafE6vC0zONDiZUVERHO225b5KMlRjUm5qGKYbZpWVkp6DbgZy7Dl00/yZyMg2DYaCZSSMPtKG0xoBymbwprRbrKjBwTZ7BIdoCt2Q3yUtRHvmSolrjXOOrY6HjZbbs3BrvenANBhmS5Yo4BwmnbWdYkiTB1SNFrGuTZX0ua/UB2UOhsIcQhZUts0EkwNizyFu2939XnItERDKVqJ+Qlr8L0dSTUfKspIzoBI+kLQhoc1E/+AQd7EFgBsi34GYQ68C29D7NDBfsXFwsdzFHNQNLBCpIMMwh/UW9s2XEyw5K6YuOCQ8B2Vxa6UZ0mMMDvTe466+HhRfPb2OZ1bj1gDUjwaImcOFKDgslLPJSrLeu1C2M3dmpR1PtWiBsRTmkFIhvdXxBOMBwkVFzhOnmzntWGrSTb4p7VTV66BoGalzAUZlDvS+++ZLicBI8pAf8MRxqqAaB8Ng4lwMk86aZkjTbpmuWXVToDKHLOgkkjPijRKxoCPLlS7PQU5lBfTBwVVlJSsO6htNByTVUysL+n/4927mACSDfiwr9ZP6kh2e7zi8gIJp4GBUT6Cm78oIZ4mE3+Ot++fwhBQc2m6QwhwM0bxyEJxZa4pjGhRTFxxcaYdsGyxKw4uMSI0hrXaMHAVyuui1lJWeWd3C9/3+/fjlT8TeP/WjAcJFn7GYbs+nGNK2pQ8Og8pKtOOxDQOVFKYWt8+I/+Z4ARwvwKwSHOTvizJ30sxxeQdYkzqjlhWqLxubMjabLs5Gfe+H9Y9qLQ8GA1bmioldqnxsvVpUX90Kq6MBCFlpuOAgS6zxcQiDPnpttUJaTvGVg0PT8fDBY2e0rIcCbcJzkNq1HF2uSswhWXey0MNzEMzBjKvb6drZaLo4GrWIuLwVXtvyVMNEcJCz16RzSSa4yszObbQSU/w2mg5KUpruP3nVPnzxPd+M5RliDumtXmR2cOv+eTx/pSGurZbbrW4Aw1dIn15rav2GLJi64NCRmUO0UHtSloq+zmF8jffova+VrNTxfPz0X3w1qmGIby65txJjDCXLFMwhayorZbDYpoHFSmHgbCXLZKlzLuh3LTc2W2kXJzMHNQtkS5OqKkMrK7meXlbSfFcnLsSphsMG+lrbxVzZxkzBguMH4iaXj62XRBf2VVKCwxCyUsf1waKdtRwoiM3QNdvVdkYKJJel4PA3j5zHv/vQcTx7ubsmgJ5flCa2NZ3QcyiYBvYtlCRTOFl3Qh7YmmbzEfte5DnIzMEVbakpY+miHBxkQ7rtiXMhZ0XRNaemC/+7Dz2Kn/ngo+Lf600XS9J9wxjD7rk4+6dXQkpb2qTSwn0+msrWdlNkJWPwVNa262O13unrLaRh6oJDgjlECzXdjLo6hzBLJRg6h12G48uy0nhnRWTFf/300zhxvoa9c6WEVBEeW5xXULINXI30316GtCNdkLLeO1+x0XazdWZ1Ja+iWtQ3JJPpt8g1j25QuSeMmlVEC2y65+AJqUGWMbSykoY5EOXfN18a+rvcbLmYK9ldbFJegHqxsLWGg6WZKDiIQsLhPAcyseVz2Iq8OEqfLES7VGIEMnOQx5zSICjdsdNzCpYhvKKW62NtKwx0cyUbW06YXqwa0pZpYL6sr5LuzlZKGtIHFioo26aQk8hXmy1ZieOst1xhrMsLuJCVlOB7qdbBUxdjmXa94aRm+QG9B4k1ndBzAMLrCoBgJWnBwbbYwJ1yifHq0lizYOqCg5ytZEUXO1FkXXCQswrG8d6FLllp51JZv/zMFbz3C8/hn7/uMN5400piZ+pKxYFAuMhyDjAW1x+oKFoGHOm8xC3JmfApskhLtOOxjNCc1OWv6zRwkh3k4KDOI6YAknYc9baLldmw381mQlZSg4PekD5xvoY9c0UcWqyMICuFVejEgOh1ErJSD+ZATfeA2DQephCu7QYiEyhxvh0vkVFjmwY4h2BwlHlUKZgJWYk63dY0k+kcP4DB4nuwUgi9orWoNfhsyQrTizte3POsEF+fS9WCNovQVQ1pK9wsdLywhmKxYmP3XFEwnIubbZRsA0eWK0lDuu2KhVlnSKuy3WbLxZrUo2u9GbM5Heh70l3rsudFhWjE4lM9B2NwQ7pXGmsWTF1wcH0umENBYg6c81TPARjPDr+jMaTpJvy1e57CT/zZw5naCQ+Ljz5yDgsVG//nW2/BbMlKZGTIZjkQm39zJbur4IagpjSqngOQrvXLoGwly2SpPWdaymIl/592y0C6rNSLOcyWbMyVrIQh3S0rGdoK6RPnN3Hr/vmREhdqbQ9zZUu8Zxz84mNOS6d2o9YftBDNjsIcXF+wRDkQNhUmRYybvnt67IGFcjI4RIuPfJ0R6F6I6lmFV0SBjjYk9bYrEgzkY1iq6rPh5CwoIGYOYhZ6tYCVmWJCVto7V0q05OCco9byRG1CQ8ccNMEBAJ6LJLRexaNA781hy/XFGNA98yF7IYaT7jkYCKSAnQVn1qMCuMU8OABI7t4tI/Ic/DCXOeDdZem9sgoGhbw7t6OWDLSQffSr5/Hx4xfwiceGq7LNgo2miz2zJZQLJuZKNlpuXI0qm+VAfHOpQ35kqNOndMFhvdGfOdBr2Gb6hLym40u9l5LUvqrISvJ3Ve+TrbTV8TBbCmfm1qRma13yomV29VZquz6evdzArfvnRmrQWItkparSUkVmDmnMh35PwaE6gufQdn3MlmwwlmQOTakKHYh7TZHHRF7MwcVyIpX11NUGAP2577i+qB0A4pRx2nHTd11reXGXXOk7WawUsKa5tuRaG4AYny+lltpYmS2KqWyXotqDeSm7jmY57CXm4HSzVvn8tqX76FkRHNLbzgDx5lBdV/yo31rFtsTx75opJGQldQMLhBsrAAOZ0mfWmihahmiUOSimLji4UlaOLZ3QdkrPEl3V7bBQd+dUfX1xs41zGy0YDPiljz+xbf2WNltxEz15ZxZE83x1zGG+xwVeME2RagnEO0jbNISstNkKe+C88/3H8BcPnNa+jmAOPVoZt10fu6KLWNyg0cKvZitpPYeUxbXW9sRAdbnOoUtW0jCHpy7W4Qcct+6fG6mSnr4XwRyErBQeT9EyUmUlua8SEJ77omUMna1UssPZy4ng4Cazt1KZw2IZVxth9fFm0xWeli4ZwPFjeReIvSLZc6BzQI3o5JkiS1W7d7aSkJUM0XoeCIPK7lmFOcyHzIEeQ8erBgcnChqAPgUaAJ693IAfcGy24iI7HdIUiXgMaPxZ986XhKzUUoIqgdYybwDmcDpKYyX2NiimLjh0vOTuHQiDg2p6EcYpK8mGNL122/Xx8OmwD/7PvfUVOL/Zxu9+/pmR30uHzZYrggLJD/W2JxWvyTdrf+ZgRwY27ZrErAyLJapY73vuKu45cQn3P6dvgSUzh2rKIttyfGEQqtS+p6wkZZfoKHe9He7a56LgwDlHUycrWUYXc6Dit1v3z4+U8kzZShWN52CwUK5JCw5XpdYZhNnScG2721648JRsI5Gt1Ox4qBZk5pDcpcayUgWuHy6MJCnR51PRcbvvhc2Wi3rHw3K1gNkoONTaXmTCJpeixWoBa5rme3LnYyBun0HMYb4cMofNlou26+PSZgd750pYqITffxBwcbwkK1EqK30vBdNI1DkkgsPqVnQd9b530jadOpa0b76MC1G2UscNtMxBrGUDdHk+s9Ya2m8ApjA4uFJWThwceFcVJqFsJ2/YUSBLWuFrhwvZQ6fWUbIN/NDXH8X/evt+/N4XnkuMrRwXajJzEDefK25ydScHpGcqAfENKIKDxByIUm+0XPzRl14AkF5VKgzplFRW8oN2RRk5wnPQpLKWlDqHLU0dg4zQc7AwV7ZRa7tw/AB+wDXZSt2G9InzNcyVLBxcLA+d8tzxfLTdAHMlSyzAsuE+U7RCfT1FnlsTTfdiaaA65EyHjhugaBtdGV9NpWJc3lQB4W6XsbhR25WtDk6tNcTj0zyHosKiKV1zaaYgWqnU266WyS1VCnC8oOta0TIHL0h0liUZ5eSlLSEfLVQKCDjN9giPd6laQME04tqG6Jzuniui7cYpxxQc5koWnr281cXmdKDmeeo1o5vXsG++hAubrVBy8gPR+0wGsaqsbbs559o5DoNg6oKD3LJb1unU5l6EXilnA7+3F0ta4WtbIji86sACbNPAz731FQAPWzWPGzpZqdbyunRaIG6+1ysdr6jIC7LnULINFCwDj5/bxGeeDMcy6naQgCwrGZEhnbxhOl7oB8XMIanJVwvJbCV5YdvqxDULG9rg4EqegyvkRbUIrmQbInAQTpyv4Zb9c2CMRSwwGLjhHS2c8xJzkD2H2ZLdsxWJaPAmtTgZtjNrxwvTJNWCP7liF+gODh0vXLDo+7lcdwRzOLBQ1nsOXjyWFggXQ6o5WKpIzKHlaivWSbJRjXqVORRtE44XiM6yixVbTCo8fm4DQMgQaBO03nTEdRqyufh6pOuO+iPROSbJ8s7Dizi91sRqNC+i173DGNMWfMab1CRzqLU9wRLVDWz4eSNZKWOtA7G0Yc1oYBqDg6T7F6SLnFJVdY33gPF4Dq7PE8yhUjCx0XRw4vwm7jqyCCDUF5eqhdSFdPj3DtBwfCk4xDuzWA7qlpV6ZVwUlOAg79oYY1go2/j4YxfAGMNtB+ZTmUMsK4WLbNNNdsKkxZ52x02JOVQKZiKbqqIMq6+1PTHVSl2kXD9A2w2ibKVQVmiKatxu5gAgUfR3dq2J63bNJB4/6HUiL0RVjecwW7J6zkwm7VtuslctWn17/+jQdsNFXmUOjY6nZQ7EpDpu2CmUgsPVRgenrzaxa6aAffMlvazk+UnmYJsisC5FqazhOfC0FetUYJYaHCTmAIRtMqhVPjGHx6MRs3vmS1J2nSsYJiUJqMyB5Ka6kgl31+FFBDwcmSofYxp0GW66dvGUUvvClTDgphXBAdkNaeonRfMlhsHUBYdEEZwkK+nS5eR/jzuVlV77+NlNuD7Hq6PgAOhnM48KuuDno6AwK8lK6m4LkPvYpF/gtiorSfO5gTCwcA582617cNPe2dQqZcrPtqLBL5wnUylpwV2OZCU511yucQCSWm7HC7NIaFi6Ghzo5ibm4PpcFHHpiuCA5JwDynQK33c4+VFeiLqK4CLJa7Eaplnq0pxrbRcFqcoYCA16XfPCfiBtv6gEh7ARYXye6VzE9UGhRESy35V6B6cjyYLkOhWOIivJi+HyTAF2ND601nZFIzoZgjkoQVMnKwFhVtJC2QZjTAQHmj8eeg5Ul+PEATdKL24qMiYxB7oO6fPddWQBAHDshdBD7LWxos+cxhzk75OM8eevbHX9jRCrINmYg7wpGRZTFRyCgIe7dyqCE1Qs0NI5ID3lbBg46m6pYIqL+a7DC+L3w7bf7QXRdrlCnkOcKigMaZ3nkIE5uBpZKXxueMP90OuPYraUvpsV7TMMFhcHSbIInfvZkhXNPIh3cmpwEIOKHF/IAAdTgsOWCA62YFTUa0eXrQTEQcvzA3S8QBxvZYCU53tPXhazH4ReXbbDjByDSS0aXMyWbCxG+rqOldRa3a25Z0rWwKmsnh/ACzhKtomSZL5zzqMiuHTPgeSohUoBBgt3pafXmjiyVMGcUk9DUDdK8oK3FDHEuXJ4zejqj0jPVzOWXI0hDYRFZLTRWa4WwBjwtYt1MAaszBYTCRRywJYXcAoSe6PaA7Wp4+2Hwnv4oVPriWNMg86n0snb+6NCuOeuNLrOFaFgDsYc5M84LKYqOJBZozIHRwoOaams25WtBABHlyuiIRcAFFKqcbOi1nbx9t+7L9HTRu3JXy1YMFg6cyjayQVehy5DWmqDAQDX757BXYcX8JrrljBXslMzhuSgojvf9HPJNjEjma1yu26CnF1GC+TBSFfdVHaZtHsKDenwdUj3TpOVaNEkqYHy/7NmtQUBx7/442P4b3/3dHQM5DlYwrvoYg6iC6neM5lTzsEwhjR5DCUypCOGRH5POREcol2qF3sOxagNxlK1iAubbZzfCDNh5lOYQ/gcqc4hen2DxdfobCl8rq7uZCnNc/ADMAYhNSaYQ3QeLdPAcrUA1+fYNVNMJlBEngOxsUrBEhXSW4rnIBdYzhYtzJVs7J8vYbPlijnxvdCLOcjnmwrhnr8cBgddhTQZ0oN4DkCsJAyDqQoOavWkLZk4aYY0GbP0pT10an1oPyCszo71cXqvuyRJCYh71wyLr12s44EX1nDshTXxOzU4GAbDTKRNx1Rc6q1EhnQP2mlbyd20MLaj3//S216JD7zz9WCMxXMGNIuW53NxQ+u0e3moenizxjS/qmjRcodP+p7SPAchK0V1DkA8MrK7x1b4mWjRpN29mF+dMThcqrfR8QJ8NUpfVndw4SS3OJV1pmj17EJaa3uYVb6j2WGCg7Q5KkmdTOnzyKmsap1DW8q93zVTwKNnNxBwxLJSlCIqo4tFC6ZaEAv7XMQ2df2E5koWTIN1eTGUEUi5+zSbZLXeSUik5I+Qnk8Bdr3pJthYtWh2ZccJz0FiDiTPvDwaCbpYtfvWD+hqY3TrEBXCPS+Yg74rK4DM/ZV0XtWgmKrgIOfTy/8PjUk9czAMFs2R9vCpxy/in/3ul0Vq5iCQB58TaEF5tRocRvQcrkQFPlekJmhqcAAgbty4J1IyewTo7TkUFeYQt0uOu7vSOZaLmlS4QQDbSLYVkW8aeTcV7oqlVE9l11ySggstkMvVAsq2qQkOxBxiWYmKjXS9lQCJOShptJWMnsOZtVBOevZyA5stt0v7LRfC3lKc88iQtmMJRWNKpzGHthsM1GtHXP/CkA4Sn0f2HAqSVwdE2UrRgrUyW8QzqyFjPbJcxVzJRsC7Bzh1pbJG11uyXiO8PtVUWiC8tnRV0l1yVfSzH/CEREodUokFWKYhWqiEdSexl9RUDOk9wpAO37smB4eVKDj0MaMBaFvFpMnbe+dLopFh2jwHAJm/81or9xwSUDMZBD2WOz9qqGClYOKJCzW8+y/DlrwnV7tbEA/63vS6QJjlIGPYebAE6m8jd8jUXQxzEW1X2xwDoU4/W7Swa7aHrKR6Dl4y+Mqgm02nP3s+F/6Prq5E3k1VC6ZYmBtOt+cga/9E+2ciw1ltQSEb0hS8Ylmpe54DEBvSWyI4DCYrnZGKwx49sxFKEJKhXI2YUccL4Pq8r6xErTdkiFGhnd7HIoOCQVGpkKbPU5HbZ1jJTYEsEckjQg8vVeLvXfFAHC9IzEKm+04t5hOeg2ZB1FVJu0rldVF6niyRrkTHuVdqo00pw/I5rSqGtGkwUakvy0okz7x8JZwXkS04WImphYCeOYTHWRbnW5+tNFiFdK0dSl/yuRoUUxUcVMNUriqkm6OkOVkl28SXnrmKomXgln1zeOFKo+sx/aALDq8+sohvuGEXbtwzm3hs2Ap7lOAQ3jCUFw3omcNsyUItISvFx/Ydt+3D/T/35q5FUj1OIOk5GJLeK2O2B3Pw/EBc3LTYyp0wVeYgWna3e2QrOX6ipbfcHoNQlzyHLkM6NVuJdtQktxBzyGZIU7MzxsKUR9VQrkTMoS5of29ZiXwJGXRO6j2mlbVdHycv1RP/BtJlpX5FcHR+KGOpaBnYPVsU51XNVJM7FQDx+V6WggNlOsmN6GQsVgrd2UpKjzD5fl5MMIcoOMyXEn/fiNp+0CZK9hwaUaV4tWCCsaQhPa8yh5TRujK0qawpCgYVGOr+BnRLff1Qa4WfcdjWGcCUBQe117vaPkPt30KoFEwYDPit77sTr7luCc9faQzcPbXjh196Qdqdv+nmPXj/j762azG1zRFlJQ1z2Gy5YZqiZAKSrKQLXPLIyTTIhj6QTBNWMSe1Q1DhBnGnXLEDV1IpgYg5FM2EIa0eo+xZkCY8W7IxX9EFh/jvtMCmyUoiC8pVmYMqK/VjDi3snSvh5SszYXCQJAx6vZbjJySvhR5jMan1hox4pkP6sfzxl1/Ad/zWF8W57XhycDCFQa2TlVR9uyOxAGIOh5YqMAwmvnf13Hc8P7GrT2MOm9H1qWcO3W271aQP+T0WNcxhj8Qc5isFbLRc1FuxVBcGay+a5+1jphgmDsxItSRycHjZILJSShGcbbKu+0gOYlrPQWoimgXqdTcMRnv2hEGeNwBIucEBFwNNdHjHG65DyTbw9dfvwtOX6tjqeLi81RGVltneu7vQLA2jM4dO4v9A8gImzJVs1NuedF4G2wuospJ6Y8qIi5pSmAPJSqIzqSQrubKsFGrAHc8XsouMkiQrqcxAlnSAcIEvWoY4ZvmG17XsBuINRroh3cdzWG/i0FIZR5ar+OxTq7h1/1zieylHi5Esedmm0TWMBgh3yW03OSZVPqZec46Pn92E44XTAMuFcoI5U1VxEHCxa5bPh5o22fF8kcBAWXdHorYMcxrmwDnXtpIBFOZQssV9owsOi9VCF5tSX1eWTeRxt1TrIMtKixUbp6420OhIzKFoIojqbppOvBmRTX/53tozV8TNe2dx24H5ruNVQf24OOdiB6+bRgnE6axp54L6nA2SyjqKGQ1MGXNQd8iFhKykb4ULAN//2sP4rrsOAgCui3YGlFY27Hv3QmFkz4FkpSRzUINDKCvpmUMW0PnrSLJSWoDRLRIEz+eiwpM8g96GtBf7CaqsJGUrbbU9WAZD0TK0slItak9BoPNjGd07N2FIK9lKFcVz6CcrnV1r4tBiBXceXsBaw8ET52vJ6uaCiWYnlpXo8y1qWmjUUwqZaAHrVSX95MVwgh2dE1VWCj9rIBicVlbySFaSmUO4uFPPHh1j9AKOgKOr5gdAopOpbLTr0kKXonMiZ0K5fnr9hLyb/0fX78L3v/awKFwDwsy89YaTzFaSGKHMVKmWhHpj0bXDGMOn3vWN+N7XHO46XhXlQjjQKDG7W9P0EVCZw+gV0rJ0NiymKjionoPIDQ6CaIhG77xkAHjZrtBwen5A3yGuJej/Hups5kFBjGGtEd84tZbXzRzKNrY6nrg40yShNBRVz8Hjqa8ht0NQEcpK0USwoiY4OGFjt6JloFo0xY0KQCMrRcwjylaaKYUyQJrnIC9AcsZQ2melbCXKmKLF2zYN2CZLyGEqHC/AhVobB5cquCMqmLracBI3aaVgRcwhlpWAcFerSigyu5Ax20dWajm+8M2IjQjmYJuCBbRdX6QNJ2QlpUJans1AstKR5TA46DwHkVJudzOHJcVzIOjuzcVq2CxPTi3vpMwlAZKew2K1gP/yT29LfK6FSkF4cLOSrASEm4GGVHRJ9TY6Ly8ryF+TM7nUwUqEfX2Cgz1gbyVZOhsWUxUc1GIvWyo51xXa6LB/oYyCaeD5q8MFBzkjKA22NVqF9JV6B7bJRF95IE1WCncutCMdlDl0t88IBL3VPbZkG9oakVBWitmc2q2SvhvGQh/ED7hgRSpzoMWAiuDo7wtlG03HTwRd1cydUxYEGarn0HTCdtryNVO2TbGY6nB+owXOgUOLZdy0Z1Y8dz7hOZiRJJZc+BerhS5ZSaTBlvTMIU1WOrlaB222u5lDnDnVjkZrAnpZSec53LBnBm+/+yC+5RV7AMT+hxyYO163jPmKfXN45ze+DG+8cbf4nfzd6AL2sqYQTp2ZkiYr6SCnusqGNBBeT41OvKufiYo6R0kJ1Q0SS9ukkjdCM7dVqEkC/aDzqgbFdAUHJSvHlqhYVuZgGgxHliuDy0qajKA0FExzaObQcnw0HF9kTRCLkAt1CPRvesygzEH1HDo9DGkg9jhUuD4X2Uq6bpVyKiPR/NUoq0gNDobBRLaNLBvRwiAvUvW2m6iToOCp2ySo2UpbUQGenO1R0bQblyHGMi5VYJmG0KWT2UoWPCn4zQnmoJOV9Mwh9hz0x/LUxThLiRa3ttctK7XdoLch7YXjdeVU1qJl4le/+3YhK5kGw2zRUnb34XvJZnHBMvCzb31FYgGXz0ua5wAkjXrdECECDaBKgyw7iY2CYLJeol3LbNFCve2K9t7DMAddEkOavF2yTSxXC9psSiDpn/YDjUHNPQcJamtqw2AwjbAauZMyuFuHo7uqw8tKGYKDbbGhDWla6G/eOxv9O55upWMOQJzVNGjOc1cqq5fuSgMwsQAAIABJREFUOQCxx6HCC5JBRU3xk3vr0K74Ui38nGoRHBDedGEqqyvMWvrsyeDgYbbY7TmoHUCB7uDQ0GVKFc2eshK1saaF846on1ZSVjKjz9dOfL6FSndOf9qulaqZ0/orPXWhLoJxzBzIkDYTLKnp+LAMlrhuw+LG6L5Rug7oMCeNYAW6OxWkYbZPcIg7s8bfqep70XvMFK2+9968hjnInkNDMqRniqHnUBtBVqpokhh6KRj7FkqpvmhB8YF6gcagjpqtNF3BQTPUxjKYGPaTduJVvGxXFaeuNgfq3a977zQUI89h0HRZIA4ON+2dAxDWOvgBR72j8RxKozEHWmCypLIC4Q2nYw5yERzQ3XNGvmGq6uJZ7P7OaIiS3HspDg7xAtslKwkpQd+7xjSYZEj7icIwel4vQ/rMWgu2yUSGDPkO8vdCi9GlWhtVqR35YqWAhkYWA7qZgxV1NE3rzPrUxRpu3T8H02DYiM4HyUrhsB9D/E5XnQzEhZoUHHqxbrUzq5pSnv683rIS1RKsK7KSfA1aUTPDfh1SAZU5JK+FRseLZmlLhvSInoNuVkwrxZAGwrkOaXVHsn/aD/Fwopw5CKiGNBBnBqVVYepw3a4qHD/A+aizZhYMYkjLrcQHBTEFYg5Xt5zU3Q0thle3HJgRixoEjLFE2q3aO0pF2EhNJyvF7TOA7m6VPZlDsfsCJ1lJ9hz0zMHVZiulXQfyqFB9dXbvaXBn1pvYv1AW5/m11y3hul1V3Lp/Ln6NKOBcrLUTrIgklA1JQunVdnkmpQsu5xxPXqjh5r1zol0EEJrKZPrHhnQoK+kWpDA4cHQoqPRiDiVLb0hrJprJSDAHXbZSdE6u9vAc6NiyBAe5jxj5QLRQb7bCKYG0GZkthRIi+R2jMYfkRigt0P70m2/Af/zHt2j/Rhu1LGvGOFpnAFMWHHTSjm0ZYhJcFs8BCIMDMFjGUtyUrv8CrGr5g4BYwPW7Z8AYcHWrk7q7oR3n1UZn4BoHArEcoHedAxA1UtOksvpBf+Yg2ktENydN26pqmEOlYIVFcG0dc3DFezYcP7HrjmUl/XUgdyvVNv3rwxwojZWwPFPE5979RrzqYJxOKZjDZjuxOOpaaNTaHhgDZjSLt9y9VsblegfrTRc375vFQqUgNPN21OuIMSa8ADKkVYYEhMGh42WXlZKGdFQQ2oc5VKPiU0AfsMvR1LqE56ALDraZqShtQeN30GZkNepXJstKAMQGcZiFVlvw2WOT+soD8/jmm3dr/zaIIR0nMuSykoDjd/f+sQwGz+faIeZpuG5l8OAwSKGZquUPAmq6tzJbxFKlgCsNJzU40A2w1nAyZVGlHWsiW6mn55DCHAKeqExX+yC1ZUO6GMsuALoWaIBkJQ91aRhPPMwlfN2tTrckM6fsFlXIzGFLkhgIuhbMMs6st3BoqZz6dyAOTKv1TuLYFivdmTm1louZogVDw/jUaW4EMqNv3juHubItmIjc+VTUOfSQlYoWyUr6dg8y1EQEOof9JNawm286m2OMdVVJ6zYolYLZd7YCHSflF6gS42UKDtH1Rt/NuY0WqgVzYEkWSC/4zCpvyzANBoNlS2WtjWCiy5iqCmktczANMc8hq6y0MlNEtWAOxRwyGdIDpqXJuNpwoqE4JpZnCpmYQ8CRmOc7CORWH72K4IBIXkhJZbWlBW5ltojj0ZQuIKTd+xeS2UqXap1wZ6lbGAsmLtc7cLy4enhOSamsa9JA53t4DkAUHBKGdPJxuhbMhEbHw1rDEbMl0kCfzwu4why6ZaV6Oz3jJK2z71NR8dvNe2fD2g85OFgUHKjgL5KVbJ2sxMSYVaAfc0jKSp0B/Le5cih96XorAVEWlyorKdfgL3/XbYlK6DQYRlgP0+zEvaJIUrvcxRzC835uozW0PKMt+MyYUq9D1oad45gCB0wZc9Dt3mnqWq8KaRWMMVy3UhWTmbKAbois7TOA5KjMr12s4y3//QtCTknD5a2O6BuzXC3i6lY6c7CkgSSFEZiD3JW1nyHteEHXjlY1pFdmi7i61RGGf0vDHDZbrjZTCQhvOpLXiP5bpoGZoiUFh27mQOcnbRdctEyxU5ZbKYj3lTp4qqA01sNLvYODLOEkmENVJyu5XWa0ONaUQsqnLtSxd66ExWohURjYduO222q2UpqsJDOHYo8Fbb6cHPREzCHLvUDZZGkL5lI12XxPxxy+4YYV3KA0t0zDYqWAuXKcomxGFfaqjEnX3rn11tA7cHUGSBCEacHDMAcg9oH6YRxT4IApCw5pzKHZ8RDw3tRYxXW7ZsRM14HeO4uspGEOT12s4amLdXzi+IWez71S74gq1eWZAq72kJWA+AIZtABOHGvCkA4So0ZVpFVJu0GQkJVWZosIeCyhtKWunPKuPq0xYLlg4ioFB4UZqMFBDjBqhoqK0OiO6xxUQ7rao86B5jgc6hMcZJlsTiMrrSeYQ3p/nLT+XE9erOPmfeFCuZAIDpKsZMl1DunZSo7HxUKfln8ffo5kR944c6///TZXtrSN6AhL1f7MYRDMl21tUSExhxnFc1Ar3AcBTc+jDYXcQ2wYWCbLlK1US8lyGxR9zzJj7BBj7HOMsScYYycYYz+teczNjLH7GGMdxti7pd+XGGMPMMYejZ7789Lf7mWMPRL9d54x9tHo94wx9puMsWcYY8cZY3dl/TC6ltKWaYiFYpAv5bpdVZxbbyUGzgPAhx46i1+/52va9wYGYw7yzU034T0nLvV87pWtjpjBsGumiCuSrKS7iElnHzY4yLJS2LognYGkDfzxfJ6QlXZHTdHohpSpdtEyRGaG2nCOULJNUQGsMoPNZlJW0mUrpaULEnPwIjlFZ0h3vECb4kxN/w4tZvMcgGSBX8k2MVu0RPEfQG2X9cdasIyua9P1AzyzWsfNUZozBcsg4KEhbSdlJWqfoc1WihhjOwNziPtqhfdZlgwnwmzJ7rlpkz0Hzw8iiXT44PCylapo/UEo22aXrKRjnINCLfjsNVMmCzLLSi03zEobMggRsoQWD8DPcM4fZozNAniIMfZ3nPMnpMesAfgpAG9TntsB8CbO+RZjzAbwRcbYJznn93POv4EexBj7MIC/jv757QBuiP57LYDfjf7fF7pMhoLJhAY3yJfysl1VBDy86a/fHVPW999/Cs9f3sK7v+2mrvcO328Az8GLFxm6CR94YQ3rDSfRoEzGlS0HbxCyUgH1tofL9U7qxUCL4zCGGkA71PA4+3kOdEOpprTcPgOIO2Ze3uqAc46mlPtNc5ZrmilwBHmnKwcQHXOQb/KlagGvvW5J1B+oKNoGtjpe1/xo9X1brt/FKs6sNzMZo4ljV3awBxbLOLcRB4d6x8VsSS+X6PpzPX+lAdfnIs15vhxOadtyolGcliorBYlzn3x9BscLMpnLc+J7j9JmMxbBAeE13Ev+WIz6Ibl+IMzYUYLDL3/XbVDLi6pFE+c2kr20ZoqjBwcgmeFG/x920baNbG13xtE6A8jAHDjnFzjnD0c/1wE8CeCA8phVzvmDAFzl95xzTtqMHf2X+HSMsTkAbwLw0ehX3wngT6Ln3g9ggTG2L8uHcTTZNLZpCA1uEOZwfTQr9skLcSsCxwvw5Pkaam0vYRzS3wwG7bwIFTFziHd+dBP6AcdnntSzB8cLsNlyJVkpGkx+pZF6AdONO+wNFWrb4XFmKYIDupmD3HgPAFZmQvPwcr2DjheAK5If3Zi6TCUg+T3KAWRBmulQ12QrWaaBD7zz9XjD9bv0nzXKVlJHhIr37TEq9MxaC4cWK32Hq9hm3EJcpf37F8o4J9XWhC0QUliO3R0cVqPakP3RTG2R3tt00ZFkJdMIK6Dbno9mx9cyB/Kasiz0avO9rHUOAPCTb74Bv/39d6b+fSnyYjaa8kTD4YNDUaoQJ8ifP+6tNJ7gIGe4tUeUlYjN9UOv62YQDHSWGWNHAdwJ4CsDPMdkjD0CYBXA33HO1ee+DcDfc85r0b8PADgj/f0slGAUve6PMcaOMcaOXb58GUA0mlC5iC2TiV3kIBH7pr1h47SHTq2L3z11sSakoFNXk7MD+tUAyIh718RxkiSC3bPFVGmJ6PVy1DaZ/v/cla304FAeA3MQ2Uq9DWnBHFoa5iAVwZEstlpva2+YilSlqkOaNDNftrHRI1upH0hWosW/y5DWNFIjXKy1sG8h2/wPqgJXmcP+hZLIq5dnTOugYw5x2ml4ruV+U7IhDYRtNBqdsENprwrptNnrMugaEwV3A2TuHVgo405ljK6MRan5nhioNQJz0EFmiCJbqTCe4FCNejQBsayU5nn1A6Xl98OOMQcCY2wGwIcBvEtayPuCc+5zzu8AcBDAaxhjr1Qe8n0A/jzr60mv+17O+d2c87tXVlYA6GUP2zTELjJrnQM9745DCzh2ak387tGzcfrlKWWwjFrW3wtFnecQMY+33rYP9568rN2dUoYOMQfqrX+2R0YFLY7DzpK1zbgPVL8AmDYqtLt9hoWZyATU6bBqIZKKNOagykq2yQb63MXIkI7bdetlJV2r7NVaR3gp/VBRcukJBxYq2Gy5QtoKOHp6Dqoh3VF27HJhYNtLFoEWbVNsNlINaZ9nLoIDYllp2PkhOpBMR6nLQMhmxwmaa06zQYAw7VWtvh8GBxbKOLMeBnxiENueyjqGQT9AxuAQ+QUfBvCnnPOPDPNGnPMNAJ8D8BbpdXcBeA2Aj0sPPQfgkPTvg9Hv+sLxurNpEg3fBvxSXn1kEU9eqAuZ4fiZDXFDn1ZaeqvdIntBHaYCxEPcv+3Wveh4Af7ha5e7nndZCQ7L1fD/nKdfwHS8ozAH1+PgnEfBt5chnZ6tpL7/ymwRl+sdbcto2lmnBgfpsYk6hkqYSvsbn/4aHnh+DbOlwWbohsxBkpU0hjQAtJSh8X7AcWWrkxhJ2Qv0WVXDneYIn99oaQ11GQWpYI+gLsqJ4CDVOQDhRokyo7Sy0gCprHMKY+x4YTO/Qdu16EDm+vFzGwNNWxwExByqxWQX3nEEhyPLFZxeayIIeDw/ersN6TEM+gGyZSsxAO8D8CTn/DcGeXHG2ApjbCH6uQzgWwE8JT3kuwF8jHMuJ/f/DYD/Pcpaeh2ATc557/zOCK7PNcwh/rIHzRJ49dFF+AHHo2c2AISjF199ZBErs8VuWWmAFDt9tpKPom3g644uYrFi454TF7ueJ6qjiTlIO9V+stKw6X8Fy4Tjhxk6nPcOMmGLa3QVwnlSy24CBQedSUfMITWVNXqsvNMDgDsOLmC+bOM3P/sMHjq1jqPLvdNKVRSjDKC0QUP0bzWd9epWBwFHduYgMmIUQzryCs5ttMRC2yuVtdPFHJJZQgu9ZCXbFN169cwhWQTXK5V1pmjBYElDelimqmKpWsB1u6p4+NTGWDwHHSg4qpsRtTXLMDi8XIXjBVitd9AekTmEqaz9ZaXNMQz6AbJlK70BwA8CeCzyDgDg5wAcBgDO+e8xxvYCOAZgDkDAGHsXgFsA7APwx4wxE2Eg+iDn/GPSa38vgF9R3u8TAN4K4BkATQDvyPph1ClRQNIgHvRLuevwIhgDjp1axx2HF3BytY5ve+Ve1NueaM9M0GVKpUFXIU03lGUa+JZX7MGnTlzsek1qukeafbVgiqretJ3CyHUOkbZNu7ZedQ5G1NtfZg6cc3hK+wwgDA5PXqhpPYdYk+/NHGgKHOHrr9+FR//T/wI/4NjqeAN/30XbEFXDgMaQ1lS8AnGTwN0ZmUPa5zsQpcGe32jFld8pslLRMkVnXzoHqgREi9pG0w3nQNtJ5kDpm+l1DiFzMA3WM9GCMZbor+RIabPjwF2HF/H5r62OVa6SQZ9fzU6bEd/BCMwhqns5dbUxcp2DrfGZVISzHLrb9w+DvsGBc/5FAD35Ief8IkL5R8VxhAZ22vPeqPkdB/AT/Y5LB50mLu+YB00hmy/buHH3LI6dWsfrXraMgAO3H5zH2bUm7nvuavK9B/Ac1NnM9DNpxd9+21785UNn8aVnr+Cbb4obcV3Z6qBSMMVOhzGGXTNFnNtI9xxGl5VCz4FYTr/XmS3ZiVYKtNOxVeYwU8QX+ngO/bKV0mQnM2qTMChK0YJLcxJSU1mV4EDVtdk9B31w2D1bgmkwnFtvibGRabISBQDX5yhY8XAeIF48y7YJ2wzbdodzoKXgYMmeQ49sJTcbC5iTvveO549UqKbiriML+PDDZ3FytS6ObZygYK2eh9lxMIcoOJxea4r7ffg6B5aYR61Dy/XhBXxnDelJh+sH2Gw6XRelLGcM86W8+ugivnpqHY+cCbOWXnVwAYeXK7hYayfaRKiDz3tB15W148X9Xt5w/S7MFi188rGkmnZ1K66OJlDGUl9ZaUTmENdx9NaRw97+0rD5iHHomEO97Yl2EWWNrNQvWyktOAwLGoWZNqJUN9kLiJlDds9BLyuZRjgLIvQcSFZKMaSVUZ5AtyFNs7Wv1MPPo8pKxAbT2mc4XtBlZKdhrmyJ792RxoqOA3dF2Uz3RxuycQYeQMqOU2WlcRjSi2EL99NrzZglD52tZMDr4zn0kyMHwVQEhytbHXzTr34Oj57dxMuijqoEWQYZhs7dfWQR9Y6HDz10FvvnS1iZLeLIcgWcA2fXY2lpkFRWcWPLzMGNb6iiZeJbb9mDTz9xKRFArmw5IhgQaM5u3zqHEbuy6mZl6KBOg3MD/WxtKoQjYz/BHFI0YAJ9j+O4AWTQorrWcMBY9/US98pJGtLEHNTAnYZqMZQDddfLgcUyzm+0xS68lyENqNdQuPjI53q+bIsOt6ohTdAWwVk0zyEbc5gvy8xhtBYXKm7cM4uZooX7n1uLjm10o1tGf1lp+E2IbRrYv1DCqatNwThHkpX6pLLGTfd2uM5hUnFhs41DSxX8wQ/fjf/yT29L/G0UWQkA7j6yBAB4+tKW6Mt/eCkMQLIpPcgNYWuYQ9tLZpN8+237sNF0cd+zsXx1Rcscwn+ny0qjMQfqaps1OKjtmwVz0BjSQDxaM8kcsmUrpTGLYUGL4FrD6ZofDeiHtwBh++3laiHzOX7jTbvx9rsPaf92ICqE69cfJ27eKBVS+vHMBkIiOCiprOJz9ejKmtVcnivZSUN6jMzBNBjuOLQgrpUsA7UGATE51WPaNVvEQsXOVMzXC0eWqji91kTLDbO4hpV4bZNlYA7jaboHTElwuH5lBh945+vxppv3dLV4pkWpEI2BHBSHlspiIXvVoXBgPPVmkYPDIIZ0P+YAAN9wwy7MFC188vFQWgoCjtV6D1kpZRIW7SBGSWX1Ay60zr6jH5WpYHQxq7LS7p7BIVu20rhlJVo81xqOdsiQbRqwTdYdHGptcY1kwbfduhf/99vUcp8Q+xdKuFhrY6PpoNCjP07qNaR8P8ngkCyCI6TJSl6UfplJVirZWK138MDza9jqeCMvqCruOhy3PNkuz0G9nn78G1+OD77z9SO//qGliggOw7IGIFsq67jadQNTEhx6aXi0Sx+kAE4GYwx3Hwk1z9sj5rBcLaBaMBMZS/36DiWOyUwaiEDSkA6P18SbX7Eb95wIpaX/668fx1rDwdcdTVaT7qr2Zg60gxi2nwvdiDSvOIusVE/ISjSASc8cqJup/B2+8aYVvOMNR1NTUXUtDsaBBHNICTyVgpUY3gKEzCGr39APBxYq8AOOZ1a3eu7+aCOhXkPq3I55yQNSs5UIabISAGy1vUzM4VWH5rHRdPH2/+8+PPD82th9gbuOxNf92LOVUjYj8xUbN2ZsBd4LR5YrWGs4WK13hq5xAMJU1n69lWLPYWdSWV/UoCyZYU0gIFysvnjyCm47GDIHxhgOL1cTwWEQ5sAYC41eP9k+Q70Jv/2V+/DXj5zHj/zRg7j35BX8+De9HN91VzIp7K4jC7h+94zIkVdRsk389//tDnzddUuZjk0F3eRUGNZP752LevsHAYdhxDRYbp8BhAV8BgPOb7bEbGPCvvky/tM/uTX1PWiRS+vaOizoGK5sOaIgTYVuGtylWhs3jWERAeJCuKcu1nve4LqMN137mAVpfKZqSAMAY0kWob5+veNqZScVP/DaI/iO2/bh2AvrePCFNbz2ZcNdb2m481AcHIadapgG4TmMsEb0AqWzPn2xPnTrDACwDaNvy+5xMofpDw5mnNY3LN5+9yF8x6v2J2jnkaWKSK0DBjOkge5JXjpt9403raBSMHHvySv45687jPe85Sb1ZfDqI0v4zL/9pp7v9bY7u1pTDXScQNwyIgtz4DxkGrMlW+x0LOWGNg2GpWpRpOcOVsls4M037x77AkQ6/HrTwQ1R40UV5YKZmAkcVkc7Y2QOYZC/sNnG7SndY4GUQkrP79L65UVCZ0iXbf20Pfqet9pepvnMQBiIvuWWPfiWW/ZkevwgmK/YuH73DJ5Z3drGOoftWQ5pxsdzVxqp11UW2FYW5kCJDDlz6AvSukfpbc4Y69IjDy9X8NmvrYod8qBDSMjwI4R6cfIYS7aJf/2m67HecPCz3/6KgRbQcUFlDlkMaSBsoTFbssVOR/e8ldkwOAwauBljeN8Pf91Az8kCCs5+wLWeAxAuJHKdw9VGONFu91x2z6EX9ksMsCdzIEPaVWQl5TzLcmNR4zmkzbag76veHr9/MCxefXgRz6xuoThmQ5rO0UKKbzcqyKP0Az7SOmQZWTwHDyXbGMt3NvXBgSjoKLKSDoeXKnC8ABdrbexfKGv7OvVCN3Po3vUBwL964/VjOd5hMbjnEDdh249yarYSQFXSowXucULXwkNFxbYSqazUJnv37HiYQ7VoYaFiY6PZu3marnmjrjJ5QQ4OiqcFpHcIpfum3vHGmnk0Cv7Zqw/iasMZu9d0cLGC9/3Q3amt3EfFbMkWQ4tGUTDkkb1pGFfTPeAlEBzkatFxQs5Y2r9QDmWlgZiDoW2fMWmQd5BA/wIkyo6ix/dKgaUeUaPosOOEfP57jSiVR3mK6ugxMQcA2D9fxkYzfX40EC/0XRsMTbYSQWdIp517uY5iUq7L11y3hNcM6Z31w5tfMX4pTMbhpdCUHmWTmqVl9+aYWmcAU5Kt1AtkhI57d3okqnU4vRYWcQ16E6mN09RspUkBLRK0W7b7GNKCOUTaJ7XPUD0HIF5Qx83qhoX8/aWlyaqGdMwcxhccqMdSL1NRWwSnuQblFGfZkC72YQ6j1gflSILaaIwUHKL0Yq6OspMwrlkOwEsgOAhZacwX+P6FEqyoLJ5zPrghbRqiZbcXdT2dlB2ajGEMaaCbOajZSkDMHCZl8UkUhqXcxGXFc6DWGYPUOfQDmdK9srHi9hnxseg2KOnMIZvnAAw/CyRHDFIaRpKVorWslyk9rilwwEsiOGwPc7BMAzfsmcWffuU0/uHpy+B8sJ4v8rCWdhQkJmWRlEGDVaiNdb/PGAeHiDn4+joHIF5Qxx24h0UpA3OoFhTPod7G4hiqaGVQOmsW5qAa0upxLKQFB6u3rCT7Z5PIaF9sEMxhFEM6uvd6pbPmzGEAiFTWwvg/6u/8wF3YPVvEO/7owfC9BthhyZ4D9cSZFONPhq3ISv3YES2qNE2NLmRdy2cKDhPjOWQxpFVZaYwFcIQDC+FC0stzSEtlVb+fZCprt1TUz5AOHzt51+WLDeOQleIhYXrm0HZ9XKq1M/f46oep/9atbZKVAOC6XVX81b96A9562z4Ag+VJyzOAs4xivFYoCOaQTVYq2yYMFqe+un2yleg5k4CshnTn/2/v3KPkqO47//n2a0ZvCSFZQm9jjECSQUiAjR88HEISwCa7gEx82Cgvn2WxZbHBuxxzktiJvbG9WZ+ztjkhji3D7nKMiWQMISYcLRGLibGNJCOwJMCvAAIhDQK90Wgev/2jq3pqpntmumeqpqp7fp9z+kz3rarbt2tu1a9+z9tdNgNC46Uz6iEsHjlnCKFTy+dQy6zUXiwX+SsMWJOhIhwG+Z2lvGsOcbJoZvl/OhrrQCiwuwbRHH74y9c50dXLB945a8TfEaX1o5ViSIIbikltBb52w0rWrF7AyoWDJy0NpFjIcfyt8g13YKnlLNHncwhDWYd2SEtiUqlQMUP1mZUG1xxGU1IgTgo5kRP0WvX60SGVNR26epjcVmD/kU7OiCk7OuSsuVN5+JPvZ+mcwfsNhUD1miDV53n6xGLVuteVaKVBrgv3OcTL26a2cf3q+XzgjJGHy4Z+u8HCWTfv2s+kUp53x5Qc2vLCoeJzSPAGJKlhad1fc+i/vGOWCM9fvUlwUK55VBEOFbNStVCZ0lZg2oQip9SZgZs0kmgr5Hmrq2dQR+2EcE2Hzm4mFvN0HOmMNVIp5Ky5U4fcXqvw3mAlXKZNKFY0nZBhNYcaJihn5EjiS9eeM6o+wgezWuGsvb3Go7v3cfGZs2J7yGx54ZCkWWk0lAqK+BwCzSGDtt1QYB1tQDhMaitUmZWKNaKVJLHppotizREYLe3FXEUrqEX4pH38ZA9vHD9Jd6/F7nOoh776XMOHQ0+bUENzKAznc3DNIWvUWl445NlXDrH/SCe/EWO+Rsv/15OKVhottX0O2Roj9Dcr5XOqq+z5pLaoWWlwzQHgHbMnx75oz2gI/weD+RxCJ/GuvYcrpbCT0BzqoVTIVR4shgqHnj6xVCUEprQXyIlBtbZ+PocMPrSMR/qEQ7Xm8H937yMn+i0rPFpaXnNIKs9htPSLVsqwWamvtlJP3dUwJ7fl+zSHIZLgskh4IxysttL7zjiVs+ZO5b9sfIabLy2XNpmdguYAYTh0ee6EGkQts9L63ziDQ8e7+rXNmFRi000XDWq+iiY71qra6ow9hUqeQ7XmsHnXPlYvPoUZk+Iz0WbvbhQzs6e0U8yrUhkxK0RrK1XMShm8CIuRkMl68zgmlQoVM0aoOdQyK2WRUEBPGsTnMLFUYMPa1UxuK/DFf34OSFFzyNeaQ9Xnedlp07ioRt2glQtnDKpRF11PJtLcAAAWxklEQVRzyBy1yrQDvPzGcZ577QiXx1wCpOX/63OmtbPjL36TVYtmDL/zGFLMR5PgspvnEBUI9WaA93NID1KyO6u0F/NIQ+dezJ02gQ1rz6/U/487lLVe2orVpsmBi/2MlKKHsmaOMMv65/uO9Gt/dPc+gNhLpWfvbpQAg0WepElbDc0hi+p71JRU71KjkyM+h64hSnZnkbZCrub60QM5+7SpbFh7Pv/58nem5s+KOqRPxpwr09YvWqk5/netzpJTJzFjYpHtL73Zr/3R5/bz9lmTWHLqpFi/L3t3zXFCf59DdqOVJFVMYPXe4MNoJTMbsmR3Fmkr5Af1NwzkwrfP5MK3z0x4RIMTdUh3xqx9uuaQPSSxcuEMtr3YJxw6u3t46t/e4CPnL4z9+7J3NxonlAo5eq1sk8+yQxr6TEv1O6QLdPcand29FZ9DPVFOWaCtkEtsRbC4idbnqpiVYtLQ8kFCIGR3Xo5HVi2awS87jnEwKBv/9EsHOdHVy0Wnx/+Q0hxXQQsSPpmd7OnNdCgrBL6GzvpNQ6Et/lhnN129RjGvVFaxGwlrzl/AgWMnh98xA5Tyucrc6dM+45tDxaD/LGq045WwCsNPXz7IpWfO5oe/PEBOJKLBunBIidC529VtFdNA3GvjxkX4NFq/Q7qct3Css4funt6a5bqzym8um5P2EOqmrZivrJuRhPYZCp8s+sLGK+fMn05OsP3FNwPh8Dor5k2LbYGfKM1z1bYYlZLLPT10dpdzCLJqeglj3ut3SJdvJkc6u+jqsaaJVGo2aiVSxvmAEfblmkN2mNRW4Ky5U9n+0pscP9nNT186yHtOT2Z5U/+vp0R04Y6srgIX0qjPIbTZH+vsobu3fke20xhtheSilaDvYSDLc3M8ct7CGTz90kF+9KsDdPdaIv4GcOGQGtGSy7XW/s0SYex8vTH0fcKhm+4ea5pIpWajVMhVzElJ+K2KBWVaox2vnLdoOsdO9nDXD1+kmBfnL05mXe3s3pFanGgRrc6u7CziXotQkJUaiFaCcrG+rh5zzSEh+mdIx+9zKOZzrjVkkFULy8Lg8Rc6WLlwRmJrsPtVmxLRkssnuntjjTKJm1AoNJLnAIHm0NvrPoeEiJZgCc1LcTuks/zQMl5ZcMoETp1crqH03oT8DeDCITWiNYs6u7JuVgp9DvVnSENZc3CzUnLUyrKP1ayUz2WumrHTlwwHcNE7kkvCHPZql7RA0hZJuyTtlPTJGvsslfSkpE5Jt0ba2yX9RNKO4NjPRrZJ0uclvSBpt6R1Qfslkg5Jejp4/XlcPzZLtOWjPoesaw6NCYcwz6FsVnKHdFLUTIKLOVopyw8t45krls3h7adO4pz59a8+2Sj15Dl0A39qZtslTQG2SdpsZrsi+7wBrAOuGXBsJ3CZmR2VVASekPSwmf0IWAssAJaaWa+kaCHyH5jZVSP9Uc1AqDl09WTfIV2s5DnUpwEU8jnai7nArOShrElRKuTo6jF6e62iQcQpHIp5ZTb3Zrxz7ar5XLtqfqLfMaxwMLO9wN7g/RFJu4F5wK7IPvuB/ZKuHHCsAUeDj8XgFa5UcRPwe2bWG+lj3FAaoDkMtvJYFmjUrARh8b0euposCa6ZKEVNkwnkysyYWPJIpXFMQ3ckSYuBlcCPGzgmD2wD3gHcYWbhsacDayT9LtABrDOznwfb3iNpB/AqcKuZ7WxknM3AwGilmZMybFYagXAIi+9191jd+RFOY0Tr+3d217/eRr385YeX02vVq44544O6Z5OkycAmYL2ZHa73ODPrMbNzgfnABZKWB5vagBNmthr4e2BD0L4dWGRm5wBfBb43yHg+JmmrpK0dHR31DiczVDKkwzyHDGehhiavRkwMYdnu7l7XHJIi9FOd7O7lZAJ+q1lT2lJZH9vJBnVdtYG/YBNwj5l9dyRfZGYHgS3AbwVNe4Cwr/uBdwX7HTazo8H77wNFSVXxWmb2dTNbbWarZ82aNZIhpUqpojmEGdLZvYEWG3RIQ9860l4+IzkqQQ2BWSluzcEZ39QTrSTgm8BuM/tyI51LmiVpevB+AnA58Fyw+XvApcH7i4EXgv3mBN+JpAuCMR5o5Hubgf4Z0s1RPqPeJDgoaw5hnoNHKyVDRfvs6vHqqU7s1ONzeC9wI/CspKeDtk8DCwHM7E5Jc4CtwFSgV9J64GxgLnB34HfIAfeZ2UNBH18A7pF0C2Wn9R8H7dcCN0nqBt4CPhI4tluKYmSx8FbLc4A+n0N7Me95DgkRdUifzLj26TQf9UQrPQEMeXWb2WuUfQoDeYayA7vWMQeBK2u0fw342nDjanaimsOJjD/1jSxaKc/Rzh7yObnmkBADI9487NSJE59NKRFd7OdkxmvmV3wODTqkPc8hWaIPGCczbpp0mg8XDikRPvUdOdENZLtmfiVaqYGb/KS2Am919dDZ5dFKSdHWz2+VbdOk03z4bEqJXE4UcuLIifJKXll+6htpEhzAobe6PM8hIfoWjHKzkhM/PptSpFTIcbQz0BwyfGGPNJQV4K2uHjcrJURftJI7pJ348dmUIsV8rs+slOELu9E1pKFPOABuVkqItn7lM9zn4MSLX7UpUirkOFrxOWT3wu5b7KexaKUQNyslQynflyHd2dXjZiUnVnw2pUgpn+NwxeeQ3X/FyHwOxcr7goeyJkK/aKUeNys58eKzKUWaxefQt55DI9FKEc3Bk+ASoS9aqSdYaja72qfTfGT3jjQOKPXzOWT3wn7X/GlcsextLJ07te5joiXIXXNIhv7FGz1ayYmX7C4iMA4oFtSnOWQ4z2Hm5Db+7sbVDR3TzyHtPodEiAoHNys5ceOzKUVK+Rw9veWyUVnOkB4JUc2h6NFKiVDICYmmeMBwmg+fTSkSdfC22oXdVshVCu655pAMkvqZJr1ktxMnPptSJGojbjWTgKSKacl9DsnRVsj1ZdlnOBzaaT78qk2R6JNelh3SIyU0LXm0UnKUCnkOh0ENLoSdGPHZlCL9NIcWMytBXziraw7J0VbIcbSiOfh5duLDZ1OK9PM5tJhZCfoiljxDOjlKheYoweI0Hz6bUiSqObSiMzE0K3ltpeTo55B24eDEiM+mFAk1h7ZCjmDZ7JaiIhxcc0iM/ln2ree3ctLDhUOKhGaAVjUHuFkpedqapASL03z4bEqR8KbZqiGIblZKnn6mSRcOToz4bEqR8GJub9Eok75oJdcckqJ/rkxrPmQ46dCad6Umoc/n0JoXdVi2u5FS305jlFo84s1JD59NKVJqcZ9DuOBPwZPgEsPNSk5S+GxKkVK+tYVDn0O6NX9fFohqna06j5x08NmUIn2aQ2ualZadNo3FMycyb/qEtIfSsvTPsm/NeeSkg6/nkCIVzaFFHdJnzpnCY5+6NO1htDRtLZ5I6aSHz6YUKba4WclJnlBzkDyfxIkXvyulSKublZzkKbV4lr2THi4cUsQ1B2e0hA8YblJy4sZnVIq0VZLgXHNwRkalBIvPISdmXDikiGsOzmhxzcFJCo9WSpGKz6FFo5Wc5PE51BhdXV3s2bOHEydOpD2UMaW9vZ358+dTLBbrPsaFQ4pUCu+5Q9oZIaUWL8ESN3v27GHKlCksXrx43DjwzYwDBw6wZ88elixZUvdxwz5uSFogaYukXZJ2SvpkjX2WSnpSUqekWyPt7ZJ+ImlHcOxnI9sk6fOSXpC0W9K6SPtXJP1C0jOSzqv71zQZrV4+w0meilnJ51BdnDhxgpkzZ44bwQAgiZkzZzasLdWjOXQDf2pm2yVNAbZJ2mxmuyL7vAGsA64ZcGwncJmZHZVUBJ6Q9LCZ/QhYCywAlppZr6TZwTG/DZwRvC4E/jb423K0evkMJ3lafU2QJBhPgiFkJL952BllZnvNbHvw/giwG5g3YJ/9ZvYU0DWg3czsaPCxGLws+HwT8Jdm1hv2EbR/GPhfwbE/AqZLmtvwL2sCSh5p4oyS0JzkwsGJm4ZmlKTFwErgxw0ck5f0NLAf2Gxm4bGnA2skbZX0sKQzgvZ5wMuRLvYwQBi1CqdNn8D1q+fz3tNPTXsoTpPipsnWZvLkyal9d90zStJkYBOw3swO13ucmfWY2bnAfOACScuDTW3ACTNbDfw9sKH+YYOkjwWCZWtHR0cjh2aGYj7Hl649h4UzJ6Y9FKdJ8Sx7JynqEg6Bv2ATcI+ZfXckX2RmB4EtwG8FTXuAsK/7gXcF71+h7IsImR+0Dezv62a22sxWz5o1ayRDcpymx/1WzcVtt93GHXfcUfn8mc98hs997nN88IMf5LzzzmPFihU88MADVcc99thjXHXVVZXPH//4x7nrrrsA2LZtGxdffDGrVq3iiiuuYO/evbGMdViHtMqejG8Cu83sy410LmkW0GVmByVNAC4Hvhhs/h5wKfBr4GLghaD9QeDjku6l7Ig+ZGbx/FrHaTE8WmnkfPYfd7Lr1bqNIHVx9mlT+Yurlw26fc2aNaxfv56bb74ZgPvuu49HHnmEdevWMXXqVF5//XXe/e5386EPfaguJ3JXVxef+MQneOCBB5g1axbf+c53uP3229mwoSFDTE3qiVZ6L3Aj8GzgOwD4NLAQwMzulDQH2ApMBXolrQfOBuYCd0vKU9ZS7jOzh4I+vgDcI+kW4Cjwx0H794HfAX4BHAf+YHQ/0XFaF49Wai5WrlzJ/v37efXVV+no6GDGjBnMmTOHW265hccff5xcLscrr7zCvn37mDNnzrD9Pf/88/zsZz/j8ssvB6Cnp4e5c+OJ3xlWOJjZE8CQIszMXqNs/hnIM5Qd2LWOOQhcWaPdgJuHG5fjOB7xNhqGesJPkuuuu46NGzfy2muvsWbNGu655x46OjrYtm0bxWKRxYsXV+UkFAoFent7K5/D7WbGsmXLePLJJ2Mfpz9uOE4T47WVmo81a9Zw7733snHjRq677joOHTrE7NmzKRaLbNmyhRdffLHqmEWLFrFr1y46Ozs5ePAgjz76KABnnnkmHR0dFeHQ1dXFzp07Yxmnl89wnCamLe95Ds3GsmXLOHLkCPPmzWPu3Ll89KMf5eqrr2bFihWsXr2apUuXVh2zYMECrr/+epYvX86SJUtYubJskCmVSmzcuJF169Zx6NAhuru7Wb9+PcuWjV4rUtmK09ysXr3atm7dmvYwHGfM6erp5ZL//hi3X3kWv7OiJXNFY2X37t2cddZZaQ8jFWr9dknbgnSCKlxzcJwmppjP8a+3XZb2MJwWxHVRx3EcpwoXDo7jjCtawZTeKCP5zS4cHMcZN7S3t3PgwIFxJSDC9Rza29sbOs59Do7jjBvmz5/Pnj17aNZ6bCMlXAmuEVw4OI4zbigWiw2thjaecbOS4ziOU4ULB8dxHKcKFw6O4zhOFS2RIS3pCPB8jF1OAw5lsK+4+4v2dSrweoz9jZZmOW/1MNy5baXfmnR/0XOZtbEl1Vfc/UX7OtPMptTcy8ya/gVsjbm/r2exryTHFsc5HI/nrc79hzy3rfRbk+4vei6zNrYsn7fB+hpqbrpZqTb/mNG+4u7Px5Z+X1nvz8eWfl9x91dXX61iVtpqgxSPcurDz2Fy+LmNDz+X8TLU+WwVzeHraQ+gBfBzmBx+buPDz2W8DHo+W0JzcBzHceKlVTQHx3EcJ0ZcODiO4zhVNIVwkNQj6enIa/EQ+z4myR1WA5Bkkv5P5HNBUoekh9IcV6sg6ZrgHFev8ejUhc/RbNEUwgF4y8zOjbz+Le0BNSHHgOWSJgSfLwdeaaQDSV6ocXBuAJ4I/taNpHwyw2lKRj1HnfhoFuFQhaRVkv6fpG2SHpEUXUD3xkDD+JmkC1IbZPb4PnBl8P4G4NvhBkkXSHpS0k8l/VDSmUH7WkkPSvoX4NGxH3L2kTQZeB/wR8BHgrZLJD0u6Z8kPS/pTkm5YNtRSf9D0g7gPemNPJOMZI4+LuncyH5PSDpnTEfdgjSLcJgQMSndL6kIfBW41sxWARuAz0f2n2hm5wL/KdjmlLkX+IikduBdwI8j254D3m9mK4E/B/5bZNt5lM/1xWM20ubiw8A/m9kLwAFJq4L2C4BPAGcDpwP/LmifBPzYzM4xsyfGfLTZZiRz9JvAWgBJ7wTazWzHmI24RWkWM8Fbwc0eAEnLgeXAZkkAeWBvZP9vA5jZ45KmSppuZgfHcsBZxMyeCfw1N1B+QosyDbhb0hmAAcXIts1m9saYDLI5uQH4n8H7e4PPDwE/MbNfAUj6NmXtYiPQA2xKYZyZZ4Rz9B+AP5P0KeAPgbvGZLAtTrMIh4EI2Glmg6nkA5M3PJmjjweBvwEuAWZG2v8K2GJmvxtcnI9Fth0bo7E1HZJOAS4DVkgyyg8qBvwTg8/DE2bWM3ajbDoamqNmdlzSZsoa3PXAKpxR0yxmpYE8D8yS9B4ASUVJyyLb1wTt7wMOmVmc1RGbnQ3AZ83s2QHt0+hz/q0d0xE1N9cC/9vMFpnZYjNbAPwaeD9wgaQlga9hDWWHtTM8I5mj3wC+AjxlZm8mO7zxQVMKBzM7Sfmi/GLg1HsauCiyywlJPwXupOwkdALMbI+ZfaXGpi8Bfx2ct2bVKNPgBuD+AW2bgvangK8BuykLjIH7OTUYyRw1s23AYeBbYzDEcYGXz3CcBJB0CXCrmV2V9ljGA5JOo2xmWmpmvSkPpyVoSs3BcRwnRNJ/oBzVdLsLhvhwzcFxHMepIpOag6QFkrZI2iVpp6RPBu2nSNos6efB3xlB+9IgOaZT0q0D+pouaaOk5yTtDp3YjuM4zuBkUnMIsp3nmtl2SVOAbcA1lCMU3jCzL0i6DZhhZv9V0mxgUbDPm2b2N5G+7gZ+YGbfkFSinCA37nMeHMdxhiKTmoOZ7TWz7cH7I5SjPeZRjmO+O9jtbsrCADPbb2ZPAV3RfiRNAz5AOYMSMzvpgsFxHGd4MikcogTJLispO5zeZmZhJvRrwNuGOXwJ0AF8K6jH8g1Jk5Iaq+M4TquQaeEQFDTbBKw3s8PRbVa2hw1nEytQrgv0t0E9lmPAbUmM1XEcp5XIrHAIiuttAu4xs+8GzfvC6qvB3/3DdLMH2GNmYfGujZSFheM4jjMEmRQOKlfT+yaw28y+HNn0IPD7wfvfBx4Yqh8zew14OSztC3wQ2BXzcB3HcVqOrEYrvQ/4AfAsECa1fJqy3+E+YCHwInC9mb0haQ6wFZga7H8UONvMDgd13r8BlIBfAX/gtVccx3GGJpPCwXEcx0mXTJqVHMdxnHRx4eA4juNU4cLBcRzHqcKFg+M4jlOFCwfHcRynChcOjhMDkj4zsCLwgO3XSDp7LMfkOKPBhYPjjA3XAC4cnKbB8xwcZ4RIup1ypv5+4GXKpeUPAR+jnHT5C+BG4FzgoWDbIeDfB13cAcwCjgN/YmbPjeX4HWcoXDg4zgiQtAq4C7iQcoHH7cCdwLfM7ECwz+eAfWb2VUl3AQ+Z2cZg26PAfzSzn0u6EPhrM7ts7H+J49SmkPYAHKdJeT9wv5kdB5D0YNC+PBAK04HJwCMDDwyqDV8E/EO5jBgAbYmP2HEawIWD48TLXcA1ZrZD0lrgkhr75ICDZnbuGI7LcRrCHdKOMzIeB66RNCFYyvbqoH0KsDcoOf/RyP5Hgm0Ea5P8WtJ1UK5CLOmcsRu64wyPCwfHGQHBMrbfAXYADwNPBZv+jHL14H8Fog7me4FPBSsSnk5ZcPyRpB3ATspL4DpOZnCHtOM4jlOFaw6O4zhOFS4cHMdxnCpcODiO4zhVuHBwHMdxqnDh4DiO41ThwsFxHMepwoWD4ziOU4ULB8dxHKeK/w8GV3HqFd2cwQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "total_subscribers_per_day_results.plot(x=\"date\", y=\"value\")" + "first_result = total_subscribers_per_day_queries[all_dates[0]].get_result()\n", + "first_result" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "- Should be stable over time except for possible small changes due to new mobility restrictions\n", - "- Should show weekly variation (but not in the synthetic data)" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 63, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "subscribers_per_admin1_per_day_results.pivot(index=\"date\", columns=\"pcod\", values=\"value\").plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 142, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 142, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "subscribers_per_admin2_per_day_results.pivot(index=\"date\", columns=\"pcod\", values=\"value\").plot(legend=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 152, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 152, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# May be clearer to plot sum\n", - "plt.figure()\n", - "subscribers_per_admin2_per_day_results.groupby(\"date\").sum().plot(ax=plt.gca(), y=\"value\", label=\"sum(subscribers per admin2)\")\n", + "This result has two columns:\n", "\n", - "# Similar for OD matrix\n", - "od_matrix_admin2_per_day_results.groupby(\"date\").sum().plot(ax=plt.gca(), y=\"value\", label=\"sum(OD matrix)\")\n", + "- `pcod` is the P-code. Since this result is at admin0 level, there is only one P-code (\"GH\" is the P-code for the whole of Ghana).\n", + "- `value` is the unique subscriber count.\n", "\n", - "# Show total subscribers for comparison\n", - "total_subscribers_per_day_results.plot(ax=plt.gca(), x=\"date\", y=\"value\", label=\"total subscribers\")" + "This is the result for a single day. It will be convenient for us to combine the \"total subscribers per day\" results for all days into a single DataFrame - so that we know which result corresponds to which date, we can add a 'date' column:" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "- Should be stable over time except for changes due to new mobility restrictions (in this case, sharp changes are due to start of simulated \"disaster\" on 2016-03-01 and start of recovery period on 2016-03-10)\n", - "- Should show weekly variation (but not in the synthetic data)\n", - "- Explain why sum of admin2 is larger than total" + "# Add date column\n", + "first_result[\"date\"] = all_dates[0]\n", + "first_result" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Spatial distribution of subscriber counts\n", - "Should be larger in urban districts, smaller in rural" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Calculate median daily subscriber count per admin2\n", - "median_subscribers_per_admin2 = subscribers_per_admin2_per_day_results.groupby(\"pcod\").median()" - ] - }, - { - "cell_type": "code", - "execution_count": 65, - "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", - "
geometrypcodcentroid
0MULTIPOLYGON (((-1.41637 6.32333, -1.43242 6.3...GHA.1.1_1{'type': 'Point', 'coordinates': [-1.585607706...
1MULTIPOLYGON (((-1.54145 5.93492, -1.53550 5.9...GHA.1.2_1{'type': 'Point', 'coordinates': [-1.394701237...
2MULTIPOLYGON (((-1.41025 6.86558, -1.42795 6.8...GHA.1.3_1{'type': 'Point', 'coordinates': [-1.557937016...
3MULTIPOLYGON (((-2.29597 6.71882, -2.29462 6.7...GHA.1.4_1{'type': 'Point', 'coordinates': [-2.201639978...
4MULTIPOLYGON (((-1.81879 6.98329, -1.83513 6.9...GHA.1.5_1{'type': 'Point', 'coordinates': [-1.957634046...
............
132MULTIPOLYGON (((-2.36110 6.08630, -2.36740 6.0...GHA.10.9_1{'type': 'Point', 'coordinates': [-2.609585309...
133MULTIPOLYGON (((-1.82511 5.57554, -1.82662 5.5...GHA.10.11_1{'type': 'Point', 'coordinates': [-2.009582598...
134MULTIPOLYGON (((-1.70347 4.94569, -1.70347 4.9...GHA.10.10_1{'type': 'Point', 'coordinates': [-1.658353642...
135MULTIPOLYGON (((-2.59935 5.44091, -2.59728 5.4...GHA.10.12_1{'type': 'Point', 'coordinates': [-2.332295004...
136MULTIPOLYGON (((-1.97473 4.91827, -1.98106 4.9...GHA.10.13_1{'type': 'Point', 'coordinates': [-1.990833941...
\n", - "

137 rows × 3 columns

\n", - "
" - ], - "text/plain": [ - " geometry pcod \\\n", - "0 MULTIPOLYGON (((-1.41637 6.32333, -1.43242 6.3... GHA.1.1_1 \n", - "1 MULTIPOLYGON (((-1.54145 5.93492, -1.53550 5.9... GHA.1.2_1 \n", - "2 MULTIPOLYGON (((-1.41025 6.86558, -1.42795 6.8... GHA.1.3_1 \n", - "3 MULTIPOLYGON (((-2.29597 6.71882, -2.29462 6.7... GHA.1.4_1 \n", - "4 MULTIPOLYGON (((-1.81879 6.98329, -1.83513 6.9... GHA.1.5_1 \n", - ".. ... ... \n", - "132 MULTIPOLYGON (((-2.36110 6.08630, -2.36740 6.0... GHA.10.9_1 \n", - "133 MULTIPOLYGON (((-1.82511 5.57554, -1.82662 5.5... GHA.10.11_1 \n", - "134 MULTIPOLYGON (((-1.70347 4.94569, -1.70347 4.9... GHA.10.10_1 \n", - "135 MULTIPOLYGON (((-2.59935 5.44091, -2.59728 5.4... GHA.10.12_1 \n", - "136 MULTIPOLYGON (((-1.97473 4.91827, -1.98106 4.9... GHA.10.13_1 \n", - "\n", - " centroid \n", - "0 {'type': 'Point', 'coordinates': [-1.585607706... \n", - "1 {'type': 'Point', 'coordinates': [-1.394701237... \n", - "2 {'type': 'Point', 'coordinates': [-1.557937016... \n", - "3 {'type': 'Point', 'coordinates': [-2.201639978... \n", - "4 {'type': 'Point', 'coordinates': [-1.957634046... \n", - ".. ... \n", - "132 {'type': 'Point', 'coordinates': [-2.609585309... \n", - "133 {'type': 'Point', 'coordinates': [-2.009582598... \n", - "134 {'type': 'Point', 'coordinates': [-1.658353642... \n", - "135 {'type': 'Point', 'coordinates': [-2.332295004... \n", - "136 {'type': 'Point', 'coordinates': [-1.990833941... \n", - "\n", - "[137 rows x 3 columns]" - ] - }, - "execution_count": 65, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Get admin2 boundaries\n", - "admin2_geojson = fc.get_geography(connection=conn, aggregation_unit=\"admin2\")\n", - "admin2_gdf = gpd.GeoDataFrame.from_features(admin2_geojson)\n", - "admin2_gdf" - ] - }, - { - "cell_type": "code", - "execution_count": 68, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 68, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Join median subscriber counts to admin boundaries, and plot\n", - "median_subscribers_per_admin2_with_geo = admin2_gdf.merge(\n", - " median_subscribers_per_admin2, left_on=\"pcod\", right_index=True\n", - ")\n", - "\n", - "median_subscribers_per_admin2_with_geo.plot(column=\"value\", legend=True)" + "The most convenient way to combine the \"total subscribers per day\" results for all dates into a single DataFrame is to use the pandas `concat` function. First, we can use a list comprehension to get a list of individual result DataFrames (`.assign(date=day)` adds the value of `day` in a new `date` column):" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "- Should have larger subscriber counts in urban districts, and smaller in rural districts" + "all_total_subscribers_results = [\n", + " query.get_result().assign(date=day)\n", + " for day, query in total_subscribers_per_day_queries.items()\n", + "]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Events per subscriber (for each admin2, then for whole country)" + "Now we can use `pd.concat` to concatenate all the DataFrames in the list `all_total_subscribers_results` into a single DataFrame (the `ignore_index=True` option ensures that each row in the final DataFrame has a unique index, rather than keeping the indexes from the individual DataFrames):" ] }, { "cell_type": "code", - "execution_count": 124, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 124, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "# Total events per day\n", - "average_events_per_subscriber = total_events_per_day_results.set_index(\"date\").value / total_subscribers_per_day_results.set_index(\"date\").value\n", + "total_subscribers_per_day_results = pd.concat(\n", + " all_total_subscribers_results, ignore_index=True\n", + ")\n", "\n", - "average_events_per_subscriber.plot()" + "total_subscribers_per_day_results" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "- Values should be reasonable (e.g. not 500 events per subscriber per day)\n", - "- Values should be >= 1 (because every active subscriber has at least 1 event\n", - "- Values should be fairly stable over time" + "The `total_subscribers_per_day_results` DataFrame contains the total daily subscriber count for each day in our date range. The `pcod` column is not useful in this case - it has the same value for every row, so we can drop it:" ] }, { "cell_type": "code", - "execution_count": 141, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 141, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "# Per admin2\n", - "events_per_subscriber_per_admin2 = (\n", - " events_per_admin2_per_day_results.set_index([\"date\", \"pcod\"]) / subscribers_per_admin2_per_day_results.set_index([\"date\", \"pcod\"])\n", - ").reset_index()\n", - "events_per_subscriber_per_admin2.pivot(index=\"date\", columns=\"pcod\", values=\"value\").plot(legend=False)" + "total_subscribers_per_day_results = total_subscribers_per_day_results.drop(\n", + " columns=\"pcod\"\n", + ")\n", + "total_subscribers_per_day_results" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Missing data\n", - "- Total events per day, over time" - ] - }, - { - "cell_type": "code", - "execution_count": 135, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 135, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "#### 2. Subscriber count per region per day\n", + "\n", + "We can get the \"subscribers per region per day\" results in the same way. This time we're getting the list of individual query results within the call to `pd.concat()` instead of assigning it to a new variable first, but the process here is the same." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "total_events_per_day_results.plot(x=\"date\", y=\"value\")" + "subscribers_per_region_per_day_results = pd.concat(\n", + " [\n", + " query.get_result().assign(date=day)\n", + " for day, query in subscribers_per_region_per_day_queries.items()\n", + " ],\n", + " ignore_index=True,\n", + ")\n", + "\n", + "subscribers_per_region_per_day_results" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "- If there's an anomaly, show a map of events per admin2 on that day, to see if there's a spatial effect" + "This time the `pcod` column contains the level 1 P-code that identifies each region. There are 10 regions, so we get 10 subscriber counts per day. In this case the `pcod` column contains useful information, so we'll keep it.\n", + "\n", + "#### 3. Subscriber count per district per day\n", + "\n", + "We can get the \"subscribers per district per day\" results in the same way. This DataFrame is larger than `subscribers_per_region_per_day_results`, because there are 137 districts." ] }, { "cell_type": "code", - "execution_count": 156, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 156, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "# E.g. if total event count was lower on 13 March, can plot event count per admin2 on that day\n", - "admin2_gdf.merge(\n", - " events_per_admin2_per_day_results[events_per_admin2_per_day_results.date == \"2016-03-14\"],\n", - " on=\"pcod\",\n", - ").plot(column=\"value\", legend=True)" + "subscribers_per_district_per_day_results = pd.concat(\n", + " [\n", + " query.get_result().assign(date=day)\n", + " for day, query in subscribers_per_district_per_day_queries.items()\n", + " ],\n", + " ignore_index=True,\n", + ")\n", + "\n", + "subscribers_per_district_per_day_results" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "If no data for parts of the country, suggests the CDR data are incomplete." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Indicators\n", - "\n", - "- Calculate indicators from aggregates\n", - " - Scaled subscriber count per admin2 (including baseline calculation)\n", - " - Average admin2 visited per subscriber for each admin1\n", - " - Scaled OD matrix subscriber count\n", - "- Produce visualisations (not sure exactly what to show for OD matrix - maybe pick a few pairs and show line plots; could also do a before vs after map of Accra -> other)\n", - "- Explain what we see" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Scaled subscriber count per admin2\n", - "\n", - "- Divide subscriber count by total, to mitigate effects of changes in calling behaviour (i.e. assume actual number of people is ~ constant, so changes in total are due to people calling more/less)\n", - "- Calculate baseline average\n", - "- % of baseline" - ] - }, - { - "cell_type": "code", - "execution_count": 181, - "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", - "
pcodvaluedatetotal_subscribersscaled_subscriber_count
0GHA.10.10_1649822016-02-0321382070.030391
1GHA.10.1_1138682016-02-0321382070.006486
2GHA.10.11_189342016-02-0321382070.004178
3GHA.10.12_1144852016-02-0321382070.006774
4GHA.10.13_1227582016-02-0321382070.010643
..................
5580GHA.9.5_1153982016-04-1121370140.007205
5581GHA.9.6_164032016-04-1121370140.002996
5582GHA.9.7_1164602016-04-1121370140.007702
5583GHA.9.8_1254062016-04-1121370140.011889
5584GHA.9.9_1118492016-04-1121370140.005545
\n", - "

5585 rows × 5 columns

\n", - "
" - ], - "text/plain": [ - " pcod value date total_subscribers \\\n", - "0 GHA.10.10_1 64982 2016-02-03 2138207 \n", - "1 GHA.10.1_1 13868 2016-02-03 2138207 \n", - "2 GHA.10.11_1 8934 2016-02-03 2138207 \n", - "3 GHA.10.12_1 14485 2016-02-03 2138207 \n", - "4 GHA.10.13_1 22758 2016-02-03 2138207 \n", - "... ... ... ... ... \n", - "5580 GHA.9.5_1 15398 2016-04-11 2137014 \n", - "5581 GHA.9.6_1 6403 2016-04-11 2137014 \n", - "5582 GHA.9.7_1 16460 2016-04-11 2137014 \n", - "5583 GHA.9.8_1 25406 2016-04-11 2137014 \n", - "5584 GHA.9.9_1 11849 2016-04-11 2137014 \n", - "\n", - " scaled_subscriber_count \n", - "0 0.030391 \n", - "1 0.006486 \n", - "2 0.004178 \n", - "3 0.006774 \n", - "4 0.010643 \n", - "... ... \n", - "5580 0.007205 \n", - "5581 0.002996 \n", - "5582 0.007702 \n", - "5583 0.011889 \n", - "5584 0.005545 \n", - "\n", - "[5585 rows x 5 columns]" - ] - }, - "execution_count": 181, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Merge admin2 and total subscribers\n", - "merged_subscriber_counts = subscribers_per_admin2_per_day_results.merge(\n", - " total_subscribers_per_day_results.rename(columns={\"value\": \"total_subscribers\"}), on=\"date\"\n", - ")\n", + "#### 4. District-level OD matrix per day\n", "\n", - "# Divide sub count by total subs to get scaled sub count\n", + "The process for getting the OD matrix results is the same:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "od_matrix_district_per_day_results = pd.concat(\n", + " [\n", + " query.get_result().assign(date=day)\n", + " for day, query in od_matrix_district_per_day_queries.items()\n", + " ],\n", + " ignore_index=True,\n", + ")\n", + "\n", + "od_matrix_district_per_day_results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This DataFrame has four columns:\n", + "\n", + "- `pcod_from` is the P-code of the first district,\n", + "- `pcod_to` is the P-code of the second district,\n", + "- `value` is the number of unique subscribers who were active in `pcod_from` and later `pcod_to`,\n", + "- `date` is the date on which subscribers were active.\n", + "\n", + "#### 5. Total event count per day\n", + "\n", + "\"Total events per day\" is a single query, so we can get the full result using a single call to `get_result()`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "total_events_per_day_results = total_events_per_day_query.get_result()\n", + "total_events_per_day_results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This has three columns: `pcod` (the P-code for Ghana - this is always \"GH\"), `date` (the date on which events were counted) and `value` (the count of CDR events on that date). At first glance it looks like this is in the format we need, but let's check the information about this DataFrame:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "total_events_per_day_results.info()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The datatype of the `date` column is 'object' (i.e. string). For later analysis, it will be useful to convert this column to 'datetime' data type, which we can do using the pandas `to_datetime` function. Let's also drop the \"pcod\" column (as we did for \"total subscribers per day\"), becuse this doesn't contain useful information." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "total_events_per_day_results[\"date\"] = pd.to_datetime(\n", + " total_events_per_day_results[\"date\"]\n", + ")\n", + "\n", + "total_events_per_day_results = total_events_per_day_results.drop(columns=[\"pcod\"])\n", + "\n", + "total_events_per_day_results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 6. Event count per district per day\n", + "\n", + "\"Events per district per day\" is a single query, like \"total events per day\", so we can get the result in the same way. Again, we'll convert the `date` column to 'datetime' type. This time the `pcod` column is important (it identifies the districts), so we'll keep it." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "events_per_district_per_day_results = events_per_district_per_day_query.get_result()\n", + "events_per_district_per_day_results[\"date\"] = pd.to_datetime(\n", + " events_per_district_per_day_results[\"date\"]\n", + ")\n", + "\n", + "events_per_district_per_day_results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### QA checks\n", + "\n", + "It is possible that some of the CDR data available in FlowKit may be incomplete or incorrect. If this is the case, conclusions we draw from our aggregates may be incorrect or misleading, so it is important to perform some quality checks on our query results before we use them to investigate mobility patterns. In this section we'll go through some of these checks." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Time-series plots\n", + "\n", + "A simple check we can perform is to plot the subscriber counts over time, and look for any unexpected changes. For example, we can plot the total subscriber count per day:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "total_subscribers_per_day_results.plot(x=\"date\", y=\"value\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that the total subscriber count per day remains stable over time, except for some very small fluctuations. If there were any large changes, this could indicate either missing data or changes in calling behaviour, either of which would make the insights from these results unreliable.\n", + "\n", + "**Note:** In real data, we would expect to see a repeating weekly pattern of variation in these results - for example, the number of active subscribers on a Sunday may typically be lower than on a weekday. The data we're using here are synthetic, and there is no such pattern present.\n", + "\n", + "We can make a similar plot of subscriber counts per region, using the pandas `pivot` method to transform the DataFrame into a structure that can easily be plotted as multiple lines:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "subscribers_per_region_per_day_results.pivot(\n", + " index=\"date\", columns=\"pcod\", values=\"value\"\n", + ").plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we can see that there is a very large drop in the subscriber counts in 'GHA.1_1' (Ashanti region) on 1st March, followed by a smaller increase on 10th March. Subscriber counts in all other regions increase when the subscriber counts in Ashanti decrease. This is due to the modelled mobility pattern in the synthetic dataset, in which all subscribers were forced to leave the Ashanti region on 1st March and were allowed to begin returning from 10th March. So in this case, the changes seen here are due to \"real\" mobility changes, rather than problems with the data.\n", + "\n", + "**Note:** In a real-life scenario we would not usually expect changes due to mobility restrictions to be as large or as sudden as those seen here. However, such changes would typically be visible in these plots, so care should be taken when trying to determine whether a change is a \"real\" effect or a data issue.\n", + "\n", + "We can make a similar plot of district-level subscriber counts:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "subscribers_per_district_per_day_results.pivot(\n", + " index=\"date\", columns=\"pcod\", values=\"value\"\n", + ").plot(legend=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Again we can see the sharp changes on 1st and 10th March. Due to the large number of districts, it may be more insightful to plot the sum of subscriber counts across all districts. Let's include the \"total subscribers per day\" data in the same plot, for comparison - we can do this by creating a matplotlib figure, and specifying `ax=plt.gca()` (\"get current axes\") to plot multiple results in the same plot." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a matplotlib figure\n", + "plt.figure()\n", + "\n", + "# Show total subscriber count for comparison\n", + "total_subscribers_per_day_results.plot(\n", + " ax=plt.gca(), x=\"date\", y=\"value\", label=\"total subscribers\"\n", + ")\n", + "\n", + "# Plot the sum of per-district subscriber counts across all districts\n", + "subscribers_per_district_per_day_results.groupby(\"date\").sum().plot(\n", + " ax=plt.gca(), y=\"value\", label=\"sum(subscribers per district)\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that the sum of subscriber counts across all districts is also stable over time (again, if we were using real data we'd expect to see weekly variation, and changes due to mobility restrictions). Also, the sum of district-level subscriber counts is always larger than the total subscriber count - this is because some subscribers will be active in multiple districts on the same day, so they will be counted multiple times in the sum, whereas each subscriber is counted only once in the country-level total subscriber count.\n", + "\n", + "Let's also plot the sum of OD matrix counts:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.figure()\n", + "\n", + "# Show total subscriber count for comparison\n", + "total_subscribers_per_day_results.plot(\n", + " ax=plt.gca(), x=\"date\", y=\"value\", label=\"total subscribers\"\n", + ")\n", + "\n", + "# Plot the sum of per-district subscriber counts across all districts\n", + "subscribers_per_district_per_day_results.groupby(\"date\").sum().plot(\n", + " ax=plt.gca(), y=\"value\", label=\"sum(subscribers per district)\"\n", + ")\n", + "\n", + "# Similar for OD matrix\n", + "od_matrix_district_per_day_results.groupby(\"date\").sum().plot(\n", + " ax=plt.gca(), y=\"value\", label=\"sum(OD matrix)\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The sum of OD matrix counts is smaller than the total subscriber count - this is not unexpected, because some subscribers will only be active in a single district so will not be included in the OD matrix.\n", + "\n", + "There is an effect from the mobility changes on 1st and 10th March, but again there is no obvious sign of data issues." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Spatial distribution of subscriber counts\n", + "\n", + "Another thing we can check is the spatial distribution of subscriber counts. WE eould expect subscriber counts in urban districts to be larger than those in rural districts. To check this, let's calculate the median subscriber count per district:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "median_subscribers_per_district = subscribers_per_district_per_day_results.groupby(\n", + " \"pcod\"\n", + ").median()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To plot the median subscriber counts on a map, we need to get the geographic boundaries of the districts. We can do this using the flowclient `get_geography` function, as described in the [\"Geography\" tutorial](03-geography.ipynb):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "districts_geojson = fc.get_geography(connection=conn, aggregation_unit=\"admin2\")\n", + "districts_gdf = gpd.GeoDataFrame.from_features(districts_geojson)\n", + "districts_gdf" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now join the district boundaries to the median subscriber counts, and display them on a map:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "median_subscribers_per_district_with_geo = districts_gdf.merge(\n", + " median_subscribers_per_district, left_on=\"pcod\", right_index=True\n", + ")\n", + "\n", + "median_subscribers_per_district_with_geo.plot(column=\"value\", legend=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that the subscriber count in Accra is much larger than in other districts, as we would expect.\n", + "\n", + "It is difficult to compare the subscriber counts in other districts on this colour scale. It would be clearer to us a log scale - we can do this using `matplotlib.colors.LogNorm`. First, we import the `matplotlib.colors` library:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.colors" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can plot the median subscriber counts in the same way as we did before, but additionally specifying the `norm` parameter. We use `matplotlib.colors.LogNorm()`, which takes two arguments `vmin` and `vmax` (the minimum and maximum values in the colour range):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "median_subscribers_per_district_with_geo.plot(\n", + " column=\"value\",\n", + " legend=True,\n", + " norm=matplotlib.colors.LogNorm(\n", + " vmin=median_subscribers_per_district_with_geo.value.min(),\n", + " vmax=median_subscribers_per_district_with_geo.value.max(),\n", + " ),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that the cities of Accra, Kumasi, Tamale and Sekondi-Takoradi all have higher subscriber counts than their surrounding districts, which aligns with what we would expect. Subscriber counts in the Ashanti region are smaller - this is in line with the time-series plot we made earlier of subscriber counts per region." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Events per subscriber\n", + "\n", + "We can also check the average number of events per subscriber per day. We should always have at least 1 event per subscriber (becuase a subscriber with no events would not be present in the dataset), but this value should not be too large - it would be hard to believe that subscribers make 100 calls per day on average, for example. A \"reasonable\" value here will depend on which CDR data types are included - there would typically be more mobile data sessions than phone calls per subscriber per day.\n", + "\n", + "The number of events per subscriber should be fairly stable over time. If this is not the case, it could indicate that there have been substantial changes in calling behaviour, which could make our results unreliable.\n", + "\n", + "We can calculate the average events per subscriber for the whole country by dividing the total event count per day (from `total_events_per_day_results`) by the total subscriber count per day (from `total_subscribers_per_day_results`):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "average_events_per_subscriber = (\n", + " total_events_per_day_results.set_index(\"date\").value\n", + " / total_subscribers_per_day_results.set_index(\"date\").value\n", + ")\n", + "\n", + "average_events_per_subscriber.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that the average number of events per subscriber is around 2.3, which is reasonable, and there are no large changes over time.\n", + "\n", + "Similarly, we can calculate the average number of events per subscriber in each district by dividing event counts in `events_per_district_per_day_results` by subscriber counts in `subscribers_per_district_per_day_results`:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "events_per_subscriber_per_district = (\n", + " events_per_district_per_day_results.set_index([\"date\", \"pcod\"])\n", + " / subscribers_per_district_per_day_results.set_index([\"date\", \"pcod\"])\n", + ").reset_index()\n", + "\n", + "events_per_subscriber_per_district.pivot(\n", + " index=\"date\", columns=\"pcod\", values=\"value\"\n", + ").plot(legend=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The changes on 1st and 10th March correspond to a large decrease in the number of events per subscriber in some districts. This could be because the residents of these districts have moved away, so the subscribers we see just made brief visits to the district, or could be because subscribers in these districts are making fewer calls than usual. In either case, we should be cautious when interpreting a change in subscriber count as a corresponding change in population size, as some of the apparent change may be due to different phone usage." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Missing data\n", + "\n", + "It is possible that some of the CDR data ingested into FlowKit's database may be incomplete - there may be missing data on certain days, or for certain geographic areas. To check for missing data we can plot the total event count per day:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "total_events_per_day_results.plot(x=\"date\", y=\"value\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this case, we can see that the event count is quite stable over time, and there are no days with a much smaller event count than usual.\n", + "\n", + "If we noticed that the event count on one day was significantly smaller than usual, we could look at the district-level subscriber counts to see whether there are areas with missing data. For example, to plot the event counts per district on 21st February (using a log colour scale, as we did previously):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "events_per_district_20160221 = events_per_district_per_day_results[\n", + " events_per_district_per_day_results.date == \"2016-02-21\"\n", + "]\n", + "\n", + "districts_gdf.merge(events_per_district_20160221, on=\"pcod\",).plot(\n", + " column=\"value\",\n", + " legend=True,\n", + " norm=matplotlib.colors.LogNorm(\n", + " vmin=events_per_district_20160221.value.min(),\n", + " vmax=events_per_district_20160221.value.max(),\n", + " ),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If there were parts of the country with significantly lower event counts than the rest, this could indicate missing data.\n", + "\n", + "If the aggregates are re-calculated regularly from new available dates of CDR data, these QA checks should be updated each time to check for issues in the new data." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Mobility indicators\n", + "\n", + "The aggregates we have calculated do not reveal any personal information about subscribers. However, the raw aggregates are not appropriate to share with a wider audience, for two reasons:\n", + "\n", + "1. The aggregates may reveal commercially sensitive information (for example, the size or geographic distribution of an MNO's subscriber base),\n", + "2. The aggregates could be misleading (for example, a subscriber count of 10000 could be wrongly interpreted as a population count of 10000 people, whereas the true relationship between subscriber count and population count would depend on the MNO's market share, subscribers' calling behaviour, and other factors).\n", + "\n", + "In this section we will use the aggregates to calculate some \"mobility indicators\", which are scaled so that they do not reveal the absolute size or distribution of subscriber counts, while aiming to represent relevant mobility information.\n", + "\n", + "We will calculate three mobility indicators:\n", + "\n", + "1. Percentage change in subscriber presence per district\n", + "2. Average number of districts visited per subscriber within each region\n", + "3. Percentage change in subscriber movements between districts\n", + "\n", + "Details of other mobility indicators can be found on our [COVID-19 website](https://covid19.flowminder.org/).\n", + "\n", + "We need to choose a \"baseline period\" - this is a period before mobility restrictions began, which is assumed to display normal mobility. The baseline period should be at least 4 weeks long, so that baseline averages are not overly skewed by unusual events such as public holidays, and should be a whole number of weeks so that baseline averages are not skewed by including a larger number of Sundays than weekdays (for example). The first mobility restrictions in our example started on 1 March 2016, so we will choose the 4 weeks immediately before this as our baseline period:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "baseline_start = \"2016-02-02\"\n", + "baseline_end = \"2016-03-01\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It is also useful, if possible, to identify a stable period during the period of mobility restrictions. In our example, the most recent change in mobility restrictions occurred on 10 March 2016, so we will take all dates from 10 March onwards as our stable period:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "stable_period_start = \"2016-03-10\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 1. Percentage change in subscriber presence per district\n", + "\n", + "This indicator is the percentage change in the number of subscribers in a district, relative to the median number of subscribers during the baseline period.\n", + "\n", + "The subscriber counts we have calculated could be affected by calling behaviour - if fewer subscribers make calls on a particular day, the subscriber count will be lower although those subscribers may still be present in a district, without making a call. To correct for this effect, we can divide the subscriber counts per district by the total subcriber count for the country each day. Assuming that the total number of people in the country doesn't significantly change during the period we're investigating, this will mitigate the effects of changes in calling behaviour.\n", + "\n", + "To calculate the \"scaled subscriber count\" per district (i.e. the subscriber count per district divided by the total subscriber count for the country), we first need to merge the district-level subscriber counts with the total subscriber counts, joining on the 'date' column:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "merged_subscriber_counts = subscribers_per_district_per_day_results.merge(\n", + " total_subscribers_per_day_results.rename(columns={\"value\": \"total_subscribers\"}),\n", + " on=\"date\",\n", + ")\n", + "\n", + "merged_subscriber_counts" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now add a new `\"scaled_subscriber_count\"` column to this DataFrame, calculated as the district-level subscriber count divided by the total subscriber count:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ "merged_subscriber_counts[\"scaled_subscriber_count\"] = (\n", " merged_subscriber_counts.value / merged_subscriber_counts.total_subscribers\n", ")\n", "\n", - "merged_subscriber_counts" + "merged_subscriber_counts" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We want to calculate the percentage change in the scaled subscriber count relative to the baseline period, so we need to define a single \"baseline\" scaled subscriber count for each district. We define this as the median of the daily scaled subscriber counts over all days in the baseline period. To calculate this, we filter the `merged_subscriber_counts` DataFrame to include only dates within the baseline period, then group by district (identified by the \"pcod\" column) and find the median of the \"scaled_subscriber_count\" column:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "scaled_subscriber_count_baseline = (\n", + " merged_subscriber_counts[\n", + " (merged_subscriber_counts.date >= baseline_start)\n", + " & (merged_subscriber_counts.date < baseline_end)\n", + " ]\n", + " .groupby(\"pcod\")\n", + " .median()\n", + " .scaled_subscriber_count\n", + ")\n", + "\n", + "scaled_subscriber_count_baseline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can merge these baseline values into the `merged_subscriber_counts` DataFrame as a new \"scaled_subscriber_count_baseline\" column, joining on the \"pcod\" column:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "merged_subscriber_counts = merged_subscriber_counts.merge(\n", + " scaled_subscriber_count_baseline,\n", + " left_on=\"pcod\",\n", + " right_index=True,\n", + " suffixes=(\"\", \"_baseline\"),\n", + ")\n", + "\n", + "merged_subscriber_counts" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now calculate the percentage change as\n", + "$$\n", + "100 \\times \\left(\\frac{\\mathrm{scaled\\ subscriber\\ count}}{\\mathrm{scaled\\ subscriber\\ count\\ baseline}} - 1\\right)\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "merged_subscriber_counts[\"percent_change\"] = (\n", + " merged_subscriber_counts.scaled_subscriber_count\n", + " / merged_subscriber_counts.scaled_subscriber_count_baseline\n", + " - 1\n", + ") * 100\n", + "\n", + "merged_subscriber_counts" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's choose a few key districts, and plot the percentage change in subscriber presence over time:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "display_districts = {\n", + " \"Accra\": \"GHA.5.1_1\",\n", + " \"Kumasi\": \"GHA.1.16_1\",\n", + " \"Tamale\": \"GHA.6.13_1\",\n", + "}\n", + "\n", + "plt.figure()\n", + "for name, pcod in display_districts.items():\n", + " merged_subscriber_counts[merged_subscriber_counts.pcod == pcod].plot(\n", + " ax=plt.gca(), x=\"date\", y=\"percent_change\", marker=\".\", ls=\"\", label=name\n", + " )\n", + "plt.axhline(0, ls=\":\", c=\"k\")\n", + "plt.ylim(bottom=-100)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that the subscriber presence in Kumasi decreased by more than 80% from early March, compared to the baseline period. In fact, there are no data for 1-10 March, suggesting that there were no active subscribers at all in Kumasi during this time. Meanwhile, the subscriber presence in Accra and Tamale increased by 20%. It appears that almost everybody in Kumasi has moved away to other districts.\n", + "\n", + "We can also look at the percentage changes in all districts, on a map. Since the percentage change will be different each day, let's find the median percentage change per district over the \"stable period\" from 10 March onwards:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "median_subscriber_count_percent_change = (\n", + " merged_subscriber_counts[merged_subscriber_counts.date >= stable_period_start]\n", + " .groupby(\"pcod\")\n", + " .median()\n", + " .percent_change\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now join the district boundaries to the median percentage changes and show these on a map (we'll use the \"Spectral\" colour map with a colour scale from -100% to 100%):" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "districts_gdf.merge(\n", + " median_subscriber_count_percent_change, left_on=\"pcod\", right_index=True\n", + ").plot(\n", + " column=\"percent_change\",\n", + " legend=True,\n", + " cmap=\"Spectral\",\n", + " norm=plt.Normalize(vmin=-100, vmax=100),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that subscriber presence in the Ashanti region decreased by 80% following mobility restrictions, and subscriber presence across the rest of the country increased by around 20%." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 2. Average number of districts visited per subscriber within each region\n", + "\n", + "We can also look at the average number of districts visited per subscriber within each region. This is an indicator of the amount of movement in each region - if people move around less, they will be seen in fewer districts.\n", + "\n", + "The average number of districts per subscriber within each region is the sum of subscriber counts for all districts within a region, divided by the overall subscriber count for that region.\n", + "\n", + "We will start by mapping each district to a region. We can do this by looking at the P-codes - district \"GHA.X.Y_1\" is within region \"GHA.X_1\", so we can find the region P-code from the district P-code by taking everything before the final `\".\"`, and appending `\"_1\"`. Let's add this as a new \"region_pcod\" column in the `subscribers_per_district_per_day` DataFrame:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "subscribers_per_district_per_day_results[\n", + " \"region_pcod\"\n", + "] = subscribers_per_district_per_day_results.pcod.apply(\n", + " lambda x: x.rsplit(\".\", 1)[0] + \"_1\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can now group by date and region, and sum the subscriber counts:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "districts_per_region_stats = (\n", + " subscribers_per_district_per_day_results.groupby([\"date\", \"region_pcod\"])\n", + " .sum()\n", + " .reset_index()\n", + ")\n", + "\n", + "# Rename column to be more explicit\n", + "districts_per_region_stats = districts_per_region_stats.rename(\n", + " columns={\"value\": \"sum_district_subscriber_counts\"}\n", + ")\n", + "\n", + "districts_per_region_stats" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can merge the summed district-level subscriber counts with the region-level subscriber counts:" ] }, { "cell_type": "code", - "execution_count": 182, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "pcod\n", - "GHA.1.10_1 0.004650\n", - "GHA.1.11_1 0.009366\n", - "GHA.1.12_1 0.005379\n", - "GHA.1.13_1 0.011214\n", - "GHA.1.14_1 0.006864\n", - " ... \n", - "GHA.9.5_1 0.005901\n", - "GHA.9.6_1 0.002443\n", - "GHA.9.7_1 0.006250\n", - "GHA.9.8_1 0.009675\n", - "GHA.9.9_1 0.004555\n", - "Name: scaled_subscriber_count, Length: 137, dtype: float64" - ] - }, - "execution_count": 182, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Baseline median\n", - "baseline_start = \"2016-02-01\"\n", - "baseline_end = \"2016-02-29\"\n", - "\n", - "scaled_subscriber_count_baseline = merged_subscriber_counts[\n", - " (merged_subscriber_counts.date >= baseline_start)\n", - " & (merged_subscriber_counts.date < baseline_end)\n", - "].groupby(\"pcod\").median().scaled_subscriber_count\n", - "scaled_subscriber_count_baseline" + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Merge with region counts\n", + "districts_per_region_stats = districts_per_region_stats.merge(\n", + " subscribers_per_region_per_day_results,\n", + " left_on=[\"date\", \"region_pcod\"],\n", + " right_on=[\"date\", \"pcod\"],\n", + ")\n", + "\n", + "# Rename value column\n", + "districts_per_region_stats = districts_per_region_stats.rename(\n", + " columns={\"value\": \"region_subscriber_count\"}\n", + ")\n", + "\n", + "districts_per_region_stats" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can calculate the average number of districts visited per subscriber per day within each region, by dividing the summed district-level subscrber counts by the region-level subscriber count:" ] }, { "cell_type": "code", - "execution_count": 183, - "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", - "
pcodvaluedatetotal_subscribersscaled_subscriber_countscaled_subscriber_count_baseline
0GHA.10.10_1649822016-02-0321382070.0303910.030399
137GHA.10.10_1651102016-02-0421366910.0304720.030399
274GHA.10.10_1649112016-02-0721371920.0303720.030399
411GHA.10.10_1649482016-02-1021368680.0303940.030399
548GHA.10.10_1651592016-02-1121370270.0304900.030399
.....................
5036GHA.9.9_1118122016-04-0721373040.0055270.004555
5173GHA.9.9_1117962016-04-0821377080.0055180.004555
5310GHA.9.9_1117702016-04-0921370870.0055070.004555
5447GHA.9.9_1118642016-04-1021359130.0055550.004555
5584GHA.9.9_1118492016-04-1121370140.0055450.004555
\n", - "

5585 rows × 6 columns

\n", - "
" - ], - "text/plain": [ - " pcod value date total_subscribers \\\n", - "0 GHA.10.10_1 64982 2016-02-03 2138207 \n", - "137 GHA.10.10_1 65110 2016-02-04 2136691 \n", - "274 GHA.10.10_1 64911 2016-02-07 2137192 \n", - "411 GHA.10.10_1 64948 2016-02-10 2136868 \n", - "548 GHA.10.10_1 65159 2016-02-11 2137027 \n", - "... ... ... ... ... \n", - "5036 GHA.9.9_1 11812 2016-04-07 2137304 \n", - "5173 GHA.9.9_1 11796 2016-04-08 2137708 \n", - "5310 GHA.9.9_1 11770 2016-04-09 2137087 \n", - "5447 GHA.9.9_1 11864 2016-04-10 2135913 \n", - "5584 GHA.9.9_1 11849 2016-04-11 2137014 \n", - "\n", - " scaled_subscriber_count scaled_subscriber_count_baseline \n", - "0 0.030391 0.030399 \n", - "137 0.030472 0.030399 \n", - "274 0.030372 0.030399 \n", - "411 0.030394 0.030399 \n", - "548 0.030490 0.030399 \n", - "... ... ... \n", - "5036 0.005527 0.004555 \n", - "5173 0.005518 0.004555 \n", - "5310 0.005507 0.004555 \n", - "5447 0.005555 0.004555 \n", - "5584 0.005545 0.004555 \n", - "\n", - "[5585 rows x 6 columns]" - ] - }, - "execution_count": 183, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "merged_subscriber_counts = merged_subscriber_counts.merge(\n", - " scaled_subscriber_count_baseline,\n", - " left_on=\"pcod\",\n", + "districts_per_region_stats[\"average_districts_per_subscriber\"] = (\n", + " districts_per_region_stats.sum_district_subscriber_counts\n", + " / districts_per_region_stats.region_subscriber_count\n", + ")\n", + "\n", + "districts_per_region_stats" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's plot the average districts per subscriber over time for all regions:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "districts_per_region_stats.pivot(\n", + " index=\"date\", columns=\"region_pcod\", values=\"average_districts_per_subscriber\"\n", + ").plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that in all cases the average districts per subscriber is very close to 1, so levels of movement were already quite low before the mobility restrictions. After the mobility restrictions, the value in GHA.1_1 (Ashanti) drops lower (so the subscribers remaining in Ashanti are not moving around the region as much) while the values for all other regions show only a small increase." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 3. Percentage change in subscriber movements between districts\n", + "\n", + "Finally, we can look at the changes in subscriber movements between districts. To do this, we will use the \"district-level OD matrix per day\" aggregate, which counts the number of subscribers seen in both of each pair of regions per day. We will calculate the percentage change in subscriber movements, using a process very similar to the one we used for the \"percentage change in subscriber presence per day\" indicator:\n", + "\n", + "1. Scale the OD matrix subscriber count for each pair of districts by the total subscriber count for that day, to correct for the effects of changes in calling behaviour.\n", + "2. Calculate the median \"scaled subscriber count\" for each pair of districts over the baseline period,\n", + "3. For each pair of districts each day, calculate the percentage change in scaled subscriber count relative to the baseline.\n", + "\n", + "We start by merging the OD matrix DataFrame with the \"total subscribers per day\" DataFrame:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "od_merged_subscriber_counts = od_matrix_district_per_day_results.merge(\n", + " total_subscribers_per_day_results.rename(columns={\"value\": \"total_subscribers\"}),\n", + " on=\"date\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we divide the subscriber count for each pair of districts by the total subscriber count for that day, to get the \"scaled subscriber count\":" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "od_merged_subscriber_counts[\"scaled_subscriber_count\"] = (\n", + " od_merged_subscriber_counts.value / od_merged_subscriber_counts.total_subscribers\n", + ")\n", + "\n", + "od_merged_subscriber_counts" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now calculate the median \"scaled subscriber count\" for each pair of district over the baseline period:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "od_scaled_subscriber_count_baseline = (\n", + " od_merged_subscriber_counts[\n", + " (od_merged_subscriber_counts.date >= baseline_start)\n", + " & (od_merged_subscriber_counts.date < baseline_end)\n", + " ]\n", + " .groupby([\"pcod_from\", \"pcod_to\"])\n", + " .median()\n", + " .scaled_subscriber_count\n", + ")\n", + "od_scaled_subscriber_count_baseline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now merge the baseline values back into the `od_merged_subscriber_counts` DataFrame, joining on the \"pcod_from\" and \"pcod_to\" columns:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "od_merged_subscriber_counts = od_merged_subscriber_counts.merge(\n", + " od_scaled_subscriber_count_baseline,\n", + " left_on=[\"pcod_from\", \"pcod_to\"],\n", " right_index=True,\n", - " suffixes=(\"\", \"_baseline\")\n", + " suffixes=(\"\", \"_baseline\"),\n", ")\n", "\n", - "merged_subscriber_counts" + "od_merged_subscriber_counts" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, calculate the percentage change from the baseline value, for each pair of districts each day:" ] }, { "cell_type": "code", - "execution_count": 184, - "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", - "
pcodvaluedatetotal_subscribersscaled_subscriber_countscaled_subscriber_count_baselinepercent_change
0GHA.10.10_1649822016-02-0321382070.0303910.030399-0.027144
137GHA.10.10_1651102016-02-0421366910.0304720.0303990.240851
274GHA.10.10_1649112016-02-0721371920.0303720.030399-0.088948
411GHA.10.10_1649482016-02-1021368680.0303940.030399-0.016840
548GHA.10.10_1651592016-02-1121370270.0304900.0303990.300517
........................
5036GHA.9.9_1118122016-04-0721373040.0055270.00455521.333545
5173GHA.9.9_1117962016-04-0821377080.0055180.00455521.146293
5310GHA.9.9_1117702016-04-0921370870.0055070.00455520.914395
5447GHA.9.9_1118642016-04-1021359130.0055550.00455521.947058
5584GHA.9.9_1118492016-04-1121370140.0055450.00455521.730128
\n", - "

5585 rows × 7 columns

\n", - "
" - ], - "text/plain": [ - " pcod value date total_subscribers \\\n", - "0 GHA.10.10_1 64982 2016-02-03 2138207 \n", - "137 GHA.10.10_1 65110 2016-02-04 2136691 \n", - "274 GHA.10.10_1 64911 2016-02-07 2137192 \n", - "411 GHA.10.10_1 64948 2016-02-10 2136868 \n", - "548 GHA.10.10_1 65159 2016-02-11 2137027 \n", - "... ... ... ... ... \n", - "5036 GHA.9.9_1 11812 2016-04-07 2137304 \n", - "5173 GHA.9.9_1 11796 2016-04-08 2137708 \n", - "5310 GHA.9.9_1 11770 2016-04-09 2137087 \n", - "5447 GHA.9.9_1 11864 2016-04-10 2135913 \n", - "5584 GHA.9.9_1 11849 2016-04-11 2137014 \n", - "\n", - " scaled_subscriber_count scaled_subscriber_count_baseline \\\n", - "0 0.030391 0.030399 \n", - "137 0.030472 0.030399 \n", - "274 0.030372 0.030399 \n", - "411 0.030394 0.030399 \n", - "548 0.030490 0.030399 \n", - "... ... ... \n", - "5036 0.005527 0.004555 \n", - "5173 0.005518 0.004555 \n", - "5310 0.005507 0.004555 \n", - "5447 0.005555 0.004555 \n", - "5584 0.005545 0.004555 \n", - "\n", - " percent_change \n", - "0 -0.027144 \n", - "137 0.240851 \n", - "274 -0.088948 \n", - "411 -0.016840 \n", - "548 0.300517 \n", - "... ... \n", - "5036 21.333545 \n", - "5173 21.146293 \n", - "5310 20.914395 \n", - "5447 21.947058 \n", - "5584 21.730128 \n", - "\n", - "[5585 rows x 7 columns]" - ] - }, - "execution_count": 184, - "metadata": {}, - "output_type": "execute_result" - } - ], + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ - "merged_subscriber_counts[\"percent_change\"] = (\n", - " merged_subscriber_counts.scaled_subscriber_count / merged_subscriber_counts.scaled_subscriber_count_baseline - 1\n", + "od_merged_subscriber_counts[\"percent_change\"] = (\n", + " od_merged_subscriber_counts.scaled_subscriber_count\n", + " / od_merged_subscriber_counts.scaled_subscriber_count_baseline\n", + " - 1\n", ") * 100\n", - "merged_subscriber_counts" + "od_merged_subscriber_counts" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To show the percentage changes on a map, let's calculate the median percent changes over the \"stable period\":" ] }, { "cell_type": "code", - "execution_count": 190, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(-100.0, 31.561113800097285)" - ] - }, - "execution_count": 190, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Choose a few districts to show\n", - "display_districts = {\n", - " \"Accra\": \"GHA.5.1_1\",\n", - " \"Kumasi\": \"GHA.1.16_1\",\n", - " \"Tamale\": \"GHA.6.13_1\",\n", - "}\n", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "median_od_subscriber_count_percent_change = (\n", + " od_merged_subscriber_counts[od_merged_subscriber_counts.date >= stable_period_start]\n", + " .groupby([\"pcod_from\", \"pcod_to\"])\n", + " .median()\n", + " .percent_change.reset_index()\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We could choose a district, and show the median percentage changes in movements from that district to all other districts. For this, we need to join the percentage changes data to the district boundaries, using the \"pcod_to\" column.\n", "\n", - "# Plot % change over time for the chosen districts\n", - "plt.figure()\n", - "for name, pcod in display_districts.items():\n", - " merged_subscriber_counts[merged_subscriber_counts.pcod == pcod].plot(\n", - " ax=plt.gca(), x=\"date\", y=\"percent_change\", marker=\".\", ls=\"\", label=name\n", - " )\n", - "plt.axhline(0, ls=\":\", c='k')\n", - "plt.ylim(bottom=-100)" + "**Note:** If we wanted to show movements in the other direction (i.e. movements from all districts to a chosen district), we would join to the district boundaries using the \"pcod_from\" column." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Join to geo (on the \"to\" location)\n", + "median_od_percent_change_with_geo = districts_gdf.merge(\n", + " median_od_subscriber_count_percent_change, left_on=\"pcod\", right_on=\"pcod_to\",\n", + ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Average admin2 per subscriber in each admin1\n", + "Let's plot the percent change in movements from each of Accra, Kumasi and Tamale:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "display_districts = {\n", + " \"Accra\": \"GHA.5.1_1\",\n", + " \"Kumasi\": \"GHA.1.16_1\",\n", + " \"Tamale\": \"GHA.6.13_1\",\n", + "}\n", "\n", - "- Add admin1 pcode column to admin2 counts\n", - "- Sum admin2 counts per admin1\n", - "- Join to admin1 counts\n", - "- Divide\n", - "- Plot over time for all admin1 regions" + "for name, pcod in display_districts.items():\n", + " median_od_percent_change_with_geo[\n", + " median_od_percent_change_with_geo.pcod_from == pcod\n", + " ].plot(\n", + " column=\"percent_change\",\n", + " legend=True,\n", + " cmap=\"Spectral\",\n", + " norm=plt.Normalize(vmin=-100, vmax=100),\n", + " legend_kwds={\"label\": name},\n", + " )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Scaled OD matrix counts\n", - "- Same process as for scaled admin2 counts\n", - "- Show a map of before vs after for either Accra or Kumasi (not sure which will look better)" + "From Accra and Tamale, movements to the Ashanti region have decreased, while movements to other districts have increased slightly. For Kumasi, movements to all other districts have decreased, especially to the rest of Ashanti (reflecting the smaller number of subscribers remaining in the region)." ] }, { @@ -2238,9 +1613,13 @@ "source": [ "### Summary\n", "\n", - "- What we did\n", - "- What it showed\n", - "- Maybe some advice on how this could be modified to do other things" + "In this example, we used FlowKit to extract aggregates from CDR data, and used this to produce mobility indicators. Before producing the indicators, we performed some QA checks on the aggregates to check that there were no issues with the underlying CDR data that could affect the validity of our mobility insights.\n", + "\n", + "We discovered that there was a large decrease in subscriber presence in the Ashanti region from 1 March 2016, followed by a small recovery on 10 March 2016, and a corresponding increase in subscriber presence in the rest of the country (so it appears that there was a large displacement of people from the Ashanti region to the rest of the country).\n", + "\n", + "**Note:** This example is built on a synthetic dataset, which is not intended to represent the effects of real-life mobility restrictions.\n", + "\n", + "In the real-world scenario of an ongoing disease epidemic, the effects of mobility restrictions could be monitored in near-real-time by updating these indicators every few days, provided regular updates of CDR data are being added to the FlowKit server. For more infirmation on the use of CDR data to monitor mobility during a disease epidemic, visit Flowminder's [COVID-19 website](https://covid19.flowminder.org/)." ] } ], From 72baa507882e808b44397e7fe790b0b089bacf24 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Sat, 1 Aug 2020 20:23:14 +0100 Subject: [PATCH 3/3] Refer to example from index --- index.ipynb | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/index.ipynb b/index.ipynb index 285346f..5ca74c8 100644 --- a/index.ipynb +++ b/index.ipynb @@ -51,7 +51,9 @@ "1. [Getting started with FlowClient](01-getting-started-with-flowclient.ipynb) - this tutorial will teach you how to connect to a Flowkit server, \n", " 1a. [Getting an access token](01a-getting-an-access-token.ipynb) - instructions for getting an access token from FlowAuth, which you will use in tutorial 1, \n", "2. [Running a query](02-running-a-query.ipynb) - this tutorial will teach you how to use FlowClient to get aggregated data from FlowKit, \n", - "3. [Geography](03-geography.ipynb) - this tutorial will teach you how to join query results to geographic boundaries. " + "3. [Geography](03-geography.ipynb) - this tutorial will teach you how to join query results to geographic boundaries. \n", + "\n", + "Once you have worked through these, you could take a look at the [\"Mobility indicators\" worked example](mobility-indicators.ipynb) for a demonstration of some analysis using FlowKit aggregates." ] } ],