diff --git a/.github/ISSUE_TEMPLATE/python-api-v1-0-0-feedback.md b/.github/ISSUE_TEMPLATE/python-api-v1-0-0-feedback.md deleted file mode 100644 index 35c70deb..00000000 --- a/.github/ISSUE_TEMPLATE/python-api-v1-0-0-feedback.md +++ /dev/null @@ -1,10 +0,0 @@ ---- -name: Python API v1.0.0 Feedback -about: Feedback for the new Python API -title: "[API v1.0.0 Feedback] description of feedback" -labels: python api feedback -assignees: ACscooter - ---- - - diff --git a/.gitignore b/.gitignore index e3dfb396..39dca0bf 100644 --- a/.gitignore +++ b/.gitignore @@ -124,4 +124,14 @@ datacommons.RCheck *tar.gz ## VSCode -.vscode/ \ No newline at end of file +.vscode/ + +## JetBrains +.idea/ + +# Gemini +GEMINI.md +.gemini/ + +# Temp files +tmp/ \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md index 396e9ddc..f4890aee 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,113 @@ # Changelog +## 2.1.6 + +**Date** - 01/28/2026 + +**Release Tag** - [v2.1.6](https://github.com/datacommonsorg/api-python/releases/tag/v2.1.6) + +**Release Status** - Current head of branch [`master`](https://github.com/datacommonsorg/api-python/tree/master) + +This is a patch update that adds support for resolving indicators (StatisticalVariables and Topics) from natural language queries via the `resolve` endpoint. It introduces a new `fetch_indicators` method and updates the `Candidate` model to include match scores and types. + +## 2.1.5 + +**Date** - 01/12/2026 + +**Release Tag** - [v2.1.5](https://github.com/datacommonsorg/api-python/releases/tag/v2.1.5) + +**Release Status** - Current head of branch [`master`](https://github.com/datacommonsorg/api-python/tree/master) + +This is a patch update that adds support for per-request API key overrides using a context manager. + +## 2.1.4 + +**Date** - 10/31/2025 + +**Release Tag** - [v2.1.4](https://github.com/datacommonsorg/api-python/releases/tag/v2.1.4) + +**Release Status** - Current head of branch [`master`](https://github.com/datacommonsorg/api-python/tree/master) + +This is a patch update that allows the client to use an API key, if specified, for instance validation when a URL is provided during initialization. This is useful for validating against non-production environments or custom Data Commons instances that require authentication. + +## 2.1.3 + +**Date** - 10/21/2025 + +**Release Tag** - [py2.1.3](https://github.com/datacommonsorg/api-python/releases/tag/py2.1.3) + +**Release Status** - Current head of branch [`master`](https://github.com/datacommonsorg/api-python/tree/master) + +This is a minor fix that removes text validation on the `surface_header_value` parameter so that additional Data Commons surfaces can be added without re-releasing the package. This is only used by Data Commons to track usage across its platforms, and does not change the behavior of the client. + +## 2.1.2 + +**Date** - 10/16/2025 + +**Release Tag** - [py2.1.2](https://github.com/datacommonsorg/api-python/releases/tag/py2.1.2) + +**Release Status** - Current head of branch [`master`](https://github.com/datacommonsorg/api-python/tree/master) + +This update adds an optional `surface_header_value` parameter to the Data Commons Client that is used internally by Data Commons +to track usage across its platforms. Other Data Commons services make calls to the Python client and pass in this parameter, but it +is not intended for public use and does not affect the behavior of the client. + +## 2.1.1 + +**Date** - 06/10/2025 + +**Release Tag** - [py2.1.1](https://github.com/datacommonsorg/api-python/releases/tag/py2.1.1) + +**Release Status** - Current head of branch [`master`](https://github.com/datacommonsorg/api-python/tree/master) + +This is an under-the-hood update to use `pydantic` for data models. + +## 2.1.0 + +**Date** - 05/08/2025 + +**Release Tag** - [py2.1.0](https://github.com/datacommonsorg/api-python/releases/tag/py2.1.0) + +**Release Status** - Current head of branch [`master`](https://github.com/datacommonsorg/api-python/tree/master) + +Bugs fixed: + +- Remove auto-flattening for unpack_arcs +- Fix unpack_arcs when multiple arcs are in the node response + +Other improvements: + +- Clarify parent_entity requirements for observations_dataframe +- Updated some tutorials and notebooks to use the v2 client +- Fix install command and refine documentation +- Handle empty/malformed REST API node responses +- Make renamed methods backwards compatible + +New features: + +- Add helpers to extract data from NodeResponse arcs +- Add convenient ways to fetch parents and children of given entities + +## 2.0.0 + +**Date** - 04/08/2025 + +**Release Tag** - [py2.0.0](https://github.com/datacommonsorg/api-python/releases/tag/py2.0.0) + +**Release Status** - Current head of branch [`master`](https://github.com/datacommonsorg/api-python/tree/master) + +Initial v2 of the Data Commons API Python client library. + +## 1.4.4 + +**Date** - 01/12/2026 + +**Release Tag** - [py1.4.4](https://github.com/datacommonsorg/api-python/releases/tag/py1.4.4) + +**Release Status** - Current head of branch [`master`](https://github.com/datacommonsorg/api-python/tree/master) + +Added deprecation notice to legacy `datacommons` package. + ## 1.4.3 **Date** - 11/10/2020 @@ -22,7 +130,7 @@ Bugs fixed in new release New features added to the Python API -- Added batching to `get_stat_all` to handle querying for many StatisticalVariables across many Places. +- Added batching to `get_stat_all` to handle querying for many StatisticalVariables across many Places. ## 1.4.1 @@ -34,9 +142,9 @@ New features added to the Python API New features added to the Python API -- `get_stat_value`: returns a single value for the specified Place and StatisticalVariable. -- `get_stat_series`: returns a single time series dict for the specified Place and StatisticalVariable. -- `get_stat_all`: returns a nested dictionary of all possible time series for each Place and StatisticalVariable pair. +- `get_stat_value`: returns a single value for the specified Place and StatisticalVariable. +- `get_stat_series`: returns a single time series dict for the specified Place and StatisticalVariable. +- `get_stat_all`: returns a nested dictionary of all possible time series for each Place and StatisticalVariable pair. ## 1.3.0 @@ -48,12 +156,12 @@ New features added to the Python API New features added to the Python API -- Option to use the API without providing API key. -- New options to `get_stats`: `measurement_method`, `unit`, and `obs_period` for finer-grain control over returned statistics. +- Option to use the API without providing API key. +- New options to `get_stats`: `measurement_method`, `unit`, and `obs_period` for finer-grain control over returned statistics. Bugs fixed in new release -- Elegantly handle sparse responses from `query`. +- Elegantly handle sparse responses from `query`. ## 1.2.0 @@ -65,12 +173,11 @@ Bugs fixed in new release New features added to the Python API -- Add get_stats API to get observations given a StatisticalVariable and place dcids. +- Add get_stats API to get observations given a StatisticalVariable and place dcids. Bugs fixed in new release -- Check Null and empty data in REST API response field to avoid KeyError. - +- Check Null and empty data in REST API response field to avoid KeyError. ## 1.1.0 @@ -82,11 +189,11 @@ Bugs fixed in new release New features added to the Python API -- Handle and ignore NaN in API argument. +- Handle and ignore NaN in API argument. Bugs fixed in new release -- Various small fix. +- Various small fix. ## 1.0.9 @@ -98,7 +205,7 @@ Bugs fixed in new release New features added to the Python API -- Use six package for urllib. +- Use six package for urllib. ## 1.0.7 @@ -110,7 +217,7 @@ New features added to the Python API New features added to the Python API -- Support python 2.7. +- Support python 2.7. ## 1.0.6 @@ -122,9 +229,7 @@ New features added to the Python API New features added to the Python API -- Add a new API for getting related places. - - +- Add a new API for getting related places. ## 1.0.5 @@ -136,9 +241,8 @@ New features added to the Python API New features added to the Python API -- Remove the dependency on Pandas and Numpy in package dependency. -- Replace requests with urllib. - +- Remove the dependency on Pandas and Numpy in package dependency. +- Replace requests with urllib. ## 1.0.2 @@ -150,8 +254,7 @@ New features added to the Python API New features added to the Python API -- Remove the dependency on Pandas. - +- Remove the dependency on Pandas. ## 1.0.1 @@ -163,14 +266,14 @@ New features added to the Python API New features added to the Python API -- Added two new functions `get_pop_obs` and `get_place_obs` -- SPARQL query is now supported as a function `query` instead of a class. -- Added documentation on how to provision an API key and provide it to the API +- Added two new functions `get_pop_obs` and `get_place_obs` +- SPARQL query is now supported as a function `query` instead of a class. +- Added documentation on how to provision an API key and provide it to the API Bugs fixed in new release -- Fixed various typos and formatting issues in the documentation. -- If the index of the `pandas.Series` passed into functions such as `get_populations` and `get_observations` was not contiguous, then the assignment step would not properly align the values returned by calling the function. This is because the `pandas.Series` returned by the function would have a different index than the given series. This is fixed by assigning the index of the returned series to that of the given series. +- Fixed various typos and formatting issues in the documentation. +- If the index of the `pandas.Series` passed into functions such as `get_populations` and `get_observations` was not contiguous, then the assignment step would not properly align the values returned by calling the function. This is because the `pandas.Series` returned by the function would have a different index than the given series. This is fixed by assigning the index of the returned series to that of the given series. ## 1.0.0 @@ -180,15 +283,15 @@ Bugs fixed in new release New release of the Python API. -- New functions in the API built on top of the [Data Commons REST API](https://github.com/datacommonsorg/mixer). - - `get_property_labels` - - `get_property_values` - - `get_triples` - - `get_populations` - - `get_observations` - - `get_places_in` -- New tests and examples checked into `datacommons/test` and `datacommons/examples` -- Full documentation released on [readthedocs](https://datacommons.readthedocs.io/en/latest/) +- New functions in the API built on top of the [Data Commons REST API](https://github.com/datacommonsorg/mixer). + - `get_property_labels` + - `get_property_values` + - `get_triples` + - `get_populations` + - `get_observations` + - `get_places_in` +- New tests and examples checked into `datacommons/test` and `datacommons/examples` +- Full documentation released on [readthedocs](https://datacommons.readthedocs.io/en/latest/) ## 0.4.3 @@ -200,7 +303,7 @@ New release of the Python API. Patch release that fixes bugs in `datacommons.Client`. -- Functions `get_cities` and `get_states` now provides `typeOf` constraints in their datalog queries. +- Functions `get_cities` and `get_states` now provides `typeOf` constraints in their datalog queries. ## 0.x diff --git a/Missing_Data_Imputation_Tutorial.ipynb b/Missing_Data_Imputation_Tutorial.ipynb deleted file mode 100644 index a0fbdab9..00000000 --- a/Missing_Data_Imputation_Tutorial.ipynb +++ /dev/null @@ -1,639 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "name": "Missing Data Imputation Tutorial.ipynb", - "provenance": [], - "collapsed_sections": [], - "include_colab_link": true - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - } - }, - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "view-in-github", - "colab_type": "text" - }, - "source": [ - "\"Open" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "m-Jrb-eMOvMP", - "colab_type": "text" - }, - "source": [ - "# Time Series Holes: A Case Study Using Data Commons\n", - "\n", - "In this notebook, we will examine types of missing values in time series and methods of imputing those values. Missing values might happen during data collection, or may be intentionally introduced during processing. Data scientists often impute missing values before using time series for analysis and machine learning.\n", - "\n", - "First, we will survey random statistical variables from Data Commons and visualize their time series for a few counties. This will give us an understanding of the types of time series holes that exist.\n", - "\n", - "Then, we will impute missing values using Pandas imputation methods that the [scipy.interpolate](https://docs.scipy.org/doc/scipy/reference/tutorial/interpolate.html) package provides.\n", - "\n", - "\n", - "**To use this notebook, click on 'Runtime' and select 'Run all'**." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "b-Wt5rWaAtSQ", - "colab_type": "code", - "cellView": "form", - "colab": {} - }, - "source": [ - "#@title Technical details: sampling function\n", - "#\n", - "#\n", - "#@markdown This section contains the functions that we use to retrieve data from Data Commons. We use \n", - "#@markdown [**`build_time_series_dataframe`**](https://docs.datacommons.org/api/pandas/time_series.html) \n", - "#@markdown to access the data for each sampled statistical variable. \n", - "#\n", - "#@markdown **To reveal the hidden code double click on this section.**\n", - "#\n", - "\n", - "\n", - "\"\"\"\n", - "The function input are the total sampled statistical variables and a boolean flag for \n", - "plot/not plot the sampled statistical variables. To avoid value errors for statistical variables \n", - "with no data for our selected state we use try/except. \n", - "\"\"\"\n", - "def select_random_statvars(sample_size, plot_flag, log_p):\n", - " prov = pd.DataFrame(dc.get_property_values([\"StatisticalVariable\"], \"typeOf\", out =False, limit =500))\n", - "\n", - " chosen_idx = np.random.choice(len(prov.index), replace=False, size=sample_size)\n", - " df_trimmed = prov.iloc[chosen_idx]\n", - " allstatvars = set(df_trimmed['StatisticalVariable'])\n", - " pltstats =[]\n", - "\n", - " # Comment the following line if you want to include all statistical variables:\n", - " allstatvars = [x for x in allstatvars if not (x.startswith(\"dc/\"))]\n", - "\n", - " geoids = (dc.get_places_in([_PLACE], \"County\"))[_PLACE]\n", - "\n", - " \"\"\"\n", - " For each statistical variable, a column represents a county (e.g. counties contained in California). \n", - " We select time series with at least four data points, at least four complete counties, and at least \n", - " four missing values. You can change the threshold by setting another value to *threshold*.\n", - " \"\"\"\n", - " for statvar in allstatvars:\n", - " try:\n", - " data = dc.build_time_series_dataframe(geoids, statvar)\n", - "\n", - " # Get all state names and store it in a column \"name\"\n", - " # Get the first name, if there are multiple for a state\n", - " data.insert(0, 'name', data.index.map(dc.get_property_values(data.index, 'name')).str[0])\n", - " data.set_index('name', inplace=True)\n", - " data = data.transpose()\n", - "\n", - " data.dropna(axis=0, how='all', inplace=True)\n", - "\n", - " notNaColumns = data.columns[data.notna().all()].tolist()\n", - " naColumns = data.columns[data.isnull().any()].tolist()\n", - " \n", - " threshold = 4\n", - " if (len(naColumns) > threshold and len(notNaColumns)> threshold and data.size> threshold):\n", - " if (plot_flag):\n", - " plt = data[naColumns].plot(style=['bo-', 'o-', 'ro-'], figsize=(22, 10));\n", - " plt.set_ylabel(statvar, fontsize=14)\n", - " plt.set_xlabel('Date', fontsize=14)\n", - " pltstats.append(statvar)\n", - " except ValueError as e:\n", - " if (log_p):\n", - " print(statvar, ': No data for', _PLACE)\n", - " \n", - " return pltstats" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "20oMQF58TCZO", - "colab_type": "code", - "cellView": "form", - "colab": {} - }, - "source": [ - "#@title Technical details: validation\n", - "#\n", - "#\n", - "#@markdown In this section, we explain the implementation details of the cross-validation function for technical readers. \n", - "#\n", - "#@markdown **To reveal the hidden code double click on this section.**\n", - "#\n", - "#\n", - "\n", - "\"\"\"\n", - "The *artificial_score_generator* retrieves data using *build_time_series_dataframe* for each statistical variable.\n", - "It calls the *multiple_rounds_score_validation* to compute a matrix of R2 scores for each method and statistical \n", - "variable. \n", - "\"\"\"\n", - "\n", - "def artificial_score_generator(rand_st):\n", - " if (len(rand_st) < 1):\n", - " print(\"run select_random_statvars again\")\n", - " return\n", - "\n", - " geoids = (dc.get_places_in([_PLACE], \"County\"))[_PLACE]\n", - " all_scores = pd.DataFrame()\n", - " i = -1\n", - " for sv in rand_st:\n", - " i += 1\n", - " data = dc.build_time_series_dataframe(geoids, sv).transpose()\n", - " data.reset_index(level=0, inplace=True)\n", - " data.dropna(axis=1, how='all', inplace=True)\n", - " data['index'] = pd.to_datetime(data['index'])\n", - " data.set_index('index', inplace=True)\n", - "\n", - " current_scores = multiple_rounds_cross_validation(data, 20, sv)\n", - " # Cap negative values at -100.\n", - " current_scores.iloc[:, 1:2] = current_scores.iloc[:, 1:2].apply(lambda x: [y if y > -100 else -101 for y in x])\n", - " if i > 0:\n", - " all_scores = all_scores.merge(current_scores, on='method', how='left')\n", - " else:\n", - " all_scores = current_scores\n", - " \n", - " return all_scores\n", - "\n", - "\"\"\"\n", - "*multiple_rounds_score_validation* function calls *one_round_cross_validation()* for \n", - "(rounds =) 20 times. In each round, the *one_round_cross_validation()* removes data points \n", - "*independently and uniformly at random* and calls *_FillwithX()* to impute the SAME set of missing \n", - "data points with each method from the set *_METHODS* that we defined earlier. \n", - "To generate a normalized result, we report the average of calculated scores.\n", - "\"\"\"\n", - "\n", - "def multiple_rounds_cross_validation(df, rounds, stvar):\n", - " notNaColumns = df.columns[df.notna().all()].tolist()\n", - " multiple_rsquared_values = one_round_cross_validation(df, stvar)\n", - " cols = multiple_rsquared_values.columns.difference(['method'])\n", - " for round in range(rounds-1):\n", - " multiple_rsquared_values[cols] = multiple_rsquared_values[cols].add(one_round_cross_validation(df, stvar)[cols])\n", - " \n", - " multiple_rsquared_values[cols] = multiple_rsquared_values[cols]/rounds\n", - " ave = 'Average of %s rounds for %s'%(rounds, stvar)\n", - " multiple_rsquared_values[ave]=multiple_rsquared_values.mean(axis=1,skipna=True)\n", - " multiple_rsquared_values.sort_values(by=ave, inplace = True, ascending=False)\n", - " return multiple_rsquared_values[['method',ave]].round(3) \n", - "\n", - "def one_round_cross_validation(df, sv):\n", - " rsquared_df = pd.DataFrame({'method': pd.Series(_METHODS)})\n", - " notNaColumns = df.columns[df.notna().all()].tolist()\n", - " df = df[notNaColumns]\n", - "\n", - " # Make a copy of each column and randomly delete values from original columns:\n", - " for col in notNaColumns:\n", - " df[col+\"_ref\"] = df[col].copy()\n", - " df[col] = df[col].sample(frac=0.8)\n", - "\n", - " for col in notNaColumns:\n", - " _FillwithX(df, col, sv)\n", - " result = []\n", - " # scoring the result and see which is better\n", - " for m in _METHODS:\n", - " r2 = -100\n", - " try:\n", - " r2 = r2_score(df[col+'_ref'], df[\"Fill\"+m+\"_\"+col])\n", - " except ValueError as e:\n", - " warnings.warn(\"r2 returns large negative value for %s :\" %m)\n", - " result += [(m, r2)]\n", - " \n", - " rsquared_df[\"r2_\"+col] = pd.DataFrame(result, columns=['Method', 'R_squared'])['R_squared'].copy()\n", - " rsquared_df[\"r2_\"+col] = pd.to_numeric(rsquared_df[\"r2_\"+col])\n", - " return rsquared_df \n", - "\n", - "\n", - "def _FillwithX(df, geo, sv):\n", - " for meth in _METHODS:\n", - " method = \"Fill\"+meth+\"_\"+geo\n", - " try:\n", - " if (meth == 'Mean'):\n", - " df[method] = df[geo].fillna(df[geo].mean())\n", - " elif (meth == 'Median'):\n", - " df[method] = df[geo].fillna(df[geo].median()).bfill()\n", - " elif (meth == 'Spline_d1'):\n", - " df[method] = df[geo].interpolate(method='spline', order=1).bfill()\n", - " elif (meth == 'Spline_d2'):\n", - " df[method] = df[geo].interpolate(method='spline', order=2).bfill()\n", - " elif (meth == 'Spline_d3'):\n", - " df[method] = df[geo].interpolate(method='spline', order=3).bfill()\n", - " elif (meth == 'Spline_d4'):\n", - " df[method] = df[geo].interpolate(method='spline', order=4).bfill()\n", - " elif (meth == 'Spline_d5'):\n", - " df[method] = df[geo].interpolate(method='spline', order=5).bfill()\n", - " elif (meth == 'InterpolateLinear'):\n", - " df[method] = df[geo].interpolate(method='linear').bfill()\n", - " elif (meth == 'Time'):\n", - " df[method] = df[geo].interpolate(method='time').bfill()\n", - " elif (meth == 'InterpolateAkima'):\n", - " df[method] = df[geo].interpolate(method='akima', order=2).bfill()\n", - " elif (meth == 'InterpolateSLinear'):\n", - " df[method] = df[geo].interpolate(method='slinear').bfill()\n", - " elif (meth == 'InterpolatePoly5'):\n", - " df[method] = df[geo].interpolate(method='polynomial', order=2).bfill()\n", - " elif (meth == 'InterpolatePoly7'):\n", - " df[method] = df[geo].interpolate(method='polynomial', order=7).bfill()\n", - " elif (meth == 'Krogh'):\n", - " df[method] = df[geo].interpolate(method='krogh').bfill()\n", - " elif (meth == 'Pchip'):\n", - " df[method] = df[geo].interpolate(method='pchip').bfill()\n", - " except:\n", - " print(meth, \"imputation raised error for \", sv, \" filled missing value with zero instead!\")\n", - " df[method] = df[geo].fillna(0, inplace=True) \n", - " return df" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "iVcpgbNr_m5l", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 35 - }, - "outputId": "40cde294-a9ce-48f2-f16f-e23f5db21aa4" - }, - "source": [ - "# from google.colab import auth\n", - "# auth.authenticate_user()\n", - "\n", - "# Import the required libraries\n", - "import pandas as pd\n", - "import random\n", - "\n", - "!pip install datacommons --upgrade --quiet\n", - "import datacommons_pandas as dc\n", - "\n", - "# Import other required libraries\n", - "import matplotlib.pyplot as plt\n", - "plt.rcParams.update({'font.size': 22})\n", - "import matplotlib.patches as mpatches\n", - "\n", - "# Import a scoring metric to compare methods\n", - "from sklearn.metrics import r2_score\n", - "# %matplotlib inline\n", - "\n", - "import numpy as np\n", - "\n", - "import warnings\n", - "\n", - "states = pd.DataFrame(dc.get_places_in(['country/USA'], 'State')['country/USA'])\n", - "states.insert(0, 'name', states[0].map(dc.get_property_values(states[0], 'name')).str[0])" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "text": [ - "\u001b[?25l\r\u001b[K |████▎ | 10kB 11.5MB/s eta 0:00:01\r\u001b[K |████████▋ | 20kB 1.7MB/s eta 0:00:01\r\u001b[K |█████████████ | 30kB 2.3MB/s eta 0:00:01\r\u001b[K |█████████████████▎ | 40kB 2.6MB/s eta 0:00:01\r\u001b[K |█████████████████████▋ | 51kB 2.0MB/s eta 0:00:01\r\u001b[K |██████████████████████████ | 61kB 2.2MB/s eta 0:00:01\r\u001b[K |██████████████████████████████▎ | 71kB 2.5MB/s eta 0:00:01\r\u001b[K |████████████████████████████████| 81kB 2.2MB/s \n", - "\u001b[?25h" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "9rRpybHcPAWh", - "colab_type": "text" - }, - "source": [ - "# Part 1: Sample random statistical variables\n", - "\n", - "In the following block, we will query Data Commons for the time series of 300 statistical variables for your selected state (defaults to California). Then, we will explore the datasets for all counties inside the state and plot the times series that are available for at least 4 counties. In **`select_random_statvars(sample_size, plot_flag, print_flag)`**, you can alter the plot_flag and print_flag to hide the plots and print logs respectively. The third option will let you see the sampled statistical variables with no data within the selected place. \n", - "\n", - "**Note:** For visual purposes, we include dots for a maximum of 3 lines. We use plain lines if there are more than 3 counties to plot. " - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "YaJPrlmKOVfN", - "colab_type": "code", - "cellView": "both", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "outputId": "910e7e91-d826-4775-a7f1-a73f1de565f7" - }, - "source": [ - "#@title Select a state to plot { run: \"auto\" }\n", - "state_name = \"California\" #@param [\"Missouri\", \"Arkansas\", \"Arizona\", \"Ohio\", \"Connecticut\", \"Vermont\", \"Illinois\", \"South Dakota\", \"Iowa\", \"Oklahoma\", \"Kansas\", \"Washington\", \"Oregon\", \"Hawaii\", \"Minnesota\", \"Idaho\", \"Alaska\", \"Colorado\", \"Delaware\", \"Alabama\", \"North Dakota\", \"Michigan\", \"California\", \"Indiana\", \"Kentucky\", \"Nebraska\", \"Louisiana\", \"New Jersey\", \"Rhode Island\", \"Utah\", \"Nevada\", \"South Carolina\", \"Wisconsin\", \"New York\", \"North Carolina\", \"New Hampshire\", \"Georgia\", \"Pennsylvania\", \"West Virginia\", \"Maine\", \"Mississippi\", \"Montana\", \"Tennessee\", \"New Mexico\", \"Massachusetts\", \"Wyoming\", \"Maryland\", \"Florida\", \"Texas\", \"Virginia\"]\n", - "_PLACE = states.loc[states['name'] == state_name].values[0][1]\n", - "\n", - "# Set the second value to True if you want to plot data for the sampled statistical variable:\n", - "random_stats = select_random_statvars(300, plot_flag=True, log_p=False)\n", - "print(\"Number of valid samples: \" , len(random_stats), random_stats)" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "text": [ - "Number of valid samples: 4 ['Count_Death_85Years_EndocrineNutritionalMetabolicDiseases_Female', 'Count_Death_55To64Years_Male_White', 'RetailDrugDistribution_DrugDistribution_PoppyStrawConcentrate', 'Count_Death_MentalBehaviouralDisorders_White']\n" - ], - "name": "stdout" - }, - { - "output_type": "display_data", - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABQ8AAAJ6CAYAAACG8bRTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd1zWVf/H8deXIUOGgltRMHPnCE3NSVbiTEutNBUbdpum1Z2p3VlmdWdad+t2ZJk4y3E707Ql5sjcpknDElMcCQIuRMb5/YHwA7kQ0AsvwPfz8bgecJ3zPed8vl980NWHMyxjDCIiIiIiIiIiIiJXcnJ0ACIiIiIiIiIiIlI0KXkoIiIiIiIiIiIiNil5KCIiIiIiIiIiIjYpeSgiIiIiIiIiIiI2KXkoIiIiIiIiIiIiNrk4OgAREREpHDt37izr5OQ0yNnZub8xphxgOTomEZFiwFiWFZOamjovLS1tdnBwcLyjAxIREXEkyxjj6BhERETEznbu3FnKxcVlsZ+f323lypU75+7ufsmylDsUEcmLMYaLFy+WOnXqlHdcXNxPKSkpfYKDgy85Oi4RERFH0bJlERGRkulhHx+f26pVq3baw8NDiUMRkXyyLAsPD49LAQEBsT4+PrcBDzk6JhEREUdS8lBERKQEcnV17eLn56ekoYjINbIsCz8/v0uurq5dHB2LiIiIIyl5KCIiUjI1Kl269AVHByEiUpyVLl06EWjk6DhEREQcSclDERGREsgY4+Hs7Jzm6DhERIozZ2fnVGOMp6PjEBERcSQlD0VEREooLVkWEbk++j0qIiKi5KGIiIiIiIiIiIjkQslDERERERERERERsUnJQxEREREREREREbFJyUMRERERERERERGxSclDERERERERERERsUnJQxEREREREREREbFJyUMRERERERERERGxSclDEREREcGyrGDLsoIBPv7447JNmjSp6+np2bR06dJNW7VqVXvdunVettp99913pZ988slqDRs2rOfv79/Y1dX19goVKjQKDQ2t+e2335a21ea5556rYllW8HPPPVfljz/+cH3ggQcCy5cv38jDw6Np/fr1682aNatsxrVfffVV6fbt29cqU6ZMEw8Pj6YtWrSovWHDBs/c7uPEiRPOI0aMqFK7du36np6eTTP6fPXVVyskJSVZ1/ucRERERG42ljHG0TGIiIiIne3duzeqcePGMY6OQ4qPjMThyJEjj3/44YeVb7/99nMVKlRIjoyM9Dh06JC7q6urWbNmza933333+azt7rzzztrbtm3zvuWWWxKrVq16qVSpUml//vmn+++//+7h7OzMjBkz/nz00UfjsrZ57rnnqrz77ruV77///tiIiAhfT0/P1MaNG184fvy4665du7wsy2L69Ol/uru7m8cee6xm3bp1E2vUqJF04MABj0OHDrl7eHikbd269UCjRo2Ssva7bds2j27dut166tQp14oVKybXq1fvQlpaGnv37vVKSEhwbtWq1dnvvvvud3d3d30Alnzbu3dvucaNGwc6Og4RERFHUfJQRESkBFLyUAoqI3no6+ubumrVqt/atm17ASA1NZVHHnmkxueff16uVatWZ7Zs2fJ71nZLlizxadGixYWAgICUrOULFizwHTRo0C2lS5dOO3LkyE/e3t5pGXUZyUOAwYMH/z1jxowjLi4uALz11lvlx4wZU71ixYrJiYmJTu++++7hjORjamoq9913X83Vq1eX7dOnT8yiRYsOZ/R57tw5q27dug2jo6NLjR07NvrVV1894erqCsDJkyede/XqVfOHH37wefbZZ4//5z//OVYYz1BKJiUPRUTkZqdlyyIiIiKS6YUXXojOSBwCODs7M2nSpGiAnTt3el+59Ld3795nrkwcAvTr1y+hc+fOcQkJCc6rV6/2tjVWlSpVLk2dOvVoRuIQ4J///OepMmXKpJw8edK1Xbt2CVlnLTo7OzN27NjjAFu2bPHJ2teUKVPKRUdHl+rSpUvcv//978zEIUDFihVTFyxYEOXi4mJmzZpVPi0tDRERERHJH5e8LxERERGRm8UDDzyQcGVZQEBAio+PT+qZM2ecT5486Vy9evVsycLjx4+7LF682Hf//v0eCQkJzikpKRbAr7/+6nH5q5utse68886zVy4hdnFxoWrVqpfi4+NdOnXqdObKNg0bNkwCOHXqlGvW8nXr1vkC9O7dO+7KNgCBgYHJNWrUSPrjjz/c9+/f73blkmcRERERsU3JQxERERHJVKtWrUu2yr28vFLPnDnjnJiYmG3lyuTJk8u9/PLLARcvXsx1RcuZM2ecbZVXrVrV5lienp5pANWrV89R7+vrmwZw6dKlbDMg//rrLzeARx99tOajjz6aWygAnDhxwkXJQxEREZH8UfJQRERERDI5O9vM89m0YcMGz9GjR9dwdnY248aNO/rAAw/EBwUFJXt5eaU5OTkxfPjwqlOmTKlkjLF5yrGT09V30MmrPqvU1FQAOnTokODn55djGXVW5cuXT813xyIiIiI3OSUPRUREROSaLFy4sKwxhsGDB/89YcKEk1fW//nnnzaXKxeGypUrX4qKinJ/8sknTz300EM5ll6LiIiIyLXRgSkiIiIick3i4uJcAAICAnIsLz527JjLpk2bfHK2Khz33nvvGYDFixeXvVFjioiIiNwMlDwUERERkWtSp06diwCff/65f0JCQubnyri4OKdHHnkk8OzZs/lfA32dnn322VOVKlW6tHTpUv/nnnuuytmzZ3N8zv3ll19KTZ061e9GxSQiIiJSEih5KCIiIiLXZNiwYTGVKlW6dODAAc+goKDb7r333lvuueeeW4KCghrt27fPs0+fPjE3KhZfX9+0FStWHKxcufKld999t3JAQECjFi1a1O7Ro0fQXXfdVatGjRoN69Wrd9tHH31U4UbFJCIiIlISKHkoIiIiItekfPnyqTt27Ih8+OGHYzw9PdMiIiJ89+3bVzo0NDRux44dkdWqVUu+kfHccccdifv27TswZsyY6Bo1alw8cOCA59q1a8v+/PPPnmXLlk0ZOXLk8RkzZhy+kTGJiIiIFHeWMcbRMYiIiIid7d27N6px48Y3bNaXiEhJtXfv3nKNGzcOdHQcIiIijqKZhyIiIiIiIiIiImKTkociIiIiIiIiIiJik5KHIiIiIiIiIiIiYpOShyIiIiIiIiIiImKTkociIiIiIiIiIiJik4ujA7jRypUrZwIDAx0dhoiISKGaNGkSBw4cqOHoOEREirvY2FiaNWtmHB2HiIhIYdq5c2eMMaa8rbqbLnkYGBjIjh07HB2GiIhIoYqMjKRevXqODkNEpNizLEv//yAiIiWeZVmHc6vTsmURERERERERERGxSclDERERERERERERsUnJQxEREREREREREbFJyUMRERERERERERGxSclDERERERERERERsUnJQxEREREREREREbFJyUMRERERERERERGxSclDERERuekEBgZiWVa2l5OTE76+vrRo0YL//Oc/JCUlOTrMGyopKYkZM2bQrVs3qlWrhru7O6VLl+bWW2+lX79+LFu2jLS0NEeHKSIiIiI3mJKHIiIictPq1KkTgwYNYtCgQfTr148mTZqwa9cu/vnPf9KhQwcuXrxot7EyEpZRUVE26yMiIrAsiw4dOthtzPzatm0btWvX5sknn2TdunVUq1aN++67j9DQUDw9Pfnss8+4//77adGixQ2P7Xo58rmKiIiIlAQujg5ARERExFHGjBmTI6n022+/0bp1a7Zu3cpHH33EyJEjHRPcDbJjxw7at2/PxYsXefTRR3nzzTepUKFCtmv++usv/v3vf7No0SIHRSkiIiIijqKZhyIiIiJZZMzAg/RZayVZcnIyffv25eLFi4wYMYKZM2fmSBwCVK9enenTp7N8+XIHRCkiIiIijqTkoYiIiNjF/PkQGAhOTulf5893dETXrlKlSkB6ci2rqKgoLMsiMDAw17YZeyhmCA8Px7IsDh8+DEBQUFC2vRajoqLo0KEDISEhAGzYsCFb/ZUzI40xfP7559x7772UK1cONzc3qlevzhNPPJHrkujczJ8/n0OHDlGhQgUmTZqU5/Xt2rXLURYTE8Po0aOpW7cuHh4e+Pj40LJlS6ZOnUpKSkqO68ePH49lWYwfP97mGBnPKywsLNfys2fPMmrUKIKCgnBzc6Nq1aoMHTqU06dPZ2uT13M1xnDrrbdiWRZbt27N9b4feOABLMti6tSpeTwhERERkZJHy5ZFRETkus2fD0OGwIUL6e8PH05/D9C/v+Piulbbtm0DoF69etfdV61atRg0aBBLlizh/PnzPPDAA3h5eWXWe3l5ERoairu7O+vWraNixYqEhoZm1tetWzfz++TkZB566CGWLl2Kh4cHzZo1o2LFiuzfv59PPvmE//3vf3z11Vc0a9YsX7GtWLECgAcffBA3N7cC39vBgwe56667OHLkCJUqVaJ79+5cuHCB9evXM2zYMJYtW8YXX3xxTX3nJiEhgdatWxMdHU27du1o2LAhmzZtYvr06Wzbto2tW7fi6uoKkOdztSyLYcOG8eyzzzJ16lRatmyZY7zo6GhWrlyJt7c3AwYMsNt9iIiIiBQXSh6KiIjchJ55BvbssV9/W7fClYcTX7gAjz0GH39snzGaNIH33rNPX7akpKRw9OhR5syZw7x58yhTpgxPPfXUdffbpk0b2rRpQ0REBOfPn+ftt9/OMXNxzJgxtGzZknXr1lG3bl3Cw8Nt9jVu3DiWLl1Ku3btmD9/PtWqVcus++9//8vTTz/NQw89xC+//IKLS94f83bu3AlA8+bNr+ne+vXrx5EjR+jTpw9z5szB3d0dgCNHjnD33XfzzTffMH78eN58881r6t+W5cuX06VLF7Zs2ZKZhD127BgtW7Zk165dLFq0iP6XM9b5ea6DBw/mpZdeYvHixbz77rv4+/tnq//oo49ISUlh4MCBeHt72+0+RERERIoLLVsWERGR63Zl4jCv8qIiJCQkcxmrq6srQUFBvPLKK3Tq1Ikff/yRoKAgR4eY6fTp03zwwQd4eXmxePHibIlDgOHDh9O1a1f++OMPvvzyy3z1eerUKQCb+xzmZePGjWzfvh1vb2+mT5+emTgECAgI4P333wdgypQpdj212svLi5kzZ2abvVmlShWGDx8OwLffflug/nx9fRk4cCAXL15k5syZ2eqSk5P5+HL22x6JZBEREZHiSDMPRUREbkL2nsEXGJi+VPlKNWpAUT5zpFOnTpn7G0J6Mm3v3r2sXbuWp59+mjlz5lCxYkUHRvj/1q9fT2JiIl27ds012de+fXtWr17NDz/8QPfu3Qs1ng0bNgDQvXt3/Pz8ctSHhoZSuXJljh8/zs6dO2ndurVdxg0ODs72M8uQsbz72LFjBe5z+PDhTJs2jY8++ojnn38eJ6f0v68vXbqUEydO0KFDB+rXr399gYuIiIgUUzc8eWhZ1tNAW+A2oALgA8QDe4FwYL4xxlzRJgJof5Vu1xljQq9SLyIiIoXojTey73kI4OmZXl6UjRkzJseBJMnJybz00ktMmjSJTp06sXPnTpydnR0TYBZ//vknAKtXr852IIstGTMK81K+fHmOHDnC33//XeB4oqOjAa46O7NmzZocP34881p7qF69us1yHx8fgGua5Vi/fv3MZdZr166lS5cuAJkHpAwbNuwaoxUREREp/hwx83A06UnD/cAW4DxQA7gL6Aj0tizrfmNMmo2264ATNsr3FVKsIiIikg8Zh6L861/w119QvXp64rA4Hpbi6urKm2++yaeffpo5C7Fr1675apuWZuvji32kpqYCUKdOHZsHe2TVokWLfPUZHBzMkSNH2L59+zUfBpJXIrOg8nqGGbMC7e3pp5/mm2++YerUqXTp0oX9+/fz/fffU6VKFXr27FkoY4qIiIgUB45IHj4E7DbGnM9aaFlWA+Bb4D5gEDDLRtuJxpiIQo9QRERECqx//+KZLLTFycmJwMBAYmJiiIyMzEwelipVCoBz587ZbHfY1tptOwkICADgtttuy/VAlYLq0aMHy5cvZ+HChUyePLlApyJXrVoV+P8ZkbZk1GVcC459hlfTrVs3goKC+PLLL4mKisqcdThkyJB8HT4jIiIiUlLd8ANTjDGbrkwcXi7/GZhy+e09NzYqERERkf+XlpZGVFQUQLaDOcqXL0+pUqWIjY21uTR4zZo1ufaZkTRLSUm5pvq7774bV1dXvvnmG+Lj4/N1H3np378/NWrU4O+//2b06NF5Xr9x48bM79u3T99RZtWqVcTFxeW4dt26dRw/fhwvLy+Cg4MzyzMSib/88kuONsYY1q5dW+D7uJq8nmsGJycnnnrqKdLS0pg8eTLz5s3D1dWVIUOG2DUeERERkeKmqJ22nPGproifzSgiIiIlVUpKCmPHjiUmJgZXV1dCQ/9/W2VXV1fatm0LwCuvvELWbZo3bdrEyy+/nGu/GUmzyMjIq9YfPHjQZqKrYsWKDBs2jPj4eHr06GEz+Xb+/HkWLFjAyZMn83Gn6Ym1hQsX4ubmxvvvv8/jjz9uc//D6Ohohg8fnm35btu2bWnevDlnz55l2LBhJGU5Wjs6OppnnnkGSD+MJOtJzCEhITg5ObF27Vo2b96cWZ6amsq//vUvtm3blq/Y8yuv55rVY489hqenJ1OnTuXs2bP07NmTypUr2zUeERERkeKmyKzBsCwrCPjH5bcrc7msl2VZvQA34Biw3hizMZdrRURERK5q4sSJ2ZYAx8TEsGfPHqKjo3FycuL9998nMDAwW5sJEyawceNGpk2bRkREBA0aNODw4cPs3LmTF198kddff93mWL169SIiIoL+/ftz7733UqZMGQDeeust/P39qVGjBk2bNmX37t00atSI4OBg3NzcqFOnDqNGjQJg0qRJHDt2jEWLFtGwYUOaNGlCzZo1sSyLqKgo9u7dS1JSEpGRkfk+JbpFixasX7+evn37MnPmTGbPnk3z5s2pXr06KSkp/PHHH+zduxdjTI69FhcsWEBISAifffYZERERtG3blgsXLrB+/XrOnz9Px44dGT9+fLY21atXZ+jQoUyZMoWQkBDatm2Lj48Pu3btIi4ujhEjRvDBBx/kK/b8yM9zzVC2bFkeeeQRZsyYAeigFBEREUlnUlPBycnuez0XG8YYh7yAwVw+XRnYACQDqcAbNq6NAEwur01AQH7HDQ4ONiIiIiXdgQMHHB1CkVajRg2bnyvc3NxMzZo1zcCBA82OHTtybb9x40bTsWNH4+XlZTw9PU3z5s3NvHnzjDEms68rpaammtdee83UrVvXuLm5ZV536NChzGsOHTpk+vbtaypWrGicnZ0NYNq3b5+jr5UrV5r77rvPVK5c2bi6uho/Pz/ToEEDExYWZpYtW2YuXbpU4GeSmJhopk2bZjp37myqVKliSpUqZTw8PEytWrVM//79zapVq0xaWlqOdqdOnTKjRo0ytWvXNm5ubsbLy8vccccd5r///W+ucaSmppq33nrL1KlTx5QqVcqUK1fO9OnTx/z6669m1qxZBjCDBg3K1ia38gzr16/P9Xnl97kaY8zixYsNYBo0aHC1xyU3Ef0+FRGRuCX/M3/07GWST51ydCiFBthhcsmlWSbLcpsbybKsT4DHshSlAK8A/zHGXLzi2teAQ8BG4ChQHrgT+DcQBPwG3G5s7KV4uf0QYAhA9erVgx21EbeIiMiNEhkZSb169Rwdhkix06tXL5YvX87UqVMZOnSoo8ORIkC/T0VEbm7GGA71uA8si6AVy0vs7EPLsnYaY5rZqnPYnofGmMeNMRbgCTQA3gPGA1sty6pyxbXjjDGfGmN+N8YkGmP+MsZ8DjQF/gRqA7l+ujPGzDDGNDPGNCtfvnxh3ZKIiIiIFGM7d+5k5cqV+Pv7M3DgQEeHIyIiIkXA+c1bSPr9d/zCwkps4jAvDj8w5XIy8IAxZhQwFmgM/DefbROA9y+/7VJIIYqIiIhICfb444/z0EMPERISQlpaGhMmTKB06dKODktERESKgNOzZuFcvhw+3bo6OhSHKTIHplwWDrwNdLcsy9UYk5yPNhlHDVYttKhEREREpMSaOXMmTk5O1KhRg5dffpmnnnrK0SGJiIhIEXDxt984v3kz5Z8ZiVOpUo4Ox2EKlDy0LOs24EngFuBRY8xxy7J6AoeNMbvtEE8c6XsfugB+wMl8tPG//PWcHcYXERERkZuMo/YAFxERkaLtdPhsLHd3yjz4oKNDcah8L1u2LOteYDvpM/zuAjwuV91C+kEn9tCO9MRhPBCTzzZ9L3/dbqcYRERERERERETkJpZy6hRnVq2izP29cClb1tHhOFRB9jx8DXjOGNMLuJSlPAK4Iz8dWJbVxrKsbpZl5ZjxaFlWa2Dm5bczjTGpl8s7WJbV3rpiV0rLsjwty5oE9CR9tuKHBbgXERERERERERERm07Pn49JScFPh6gVaNlyQ2CNjfLTpC8xzo9awCwg3rKsXcAJwJv02Yv1L1+zGhiXpU0T4F3guGVZey+PV/FyuT+QBDxmjPm5APciIiIiIiIiIiKSQ1piIvGffY7XXXdRKjDQ0eE4XEGSh6dJX7IcdUX57cDRfPaxgfQZjG2BW4E7AYv0JOL/gHnGmOU22kwHmgFNSU9UJl+O4zPgQ2PMbwW4DxEREREREREREZsSli8nNSEB/8Fhjg6lSChI8nABMNmyrL6AAVwsy2pP+unIs/LTgTHmEPByQQK8fBDL0IK0ERERERERERERKSiTlsbp8Nm433YbHsHBjg6nSCjInocvAYeAw4AXcAD4DtgEvGH/0ERERERERERERG6ccxERXDp8GL+wQVxx/MZNK98zD40xyUB/y7JeJn35sBOw2xjze2EFJyIiIiIiIiIicqOc/nQWLlUq49Opk6NDKTIKsmwZAGPMH8AfhRCLiIiIiIiIiIiIQyTu28+FHTuoMHo0lkuBU2Yl1lWfhGVZH+S3I2PMiOsPR0RERERERERE5MY7HR6OU+nSlOnT29GhFCl5pVFvy2c/5noDERERERERERERcYTkY8c4s3YtfgMG4Ozl5ehwipSrHphijAnJ5+uuGxWwiIiIyPUKDAzEsqw8XxEREdnaZZQXRIcOHXL06+XlRZUqVWjXrh3PPvssW7ZssePdOV7G842KirphY549e5Z33nmHu+++m8qVK+Pm5oa3tzcNGjTgscce45tvvrlhsYiIiEjxc3ruPAD8Bg5wcCRFjxZwi4iIyE2rU6dOVKpUKdf6q9UVVOvWralVqxYASUlJxMTEsHfvXjZu3Mh7773HnXfeyezZszOvkfxbs2YNAwcOJDY2Fnd3d+644w6qVKlCYmIikZGRfPrpp3z66af07t2bxYsXOzrcAgkPD2fw4MEMGjSI8PBwR4cjIiJSIqWeO0f84sX4dOqEa5Uqjg6nyClQ8tCyrNpAb6A6UCprnTHmUTvGJSIiIlLoxowZQ4cOHW7IWI8//jhhYWE5ytevX8/zzz/Pli1baN26NT/88AM1a9a8ITGVBCtXrqRXr14YYxgzZgwvvvgi3t7e2a45cOAA48eP5/fff3dQlCIiIlKUxS9ZQtq5c/gNDnN0KEXSVZctZ2VZVlfgJ6A78ChQB+gC9ALKFUp0IiIiIiVcSEgIW7ZsoVWrVvz99988+qj+HptfsbGxDBw4kLS0NN555x3efPPNHIlDgPr167No0SLef/99B0QpIiIiRZlJSSFuzlw8mgXjcVt+j/64ueQ7eQhMAF41xrQCkoABQCDwDRBh98hERESkWFm+O5rWE78jaMxqWk/8juW7ox0dUrHh5ubGjBkzANiwYQM7duzIcc3hw4d56qmnqFmzJm5ubpQtW5aQkBAWLFhgs8/x48djWRbjx4/n8OHDDB48mGrVquHi4sIzzzwDQHJyMnPnzuXhhx+mTp06eHt74+npSf369Rk9ejSnT5/ONebDhw8zcOBAKlasiIeHB/Xr12fSpEmkpqZe9V5jYmIYPXo0devWxcPDAx8fH1q2bMnUqVNJSUnJ7yMD4MMPPyQhIYHGjRtn3tPVtGvXzuZ9FOS5hoWFYVlWrkuIsz733MpPnjzJk08+SbVq1XBzcyMoKIgxY8Zw8eLFbG0CAwMZPHgwALNnz862b2ZYWBjnzp3D19cXFxcXjh49mut9BwcHY1kWa9asucrTERERuTmd/eorko8dw//yf3Mlp4IsW64DLLz8fTLgaYy5aFnWBGA18B97ByciIiLFw/Ld0Yxduo/E5PTEUXR8ImOX7gOgZ9Oqjgyt2GjYsCFNmjRhz549fP311zRr1iyzbuvWrXTu3Jn4+HiCgoLo1asXp0+fJiIigoiICNauXZuZXLrS77//TtOmTXF3d6d169akpKRQpkwZAE6ePMnAgQMpW7YsdevWpUmTJpw5c4YdO3YwadIklixZwo8//ki5ctkXmRw4cID27dsTExNDQEAA9913H3FxcYwbN44ff/wx13s8ePAgd911F0eOHKFSpUp0796dCxcusH79eoYNG8ayZcv44osvcHNzy9czW7FiBQADBw4s8EE2cH3P9VodOXKE4OBgjDHceeednDlzhk2bNvHWW29x4MABVq5cmXlt79692bp1K5s3b+aWW26hTZs2mXVt2rTBy8uLwYMH8/777zNjxgwmTJhg8x537dpFzZo1CQ0Ntdt9iIiIlATGGGJnheNaozpeN2grm+KoIMnDs4D75e+PA7WA/Zf7KGvnuERERKQQvbrqZw4cO2O3/nb/Fc+l1LRsZYnJqbyw5Cc+2/aXXcaoX8WHV7o3sEtfRVWzZs3Ys2cPP//8c2bZxYsX6du3L/Hx8TzzzDO8/fbbODs7A7B//346duzI3Llzad26NU8++WSOPhcsWEBYWBgfffQRpUpl27IaX19fVq5cSWhoKK6urpnliYmJDBs2jFmzZjFu3DimTZuWrd2AAQOIiYlhwIABfPLJJ5n9/vzzz4SEhHDq1Cmb99evXz+OHDlCnz59mDNnDu7u6R8tjxw5wt13380333zD+PHjefPNN/N8VikpKfz0008ANG/ePM/rr3S9z/VafQ1cgCQAACAASURBVPrppzz++ONMmTIl87lFRkZyxx13sGrVKjZv3kzr1q0BePvttwkPD2fz5s20adPG5mzHYcOG8cEHH/DJJ58wbty4bD9HgKlTpwIwdOhQnJwKsuhIRESk5EvctYuL+/ZR8eVxWJc/B0hOBfkE8SOQ8efO1cA7lmW9AswCfrB3YCIiIlJ8XJk4zKu8qAgJCcm2FDTrK2N23o2UMcMvNjY2s2zx4sUcOXKEwMBAJk2alJnggvTZiq+++iqQnmiyxd/fnw8++CBH4hDA29ub7t2750g4eXh48N///hcXFxf+97//ZavbuHEju3btwtfXlw8//DBbvw0aNGDcuHE249i4cSPbt2/H29ub6dOnZyYOAQICAjL3I5wyZUqO5bu2xMbGkpaW/u+rQoUKeV5/pet9rtcqICAgx8+jXr16DBgwAIBvv/22QP3deuuthIaGcvz4cZYtW5atLiYmhkWLFuHu7q69NEVERGyInTULZ19fyvTq5ehQirSCzDx8DvC6/P14wBt4APjtcp2IiIgUE/aewdd64ndExyfmKK9axoOFT7ay61j21KlTJypVqmSzztPT8wZHQ2YyLOsMsQ0bNgDps/auTPJB+h58Tz31FAcPHiQ6OpqqVbMvE7/77rttHiKS1e7du/n222+Jiori/PnzGGMAKFWqFKdOnSIuLo6yZctmi6dbt274+vrm6GvAgAGMGDEiR3lGu+7du+Pn55ejPjQ0lMqVK3P8+HF27tyZOfuusFzvc71Wd911Fx4eHjnK69atC8CxY8cK3OfTTz/Nl19+ydSpU+nbt29m+cyZM0lKSiIsLMzmMxcREbmZXYqK4ty33+H/5BCcbPy3Wf5fvpOHxpg/s3x/ARhaKBGJiIhIsTOqU51sex4CeLg6M6pTHQdGlbcxY8bQoQjtbxMTEwOQLdETHZ1+8ExQUJDNNu7u7lSpUoXo6GibSa4aNWrkOt65c+fo379/tn32bDlz5kxm8jDjYI7c4ilTpgy+vr4kJCRkK8/rPgBq1qzJ8ePHM6+9Gn9/f5ycnEhLS+Pvv/+mTp2C/Vu73ud6rapXr26z3MfHByBfsy6vFBoayq233sqGDRs4cOAA9evXJy0tjenTpwPpS5tFREQku9Nz5mK5uFC2Xz9Hh1LkXdPGJ5ZluVuW5Zn1Ze/AREREpPjo2bQqb95/G1XLeGCRPuPwzftv02EpBbRz504Abrvtthx113poh61ZbhnGjh3LypUrqV+/PitXruTYsWNcunQJYwzGGCpXrgyQORPRHux1+IiLiwuNGjUCYPv27Q6PJ0PG7NHcFMa+g5ZlMXz4cOD/9zhcs2YNUVFRNG/ePNvhOyIiIgKp8fHEL1uGT7duuF7D9ic3m3x/erEsq4ZlWSssyzoDnCf9AJWsLxEREbmJ9Wxalc1j7uLQxK5sHnOXEocFtG/fPvbu3QvAPffck1meMePtzz//tNnu4sWLmUtdCzo7bvHixQAsXLiQ7t27U7ly5cwlvOfPn+fEiRM52mSMERUVZbPP+Pj4HLMO83MfWevyex89evQAYM6cOfm6viDx5PZcM/YqPHfunM12hw8fLnAs9hAWFoaXlxdz587l3LlzmUlEzToUERHJKe7zhZjERPzCwhwdSrFQkD99zgOqAE8DXYEuV7xERERE5BokJSXxj3/8A4COHTvStGnTzLr27dsD8Nlnn5GSkpKj7ezZszHGUKtWrQInD0+fPg2kH+JxpQULFticcZgRzxdffMGZMzlP7J4/f77NsTLarVq1iri4uBz169at4/jx43h5eREcHJyv+IcPH46Pjw979+7lvffey/P6jRs35oinoM814/tffvklR5vExEQiIiLyFXt+ZSQrbcWYlY+PD4MGDeLMmTNMmDCBdevW4e/vz4MPPmjXeERERIq7tEuXOD1/HqXvvBP3OrUdHU6xUJDkYVNgoDFmtjFmrTFmXdZXYQUoIiIiUpJFRERw5513smXLFipWrMgnn3ySrb5Pnz4EBARw6NAhxo4dm21Z7IEDB3jllVcAeP755ws8dsYhHRmz1DLs2LGDsWPH2mzTtm1bmjRpQnx8PCNHjiQ5OTmzLjIyktdeey3Xds2bN+fs2bMMGzaMpKSkzLro6GieeeYZID0hmPUk5qspX7484eHhWJbFc889x4svvsjZszkXxPz22288/PDD2Q5yudbn2rFjRwDmzp3Lr7/+mlmemJjI0KFD+euvv/IVe35lJCsjIyPzvHb48OFYlsXkyZNJS0vj0UcfzfezFBERuVmcWb2G1FMx+A0e7OhQio2CnLa8FygP5P3JRURERKQYmDhxIuHh4bnW9+vXj3vvvdcuY33yySeZs9IuXbpEbGwse/bs4e+//wbSk2uzZs0iMDAwWzt3d3cWLVpE586defvtt1m2bBnNmzfn9OnTrF+/nuTkZAYMGMCQIUMKHNPLL79Mnz59ePHFF1m4cCH16tXj2LFjbNq0iYceeojNmzfnWIZrWRZz586lffv2hIeH891339GqVSvi4+NZv3493bp1Y+fOnTaX7y5YsICQkBA+++wzIiIiaNu2LRcuXGD9+vWcP3+ejh07Mn78+ALdQ69evVi+fDlhYWG8+eabvPvuu7Ro0YIqVaqQmJjIr7/+mpl4e+ihh677ubZp04Zu3brxxRdfcPvtt9O2bVtcXFzYsWMHTk5ODB48mFmzZhXoHq6mZcuWVKpUiV27dtGsWTMaNGiAq6srrVu3ZvAV/9NTt25d7rnnHr766iucnJwYOlTnG4qIiGRljOH0rFm43Xorpdu0dnQ4xUZBkodDgA8sy/oA2A8kZ600xtj3z6wiIiIihWzduqsvnmjSpIndkoebN29m8+bNAHh6euLr60vt2rXp168fffv2pVWrVrm2bdmyJXv27GHixImsXbuWpUuX4uHhQatWrRgyZAj9+vW7poM/evfuzfr165kwYQJ79+7l4MGD3Hrrrbz33nsMGzaMmjVr2mzXsGFDduzYwcsvv8y6detYvnw5gYGBvPLKK7zwwgvUqlXLZrtatWqxe/duJk2axIoVK1ixYgWurq40aNCAgQMHMmTIkMw9FwuiR48eHDp0iI8//pg1a9bw888/s2XLFkqVKkWNGjV4/PHHeeSRRzKXKme41ue6ePFiXn31VT7//HO+++47ypUrR9euXXnjjTcyTzi2Fzc3N9auXcu//vUvfvjhB3bv3k1aWhopKSk5kodAZvKwc+fOVz3ZWkRE5GZ04YcfSPrtNyq/8YbdD00ryaz8np5nWdZtwGdAfSBrIwswxhhn+4dnf82aNTM7duxwdBgiIiKFKjIyknr16jk6DBG5wZo2bcqePXtYs2YNnTt3dnQ4JYJ+n4qIlBx/PTGEi5GR1PruW5wu7yss6SzL2mmMaWarriAzD2cDfwOjgZNkTyCKiIiIiIgDLVu2jD179lCvXj1CQ0MdHY6IiEiRkvT775zfuJHyI0cocVhABUke1gWaGGN+K6xgREREREQk/2JjYxk9ejSnT59mzZo1AEyePFlLsURERK4QGx6O5e5OmSx7IEv+FCR5uA0IApQ8FBEREREpAs6ePcvMmTNxcXGhVq1ajB07lq5duzo6LBERkSIlJSaGMytX4fvA/biULevocIqdgiQPpwHvWZb1DrCPnAem7LJnYCIiIiIicnWBgYHkdw9zERGRm1XcggWYlBT8Bg1ydCjFUkGSh59d/jrDRp0BisWBKSIiIiIiIiIicnNIS0wkbsFneIWE4BYU5OhwiqWCJA/1hEVEREREREREpNhIWLGS1Ph4/AeHOTqUYivfyUNjzOHCDERERERERERERMReTFoap8PDcW/QAI9mzRwdTrHlVJCLLcvqbFnWF5ZlHbAsK+By2eOWZXUsnPBEREREREREREQK7lzEBi5FReE3eDCWZTk6nGIr38lDy7L6A4uA30lfwux6ucoZeMH+oYmIiIiIiIiIiFyb07Nm4VK5Mj6d7nV0KMVaQWYevgA8YYx5FkjJUr4VaGLXqERERERERERERK5R4v6fubB9O36PPILl6pp3A8lVQZKHtwI/2Cg/B/jYJxwREREREREREZHrczo8HKfSpSnTt4+jQyn2CpI8PAbUtlHeDvjDPuGIiIiIiIiIiIhcu+Tjxznz5ZeU6d0bZ29vR4dT7BUkeTgD+MCyrNaX3wdYljUImARMs3tkIiIiIiIiIiIiBXR63jwwBr+BAxwdSongkt8LjTGTLMvyBb4G3IH1QBLwtjFmSiHFJyIiIiIiIiIiki+p584Tv2gx3p3uxbVqVUeHUyIUZOYhxph/AeWAO4CWQHljzLjCCExERESksAQGBmJZFhEREVe9rkOHDliWRXh4+A2J61pERUVhWRaBgYE3ZLzx48djWRbjx48vULvw8HAsyyIsLKxQ4gLYt28fI0aMoFGjRpQtWxZXV1fKlStH27ZtefXVVzl8+HChjS0iIiJFQ8L/lpB29iz+gwc7OpQSI8/koWVZpy3LKpelaARw0BizzRhzrvBCExEREZGSLiIiAsuy6NChwzX3kZyczPDhw2ncuDEffvghMTExtG7dmj59+nD77bezf/9+xo8fT+3atVm2bJn9gr9BMpLYeSW7RUREbnYmJYXTc+biERyMR6NGjg6nxMjPsuUyZE8yvggsAuILJSIRERERkQLo378/ixcvpnLlykyfPp0ePXpkq09JSWHZsmW8+OKLmn0oIiJSgp395huSo6OpMGa0o0MpUfK952EWlt2jEBERERG5Bp988gmLFy+mTJkybN68maCgoBzXuLi40KdPHzp37szvv//ugChFRESksBljiJ01C9fq1fG+6y5Hh1OiFGjPQxEREZFczZ8PgYHg5JT+df58R0dUaMLCwq66F2Ju+wJmLT969ChhYWFUrlwZT09Pbr/9dpYsWZJ57ebNm+nSpQv+/v54enoSEhLC9u3brxpXSkoKEydOpF69eri7u1OxYkUGDRrEX3/9lWubn3/+mYEDBxIQEICbmxvlypWjS5cufPnll/l+HhmMMcycOZPbb78dDw8PypUrR8+ePfnpp59sXt+hQwdCQkIA2LBhA5ZlZb7ys4zZGMO///1vAF5++WWbicOsvLy8aNq0aY7y1atX07lzZ8qVK0epUqUICAhg0KBBREZG2uwnI8bcZOypGRUVlWv5119/TceOHfH19cXT05OWLVuycuXKbNdnLOnesGEDACEhIdmeUUREBHPnzsWyLEJDQ3ONZ9++fViWRdWqVUlJScn1OhERkeIscfduLu79Cb9BA7GcnR0dTomS35mH/7AsK2N/QxfgMcuyYrNeYIz5j10jExERkeJj/nwYMgQuXEh/f/hw+nuA/v0dF1cRFRUVRXBwMF5eXrRv356jR4+yefNm+vbty4IFC3Bzc+PBBx+kSZMm3HPPPezdu5eIiAhCQkLYtWsXtWvXttnvgw8+yBdffEGHDh1o3LgxW7ZsYc6cOaxdu5bvv/+eOnXqZLt+5cqV9O3bl6SkJBo0aEDbtm05evQo69at48svv+Sll17itddey/d9DRs2jGnTpuHs7Ez79u2pUKEC27Zto0WLFgy2sWl5aGgo7u7urFu3jooVK2ZLgNWtWzfP8X766ScOHTqEZVkMHDgw33FmNXbsWCZOnIiTkxNt2rShatWq/PTTT8yZM4dFixaxZMkSunbtek1952bmzJm88cYbNG/enC5duvDrr7/y448/0rNnTxYtWkTv3r0BqFSpEoMGDWLt2rWcPHmSTp06UalSpcx+KlWqRKtWrXj++ef56quv+OOPP7jllltyjDdlyhQAhgwZgovLtSw8EhERKfpOzwrHydeXMr16OTqUEic/nx7+ArJ+2jsB9LviGgMoeSgiIlJcPPMM7Nljv/62boWkpOxlFy7AY4/Bxx/bZ4wmTeC99+zTl4PNnj2bkSNH8s477+B8+S/j06ZN46mnnmLUqFGcP3+e+fPn06dPHwDS0tLo168fCxcu5K233mLmzJk5+jx8+DCJiYns3r2b+vXrA3Dp0iUee+wx5s2bx4ABA9i2bVvm9SdOnGDAgAEkJSXxzjvv8Nxzz2XWRURE0LVrV15//XXatGlDp06d8rynVatWMW3aNHx8fPj666+54447AEhNTeXZZ5/lww8/zNFmzJgxtGzZknXr1lG3bt0Cn2q9c+dOAIKCgvD39y9QW4A1a9YwceJESpcuzZo1a2jXrl1m3eTJk3nhhRfo378/v/32GxUqVChw/7mZNGkSa9asyZYsff311xk3bhxjx47NTB5mPJMOHTpw8uRJxowZY3NG5pAhQ3j99deZNm0ab7/9dra6M2fOMH/+fFxdXRmSkdAXEREpYS799Rdnv/kG/yeewMnT09HhlDh5Lls2xgQaY4LyeNW8EcGKiIhIEXVl4jCv8iLiymWgV74ylovaW2BgIJMmTcpMHEJ6Asjf35+jR48SGhqamTgEcHJyYvTo9I2/169fn2u/48aNy0wcApQqVYoPP/wQHx8ftm/fzubNmzPrPv74Y86cOUPr1q2zJQ4hfTnx008/DZAjGZWb9y4ndp999tnMxCGAs7MzkydPpkqVKvnqpyBOnToFcM2JvXfeeQeAkSNHZkscAowaNYqWLVuSkJDAx/ZKgF/29NNP51hm/MILL+Dr68vBgwevuszcln/84x+4uLgwa9YsLl68mK1u9uzZnDt3jp49e1K5cuXrjl1ERKQoOj17Dri4UFYrXgqF3dctWJa1D+hijDli775FRETETuw9gy8wMH2p8pVq1ICICPuOZUdXLgO9UsZyUXsLCQmhVKlS2cqcnZ0JDAwkNjbW5v51t956KwDHjh3Ltd9HHnkkR1mZMmXo3r078+fPJyIigtatWwNkJkYHDRpks69HH32Ut956i02bNpGampot0XmllJSUzMSkrRjc3Nzo06cP77//fq593GhZYw4LC7N5zeDBg9m6dSsRERH861//stvY3bp1y1FWqlQpatasye7duzl27BjVq1fPd39Vq1bl/vvvZ9GiRXz++efZ7mfatGlA+pJyERGRkig1IYH4pUvx7doV14r2Wykg/68wNj0JBFwLoV8REREpqt54I/uehwCenunlRVhuy0AzZCwXtbdq1arZLPfy8sq1PqMuKZfZnGXKlKFMmTI26wIDAwE4evRoZll0dDRAroeMBAYG4uTkxMWLF4mNjb3q7L6YmBiSkpJwcnKiRo0aV43BnsqXLw/A33//XeC2sbGxecZcs2b64pqMZ2UvuSUGfXx8AHLMHsyPESNGsGjRIqZOnZqZPFy/fj2RkZE0aNCA9u3bX3O8IiIiRVncwkWYxET8wmz/QVSun05bFhERkevXvz/MmJE+09Cy0r/OmHHTHpaSlpZ21Xonp6t/BMur3p6udmpwURccHAzAoUOHiI2NzePq3Nn7GVzvz/9atG7dmqZNm7J9+/bMvSAzDkp56qmn7D6eiIhIUWAuXSJu3jxK39kK93wctibXRslDERERsY/+/SEqCtLS0r+W4MRhxpLjc+fO2aw/bGsJdyGLj48nISHBZl1UVBSQvrw1Q8b3f/75Z65t0tLScHd3x8/P76pjlytXDjc3N9LS0nLdry8jBntq1KgRgYGBGGOYM2dOgdr6+/tnxpxbbBnPJutzA3B1TV9kY+vnn5yczPHjxwsUi71k7FM5ZcoUjh07xooVK/D29mbAgAEOiUdERKSwnfnyS1L+/hu/wYPzvliumZKHIiIiIgWUkUz65ZdfctQlJiYS4aB9HufPn5+jLCEhgS+++AIg2xLtjGWsuSXdZs2aBUCbNm1wcbn6TjcuLi7ceeeducZw6dIllixZYrNtRiI2JSXlqmPYYlkWY8eOBWDChAkcOnToqtefO3eO3bt3Z8acsf9jbs8g4/TnK5e2X+3n/9VXX13TvVxNfp/Rww8/jL+/P59//jkTJ04kJSWFgQMH4u3tbdd4REREigJjDLGzwilV6xZKt2lTqGNtTzjPW38e52xKaqGOU1QpeSgiIiJSQB07dgRg7ty5/Prrr5nliYmJDB06tMCn5drLhAkTiIyMzHyfnJzMyJEjSUhIIDg4mDZZPlg/8cQTeHt7s2nTJj744INs/Xz//fd8+OGHAPzzn//M19gjRowA4D//+Q87duzILE9LS2P06NG57huYkYg7ePDgNSXdnnjiCXr16kV8fDxt2rRh1apVOa5JTU1l2bJlBAcHZztBO+OU6ffeey/bSdQZ9/HDDz/g6+vL448/nq0u4+c/YcIELl26lFn+888/Z87+s6eMZ5T1Z2uLu7s7TzzxBImJiZk/Py1ZFhGRkurC1q0k/fIL/mFhhb4Ny3//OsnsYzE4F+PtXq5HYRyYIiIiIlKitWnThm7duvHFF19w++2307ZtW1xcXNixYwdOTk4MHjw4c+bejVK9enWCg4Np0qQJd911F76+vmzZsoUjR45Qrly5HLPrKlWqxNy5c3nwwQcZOXIkn3zyCQ0bNuTYsWNs3LiRtLQ0XnrpJZsnP9vSs2dPhgwZwowZM2jVqhXt27enQoUKbNu2jejoaIYOHZp58m9WNWrUoGnTpuzevZtGjRoRHByMm5sbderUYdSoUXmOa1kWCxcuZMSIEXz00Uf06NGDKlWqEBwcjLe3N7GxsWzbto24uDjc3NyyHRDTtWtXRo8ezVtvvUW7du1o27YtVapUYd++fezfvx93d3fmzZtHxYoVs405duxYFi9ezKpVq6hTpw7BwcGcOHGC7du307dvX9LS0uy6dL1Xr16Eh4czatQovv7668zDa0aNGkWdOnWyXfvUU08xefJkUlNT6dChA/Xr17dbHCIiIkVJ7KxZOPv749O9e6GO88eFi3wVc4ZnalTE0/nmnIN3XXdtWZatU5WfBOx/LKGIiIhIEbJ48WLGjBlDhQoV+O6779i1axddu3Zl165duZ6mW5gsy2LRokWMGzeOP//8k+XLl3Px4kUeeeQRtm/fbjOJdN9997Fjxw4eeeQRYmNjWbJkCfv27ePee+9l9erVvPbaawWKYfr06cyYMYOGDRuyadMm1q5dS7169fjhhx+44447cm23dOlS+vbty+nTp/nss8+YOXMmq1evzve4rq6uTJs2jd27dzN8+HD8/Pz4/vvvWbRoETt27KBhw4a8/vrrHDx4kPvuuy9b24kTJ7Jq1Sruuece9u3bx5IlS4iLi2PAgAHs3LmTbt265RjvlltuYfPmzfTo0YP4+HhWr15NQkICkydPLvDei/nRo0cPpk6dSt26dfnmm2+YOXMmM2fOtLm3YkBAAHUvbxg/bNgwu8ciIiJSFCQdPMj57zdStn8/nNzcCnWsGUdO4WpZDK5arlDHKcosY0z+LrSsEUC0MeZ/l9/PBAYBfwA9jDG/Xq19UdGsWTOTdSmNiIhISRQZGUm9evUcHYaI3GB79+6lSZMmVKlShcOHD+e5X6XkTb9PRUSKnuPjxpGwchW11n+HSx4Hu12P08kpBG/5mZ4Vy/Ju3Rv/x+EbybKsncaYZrbqCjLzcARw6nKH7YC+QD9gD/DO9QYpIiIiIiLX5+WXXwbS96BU4lBEREqilJgYElasxLdnz0JNHALMjo4hMc3wZED5Qh2nqCvIJ4qqQMYRdt2BxcaYRZZl7QM22j0yERERERHJ08qVK1mxYgX79u1j+/btBAYGMnz4cEeHJSIiUijiPvscc+kSfoMGFeo4SWlpfBodQ4ifN3VLexTqWEVdQWYengEqXP7+HuDby98nA+72DEpERERERPJn165dfPrpp/zyyy+Ehoaydu1aSpcu7eiwRERE7C7t4kXiFizAq0MH3GoG5d3gOiw9GcepSyn8I6BC3heXcAWZefgV8LFlWbuAWsCXl8sb8P8zEkVERERE5AYaP34848ePd3QYIiIihS5hxUpS4+LwGzy4UMcxxvDRkVPUK+1Ou7JehTpWcVCQmYfDgM1AeaC3Meb05fLbgc/sHZiIiIiIiIiIiAiASUvjdHg47vXr43lH80Ida0PcWX45f5EnA8pjWVahjlUc5HvmoTHmDPC0jfJX7BqRiIiIiIiIiIhIFue+/55Lhw5RZfLkQk/oTf/rFBVKudCrYtlCHae4KMjMQyzLqmhZ1vOWZU2zLKvc5bLWlmUV7kJzERERERERERG5aZ2eFY5LpUr4hHYq1HEizyUSEXeWx6qWx82pQGmzEivfT8GyrGDgV6A/8Bjgc7nqHuAN+4cmIiIiIiIiIiI3u4sHDnDhxx/xG/AIlqtroY41/cgpPJycGFjVv1DHKU4KkkJ9G3jfGNMUSMpSvg5obdeoREREREREREREgNjwcJw8PSnTp0+hjnMyKZmlJ+N4sLIfZV0LcsZwyVaQ5GEwMNtG+XGgon3CERERERERERERSZd84gRn1nyJb+8HcPbxybvBdZgVHUOKMTxZrXyhjlPcFCR5mAjY2imyLvC3fcIRERERERERERFJFzdvHqSl4TdwYKGOcz41ldnRMYSW8yXI061QxypuCpI8XAG8YllWxhM0lmUFAm8B/7NzXCIiIiIiIiIichNLO3+euIWL8L73XkpVq1aoYy0+EUdcSipPBmjW4ZUKkjx8HvADTgGewCbgIBAPvGT/0ERERERERERE5GYV/7+lpJ09i//gsEIdJ80YZhw5RRNvT1r4li7UsYqjfO/+aIw583/s3Xd4zef7wPH3k8iOhCwjA6Fm1RaKitqj1N6EryKC9tvWD52qrZaiqlZpCKpW1apWB9KaNastqbZm7EgQEZnn+f2R8U1kyOGcnOB+Xde5cs7zeT6f+/6c4+p1ep9nAE2VUs8CdUkrPB7WWv9kruSEEEIIIYQQQgghxONHp6YSs2wZDnXq4FCrlllj/XAtllN3EllQvRxKKbPGehgZM/IQAK31dq31dK31NOBnM+QkhBBCCGFW5cuXRylFeHi4basBKQAAIABJREFUpVOxiEmTJqGUYtKkSSa5XmBg4AO9n2fOnGH8+PE0aNAADw8PbGxscHNzIyAggPHjx3P8+HGT5CmEEEKIh8etH38i+fx53Mw86hBgQeRVvO1s6ORZwuyxHkYFLh4qpcYqpbpneR0K3FFKnVBKVTFLdkIIIYQQ4pH23nvvUblyZaZNm8apU6eoX78+vXr1olGjRpw5c4Zp06ZRs2ZNPv30U0unarSgoCCUUoSFhVk6FSGEEOKhExMWho2vL8VbtjRrnCOx8ey7eZsXfDwpZiWjDnNT4GnLwFhgKIBS6hmgF9AP6A7MADqZPDshhBBCCGFyo0ePpk+fPnh4eFg0j3HjxjF9+nRcXFxYtGgRAwcOxMrqf79ta6358ccfmThxIidPnrRgpkIIIYQoTPFHjnDnt98o9frrKGtrs8b6LPIqxa2t6F/W3axxHmbGFA+9gdPpz58D1mqt1yil/gB2mjwzIYQQQghhFh4eHhYvHP70009Mnz4dGxsbfvjhBwICAnL0UUrRpk0bWrRowcGDBy2QpRBCCCEsIWZJGFYuLpTo1tWscc4nJLE56gYv+HhSvJh5i5QPM2PWPIwFvNKftwa2pT9PBuxNmZQQQgghhCVknWZ67NgxunfvjqenJ87OzjRt2pQdO3Zk9v3mm29o3rw5rq6uuLi40LlzZ/75558c1wwPD0cpRWBgILdv32bChAn4+/tjZ2eHr68vY8aMITo6Os+cIiMjefHFF6lSpQoODg64uLjQpEkTwsLC0Frn6J91/cFffvmFjh074uHhgZWVFRs2bADyXvMwOTmZ5cuX07dvX6pUqULx4sVxdHSkevXqjB8/npiYmPt8Z3N67733AAgODs61cJiVjY0NjRs3ztG+Z88eunfvTunSpbG1taV06dL06NGDffv25XqdjLUuz5w5k+vxvNZuzNp+6NAhOnfujLu7O/b29tSqVYvQ0NBs/c+cOYNSiqVLlwIwZMgQlFKZj7CwMHbu3IlSimrVquV539euXcPe3h4HB4d8/40IIYQQj5KkyEhu/fQTJXv3xsrJvDsff34+CoBhPp5mjfOwM6Z4+AOwSCn1OVAJ+C69vQb/G5EohBBCCPHQO3jwIA0bNuTvv/+mZcuWVKlShd27d9O2bVt27tzJp59+SpcuXdBa07ZtW9zc3Ni8eTPPPPNMnkWepKQkWrZsyZw5c3jyySd57rnnSEhIYM6cOTRu3JgrV67kOGfHjh3UrFmT2bNnYzAYaNeuHQEBAfz+++8MGTKEwYMH53kPa9eupUWLFpw7d47WrVvTsmVLbGxs8r3vK1euMGjQIL7//nvc3d3p0KEDzZs3JyoqimnTptGgQQOuXbtm3JuZi+vXr7NzZ9rElfzuIT/z58+nWbNmfP311/j5+dGjRw/8/PxYt24dTZo0YdGiRQ+c5922bt1K48aNOX36NG3atKFevXr8/vvvDBs2jBkzZmT2c3Z2ZvDgwVSsWBGAJk2aMHjw4MxHpUqVaNasGbVq1eKvv/5i+/btucb7/PPPSUxMpE+fPri7y1QqIYQQj4eYZcvB2pqSAwaYNc6tlFRWXIzmOc8S+NjbmjXWw86YacshwPuAH9BDa53x03NdYKWpExNCCCGEGX03AS7/YeksjFO6JrT/sFBCzZ07lxkzZvDyyy9nto0fP55p06YxbNgwLl++THh4OM2aNQMgISGBNm3asHPnTubNm8ebb76Z45p79+6lcuXKnDhxAm9vbwBu3bpF165d2bZtG2PGjGHNmjWZ/S9dukT37t2Ji4sjLCyMQYMGoVTaIt6RkZF07tyZ5cuX8+yzzxIUFJQj3rx58/jss88YPnx4ge/b1dWVTZs20a5du2yFxjt37hASEsKSJUt48803mT9/foGvmZsjR45gMBiwtbXlqaeeMvr8o0ePMnbsWADWrFlDz549M4+tWrWK/v37ExISQuPGjXnyyScfKNespk6dSmhoKEOHDs1s++KLLxg4cCCTJ08mODgYR0dHPDw8CAsLIygoiJMnTzJs2LBcP6MxY8YwbNgw5s2bx7PPPpvtmMFg4LPPPgMgJCTEZPcghBBCFGWpN29yY906XDu0x6aU171PeAArLkZzK9XASF/zxnkUFHjkodY6Vms9RmvdRWu9NUv721rrKeZJTwghhBCi8DVu3Dhb4RBgwoQJAPz999+EhIRkFg4B7O3t+e9//wuQbWrz3WbMmJFZOAQoXrw4CxYswNramnXr1hEZGZl5bNasWVy/fp1XXnmFwYMHZxYOAXx9fTNH1uW1C3Hr1q2NKhxm5PPcc8/lGKHo4ODAnDlzKFasGOvWrTPqmrmJikqbIuTm5kaxYsb8lp1m9uzZpKSk0KdPn2yFQyCzLTk5mU8++eSBc82qe/fu2QqHAAMGDKBatWrExsYavS5jv379cHNzY+PGjVy8eDHbsS1btnDmzBkaNGhA/fr1Hzh3IYQQ4mFwfc0adHw8bkOGmDVOikGz6HwUjVydqO3iaNZYjwLjv60BSqnSQLYxnVrrcybJSAghhBDmV0gj+B5W7dq1y9FWsmRJ3N3diY6OzvX4E088AZCjCJShRIkSdOrUKUd7pUqVaNSoEbt37+aXX36hf//+AHz77bcAOYpjGerVq4ezszO//fYbCQkJ2NtnX4K6W7du+dxh/o4cOcK2bds4c+YMt2/fzlxb0dbWlqioKK5fv07JkiXv+/oP6ueffwbIdTQfwNChQ1m9enWOtQsfVG6fH0DVqlWJiIjI87PPi4ODA8OGDWPatGksXLgw2xqU8+bNA2TUoRBCiMeHTkri+vIvcGzcCPuqVc0a65uoG1xITOb9J3zMGudRUeDioVLKFZgN9OKuwmE62ZZGCCGEEI8EH5/cv0g6OzsTHR2d63FnZ2cgbQpzbsqXL59nvPLly7N7927Onz+f2Xbq1CkAGjRocM98o6Ojs41oBChXrtw9z7tbXFwc/fv3Z9OmTfn2i42NfaDioadn2qLkMTExpKamYm1t3NfICxcuAFChQoVcj/v7+2frZyp+fn65tru4uAB5f/b5CQkJYcaMGSxatIg33niDYsWKcfLkycx1J3v37v1AOQshhBAPi9itW0m5epUy7042axytNQsio/B3sKONh4tZYz0qjBl5OB2oBTwPfA0MBbyBF4FXTJ+aEEIIIYRlWFnlv7LLvY6bQmpqKgC9e/fOMarwbnZ2djnaHBwcjI45ceJENm3aRPXq1fnwww+pX78+Hh4emdOYy5Yty6VLl3Ld5dkYderUwcrKiqSkJI4ePUrdunXv6zpZp3KbgsFgyPe4OT53Pz8/OnfuzPr169mwYQM9evRg/vz5aK0ZOnToPT97IYQQ4lGgtSZ6SRi2FSvilGVpGHP49eZtfrsVz4eVfbAy8XeJR5UxxcP2QF+t9U6lVCpwSGu9Wil1CRgBfGWWDIUQQgghHgFnzpy557Gsowd9fX35999/efPNN6lRo4aZs0uzdu1aAFavXp1jo5Hbt29z+fJlk8QpWbIkTZs25ZdffmHp0qVGFw+9vb05efIkp06dytzROKuMUZt3j8a0tU2bPBMXF5frdc+ePWtUHqYyZswY1q9fz7x58+jUqRNLlizBysqK4OBgi+QjhBBCFLb4X/eTGBFB6Xcno8z8I+1nkVGULGZNr9JuZo3zKDHmEykBZHyjugm4pz/fCzxtyqSEEEIIIR41N27cyFzHMKuTJ0+yb98+lFI888wzme3t27cH/lfQKwwxMTFAWuHybl9++eUDjzjM6rXXXgNg/vz57N+/P9++KSkp7Nu3L/N18+bNAVi2bFmu/ZcsWQJAYGBgtvaMYuJff/2V45w///wz24Y1ppBRrExJScm3X4sWLXjyySfZsWMHb7/9NjExMbRv3z7PadlCCCHEoyZmyRKs3dxw7dzZrHFOxSey9dpNBnt74Ght/pkkjwpj3qmTgH/68wigj0qbK9INiDF1YkIIIYQQj5pXXnmFS5cuZb6Oi4tj1KhRpKam0rVr12xr6o0bNw4XFxemTJnC3Llzcy1AHTt2jK+//tpk+VVNX5w8Y7OODAcPHmTixIkmiwPQtm1bXnrpJZKTk2ndujXLli3LMW1Ya8327dt5+umnWbVqVWb72LFjKVasGCtXrmT9+vXZzlm7di1r1qzBxsaGsWPHZjvWsmVLAKZNm0ZsbGxme2RkJEFBQSYtjsL/ipURERH37Dt69OjM3ABGjRpl0lyEEEKIoirx5Enifv6Zkv36YZXLUiymtPB8FDZKMdTbw6xxHjXGFA/DgKfSn39I2lTlJOAjYKpp0xJCCCGEeLQ0btwYFxcXKleuTJcuXejZsyf+/v788MMPVKxYkblz52br7+vry4YNGyhevDijR4/Gz8+P1q1b079/fzp27Iifnx9PPvkka9asMVmOb731FpA2KrB27dr07duX5s2bExAQQNu2be9rE5b8zJw5k0mTJhEfH8/gwYPx8vKiQ4cO9O/fn06dOlG2bFlatmzJ4cOHqVy5cuZ5tWrV4pNPPsFgMNCtWzcaNWpE//79CQgIoFevXgDMmTOHmjVrZosXEhKCr68vBw4coEqVKnTr1o1nn32WatWq4eLiwtNPm3YyTZcuXbCysmLWrFm0bduW//znPwwbNow9e/bk6Dtw4MDMTWj8/f1z3dFbCCGEeBTFLF2GsrOjZL++Zo1zPTmF1Zei6VqqJF52NmaN9agpcPFQa/2x1np2+vPtQFWgN1Bbaz2noNdRSo1RSq1RSkUopaKVUslKqSil1E9KqQEqj5WvlVJWSqkQpdRBpVScUuqmUmqnUsq8/7qEEEIIIUzA1taW7du3M2LECH7//Xc2bdqEra0tISEh7Nu3j9KlS+c4p0WLFhw7dozXXnsNLy8v9u3bx7p16zh27Bj+/v588MEHvP/++ybLsUePHuzYsYMWLVoQGRnJ5s2biY2NZdasWSxfvtxkcTIopXj77bc5ceIE48aNo1y5cuzbt4/Vq1eze/du/Pz8mDBhAsePH88xEm/UqFHs3LmTrl27cvr0adasWcOZM2fo1q0bu3btYvjw4TnilSxZkt27d9O/f39SUlLYsmUL58+fZ9y4cWzdujVzYxhTqV27NqtXr6ZBgwbs2bOHxYsXExoayt9//52jr6OjY2bxMjg4uFA25RFCCCEsLSUmhpsbN+LapQvF3My7BuGyC9HcMWhG+nqaNc6jSJl6esY9Ayp1HvAC/gQuALeBckAAoICNQDettSHLOdak7fDcGYgFtgF2QMv0v7O11i8WJH79+vX1wYMHTXY/QgghRFEUERFBtWrVLJ2GAMLDw2nRogXNmzcnPDzc0umIIurq1av4+vpibW3N+fPncTPz/0CJgpP/ngohhPlEzZnLtTlz8P92C3b+/vc+4T4lGgw02Huc6k4OrKqdc7M1AUqpQ1rr+rkdM+onTaXUKKXUMaVUvFLKP71tglKqlxGX6QOU1FrX1Vo/p7Xuo7VuDNQErgBdgMF3nfMSaYXD40BlrXU3rXXHLOeMVUp1MeZehBBCCCGEKCref/99kpKSGDx4sBQOhRBCPBYMCQlc//JLnJs3N2vhEGD9letcTUphpJ+MOrwfBS4eKqVeAt4AFpI2QjDDBWB0Qa+jtd6ltb6dS/sxIGOxn9ZZ4loD/5f+MlhrfSXLOf8A49Nfvl7QHIQQQgghhLC0PXv2MGzYMFq0aMHs2bNxdXXlzTfftHRaQgghRKG4uXkzqTExuA0ZYtY4Wms+i4yiqpM9zUsWN2usR5UxIw9HAi9orT8Bsm73dxioYaJ8Mq6bmKWtMWnTnM9rrX/J5Zy1QDLQQCnlbaI8hBBCCCGEMKu///6b0NBQ9u/fT9OmTdm6dStly5a1dFpCCCGE2WmDgZiwpdhVq4ZjQEOzxvrlehwRtxMY4etJHttsiHsoZkTfcqStU3i3ZMDhQRNRSlUgrUAJsCnLoTrpfw/kdp7WOl4pdQyonf648KC5CCGEEEKYSmBgIIW9xrR4OAQFBREUFGTpNIQQQohCd3vnTpJOnqTstKlmL+gtiLyKp20xupUqadY4jzJjioengLrA2bvaO5C2FqFRlFJDgOaADeADPE3aSMgpWuv1WbpWSP97d9yszpFWOKyQTx8hhBBCCCGEEEIIYWHRYWEUK1UKl/btzRonIu4OO2JuMb5CaeysjNr2Q2RhTPFwOjBHKeVI2pqHjZVSA0lbj3DofcRuQvaNUVKAN4GZd/VzTv+bY53ELOLS/+Y6eV0pNRwYDuDn52d0okIIIYQQQgghhBDiwSVERBC/dx9er76CsrExa6yF56NwsFIM9vYwa5xHXYHLrlrrJcAkYArgCCwHXgDGaq1XGxtYaz1Ma63Sr1UDmJV+/X1KKZMu9qK1Xqi1rq+1ru/pKTvrCCGEEEIIIYQQQlhCTFgYytGREj17mjXO1cRk1l2+Tq/SbrjZGDN2TtzNqDGbWutFWutypG1gUlpr7aO1Dn2QBLTWd7TWx7XW44CJQC1gTpYuGaMKnfK5TMboxFsPkosQQgghhBBCCCGEMI/kK1e4ueVbSnTvjrWrq1ljLblwjWStGe4rg8geVIGLh0opK6WUFYDW+hpgpZQappR62oT5hKX/fU4plTF29Uz633L5nOd7V18hhBBCCCGEEEIIUYRc/2IFGAy4DRpo1jjxqQaWXrxGGw8XKjramzXW48CYkYdbgDEASiln4CDwEfCzUmqQifK5Ttrah8UAt/S2w+l/G+R2QvoajE+mvzxiojyEEEIIIYQQQgghhIkYbt/m+urVFG/VCltf33uf8ADWXo4hJjmVkb5eZo3zuDCmeFgf2J7+vBsQS9r05ReAV02UzzOkFQ5vANfS2/YCUYCPUuqZXM7pSdqOzQe01hdMlIcQQgghhBBCCCGEMJEbX6/HEBuL25Ags8YxaM3CyChqFXegkWt+K+CJgjKmeOhMWlEPoA2wXmudTFpBsWJBLqCUaqqU6qSUyrFSpVKqCZCxfmKo1joVIP3vtPT2+UopryznPAF8mP7yfSPuRQghhBBCCCGEEEIUAp2aSsyyZTjUro1jnTpmjfVTdCwn7yQy0tcLpZRZYz0ujNlu5hzQRCm1GWhL2og/SJteHF/Aa1QClgA3lFKHgctAcdKKj9XT+2wB3rzrvI9JG5X4HPCPUmobaaMNWwH2wKda641G3IsQQgghhBBCCCGEKAS3tm0jOTISr1dNNXE1b/Mjr+JtZ0MnzxJmj/W4MKZ4OBNYTtrux2eBX9LbnwH+KOA1fgbeBZoBTwBPA4q0IuI64Aut9Ya7T9JapyqlngdGAUNIK16mAoeAeVrrL424DyGEEEIIIYQQQghRSGKWhGHj40PxVi3NGuforXj23rjN2xXLYmMlow5NpcDTlrXWnwGNgaFAU621If3QSXKOFMzrGqe11m9prVtorf201g5aa3utdXmtdY/cCodZzjVoredoretprZ201i5a66ZSOBRCCCGEscqXL49SivDw8FyP//HHH5QpUwalFD169CApKQmASZMmoZRi0qRJhZdsIdq9ezfDhw+nWrVquLq6YmtrS+nSpWnVqhUzZszg6tWrlk5RCCGEEA+ZO7/9xp0jR3AbNAhlbW3WWJ9FRuFsbUX/su5mjfO4MWbNQ7TWB7XW67XWcVnatmitd5s+NSGEEEKIwvfrr7/SvHlzLl++zJAhQ1i9ejW2traWTsus4uLi6NmzJ02bNmXRokUkJiYSGBhIjx49qF69Onv37uXVV1+lYsWK/Prrr5ZO12gZxeIzZ85YOhUhhBDisRMdthSr4sUp0b2bWeNcSEhi49Xr9C/jjksx8xYpHzf5TltWSr1M2rTghPTnedJazzRpZkIIIYQQhWz79u106dKFuLg4XnrpJWbOnJltoe3Ro0fTp08fPDw8LJilaSUlJdG2bVv27NlD1apVWbhwIc2aNcvWJzExkaVLl/L2229z6dIlC2UqhBBCiIdN0vnz3PrhB9yHDsHKybw7H39+PgqAYb6eZo3zOLrXmodjgKVAQvrzvGjS1kQUQgghhHgobdq0iV69epGYmMjbb7+d69RkDw+PR6pwCDB58mT27NlD+fLl2b17N25ubjn62NnZMXz4cLp06cKNGzcskKUQQgghHkYxy5aBlRUlBwwwa5xbKal8cTGaTp4l8LV/tGeMWEK+05a11hW01tFZnuf18C+cdIUQQgghTG/FihV0796dpKQkZs2aleeahnmteRgWFoZSiqCgIG7dusW4ceOoUKECdnZ2eHt7ExwcTExMTK7X1FqzcOFC6tSpg4ODA56ennTr1o0//vgj23XvtmrVKp599lnc3NywsbHBw8ODmjVrEhISwsmTJwt037GxscyePRuAmTNn5lo4zKpUqVJUqVIlR/7Lly8nMDCQkiVLYm9vT8WKFQkJCSEyMjLHNc6cOYNSivLly+cZRymVbcRnbu2rV6+mcePGODs7U7x4cVq2bMmuXbuy9c94/86ePQtAhQoVMq+RMY353XffRSnFyJEj88xn8+bNKKVo2LBhnn2EEEIIkV1qbCw3v1qHS4f22JQubdZYKy9FcyvVwAgZdWgWRq15KIQQQgjxqJk/fz4DBw5Ea83ixYt58cUX7/taN2/epEmTJixevJjatWvTpk0b4uPjWbBgAa1btyY5OTnHOSNGjGDEiBH8+eefNGnShFatWvHHH38QEBDAwYMHc40zadIk+vbty65du3jqqafo2bMnDRs2JDU1lXnz5nHgwIEC5btjxw5u3bpFiRIl6Ny5s9H3q7VmwIABDBo0iD179tCgQQOef/55tNbMmzeP2rVrFzgXY7z11lv069cPW1tbOnbsiI+PD9u3b6dly5bs3bs3s1+lSpUYPHgwTunTpLp3787gwYMzH87OzgwfPhxbW1tWrFhBbGxsrvHmzp0LQEhIiMnvRQghhHhU3Vi7FkN8PO65/AhqSikGzcLzUQS4OlHXxbxTox9X95q2DIBK+4l3ENAd8CdtmvIpYC2wQmutzZahEEIIIUxu6v6p/BXzl6XTMEpVt6qMbzjepNecNWsWGzduxNbWlpUrV9Kt24Mt5L1hwwY6dOjAnj17cHZ2BuDixYs0atSIw4cPs2bNGvr375+t/6JFiyhRogTbtm2jbt26ABgMBsaPH8/06dNzxEhMTGTatGk4Oztz6NAhKleunO34P//8Q7FiBfqKx6FDhwCoW7cu1vex++H8+fP58ssvKVWqFNu2baNGjRoApKam8t///pdPP/2Unj17cuLECezs7Iy+fl7mzp3L/v37qVevHpD2fo0cOZJFixbx1ltv8eOPPwLQtGlTmjZtSnh4OLdv32b69Om5jnjs1asXX3zxBcuWLWP06NHZjv3777/88MMPuLu707t3b5PdgxBCCPEo08nJxCz/AseAAOyrVzdrrC3XbnA+IZl3K3mbNc7jrKAjD9cBS4BywB/AMaACsAz4yjypCSGEEEKY18aNGwF46aWXHrhwCODs7ExoaGhm4RCgbNmymQWpbdu2ZeufMWX4lVdeySwcAlhZWTFlyhR8fHxyxIiNjeXOnTtUrFgxR+EQ4IknnqBChQoFyjcqKm1hcS8vrwL1v9uMGTMAePfddzMLhwDW1tZMnz4dPz8/zp49y1dfmfbr4jvvvJNZOIS09+vdd98FYOfOnbmO8MzPmDFpS3vPnz8/x7H58+ejtWbo0KHY29s/QNZCCCHE4yN26/ekXL6M25Ags8bRWrPgXBQVHGxp4+Fq1liPs3v+LK2U6g+0AdpprX+461hbYJ1Sqp/W+ksz5SiEEEIIEzP1CL6HVfPmzfn555+ZMWMG9erVo1evXg90vXr16lE6lzV9qlatCqSNQsyQkpLCnj17AOjXr1+Oc2xsbOjRowezZs3K1u7p6Un58uU5evQor7zyCi+88ELm9QvT+fPnOXXqFFZWVgwcODDHcVtbW/r3788HH3xAeHh4thGXD6pTp0452kqVKkXJkiW5fv060dHRuX4OeWnYsCENGzZk//79hIeHExgYCMCdO3cICwvDysqK4OBgU6UvhBBCPNK01sQsWYKtvz/Ozzxj1lgHbt7myK14pjzhjXUu6yUL0yjIyMMBwNS7C4cAWuvvgY/S+wghhBBCPFQmTZrEq6++SmpqKv3792fNmjUPdD0/P79c211cXABISEjIbLt27RqJiYlYWVnh6+ub63nlypXLtX3ZsmV4eXkxc+ZMqlWrhpeXF507d2bu3LncvHmzwPl6eqYtKn716tUCn5PhwoULAJQpUybPEXn+/v7Z+pqKMe9zQY0dOxaAefPmZbatWrWKmJgY2rdvX+DRnEIIIcTjLn7/ARKOH8dt8GCUlXm32lgQGUWJYtb0LpP/pm/iwRTkU6wFfJvP8S1AbdOkI4QQQghRuD766CNeffVVUlJSHriAaHWfX5Bz21k4v+s1a9aM06dPs3r1aoKDgylbtizffPMNo0ePplKlShw5cqRAcTOm/h4+fJjU1FST5n6/DAbDPfvc7/ucn549e1KqVCk2bNjApUuXgP8VEkeNGmXyeEIIIcSjKiYsDGs3N1y7GL8ZmzHO3Enku2s3GeztgdN9rN0sCq4g37zcgUv5HL8ESIlXCCGEEA+tuwuIa9euNXtMd3d3bG1tMRgMREZG5trnzJkzeZ7v6OhIr169mDdvHr/99hsXLlygd+/eXLt2rcC7Ardo0QJnZ2du3LjBpk2bjMrf2zttUfKLFy+SmJiYa59Tp05l6wtp05kB4uLicj3n7NmzRuVhKra2towYMYLk5GQWLVrE/v37OXjwIP7+/rRr184iOQkhhBAPm8RTp4nbsYOSfftiZea1ghdGRlFMKYZ4e5g1jihY8dAGyG/V6ZT0PkIIIYQQD62sBcR+/fqZvYBoY2ND48aNAVi5cmWO48nJyaxbt67A1ytTpgzvv/8+AEePHi3QOS4uLpmbhbyD7JC1AAAgAElEQVTyyivExMTk2//q1aucOHECAB8fH/z9/TEYDHzxxRe55r9ixQqAzDUEIW2qtK2tLdHR0ZkbtmT17bf5TXi5PxkFy5SUlHz7jRw5EhsbGxYuXJi5mU1wcLBZRjoKIYQQj6KYpUtRtraU7NfXrHGuJ6ew8lIMXUuVoLSdlKTMraDfhD5QSs3O7QG8b84EhRBCCCEKy90FRFPvEny3jMLd9OnT+e233zLbDQYDb7zxBufOnctxztmzZ/n888+JjY3NcWzz5s1A3msl5ubtt98mICCA06dP07RpU3bt2pWjT1JSEosXL6ZOnTpERERktr/88ssAvPnmm/z111+Z7ampqfzf//0f586do1y5cvTo0SPzmI2NDc2aNcuMrbXOPLZr1y7eeuutAudeUBkjH7PmnpsyZcrQvXt3Lly4wIoVK7C3t2fo0KEmz0cIIYR4FKXExHBzwwZcu3SmmLu7WWMtvxjNHYOBkb5eZo0j0txzt2XgF6BiAfoIIYQQQjz0PvroIyCtoNe3b9qv5lmLX6bUvXt3hg4dyuLFi2nQoAGBgYF4enpy8OBBIiMjCQ4OZv78+Zkj5wCuX7/OCy+8QEhICLVr16ZChQoYDAaOHz/OsWPHsLGxYdq0aQXOwc7Ojh9//JFBgwaxYcMGmjVrhr+/PzVr1sTR0ZErV66wf/9+4uLicHFxoWzZspnnjho1it27d7Ny5Upq1apFYGAgbm5u7N+/n1OnTlGyZEnWrl2LnZ1dtpiTJ09m586dzJ8/n/DwcGrUqMHZs2c5dOgQr732Gu+9996Dv7lZdO3aNXPH5zZt2lCiRAkApk6divtd/3MzduxYVq1aBUCfPn1wc5PVeYQQQoiCuL5qFToxEbegILPGSTIYCD0fRfOSxanu7GDWWCLNPYuHWuvAQshDCCGEEKLIKMwC4qJFi2jQoAELFixg586dODk50bRpU9auXZs5ktDD439r+VSsWJGPP/6Y8PBwjh07xrFjx7CyssLb25vhw4fz4osvUr16daNyKF68OOvXr2fnzp0sXbqUnTt3sn37dhISEnBzc6NRo0Z07NiRgQMHZiu2KaVYsWIF7du3Z9GiRfz666/cuXOHsmXLEhwczMSJE3PdSfrpp59m27ZtTJo0iV9//ZWzZ89So0YNli1bRv/+/U1ePBw9ejSxsbGsWLGCb775JnONxjfeeCNH8bBhw4a4uLgQGxtb4LUjhRBCiMedITGR6yu+xKn5M9hVvNf4swez4eoNriSl8HFVT7PGEf+jsk4VybejUraAldY64a52e8CgtU4yQ34mV79+fX3w4EFLpyGEEEKYVUREBNWqVbN0GuIBtWrVim3btvHVV1/RvXt3S6fzWNi4cSPPP/88DRs25Ndff7V0OqIIkP+eCiHEvd346isuvfEmfksW45S+prM5aK1peeAEqUB4gyoopcwW63GjlDqkta6f2zFjVn9eC4zKpX0ksOZ+EhNCCCGEeNwdO3aM+Pj4bG3Jycm89957bNu2DU9PTzp06GCh7B4vKSkpvPvuu8D/1nMUQgghRP601kSHhWFXtSqOjRqZNdau63Ecv53ACF9PKRwWooKseZihCfB6Lu0/Aq+ZJh0hhBBCiMfLBx98wPr166lbty7e3t7cuHGDP/74g4sXL2JnZ0dYWBgODrKejzktWbKEX375hf3793P8+HECAgLo1auXpdMSQgghHgq3d+0i6d+TlJ36odkLevMjr+JhU4xuXiXNGkdkZ0zx0BFIyaXdABQ3TTpCCCGEEI+Xvn37EhcXx+HDhzl8+DApKSmUKVOGQYMG8eqrr1KzZk1Lp/jI+/nnn1m6dCklS5akV69ezJo1S0YzCCGEEAUUs2QJxby8cGnf3qxxTtxOYHvMLf6vQmnsrY2ZSCselDHFw9+BvsDbd7X3A/40WUZCCCGEEI+Rjh070rFjR0un8VgLCwsjLCzM0mkIIYQQD52Ev/7i9p69eL78MsrW1qyxPou8ir2VYnBZj3t3FiZlTPFwMrBRKVUJ2J7e1hLoCXQ1dWJCCCGEEEIIIYQQouiKCVuKcnSkZG/zLvcRlZTMuivX6V3aDXdbY0pZwhQKPM5Ta/0t8BxQDpid/vADOmutvzFPekIIIYQQQgghhBCiqEm+cpWbW7ZQols3rF1dzRpryYVrJBo0w309zRpH5M6ocq3Weiuw1Uy5CCGEEEIIIYQQQoiHwPUVKyAlBbdBA80a506qgbAL12jj7kIlR3uzxhK5kxUmhRBCCCGEEEIIIUSBGeLjub56NcVbtcLWz8+ssb66EkNMciojfb3MGkfkLd+Rh0qpWMBfa31NKXUL0Hn11Vq7mDo5IYQQQgghhBBCCFG03Fi/HsPNm7gNGWLWOAat+SwyiqecHWhcwsmssUTe7jVteQxwK/35aDPnIoQQQgghhBBCCCGKMJ2aSszSZdjXegqHOrXNGuun6Fj+jU9kXvVyKKXMGkvkLd/iodZ6aW7PhRBCCCGEEEIIIcTjJ27HDpLPncPr5f+avaD3WWQUZe1seM6zhFnjiPzJmodCCCGEEEIIIYQQokCil4Rh4+1N8VatzBrnj1vx7L4Rx398PLGxklGHlnSvNQ/zXecwK1nzUAghhBBCCCGEEOLRdee337hz6BClXpuIKnavlfAezILIKJysrRhQxs2sccS93euTlnUOhRBCCCGEEEIIIR5ziSdPcn7si1i7u+ParbtZY11MSGLj1esM9fbE1ca8RUpxb/lOW9ZaLy3oo7ASFkIIIYR4UOXLl0cphVKKCRMm5Nt3wIABmX0DAwMLJ0EgLCwMpRRBQUGFFhMgMTGRhQsX0qlTJ3x8fLC3t8fJyYknnniCfv36sX79egwGQ6HmJIQQQgjLSoiI4OzAQWiDAb8li7F2Nu/Ox6EXrmHQMMzHw6xxRMEYveahUupZpdRopVSIUirQDDkJIYQQQhSa5cuXk5qamuux2NhYvv7660LOyHL2799P5cqVGTFiBN9//z0+Pj506dKFdu3a4ejoyMqVK+nWrRsBAQGWTtVo4eHhhV4AFkIIIR4Fd44e5ezgIJSdHeW/WI595cpmjReXksryi9fo6FkCPwc7s8YSBVPgsZ9KKW9gPVAPuJjeXFYpdRDoqrW+mOfJQgghhBBFUP369Tl48CA//vgj7dq1y3F81apV3LlzhwYNGnDgwIFCza1r1640atQIV1fXQol38OBBmjdvTkJCAkOHDuWDDz7Ay8srW59z584xZcoU1qxZUyg5CSGEEMKy4g8cIHLESKw9PCi3ZDE23t5mj7nyUgyxKQaCfT3NHksUjDEjD2cDqUAlrbWv1toXeCK9bbY5khNCCCGEMKeMKcFhYWG5Hg8LC8Pa2pqBAwcWXlLpXF1dqVq1KmXKlDF7rOTkZHr16kVCQgJjx44lNDQ0R+EQwM/PjwULFrBhwwaz5ySEEEIIy4rbuYtzLwynWJkylFu+vFAKh6las/B8FA1dnajrat6p0aLgjCketgZCtNanMxq01qeAsenHhBBCCCEeKgEBAVSrVo2NGzdy48aNbMdOnDjB3r17adu2bb4FvJ9++omQkBBq1aqFu7s7dnZ2lCtXjsGDBxMREZHrOUFBQSilCAsL4/fff6dnz56ULl0aa2trZs2aBeS95mHW6bfJycm8//77VK1aFXt7e7y8vBgwYADnzp0z6n1YsWIFp0+fxsvLi2nTpt2z/zPPPJOj7dq1a4wfP56qVavi4OCAi4sLjRo1Yt68eaSkpOToP2nSJJRSTJo0KdcYed1/1vZbt24xbtw4KlSogJ2dHd7e3gQHBxMTE5PtnMDAQFq0aAHAzz//nLmGZcb7qLXmiSeeQCnFvn378rzv7t27o5Ri3rx593iHhBBCiIfbrW3bOD9qFLYVKlBu+TJsSuX8UdEcvo26SWRCEiNk1GGRYuyah7qAbUIIIYQQD4UhQ4aQkJDAypUrs7VnjEYcMmRIvuePHDmS0NBQihUrxjPPPEOHDh2wtbVl2bJl1K9fn127duV57u7du2nYsCGHDx8mMDAwc23BgkhOTqZ9+/Z8+OGHVKpUifbt22NlZcWKFSto2rRpjmJofjZu3AhA7969sbMzfm2hf//9l7p16zJt2jRu3rzJc889xzPPPMMff/xBSEgI7du3JzEx0ejr5ufmzZs0adKExYsXU7t2bdq0aUN8fDwLFiygdevWJCcnZ/Zt164dbdu2BaBUqVIMHjw489GuXTuUUoSEhADkWRi8cOECmzZtonjx4hYZiSqEEEIUlpvfbOH82Bexq16NcmFLKObmVmixF0RepbyDLe08CmfZFlEwxux3vQ34VCnVV2sdCaCU8gNmpR8TQgghxEPi8pQpJEb8Zek0jGJXrSqlX3vN5NcdOHAgEydOJCwsjODgYABSU1NZtmwZbm5udO7cmU2bNuV5/vTp0wkMDKREiRKZbVprFi5cyMiRIxk+fDjHjh1DKZXj3M8//5zXX3+dyZMnY2Vl3G+6e/bsoX79+pw8eTJzivHNmzd59tlnOXz4MHPnzuX1118v0LUOHToEQIMGDYzKIUO/fv2IjIykZ8+eLFu2DHt7ewAiIyNp1aoVP/30E5MmTeKDDz64r+vnZsOGDXTo0IE9e/bg7OwMwMWLF2nUqBGHDx9mzZo19O/fH4AJEybQqFEjvv/+e6pWrZrrNPUhQ4bwxhtvsHbtWj7++GPc3d2zHf/ss89ISUlh0KBBFC9e3GT3IYQQQhQlN9at49Ibb+JYrx4+CxaYfVflrA7cvM2h2Hjef8Ib61y+NwnLMeZb6ljACTillDqrlDoLnExvG2uO5IQQQgghzK106dK0a9eO/fv3Z04z/uGHH7h48SL9+vXD1tY23/Off/75bIVDAKUUI0aM4OmnnyYiIoLjx4/nem7VqlV55513jC4cZsRYvHhxtrUJXV1dGT9+PADbthX8t92oqCiAXNc5vJedO3dy4MABihcvzoIFCzILhwC+vr588sknAMydO5eEhASjr58XZ2dnQkNDMwuHAGXLlmX06NGAcfcPae/doEGDSEhIIDQ0NNux5ORkFi1aBMCoUaMeMHMhhBCiaIpZ/gWXXn8DpyZN8F20sFALh5A26rBEMWv6lCm8kY6iYAo88lBrHamUqgu0AqqmN0dorX8yS2ZCCCGEMBtzjOB7mAUFBbFlyxbCwsKYOnVq5si0u9fby8v58+fZsmULf/31F7GxsaSmpgJw+fJlAP7++29q1KiR47wuXbpgbW19Xzn7+flRs2bNHO1Vq6Z9Tbt48eJ9XddYP//8MwDPPfccbrlMa2rXrh1lypTh0qVLHDp0iCZNmpgkbr169ShdunSO9ge5/9GjRzN//nw+++wzXn311cyi7tdff83ly5cJDAykevXqD5a4EEIIUQRdW7SIqBkzcW7VEu+ZM7G6x4+npnb2TiLfRd0kxM8Lp/v8biTMx5hpy2itNfBj+kMIIYQQ4pHQuXNn3N3dWb58OePGjWPjxo3UrFmTevXq3fPct99+mylTpuS6KUiG2NjYXNvLlSt33zn7+fnl2u7i4gJg1Cg/T09PIiMjuXr1qtF5XLhwAYAKFSrk2cff359Lly5l9jUFU95/hurVq2dOs966dSsdOnQA/rcOYsa6iEIIIcSjQmtN1OzZRM9fgEvHjpT98AOUjU2h57EwMgprpfiPj2yUUhQZNUdGKfW8UuoXpdS19MdOpVRXcyUnhBBCCFEYbG1t6devH5cuXWLIkCEkJibec6MUgHXr1jF58mQcHBxYtGgRJ0+eJD4+Hq01Wmv69u0LpH0xz42Dg8N953w/U53zklEkPXDgwH1fI7c1HR+EwWDI97gp7z+rMWPGAP8rGP7555/88ssvlC1blueff94sMYUQQghL0Fpz9cOpRM9fgGuP7pSdNtUihcMbySmsvBzD86VKUNqu8OOLeyvwty6l1CvAauAE8H/pj7+AL5VSr5onPSGEEEKIwpExRfmbb76hWLFimZtt5Gft2rUATJkyhWHDhuHv75+tIPjvv/+aJVdT69y5MwCrV682eldkb29vAE6dOpVnn4xjGX2BzLUk4+Licj3n7NmzRuVhKp06daJChQp89913nDlzJrOIOHz4cIoVM2rSjhBCCFFkaYOBy5PeIWbpUkoOGECZyZNRFpouvPxiNPGpBkb6Gr/2sigcxvxk+yowWmv9gtZ6cfrjBdI2S3nFPOkJIYQQQhSOunXr0qRJE9zd3enZs2eBNg+JiYkB0jYGuVtERARHjhwxeZ7m0L9/f8qVK8fVq1czN1zJz86dOzOfN2/eHIDNmzdz/fr1HH2///57Ll26hLOzc7Zp4BmFxL/+yrnrt9aarVu3Gn0f+ckoVuY3vRzSRjSOGjUKg8HARx99xBdffIGNjQ3Dhw83aT5CCCGEpeiUFC5NnMiN1atxf+EFSr3+GspMI/rvJclgIPT8NZqVdKaG8/3PyBDmZcy/DmdgRy7tO9KPCSGEEEI81Hbt2sW1a9f48ssvC9Q/Y3OORYsWkZSUlNl+9epVBg8efM9CVVFha2vL6tWrsbOz45NPPmHYsGG5rn944cIFRo8enW36brNmzWjQoAG3bt0iJCQk28jFCxcu8NJLLwFpm5Fk3Ym5RYsWWFlZsXXrVnbv3p3Znpqayuuvv87+/ftNeo8Zxcp///33np/Lf/7zHxwdHZk3bx63bt3i+eefp0yZMibNRwghhLAEnZTEhZdf4ebGTXi+9CJer7xs8qVHjLHp6g0uJyXLqMMizpji4QagRy7t3YFNpklHCCGEEOLh8dJLL+Hq6sqWLVuoVKkSPXv2pFOnTlSsWJG4uLiHao28gIAAduzYgY+PD6GhoXh7e/P000/Tp08fevToQZ06dfD19WXu3LlUrlw527lffvklPj4+rFy5kgoVKtC7d2+ee+45qlSpwl9//UXLli2ZNGlStnP8/PwIDg4mNTWVFi1a0LJlS7p27Yq/vz9z5sxh7NixJr2/cuXKUadOHa5cucJTTz3FwIEDGTZsGB999FGOviVLlmTAgAGZr2WjFCGEEI8CQ0ICkWPGcOuHHyg1cQIeI0daNB+tNQsio6jsaM+zbsUtmovIX77FQ6XUyxkP4F9gglLqe6XUpPTHVmAiaesgCiGEEEI8Vvz9/Tly5Ah9+vRBa83mzZuJiIhg+PDh7N27F1dXV0unaJTGjRvzzz//MH/+fFq3bs3Zs2dZv3493377LXFxcfTr14/NmzezZ8+ebOdVqlSJI0eOMG7cOIoXL87GjRsJDw+nRo0azJkzh++++w47O7sc8WbPns3UqVPx9/dn165d7Nq1i4CAAA4ePEidOnVMfn9ff/01vXr1IiYmhpUrVxIaGsqWLVty7du6dWsAatSokTk1WwghhHhYGW7fJnJkMLd/2Unpd97BbfBgS6fE7htx/Bl3hxG+nhYd/SjuTeW1+x+AUup0Aa+jtdb+pknJvOrXr68PHjxo6TSEEEIIs4qIiKBatWqWTkOIh1bXrl3ZsGED8+bNIzg42NLpCAuS/54KIR52qbduETl8BHeOHqXshx/gmr5RmqX1P3qKo7fiOdi4OvbWlllzUfyPUuqQ1rp+bsfy3TJOa13BPCkJIYQQQghRNB06dIhNmzbh7u7OoEGDLJ2OEEIIcd9Srl8n8j/DSPjnH7w//hiXtm0snRIAf99OYFtMLOPKl5bC4UMg3+KhEEIIIYQQj4thw4YRFxfHt99+i8FgYPLkyTg5OVk6LSGEEOK+pERFcW7oUJLOnsN3zqc4F6FlOBZGRmFvpRjs7WHpVAok/MRVvth3lmk9auHmZGvpdAqdUcVDpVRl0jZN8QOyvVta66EmzEsIIYQQQohCFRoaipWVFeXKleOtt95i1KhRlk5JCCGEuC/Jly5xLmgIyVFR+C78DKdGjSydUqaopGTWXomhV2k3PGyL/pi2+KQU3tjwJ3bFrHCys7Z0OhZR4E9JKdURWAccAeoBB4CKgB2w0yzZCSGEEEIIUUjyWwtcCCGEeFgknTvHuaAhpMbG4vf55zjWNf0mZA9i6YVoEg2a4T6elk6lQD7Z9g/nr99h9fBG2BV7PIuHxkwsnwy8o7VuDCQCA4HywE9AuMkzE0IIIYQQQgghhBAFlnjyJGf7D8AQH4/f0rAiVzi8k2pgyYVrtHZ34Qkne0unc0/HL8by+c7T9KrvQ4C/u6XTsRhjiodVgNXpz5MBR611AmlFxZdMnZgQQgghhBBCCCGEKJiEiAjODhyE1hq/ZUtxqFHD0inlsO7KdaKTUxjhW/RHHaYaNBPX/0EJBxte61DN0ulYlDHFw1tARln4ElAp/XkxoKQpkxJCCCGEEEIIIYQQBXPn6FHODg5C2dlR/ovl2FeubOmUcjBozWeRV6np7ECTEs6WTueeVvx6lqORN3izU3VKOD5+m6RkZczKlL8CTYHjwBZghlKqFtAV2GuG3IQQQgghhBBCCCFEPm7v38/5kcFYe3hQbslibLy9LZ1SrrbH3OKf+ETmVvNDKWXpdPJ1+WYC07aeoNkTHnSpXdbS6VicMcXDl4GM0vAkoDjQHfg7/ZgQQgghhBBCCCGEKCRxO3dxfswYbLy98Vu8GJtSXpZOKU8Lzl2ljJ0Nnb2K/uTVdzYfIznVwHvPP1nkC52FocDFQ631qSzP44Fgs2QkhBBCCCGEEEIIIfJ166efuPDfl7GtVAm/0M8p5uZm6ZTy9OeteHbdiOMN/zLYWBXtYtxPx6/w3Z+XGde2CuXcnSydTpFQ4DUPlVKnlFI5tpZRSpVQSp3K7RwhhBBCCCGEEEIIYVo3v9nC+Rdfwq56NcqFLSnShUOABZFROFpbMbBs0d6x+HZiCm9t/JPKpZx5oZm/pdMpMozZMKU8YJ1Lux1QNCfUCyGEEEIIIYQQQjxCbqxbx8Vx43CsUwe/0MVYu7paOqV8XUpMYsPV6/Qr44arjTGr5xW+mT/+zcWbCUzpWhPbYsaUzB5t9/zUlFLdsrzsqJS6meW1NdASOGPivIQQQgghhBBCCCFEFjHLv+DK++/j1LQpPp/OxsrBwdIp3VPo+WsYNLzg42npVPL1x/mbLNl9mn4BftQvX7RHcha2gpR8v0r/q4HQu44lk1Y4fMWEOQkhhBBCCCGEEEKILK4tXETUzJk4t2qJ98yZWNnaWjqle7qdksryi9F08HSlnIOdpdPJU0qqgYnrf8fNyY7x7apaOp0i555jMLXWVlprK+Ac4JXxOv1hp7WuorX+xvypCiGEEEKYRvny5VFKoZRiwoQJ+fYdMGBAZt/AwMDCSfA+BQUFoZQiLCzMIvEz3tczZ85YJL4xEhMTWbhwIZ06dcLHxwd7e3ucnJx44okn6NevH+vXr8dgMFg6TSGEEAKtNVc/+YSomTNx6dgRn48/figKhwArL8dwMyWVYN+iuws0wNK9Z/nzQixvP1cdVwcbS6dT5BR4ArfWuoLW+po5kxFCCCGEKGzLly8nNTU112OxsbF8/fXXhZyRMLf9+/dTuXJlRowYwffff4+Pjw9dunShXbt2ODo6snLlSrp160ZAQIClUzVaeHj4Q1HoFkIIUTBaa65+OJXo+Qtw7dGdstOmomwejuJWqtYsioyivosj9VyL7q7FF2/cYcYPJwis4kmnp8pYOp0iyajVH5VSo5RSx5RS8Uop//S2CUqpXuZJTwghhBDCfOrXr8/Fixf58ccfcz2+atUq7ty5Q4MGDQo5s4fTtm3biIiIwNu76O6ld/DgQZo3b865c+cYOnQoFy5cYN++faxevZp169Zx9OhRzp49y4gRIzh58qSl0xVCCPEY0wYDlye9Q8zSpZQcMIAykyejrHPbx7Zo+i7qJmcTkhhZhEcdaq15a+MxDFrzbpcnUUpZOqUiqcDFQ6XUS8AbwEIg67t5ARht4ryEEEIIIcwuKCgIIM9pvmFhYVhbWzNw4MDCS+ohVrFiRapWrYpNER0RkZycTK9evUhISGDs2LGEhobi5ZXzf2j8/PxYsGABGzZssECWQgghBOiUFC5NnMiN1atxf+EFSr3+Gsrq4dr997PIKPzsbWnvWXR3g/7+2GV+irjCf1tVxtfN0dLpFFnG/MsbCbygtf4ESMnSfhioYdKshBBCCCEKQUBAANWqVWPjxo3cuHEj27ETJ06wd+9e2rZtS5ky+U9hiY6O5o033qBmzZo4Ozvj5ORE3bp1+fjjj0lOTs7RP+vahP/++y/9+vWjVKlS2NnZUbVqVaZOnZrnenu3b9/m9ddfp2LFitjZ2eHr68uoUaOIjo7ON8fk5GTmzJlDQEAALi4uODg4UK1aNSZMmJDvudHR0bz11lvUqVMHFxeXzHUBg4KC2LNnT7a+ea15GBgYiFKK8PBwDh06ROfOnXF3d8fe3p5atWoRGnr3nnzZ7/f999+nVq1aODk54eTkRO3atZkyZQrx8fH53vPdVqxYwenTp/Hy8mLatP9n787Doir7P46/DzsKyOKKgmBiuJe4Pq64JC6RptgTbmCmopZlVpiV2GZmy6MmmmaCuGXmmrhkueduJoaipiCKC8iugMKc3x/I/BwZBJRh0L6v65qL8Zz7PvOZM1b0nXv5otj2nTp1KnQsKSmJd999F09PT6ytrbGzs6Nt27aEhoaSm5tbqH1ISAiKohASEqL3NcLCwlAURVvI1nc8IyODt99+G3d3dywtLalduzZBQUEkJyfr9OnSpQve3t4A7Nq1S7tWZ8E0ZlVV8fDwQFEUDhw4UOT7HjBgAIqiEBoaWswdEkIIYQjq7dtcnvgWaes3UO2NCVR/a+JjNyLuaNpNDqffZJRLNUwraPaM7DtM3fA3DWvZMaKDu7HjVGgl2W25QF3gpJ7jd4CKvze4EEIIIYQegYGBvPPOO6xYsYKgoCDt8YLRiIGBgQ/sHxUVhY+PDwkJCdSpU4cuXbqg0Wg4ePAgEydOZNOmTURGRmKhZzgLo3cAACAASURBVGHz48ePM2HCBKpWrYq3tzfXr19nz549BAcHc+nSJebMmaPT/ubNm3h7e3P48GHs7Ozo1asXpqamrFy5km3bttG4sf7vc7Ozs+nVqxc7d+6kUqVKeHt7U6lSJfbs2cOMGTNYuXIlv//+O/Xq1dPp9+eff9KnTx+uXLmCo6MjXbp0wcrKiri4OFasWAHAf/7zn2LvcYEtW7bw9ddf8/TTT/Pcc89x8eJF/vjjD0aOHElqaipvvfWWTvukpCS6du1KVFQUDg4O9OzZE4AdO3YwZcoUVq1axe+//46jo2OJXn/9+vUAvPTSS1haln7Hx3PnztG1a1fi4+OpWbMmzz//PLdu3WLHjh2MGzeOtWvX8ssvvzzUtYuSlpZG+/btuXz5Mp06daJJkybs3buX+fPnc+jQIQ4cOKAd6enj44OVlRVbt26lRo0a+Pj4aK/j6emJoiiMGzeON998k9DQUNq2bVvo9S5fvsyGDRuwtbWVEbdCCGEEmuxsLk2YwM1du6kxORjH4cONHemhzIu/ThUzU16uWbL/RhvDl1tjuJ6Rw3dDW2Ju+niN6ixvpSkengdaAHH3He8NRJdZIiGEEEIY3J5VZ0iKzzR2jFKp6mJDx0ENyvy6Q4cOZfLkyYSFhWmLh3l5eSxZsgRHR0d8fX3ZsGGD3r5ZWVm88MILJCQkMH36dCZNmoSZWf6vV8nJybz00kts376dzz77TO/Is1mzZjF16lQ+/PBDTO5ORdq9ezfe3t6Ehobyzjvv4OLiom3/4YcfcvjwYZo2bcr27du1U25TU1Pp06dPkTk//PBDdu7ciaenJ9u3b9euSZiVlcXQoUP5+eefGTx4MPv379f2yczMxNfXlytXrjBmzBi+/vprrK3///vixMREYmJiSnqbAZgxYwaLFi1ixIgR2mNLly5l6NChfPTRRwQFBVGp0v9PGRo7dixRUVF07NiRDRs2YG9vD0BKSgp9+/bljz/+YNy4cdpCZnGOHj0K8NBrWPr7+xMfH4+fnx9LlizBysoKgPj4eLp378727dsJCQlh+vTpD3V9fdatW0fv3r35448/sLGxASAhIYG2bdty7NgxVq1axeDBgwEIDg6mbdu2bN26FU9PT73T8QMDA3n//ff56aef+Oabb3ByctI5/91335Gbm8uwYcOwtbUts/chhBCieJqbN4kfN55bBw9Sc9o0HF56PLeXiMvKITIxjbGu1alsVjHXaDwen8qSA3EMa1uXZ1zsjR2nwitNafVL4FtFUQaTv+ZhO0VRpgKfAjMNEU4IIYQQwtBq1qyJj48Phw4d4tSpUwBs27aNhIQE/P399Y4YLBAWFsaFCxcYNGgQwcHB2sIhgKOjI+Hh4ZibmzN37lxUVS3Uv1WrVkydOlVbOIT8qbI9e/ZEo9GwY8cO7fGsrCwWLFgAwOzZs3XW6rO3t2fevHl6pzRlZWUxb948bb97NzOxtrZm/vz52NjYcODAAfbt26c99/3333Pp0iXatWtHaGioTuEQoFq1anTo0KHIe6PPgAEDdAqHAEOGDKFhw4akp6dz5MgR7fG4uDhWr16NiYkJCxcu1BYOARwcHFi4cCEmJiasWrWK+Pj4Er1+YmIigN51DouzZ88eDh8+jK2tLfPnz9cWDgFcXFyYNWsWAHPnziU7O7vU1y+KjY0NixYt0hYOAZydnRk/Pn/J8d9++61U16tSpQrDhg0jOzu70HTxO3fusHDhQiC/cCuEEKL85KWnc3Hkq9w6dAjnGZ8/toVDgO8vJWKiwCt1qho7il538jRMXhNFdVtLJvV82thxHgslHnmoqupiRVHMgM+ASkAEkAC8rqrqjwbKJ4QQQggDMMQIvsdZQEAAmzZtIiwsjBkzZmhHbN2/Dt39IiMjAfDz89N73tnZGQ8PD6Kjozl79iwNGuje9969e+st+Hl6erJ582YSEhK0x44ePUpmZia1a9emS5cuhfo0a9aMZs2a8ddff+kcL+jn7OxMjx49CvWrWrUqzz//PCtWrGDnzp20b98eyJ9iDDBixIgyW2epb9++eo97enpy6tQpnfe7Z88eVFWlXbt2PP104V/sGzVqRJs2bdi/fz+7d+/Wjr4zlF27dgHw/PPP650m7ePjQ61atbhy5QpHjx7V3sdH5eXlRc2aNQsd9/T0BNC5ZyU1fvx45s2bx3fffcekSZO0xes1a9Zw9epVunTpQqNGjR4tuBBCiBLLTUkh/pWRZJ89S+1vvsGu53PGjvTQ0u7ksvxKMv2qO1DLsugvYI1p8b4LnLqSzvwhLbC1qpibvFU0pZrUrarqQlVV6wLVgZqqqtZRVbXoFa6FEEIIIR4DBRt4REREkJSUxPr162natCleXl4P7Hf+/Hkgv3h47+YU9z6io/NXdykY9XYvV1dXvde1s7MD0BnBdunSJQDc3Yte0NvNza3QscuXLxfbr2Ctw4K2kD/yD/6/SFUWSvN+Hzb3g1SrVg2A69evl6j9vQyRpyRKc89KqlGjRnTv3p3z589ri8SAdoOUcePGPURSIYQQDyM3MZGLw4aRc+4cLt/OeawLhwARCTe4madhjEs1Y0fRKz75Ft/8epbuDWvQs3HhL+eEfqVZ81BLVdWksg4ihBBCCGEsFhYW+Pv7M2fOHAIDA8nJySl2oxTIXxsRoE+fPlSt+uCpOfevLQfoTFc2tNKOHjTEro4P837LMoeXlxfx8fEcPnz4oTcDKev7UtSu2gUM9XfktddeY/v27YSGhtK7d29OnjzJ7t27cXZ2pl+/fgZ5TSGEELruJCQQFxhIbmISLgu+o7KejaweJ3c0KosuJ9HB3oYmtpWK71DOVFXlg/UnURSY9kLjx24Ha2MqtnioKIr+lbfvo6qq76PHEUIIIYQwjoCAAObMmcMvv/yCmZlZiabBuri4EBMTQ1BQEH369DFovoK1CmNjY4tso+9cQb8LFy4U2a9gBOW96yG6urpy6tQpYmJiSr22YVkoyFKQTR99uR/E19eXdevW8eOPPzJz5sxS7Yr8sHkK1szMzNS/QVHBCM/y1rdvX9zd3dm8eTOxsbHaUYejRo3SWbtTCCGEYdy+eJG4gAA06Rm4fv89lVo8a+xIj2zD9RSu5NzhiwZ1jB1Fr01RV9gZk8gHfRtR2966+A5CqyRfZfYFmgI3inkIIYQQQjy2WrRoQfv27XFycsLPz69Em2r06tULgJ9++snQ8fDy8qJy5cpcunSJ3bt3Fzp/8uRJTpw4obefjY0Nly9f1ru5xo0bN9i4cSOAzlqKPXv2BOCHH37Qu9mLoXXs2BFFUThw4ABnzpwpdP7UqVMcPHgQExMTOnXqVKJrDh48mLp163L9+nXefffdYtvv2bNH+7xz584AbNy4kZSUlEJtt27dypUrV7CxsdGZ7l5QSDx9+nShPqqq6kwbLgsFxcrc3NwHtjMxMWHs2LFoNBpmzpzJ0qVLMTc3Z9SoUWWaRwghRGE5584RN3gI6q0sXMPDnojCoaqqzI9PxKOSJd2c7Iwdp5C0rDtM2xhNk9p2DG9X19hxHjslKR7OBCyBTsA/wAeqqgbe/zBoSiGEEEKIcrB3716SkpJYvnx5idqPGjUKFxcXwsPDCQkJ4datW4XaXLhwgaVLlz5ytkqVKjFy5EgAJkyYoLOGYlpaGmPHjtVb5LO2tmbMmDHafleuXNGey87OJigoiMzMTNq2bauzycfIkSNxdnbmjz/+4LXXXiu0tl5iYiJ79+595PdVlLp16zJgwAA0Gg2jR48mLS1Ney41NZXRo0ej0WgYNGgQLi4uJbqmhYUFP/74I5aWlsyaNYuRI0fqXf/w8uXLjB8/Xmf6bseOHWnVqhUZGRmMGzeOnJwcnfZvvPEGkL8Zyb07MXt7e2NiYsKWLVt0drPOy8tjypQpHDp0qOQ3pQQKipXnzp0rtoD4yiuvUKlSJUJDQ8nIyKBfv37UqlWrTPMIIYTQlX3qFHFDh6GqKq5LwrFu3NjYkcrEH6mZRGVmMdqlOiYVcDrwF1tOcyMzh+n9m2FmWn7Lxjwpip2ToKrqu4qivAf0AUYAUxRF2QksAtarqnrHsBGFEEIIISomGxsbNm3aRN++fZk2bRpz5syhWbNmODs7k5GRwalTpzh37hxt2rRhyJAhj/x6n3zyCXv27OHYsWPUr1+frl27Ympqyo4dO7C3t8fX15cNGwqvOPPxxx9z5MgRdu7ciYeHB127dsXa2po9e/Zw5coVXF1dWbZsmU4fW1tb1q9fT58+fZg7dy4rV66kffv2WFlZERcXx59//snLL79s0CnN8+bN4/Tp0+zcuZN69eppR0bu2LGDlJQUmjdvzty5c0t1zTZt2rBjxw4GDRrEokWLCA8Pp1WrVri6upKbm8s///zDX3/9haqqtL1v7anly5fj7e2t3Zm6Y8eO3Lp1ix07dnDz5k26detGSEiITh9XV1eCgoKYO3cu3t7edOzYETs7O44dO0ZKSgqvv/46s2fPfpTbpKNu3bo8++yz/PnnnzRr1gwvLy8sLS15+umnefvtt3XaOjg4MGTIEBYsWADIRilCCGFoWX/9xcVXR2FSuTJ1F/+AhZ6Nzh5X8+MTcTI3Y0ANB2NHKeRoXDLLDl5kRHt3mtapYuw4j6USlVtVVc1TVXWDqqr9AHdgB/AJcFlRFBtDBhRCCCGEqMiaNm3KiRMn+Oyzz/Dw8ODYsWOsXr2aY8eOUbVqVT744ANtceZR2djYsGvXLoKDg3F0dCQyMpIDBw4wcOBADh48iIOD/l/Yrays2LZtG7Nnz6ZRo0bs2LGD9evXY2dnxzvvvMOxY8e0OwXfq2XLlkRFRREcHEzNmjX59ddf2bRpE8nJyfj7+2tHNBpK1apV2b9/Px9//DG1a9dm8+bNbN68GRcXFz799FP27duHo6Njqa/brl07zp49y7x58+jRowdxcXGsXbuWyMhIMjMz8ff3Z+PGjfzxxx86/erXr8+ff/7J22+/rS2u7ty5k8aNG/Ptt9+yefNmvesozp49mxkzZlCvXj327t3L3r17adOmDUeOHOHZZ8t+qtqaNWsYNGgQycnJrFixgkWLFrFp0ya9bXv06AFA48aNtVOzhRBClL2bhw5xMXAEpvb2uC2NeKIKh2dvZvPrjXQCajthXcFG9d3O1TB5TRTOVax467kGxo7z2FJKu4aNoihPAa8Aw4DbQFNVVW8aIJtBtGzZUj1y5IixYwghhBAGderUKRo2bGjsGEKICq5///6sW7eO0NBQgoKCjB2nQpJ/nwohHlXmnr1cGj8e8zp1cP3hB8xrFL+u8uPknZh4fryazJF2jahmYW7sODrm7jjHzK0xfD+sJd0b1TB2nApNUZSjqqq21HeuRCVhRVGsFUUZrijKbiAKqAsMV1W13uNUOBRCCCGEEELkO3r0KBs2bMDJyYlhw4YZO44QQjyRMrZv59LYsVjUq0fdiCVPXOEw6XYuq64m41fDscIVDuNu3GT2b2fxaVxTCoePqNg1DxVFWQgMAs6Sv86hr6qqqYYOJoQQQgghhCh7I0eOJDMzk8jISDQaDR999BGVK1c2diwhhHjipP2yiYR338WqSWNcFyzAtMqTt95e+OUksjUqo1yqGTuKDlVVeX/dScxNTQjxfTI2pTGmYouH5E9RvghcAXoBvRQ9O+eoqupbttGEEEIIIYQQZW3RokWYmJhQt25dPvzwQ8aOHWvsSEII8cRJXb2aKx98SCUvL+rMn4+pzZP3JU12nobFl5Po5mhHg8pWxo6jY/3xBPacTWKab2NqVqlY2R5HJSkeLgFKtzCiEEIIIYQQokIq7ZrnQgghSic5YinXPv2Uyh06UGfObEysrY0dySDWXEsh6U4uQa4Va9Rh6q3bfPxLNM+42DOkbV1jx3kiFFs8VFU1oKxeTFEUc6AT0BvoDDQArIBEYD/wraqqO/X0CwOGP+DSMaqqepZVTiGEEEIIIYQQQojSSlqwkMSvv8amezdqf/01JhYWxo5kEKqqMj8+kSY21rS3tzF2HB3TI0+TmnWHiP5NMTUpPHNWlF5JRh6Wpc7Ar3efXwV2AzeBRsAAYICiKB+rqvphEf33Aef0HL9S1kGFEEIIIYQQQgghSkJVVRJnz+bGvPnY9emD8+fTUcwr1gYiZen35AzO3MpmTkNX9C1tZywHz9/gxyPxjO5Uj0bOdsaO88R4YPFQUZQNJb1QCdc81AA/A7NUVd1z32u9BCwDPlAUZYeqqjv09P9eVdWwkmYSQgghhBBCCCGEMCRVVbn++QySw8OpMnAAtaZNQzE1NXYsg/ou/jo1Lcx5obq9saNo5eTm8d7aKOo4WDOhu4ex4zxRiht5eKMsX0xV1d+B34s496OiKD3I36BlCKCveCiEEEIIIYQQQghRIagaDVdDppG6ahUOQ4ZQ473JKCYmxo5lUH9nZrE7JZMp9WphUYHe6/yd5/kn8SaLA1tRyaK8J9o+2R54N1VVDSyvIHf9efdnnXJ+XSGEEEIIIYQQQogSU3NzSXjvPdI3bMTp1VepNvHNCjWF11Dmx1+nkqkJQ52djB1F63xiJnN3nKNvs1p4P13d2HGeOBWtFFswrrSoNQy9FUVpBtgA14C9wK+qqmrKI5wQQgghhBBCCCGEevs2lye9Tca2bVR7YwJVx4wxdqRycTXnDuuupTLM2Ql784pRUlJVlSlrT2JpbsKHzzcydpwnUqk+aUVRvIGXAVdAZ8sgVVW7PkoQRVFqAgF3//hzEc2G6TkWrSjKf1VVjXqU1xdCCCGEEEIIIYQoicR588jYto0ak4NxHD7c2HHKhaqqfPJPAnmqyiiXasaOo7X66CX2n7/Bp/2bUN3WythxnkglnpyuKEoAsBmwBboAiYAD0AKIfpQQiqKYAUuBKsBvqqpuvK/JceB18ndltgGcgb7AX3ePbVcUpfYDrj9KUZQjiqIcSUxMfJSoQgghhBBCCCGE+BfT3LpFyvIV2Pbo8a8pHAKEJdxg9bUUJrrVpK61pbHjAJB88zafRZ7Cq64DL7dyNXacJ1ZpVracBIxXVfVl4A4wWVXVZ8kv+mU+Yo75QDcgnvzNUnSoqvo/VVXnqKp6SlXVm6qqXlFVdRPQGjgAVAcmF3VxVVUXqKraUlXVltWqVZzquBBCCCGEEEIIIR4vqWvXoklLwzGwvLeJMJ4jaTf58OxlujnaMdGthrHjaH2yKZqM7Fw+698UE5Mnf71JYylN8bAesP3u8xzyRwACfMv/TzcuNUVRZpG/w/JVoJuqqldL2ldV1dvA9Lt/7P2wGYQQQgghhBBCCCGKo+blkRy+BKvmzbB+9hljxykXibfvMPJkLM6W5sxt5IpJBdkU5o9zSaw5dpnRnevxdE1bY8d5opWmeHiD/CnLAJeBJnefOwHWD/PiiqJ8Rf505ETyC4dnH+Iyp+/+LHLashBCCCHEvdzc3FAUBUVRCA4OfmDbIUOGaNt26dKlfAJWEGFhYSiKQkBAwEP1z8jI4KuvvqJ79+7UqlULS0tLbG1tady4Ma+88grbt28v/iJCCCFEBZLx++/cuXgRp8DAf8XOyrkalVF/x5KWm8sPTd0rzCYp2XfymLLuJHWdKvFaV4/iO4hHUpri4R7gubvPVwGzFUVZDKwAfi3tCyuK8gUwkfyiZHdVVR923cSCvcEfdeq0EEIIIf6FIiIiyMvL03suPT2dNWvWlHOiJ0NkZCTu7u5MmjSJffv20aBBA1588UW6detGbm4uP/zwAz169MDPz8/YUUvtUYuqQgghHl/JYeGY166Nbffuxo5SLj45n8D+1JvMfNqFxjYPNW7MIEJ3nONC0k0+7dcUK3NTY8d54pWmZDweKNi2ZjqQC7Qnv5D4SWleVFGUz4G3gRSgh6qqJ0rT/z6D7v48/AjXEEIIIcS/UMuWLTly5Ai//vorPj4+hc6vXLmSrKwsWrVqxeHD8qtGSW3YsIH+/fujqirBwcG899572NrqTieKjo4mJCSEs2cfZuKJEEIIUf6yTpwg6+hRakwORjGrGCPwDGn99RTmxycyonZVBtZ0NHYcrbPXMpi36x/6P1ubDh5VjR3nX6HEIw9VVU1WVTXh7nONqqozVFX1VVV1kqqqqSW9jqIonwDvAqnkFw7/LKb9M4qi9FUUxfS+42aKorxF/rRngG9KmkEIIYQQAtCOHAsLC9N7PiwsDFNTU4YOHVp+oR5zN27cYNiwYWg0Gr766iumT59eqHAI0KhRI1atWsWsWbOMkFIIIYQovRuLF2Nia0uVAQONHcXgTt/M4s3T8bSyq0xIfWdjx9HSaFTeWxtFZUszpvRpaOw4/xqlmbYMgKIozncLei3ufZSwry8w5e4fzwGvKYoSpudx7+JDbsBG4LqiKL8qirJMUZQtQBzw5d0276iqurW070UIIYQQ/25t2rShYcOGrF+/ntRU3e9CY2Ji2L9/Pz179qRWrVoPvM6NGzd4//33adq0KTY2NlSuXJkWLVrwzTffcOfOnULtAwICUBSFsLAwTpw4gZ+fHzVr1sTU1JT//e9/2nY3b97kyy+/pF27dtjb22NtbU29evXw8/MjMjKy0HXv3LnD/Pnz6dixIw4ODlhZWeHh4cHEiRNJTEzUm11VVRYtWkSLFi2wtramatWq9OvXjxMnHm5iyJw5c0hLS6N58+a88cYbxbbv1KlToWNxcXGMHTuWevXqYWlpiYODA97e3ixfvlzvNe69n/qEhISgKAohISFFHr927RqjR4+mTp06WFpa4u7uTnBwMNnZ2Tp93NzcCLy7u2Z4eLh2PcyCacyZmZlUqVIFMzMzLl26VOT79vLyQlEUvZ+jEEKIiuf2pctkbN2G/SA/TG0qGzuOQaXn5vFKVCyVTU1Y2MQNC5NSl44MZtWReA7HpvBer4ZUtbE0dpx/jRKPs1UU5VlgKeAJ3L8qqAqUZJL5veNcW9596LML+Pzu87+AWUBroBHQ8e7rXQIWA3NVVT1agtcWQgghhCgkMDCQd955hxUrVhAUFKQ9XlCIKigUFSUqKgofHx8SEhKoU6cOXbp0QaPRcPDgQSZOnMimTZuIjIzEwsKiUN99+/YxZswYateuTZcuXcjIyKBSpUpAfgGtZ8+exMTEYGNjQ4cOHahSpQrx8fFs3ryZxMREevfurb1Weno6ffr0Ye/evVSpUgUvLy/s7e05duwY33zzDT///DO7du3Czc1NJ8O4ceOYN28epqamdO7cmerVq3Po0CHatGlT7HvXZ/369QAMGzbsoRaSP3DgAL169SI1NRV3d3f69+9PcnIyO3fuZOfOnWzZskVbtCsr8fHxeHl5oaoq//nPf0hPT2fv3r3MmDGD6OhoNmzYoG07cOBADhw4wL59+3jqqafo0KGD9lyHDh2wsbEhMDCQWbNmsWDBAj766CO97/HYsWPUq1dP73R5IYQQFU9KRASYmOA4ZIixoxiUqqpMOHWR2OwcVj9Tn5qW5saOpJWYkcNnkado7e6IX8s6xo7zr1KaSfoLgHjgVSCB/AJeqaiqGgaElbLPBaD4r62FEEIIUWI7whZwPe68sWOUSvW69fAOGFXm1x06dCiTJ08mLCxMWzzMy8tjyZIlODo64uvrq1M8uldWVhYvvPACCQkJTJ8+nUmTJmF2dw2k5ORkXnrpJbZv385nn31WaNQbwPfff8+UKVP46KOPMLnnW32NRkP//v2JiYnhhRdeYPHixTg4OGjPZ2RkcOjQIZ1rjRo1ir179zJw4EAWLFigbZ+Xl8d7773HF198QUBAADt37tT22bhxI/PmzcPOzo5ff/2V1q1ba/u8+eabzJkzp1T3Mjc3VztisVWrVqXqC5Cdnc2gQYNITU3ljTfe4Msvv8TUNP/76ZMnT9KtWzciIiJo3749o0ePLvX1i/LDDz8wcuRI5s6dqy3ynjp1itatW7Nx40b27dtH+/btAfjyyy8JCwtj3759dOjQQe9ox3HjxjF79my+//57PvjgA8zNdf/HKzQ0FICgoCCdz10IIUTFlJeRQerq1dj5+GBezGyEx923F6+zOSmNafWdaWdvY+w4Oj7ZFE3WnTw+69/0X7HTdUVSmt9WGgGvq6r6h6qqsaqqxt37MFRAIYQQQghDqlmzJj4+Phw6dIhTp04BsG3bNhISEvD399c7YrBAWFgYFy5cYNCgQQQHB2sLhwCOjo6Eh4djbm7O3LlzUdXC37t6enoybdq0QgWkDRs28Oeff+Lm5saKFSt0CocAtra2dOvWTfvn6OhofvzxR+rWrcuSJUt02puamjJ9+nSaNm3Krl27iIqK0p4rmCL95ptvaguHBX1mzpyJs3Pp1ji6ceMGGo0GgOrVq5eqL8BPP/1EfHw8bm5ufPHFF9rCIUCTJk2YNm0akF/AK0suLi7Mnj1b57Nu2LChdq3L3377rVTX8/DwwMfHhytXrrB27Vqdc0lJSaxatQorKytGjBjx6OGFEEIYXOqqn9DcvIljYICxoxjU7uQMpp+/wgvV7RlVp5qx4+jYdSaR9ccTCOpSn/rVK1ZR89+gNCMPo4CawBkDZRFCCCFEOTHECL7HWUBAAJs2bSIsLIwZM2ZoR5MVbKhSlIL16vz8/PSed3Z2xsPDg+joaM6ePUuDBg10zr/wwgs6BbICW7ZsAWDw4MFYW1sXm3/z5s0A9O3bV297ExMTOnbsSFRUFPv376dp06bk5uayb98+AIbomYJlaWmJn59fuW5osmvXLgD8/f0LjdaD/M9j7NixnDt3jsuXL1O7du0yed2uXbvqvW+enp4AJCQklPqar732Gps3byY0NJRBgwZpjy9atIicnBwCAgJwdKw4O1cKIYTQT71zh+SlS6nUujXWjRsbO47BxGffZkx0LB6Vrfj6aZcKNbIv63Ye76+Lol7Vyozt8pSx4/wrlWbk4XvAF4qidFcUpYaiKI73PgwVUAghhBDC0Hx9fXFyciIiIoKkQHd1swAAIABJREFUpCTWr19P06ZN8fLyemC/8+fzp377+fnpbJxx7yM6OhpA74YldevW1XvduLj8SR0FxaviFOSYO3dukTkKpsoW5EhKSiInJwcTE5Mic9y/PmJxnJyctKMor1+/Xqq+AJcvXwbA3d1d73krKyvtaMiCtmXB1dVV73E7OzuAQpumlISPjw8eHh7s2rVL+3dAo9Ewf/58IH9qsxBCiIovfes2cq9cwbGYLxQfZ9l5GkaevMAdjcoPTdyobFaSLS3Kz+zfzxKfnMWn/ZtiZV6xsv1blGbk4fa7P7ehu96hQsk3TBFCCCGEqHAsLCzw9/dnzpw5BAYGkpOTU6LNQvLy8gDo06cPVatWfWBbJyenQseKGlVY2m/7C3J4eXnRpEmTB7ZtbMBRE2ZmZjRr1ozjx49z+PBhOnbs+FDXKevRDgVTqYtiiHUHFUVh/PjxTJgwgdDQUL799lsiIyOJjY2lVatWtGxZ1L6BQgghKgpVVUlevBgLd3dsunQ2dhyDmXL2En9lZBHWxJ2nKlkZO46O01fTWbj7PAO96tDuqcK/S4nyUZriobfBUgghhBBCGFlAQABz5szhl19+wczMjMGDBxfbx8XFhZiYGIKCgujTp0+ZZSkYCRcTE1Oi9i4uLgB4e3szc+bMEvWpWrUqlpaW5OTkcPHiRZ56qvA0oNjY2JIFvoevry/Hjx9nyZIlTJw4sVR9C6YhF4ykvF92drZ2CvG9U5YL1irMzMzU269gJGd5CwgIYMqUKURERPD5559rR3/KqEMhhHg8ZB05Qvbff1MzJATlCd3galnCDZZdSWZC3Rr4VKti7Dg6NBqVyWuisLM2Z0rvhsaO869W4r/9qqruetDDkCGFEEIIIQytRYsWtG/fHicnJ/z8/Eq04UevXr2A/I0+ylLPnj0BWLp0aYmmzBbkWLduHbm5uSV6DTMzM/7zn/8AsGzZskLnb9++zerVq0saWWv8+PHY2dnx119/aTdkeZA9e/Zon3funD+qY8WKFXrfR3h4OKqqUr9+fZ3iYcHz06dPF+qTlZWls8N0WSgoVhZ3r+3s7Bg+fDjp6el89NFHbN26FScnJ1566aUyzSOEEMIwbiwOw9Teniov+Bo7ikH8mX6LyWcu0cXBlnfcaxo7TiHLDl3kz4upTOndEIfKRW9gJwyvVKXzu2sdfqQoympFUX5SFCVEUZQahgonhBBCCFGe9u7dS1JSEsuXLy9R+1GjRuHi4kJ4eDghISHcunWrUJsLFy6wdOnSUuV44YUXeOaZZ4iNjWXw4MGkpaXpnM/IyNDZAbhFixb069ePc+fOMWjQIC5dulTomikpKXz33Xc6Ba/XX38dgK+//pojR45oj2s0Gt59992HWlewWrVqhIWFoSgKEydO5L333iMjI6NQuzNnzvDyyy9rM0D+2pEuLi5cuHCByZMn60w3jo6OZurUqQBMmjRJ51oFO09HRETojNbMysoiKCiIixcvlvp9PEhBsbJgd+4HGT9+PIqiMHPmTDQaDSNGjMDKqmJNCRNCCFFYzoULZO7YgYP/y5iUYPOyx82N27mMPHmB6pZmhDaui2kF2iAF4Hp6Nl9sPk37+k682KJsNkgTD6/ExUNFUdoD5wB/IAvIBoYAZxVFaWeYeEIIIYQQFZeNjQ2bNm3C1dWVadOm4eLigre3N4MHD8bX1xcPDw/q1avHt99+W6rrmpiYsGbNGurXr8+aNWtwcXGhd+/evPzyy3To0IFatWrx8ccf6/QJDw+nc+fOrF27Fg8PD9q2bct///tfBg4cSIsWLahWrRpjxozRKR7269ePUaNGkZaWRrt27ejevTv+/v40aNCA+fPnExQU9FD3pX///qxbtw57e3umT59O9erV6dKlC/7+/vTv359GjRrx9NNPs3LlSp1NYaysrFi1ahX29vZ8+eWXNGjQgJdffpmePXvyzDPPcO3aNYYOHcqoUbq7hXfo0IG+ffuSnp5OixYt8PHxoW/fvri7u7Nt27YSrV9ZGm3btqVmzZocO3aMli1bMnz4cEaOHMnixYsLtfX09KRHjx5A/uf6sPdUCCFE+UoOD0cxN8fB39/YUcpcnqoSFB1L0p1cFjVxx9G8NCvalY9pG6PJydPwSb+mFWrn53+r0ow8/BJYATRQVXWoqqpDgQbASuArQ4QTQgghhKjomjZtyokTJ/jss8/w8PDg2LFjrF69mmPHjlG1alU++OADFixYUOrruru7c+zYMT799FM8PDzYs2cP69evJyEhgb59+zJ58mSd9nZ2dvz2228sWbKETp068c8///Dzzz+ze/duNBoNo0ePZuvWrYVGvc2fP58FCxbQpEkT9u7dy5YtW2jYsCH79++ndevWD31ffH19uXDhAjNnzqRdu3acOnWK1atX8+uvv6IoCiNHjmTnzp2sWLFCp1/btm05fvw4Y8aMIS8vjzVr1nDw4EHatWvH0qVLCQ8P1/s/ET/99BPBwcFUr16d33//nWPHjtGnTx+OHTtW5G7KD8vS0pItW7bQp08f7cjSRYsWsWuX/pV8CoqHvXr1KnInaSGEEBVHbkoKaevWY+f7PGbFbIj2OPr8/BV2p2QyvUEdmttWMnacQn4/fY1NUVd4zbs+7lUrGzuOABRVVYtvBSiKkgU8o6pqzH3HPYE/VVV9LMbxtmzZUr13Wo4QQgjxJDp16hQNG8rC0kJUBM8++yzHjx8nMjJSuz6leHzIv0+F+PdJmjePxFmzqbdxA5YeHsaOU6YiE1MZcTKWoc5OzHzaxdhxCrl1O5ceX+/G2sKUyNc7YmH2ZG5UUxEpinJUVdWW+s6V5lNIA/R9VeoOpD5MMCGEEEIIIZ5ka9eu5fjx4zRs2BAfHx9jxxFCCFEMTU4OycuWU7ljxyeucHjuVjavn7rIM7aV+MSjYq4j+M2vZ7icmsX0F5tK4bACKc3E9pXAIkVR3gH+uHusPTCD/OnMQgghhBBC/OvduHGDd999l+TkZCIjIwGYOXOmrNkkhBCPgfRfNpGXlIRTYICxo5Spm7l5jIiKxcJEYVETNyxNKl5h7uTlNH7YF8vLrV1o5eZo7DjiHqUpHr4DKMAP9/S7A8wDgss4lxBCCCGEEI+ljIwMFi1ahJmZGfXr12fy5Mn06dPH2LGEEEIUQ1VVksPCsHz6aSq1e3L2hVVVlTdOx3PuVjarnnmK2lYWxo5USJ5G5b21UThUMifYR5aKqGhKXDxUVfU2MEFRlMnAU3cP/6Oq6i2DJBNCCCGEEOIx5ObmRknXFRdCCFFx3Ny7j5yzZ6k1ffoTNVr8u/hENiam8n69WnRwsDV2HL2W7I/lxKU0Zv33GapUMjd2HHGfUu/HfbdYGGWALEIIIYQQQgghhBBGkbx4MWbVqlGlT29jRykz+1Iy+Ph8An2qVWGca3Vjx9HrSloWX26NoVODavg2dzZ2HKHHA4uHiqJsAIaoqpp+93mRVFX1LdNkQgghhBBCCCGEEOUgO+YMN//4g2pvvoliUfGm9T6MhOzbjP47jnrWlvzP07XCjqacuv5v8lSVT15oUmEz/tsVN/LwBlAw5yL5nudCCCGEEEIIIYQQT4TksDAUa2scXhpk7ChlIkej4dW/Y8nSaFjTpD62ZqbGjqTX1r+vsi36Gu/6eOLqVMnYcUQRHlg8VFU18J7nAQZPI4QQQgghhBBCCFGO7ly/Ttovv+Dg54epvb2x45SJqecSOJp+i4WN3WhQ2crYcfTKzMklZMPfeNa0ZWRHd2PHEQ9Q4r25FUX5QVGUQitrKopSWVGUH8o2lhBCCCGEEEIIIYThpSxfDrm5OA4fZuwoZWLV1WTCLicR5FKN56tX3GLoV9tiuJqezWcvNsXctMTlKWEEpfl0hgPWeo5bA0/GP2FCCCGEEEIIIYT419DcukXqipXYdOuKRd26xo7zyKIybvFOTDzt7W2YUq/ibj5y4lIq4X/EMqRNXVq4Ohg7jihGsbstK4riCCh3Hw6KouTec9oU6ANcM0w8IYQQQgghhBBCCMNIXbeOvLQ0nAIDi29cwaXcyeWVk7E4mpsxv3FdzEwq5uYjuXkagn+OoqqNJW/7PG3sOKIEii0eAknkb5SiAtF6zqvA1LIMJYQQQgghhBBCCGFIal4eyeHhWDVrhnWLFsaO80g0qsrY6Diu5Nxh/bP1qWZhbuxIRQr7I5boK+mEDm6BnVXFzSn+X0mKh97kjzr8HRhA/q7LBW4DcaqqJhggmxBCCCGEEEIIIYRBZO7cyZ24i1T/5g0UpWKO0iupL2OvsiM5gxkN6tCiSmVjxynSpZRbfLXtDF09q9OrSU1jxxElVGzxUFXVXQCKorgDF1VVVQ2eSgghhBBCCCGEEMKAbixejLmzM7Y9ehg7yiPZlpTG17HXeKmmI8OcnYwdp0iqqvLh+r8B+OiFxo99wfbf5IEbpiiK0kJRlII2TsCzd48Vehg+qhBCCCFE2XBzc0NRFBRFITg4+IFthwwZom3bpUuX8gkoipWRkcFXX31F9+7dqVWrFpaWltja2tK4cWNeeeUVtm/fbuyIQgghKrCsqCiyjhzFYdhQFLOSTMqsmC7cymH8qTia2VjzeYM6Fbogt/nkVX4/fZ2JPRpQx6GSseOIUihut+UjQNV7nh+++/P+x2FDBRRCCCGEMKSIiAjy8vL0nktPT2fNmjXlnKhoISEhKIpCSEiIsaMYVWRkJO7u7kyaNIl9+/bRoEEDXnzxRbp160Zubi4//PADPXr0wM/Pz9hRSy0sLAxFUQgICDB2FCGEeKIlLw7DxMYG+4EDjR3lod3K0zDi5AVMUfi+iRvWpsWVeIwnPfsOIRv+prGzHYHt3YwdR5RScX+z3IHEe57Xu/vz/kc9QwUUQgghhDCUli1bkpCQwK+//qr3/MqVK8nKyqJVq1blnEwUZcOGDTz//PMkJycTHBzM9evX2bVrFytWrGDdunXExMTw999/4+fnx7lz54wdVwghRAV0JyGB9K1bsffzw9TGxthxHoqqqrwdE8/pm9mENqqLq7WlwV9z2TJwcwMTk/yfy5aVvO/MLTEkZeYw/cWmmFXgIqfQ74GfmKqqcaqqqoqimAPj7jlW6FEuaYUQQgghylDB6K6wsDC958PCwjA1NWXo0KHlF0oU6caNGwwbNgyNRsNXX33F9OnTsbW1LdSuUaNGrFq1ilmzZhkhpRBCiIoueUkEAI5Dhxg5ycNbdDmJn6+l8I57Tbyd7Az+esuWwahREBcHqpr/c9SokhUQj8alsPRgHMPaudGsjr3Bs4qyV6Jyr6qqd4Cx5O+6LIQQQgjxRGjTpg0NGzZk/fr1pKam6pyLiYlh//799OzZk1q1aj3wOn///TfDhg3DxcUFS0tLqlatSu/evdm8ebPe9gEBASiKQlhYGOfOncPf358aNWpgaWmJp6cnM2bMQKPR6PRRFIVp06YBMG3aNO06jPqmMd+8eZMvvviCVq1aYWdnh7W1NY0bNyYkJITMzMxCee6dDh0XF0dgYCB16tTBzMyMN954Q9vuzp07zJ8/n44dO+Lg4ICVlRUeHh5MnDiRxMREnWt+/PHHKIrCmDFjirxvGzduRFEUWrdu/cD7W2DOnDmkpaXRvHlznVxF6dSpU6FjcXFxjB07lnr16mFpaYmDgwPe3t4sX75c7zXu/az0KWoq+b3Hr127xujRo6lTpw6Wlpa4u7sTHBxMdna2Th83NzcCAwMBCA8P1/mMAwICyMzMpEqVKpiZmXHp0qUi37eXlxeKohAZGfmAuyOEEGXjzM1sZpy/QvKdXGNHKZG8zExSf/oJOx8fzJ2djR3noRxMzSTk3GWec7JjQt0a5fKaU6bArVu6x27dyj/+IHfyNExZG0UNWysm9XzacAGFQZVmrOhWoKuhggghhBBCGENgYCDZ2dmsWLFC53hBsaigmFOUDRs24OXlRUREBFWqVGHAgAE0atSIrVu30rt3bz744IMi+x4/fhwvLy8OHjyIt7c37du3559//iE4OJgJEybotB0+fDjNmzcHoHnz5gwfPlz7eOaZZ7TtLl26ROvWrXn33XeJi4ujXbt2PPfcc6SkpDBt2jTat29PSkqK3jxnz57l2WefZevWrbRr147nn38ee/v8EQLp6el07dqVoKAgoqKiaNGiBX369CE3N5dvvvmGli1bEhsbq73WqFGjsLCwYNmyZaSnp+t9vblz5wIwbty4B97jAuvXrwdg2LBhD7Ug/IEDB3jmmWeYN28eAP3796dVq1bs27ePwYMHM2zYMFRVLfV1HyQ+Ph4vLy9++eUX2rVrR5cuXbh+/TozZsxg0KBBOm0HDhxI+/btAXjqqad0PuMOHTpgY2NDYGAgeXl5LFiwoMj3eOzYMerVq4ePj0+ZvhchhNBn5oWrfBN3jY4HT7PmWkqZ/3u0rKX+tBrNzZs4PqZry17LucOrf8fiYmXBnIaumJTTBikXL5bueIHv91zg9NUMpr3QGBvLx3djmn+70nxyvwGfKYrSDDgK3Lz3pKqqFWc1cSGEEEI8UOrGf7idcLP4hhWIhXNl7J9/qsyvO3ToUCZPnkxYWBhBQUEA5OXlsWTJEhwdHfH19WXDhg16+169epWhQ4eSk5PDV199xcSJE7Xndu7cSZ8+ffjkk0/o0KEDPXv2LNR/1qxZTJ06lQ8//BATk/zvdHfv3o23tzehoaG88847uLi4APnFzJCQEP766y/69eund9MUVVUZNGgQ0dHRjB8/ni+++AJra2sAsrKyGDVqFEuXLuXNN9/UO5Ju+fLlBAQE8N1332FhYaFzbtSoUezdu5eBAweyYMECHBwctPfqvffe44svviAgIICdO3cCUKNGDQYNGsTSpUtZsmQJ48eP17neuXPn2LZtG05OTrz00kt67++9cnNzOXHiBMBDrUGZnZ3NoEGDSE1N5Y033uDLL7/E1NQUgJMnT9KtWzciIiJo3749o0ePLvX1i/LDDz8wcuRI5s6dq72np06donXr1mzcuJF9+/ZpC4ZffvklYWFh7Nu3jw4dOuj9jMaNG8fs2bP5/vvv+eCDDzA3N9c5HxoaCkBQUJD275QQQhhKZm4ev95Iw6eqHddychkbHcfqq8nMeNoFFyuL4i9QztTcXJIjllCpZUusmzYxdpxSu6NRGf13LBm5Gn5s/hRVzMuvGOfqmj9V+X516hTd5+KNW8z67QzPNapBz8Y1DRdOGFxpfqP4FqgOvA6EA6vvefxU9tGEEEIIIQyvZs2a+Pj4cOjQIU6dOgXAtm3bSEhIwN/fv1AR7V4LFy4kPT2d9u3b6xQOAbp06cJrr70G5BeF9GnVqhVTp07VKfJ06tSJnj17otFo2LFjR6ney5YtW9i/fz9t27Zl1qxZ2sIhgLW1NfPnz6d69eosW7ZM7+hDJycnZs+eXeg9R0dH8+OPP1K3bl2WLFmiLRwCmJqaMn36dJo2bcquXbuIiorSnit4/wUj/e41b948VFVlxIgRWFlZFfvebty4oZ3KXb169WLb3++nn34iPj4eNzc3vvjiC23hEKBJkybaKeFFfVYPy8XFpdA9bdiwoXYdzd9++61U1/Pw8MDHx4crV66wdu1anXNJSUmsWrUKKysrRowY8ejhhRCiGFuS0sjWqIxzrcEvXh58XL82B9Ju0vnQaRbEXyevgo1CTN+6ldyEKziOePCsgorqo38ucyDtJl97utDQxrr4DmXo00/BUs+eLBYWoG9Cg6qqvL/+JKaKwrQXGhs+oDCoEpepVVWVry6FEEKIJ4QhRvA9zgICAti0aRNhYWHMmDFDO+IroJgpTbt27QLypxTrM2LECGbMmMHevXvJy8vTKVgB9O7dW+/0W09PTzZv3kxCQkKp3kfBGncDBgzQO+qscuXKtGzZksjISA4fPsxzzz2nc7579+56NyApWLuxb9++OgXJAiYmJnTs2JGoqCj2799P06ZNAWjdujWtW7fm0KFD7Ny5ky5dugD5oyDDwsIwMTHRjvY0tILPyt/fv9BoPcj/rMeOHcu5c+e4fPkytWvXLpPX7dq1q9575unpCVDqzxjyi7KbN28mNDRUZ+rzokWLyMnJISAgAEdHx4cPLYQQJbTmWgp1rMxpaVcJRVF41aUaPtWqEBxziQ/PJbDmWipfe7rQqJwLXfqoqkry4jAs6tbF5u5/jx4na6+lsPBSEq/WqUr/Gg7FdyhjgwdDWBgUfOfl6govvghz50LXrrBtG1Sr9v/tN/yVwO4ziUx9vhG1qhj/8xePpsQFQUVRhimKUqjOrCiKhaIow8o2lhBCCCFE+fH19cXJyYmIiAiSkpJYv349TZs2xcvL64H9Ll++DIC7u7ve825ubpiYmJCdnc2NGzcKnXd1ddXbz84uf9fE+zfUKM758+cBePvtt3U227j3UVBgvH+DE4C6des+8Lpz584t8roF02Xvv+7rr78O/P90WoCVK1eSnJxMr169irx393NyctIWRK9fv16iPvcq7rOysrLC+e7C+QVty0JZf8YAPj4+eHh4sGvXLqKjowHQaDTMnz8fKPkakkII8Shu3M5ld0oG/ao76HwR5mJlwdJm7sxrVJf47Ns8dySGz/5JICtP84CrGV7W0aNknzyJY8BwlMdsWYdTmVlMPB1PmyqV+fCpsvlyq7Q0GoiOhv7985/HxsLXX8OGDXD6NHTuDAXfh6XdusPHv0TTrE4VhrVzM0peUbZKM0F+MbAFuP+3Ndu755aUVSghhBBCiPJkYWGBv78/c+bMITAwkJycnGI3SrnXw2zeAZT5mnR5eXkAdO7cGTc3twe21Vco1DdC7t7renl50aTJg9eIatxYd2qSn58fb731FuvWrePKlSvUqlVLW0gcO3bsA691LzMzM5o1a8bx48c5fPgwHTt2LHHfez3sZ1WU+3fFvp8h1h1UFIXx48czYcIEQkND+fbbb4mMjCQ2NpZWrVrRsmXLMn9NIYS43y+JqeSq8KKeUXCKotC/hgOdHW2Zdi6B2RevszExlZlPu9DBofAI9/JwY3EYpvb2VOnXzyiv/7DS7uQy4uQFbM1MWNDYDXOT8tkg5X5HjuQXB++/fT17wpYt0LcvdOqUPzJx/tFTpNy6Q1hga0yNlFeUrdIUDxVA34IFrkBa2cQRQgghhDCOgIAA5syZwy+//IKZmRmDBw8utk/t2rU5ffo058+fp1u3boXOx8bGotFosLKyKpdppAWbq/j5+ZXp6LOC63p7ezNz5sxS9bWwsGD06NF89NFHLFy4EB8fH44cOfJQuwH7+vpy/PhxlixZUmiNyeIUTEMuGEV5v+zsbO0U4nunLBesVZiZmam3X5y+1ePLQUBAAFOmTCEiIoLPP/9cW5CVUYdCiPKy9loKDSpZ0bBy0evWOpqbMauhKwNrOPD2mXgGHv8H/1qOfPiUM/bluNnH7dhYMn//HacxozEp4ouyikijqrx26iLx2bdZ80x9algWXnajvKxbB6am0KdP4XOdO8P27eDjAx1fTMakRzyvdnSnSe0q5R9UGESxX4UqihKlKMoJ8guHuxRFOXHP429gD7Dd0EGFEEIIIQypRYsWtG/fHicnJ/z8/Eq0KUfnzp0BWLJE/wSMxYsXA9ChQwfMzB79f5IKClm5ubl6z/fq1QvI3xykLBVcd926dUW+9oOMGTMGc3NzFixYwOzZs4GH2w14/Pjx2NnZ8ddff/G///2v2PZ79uzRPi/4rFasWKH3PYSHh6OqKvXr19cpHhY8P336dKE+WVlZ2t2ly0pxn3EBOzs7hg8fTnp6Oh999BFbt24t8c7VQgjxqC5n3+ZA2k3617Av0Yjujo62/N7Kk/Gu1fnxajIdD51m/fUU1HLaUCV5yRIUMzMc/f3L5fXKyuy4a2y7kU5I/dq0trcxapa1a6FLFyjqu9A2bWDbdg20jELNtKZn7Qblmk8YVkl+Y1sN/Ez+yMNNd58XPJYCrwJDDBVQCCGEEKK87N27l6SkJJYvX16i9q+++iq2trbs3btXWxQrsHv3bubMmQPAW2+9VSb5CgpZBbtC369fv354eXmxa9cuxowZQ3JycqE2V69eZeHChaV63RYtWtCvXz/OnTvHoEGDuHTpUqE2KSkpfPfdd3qLXrVq1WLAgAFcvnyZZcuWPfRuwNWqVSMsLAxFUZg4cSLvvfceGRkZhdqdOXOGl19+WbveIuSPxnRxceHChQtMnjxZZ7pxdHQ0U6dOBWDSpEk61yoYURoREUFMTIz2eFZWFkFBQVy8eLHU7+NBivuM7zV+/HgURWHmzJloNJoS71wthBCPav31VAD6VS/5xh2VTE14/ylntng1oJalOaP/jmNY1AUuZ982VEwAclNSSF2zFrvnn8fs3h09KrgdN9KZceEqL9Zw4JXaVY2a5fTp/EdxM74Ppv2DiUMmuQcb49PdjGPHyiefMLxivwJXVXUagKIoscCPqqqWflVnIYQQQognUM2aNYmIiOCll15iwoQJfP/99zRp0oSEhAT27NmDRqPh/fffL/X03KL07NmTSpUqsWbNGjp16sRTTz2Fqakpvr6++Pr6YmJiwrp16+jduzffffcdy5cvp3nz5ri4uJCdnc2ZM2eIjo6mevXqvPrqq6V67fDwcHx9fVm7di2bN2+mefPmuLm5kZuby/nz5zlx4gR5eXkMHz5c7yjL119/nZUrVwLw3//+96Gncffv359169YREBDA9OnT+eabb2jTpg3Ozs5kZWURExOjLbz997//1fazsrJi1apV9Po/9u47PKqibeDwbza9kF4JhIRepYXeQUCKEAFRKVLMS5WmHzZUfFHAF8GCBQWR0KRICb2IiICAlNAJBEISSkjvPZs93x8LkZBNJckuMPd17bVkzpw5zy7ZTfLszDx9+rBw4UK2bt1Kq1atiI+P588//yQnJ4eRI0cybty4fNfr2LEj/fv3Z+fOnbRo0YJOnTphbGzM6dOnUalUjBlldzYgAAAgAElEQVQzJm+GaXlo27Ytbm5uBAYG4uPjQ6NGjTAxMaFDhw4F9uGsX78+PXv2ZP/+/ZVauVqSJCkgKoFmVSzxtixQU7VYTapYsrtFXX6+E8P/QiPpfPIqH9R0Z7SHE0blvC8tQOKGDSiZmTiMHlXuY1eUWxlZTLoSTn0rc76oV63c9+strW3btPcDBxbeJzQ2jcUHb9CviTtv/ceVHj2gWzfYswfat6+cOKWKU+K1IoqirJSJQ0mSJEmSpPwGDhzI6dOnGTFiBHFxcWzatImLFy/Sq1cvdu3axaefflpu13Jzc2Pnzp107dqVCxcusHLlSpYvX07gQx/tV6tWjZMnT/Ldd9/RvHlzLl++zKZNmzh+/Djm5ua8/fbbbNmypdTXtrGx4Y8//mDVqlV07tyZkJAQNm/ezOHDh9FoNIwfP559+/YVOvOtdevWeRWGH3dfvgEDBhAaGsoXX3xBu3btCAoKYtOmTfz+++8IIfDz8+PQoUOsW7cu33lt27bl3LlzTJgwgdzcXLZs2cI///xDu3btWLNmDStXrtT5B9pvv/3Ge++9h4uLCwcPHiQwMJB+/foRGBhYaDXlsjIzM2Pv3r3069eP0NBQ1qxZw/Lly/nrr7909u/ZsydAqSpXS5IkPY6Q9EwupGYwyNWuzGMYqwQTPF041LoerWysmHX9LgMCrxOUmlGOkYImO5v4tWux6tgR87pPxjLajFwNb1wKIxeFXxp7Y2VkpO+Q2LoVfHzg/hbIBSiKwqytFzEzUvHxiw2pVQsOHwZXV+jVCw4erNx4pfInSrrHgBAiBd0FUwBQFMWmvIKqSD4+Psrp06f1HYYkSZIkVaigoCAaNGig7zAkKc+2bdvw9fWldevW/PPPP/oO56nRvHlzzp07x+7du/P2ppTKl3w/laT8FoZGsigskrPtG+FWDgU8FEVhc1QCH9+4S4paw5ueLkyr4Yq50eNXq0/cspV7H3xA9Z9/xrpjh8cer6IpisL0q7fZEBnPqibe9HLSf8GRiAjw8IDPPoNZs3T32RJ4h7c2nudT38aMbFsjrz0yEnr2hBs3YPNm6Nu3koKWykQIcUZRFB9dx0qzc/cU8icPTYDmwGBgbtnDkyRJkiRJkp5marU6bwZmaaskS4XbunUr586do0GDBuW2NF6SJKkoiqKwNSqB9nbW5ZI4BBBCMMTNgW4ONsy+cZevwqPYEZPIwnrVafsYRUIURSHe3x+zunWx6vBkrJtdHRHHhsh4ZtRwNYjEIcD27dr7wvY7jE/L5rNdQTT3tGN46/yz8d3c4NAh7exDX19Ytw4GD67YeKWKUeLkoaIo/rrahRCBQA/g23KKSZIkSZIkSXoKrFixgsOHD3Py5EmuXLlCmzZtGDp0qL7DeqLFxcXx7rvvEh8fz+7duwH44osv9L4fliRJz4aLqRmEZGQx0dOl3Md2NDXmu4Y1GOJmz8xrd/A9e4ORVR35sKY7tialmfeklXbsGFnBwbjPm/dEvEcGJqUx6/pdujlU4f+83fQdTp6AAKhTBxo21H18/u4gkjNymD+oCSpVwefZ0VG7bLlvXxg6FFauhBGy5O4T5/HnAcOfwIvlMI4kSZIkSZL0FPnrr7/w9/fn3r17DB06lK1btz4Rf8AZspSUFJYvX86OHTvw9vZm5cqV9OvXT99hSZL0jNgalYCJEPRzrrhZcV0dbDjUuh4TqjuzNiKOzievsismsdTjxK/wx8jZCZv+hv8eGZOdwxuXw3AzM+GHhjUqpHBMWSQlaRN/vr6gK6TjIXH8duYO/+lck/puhe9kZ2sL+/ZB167w+uuwdGnFxSxVjNKn7wt6FYgth3EkSZIkSZKkp4i/vz/+/v76DuOp4uXlRUn3LJckSSpPGkVhW3Qi3RyqYF+GmYClYWVkxCe1PfB1sef/rt3mjUth9HGyZV5dD9zNTIs9PzM4mLSjR3GePg2VafH99UmtUZhwOZyEHDU7WtSp8Oe2NHbvhpwc3UuWM3NymbX1ItUdLJjavU6xY1lbw86dMGQIjB8PaWkwY0YFBC1ViBJ/VwohLpJ/z0MBuAIOwMRyjkuSJEmSJEmSJEmSJAPxT1IaEVk5fFSraqVds5mNJXta1uWn29EsDIuk8z8pzKpVlderOqIqYnZevP9KhLk5dq+8UmmxltW8m/f4OzGVb+p70qSKpb7DyScgQFsxuW3bgseWHArhZmwaK8e2xsK0ZBWhLSy0lZuHDYO33oL09MKLsEiGpTQp7U2PfK0BYoBDiqJcLb+QJEmSJEmSJEmSJEkyJFujErBQqejlVPjy1IpgohK8WcOV/i52zLx2m/eC77AlKoGF9apT18q8QH91TAzJO3Zg9/IQjO3tKzXW0toRncgPt6MZVdWRV9wd9B1OPpmZ2pmHw4aB6pEN725Ep7LkUAgDmlalS13nUo1ragrr18PYsfDhh9oZiHPn6l4WLRmO0hRM+W9FBiJJkiRJkiRJkiRJkuHJ0SjsjEmkt5MNVkYlm2VW3rwszNjYtBYbIuP55EYEz5+6xtQarkyp4YLZQ9mt+F9/RVGrcXj9db3EWVLBaZlMv3qLljaWfFrHQ9/hFHDwIKSmFlyyrCgKH2y9iLmJio/6F1JFpRjGxuDvD5aWMH++NoH41VcFk5SS4TCcxfSSJEmSJEmSJEmSJBmcwwkpxOfkMshVvzP5hBC86u5ID0cbPr5+l4VhkWyLTuDL+p60srVCk5FB4rr1WHfvjqmXl15jLUqKOpexl0KxUKlY1sgLUwPMmgUEQJUq0L17/vbNgXc5GRrP54Oa4FzFrMzjq1SwZIk2gfjVV9oE4k8/gZ5y01Ixik0e6tjrUBdFUZSm5ROSJEmSJEmSJEmSJEmGYmtUAnbGRnR1qKLvUABwNjVhSSMvBrsl8+612wwIvM4oDyemnTpMbmIijmNG6zvEQimKwvSrtwjNyGJj01pUNTe8gi65ubBtG/TtC2YP5Qez1Ll8uf8aTavZMtSn+mNfRwhYtEhbTOXTTyEjQzsj0cTksYeWyllJZh4+utfhw5yBsUDZ082SJEmSJEmSJEmSJBmk9FwNe2KT8HWxM7gZcs872nC4dX0+D73H8lvR9Fy6HMf6DbBo2VLfoRXq+1vR7IpJYnatqnSwN4xk7KNOnIDo6IJLln/95xYRSZksGNIUlap8NikUAubM0c5AfP99bRGV9evzJy0l/Ss2eahrr0MhhAXwNjASuA68W/6hSZIkSZIkSZIkSZKkTwfikknL1fCSnpcsF8bK2IhP61Rj8LULmEVFMKffYKwuhzG3TjVczQxrCtvRhBTm3bzHi852TKheukIjlSkgQDv7r0+ff9vSs9V8/+cN2tZ0oENtx3K/5nvvgZUVTJ2qTVpu3qxNKEqGoVQfGwghVEKIccANwA+YAjRTFGVvRQQnSZIkSZIkSZIkSZL+BEQl4GpqTDs7a32HUiT7Desxdnen3eCB/B6XTKeTQayJiEOjFLcLW+W4m5nNuMth1LI046v61REGWl5YUWDrVujRA2xt/21f8XcYsanZzOxdr8JinzIFli+Hffu0S6ZTUirkMlIZlDh5KITwBa4A84GvgHqKoqxSFAN5JUqSJEmSJEmSJEmSVG6S1bn8EZ/MQBd7jAw02QWQceky6adO4fD660yt5cHBVvVobG3J/127zaCzN7iRnqnX+LI0GvwuhZGtUVjRxBtrY8OtCnL5MoSE5F+ynJSew09/hdCjvgstazhU6PXHjoW1a+HoUejZExISKvRyUgkVmzwUQnQQQhwF1gIBQC1FURYqipJV4dFJkiRJkiRJkiRJkqQXu2MSydIo+Lra6TuUIsWvWIHKygq7IYMBqGVpzuZmtfiyXnWC0jLpceoaX4dFkq3R6CW+D6/f5WxKOosbeFLb0lwvMZRUQID2fsCAf9uWHgkhOVPN273qVUoMr72mXbZ89qy22nNMTKVcVipCSWYeHgGaA0uBaGCsEOKtR28VGqUkSZIkSVI58vLyQgiBEIKdO3cW2q9x48YIITh06FDlBVfJwsLCePfdd2nVqhVOTk6YmJjg4OBAmzZtePfdd7ly5Yq+Q5QkSZL0ZGtUIl4WpjSvYribz+VERJC8dy92L7+MUZV/C5AIIRhW1ZEjrevTy9GWz0Mj6XU6mMCktEqN79d7cayOiGOKpwt9nQ07CQva5GHbtuDurv06JiWLX46G8WLTqjSsalNpcQwcCNu3w9Wr0KULRERU2qUlHUqSPLyFNmnoi3aPQ123NysqQEmSJEmSpIr0wQcfoNHTTAR9++yzz6hbty4LFizg5s2b+Pj4MHToUNq2bUtYWBgLFiygSZMmfPvtt/oOtdRGjx6NEAJ/f399hyJJkvREisnO4UhCCr4u9ga7Px9A/Jq1ADiMHKHzuIuZCcsae7GqiTfJ6lz6BV5nVvAdUtW5FR7b+ZR03g++Qyd7a971dq/w6z2uW7fgzBl46aV/277/8wbZuRpmPF+n0uPp3Rv27oXbt6FzZwgPr/QQpPtKUm3ZqxLikCRJkiRJqnSWlpZcvHiRtWvXMnLkSH2HU6lmzpzJwoULsbGxYdmyZYwcORKV6t/PlRVF4ffff+f9998nJCREj5FKkiRJ+rA9OhENGGyVZYDc1FQSN27EpncvTDw8iuzby8mWdnbWzLt5j1/uxrI3NonP61ajp5NtkeeVVXyOmjcuheJkYsyShl4Yqww3AfvAtm3a+wf7Hd5NzODXf24xpEU1ajrrp2BOly5w4AC88AJ06gR//AF1Kj+P+cwrVbVlSZIkSZKkp8nUqVMBmD17NtnZ2XqOpvIcOHCAhQsXYmJiwv79+xk1alS+xCFol3v16tWLEydO8Morr+gpUkmSJElfAqISaWhlTj0rw92jL3HTJjSpqTiMGVOi/lWMjZhftxo7WtTBysiIkRdDGX85jJjsnHKNK1dRmHg5nOgsNT839sbJtNh5WwYhIAAaNIC6dbVfLz5wHYCpeph1+LA2beDPPyEjQzsD8fJlvYbzTCpNtWUhhJgkhLgshEgXQtS83/6eEGJoxYUoSZIkSZJUMQYPHkzr1q0JDQ3lxx9/LPF5MTExfPPNN7zwwgt4e3tjbm6Ora0tbdu25fvvvyc3t+BSqLCwMIQQeHl5oVar+fzzz2nQoAHm5ua4uroyatQobt26pfN6Bw4cYPLkyTRt2hRHR0fMzMyoUaMGo0aNIigoqNSP+7PPPgNg4sSJtGnTpsi+JiYmtGvXrkD7sWPHGDx4MG5ubpiamuLm5saQIUM4ceKEznEe7DMZFham83jXrl117i/5cPuZM2cYMGAAjo6OmJub07RpU5YvX56v/4PneeXKlQCMGTMmb3/LB8uYjxw5ghCCBg0aFPq4Y2NjMTc3x8LCgri4uCKeIUmSpKfPrYwsTiWnGfSsQ0WtJmHVaix8WmLRpEmpzvWxteJAq7q84+3GnpgkOv1zlXX34lAUpVxi+yI0kr8SUphXtxrNbQx3v8iHxcfDX3/9u2Q5JCaVTYF3GN7WEw87C/0GBzRrBocPgxDa2YiBgfqO6NlSmpmH04AP0RZOeXi+7V3knoeSJEmSJD2h5s+fD8DcuXNJTU0t0Tn79u1j+vTpXL58GW9vb1566SVatGjBuXPnePPNNxk8eHCRf4C88sorzJ49G09PT3x9fTEzM2PVqlW0atWKa9euFeg/YcIEli9fjrGxMZ07d6Zv376YmpqyatUqfHx8OHr0aIkfb0JCAkeOHAFg1KhRJT7vYUuWLKFTp05s2bIFT09PhgwZgqenJ5s3b6ZDhw4sW7asTOMWZe/evbRr147Q0FB69epFy5YtuXDhAn5+fixatCivn7W1NaNGjaJWrVoAdOjQgVGjRuXdateuTadOnWjatClXr17l4MGDOq/3888/k5WVxauvvoqjo2O5Px5JkiRDti06EYCBLoZb4CPl99/JiYjAsYSzDh9lqlLxlpcbf7SqRz0rc2Zcvc3L50IITc96rLj2xiTxdXgUw9wdGFH1yfn5sXMn5Ob+u2T5q9+DMTNWMalrbf0G9pAGDeDIEbC2hm7d4NgxfUf07CjN3NkJwH8URdklhPjsofZAoFH5hiVJkiRJUkXas2cPkZGR+g6jVNzc3OjTp0+5j9u9e3d69erF/v37WbRoEbNnzy72nJYtW3LixIkCs/bu3btH37592bZtGxs3btS53Dc8PJyMjAzOnj1Lw4YNAcjOzuaNN95gzZo1jBw5kpMnT+Y7Z+HChXTt2hU7u3//iFMUhaVLlzJhwgTGjRvH5cuXS7Sh/dmzZ9FoNJiamvLcc88V2/9R58+fz1vuvXHjRl5++eW8Y+vXr2f48OFMnjyZdu3a0bhx41KPX5j//e9/LF++nLFjx+a1PXi+5syZw8SJE7G0tMTJyQl/f39Gjx5NSEgIfn5+jB49usB4U6ZMwc/Pjx9++IHu3bvnO6bRaPjpp58AmDx5crk9BkmSpCfF1qgEfGws8bQw03coOimKQtwKf0xqeGLdtetjjVXHypytzWuzJiKOT0Mi6HbqKm97uTGhugsmpdynMCQ9kylB4TStYsG8OtUeK67KFhAAHh7QsiVcjkhi54V7vNmtNs5VDOt7oFYt7QzE55+HXr20FZkf+TEuVYDSzDysAVzS0Z4D6H8OqyRJkiRJUhnNnz8fIQSLFi0iJiam2P4NGjTQudzX3d2dBQsWALBp06ZCz//oo4/yEocApqamfPvtt9jY2HDq1Cn+/vvvfP19fX3zJQ5Buyfh+PHjad++PUFBQVy5cqXYuIG8x+fg4ICxcen3YFq8eDFqtZpXX301X+IQyGvLycnhm2++KfXYRRk8eHC+xCHAiBEjaNCgAcnJyZw+fbpU4w0bNgwHBwe2bdtGREREvmO7du0iLCyMVq1a4ePj89ixS5IkPUmupWVyJS3ToJcsZwQGknnhAg6jRiGMjB57PJUQvO7hxJE2DejhaMPcm/d44cw1ziWnl3iMNHUuYy+FYaIS/NzYG3OjJ6fERHq6tqrxwIGgUsGX+4OxMTfmP51r6js0nTw9tQlEb2/o1w9279Z3RE+/0vzGeBNoATxaHLsvULLfViVJkiRJMggVMYPvSdaiRQuGDh3Khg0bmDt3Ll9//XWx56jVag4ePMjx48eJjIwkMzMTRVFISUkBIDg4uNBzR4wYUaDNzs6OF198kbVr13Lo0CE6dOiQ7/idO3fYtWsXV69eJTk5OW9fxQczSIODg2nUqOIXg/z1118AOmfzAYwdO5YNGzYU2LvwcfXv319ne/369QkKCiqQACyOhYUFfn5+LFiwgKVLl/LJJ5/kHfvhhx8AOetQkqRnU0BUAipggAEvWY7398fI1ha7B2tsy4mbmQnLG3uzOyaR94Pv0PdMMP+p5sw7Nd2wKiJJqSgKb127zfW0TNY1rUV1c9Nyjaui/f67thjJSy/BmfB4/rgazcze9bC1MNF3aIVyc4NDh7SzD319Yd06GDxY31E9vUqTPFwIfCeEsES752E7IcRI4B1gbJFnSpIkSZIkGbjPPvuMzZs38+OPPzJjxgxq1KhRaN/g4GB8fX2LLFaSnJyss93Ozq7ALMIHvLy8AG2i8GGzZ89m3rx5qNXqUl/vUc7OzgDEx8eTm5uLUSlnbNy9excAb29vncdr1qyZr1958fT01NluY2MDQGZmZqnHnDx5MosWLWLZsmV8+OGHGBsbExISwr59+3B0dJRVpiVJeuYoisKWqAQ62VfB2dQwE0fZ4eGkHPgDx3HjUFlWTDGSvs52dLSvwmchEfx0J4ZdsYksqFud7o42OvsvuxPDtuhEPqjpTheHKhUSU0UKCABbW+jcWWHkims4WZsypoOXvsMqlqMjHDwIffvC0KGwciXo+HxWKgclnkerKMoK4BNgHmAJrAb+A0xVFGVDhUQnSZIkSZJUSWrXro2fnx9ZWVl8/PHHRfYdMmQIQUFBDBgwgKNHjxIXF4darUZRlLyCJ+VVsXHz5s3MmTMHCwsLli1bRkhICOnp6SiKgqIovPbaa6W6XvPmzVGpVGRnZ3P+/Pkyx1WS/RVLQ6PRFHlcpSr/5V+enp4MGDCAiIgIAgICAG0xGEVRGDt2LObm5uV+TUmSJEN2NiWd8MxsfF0NeNbhylUIY2Pshw+r0OvYGBuxoF51AprXxkKlYtiFm0y+Ek5sdv4P8o4npvLfkAj6ONkyxdOlQmOqCGo17NgB/fvDP+Gx/BMaz5vdamNpWvqtTfTB1hb27YOuXeH112HpUn1H9HQq1W9hiqIsUxSlBuACuCmKUk1RlOUVE5okSZIkSVLl+vjjj7G0tGTNmjVcuqRrq2e4evUqFy9exMXFhS1bttChQwccHBzyZvDduHGjyGskJiaSlJSk81hYWBgAHh4eeW2//fYbAPPmzcPPz4+aNWtiYfHvdtPFXe9R9vb2dOzYEYCVK1eW6tyHY7t586bO4w/aH34MoN3XESi0onV4+KM741SOKVOmANqlypmZmaxYsQKVSsXEiRP1Eo8kSZI+BUQlYioEfZ1s9R2KTrmJiSRu3YpN//6YuFROoq6tnTUHWtXjLS9Xtkcn0vlkEBsj41EUhcisHMZdDsPL3IxvGniW+wdrleHvvyEuDnx9Fb7Ydw0POwtea6N7tr+hsrbWVovu0wfGj4evvtJ3RE+fMn2EqyhKrKIo0eUdjCRJkiRJkj65u7szbdo0NBoNH3zwgc4+8fHxAFStWlXnkt+1a9cWex1dfZKSkti5cycAXR+qHPngetWrVy9wTlBQEGfPni32eo968NiWLFlSoLLzo9RqNSdOnMj7ukuXLgCsWrVKZ/8VK1YA+R8D/JtMvHr1aoFzLl26xO3bt0sWfAk9SFYWtdQboFu3bjRu3Jg///yT2bNnEx8fT58+fQpdli1JpaXk5Og7hEqnKAq5xbz2JMOTqyhsi07geUcbbE0Mc9ZZwoaNKBkZOBSy725FMVOpeMfbnd9b1aWmhRlTg27x6vmbvHEplLRcDcubeGFj/PiFW/Rh61YwMwNjrygu3Eli2vN1MHsCH4uFhfaxDB4Mb70Fc+fqO6KnS4mTh0IIByHEEiFEsBAiUQiR/PCtIoOUJEmSJEmqLO+88w729vbs2LGD0NDQAsfr1KmDSqXi0qVLHD58ON+xFStWsG7dumKvMWfOnHz7Jebk5DBt2jSSkpJo2bJl3sxA0BYEAVi2bBnZ2dl57dHR0YwaNarY5JguvXv3Zvr06eTk5NCzZ09WrVpVYNmwoigcPHiQ9u3bs379+rz2qVOnYmxszLp169i6dWu+c3777Tc2btyIiYkJU6dOzXesR48eACxYsCDf/oy3b99m9OjR5bbM+4EHycqi9qV84M0338yLDWDSpEnlGov07Ir7+Weud+5CViEzdZ9W5/btZOmk0eRklX4vUkl/jiemEpWtxtdAqywr2dkkrFmDVfv2mNerq5cY6ltZsL1FHebXrcaZ5DTOJKfzVf3q1LeyKP5kA6Qo2v0On++p8MORa9R0tmJQc4/iTzRQpqawfj2MHAkffggffKB9jNLjK83Mw+VAH8AfmA5MeeQmSZIkSZL0xLOzs+P9998HID09vcBxZ2dnJk2ahFqtplu3bnTv3p1hw4bRpEkTxo4dy3vvvVfk+J6enrRv355mzZrRp08fXn31VWrVqsXKlStxcnIqMKNv+vTp2NrasmvXLmrXrs3LL79M//79qVWrFqmpqfiWsdLkl19+ySeffEJ6ejqjRo3CxcWFvn37Mnz4cPr370/VqlXp0aMHgYGB1K377x9pTZs25ZtvvkGj0TBo0CDatm3L8OHDadOmDUOHDgXgu+++o0mTJvmuN3nyZKpXr86pU6eoV68egwYNonv37jRo0AAbGxvat29fpsdRmIEDB6JSqfj666/p3bs3b7zxBn5+fhw7dqxA35EjR2Jvr/1juWbNmrzwwgvlGov0bFLHxxP7wxJyExK4M2Uqualp+g6p0lw5fJD0pERuX7mo71CkUtgalYCVkYqehRQF0bek3btRx8TgMGaMXuNQCcEYDyeOtKnPb01rMdDFMJOtJXH+PISHQ+0edwmOSuWtnnUxNir/PYYrk7Ex+Ptrly/Pnw/Tp0Mx2ypLJVCa74oewCuKosxTFMVfUZSVD98qKkBJkiRJkqTKNmXKFKpVq1bo8W+++YalS5fStGlTTp48yZ49e3B1dWXPnj2MGzeuyLGFEGzcuJGPPvqImzdvEhAQQGZmJiNGjODUqVM0bNgwX/+aNWty9uxZXn31VRRFYceOHQQFBTFu3DiOHz+OrW3Z9qUSQjB79myuXbvGzJkzqVGjBidOnGDDhg38/fffeHp68t5773HlypUCM/EmTZrEkSNHeOmllwgNDWXjxo2EhYUxaNAgjh49qvM5sLe35++//2b48OGo1Wp27drFnTt3mDlzJnv37sXEpHyrejZr1owNGzbQqlUrjh07xi+//MLy5csJDg4u0NfS0jIveTlx4sQKKc4iPXvilv2MJjMTt9kfkx0ayr1Zs8p9hq0hSomLJTLkOgChZ8/oORqppLI1GnbFJNHHyRYLA0weKYpC/Ap/zOrUxqpjB32HA4C7mSmdnsDKyg/buhVUxhpOZVynobsNfRu76zukcqFSwZIlMGMGLF6sTSTm5uo7qiebKOkPMCHEDWCgoiiXKzakiuXj46OcPn1a32FIkiRJUoUKCgqiQYMG+g5DekhYWBje3t7UqFEjrzCKZBiio6OpXr06RkZG3LlzBwcHB32HJBmQsryf5kRGEtKrNzb9+lF1/jzili8n+ouFuMycieMbYysoUsNwbt8u/vhlCQ5Vq6HJzeWNxcv0HZJUAvtjk3j9Yihrn6tJDwOceZh27Bi3xr6B+9zPsBs8WN/hPDWaNgVV3XASal1ixehWdKv/5FWLLoqiwOzZ8OmnMGyYdkZiOX9W+VQRQpxRFMVH17HSfKQwC1uN1pIAACAASURBVJgjhLAun7AkSZIkSZIkSf/mzp1LdnY2o0aNkolDqVzELvkRRVFwmjwZAIexY6nSqxfRixaRduIfPUdXsa6fOo591Wo0692PxKh7JNy7q++QpBLYGpWAg4kRne0NcyZd3Ap/jJycsHnxRX2H8tS4eRMuXsklu851fGrY07Wes75DKndCwJw52uXLv/4KQ4dCVpa+o3oylSZ5+CHQC4gWQgQJIS48fKug+CRJkiRJkiSp3B07dgw/Pz+6devG4sWLsbW15aOPPtJ3WNJTIDs8nMTNm7EfOhTTatrCA0II3OfNw9TLi7tvvUVOZKSeo6wYmamp3LlykTqt2uLdTDt5JfScXLps6NJyc9kbm0x/ZztMVELf4RSQdf06aUeO4DB8GCpTU32H89TYtg2qtAgjTZPFzN71EMLw/u/Ly3vvaZcvBwSAry/o2NJaKkZp6q9vqrAoJEmSJEmSJKkSBQcHs3z5ciwtLenYsSNffPEFVatW1XdY0lMg5rvvEcbGOE0Yn6/dyNqKat99S9iQl7kzbRo1Vq9+6hIhoWdPocnNpXardti5uWPvXpXQc2do0WeAvkOTirA/NpkMjYaXDLTKctzKlQhzc+xefVXfoTxVNm/PwaFDCJ3qOtOmpqO+w6lwU6aApSX85z/Qty/s2AFVDHOirUEqcfJQUZT/VmQgkiRJkiRJTzMvL69noljCk2L06NGMHj1a32FIT5nM4GCSd+7E0c8PY+eCSwDNatbEff587k6bRtS8ebh/8knlB1mBrp86jpW9A2616gDg1awlFw/sIyc7CxNTMz1HJxVma1QCVc1MaGNrpe9QClDHxpK8bTu2gwdhbG+Yyc0nUXQ0XFaHYmuaw//1qqvvcCrNG29oE4gjR0LPnrBnD8hvq5IxvDJKkiRJkiRJkiRJT6CYxYtRWVsXWRTFpncvHN4YS+L6DSRu2VqJ0VWsnOwsws4FUtunLeJ+xXLvZj6oc7K5c/minqOTCpOQo+bP+BQGutihMsBlqwm/rkNRq3EYNUrfoTxVNm7LpopPKG2rufFcNTt9h1OpXnsNNm2Cs2ehe3eIidF3RE+GIpOHQohkIYTT/X+n3P9a561ywpUkSZIkSZIkSTI8GRcukHrgDxzHjsHIrug/xl1mzMCyTRsiP/mEjMuXKynCinXr4nlysjKp3aptXlu1ho0xNjGV+x4asF0xSeQoikEuWdZkZpKwbh3W3bph5u2t73CeKv7/hKAyVTNnyLMz6/Bhvr6wfTtcvQpdukBEhL4jMnzFLVueAqTc//ebFRyLJEmSJEmSJEnSEynm668xcnDAfuTrxfYVxsZ4fLmI0MFDuDt1Gl6bfnvil2TeOHUcM0srqjdqktdmYmpG9UZNCD13Ghhf+MmS3myNSqCWhRlNrC30HUoBSQHbyE1IwGG0nHVYnm7eyyTGLgxPjQd13Z7dTf9694a9e6F/f+jcGf74A2rU0HdUhqvImYeKoqxUFCVLCGEMxAA777cVuFVOuJIkSZIkSZIkSYYl7cQJ0o4dx2n8OIysS7ZvnLGjI9UWf4M6OpqIme+g5OZWcJQVR6PJJeT0P3g398HI2CTfMa9mPiRG3iMhUk7tMTSRWTkcS0zF19XO4CrtKhoN8f7+mDdqhGWrVvoO56ny4a/XQShM6/5szjp8WJcucOAAxMVBp05w/bq+IzJcJdrzUFEUNbAFeHbT0pIkSZIkSZIkSY9QFIWYr77G2M2t1NVgLZ57DtdZs0g7epSY776roAgrXsS1IDJSkqndql2BY97NWwIQelYuXTY026MTUMAglyyn/vUX2WFhOIwZY3CJzSfZrbh0jkffRn2tOr49LfUdjkFo0wb+/BMyMrQzEJ+SnSTKXWkKppwHaj/OxYQQJkKIHkKIRUKI0/f3S8wWQtwVQmwSQnQt5vxhQogjQogkIUTq/TEmCyFk4RdJkiRJkiRJkipd6p+HyDh/HqfJk1CZlb6isN0rQ7EdNIi4JT+ScvDPCoiw4t04dQIjY2O8m7UocMzerSp2bu6EnTuth8ikomyNSuQ5awtqW5rrO5QC4lf4Y+zujk3vXvoO5any5f5gNLmCLs51MC5uE7tnSLNmcPgwCKGdjRgYqO+IDE9pkm6fAIuEEL5CiOpCCIeHbyUcowtwAHgL8AAOA1uBeGAw8KcQYo6uE4UQ3wNrAR/gCPA7UBf4DtgkE4iSJEmSJEmSJFUmRaMh5ptvMK1RAztf3zKNIYTA7eOPMG/YkIh33yU7PLyco6xYiqJw49RxPJs0w9RC90wm72Y+3L58kZzsrEqOTipMaHoWZ1PS8TXAWYcZly+TfvIkDiNGIExMij9BKpHgqBS2nb9L8hkvXhlgeAljfWvQAI4cAWtr6NYNjh3Td0SGpTQJt11AE7TLl8PQ7oEYA8Tevy8JDbAZ6KwoiruiKP0VRXlFUZQmwKtALvCREKLbwycJIQYDk4BI4Ln7570E1AGCgJfQFneRJEmSJEmSJEmqFMl79pB17RpOU6Y8VpJDZW6Ox+LFCJWKO29OQZOeXo5RVqzYW2EkRUfpXLL8gHezlqhzsrlz5VIlRiYVJSA6AYCBLkVXBteHeP+VqKyssBv6sr5Deaos2n8NI8WYnAu16CUndOpUq5Z2BqKrK/TqBQcP6jsiw1Ga5GG3h27dH7o9+LpYiqIcVBRliKIoR3Qc2wD43/9yxCOH379//66iKNcfOicKmHj/y/fk7ENJkiRJkiRJkiqDkpNDzOLFmNWti03fPo89nmk1D6ouWkTWjRvc++hjFEUphygr3o1TJ0AIarVsXWifao2aYGxier/qsqRviqKwNSqRtrZWeJib6jucfHIiI0neswe7IUMwqiJLLpSX87cT2Xc5iqwLNenVxRQLwyuubTA8PbUJRC8v6NcPdu/Wd0SGocTJNkVR/irqVk7xnL1/X+1BgxCiGtASyAZ+0xUXcBdwA9qWUxySJEmSJEmSJEmFSgwIICf8Fs7TpyNU5TOHwbpjB5ynTSV51y4SVq8plzEr2vVTx6latwFWdtrlr2vXav/oVqm092vXgompGdUaNSHsnCyaYgiC0jIJTs80yEIp8atXg0aD/ciR+g7lqbJw/zWqmJpy96A3Zdxh4Zni5gaHDkHDhuDrC9OmFXxfe9aU+KecEOJNIcSjMwIRQowQQkwqp3jq3L+/91Bb8/v3lxVFySjkvFOP9JUkSZIkSSqUl5cXQgiEEOzcubPQfo0bN0YIwaFDhyovuEowevRohBD4+/tX2jU1Gg3r1q3j5ZdfxsvLC0tLSywsLPDy8mLQoEGsXr2arCy5H5r0ZNBkZRH7/Q9YNG2Kdbeu5Tq247hxWHfvTtSCBaSfMexkW1J0FDFhN6nTSjuHY+1aGDcOwsNBUbT348Zp272btSThXgSJkfeKGVWqaFuiEjAW0N/ZsJYs56amkbjxN6r07oVpNQ99h/PUOB4Sx5HrsdTJqYUq15j+/fUd0ZPByUm7bNnLCxYv1v2+9iwpzUdk04HbOtrDgBmPG4gQwg0Yff/LzQ8d8r5/X9TOwbce6StJkiQ9BTTZuWTfTdV3GNJT7oMPPkCj0eg7jKfa9evXadasGcOGDWPz5s04ODjQt29fXnzxRVxcXNi+fTuvv/46devWJf0J2usNICwsDCEEXl5e+g5FqkSJ69ejjozEecYMhBCF9tOk55B9L61UYwuViqr/+xwTj6rcmT6dnOjoxw23woScPgFArfvJw1mz4NGXcHq6tt27WUsAuXRZzxRFISA6gc72VXA0LZ9yu7mJiWReufLY4yRt2YwmJQXHMWPKIaqKp0nPMfjfUxVFYeH+a7jamBG0owZduoBDScvdStjaQmZmwfYH72vPktIkD6uhO4F3h4eWGZeFEMIYWAPYAn8oirLjocPW9++L+qn74BWrc1MEIcQ4IcRpIcTpmJiS1naRJEmS9C0x4AbR358lNzlb36FITylLS0suXrzI2mft4+NKFBYWRvv27bl48SL9+/cnJCSEwMBANm3axMaNGzl58iT37t3j/fffJzIykuxs+XqXDJsmLY3Yn5Zi2a4tVm3b6OyjKArp56KJXHSG6G8DUccVtoBKN6MqVaj27bdoUtO4O30GSk5OeYRe7m6cOoFT9RrYu1UF4NYt3f1u3QJ7dw/sXN0JlUuX9ep0cjp3MnPKZcmyoigk7dhJSN9+hA4eQsb582UfS60mfuUqLFq0wOK55x47toqU7/X93VmybiXrO6RC/XktmjPhCbzSqA5XLxvJJctlcOeO7vbC3u+eVqVJHkYCzXS0t0Bbcflx/Aj0QDuzscDS6MelKMpSRVF8FEXxcXZ2Lu/hJUmSpAqQE5VG+tlo0ED6BfnBj1Qxpk6dCsDs2bNl0qqCjBgxgtjYWHx9fdm2bRve3gUXijg7OzNv3jyOHj2KmZmZHqKUpJKLX72a3Ph4XKZP13lcnZBJnP9l4tdfw8jODIQg9e+IUl/HvG5d3D/7lIzAQKIWfPG4YZe79OQk7gRdpnarf7ed9/TU3dfeHjQa8GrWktuXL6KW77d6szUqAXOVoI+T7WONk3P3LrfHjydi5kxMPDwwdnbm3sezy5zoTjlwgJy7d3EYM/qx4qpo+V7f9maoqpiSuOUGSq7hrWDQaBS+2BeMp4MlWVerA8jkYRkU9r5WWPvTqjTJw1+BxUKInkIIk/u3XsDXQJk/rhdCfAO8gTY52UNRlMhHujyYVWhVxDAPZiemlDUOSZIkybAk/x6OMDHC2NmC9PMyeShVjMGDB9O6dWtCQ0P58ccfS33+vn37GDBgAK6urpiamuLu7s5rr73GxYsX8/Xbu3cvQgiaNy98e+b4+HjMzMwwMzMjPj4+r/3AgQNMnjyZpk2b4ujoiJmZGTVq1GDUqFEEBQUVOl5aWhqzZs2iVq1amJmZUb16dSZNmkRcXFyh58TExPDNN9/wwgsv4O3tjbm5Oba2trRt25bvv/+e3NzcUjw7cOjQIf7++29MTU1ZsmQJqmKKSrRq1QqLR0pApqWlMXfuXJo2bYqVlRVWVlY0a9aMefPm6Vzi7O/vjxCC0aNHFxqTEIKuXbsW2p6Tk8PcuXOpX78+5ubmuLi4MGLECG49Ms1g9OjRecnQ8PDwvH00H17G3KNHD4QQrF+/vtDH/fbbbyOE4J133iny+ZH0Lzcxkbjlv2DdowcWTZvmO6ZoFFKO3iXqqzNkhSZh278mLpObYdnUmbTTkWjSS59Use3XD4dRr5OwejVJOwrfn1UfbgaeQlE01G7VLq9t7lwwMsrfT6WC+Hjo3BmMHFuizs7izpWLSJVPrVHYHp1IT0dbrI2Nij9BByU3l/iVKwl5cQDpp8/g+sH7eK1fh+tHH5J17Rrxq1aVadz4Ff6YeHpSpXv3Mp1f0XS+vic1w35ALXIi00g9WvoPCCra7kv3CLqXzFs967Jjm4qWLaF6dX1H9eSZOxcsLfO3WVpq258lpUkezgb+BvYB6fdve4BjwEdlubgQYhEwFYhBmzi8rqNb2P37GkUM9eAlEFZEH0mSJOkJkX0nhYxLcVh38sDKx42c2ymlXvIlSSU1f/58AObOnUtqasn3Lpo2bRovvPACe/bsoVatWvj6+uLu7s769etp3bo1u3fvzuvbs2dPqlatyrlz57hw4YLO8datW0d2djYvvvgiDg9tSDRhwgSWL1+OsbExnTt3pm/fvpiamrJq1Sp8fHw4evRogbHS0tLo1q0b8+bNIzY2lj59+tC6dWvWr19PmzZtSEhI0BnDvn37mD59OpcvX8bb25uXXnqJFi1acO7cOd58800GDx6Moiglfo62bdsGQO/evXFzcyvxeQ/ExsbSrl07PvzwQ27fvk3v3r3p3bs34eHhzJo1i/bt2+dLtJaHnJwc+vTpw+eff07t2rXp06cPKpWKtWvX0rFjRxITE/P6duzYkcGDBwNgZWXFqFGj8m5DhgwBYMqUKQD88MMPOq+XkZHBihUrUKlUTJw4sVwfi1T+4pb/giY1Fef7s5YfyI5IJfqHcyTtvImZty2uM1pSpaMHQiWw7uiBkq0h9eSjcyRKxuX//g8Ln5bc++gjMq9dK4+HUS5unDpBFUdnXLxr5bXVrw+5udp9woSAGjVg1Srw94egIOj3ahMUYcINAy8E87Q6mphCbI6al1zLVigl8+pVwl59jaj5n2PZyodaO7bj8PrrCCMjqjz/PNbduxPz7XdkF7bOsxDpgWfJOH8eh1HasQxNUa9v80aOmDdwIPlAOOp4HZvj6Yk6V8OX+4Op51oFH5eqHD8uZx2W1fDhsHSp9v3swfva0qXa9mdJiXdIVRQlB3hNCPEx/y5fPldIwq9YQogFwFtAHPC8oiiF7bB69v59IyGERSEVl1s90leSJEl6giXtD0dlaUyVTh5oMtUk7Qkl/XwMNt2fsfUBFSg4+FNSUguftWaIqlg3oG7dMn1eWaTu3bvTq1cv9u/fz6JFi5g9e3ax5/z4448sXryYRo0asWnTJurXr593LCAggJdffpnhw4dz8+ZN7O3tMTIy4vXXX+fzzz/H39+fL7/8ssCYK1euBCgwY27hwoV07doVO7t//9hTFIWlS5cyYcIExo0bx+XLl/MVbfj44485deoUTZo04cCBA7i4uACQmJhIv3792L59u87H1bJlS06cOEGbNvn3cbt37x59+/Zl27ZtbNy4kVdeeaXY5wjgzP0EQatWrYrpqdukSZO4ePEinTp1Yvv27XnPQUJCAv379+fYsWNMnjyZdevWlWl8XY4dO4aPjw8hISF5z1tSUhLdu3cnMDCQ77//nln3d0n38/Pj+eefZ/PmzTg5OemsXv3iiy9So0YNjhw5wqVLl2jcuHG+4+vWrSMhIYF+/frpXNItGQ51TAzxq1dj078/5vXqAqDk5JL8x21SDt9BZWGMw6v1sGjqnO/1aFrVGrPadqQei9AmHIxLM38DhIkJ1b76itBBg7kzZSrem37DyMamXB9baeVkZhJ+PpAmPXrne6wffgiOjnDzJjwaYp8+MGOGOdduNyFpxxks6kOHDpUc+DNua1QiVYxUdHco3fePJjOT2B+WEPfLLxjZ2FB14UJs+vXN938vhMDtow8J6defyP/OofrSn4osJvSw+BUrUNnaYvfSS6WKq6KV5PUthMBuYG2ivjxNQsANnMY0KvHjrkhbAu9yMzaNn0a2ZNdObTwyeVh2w4c/e8nCR5XuJxdwP1m4B9j9GInDz4GZQALQU1EU3R/Ba693GwgETIGXdYzVBW3BlkjgeFnikSRJkgxH1s0ksoITqNK1OipzY4ztzDH1spFLl6UKNX/+fIQQLFq0iOKKq+Xm5jJnzhwANm7cmC9xCODr68v48eNJTExkzZo1ee0PkoJr165FrVbnO+fKlSucOnUKNzc3XnjhhQLjPZw4BO0fK+PHj6d9+/YEBQVx5aEqlxkZGSxduhSAxYsX5yXAAOzs7FiyZEmhf9g0aNCgQOIQwN3dnQULFgCwadMmnefq8uC5fDiGkgoPD2fTpk2oVCqWLVuW7zmwt7dn2bJlqFQqNm7cyO3bt0s9fmGEEPzyyy/5Yra1teXdd98F4I8//ijVeEZGRkyaNAnQPfvwQduDPpLhiv3xJxS1Guc3JwOQGZJI1NeBpBy6jWVzF1zfaollMxedr68qnTzQJGeXeQ9fY2dnPL75hpyICCLeeRdFzxXiwy4Eos7Jzrdk+fBh2LsX3nuvYOIQwMUF1q6FLgNbYmd2lwG9I5k0CZKSKjHwZ1hmrobdMYn0dbbD3KjkaYC0E/9wc+BA4pYuxfbFF6m5aye2/fvp/D43cXfHZdpU0o4cIWXPnhKNn33rFikHDmD/yiuoHl0bqkeleX0b25lh08uLrOAEMi48bjmIx5elzuXrA8E0rWZLr4auBARA7drQqJG+I5OeZKWqzS6EmAy8C3jc//oO8D9FUXSvw9A9xmf3x0hEmzgsyWzB+cBvwP+EEMcURblxfywX4MG1P1cUxfB2KZUkSZJKTFEUkvaHoapiinU797x2y2bOJAaEkBOZholbUVvgSiVVETP4nmQtWrRg6NChbNiwgblz5/L1118X2vfcuXPcu3ePRo0a0bBhQ519unTpwvfff8/x48fzlq3Wq1ePtm3bcuLECXbv3s2AAQPy+j+YdTh8+HCMjQv+enbnzh127drF1atXSU5Oztt7MDJSuwwyODiYRvf/Kjhz5gypqal4eHgU2NcP4LnnnuO5557jfCFVMdVqNQcPHuT48eNERkaSmZmJoiikpKTkXasyHDlyBEVRaNeuHfXq1StwvGHDhrRp04bjx49z+PBhhpfTlABPT0+aNGlSoP1BkjgiovT7Wvn5+fHJJ5+wZs0a/ve//1GlShUA/vnnH86cOUPNmjULJI0lw5Jz9y4JGzdiN2gQxs5Vid8UTPrpKIwczHF6ozHmdYquXGtW1x5jF0tSj9zFsrnuBERxLFs0x/W994j67DNif/wRZz0mnG+cOoG5lTXVGmjfdxQFZs2CqlVh8uSiz+37mg8rTi5j4rDTzP+pP9u2wQ8/wMCBlRD4M+xgfDIpuZoSL1nOTUoiasECkjZvwcTTE88Vv2DVrl2x59mPGEHS9h1EzpuPVceOxc6SjV+1GoyNsTeQaV2a9BwSd4dqX9+O5jj5Nca8dvGVqa3bVyX9bDSJO0Iwr2uPyqJUqZZy9es/t4hIymTBkKYkJwv++AOmTdMuuZWksirxd7QQ4gPgfWAh8GBznU7A50IIG0VRPi/BGAOAWfe/vAFMKeQH59WHx1MUZZMQYgkwEbgohDgA5KCt0GwDBADflfSxSJIkSYYpMziB7LBk7HxrIUz+3fPGorETidtDSD8Xje0LclmfVDE+++wzNm/ezI8//siMGTOoUUP3dss3b94EKLBUWJdHZzGOGTOGEydOsHLlyrzkYW5ubt4MRV1FPmbPns28efMKzFZ8WHJyct6/79zfa6qoJbBeXl46k4fBwcH4+voWWYjl4WsVx9nZmatXrxIdHV3icx64e/cuUPTjqFmzJsePH8/rWx48CymfaHP/D+DMzNLvaeXg4MDw4cP5+eefWb16dYGZiBMnTiy2mIykXzHf/4AQAqtuQ4n88gya9Bysu1TDpocnKtPi92gTQlClkwcJm6+TFZKEee2y7TlnP3wYGefPE/vtd1g0box1585lGudx5KrV3DxzkpotW6O6vz/d3r1w9CgsWQKP1DwqwN69KraubtT0OMOJE/3x89Mupxw8GL79Ftzdiz5fKputUYk4mRjT0a5Kkf0URSFl714i584jNyEBx//44TRpEqri/mPvE0ZGuM35L2EvDyV60Ze4//eTQvvmJiWRuGULtn37YuJa+hnq5UlRFDIuxpK4PQRNeg5VulSjSglf3wBCJbAfVIfo786StDcU+5fqVHDEuqVnq/n+zxu0q+lIh9qObNgAOTlyybL0+ErzW8oEYJyiKP9VFOWP+7dP0Cb0Srq7s8ND//YBRhVyK/DRq6Iok4DhaJcwdwF6o01AvgkMVhSldOX/JEmSJIOiaBSS94Vh5GCOlU/+wgpG1qaY1bYn/XxMqYo1SFJp1K5dGz8/P7Kysvj4448L7fdg1p+Hh0e+Ahm6bj169Mh37iuvvIKFhQU7d+7Mq3p84MABIiIiaNmyZYH98DZv3sycOXOwsLBg2bJlhISEkJ6ejqIoKIrCa6+9BlBur4shQ4YQFBTEgAEDOHr0KHFxcajVahRF4dr9Qg2luVbLli0BOHXqVJljKu+9ozTFLPesqCTegxmoS5YsASAuLo6NGzdibm7O2LFjK+SaUvlQ1GqSAgIwb9qb5H3xGNma4TK5OXZ9vEucWACwbOaCytqE1COlKybxMCEE7nP+i1ndutyd+U6pC1OUh7tXL5OZlkrt1tpZaBqNdtZhzZpQkm9lIQTezVpy69IFmjfN5vRpmD8fdu6EBg20hQj0vCr7qZOizuX3uCQGuNhhrCr8PTXn3j3uTJzE3RlvYeLqivdvG3F5++0SJw4fsGjUCIeRI0ncsIH0wMBC+yVs2IiSno7DmNGlGr+8qROziFt5hfhfr+a9vm1L+foGMPWwxrqDB2n/RJIVpp/1+Cv+DiM2NZv/610PIQQBAeDqCm3b6iUc6SlSmrm0LoCu3/xOAq4lGUBRFH/AvxTXfPT8X4Ffy3q+JEmSZLgyLseSE5GG/dC6OjeTt2zqTMJvwWTfSsGshn43ipeeXh9//DGrVq1izZo1zJw5U2ef6tWrA9p9AHUVyCiKra0tvr6+rFu3jl9//ZUpU6bkjaFr1uFvv/0GwLx58/Dz8ytw/MaNGwXaPDw8AAgLCys0Dl3Hrl69ysWLF3FxcWHLli0YPVLxUte1ijNgwAC+/vpr9u3bR1RUFK6uJfqVEfj3cTyY6anLg2MP+gKYmpoCFFo5Ozw8vMQxlKfnnnuOzp07c/jwYQ4fPsyJEyfIzMxk9OjR+aprS4ZFURRyE5MwVplg5N4d277eWHfwQBiVPqktTFRYt6tK8u/h5ESnY+JStv3dVBYWVPt2MaFDXubOlKl4rfsVlbl5mcYqixunTmBsaobXc80B2LIFzp6F1avh/suvWN7NfDi3bxd3gi7h1bQF772nnXk4frz2tnatNomoY8cCqQz2xiaRqVF4yVX38lslN5eEdeuJ+fJLFEXB5d13cRg5AqFjG42Scp46heT9+4mcPRvvzZsRj3xzKNnZJKxZg1X7dpg/sndwZVE0Cmkn7pG0NwwUBdt+3li3L9vr+wGbnjXIuBhLwtYbuE5pXuoCSY8jKT2Hn/4K4fkGLrSsYU9WFuzeDa++CgZYxFp6wpTmOzkYGKajfRhwrXzCkSRJkp5FSq5C8v5wjF0ssWyme9mKRSNHMFaRIQunSBXI3d2dadOmodFo+OCDD3T2ad26NY6Ojpw9e7ZMCbUxY8YA2n0Ok5KSCgwiGgAAIABJREFUCAgIwNTUlGHDCv6aFR8fD/ybsHxYUFAQZ8/+P3v3HR5VmT1w/Hunz6T3kIRAQq8JhK4oTUQECUVBQMGyoIhYsKCiYuGnoiKwgCiLsoqdhQBSVJReBelNgRBSSO+ZPvf+/hhAMIWUmSTA/TzPPC6Ze997JptMZs6c95zSraPj4uLw8PAgJSWFrVu3lrr/6NGjHD5celbdpWuFhYWVShyCc9BLVfXu3Zvu3btjtVp5/PHHr1n1t3//fkwmEwA9e/ZEEAR2795dZp/FEydOsGfPHhQKBbddsXXzUiLx5MmTZV5j3bp1VX4cFbmUrKxoW/kll6oP58+fz6JFiwB44loN4mR1RrQ5sF3IR7Ja0HceTINpvfC6LaJGiQWPrqGgUlC8vWZb7TWRkYTNeg/LiROkz3ij1qryJUni9O+7adS+A2qtDrsdXn0VWreGi4XQldKwTTuUajWJB/df/lqzZvDrr7BkCRw+DDEx8PbbYLW64YHcZFZm5BGhU9PJu3TC2vznnySNHkPG22+j79CB6DWrCXhofI0ShwAKDw9CX30Vy1+nyfns81L3F65fjz0zE/+LfxNrmy29hKxFh8hffQZNIy9CnonDq2fNfr8BFFolvkOaYM8wUlSDKuPq+HTbGQrNdp69w5l1/+03KCqStyzLXKMqycMZwGuCIGwUBOGNi7eNwHTgdbdEJ5PJZLKbgvFAJvYsEz79GyGUs51GoVOhb+WP8XAWkkPeuixznxdeeAE/Pz/WrFlDYmJiqfvVajWvvvoqDoeD+Ph49u7dW+oYq9XK6tWry0xg9e3bl4YNG7J//35ee+01zGYzgwcPLrP67NKQjsWLF2O94h10ZmYm48aNKzNhZTAYLlcpPvXUU1f1XSwoKGDSpEllJhqaNWuGQqHg6NGjpZKOn3/+Od98802pcypj2bJl+Pv7s3LlSuLj48useszNzeXVV1/llltuwWKxANCoUSOGDx+OKIpMnDiRgitGsubn5zNx4kREUeS+++67KrnauXNnvLy8OHbsWKmYFy5cWKVp0ZURFBSERqMhIyODvLy8Co+Nj4+nYcOG/PDDDyQmJtK5c2c6derk0nhkNSeJEvYCC/ZMI2JRLggCEXOfR+Vf8+o+pacGj7hgSv7IwFFcs6yYV69eBE6aREFCAvnfflvj2CojM/EMRTlZNO3s3AO5bBmcPOlM8lWlskmt1RHRqu1VyUNwDnR4+GE4ccI5QOXVVyEuDnbvduWjuLlkW+1syStiaLDfVW0gRIuFrHnzSBw+AmtSEmGz3qPhfxajiYhw2bW9+vTGq39/sj/+GOsVVd+SJJHz+VI0TZvgceutLrteZUg2kYKfz5Hx7wPYs034jWxB4MNtXfL7fYm+dQD6tgEU/pqMPdvksnUrklVk4bPt5xgcE0brMOcOnYQE8PSEPn1qJQTZDa7SyUNJklYAXYF0YNDFWzrQRZKkBPeEJ5PJZLIbnWQXKdyYhDrCE12bgAqPNcQEIRbbsJzNr6XoZDcjX19fXnrpJQCMRmOZxzz11FM888wzHDt2jK5duxITE8OwYcMYNWoUPXv2xN/fnyFDhpSZKFMoFDzwwAMAzJs3Dyh7yzLA008/jY+PD2vXrqVp06bce++9DBo0iCZNmlBcXEx8OeUEb7/9Nh07duTgwYM0bdqUoUOHMmLECKKjo0lNTb1q0vMlQUFBTJo0CbvdTu/evenTpw+jR4+mXbt2PPzww0ybNu1a37oyRUdHs3PnTlq3bs2aNWto0qQJcXFx3HvvvYwcOZJu3boRHBzM22+/TVhYGFqt9vK5H3/8MW3btmXz5s1ER0czfPhwhg8fTnR0NNu2bSMmJoYFCxZcdT2DwXC5Z+WYMWO49dZbGTFiBC1atODpp5/mhRdeqNbjKI9arebuu+/GbrfToUMHxowZw6OPPlrm90ulUvH443+3CperDusf0WK/mDS0IijtSDYTCk9PVNeYGFsVnreGg12ieNeFGq8VOPkJPG7rSfr/vYPp4EEXRFex07/vQhAUNInrgsUCM2ZAp07Vq2yKiu1EXloKBZnppe4LDYXvvoM1ayA/H3r0gClTnFVUsqr5MSsfh8RVW5aN+/aRGD+U7IUf4zPwLqLXr8Pnnntc3mMWIOSVVxBUKtLf+LtC1rhnD5aTJwkYP94t1yyPJbGAjHl/UPRbMob2QYRM7YRHNaefX4vvPU0QlAJ5CadrpTJ4wabTWB0iz/RzDmoRRVi1CgYOhFrsaiC7gVVpA74kSfslSRorSVLcxdtYSZJK75eRyWQymaySSvam48i34NO/8TVfvOla+CNolRgPyluXZe715JNPEnGN6ovZs2ezZcsWRo0aRV5eHmvXrmXDhg1kZ2czaNAgvvrqK3r27FnmuVcmC0NDQxkwoNSsOMCZeDtw4ACjRo1CkiTWrFnDiRMnmDBhArt27cLHx6fM8zw9PdmyZQvTpk3D39+fdevWsXv3bkaMGMGePXvw8yu779XcuXP59NNPiYmJYe/evaxfv56QkBDWr1/PhAkTKvx+VKRFixYcPnyYZcuWER8fT1ZWFj/++COrVq0iPT2d+Ph4vv76a06dOoX+isb8gYGB7Nq1i7feeovw8HDWr1/P+vXradiwITNnzmTHjh1lVmw+99xzLFmyhPbt27Nv3z5+/fVXmjRpwvbt27nrrruq/TjKs3jxYh555BEcDgfff/89S5Ys4dtyKsHuuOMOAAICAhg5cqTLY5FVjyRK2PPM2LNMSBKoAvWIxjwElQqFp6dLr6UOMqBr6U/J7gtItprNfBQUCsJnzUIdEkLKU09jz852UZRlO/37biJatUHv5c3ixZCUBP/3f86KwaqK6uAcqJR4YH+5xwwaBMePw+TJMH8+tGnjHKwiq7yEjDyaG3S08tDhKCzkwmuvkzT2ASSrlYb/+Q9h772Hqpy/Ca6gDgkm6NlnKNm5i8I1awDI+fxzlAEBeA8e7LbrXkk02clb8RdZnxxGsosEPtwW/5EtUHqo3XZNpbcWnwGNsZzOx+Tm162p+Sa+3nOee+MiiA5yPl/t3g0ZGfKWZZnrCBVlwQVBiKzsQpIknXdJRG7WqVMnad++fXUdhkwmk8kA0eogfdbvqIIMBE1oV6lPfnO/P4XpeA5h07vVahPq682JEydo1apVXYchk8n+4ZlnnmHOnDm88MILvPfee3UdjgwQTTbs+RZwSCg8NSi9NYglxViTklA3aMBfmZkufz41n8kne/ERfIc1xbNLg5qvd+IE50bdjz4mhsjPltS4X11Z8tLT+OypCfQe9y9a3D6EJk2c05F/+616yUNJklgy5VECIiIZ+uK1u2Dt3g2PPgrHjsHIkTB3rnOKrKx8qWYrcbuO82JUKI/8eZiMt97GnpOD/7hxBD05GYWhekN7qkpyODg3ejS288lELFxA0v2jCXxyMkG1UH1tOppN3qoziMVWPG8Nx/uORlWeolxdkiiR9fEh7LlmQqfGoTC4J1n54vLDrDyQyubnexHm6/wA7oUXYM4cyMqCcj5nlMlKEQRhvyRJZfZTuda7rnNAYiVvMplMJpNVSfHONMRiGz53Nqr0lhFDbDCS2YH5VK6bo5PJZDLXSk5OZvHixWg0GiZPnlzX4dz0JLuILduEPceMoBBQBRtQ+WpBAHtGBoJajdJNFVnaaB/U4Z4Ub0tFEmu+pVHXqhWhb8zAuHcvmR/OdkGEpZ3+3dl4sGnn7syf76xqmjmzeolDAEEQaBzbifPHDmOvxFSUbt3gjz/grbdg5Upn4vKzz6CWZsVcl1ZlOtu8dP14HqlTnkIZGEjj774j5MUXai1xCCAolTR4800chYWkvfQyglaLX1Um7FSDo8BC9hfHyVl2AqWnmuAnYvG9O7rWEocAgkLAd1gzRJON/HXuSZmcySpm+R8pjO3W6HLiUJKcvyN9+siJQ5nrXCt52BnocvE2FkgDXgPuuHh7DUi9eJ9MJpPJZJUmmuwUbUlB19IfbePKv7LRNvFF4amWty7LZLLrxrRp0xg7diydOnWipKSEp556qswJ2rLaIUkSjmIrtgwjksWB0keLKthwOakgFhYims2ogoMRFO6pcBcEAa9bw7FnmTD/WfGgncryjY/Hb/T95H7+OYUbNrhkzSud/n03wY2bIKqDee89uPtuZy/CmoiKjcNusZBy8liljtdoYPp05zTmdu3gkUegb1/466+axXEjkkSR5SfP0Or8Wfw3rCP4ualEff8d+nZt6yQeXYsW+I0aie3cOTx69EBVRssJV5BEieLdaaTP3o/5zzx87mpM8ORYNBFebrnetWgaeODZMwLjvgy39Oz+6Jc/0aoUTOrd5PLXjh+H06flLcsy16rwr+HFHof7JUnaDzwGPCNJ0kxJkn67eJsJPAtMqo1gZTKZTHbjKNqWgmSy492/UZXOE5QC+naBmE7kIlpKT5qVyWSy+ubbb7/l66+/RqVS8eKLLzJz5sy6DummJdoc2LNMOPItCBoF6mADSi/N5ep3SZKwZWYiaLUofX3dGou+fSBKHw3F21JctmbItGnoY2NJe/kVLKdPu2zdkvw80v48QdPO3fjwQ8jLc05YrqnINu1RqlScO1i1tlItWsCmTfDJJ85qxPbt4d13wWareUw3AsuZM2x9YgrH1XruzEgmes1qAh59FEHtvh5/lXGpf6jlzz8RK1FtWlW2TCNZnxwmP+EMmoZehD7TEa/bGyIo67bNjXffSJR+WvJWnkayiy5b91haAT8evsDDt0QR6Pn3sLGEi+Nsy5iNJpNVW1V+i7oAh8v4+mEgzjXhyGQymexm4Ci2Urw9FX37QDRhVW9Eb4gJAruI6bi8dVkmk9V/586dQxRFUlNTeffdd1HX8Rv4m5EkSTgKLdgzjUh2EaWfDlWgHkF99dshR34+ksWCOtg9E1ivJCgVePYIx3KmAGtasWvW1GgInzsHhV5PyuQncRS7Zt0z+/eAJOHfpBsffeTsORgbW/N11TodEa3bVTg0pTwKBUyYACdOOKsgX3oJOneG33+veVzXK9FqJWv+AhLjh7LePxRBkhg35XE0kZUeZeC+2Mxm8r//AV379thSU8lZvNhla0t2kcKNSWTM/QNbphG/Ec0JfKQtqgD9tU+uBQqNEr/4ptizTBRtTnbZuh/+/CfeOhX/ui36qq8nJDi3+YeFuexSMlmVkofnKLvCcBKQ5JJoZDJZ5eWcgb2L5UYvsutS0aZkJJuI9x1Vqzq8RBPpjdJXi+lgposjk8lqn9XuIKfYQkVD7GQyWfWJFgf2DCOOQisKnQp1iAGlh7pUclASReyZmSh0ehTe3rUSm0eXUASNkuJtqS5bUx0SQvhHs7EmJ3PhpZdc8txy+vfd+ISEsui/jTGb4c03ax7nJVGxceSmpVCQmVGt8xs0gOXLnT3esrKcSZNnngEX5U2vG8Y/DpA4dBjZ8+fj2b8/WwfG08PPiwY6TV2HBkDB6tU48vIInjoV74EDyVn0CZazNe8DaEkqJGPeHxRuPI++bSChU+Pw6BTi9uR/Vela+KOPCaJwUzK2LGON19uflMtvJzN5rFcTfPR/fyCVnAz79slblt3BmlpM/uozLq0evZ5UJXn4DDBREISTgiAsvXg7AUzEuXVZJpPVpp9ehnXPwZnf6joSmaxK7PkWindfwBAXgjqoes26BYWAISYI81/5OErkPUqy65ckSSTnmUjNN5FVbKnrcGSyG4okStjzzNizjEgSqAL0qAL05W5hdOTlIdlsqELcX3V4iUKvwqNzCMZDWTgKXPcc4NGlC8HPPUfRLxvJ+c9/arSW1WTk/JGDhLToxsKPBcaPh+bNXRMnQONY5ya2xINVrz68Uny8s9fbxInOKbNt24IbWj/WO47iYtLffJOkMWMQTUYafrKI3BlvctZqZ2iIewb+VJUkiuQu/S+61q0xdOlMyEvTEPR60mfMqHZyWzTbyUs4TdaiQ0hWkYDxbQi4vyVKz/qRLC2L76BoBLWS/JWna5TUlySJWRtOEeipZXyPxlfdt2qV879y8tC1RKONnGXHMR3NRjTfnG2TKp08lCRpA9AMWAF4X7ytAJpLkrTePeHJZLIyZf0Jf158NfTrm3L1oey6UvTbecDZ/6Um9DFBIEqYjmS7IiyZrE4UW+yUWOxolAoyCswUm+VkuEzmCqLJji2jBLHEhsJTjTrEgEKvKvd4SRSxZ2WhMBgu92WrLZ63hIMkUbwzzaXr+o8fh/fAu8j6aA4lu3ZVe53Eg/tx2O1s3N8NgNdec1WETv5hEXgHhZBYxb6HZfHxgYULYft2MBjgrrtgzBhnReKNqOjXXzl79yDyvvkWvwfG0mTNGjxvv50VGXmoBYG7g+rHqN3irVuxnj2L/0PjEQQBVVAQwVOnYty7l4KVCVVez3Qsh4zZ+ynZcwHPHmGEPBOHvqV7BrC4ktJLg89djbGcLcC4v/q7Z7afzmZPYi6TezfBoLn6eS0hAVq2dPYFlbmGJErkfHsKR6EV/7Gt6nWC2p2q1DlUkqQUSZJeliRp2MXbK5IkuW7Tvkwmq5zdC0CphTvehAsH4cSauo5IJqsUW7aJkn3peHZtgMpPV6O11A08UAXrMR6Sty7Lrk+SJJFeaEajVNA02BOtSsn5XBPWm3Q7jEzmCpJDxJ5jwp5jQlAIqIIMqHx1CIqKKwkdOTlIdjuqkNrf7qjy16FvG0jxnnREi8Nl6wqCQIO33kITHUXqs1OxpVUvOXn6991oPHxY+EUrHnsMXN0+TxAEomLjSD56GLuLJp7ccgscOAAzZsAPP0CrVvDFFzfO5+22zExSnnqalCcmo/TxofF33xL68ssoPDwQJYnVmfn09vfCT11+wrw25X6+FFVoKN4DBlz+mu+9I9B37Ejme+9hz61cD2tHoZWcr06Q8+VxFAYVwZNi8R3cBIVW6a7QXc6jcyiaRt4UrDuLo7jqQ2MkSeL9n04R7qvn/q5X/zLm5cHmzTB0qIuClQFQuDEJy595+A5ugjaydlpa1EdVSh4KgmAQBKGHIAjxgiAMu/LmrgBlMtk/lGTDoW8hZhR0ewICm8OmmSC67sWmTOYuhb8kISgVePVuWOO1BEHAEBOM9Vwhdhdu9ZLJakuh2Y7J6iDYW4dKqSAywIAkSZzPLUEUb5B3uDJZLZEkCUeJFVuGEdFsR+mtQRVsqFRSQXI4sGdno/D0ROnhUQvRlubZMxzJbKdkX7pL11V4eBAx799IVispU55CtFTt76XDbuPsH7+TZuyKRqvk5ZddGt5lUR3isFnMpJ445rI1tVp4/XU4eNBZhTVuHNx5J5w967JL1DpJFMn7/nvO3j2I4k2bCHr6aaL+txx9+/aXj9lTUEKaxVZvtiybjx/HuGcP/g+MvWras6BQ0OCNGTiMRjLfm1XhGpIoUbz3Aumz92E6kYP3nY0IfrIDmoZe7g7f5QSFgN+wpogWBwXrqt7z8adjGRxOKeCpfs3Qqq5+fvvxR3A45C3LrmQ6nkPRb8kY4kLw6Bpa1+HUqUonDwVB6IdzMMp2nNuVl19x+8Et0clkstJ+XwJ2M3SfDEoV9H4Fsk7CEfnXUFa/WdOKMR3KwvOWcJRerin3N8QEgQSmQzfofiTZDUuSJDIKzWhVSvwMzjdTOrWSCH8DRquDtAJTHUcok10/RJsDe7YJR54FQa1AFWxA6a2tdAWhPTsbyeFAHRLi5kjLp430RtPIm+IdaUgu/vBAGx1F2HvvYj56lIy3Z1bp3OSjh7GajKza2o2nnwZ3fYsi28SgVKlcsnX5n1q3hm3bYMEC2L3b2Qvxgw/Afp21LbOcTeT8g+NIf+11dK1aEbUqgcDHJl6VkANYmZGHXqGgf2D9qJDKWboUhcGA7733lrpP26wZAY88TMGqVeVurbdlGclafJj8FafRhHkS8lRHvHtHltu79HqgDvHA67YIjH9kYj6dV+nzHKLE7F9OER3kwbAO4aXuT0hwTlju1MmV0d687Nkmcr8/hTrMA7/4JvVuCE9tq8pv3FxgLRAhSZLiH7frp05YJrue2czw+2JodicEXexU3eoeaBADm/4P7FUvfZfJakvhL0kIOiVet5V+sVNdqkA96ghPjHLyUHadyTfZMNschPwjweGjVxPspSW3xEpuiVxRK5NVRJIkHIUW7JlGJJuI0k+HKlCPQl35tyaS3Y4jJweltw8Kvd6N0V6bV89wHLlmTMdyXL92v34ETJhA/g8/kL98eaXPO71vNw5JR6Yllueec3lYl6l1OsJbta3x0JTyKBQwaZJzoEr//vD889C1K/zxh1su51KS1Ur2okUkxsdj/vNPGrz9FpH/XYo2KqrUsTZR4sesfAYEeuOhrPu36Lb0dArXrcdnxHCU5UwwD3zsMdSNIrkwYwai2Xz565JdpPC382TM/QPbBSN+w5sR+K921R62V99492mIKkDnHJ5iq1y7ktWHUvkzo5ipd7RA9Y/kqcnkHBAUH+/8eZfVjGh1kLPsOAgCAWNbI1Th78qNqio/Vo2BtyRJcm0nX5lMVnlHvoeSLOgx+e+vKRTQ5zXIT4IDX9RdbDJZBSznCzGfyMXr9ggUBvW1T6gCQ0wwttRibFlGl64rk7mLeLHqUK9W4qMv/fsQ4q3DU6siNd+M0XqdlcbIZLVEtDiwZxpxFFpR6FSoQwwoPdRVrgyxZ2UhiSKqkGA3RVp5utYBKP11FG9Lccv6QU9NwaNHd9LffAvTkaPXPF4SRY7v3MPRlDienarBz827YKNi48hNTaYwy329jCMiYOVKWL4c0tKgSxdnItFYT19CmA4dInH4CLLmzMWzTx+arP0R3xEjyv0535JXRK7NUW+2LOd99RWIIv4PPljuMQqdjgavv44t6TzZn3wCOF83Zvz7AIU/J6FvFUDo1Dg8OofeUJVfglqJb3xT7DlmCjedv+bxVrvIR7/8RZswb+5qW3r77C+/OH+O5S3LNSdJEnkr/sKWYSTg/pao/GvWp/1GUZXk4Q5Antkjk9UVSYJdCyC0HTTuefV9TftCZA/Y8j5Y6+mrH9lNrfCncyg81Xj2cF3V4SWGmEAQ5K3LsutHXokVq10kxEdX5hshQRCI9DegVgiczzFid8gDVGSySyRRwp5vxp5lRBIlVAF6VAH6am1hFG027Lm5KH39UGi1boi2agSFgNctYVjPF2FJKnT9+kolYR9+iDIwgJSnpmDPq3i7ZPqZv7CV5JJc1I0pU1weTilRsc69lu7YunwlQYDhw+HECXj4YecW5rZtncmX+sJRXEL62zM5N+p+HEVFRCxcSMScj1AFBVV4XkJGHr4qJb38674XoFhSQt533+PVvz+aiIgKj/Xo0QPvewaT8/kycr7YT9bHh5DMdgIebE3AmFYua3dT3+ia+WHoEEzRlhRsGSUVHvv9vmTO5xp5rn8LFGUMgEpIcE4bv/12d0V78yjZmYbpYBbe/Rqha14/EvH1QVX+yi4CPhAE4VFBELoKgtDxypu7ApTJZBed3ujsbdj9SeernisJAvR9FYrTnduaZbJ6xHw6D8uZArx6N3TLNDyltxZtlA/GQ1lIN8oYRdkNSxQlMosseGhUeGnLn4J5aYCKTZQ4n2uUf7ZlMkA02Z0DUYptKDzVqEM8UOirP03WnumscFMFV5yQqU2GTqEIOhXF21Pdsr7Kz4+IufNwZOeQNnUqkqP8gXsbf9iFQ1QS/1BnPD3dEs5V/MMj8A4KdtvW5X/y9YVPP3VOp1WrnduZx42DHNfvGq+Sos2bOTt4MHlffYXf/fcT/eMavPr0vuZ5RofI+uwC7g7yQVMP9q3m/28FYmEhAePHVep4n3ufwKPXqxiPleDRtQEhz8Shbx3g5ijrns/dUSi0SvJWni6336nZ5mDer3/RqZEfvVqUfr6y22H1ahg0CDQ3Zp611ljOFZC/NhFdK3+XDHi8kVTlWWU50BL4FNgF7Lvi9rvrQ5PJZFfZNR+8wqDN0LLvb9QDmvaD7R+B2fWfVstk1SFJEgU/JaH00eLZtYHbrqOPDcKeZcKWVvGntjLZJY0bN0YQhKtuOp2OqKgoHnzwQQ4ePFjqnPHjxyMIAkuXLq32dXNKrNgcIqHlVB1eyaBREe6ro9hiJ6PQXOGxtcFisfDpp58yaNAgIiIi0Ol0eHh40KxZM0aPHs3KlSsRRblKUuZ6kkPEnmPCnmNCEEAVZEDlq0Moo/qmskSLBUd+Pio/PxT16N22QqvEs1sopqPZ2HPd83uvb9eW0NdepWTnLrLmzivzGEly9jtMKWzPY0/UQuYQZ9V1VGwc548cwm6z1co1wVmpdegQTJ8OX38NLVvCV185vwe1yZ6dTeqzz5Ly2OMoPAw0+vorQl97FWUlM7cbcwopcYj1Ysuy5HCQ+8UX6Dt0QB8bW+GxjiIrOV+fIP9/51H5eWHc+h5Y/0Chq/4HA9cTpacGn4FRWM8Vljtt/Ytd58gssvD8nS3KfO2wc6cz6S1vWa4ZR6GVnK9OoPLT4n9fixr9jbkRVSV5GFXBLdr1oclkssvSj8DZzdB1AqgqeIHbZzqY8pzbm2WyesB8PBdbchHe/SIRVO77FNzQNhCUAsZD7uuTJLsx3XnnnYwbN45x48bRv39/zGYzX375JZ07d+bbb7916bUcokhWkRkvnRqPCqoOr+TvocXfQ0NmkYUCU+29mf6nvXv30rx5cyZOnMhPP/1EREQEQ4YMYcCAARgMBr755huGDRtG165d6yzG6tq8eTOCINCrV6+6DkX2D5Ik4SixOasNzXaU3hpUIQaXVLHbM7MA4ZrbQOuCZ/cwEAS3VR8C+I4Yge+9I8j59FOKNm4sdf/yL5PxVqfQsns3anNHd+PYTtgsZlJPHqu9iwI6Hbz1lnOASpMmMHYsDBwI5865/9qSJJH/vxWcuXsQRb9sJHDKk0SvWIGhQ4cqrbMyI48QjYruvrWT7K1I0cZfsaUeNLtZAAAgAElEQVSk4P/Q+HKPkSSJkn3ppM/ej+lYDt53NCL05dvQNQ0g84MPsWdn117AdcwQF4ImyoeCdedwFF09ALPIbOPjzWe4rXkQXaPLrsRcuRK0WrjzztqI9sYkOURyvj6BZHYQ8EDrGlW136gq/U5OkqSkim7uDFImu+ntWgBqD4gbX/FxYR2g9RBnlWJJHe+5kN30JFGi4OdzqAL1GDqGuPVaCoMaXTM/TIeyyt3yIZOVZdq0aSxdupSlS5eyevVqzp49y5gxY7Db7UycOJHc3FyXXSu72IpdlAjxrto78TAfPXqNkpRcIxZb+VsM3WXfvn3cfvvtnD9/nocffpjU1FR2797Nd999x//+9z8OHTpEUlISEydO5MyZM7Uen+zGJNlE7NkmHHlmBJUCVbAB5T+mk1eXaDbjKMhHFeCPoHbtEC9XUPpoMcQEUbIvHdHkvqFJIdOno2vblrQXp2E5m3j56w4HrPxsFwCjJ9XuBwKRbdujVKlqbevyP7VrBzt2wLx5sH07tGkDH33k/J64gzUpifMPPcyFV15B27QpUasSCJo0CaGK1bAFNju/5hQyJNgPZT0YKpL7+eeoGzbEq2/fMu+3Z5vI/s8R8pb/hTrEQMhTHfHuG4lCrST0jRlIJhMZ77xby1HXHUEQ8BvaFMnmIP/Hs1fdt2R7InlGG8/3L3v8hCQ5+x326wdedd/q8rpVsC4R67lC/IY3Qx3qUdfh1EvXTB4KgvC1IAheV/z7sX/8208QhK3uClAmu+kVXoAjy6HjA6CvxDaE3q+AzQjbZ7s/NpmsAqbDWdgzjHjf0QhB6f4XsobYIBwFVqxuaDIvu3no9Xo+/vhjPDw8KCws5KeffnLJunaHSHaRBR+9GoOmap9mKxQCjfw9EARIyjHiqMUEuc1m47777sNsNjNlyhSWLFlCcHDpqbSRkZEsWrSIhISEWotNdmOSJAlHkRVbphHJKqL01aIK0qNQu65nrj0jE0GhRBUY6LI1Xc2zZziSVaRk7wW3XUOh1RIxby6CRkPKlCcRS5ytP777DoJUu1H7Ncc3uHa/RxqdnvCWbThXR8lDAKUSnnwSjh2D3r3h2WehWzfn1mZXkWw2sj9dzNl7hmA+epTQGTNo9OUXaKOrt6FvXXYBVkkiPsTXdUFWk/HAAUwHD+L/4IMIyqt/byWHSOHmZNLn/IE1pRjfoU0JmtAedbDh8jHa6GgCJkygcO1airdtq+3w64w62IBXr4aYDmVh/tM5zCi3xMp/tiVyV9tQ2kX4lHne4cPOCtmh5XS2kl2b8WAmxTvS8LwlDENs6dc4MqfKVB6OBPRX/HsWcGV9vwa4xZVByWSyK+z9FCQHdH2scscHtYD2o2DvYihMc29sMlk5JIdIwS9JqBt4oG9XO288dK0CENQKjPLUZVkNeXl50bx5cwCSkq69uaKoqIhPP/2U+Ph4mjZtisFgwNPTkw4dOjBz5kxMJhNZxRZESSLEW3fVuSUlJXzwwQd0794dX19f9Ho90dHR3Hvvvaxbt+7ycRqVgob+BopNZt6dPY+ePXvi5+eHTqejWbNmPPvss2Rllf7ZX7p0KYIgMH78eHJycpgyZQpRUVFoNBriK9Ec6auvviIxMZHg4GBmzZp1zeNvu+22Ul/Lzs7mxRdfpGXLluj1ery9venWrRsLFy7Ebi9dVTVjxgwEQWDGjBllXuPKx1Te14uKinj++eeJiopCq9USHh7O448/XqqStFevXvTu7RxEsGXLlqt6YPbq1QtJkmjWrBmCILB79+5yH/fw4cMRBIGFCxde4zskq4hodWDPNOIosKDQKVGHGlB6alxSbXj5GkYjjqJClIEBCKr6uy1NE+aJtokPxTvSkOzu6yWqDgsjfPaHWM8mkjZ9OlarxHtvZRMZ8Cdd+ndz23UrEhUbR07KeQqz67YVSWQkrFkD334L589DXBy89BKYTDVb13TkKIn33kfW7Nl43nYb0WvX4jdqJEINhpwkZOTTWK+hg5fh2ge7We7S/6Lw9sZ32NXZLGtKEZnzD1K44Rz6Fn6ETo3Ds2uDMvvKBUycgCYqivQ33kSs6Tf8OuLduyGqID15CacRrQ4WbTlDidXOs3c0L/eclSudszMHD67FQG8gtvQS8v73F5rG3vgMjKrrcOq1yjxD/fO3ue7roGWym4W1BPZ9Bi0HgX8Vnsx6vQiSCFvfd19sMlkFSvZl4Mgx492/Ua01G1ZolehaB2A6koXkkIc2yGqmsNBZwaqtRLOvQ4cOMXHiRHbt2kVYWBj33HMP3bt358yZM0yfPp3bb+9FWnYhvgYNuiuqp5KSkoiLi+P555/n6NGjdO/enSFDhtCgQQPWr19fKlknWU1MGhPP9Oef5vCRI3Ts2JG7774bu93ORx99RKdOnThXToOu7OxsOnfuzFdffUVMTAxDhgwhNDT0mo9t1apVAIwcObJS34t/On36NB07dmTWrFkUFBQwePBgbrvtNo4cOcITTzzBXXfdhcViqfK6FSkoKOCWW27hs88+IzY2lv79+2M0Glm0aBF33HEHtisGMQwYMIA7LzaJCgkJudz/cty4cQwYMABBEHjiiScAyk0Mpqamsnr1ary8vHjggQdc+lhuFpIoYc+3YM80IokSqgAdqgA9gtL1vXJtGRkIShWqgPo/xdWzZwSOQiumI+7t/ebRvTtBTz9N0foN/PLkf/Gw7QWgWZfubr1ueaI6dAIg8UDdVR9eIggwciScOOGcxPzuu9C+Pfz2W9XXEo1GMt55l3MjR+LIySH83/OI+Pc81CE1q3TKstrYlldEfLCfSxPt1WFNSaHol1/wGzkShYdz66dodW7FzVxwEEexjYCxrQh4oDXKClp4KDQaQt+YgS0lheyb6EMZQaXAb2hTHLlmzqw7w393nmNoh3CahZS/HzkhAW65BcrYFCC7BtFkJ/vL4wg6JQGjW7nlb86NpP5+3CaTyeDAV2DOhx5PVu08v8bO/oj7P3ee6y/PNJLVHsnmoOjX82givdC19K/VaxtigpzbPU7no29Ru9e+3rz6VwpHi6+vT/Pbeup5q1mE269z8OBBEhOd/b9irzElEpyTm3/99Vd69eqF4orKkfz8fO6//342bNjAsiWLeO/N6ZfvE0WRoUOHcurUKYYMGcLnn3+On9/frSmKiorYu3fvVdeZMGECe3btZOA98bw8cw4xzcLx1KpwOBy8/PLLzJo1i/Hjx7N58+ZSMa5du5b+/fuzfPlyvKrQFGn/fueb986dO1f6nCuNHj2a5ORk7r33Xr744gt0OmflZXJyMv369WPjxo3MmDGDd955p1rrlyUhIYGBAweyc+dOPC9OKU1LS6Nbt2788ccffP/994wZMwZw9rzs1q0bP/30Ey1btixzkvZDDz3E9OnT+eGHH/joo48I+EfS6ZNPPsFut/Pggw9W6XsrcxLNdux5FnCIKDzUKH20bvvQyVFcjFhSgjo0tNR2yvpI19wPVbCeom0p6GOD3JoYCvjXo5QcPEyjXz9geNSt+DUIxz/c/c+3ZfEPb4hXYBCJB/cTc8dddRLDP/n7w5IlMGYMTJgAffvCQw/BBx8477uW4m3bSH99Bra0NHxHjSR46lSULnq+WJWZjwj1Yspy7n+/AIUCv7HO51jzqVzyVp7GkW/Bo2soPndFVXqKskeXLvgMG0bO50vxHjQYXYvyq+9uJNpoXwxxIXywOwlRIfFMv/Ifd2Kiczv9hx/WYoA3CEmUyP3+FI48C0ET2qH0rlqf0ZtRZVOrcvd5may2iQ7YvRAiukDDLlU//7bnQKGGzTdPs2FZ/VC8+wKOQivedzau9U/Adc39EHQqTAflrcuyqsvLy2P16tUMGzYMURSJjY3l9ttvv+Z5ERER9OnT56rEIYCvry8fzP4IgE0bVqNR/Z2sWL16NQcOHKBx48Z88803VyUOwbl1uu8VjeaPHz/Od999R6NGjfju62UEBvpzPseIzS6iVCp55513aNeuHVu2bOHIkSOlYlSr1XzyySdVTm5d2gpdVp/Da9m2bRu///47Xl5eLFq06HLiEKBhw4bMnTsXgAULFmA2m6u8fnk8PT1ZsmTJ5cQhQFhYGJMnTwbg119/rdJ6Pj4+PPjgg5jNZpYsWXLVfTabjcWLFwMwadKkGkZ+c5EcIvZcE/ZsE4IAqiA9Kj+d2xKHkiRhz8hAUKtRVibbUw8ICgGvWyOwpZVgOVvg3msJAqsi3+G8LYK+F7bTvGXbOqtiEwSBqNg4zh89hMNed1Pmy9KnDxw5AtOmwRdfQKtWzh6RUjnvlu25uaQ+/wLJ/5qAoNPRaNmXNJgxw2WJQ4CEjDxae+ho4aG79sFu5CgsJP9//8Pn7oEoPPzI/fYk2Z8fQ1ArCJrYHr+hzSqdOLwk+PnnUHp5kf7aa0jizbOrpKB7CGuwMsRgIMJXX+5xFzcHMGRILQV2AynalIz5RC6+d0ehbVx2P0nZ1Sr72/uOIAjGi/9bA7wuCMKlv2B131hBJrsRnVoHeYnQb0b1zvcKha4TYcdcuOVpCGntyuhksjKJFjtFm5PRNvNF16T2m3YLKgX6tgGYDmcj2RwILmywf6OpjQq+68Glfnf/1LFjR1asWFEqIVgeSZLYsWMHW7duJSUlBZPJhCRJFJudb3wTz5y+6vgNGzYAMGbMGPT68t8YXLJ+/XoABg0ahKeHB400Dk5nFpOUayQ6yAOFQkHPnj05cuQIu3btol27dqUeT+PGjSv1WFxly5YtAAwePBj/MpI1AwYMoEGDBly4cIH9+/dzyy2uaaEdFxdX5pbsli1bAs4qxKqaPHkyH3/8MZ988gnPPffc5Z+LFStWkJ6eTq9evWjdWv47WxmSJCEa7TgKLCBJKLw1KL1c29ewLGJREaLJhDosrEa95WqboUMwBT+do3hbqlv/rhYVwVsfevJA7DgeSn2L4PUbkR6eWOWpv64SFduJwxs3kHryOJFtY+okhvLo9fDOOzBqFDz6qPO/X34J/fvD7NnO/oiRkRIfj1xNky3v4igpIXDSJAIem4jCxd/P8yYL+wqNvBLdwKXrVkf+998jGY3ou91Dxuz9iBYHXn0j8e7dEEFVvd85lZ8fIdNeJO3FaeR9+y3+o0e7OOr66d87ElErFYwtFijZewHPbmFlHrdypXNCeJMmtRzgdc58KpfCjUnoY4Pw6FH291ZWWmWSh1uBK38cdwKRZRwjk8lcaed88G0ErWrQ/faWp5w9EzfNhFFfuS42mawcxdvTEEvs+PRvXGcxGGKDMe7LwHQyF0O7oGufILup3XnnnZcTTVqtlrCwMHr27Env3r0rnczIyMhg2LBh7Ny5s9xjLvVQvOTSIJZLCa1rOXv2LOCs0luwYEGFx5Y1OKVRo0aVus4/BQUFkZycTGZm1QcXpKamAhAVVX7P3ujoaC5cuHD5WFeIjPzny1Qnb29vgGpVObZu3fryNusNGzYwcOBA4O8+iJf6IsoqJtlF7HlmJIsDQaNE6ad16RTlcq8rSc4JyxoNSt+6n0ZbFYJagWf3BhRuPI8t03jVVFpXmjMHsrMhpts5Th2Lps3xP8l4911CX3vNLde7lsi27VEoVSQe3F/vkoeXxMTA7t0wbx68+CKsXev8eoQ6memOGTRetZOCiFjaf/km2mbN3BLDqsx8AIYE1+3PtWS1kvvfL1FHtqNkj4gm0gO/4c1Qh3jUeG3ve+4hPyGBrNkf4dW3X417RNZ3f2YUsfJgKhN6RhOeZqdg/Tn0rQNK9YjMyoLt22H69HIWkpXJnmsm59tTqEMM+A1rVud9Qq8n10weSpLUqxbikMlkV0rZB8m7YcB7oKjBi2qDv7Pn4aaZkLIfIuJcF6NM9g+OEhtFW1PQtQlA07Du+n5po31QeGkwHsy6bpOHexNz+X5fMjOHtkWrkqsn3WnatGn06tWrRms8+uij7Ny5k1tuuYUZM2YQExODr68vaYVW8gqNdIgu/UbnyherjqJi7DnZKD09UXh7l1mZ4nA4AGdVXdu2bS9/3WR1YLY58NCq0Fys7GjTpk2p8ytT3ViWuLg4kpOT+f3336s9DMTVL8zFa2xdq2y1aFU9+eSTbNy4kYULFzJw4ECOHj3K1q1bCQsLq9Tk6pudw2jDkeccjqP01aLwUNfamzZHQQGixYw6IuK6qjq8xKNbAwo3J1O8PRW/Ya5PQuXkOHv3DRtqpSBpP+ED78K/awm5n3+Orn17fKvx871j32rCd7xLQ52a6vwV0wDjmqcinjoEn/y3GivUDiXwjAH6/AtsNvBUFNPAkUbygUDeOjOdXeb7SWzmvp+5FRl5dPb2IFJf9YFWriJabKRNexd7Vib6nvfjO6QJHuVMUa4OQRBo8PrrnL1nCBn/939EzJ3jknXrqw9/PoWnRsVjtzfB0+QgY85+8tecJWBMq6uO+/FHEEWo9T8/DjvsWQTpR2DIAlBeP2M0JJuDnGXHQZIIGNsahUZ+jV0VLv9/WhCEQiBWkqSzrl5bJrtp7JoPWh/oMKbma3V73PkE/9tb8GBCzdeTycpRtDUFyerAp3/1KpxcRVAIGNoHUrznAqLZXuX+OnVNkiTeWHOMY2mFRPjpebqCRtmyuldSUsK6detQKpX8+OOP+F6sajJa7RSYbBRmpZR53qXquJMnT2LrkoZksyEWF0N6OgqdDoW3N0pvbwStFkEQaNiwIeDcZv3+++9fXkeSJM5ml2CyOmgS5IFe49qf93vuuYeEhAS+++473n///SpNXA4PDwf+rposy6X7Lh0LoLmYPC0uLi7znEtVm7Vt0KBBREVFsX79es6dO3e56nDChAmoVNfX80xtcxRbceRbELRKZ1/Dam5hrA5JFLFnZqLQ6VD6XJ99rZSeGjw6hlDyRybe/Ruh9HTt1tdZs5zblic/cIg/vjXTtFM3gtvGYD52jPTXZ6Br0QJdq1bXXuii/6Zm03zb+3gZUziua09bTwPVSSMpfCTyUpLx0fihrqPt05WVnOf8b5w+GX2QlRZ3pdF6x1lWbrMC7ulFeLLExIkSMzObhV/7YDcp2rSPC6+9iiPrHNqW3QmfNQ61X/U+rKqIpnFjAic9TtacuRRt2oRXOS1HrneHkvP56VgGz/Rrjp+HBjzAu08khT8nYTqZi/6KQYQrV0JkJFRirpvrpB2ENVPgwiHnv1sMgDZDazGA6pMkibyEM9jSSggY1xpVoOt/Tm907nilI9d9ymQ1kZcEx1c5Kwa1Lqje0npBz6nw08uQuBWibqv5mjLZPzgKLZTsTMMQG+ySLSo1pY8JonhHGqajOXh0CqnrcKpk19kcjqUV0sBHx8JNZxgcE0aTIM9rnyirEwUFBYiiiK+v7+XEIUB6gRmVQsH6hB/KPO/OO+/kk08+4asvv2Tq0KF4N2uGoNUiFhbhKCzEnpmJPfPiNktvb+7s1YvpOCcJv/POO5eTVYIgEOlvuNz/sGmQJyql6xIzY8aM4Y033iApKYkXX3yROXMqrvjYtm0bPXv2BLg8bGbNmjXk5eWVGgrz008/ceHCBTw9PYmL+7sy/lIi8eTJk6XWlyTpcr9IV7mUrLTb7RUep1AomDRpEs8//zzvv/8+y5YtQ61WM2HCBJfGc6NxFFlxFFgQdCpU/u4biFLu9fPzkaxW1JGR1/X2NM9bwynZm07J7gt493Pdh3RpafDvf8PYsWDL3IVGb6Bh2/YIKhXhsz8kcfgIUp6cQtTyHyq15XvR+Uy+PLKbHQWH2dxxKqO87uGtpuH8q2HVdwLYk5NIeO4J7rjrMdr3G1Cdh1drJr8CIZl7WBo5nlfyZ3F7t9+ZftsH3B+TAOfmQWPX9HS9UkJGPgrgnjrYsmwvKCbtxXcp2bISQedF4LNvEvDocLdVfgMEPPwwBT/+SPpbb+HRpQsKj7p/velqH/x8Cn8PDY/0/Lvdh9dtERgPZpGfcBrtM3EotEqKi+Hnn2HiRKiVpzWrETa/A7sWgEcgjPjcWZiycz60jq+lIGqmZE86xv0ZePVpiL5VQF2Hc126/ur2ZbIb3Z5FICigy0TXrdnpEfAOh1/fKn8cnExWA4W/JSM5JLz7ld1rrLZpGnqh9NdhPFT1Pm11bcm2RAI8NPzwWHd0agWvrDyCJP/e1lshISH4+fmRn5/P119/DUCx2U6xxc6R3VuY89FHZZ43ZMgQYmNjOXf+PA+/8gpFoohCq0UVFIi2STTWsDC2/fUXgkaDPSeHNj4+DO7Xj9OnT3PvsGEkJydfXkutVBDpbyAnJ4/35szHZnPddFKNRsN3332HVqtl7ty5PProo2X2P0xNTWXy5MlXbd/t2bMnnTt3pqioiCeeeAKLxXLV8U8//TTgHEZy5STm3r17o1Ao2LBhAzt27Lj8dYfDwSuvvMLevXtd9vjg72Tl6dOnr5lAfOSRRzAYDCxcuJCioiLi4+Np0KDuBxXUR5Ik4Si04CiwoNCrUAXUfuJQEkXsWVko9HoULpxuWxfUwQZ0Lf0p3n0Byea6qbMzZzq3277+moPT+/YQ3bEzSpUaAFVgIBFz52DLyCD1hRcqnHYrSRKzz6Uz40warxb8gqRQcVvvCQwI9OaNM6nszi+7krgiARGReAUEkXhwX7UfX22ZORMeDlpKjt2frzPHMH7VIgZ+s4LgABssHQirp4Ap32XXkySJlRl59PTzIkijdtm6lZH3w8+c6Xc3JZv/hz6uH03WryVowr1uTRwCCBoNDd54A3vaBbLmV9z793q060wO2/7KZlKvJnhq/67xElQK/IY1xZFvoXCjs/L+55/BYoGhtVH0d2YTfNwdds6DDmPhiT3Qdhh0mwSp+yDZtX+T3cFyvpD8NWfQNvdz6YcvNxs5eSiT1SfmAvjjC2gzDHxcuAVBrYPbX4CUvfDnT65bVybD2Xi45Pd0PDqHoAqoH1sABEHAEBOE5Uw+jiJrXYdTaaczi/n1ZCYPdG9EhJ+BaXe1YvfZXJbvL3vrq6zuKZVKXnnlFcBZpdejRw/uHz2asff0Y9Twe3j22WfLPE+hUPD9f/5Dk8hIEn76icjISAYOHMj999/PrbfeSnhkJP83dy7axo3RtWiBOjycz+bMoWenTiSsWUPzZs3o2rEjI4cPZ8Tw4fTs3oXbY5ow/bmnSMsrcelj7Nq1K5s2bSIiIoIlS5YQHh5Ojx49GDVqFCNGjKBDhw40bNiQBQsW0Lz51dvsv/76ayIiIvjmm2+Iiopi5MiRDB48mBYtWnDy5En69u3LjBkzrjonMjKSxx9/HIfDQe/evenbty9Dhw4lOjqa+fPnM2XKFJc+vkaNGtGhQwcyMjJo3749DzzwAI8++uhV28Mv8fPzY+zYsZf/LQ9KKZszcWjFUWhFYVCj9NfVSdWfIzcXyWZDFRJyXVcdXuLZMxyx2IbxgGs+GEtMhMWLnRODtfaTmAoLaNq521XH6GNjCX35JUq2biN7wcIy15EkiZlnLzArMZ1RQZ7cmbIOofkAFF6hzGvViEidlgnHzpFhqdoHG4IgEBUbx/mjh3DYXfehiDuM6H6W2/SbWc/9WNGh08G2tL4waZdzN9GBL2FBF+fuIhd8IHigyEiS2Up8SO1VHVpTs0gcNYn0V58CQUGD9xbQeNlc1KG1V8VliIvD9777yP3iC8zHj9fadd1NkiQ++PkUod46xnYrndzSNvbBo0soxTtSsaYWs3Il+PvDrbe6MShjLqx8HL6MB0EJ49fCPfNAf3EXQexo0PnCrn+7MYiacxRbyV12AqWPloBRLWr9Q6wbiZw8lMnqk/3/BWsx9Jjs+rVjx4B/tLPE/BrN5mWyqijcmASCgHef+lF1eIkhNghEMB3JrutQKm3J9kQ0KgUPXHzhOKpzQzo18mPmuhPkFFuucbasrkydOpXly5fTrVs3jh07xqZfNqBTq1m2bBkzZ84s8xzJ4aChwYPda9cyc+ZMmjVrxrZt21i1ahVpaWkMGjSIl156CQBBpULl50dgmzb8tmMHSxct4tauXTl77hwrVq9m6+bNOCwW/jX+IZb9kECBFQpNrn2j3b17d/766y8+/vhj7rjjDpKSkli5ciXr1q2juLiY0aNHs2bNmlITp5s2bcqBAwd4/vnn8fLyYtWqVWzevJk2bdowf/581q9fX2YfxXnz5vHee+8RHR3N9u3b2b59O127dmXfvn106NDBpY8NYMWKFdx3333k5ubyzTffsGTJEtZeGp36D3fccQfgHExzaWu27G+SJOEosCAWWVF4qFH6aeskcSc5HNizslF4eqL0vDFaP2ijfVA38KBoe4pLKtLfeAOUSue01tO/70apUtE4pvRwPd9Ro/CJjyd7wQKKNm++6j5Rknjlr1Tmn8/kwbAAZgtHEYzZ0HEcAN4qJUvaNqbILvKvY+ewVvE1aOMOcVhNJtJOnaj246wNuUv/i6DR8Mae+xFF2LoViothzgIP6P82/Os38AyB7x+Eb8dAYVqNrrcyIw+tQuDuIPcnD0VRJGv+V5wdOBDzoa149h9F09/W4Tukj9uvXZbgqc+i9PPjwmuvI10cJna923Qqk/1JeTzZtym6cibQ+wxojMKgJnfFX6xbKzF4MLil3a4kweEfYH5nOPI99HwOHt8Jjf+RqdR4QOdH4MSPkFs/x11IDoncr0/iMNoJGNMKhaF2q3RvNIKrt0LV94EpnTp1kvbtq/+l77KbkMMGc2OcCb7xP7rnGod/gBWPwvAl0G6Ee64hu6nYMkrImPMHnj3D8R0YXdfhlJIxZz+CVkXw4zF1Hco15RRb6PHubwzrGM47w9pf/vqfGUXcPW8bg9uHMXtk5btinzhxglZVaHAvqzlJkvgrsxhRkmge4oWigoSJ7WJPQ210NAqDoXrXE0XEkhIchYWIRUVIdjsIAma1jiKVnpCwQLS6+j1k4Ho0dOhQEhISWLhwIY8//nhdh1OvSJKEI8+CaLSh8NSg9NHUWcWfK37HLhVt5SsAACAASURBVKlPz6clBzLJ++4UAQ+1Qd/C/9onlOP4cWjXDp59FmbNkljy1L/wbxDOsJfeKPN40Wzm3P2jsaWmErX8BzSRkTgkiedOJfPNhVwmNgxiRpMwhGXDIeskPH0EFH8nQRIy8v6fvfMOj6Ls+vA927O76Y0UEhICBJAiINIJHUQBUSxYEPR9fSVYsYuIDT8rNhBUilgRBaQoUkTpvQhSAiGd9J5s353vj4FISO8J7H1duUh2ynNm2ZmdOc85vx//O5nAg0E+vNk+uNpxWowG5j84mZ5jxzPonqm1Pt6GxJaTw7khQ3EfN46A118reX3iRNi6Varw9PJCcqndOx+2vQUyBYyYAz2nQQ3bfe2iyPW7/6GXm44lXcKq3qAOGE+eJ2XmS1jjjiL3b0vgW2+i79f091T5GzZwYebT+L/4Il7339fU4dQJh0Nk7Cc7KTbb2DpzMMpKdIsNxzLI+f4Ms7eEM/7lIMaPr+dg8hJh/ZNwbgsE9YRxn4B/54rXL0iFD7tAr6lwU9lq/aYm79fzFG1PwXNSe3Q9W5YGelMhCMIhURR7lbesISoPnXWgTpzUhpO/QEGK1NrQUFx3G/h1hm1zpRsYJ07qSMHmBASVHNfBrZs6lHJx6eaHJaEAW66pqUOpkm/2JmK2OXhwQOkkbHt/Vx4e1JZVR1LYda7lVFFei+QbrZisdlq5aSpNHIo2G/asbOSubnVKaggyGXJXV1RBQag7dEAVFobCywuNaMPXkIPjXAzm83HYsrJxWFpO+35z5tChQ6xduxZvb2/uv//+pg6nWSGKIvYck5Q4dGvaxKF0jmXV+Rxrjmi7+CB3U1G0I6VO+5k9G3Q6eO45yEpKID89jYjefStcX6bREPzJxyAIJD/6GOZiA9EnE/g+NYen2vhLicP8JIj9Q9JFk5Wunprg78nDwb4sTsni57ScasepctESFNmJuKOHan2sDU3u998jms14PTCl1Ouvvy65WL/zzsUX5Aro/zhM3w3BPWHDTFg6BjLKmkNVxp68IjIsNib4e1a9ci1xWG1cmP0R8ZNuxZp0Cve7o4nYsqZZJA4B3G66Cd3AgWR++CHW1NSmDqdO/HoilVOpBTw1on2liUMAl66+nLd58uygBIb2rseOFIcd9iyA+X0gYQ+Mfhse3Fx54hDALQC6TIIj34Axt/7iqQcMxzMp2p6Crk+AM3FYT9QpeSgIQoQgCFd6z48B6vZt5sTJtYYowu5PwLsdRIxouHFkMhg6C3Ji4dh3DTeOk2sCS3IhxhPZ6AcEIdc1zzYAbTfJ3dFwLLOJI6kck9XO13vjGRrpR4Rf2fa6GUMjaOOt5aXVxzFZr44WnasNURRJLzCjUcpxd6n8fLBlZSE67Cj8/eptfEEQkOt0KAMC0LRvj611KDkaN6wWK9a0VMwxMZhjY7FmZuIwO1vga8pDDz3EXXfdxZAhQ3A4HLz22mvorkKnz9oiOkRs2SYcRhtydzUKt6ZpVb6EdI456vUcay4IChm6foGYz+VhuVBzExKAQ4fg559h5kzw8YFzB/aAINC2542VbqcKDibovXcxx8Sw9omnWZOey6zwAJ4NC5D+v498I614/b3lbj+rbSB93HU8fSaJk0XGascb1r0nWYnxFGY3vwk0h9lM7nffoxs8CHXbtqWWde4M99wDH38MpfJbXuFw3xqY8BlknYGFA6RqRFv1rs2r03PRyWWM8HarxyP5l8Idhzk3bDz5Py5EFdqZNitXE/jKDGTKhuiRrR2CINDqldmIDgdpFciDtARsdgcfbIqhg78rt3QLrMYWAk+vj0ClEDFvjq2fINKOw5fD4fcXJFfw6H3Q539lJgAqpG80WA1wcGn9xFMPWDMM5K48iyrEFY+bm19nVEul2slDQRDmCoIw5eLvgiAIm4EYIFUQhJJvGlEUd4qi6LwrdeKkJiTsgtSj0sW3gZ3K6DAGgnrBn2+DtflXYzlpvuRvSkCmVeA6sB7NfeoZhZcGVYgrxmaePFxzJIWsIgsPDSy//UijlPPmrV2IzzYwf9u5Ro7OSXXINVgx2+z4u1VuDCFardiyc5C7eyDTXDn/Wj8IgoCruysKPz/O6/0wBoWi8Jdm3W3p6ZjPnsV09izW9HQcRqPTzbsaLF68mJUrV+Lj48O7777L9OnTmzqkZoOUODQimmzIPdTIXZu2Vb4xzrGmRt+7FYJKRtHO2tVrzJoF3t7w5JPS3+f27yWwXSQ6j6or2WT9+rPt9slct2Mbi0/uY0boxYoeh11KHrYdCh7layArZQKfd26Du0LBtBNx5Fur1wUT1l3SYWyO1Yf5a9diz87Ge2r5LdVz5khu1mXyW4IgGU5EH4DOE+Cv/4OFAyFxb6XjmR0ONmTmM8bHHZcqqtRqir2wmKTo2ST/9z4c+Zn4PDabsPXf4NKxYVuja4sqOBjfGdEUbdlK4ZYtTR1OrVh1OIXzWcXMHNkeeTWMPA4dggNnNCS0CsF0MhvjP3VIqFuNsGUOfB4F+UmSrNXkH8Gjht1Era6D8CGw/3OwNX2Xg8NkI/vrkwgqGV73dERQOG0+6ouavJP3AGcu/j4G6A70AZYD/1fPcTlxcm2x+1PQekO3uxp+LEGAYbOhIBkONZ8ZIictC/P5fMwxubhGtUamaT4z0eWh7eaLNbUYa3r9OtDWF6Io8uXOODoFuNE3vGLHwv4RPky8PoiFf8VyNr2wESN0UhUOUSS9wIRWpcCtivPBlpkJiCj8fBs8Lj9XNW4aJSnFDixunqjbtkXdoQPKgAAEhQJbZibm2FjMMTFYU1OxFxc7E4kVIIoidrud8+fP8/TTTzd1OM0G0SFiyzIimu3IPTXI9U2vsdmY51hTIdMq0fVqheFYJvaCmtVsbN8OGzfC88+DmxsUZGaQER9bacvyJQptdiYfi+XNqJvI79uP8IXzMRw+LC2M/UOS3+lReTu/n1rJF9e1IcVkZcapRBzVuOZ4tw5F7+1DfDNLHoqiSM6yr1B37Ij2xvKrNtu2ldysP/9c0j4sg94XbvsS7vlJqt5aMgrWPwWm/HL392dOIXk2O7fWc8ty7qotnBs2lqKtK9F0jyL81w34Tr8bWUMXNdQRrylTUHfoQNrrb2Avql0lblNhttn5cEsM3Vp7MKJT9dpq16yRTI663BuEspWOvF9icZhrIUUVtx0+6wc750HXuyB6v6SHX9uK8b4zoDAV/llVu+3rCVEUyV0Zgy3biNfdkSjcyxqyOak9Nbka+APJF3+/CfhRFMX9wCdA/dveOXFyrZB1DmJ+gxseAqVL44wZPhjCBsP298Dcsr5onTQ9oiiSvykemZsKfd+Apg6nSly6+oLQfFuX/4zJ5FxGEf8ZFFZlm99LYzuiUyt4cfVxHA5nkqe5kFNswWp30KqKVk2HxYItNxe5hyeychyG6xtBEAj2ckGpEEjMMWC1O5AplSi8vVGHhaGJjEQZFIRMo8GWk4MlLg7z6TNYUlKwFxYi1tAV1cm1hWh3SIlDix25l6ZZyFc09jnWlOj7B4JDpGh39V17RRFeegkCAyE6Wnrt3EGp0i2iV+Uty7lWG3ccjeVAQTHzrwvjho/moQwMJOXxJ6SE7aFloPWBDjdVGccN7jpejQhkc3YBHyakV7m+IAiEde9JwvGj2G3NR7O7eMcOLLGxeD8wpdJr/6xZUsLn1fK9aCTajYDpe6HPdGlyf/6NkovtFaxOz8VLKWeQp2s9HAFYU7OIm/woaS8+CqJIqzc+Juz7+aiCWkbyXVAqCXjtVWwZGWR+9HFTh1MjvtuXyIV8E8+M7FBtmYfVq2HQIPDxk+ExMQJ7oYWC3xOqP6ghB36Jhq9ukS4I9/8CE+aDtvbmSwBEDAPfjlJBTBNOQhZtT8b4Tzbuo8PQtG14J/JrjZokD7OB0Iu/jwS2XvxdgdMkxYmT2rN3PsjVcMN/GnfcYbPBkAX7PmvccZ20eEwxuVjiC3AbGoKgrKYeShMid1WhbuuB4Vhms6yq+nLHeVq5aRjbpWqtG2+9mhdv6siB+FxWHExqhOicVIXdIZJRYEavVqDXVKF1mCElsBuzIkohkxHqpcPuEEnMNpSq8hEUChSenqhCQ9FERqJq3RqZXocjPx9LQgLm06exJCVhz89HtDu1Np38S0ni0GpH4e2CXNv0iUMAW0YG0LjnWFOh8HbBpbM3RXvTcJird35u3Ag7d8LLL4PLxfnqcwf24h0cgmdAxRIkmRYrtx89xz9FRhZ3DmOCvydyNzeCP/kYe2EhyY/NQDy9EbrfDYrqVZ9ODfLhdn9P3o1LY2t2QZXrh3XvicVo4ELMqWrtvzHIXroUhZ8fbmPGVLpeUBDMmAFffw2nKgtfrYfRb8FDW6SOpBX3wIp7JUdboNhu5/esAm729UBZjRbXynA4HGQuXEHsmLGYjvyBfugk2m7ZgOftDai93kC4dOuG5913k/vNNxiPH2/qcKqFwWJj/rZz9A33pn9ExV0nlxMTI7mkT5gg/a0OcUPXJ4CiPRewJFXRkSKKcGIVzO8NR7+H/k/A9D0QHlWn4yhBECT5rfTjEPdX/eyzhpjO5ZK/MR6XLj7om7GkUkumJsnDn4HvLmodegG/X3y9O+AUYHLipDYUZ8PR76DbnVLbQmMS3EuaHd71SbNzx3LSfBEdIgW/xyP30qDr1XKcy7TdfbFnm7AmN69K25MXCth1Lpsp/dqgqqYmy6SewdwY5sVbv54io9CpW9rUZBeZsTkc+LtVrq3mMJux5+Wi8PJCpmzcRIuLSk6QpwvFFhtp+eV/ZgS5HLm7O6rWrVFHRqIKDUXm7o6jqAhLUhKm06exJCRgy81FbEaVP04aH9HmwJZpRLSJKLxdkLk0D+kKh8mEPS+vSc6xpkI/MBjRZMNwqOrqPYdDqjoMD4dp06TXjIUFJJ86QcQNFbcsp5otTDxyjvMGM8u7hjHa171kmaZDBwJefw3jkb/JOKyF66vvQC4IAu90aE0nvYbokwkkGCtvvw65rjsyubzZ6B6aTp/GsGcvnvfdi6CqOmH63HOSu/Xs2dXYeVBP+O+fMOwViNkkVSEeXMqmzDyMDkedW5aNZxKIu+V+sj6cg8zVm+BFy2m94DUU7mUN21oKvk8+gcLHh9TZr7SI76ilu+LJKrLw9KjqVx3+8ov076XkIYD7qDbI9CpyV51FtFcwQZ6fDN/fBT9NBfdg6bM14tX673jrMgl0vrBnfv3utxrY8kzkfH8aha8Lnre3a1LDrquZmiQPnwI+Ak4CI0RRvCQeFQA4S5ecOKkNB5eAzQR9optm/CEvgbkAdrWsMn8nTYfxRBbWC8W4DQ9pUQLELp19QC5gOJrR1KGU4sud59Gq5EzuXb64fHkIgsDciV0wWR28sb75VGBci9jsDjKLzLhplOjUVWgdpmcgyGQofJumIspTq8JHryaryEyeoXJBc0EmQ+7qiiooSEoktglD4eWFw2TCmpKC6fQZzHFx2LKzcVitjXQETpoDos2BNcuIaBdR+GialeatLSOzSc+xpkAd6oYqxJXCnSmIVUhZ/PwzHDkitc5eynWdP3wA0eGgXQV6h4lGMxMOn+OC2cp33doS5VXW3df95pvx7CInJ0ZP/r6zNYpfK5ex+LowRODBE/EY7RVLJai1WoI6dCL+yMEajdFQ5CxdhqDV4nnHHdVa38cHnnoKfvpJMr2oErkSBj4lVYcFdIX1T9Dxp9vpa7vAje61c3p3WG2kvvYp8beNxxJ/HPdJDxOx5RdcB/Ws1f6aE3JXV/xnzcJ86hQ5y79u6nAqJd9gZdFfsQzv6EfP0OongtesgR49IOSyW0aZRoHHuLZYU4sp2nWFgZLDDvsWScnnuO0wai48uEX6PDUESg30/i+c3QSZZ6pev54QrQ6yvzmFaBPxvq8Tsirux5zUnmo9+QmCoATmAj+Lovi4KIpHLi0TRXGeKIpfNlSATpxctVhNkitVxAjwi2yaGFpdJ4nj7lsIhVXPWju5thHtIgWbE1D4adF292vqcGqEzEWBpoMXhr+zqnzAaizSC0ysO3aBO3q1xr2GLX9tffVMH9KWtccu8OeZ5pUQvZbIKjJjd4hVVx0ajdgL8pF7eyMomu6mtpW7Bp1KQXKuEZO1em2OgiAg1+tQBgSgbt8edXg4Ch8fRKsVa2oq5jNnMMfGYsvMxGGumXGDk5aFw2rHmmkAh4jC16VZPaA1l3OsKdAPDMKeY8J0MrvCdWw2qeKtUye4++5/Xz93YA96bx/8wtqW2SbWYGLCkXPk2eys7N6Wvh4VVKUl7MI/MgmXDq1JffllTGdiahR/Gxc18zuFcqLIyHMxSZXKi7Tp3pPMxHgKc+rgMFsPWNMzyP/1VzwmTkTu7l71Bhd56inw8pI0EKuNd1uYso7isR/TKi+GlXvuR7b9vRq72hbtPkbsiInkfTcfZetI2qxYReDrTyBTXz1Vuq4jR6CPiiLzk0+wptTOibwx+HxHLAUmGzNHdqj2NmlpsGdP6arDS7hc540m0ouCzQnYci92F6SflMx3fnsWWt8oJaH7RoO8ga+PvR4EhQb2fNqw41xG3rpYrMlFeE1qj9JX22jjXotUK3koiqIVmI5T29CJk/rj+EoozoB+M5o2jqgXwGaGHe83bRxOmj2GIxnYMo24jwxFqKPWTlOg7e6Lo9CCOa58B8PGZtnueOwOkWn9w2q1/SNRbQn31fHyLycwWpx6dI2N1e4gq8iCh4sKF1Xl2p/W9HQEuRyFj08jRVc+MkEgxFuLTCaQkG3AXkNDFEEQkGm1KFv5o27XDnVEBAo/PxBFrOnpmM+exXz2HNb0dBxGY7PUGHVSOxxWO7ZMI4ig8HFBVsVnvrFpLudYU+DS2Qe5l4bCHRUnS775Bk6fhjfekIw7AKxmE/HHjhDRq0+ZFr9TRUYmHDmH2SGy6voIerhVUul26CsErTtBC75ApteR/Nij2Aur0F+7guHebsxs48+Pabl8daHiJGjY9b0AiD96uEb7r29yv/kG7Ha8plS/TRskd+sXXpC0J3fsqMGGgsDqoJsZeMNyiiLGwLY34PPBkHSgyk3tRUaSHn+NpAfvwZ6bivf0lwjf8B0u15VNGLd0BEGg1eyXQRBIe+31ZvkdlFloZsnOeMZ1C6RjQNlK3opYu1aSLbz11rLLBEHAY0JbECBv9UnEra/DokGQcx5u/Rzu/Rk829TfQVSGzhu63Q3HVkBRw09uFx9Io3h/Gq5Rwbhcd+1d/xubmvSc/Q4MbahAnDi5phBFSQ/Cv4vketyUeLeF6++VWqjzEps2FifNFtHmoGBLAspgPZrO1RN2bm5oIr0QVHKMzcB1udhs49u9CYzq3IoQ79rNkqoVcube2oWkHCMfba1Zq5iTupNZaEYUwd+tckdXe3ExjqIiFD4+CPKmT7go5TJCvbRYbA6Scmqf4BMEAZlGg9LPD3VEBOr27VG2agVyGbbMTMyxsZjPnsWamoa92NAsH+KcVA+H5WLiUECqOGxmicPmdo41NoJMQN8/EEtCAebEssYjZjPMmQO9epWuWor/+wg2i7lMy/KxQgMTj5xDjsDq6yPorK9EF82YCyd/ga6TUAaFEvzhh1hTLnDhuedr7NY+s00rhnm58fLZFA7mF5e7jk/rUPRe3sQdbbrWZUdxMbkrVuA6fDiq1q1rvH10tOR2/eKLNTOlXZ2ei5t7IO53L4e7V4ApHxaPgF+fBXP5ydq8X/7k3LCxFP3+PZquAwnfsAG/x+5FJms5sjM1RRkYiO+jj1L0118U/v571Rs0MvO3ncNid/DkiPY12m7NGmjbFjp3Ln+5wkODZ69M3OPvQ9jxHlx3G0QfkHT1G1v/r2802M1wYHGDDmNJLiT3l3OoIzxwG9GmQcdyIlGTK8dWYK4gCB8KgnCfIAgTL/9pqACdOLkqid0Kmaeki2tzEHQd/CwIMvjr7aaOxEkzpXh/GvY8M+4j27RYEWKZSo5LZ28Mx7MQbTV7qKlvfjqUTIHJxkMDw+u0nz7h3kzqGcwXO85zKrVqt0on9YPF5iC72IKnTom6EsdxURSxpacjKBTIvZtP0l2nVhDgrqHAZCWzsH5ajWUqFQofH9Th4Wg6dEAZGIigUmHLycYSdx7zmTNYLlzAXlRU46SCk6bDYbZdTBwKKH21yCr5vDcFzfUca2x0vfwRNHKKyqk+/OILSEiAuXNL33LGHtiLRqcnKPLfbMT+vCJuP3IOvULOLz0iaK+rXJKBv1dKSYIeUgWetmdP/J99hqI//iC7XXuQyaBNG/j22yqPQSYIzO8UQqBayUMn4sm0lNVTFQSBsO49Sfj7KPYmMsXIW70GR0EBXg88UKvtXVwkt+udO6G6ua00s5XdeUVM8PeQ7sE6jIbofZK+3P7PYX4fOLOxZH1rRg7x9z1B6nOPgN2G/6vzCFvxGargliU5U1u87rsXTadOpL35Zo2rYBuSlDwj3+1LZFLPYMJ8qq9bWVAAW7dKyf9yb8GNebDucbSHpyAo7GTL5+K4ab5UBdgU+LSD9mPgwBdgNTbIEPZiK9nfnEKuU+F1VwcEect8Nmlp1CR5+CngBzwGfAX8dNnPyvoPzYmT6lORe2SzZfen4BogzQo1B9yD4YaHJOfnLGcFk5PSOCx2Cv5IRBXmjrqdR1OHUydcuvkiGm2YYprOYdzuEFm8M44eIR41EsquiBdv6oi7i5IXVh3H0Uz0HK92Mgqk7xw/1yq0DouKcBgMKHx9EZpZpYe3XoWHVkVagYlCU/2anghKJQovL9Rt2qCJjEQZHIxMq8Wel4clPl5KJCYnYy8oQLQ7W+6bKw6TDVuWCUEuoPR1aZYmWc35HGtMZGoFuhsDMJ7Iwpbz7z1xcbHUqhwVBcOH/7u+w24n9tB+wnvcgPyiRuSOnELuPHYeP5WSNddHEOpSeVU1ogiHv4KA7hDQreRlT5kMt+JiMhUKily0Uubyv/+tVgLRQ6lgSZcw8mw2Hv4nAVs532lh3XthMRpIjTld5f7qG9FuJ+err3Dp1g1tj+trvZ9p0yAsTKo+rM5cyi8ZuYhQ2mVZ7Qo3vQMPbpZ+//5OxB+nkLVgKbGjxmI8sAnd4Ftpu2UDXneOrnWsLRFBoaDVa69hz84h44MPmjqcEj7eIj1jPTasXY22++03sFjK1zvk5FrJEOXwcug7A8d9f2E0dCV/Y3zdA66Kykpn+80AQzYc+6H+h3WI5PxwGnuhBe97OyLXV+12Xp9YLE2rudqUVPtbVhRFWSU/zWsa0slVjyiKmE6eJPPjj9k/ZBRnhwwhNzOvqcOqHmkn4Pw2abZQ0bgXu0oZ+BQotbDtzaaOxEkzo2j3BRxFVtxHhbbYqsNLaNp5INMqMDRh6/Lmk+kk5hjqXHV4CU+dilljO3I0KY9v9yXUyz6dVIzJaifXYMVbp0JVSTKlpCJKqUTuWfckcX0jCAJBHi5olHIScwxYbA2TxBPkchQeHqhCQtBERqIKCUHm6oqjsBBLYiKm0zHYcgqdbc3NDIfRhi3biKAQUDTTxGFzP8caG32/QBCEUo6rn34K6enw5pulK5aST/2DqaiQiIsty5uz8rn3+HlCXVSsvj6CIE017k8vHIb0EyVVh5cQZs0iICUZtcVMclAQyYFB5CsU2F96qVrH0VnvwrsdWrM7r4g3zl8oszykS3dkcnmTtC4X/vEH1qQkvKZOrdN+VCrJ9frIEVi1qur1V6fn0VXvQoS2nAmr1jfAw9sxd3qM5EU7yPz4HRRageD5SwlZNBeFh2udYm2puFzXGc977yHvhxUYjhypeoMGJjaziJ8OJ3Nvn1ACPSqRAiiHNWvAzw/6Xq4wUHABfrgHfrwP9H7wnz9g1JuowvzR9wukeF8q5oQG6ki5NPZHXSXpgvII7S9NKuxdUL0MeU2G35yA+WwenuMjULVu+M+3KIoUFp4k9vw89u4bw+49Q7DbW1jhUj3R/O4EnDipANFux3DoEOn/9zaxw0cQN/E2shYuQu/pho8hj60ffNHUIVaPvQukJF3PB5o6ktLofKDPdPhnNaQea+ponDQTHEYbhX8lo4n0Qt2m+o6CzRVBLsOliw+mk9k4mshk5Msd52nt5cKozq3qbZ+3Xh9E/whv3tl4hvSCa/OGpjacPn2a//3vf3To0AGtVouLiwshISH069ePmTNnsnnz5jLbZBSYEATwda28KsdRUIDDZELh59cgFVHLli1DEASioqJqvQ+5TCDUSwsiJGQbyq1cnTNnDoIgMGfOnNoHexFBJkPu5oYqOBhV23bI9P4gCFhTk7BeyMVhdbB+/XruuusuQkND0Wg0uLu707VrV2bOnElcXFyF+65tnJfexwdq2YLYnDGbzXz++efcfPPNBAcHo9Fo0Ol0tGvXjsmTJ7N69Woc5TzU2Q3Wi4lDOQofFwR583xcaOhzrKWhcFej7eZL8YF0HEYbeXnw9tswdiz061d63XMH96BQqmjTtQdrM/KYeiKODjoNq66PwK+67ruHl0v3s11uL/16YiIyUaR1cjIe+fkYNRouBAQSo9aQ+OBD5P6wAltm5RN4k1p5MTXIh4VJmazNKF0coNZqCezQkbijh6oXZz2Ss3QZyqAgXIcPq/O+Jk+W3K9ffllyw66IOIOZo4UGJviXnyB32OykvbOE869voChVh8+NbrQd9g+uSa9Ddmyd42zJ+D72OAp/f9Jmv4Jord8K+5oyb3MMaoWM6UNqZlRjNsOGDTBu3EWzI4cDDnwpVRue2wIjXoP/bIPAfyth3UaGIndTkbvqLKK9HhN3V46dlwi7Pyl/XUGAvo9CVgycK3svVVuM/2RTuC0JbS9/dL3r7z76SkTRQV7eQc6encvuPVHsP3AL8fELUCo9aRs+E7g25Vdq9E0rCIKnIAiTBUF4XhCE2Zf/NFSATq5tRIuFoh07SX1lDmcHR5Fwz73kfvst6ogIAt54nXY7d9Bp1UougvCK5QAAIABJREFUhHTAZ9MaMnLLF1huNhSmwd8/SgYlWq+mjqYs/WaAxgP+eKOpI3HSTCjckYxotOE2MrSpQ6k3tN38EK0OTKcqdnRsKI4k5nIwIZdp/cOQ16NjtSAIvDmhC2a7g1fX/VNv+72aWbFiBd26dWPRokUUFxcTFRXFxIkTiYyMJCYmhg8++IAXXnih1DZGi408oxUfvRplJQkVURSxZmQgqNXIPZp3q79aKae1lxaj1U5KXuM4JIuiiD3fgqByQR0ehiBXkJMYw6hhw7jllltYsWIF3t7ejB8/nqioKLKysvjggw+IjIzko48+avD4rgb2799P+/btefjhh/n9998JDg5m/PjxjB49Gq1Wy/fff8/EiRO58cYbS21nL7ZizzEhqORSxWEzTBz++eefCILAkJEjW8Q51pjoBwQhWuwU70/j/fchN1dqW74cURQ5d2Avod2uZ3Wegf/9E08PNx0/dY/AS6mo3kDmIjj+E3S+FTRXTCyGhACgtNlolZFOxPlY2iTE4223YUlOIm3OHM4OGkz85HvIXroMS3JyuUO8GhHIDW46njidyJni0pNiYd17kZkQR1FO432PG48dw3j4MF5T7kdQVPN9qgS5XPq/OX1acsOuiDUZUmXXeL+yn/PifceJHXEbucs/QhkQQej3P+O7dA/CuA8h9W/4rB/seB/sTZs4ayrkeh2tXp6F+exZspcua7I4/rmQz/q/U3lwQBg++irkAK5g2zYoLLzYspxxGpaOgQ0zpWTh9D3Q/3GQl/48ytQKPMZFYEs3VOrCXiPKG/u622DvwopdlTtPALegihOMNcSaaSDnxzMog/V4jo+ol31ejsNhITt7O6dPz2Lnrr4cOnwnSclfo9NF0DHyLQYO2EvPHt/RuvUDyOW1Mzts6VT7yicIQh9gA2AGfIEUIODi3/HAaw0Qn5NrEIfBQNHOnRRu3kLRn3/iKCxE0GrRDx6E6/Dh6AcPRq7Xl9om5OGHsL30DOvmf8eDs/7TRJFXg/2fg8MGfR5p6kjKR+MOA56ALXMgcS+E9GnqiJw0IfYiC0U7U3Dp6oMqUF/1Bi0EVRs35O4qDEcz0XZrXPHwL3fE4apRMKlXzR0aq6KNj47Hhkbw3qYYtp5KJ7DeR7h6SEtLY9q0aVgsFubNm8ejjz6K/DKXVofDwc6dO9m5c2ep7dILzMhlAj6ulbf02fPyEM1mVK1bt4hWfzcXJX6uGjIKTWhVcrwve7iZMWMGd911Fz4+PvU2nsNgQzTbkXuokWlUEBzI2Em3cfjECbpEdmLJ/MX0GHBDiauvKIosXbqU6OhonnjiCex2O0899VS9xHLrrbfSp08f3N1bfmX1JQ4ePMjgwYMxmUxMmzaNt956Cz+/0te6xMRE5s6dy48//ljymr3Igj3PjKCWo/B2QajHCY4GweFA6efXIs6xxkIVpEcd7k7+jhQ++SiQO++U0b176XUy4mIpzMok+/ZpfHQqkYGeepZ1CUNXE6fqf1aDpahMyzIAzz0H06eX/CkALg4HLq++iu/kyZhjzlK4ZTOFm7eQ8fbbZLz9NuqOHXEdMRzX4cNRt2uHIAioZDK+uK4NIw6eYdrxODb2ao+rQooxrHtPdny3jLhjh+gyZGQt3qmak710GTJXV9wn1p9e+YQJkgv2nDlw992gviKvJIoiq9Jz6eOuK9VKbjeYSH3pPQo3/oCg1OD13+fxfeK+f12Ue02F9qPht2dg62twYhWM+xiCetZb7C0F12HDcB0xnKz583EbM7pWDtl15f1NMbhpFLWSq1mzBrzczYxUz4OF74FaDxM+g253V2q66dLZG01nbwq3JqLt4oPCu2at0iXYzLDjAykJrdbD+AXQfbI0dtSL8M8aafmY/yu7rVwJNz4Mm2dLXW2XaaPWFIfZTvY3pxDkAt73dERQ1s/Elt1uIDt7B5mZm8jK3orNVohcrsXbOwpf35H4eEehUFybrf/lUZN3/V3gWyAIMAFDgRDgIOC0aHVSJ+z5+eT/8gtJM2YQ068/KY89TvH27biOGEHwggW037Ob4HnzcB87tkziECBiwhgKvFvh/etPJOcamuAIqoGlGA4ugY43g1f9aJ01CL3/C3p/6WbDqUF1TVO4LQnR6sBtxNVTdQggyARcuvpiisnFYWi82fikHAO/nUhl8o0h6NV1r1ooj/8Oaks7Pz2zf/kHh/P8rZD169djMBjo27cvTzzxRKnEIYBMJmPQoEG8+OKLJa8Vm20UmKz4uqpRVNIiKToc2DIykGlckLm5Ndgx1Df+bmpcNUou5JswWP7tofPx8SEyMrLekoei3YE934ygkiPTSe2Rr775JodPnCAkKIjfFn9Bl7bh2DIM2PJMiA4RQRCYNm0aP/wgCa8///zznDx5sl7icXd3JzIykoCAgHrZX1NjtVq54447MJlMPPbYYyxevLhM4hAgJCSEhQsXsmbNGgDshRcThxpFs08clrh1y2Qt6hxrLPSDgqHIwtCQLF4rp7Tj3MG9HOw6gI9wZbi3G193Ca9Z4hCklmWfDtD6xrLLYmKkfwMlDUYUCmjdGiZPRhAENB3a4xsdTfia1bTdvAm/Z59FptGQ9cmnxI0bz/nRY8h47z2Mx47hr5SzqFMb4k1mHj+VWFIZ7RPSBr2XN/FHGqd12ZKcQuGmTXjeeQdyffVdcqtCECQ9yoQE+PLLsstPFps4azCXMkrJ37Cdc0PHUvjbt6g79yNs/Tr8n5ryb+LwEm4BcOc3cOe3knHFl8Nh4wtS1eg1hv+sWQgKBWlzXm10fd1DCTn8cTqD/0W1xd2lmpIAF3E44MLevRx7ZCDKnW9Bp/EQfeDf5F0VeI5rCzKB3F9ia3fciXth4UD46//+Hfv6e/4d2ydC+vvgYshLKn8fPaaASg975td8/IuIokjuzzHYMgx43R2JwrMKF/gqsFrzSU1dzd/HH2H7jhs4fmI6Wdl/4us7iq5dP2fggAN0ue4TWvnf4kwcXkFNkoddgU9F6ZNnB9SiKKYDzwFzGiA2J1c51owMcn/4gcRpDxLTfwAXnnse0/ETeNx2GyHLltFu104C576J69AhyK6cirsCQS7Hb+oUOuQk8sPSDY10BDXk6HeSqGzfGU0dSeWodDDoGUjYBbF/NHU0TpoIW56Jor2paHv6o/S9+krztd18wS5iPNF4LU9Ld8UjEwQe6NemwcZQKWTMndiFlDwjhaZKRJSucTIypBab8pIq5SGKImkFJhQyGedOHOWZZ56hV69e+Pv7o1KpCAwM5Pbbb2fv3r3Yc3MRrVYU/v9WRF2ux5eens7DDz9McHAwarWasLAwnn/+eUymhtWqjIqKQhAE/vzzz3KXT506lXBfPetXfkdCtgHrRZ2kyrQEf/jhB4YOHYqXlxdKpRIfHx+6dOlCdHQ0sbHla23Z8y3gEJF7qhEEgYKCAubPlx4q3vvgA3xatcJRmAGCCUeRFWu6AcfFz/L48eMZO3YsVquVd955p8JjjYuL495778Xf3x+NRkPnzp15//33sZUjLFaZ5uGmTZsYO3Ysfn5+KJVKvLy8iIyMZNq0aRw+fLjUupe/v9u2bWP48OF4enqi1+sZMGAAa9eurTDe4uJi3nzzTbp164ZOp0On09G9e3fmzp2LwVCzCdFvv/2WuLg4/Pz8Kn2PLjFw4EDsBWbs+WZkLgoU3hqyc7J57rnniIyMxMXFBTc3N/r06cOCBQvKfQ+r0pus6D2+/PXCwkKeeeYZwsLCUKvVBAUF8cgjj5CTk1Nqm6ioKIYOk/Tmduzfj0wmQxCEEv1PURRpd7Fybe/evRUe92233YYgCCxYsKDK96ilkaX1JDbHhedHp9CuXemEgSiKLMw1sa3faG7x9WDJdW3Q1LQ1PeMUJO+Xqg6vTGAkJsKCBZKdcEqKlP348EOIjYU9e8rsStW6Nd7TptLm+++I+OtPWs15BWVQENnLviL+zrs4N2Qo4Z/M44OCNDam5/BponTtFgSBNt16knD8KI5GcGzP/Xo5yGR43ntvve97xAgYPBhef11yx76c1em5KAS42dcDa2Yu8Q88xYWZDyNazfjNepfwnz5HHVLFxEfHmyF6H/ScKumuL+gLZ+tPg64loPT3x/eJJyjetYuCDb822riiKPLOxjP46NU1v/czFZCx9CnWThiFp84A9/wEty8GvW+1dyF3V+M+MhRzTC7GmhgFmvJh/VOwZBRYDTB5ZcVjD35O+vevCmrJXDyka8WJnyG/di3URTsvYPw7C7eRbdC0q505ltmcQXLKdxw5MoUdO3tz8tTTFBT8TWDgJK7v/jUDB+yjU8e38fUZhlxet+Tk1UxNvi0sl/2eDlwqRSkCZ3eUk+phSUoie8lS4u+ezLnBUaTNeRVrSgreUx+gzY8riNj2B61enoWuz4011hMJnXwHZhc9HutXcj6zmc2qOezSF3ZQr/JnaZsbPaaAR4iz+vAapnCrNIPoNiykiSNpGJRBehQ+LhiOVaDTUs/kG62sOJDILd0CCXCvZetINbmhjRd39w6hyGTDaHEmEMsj5KIm19atWzlx4kSV6xeZbRSbbfi5qZn98izmzZuH1Wqld+/ejBs3Dm9vb37++WcGDBjAiq+/RqbVIiunSj4pKYmePXuyfv16+vbtS1RUFBkZGbz99tvccccd9X6ctcFbr8LuEEnKMVRaqTBnzhzuvvtudu7cSdeuXZk0aRK9e/fGbrezYMECDhw4UGYbh8mGw2BF5qpCppQqnbZt20ZhYSHu7u7cOnEiqtBQZDod9tx0BJUZQQBblhFbjhHR7ihJQK1fv77c+OLi4ujVqxfbtm0jKiqKIUOGcP78eZ5++mkmTZpUrkFIeSxbtoxRo0axceNGIiIiuP322+nfvz8ajYZly5axadOmcrdbvXo1w4cPJyMjgzFjxtCtWzd27drF+PHj+eCDD8qsn5WVRd++fZk1axZJSUmMGjWKUaNGkZCQwEsvvUS/fv3KJNAq45dffgHgzjvvRF3FxKsoitgLLNgLLMi0SuReGmJjY+nRowfvvPMO+fn53HLLLQwaNIjjx48THR3NmDFjMJvN1Y6nOuTn59O/f3+WLFlC9+7dGTlyJAaDgYULFzJixAislxkdjBo1ihEDBgDg7+/PlClTSn5Gjx6NIAhER0cDVJgYTElJYe3atbi6unLffffV67E0B15/Q2DJ4SACFUVY4vJLXhdFkdnHz7K5fS+G2Yr4rFMoqtoYzRxeDjIldLurnMFfl/6dfZkc/gMPgKcnvP9+pbtV+vnhedddhCxZTPtdOwl8+//QdLmOvFWr6Prsk6x//hFsc15h39pfcZjNhF3fE7OhmAsxp2p+DDXAXlBA3sqfcBszBmWr+jdouFR9mJ4uuWNfQhRF1mTkMsjTFb5dT+zImzDu3Yhu4HgitvyG9703V38QjTvc/AFM3QhKDXx7O/z8EBTVIKHUwvGcfDeaLl1If+st7Hl5VW9QD+w8l8W+uBweHRqBVlWD59rTG2D+jfglLuWj/dOxPbwX2o2oVQy6voEog/XkrT9fvW6bi2NzcIlkpDl9L7SvRBrAPRh6PSgVyWSdLX+dGx8G0QH7F9U4fvP5fPJ/O4+mkzeuUcE12tZoTCQh8UsOHprEzl39OHPmZYymZEJaP0ivnj/Tv98OOrSfg5dXP2SyhukIutqoybt0GLgBiAH+BN4QBMEfuBf4u/5Dc3I1IIqipG2yeTOFW7ZgPn0aAHWnjvg8OgO3ESNQRUTUi16NTKvF46476bt0CYt/3Mmb0aPrvM9648xvkHMeJs2uVpl5k6NQQdQLsOYROLUOOo1r6oicNCLWLCPFh9LQ9wmsc2tAc0UQBFy6+VL4RyL2Agtyt8o17OrKigOJFFvsPDggrEHHucTzoyM59PcJkvOMRPjqy73GvrruH05eKGiUeOqLToFuvHJL5zrvZ/z48QQGBnLhwgWuv/56Ro4cyeDBg+nRowc33HBDKf27S1WHKrkML52Kp59+mm+//RZ/f/9S+1y3bh233XYbj82Zw7h77kFdznu+ZMkSHnroIebPn49KJX3mTp06Re/evVm3bh27du2if//+dT6+uqBSyAn0cCE510BaBc7dZrOZd955B71ez6FDh2jfvn2p5WfPnkVxxQSg6BCx55lBIUN+mWbkoUNS22GPHj1KtlGFhmJNSsKWkYayVStkWlfshRYcJjs9OksCbtnZ2cTHxxMWVvqcWr58ObfddhvffPMNGo2mJJ4hQ4awZs0aFi5cyPTL9Ngq4rWL/Z47duyg3xVWtcnJyRQUlH/ufPzxx7z77rs8/fTTJa+tW7eOiRMn8uyzzzJ8+HC6du1asmz69OkcP36cgQMHsnbtWjwumn/k5uZy8803s3v3bqKjo/n++++rjBn+fT9vuOGGSteTTGvMOIqsyHRK5B5SJejkyZNJSkpi0qRJLF++vOQ9TEpKYvjw4WzZsoU5c+bw1ltvVSue6rBmzRpuuukmdu/ejf5i0v3ChQv06dOHw4cP8+OPP3LPPfcA8MxDD9GjVSs279xJZGQky5YtK7O/qVOnMmvWLFauXMm8efPw9vYutXzRokXYbDbuv/9+XF2vrpa0s2dhyRJ4PNoPmS6ewh0pqMM9cIgis86msCTbQLd/9vHppPEoatOabjXBse8hcizorpAyOHsWli6F6GgIvUzuRKeDRx6Bt96SKhDbVu02K3d3x338eNzHjy/RQs/9fRODtm1Du+cvzrzigm5AfwLzi4nft5vgjtfV/FiqSd7Kn3AYDHg9MKXBxujfX3LFfvttePhh8PCAgwUGDOkZTP/6KzL+2YfcqzWt3pmH24g66JGH9oX/7fxXw+7cFhg1t0r9vKsBQS4n4LVXibt9Ehnvf0DA6w1r1yCKIu/+foYgDxfu6l1NncXCNPj1GTi1FtGvM3f89A2Fbj15vPrFhmUQZAKeE9uR8ekR8jfG4zmxXZVj49dZancPrqZG5sCnpEmFbXNh0tKyyz3bQMdxcHAZDHpW0k6sBvYCM9nfnULh5YLXHe2rzBeIokhxcQwZmZvIzPydoiJpYkGv70R42OP4+o5Cp2vn1MmtAzWZbnoJuHDx91lAJvAJ4An8t57jctKCER0OjEePkv7uu8SOHk3c+PFkzZ+PTKfD77nnaLtlM+GrVuE7fXqJKHJ9EfTA/SCX47rh5+b1ULxnPriHQOQtTR1J9el6p6Rn88cbUuWkk2uGgs0JCHIZrkMaX1S6MdF29wURDH837My71e5g6a54+oZ7c11Q45gyuGuVuLsoMVrsZBdbqt7gGsPV1ZUtW7bQq1cvbDYbv/76K8899xwjRozAy8uL/v37s2LFCgAKTDaMFjt+bhpkgsDo0aPLJA4Bbr7pJiaOHElOfj7b9+8vd9zWrVvz8ccflyQOATp27FhS/bR169YGONqa46VT4a1TkVloxmQte/0vKCjAaDTStm3bMolDgHbt2pVJ6tmLLIg2BwoPdSk9vcxM6fy7/D0VZDKUrVsjd3PDmpaGw5SPwk+LoJDho3Qvs+3laLVaFixYUJL0uhTP6xcroubNm1et9yA9PR0PD48yiUOA4OBgOnXqVO52vXr1KpU4BLjllluYPHkydrudTz7513UyISGBn376CZlMxhdffFGSOATw9PTkiy++QCaT8eOPP5KUVIGe1BVcek8qa8kXRRF77sXEoV5VkjjcsWMHBw4cwNXVlYULF5Z6D1u3bl3idD1//vx6bbPX6/UsXry4JHEIEBgYyIwZkszLpfNCtNuxZWUhuFReve3u7s7999+PyWRi8eLFpZZZrVa++OILgGolkVsar7wimW48+6IcXZ9ATKdyMGUUM/NMEktSshiSdIrJSf/g6V/LCrrT6yUJnp7lJNIuDX6ZVmwJM2ZI2oe1cEuXabW4jRxJ6Pvv4b7tT155/AV29R2E6fARusen4fnOhyQ+/DC5K1diq0GVbnUQrVZyvv4abe/euHSu+8RVZbzxhuSO/f774LDZOfrpYr569Wm8Tx3CbfxUIv5YV7fE4SUUahjygpRE9GkvFQp8PQFy4uq+72aOpmNHvKZMIW/lSgwHDzboWL//k87fyfk8MbwdakUVmqIOBxxaBp/2hpjfYdhsTg36i5/39pRcluuIKlCPfkAQxfvTMF9WjVwy9sGlpcbm4b+qnzgE0PtJZqD/rIK04+Wv0+9RMOfDkUqsxS9DtDnI/uYUosWO930dkWnKr3kTRQf5+Uc4d+5t9uwdxr79NxEX9xFyuY52ES/Sr++f3Nh7HWFhj6LXV52AdFI51a48FEXx4GW/ZwJjGiQiJy0S0WrFcPDgxQrDrdgyMkChQNenD97THsR16BAUvnWYNqkmSn8/dDfdxKjfNvLp2sMs+F9Ug49ZJSmHIHE3jHoL5C2oJFomhyEvwsop8PeP0P3upo7ISSNguVCE8VgmrkNal6oOuhpR+mpRBuowHMvEdUBQg43z6/FUUvNNvHlrw1VGlIdWJUejUZKWb8JNo0SlKD1fWB8VfC2Zjh07cuDAAXbv3s2GDRvYt28fhw8fJjc3l927d7N7925+++03Xnz7E9QKOZ7af4XOs7KyWL9+PSdOnCAvLw+bzYbDaOTkWallJyYmhrFjx5YZc+jQobiUk/iIjIwEpGqr5kKAhwtGq4MCY9k2J19fX9q0acOxY8eYOXMm//nPf0qOoTwcVjuOQgsyraLCB4AruZRAJCVFuqdwOFD4+yMT/o3HXmxFFMVSDwMjRowoN3E2efJkHnroIc6dO0dKSgpBQZWf87179+bPP//k/vvv58knn6R79+7Veui4VCF3Jffddx/Lly8vpTm5Y8cORFGkb9++dOjQocw2nTp14sYbb2TPnj1s3769wn3XBFEUseeYcBhtyNxUyF1VJcf1119/AVKy08vLq8y2o0ePJiAggNTUVA4dOlRvVbI9e/akVTntoFeeF7asLES7HYVn1ZpXM2bM4LPPPmPRokU8/fTTJWYSq1atIi0tjaioqAoTwC2VY8fg+++l3J2/P9j7BpC7PYnpR87zq8rOo63cUS/6jna31eF+7vBySdYmLKrywa8kIAAmT5bKIl99VWpjrgUR7q5Mu308D0R25b7oJ7hz80+k//wT7WLOUvzXdtJemYO2Z88S52ZlYN2UtQo2/o4tLY1Wr8yueuU60r073Hkn7Ft2krO7XmLAhdMkhHei0+tvoOvZsf4H9IuU2pgPLoYtr0paiENegD7RLet5pYb4zoimcONGUl+ZQ9jqVchU9X+va3eIvL/pDOG+Om69vor7y6yzsO5xSWu+zUC4+UPwiWDNXGnxuHpq/nIbHorx7yxyV5/F/7EeCApZhWPXin6PwoEvpKKTySvKLg/uBa37SDJevf8jPWdWQt6G81gSC/GaHInSv7RJkcNhJS9vPxmZm8jK3IzZko4gKPD07EtIyEP4+oxArW74vMO1SI2FLgRB6CUIwp2CIOgu/q0TBOHqvcI4qRCHyUThH39w4fkXODtgIIlTp5G3ajUu3boR+M7btN+9i5Avv8DzzjsaJXF4iVYPTUNjs6DbtI5DCfU7A1krdn8Kanfo0QJ1dTqOg4Bu8OdbYHNWL10LFGxOQNDIcR3YcMm05oS2mx/WpEJs2cYG2b8oinyx4zzhvjqi2lfPnKM+CfKQKocu5DXM8V0N9OvXjzfffJMtW7aQlZXFrl27GDlS0vf56quvWLv6Z/zd1CUJlkWLFhEaGsrUqVN5//33Wbx4MV999RVf//gjxy+6jFbU0npJa/FK3C46xja0aUpNkAkCIV7akuO+0r17+fLl+Pn58cEHH9CxY0f8/PwYN24c8+fPJz+/tM6aPdcMgoDcvawG3yUX5/T09DLLBEFAGRSE3MsLW1YWttQ0sopzS5Z7qd2wZRhwWP6tjryy4vESarW6xFE5OTm5yuNfsGAB4eHhfP311/To0QNPT09GjhzJO++8Q1paWoXbVTR+mzZtyoydkpJS6TYA4eHhpdatCt+L91uXTIEuR3SI2LKlxKHcXY3iss91Q8VTHapzXog2G7bsbORu7lWa6IGUeB0+fDjnz59n48aNJa9f0kG8pIt4NfHyy1K766XCV5tWwUsD3PlVZeel1v7cciEGQRSJuKGW1Ws55yHuL7j+frhSK/Hll8Hd/d/By+OppyRHkEU11z27nNG+7jwe6s/XGXkcHHYzpwN9sLz8PGGrV+Hzv4ex5+WSPvctzg0dRtztk8hauAjz+fM1HkcURXKWLkUVFoZ+8OA6xVwdHEYTr3n9Hx+53oklK5F37/0v9qVfNkzi8BIymZTIid4HbYfC5tnwxRC4cLThxmxiZFotrV6ZjSU2lpwrKpPri7XHUjibUcTMER1QVGRIZLPA9nfhs/6QfgLGfQJT1pUk79asgRtvhCrmuaqNTCXHY0IEtgwjhdsS4K934bN+5Y5dK1w8oP8TELMREveVv07faMhLkCqYK6H4cDrFe1LRDwhC21X6TrPbTWRmbuHkyWfYsbMPR47eT2rqT7i5d6dTp/cZOOAA13dfRnDQZGfisAGpdvJQEAR/QRD2AvuB74BL00ofAJUr4Dq5arAXFpK/fgPJjz9BTL/+JE+PpvCPP9BHDSb4009ov2c3wZ98jPu4ccgv3vQ1NpoOHdD06cOEuF28v+Gf2lnT1xd5iXDyF6m9Q90CdXVkMhg6W7rQH1ne1NE4aWDMiQWYTuXgOjgY2WVVVlczLt2kGwxDTVzoasC+uBxOpBTw0IBwZLXRl6ojKoUcPzc1BSYr+eVUkDkpjUwmo1+/fvz666/06NEDgO2bf8XdRTofDhw4wCOPPILVauXdd9/l9OnTFBUVYU5JwXD8OM8/8wxAhd87stqYEzQS5RmJqBQy3F2k+eECo7XUcQ0cOJC4uDhWrFjBI488QmBgIOvXr2fGjBlERERw5MgRab8GG6LFjtxdjVDOQ1TPnlKPsdsQAAAgAElEQVRr1KFDh0oZY1xCEASUAQEovL2x5WSz5/ffAfD29qZttw5SQizjX0fm+qJjx46cPn2adevW8eSTT9KhQwe2bdvGc889R9u2bUslpOpKfbZRXXo/rzSskRKHRkSTDbmHutLK8vpu66rKpKY654UtM/Ni9Wn1J2EeffRR4N+E4YkTJ9i+fTuBgYFMqI9ewGbE3r2wbh08+6xU1GewO5jydxxbVXaeOWViSoKV2IN7cffzxze0ltq7R74BQQbdJ5d+fc+e0oNXRNeukrXwJ5+ApW4T0s+GtWKwpytvZZvJD+9I3LHDaDp2xPexxwhft47w337Fd+ZTIJOR+eGHnL9pLLE3jSVj3ocYT1Tv2cBw4ACmkyfxeuABhAa+duf/vouzw27B/sdXFPv15s5Rn/PXwGEM82kcqRPcg/6fvfMOj6ra+vC7z/TJpHcCKYQAgtKRJgICNkQBBTuIKGD5wI732uu9NkS9YEfsitcLFlSQ3qVIk56QBAiQ3ibT55zvjwNICckkmZAE5n2ePOLM2XuvSea031lr/eCmL2HUZ2DNhQ8vgwVPgqtmbu9NBUu/fgRfdSUF776HM9O/5douj8ybv++lfbMQrrrwDO0BDm6AD/qpWXptr4b71p/kXn7wIKxfj19Klk/E1DYCUyuJskWZuBfNVHuXnrJ2negxAYJizmy42XYIhKeoiTVnwHXISsmcdPQpoQQNjuLIkR/Ztu1+VqzsztZtE8gvWEhUVH86XPQul/bdQIeLZhAfNwydrmF0h/ONmhwJ30R1WY4ETjySfAdUYcEToKnjKSyk+Lvv2D9+PHt69+HQI49g+3MjodcOpcXHHx11RHuF4EGDkKrpQ3O2iB53JxH2Uowrl7AyvaDhAvnjffVg3GNCw8VQV1oNhMTe6hOqc/QiIoBK2fwsJIsOS+/zI+sQQBtmQJ8cgm1zfr08aPhoxT4ig/SM6NJwv9MoiwGjTsOhEjteH51mz3c0Gg29LlEzTaylxcfFlO+//x5FUZg0aRKPPPIIbdq0waTX4y0uRhMWTkZWVgNGXTXH+ixardZK38/Ozq583NFeTU6PTIH1ZJdds9nMqFGjmDFjBps3byYnJ4cbb7yRgoIC7rvvPhSvjLfUidBrkMyVF6kMGDAAi8VCWVkZc+fOrXQbIQTauDi00dF89tVXAAy5+mq0QXp0sUFIQTqUo9mHmRmV3wi6XC4OHz4MUG3J8jF0Oh3XXHMNU6dO5Y8//iAvL4/Jkydjs9kYN25cpWOyzvAdOPb6iWsf+/e+KrKijr3na8zXHq1x+/bbb4+7IiuygqfAjuL0ogk3orFULhzWNp7afrd8RlHwFBWhCQv3KevwGNdccw0pKSn8+uuvZGVlHRcRx48ff5qhT1PniScgJgYmTQKrx8stWzJYXlzOm21bMMZkoXx1Dge2baNV9561E4e9Htj0JbQarApNx1AUtVT52OLV8dBDcOgQfFtJWWMN0AjBjHZJROm1fD/genbu2YXs/TsD2ZCSQtTdd5My+1taLV1C7JNPoo2JofCjj8i64QbSBw7kyMsvY1u/HsVbeV/vok9moQkPJ/S6+jMN9BSVkj3uMQ5NvhvFYSPmH/8m5JMPKeynIyI9DOOZstbqAyGg3XVw3zrofBusfgdm9ISMxWcvhrNI7D/+gTAYOPLc8369/pu94QD7i2w8ckWb0x8aO8vhl8fgo0HgKIWbv4GRsyD45FL/H35Q/+tX8fDo2mEHbkMINyWRM1Bu+OS0teuEPggufQSyV8K+Jae/L2lUB+eD6+DA6b2hZZub3G/WUpK4gpxuU1mx+mK273iQktINxMUNo1OnT+l7yTrat3uD6OjL0Wgah+5wPlGTI9JA4AlFUYpPeT0DqLzeIECTxZ2TQ9Gnn5J92+3s7XspR556GldmFhG33UbSV1+RtmwZ8c8+i6VPH4Su8WUoBV1yCbpWrbgxczmv/7arYbIPHaWw8VNoP1y1sW+qCAEDnwLrEbWXRYBzEkd6Mc6MUoIHtEAyVNPY+RzD3CkaT54N9xH/iuMZ+VYW7szjtp5JGHUN9zuVhKB5mAm3Vya3zFn9gPOA6s4JsqyQkZkFQFKLv4/fRUeb8bdo8beZkOdoeWixgN9//93PkfqPY2LPrl27TnsvNzeXP//8s8rxBq3EkVIHVseZM1jj4+N56aWXANiyZQveUicoCppwwxkFi9DQ0OPGFY8++ujx3/GpCCH4Ze1aflu+HK1WywO33Y4iywhJoA03Hs+W/n3h7xzZexDFe7JQ/vXXXyPLMqmpqTRvXrtzcnh4OK+99hqSJHHo0KFKDVu+/PLLSscee71///7HX+vbty9CCNauXcueoyXvJ7Jz507++OMPJEni0ksv9SnGW2+9laSkJPLy8pgyZQqKV1aFQ5cXTYQRTdDJ12wrVqw4/u9+R0szf/rpJ4qLT73ch/nz53P48GEsFsvxDEeo+rulKEqdszSVo1lq2hg1U/yYWOnxVJ1tKkkS9957L7Is89prr/HFF1+g0+kYP/7c8nlctAgWL1YFRLfew8jNGawvq2BGuyRujo/E0jcBpcJDc0Marbr1qt0iexeo14GnGqUsWgRLl6qLW3xwUL3iCmjfXnUFqeO1eaRey8yLUijXGfi+9zUc2LOz0u10cXFE3HYrSbM+IW3lCuJfegljm7aUfPMt2bePZm/fSzn81FNYly9HPvpdc+7LxLpkCeE334x0gnGQPyn87EfSB1+NbdXPmHsPIXXBPCLHXMdeSxkiSOav98M52kb37GIKg2vfhjvmgUYHnw+HOROhorABgqk/dDExxDz8ELa1ayk9ptbVEYfby9uL9tI9OZz+rU8pnd39G0zvCes+UEvF710LbSq3kJg7F9q2VX/8wglra3rcQOjVaTgPa7H9eXp7izrT9Q4IbXHm7MNOt4AxVBWnj2K357A/eybrll7Pno4TOZL6IXZnNi2aj6Zr19lc0mc1bdu8QGTEJUhS49MdzidqIh6agMpyzKOBxtOkJ0CtcWZkUPDee2RefwPpAweR+69/4y0rI+qee0iZO4fUBfOJnfIY5i6d6z19v64IIYgaeweJxTmIzRtZsOP0Xkr1zp+fgatc7e/Q1EnqrT5tXvmmKooGOKdQFIXS+dloQg1YesQ3dDhnHdOFUSCBfYt/L6JmrsxEr5W4vVeSX+etDWaDlkiLgQKrE5vLv+WdTZEZM2YwduxY1lXiiuzxeJg2/V0WzFNvJm666abj7x0zcPjss8+wWq3ITife4hLsOj13TZxISUnJ2fkAtWDgwIGA6pR7LAMPVEF0zJgxZ8waO0aISYdeq2F/kZ29GZl89NFHlfZ2/OmnnwBISkxCtnmQLHqkasTz5557js6dO5Odnc2AAQPYunXrSe8risInn3xy/G/x4hNP0LZZPK79+1GOZtOKo4ZANruN/3toMtb9xXhtaql1RkYGTz31FACTJ0+uMhYAm83G1KlTKxUH582bhyzLhISEnOSOfIz169ef5uj8yy+/8MUXX6DRaI47CAMkJSVx/fXXI8syEyZMOKlXZElJCRMmTECWZUaNGnWSYF0Ver2eb7/9FoPBwFtvvcW40XeSe/gI2kgTmhPaUeTk5HD//fefVL7bt29funfvTnl5Offdd9/xzMVj2z/wwAOAakZyohPzgAEDkCSJ3377jVWrVh1/3ev18sQTT1S6n9UExeNBGx5+3NjgmFiZnp5erYA4bty44w7c5eXlDBs27Hjvy3OBY4l/LVrA9WPdXL85ne1WOx+3T2FYrFpCbEgNw66toG14T+Lb1FKN+PMzsMRC2gnFZoqiioYtWsAEHytshFCzD7dsURXPOtIx2MyLKbFkN2/FvzOqN5zShocTdv0IWrw7g7TVq0l4cypBPXtSNu8XDoyfwN5evcl5+BGOvPgi6HSE3+J/s0Bn1mH2jRhH3stTEHozzd78kKSZr6GLUo8nc3KLidBokXZaePZZvy/vO8mXwMRVcOmjsO07mN5dNVBsyHZQfiZs1ChMnTqR9+9X8FTywKSmfLYmi7xyJ49c3ubvB2bWPPhuLHx9o9rCatwCuPo1MFZeZltcrOrxfsk6tObBd3ectnZQnxT0icGUztuHt8LPLW20Buj/OBzaBLvmnf6+wQLd7kTZ9TMHtr3AuvXXsXrNpezNeAm3u5QE3R1c3P1nevVaTFraPwkL7YoQjVt3OJ+oSc7+cuAO4J9H/18RQmiAKcAiP8cV4CygKAqOv7arDsm//47raM8HU8eOxDz6CMGDBqFPavib3toScs015E19k1v3r+KNBZ0ZdEEsmrPVc8zrgbXvQdIl0Kzz2VmzvrnsSbU/x5oZqhtbgHMGx44i3AfKCb8+7fgN+PmExqLH0Coc25Z8Qq5I9ku/r6IKF//deJARnROIsvheZlefxIUYKLO7ySm20yrG4ve+Zk0Jt9vNrFmzmDVrFnFxcXTq1ImIiAiKiorYunXrcXfXxx57jCuuuOL4uLFjxzJt2jT+/PNPWrZsSe+uXZFdblZt3oRer+fOO+9k5syZZ/Wz/Pnnn/TseWYDhCFDhvDUU08xatQopk6dyqZNm2jfvj19+vTB5XKxfv364z3gzlQ2DGoGa1KkmfQ8KzuzD3P33Xdz33330alTJ1JSUpBlmR07drB9+3Z0Oh0v/fN5hFbyybXdaDSyaNEiRo4cyaJFi+jYsSNdunQhLS0Nh8PB+vXrOXToEDqdjtdff52HH34YT3Ex7pwcXFlZJ12r3H777cybN48L+nSgV9eeWO1Wlq5ajsPhYOjQoT4ZZbhcLh5++GEee+wxLrroItLS0pAkiYyMDDZs2IAQgldeeQVdJZUXx0raZ82aRfv27dm/f/9xQe3VV1+lU6dOJ23/7rvvsmvXLpYuXUrLli2PZyYuWbKE4uJiOnbsyPTp06uN+UR69OjB4t8XceNNN/LJV5/y+ewv6d69O4mJiXg8HjIyMtiyZQuKopz23fnqq68YMGAAX3/9NUuXLqVv377YbDaWLFlCRUUFAwcO5NlTFI3ExETuuecepk+fzoABA+jbty8hISHH3csnTZrE22+/XaPPcDLiJOO9pKQkOnfuzKZNm+jQoQNdu3bFYDDQpk0bHj3ad/QY4eHh3HbbbXzwwQfAuWeU8uOPsG4dTJ3l4qYdGRx0uPisQwr9I/4WJmSvhx2Fq+kaOhh3ehmaNqc7aVdJ2SHYOx/6TFYz0U5d/OOPoQbl5NxyC/zjHzB1Khx9qFEXRic3Y86q1cxp1opr80u4Kvp0Ub8yNJYgQq66ipCrrkJ2OqlYs4byhQuxLlyEt6QEJInDTz9D8KBBWAb098nluypkWSZ/6iyKPpsBHifB14ym2QsPIpn+FuLLPV4WFpZxS3wkYpLgX/+CKVPUdpENgs6oXv+3Hw4/ToL/3Q1bv4UhUyG86d4jHkNIEnHPP0fmiOvJe/U1mv3r5VrPVe5w8+7SDC5tHU2PlpGqyLrpC7V3pNsGA55QDUW0VZ8T580Dj6eO4mE1awtJED4ijdy3N1H6SyYRI1vXYbFK6HATrJym9nRscxVIGhRFobx8G3n5CyjRLqELMqz5D6JLX5JCJiH9kkBY24sI79v6vL4+bexUKx4KIVIURckEHgOWCSG6AwZUk5T2QCjQp16jDOA3FK8X28aNlP++kPKFC/EcPgwaDeaLuxN++20EDxyILtaPvQ8aEMlgIPzWW7jw7Xewp2fw45ZUhnc+S+XDO+ZC2UEY8vrZWe9s0KyT2gtlzX/g4vEQFNnQEQXwA4qsULogC22UCXOXc2Pfrw3mTtEUz96Da385hqS6N13+Ym02To/MuEtq2Zi+HtBIEs1CjWQX2SiwuogObhyiZkMwbtw4kpOTWbhwIevWrWPbtm3k5eWh0+mIb5bAtTfczP/dO55BA/qfNC48PJwNGzbw1FNP8fuCBfy6aBEx0dGMGDGC559/nvfr6CJaG8rLy/njjzM4G/J3tqRer2fhwoU8+eST/PDDD8yfP5/4+HjGjBnDc889xyQf+pUZdRpahJsob9aCZ156hc3rVrN9+3a2b9+OJEkkJCQwfvx47rvzHtompKIJMyB8fGgXHh7OwoUL+fHHH/niiy9Ys2YN27dvR6/Xk5iYyKhRo7j//vtJTU0F1AwihMB9UBUQj2UgtmzZkvXr1/PPf/6TxYsWU1pWSkpiMmPH3MGDjz3skzmHxWLh3XffZenSpWzevJn58+fjdrtJSEjglltuYdKkSfTo0aPSscOHD2fo0KG8/PLLzJs3D4/HQ+/evXn00UcrNemIiopizZo1TJs2jdmzZ/Prr78CkJaWxiOPPMLkyZMJCgry6Xd4DMUj0y2tE9uXb+aLX7/l51/msWXLFjZu3IhGozn+OW666SaGDBly0thjZjevvvoqP/zwAz/88AM6nY727dszevRoxo8fX6lo+vbbb5OYmMjMmTNZuXIlISEhDBgwgBdffJHVq1fXKP5jHCshFTrtaS1y/ve//zFlyhSWLVvG119/jdfrpV+/fqeJhwCDBw/mgw8+oH379sdLs88FvF548klo1cvJN60zKHB6+KpjKr3CTi4fPrDjL/YVbaZL7GDKV+ZgrKl4uPlLUGTofPvpi7duDaNH12w+oxHuvx+efhp27oQL6u4m/LBZ4f68g/zfDsH87kZSzTUrNZYMBoL79ye4f3/y4uIo/M90QoYMwbZ+PdbFi4/fKwUPGkTwoEE1vleybdrNoceewH1gO9qEtjT794sEdW9/2na/FZTikBWGx4bT6hGYPl01svZTVW3tiW2vZq2t/0gtR53RUxUVe0xU+9g1YYytWxN5550UfvABodddR1DPyo/t1fHxykyKbW4evbwNFGbAzw9A5nK1b/zQtyDaN4Fu7lxo1gy6d69VGOraP02GrBVVrq2LCyL40uaULz2AuUsMxlTfRHef0GjhsidQvruDkj9fJS/ETX7+ApzOwwihISysB/ZUPc2z/yI+/h1yP8xCG24gbFirgHDYyBHV9f0RQpQDDyiK8rEQIh6YCHRFLXn+E5iuKMrhquZoTHTr1k3ZsGFDQ4dxVpFdLipWr1afpi1ajLe4GGEwENSnD8GDB2Pp36/OT9MaK57iYtL7D2BNy+580usWFj3cD119Nx9WFPhwgNqY9r71qmPxuUL+bvWCoee9cMVLDR1NAD9g25RH0be7ibi5LeaO0dUPOEeRnR4OvfAHQd1jCb+uVZ3mcri9XPLKYi5MCGXW2Iv9FGHN2blzJxecclOmKArZhTasTg+tYy3HzTACqHi8MruPlGMxakmKrFqwcWXvR66owNA6DXGOmS9Ux+FSO/nlTpqHm4kIOjmLQnZ78eTakMw6tBH10yvsRLxlZbgOHEAyGNAnJ5/2t1A8Mp4SJ4rDg9Br0IQZkPT+/97379+fZcuWsWTJkpP6Gp5tZLcXT4EdFNBGmerls54tXNnZyBW2Ou9jw4cPZ+7cucyYMYN77rmnVnNUdjxtaL76CkZPcdDqkwwUg8zXHVvSJeT049bCj2awY/liRo9+DevCg8RM7oI+3kdBWpbh7U4Qlgh3/Pz3619+CbfdBt98AzfeWPPgCwogMRFuvRU+rHs/7bysfUx//im+uf1hYs1mfu2aRlAtzm+y00n6ZQMxtm9H4gcfnLFKy9ixAyGDB6tVWsnJZ57P4eTws29T9uPnoNESfutEYh4Zh3SG2G7eksFem4P1PdshhODll9XK8DVroIoE87NLyQGY97CajdqsM1z7DsRd1NBR1QnZ4WDf0GsRGg0pP8ytkTETqNUml766hH6twpievAqWvQIaPQx+Drrc4fO9oN0O0dGqHn/U38l3vG61j2AN1lbcXo68+SdCEsRO7oLQ1f2eVZadFBWtJj9vPvkHv8etlZEkAxERfYmJvpyoqMvQ6cLhyDZ47xLKTeMpc4wg9v5OaCMDBiiNASHERkVRulX2ni/fkAeAN4QQPwIeRVGeURTlGkVRrlYU5cmmJByeT3itFZT9+is5Dz3M3l69OTjxHsp/m09Qnz4kTJtG69WraDFjOmHDh52zwiGomQmhw4bRI30dpYdzmb3hQP0vun+N2ueh573nlnAIEN0GOt4M6z6E0pyGjiZAHVG8MqULs9HFB2G6KKqhw2lQJIMW0wUR2LcVoHjr1s/nx82HKLC6uLtvSz9F5z+EEDQLUy/OckocDWMm1YjJtzqRFYXYkKpFL9lmw1tehiYq8rwTDgHiQoxYDFpySuzYT+ihqSgK3mInSAJNaPXlyv5AExKCPjER2enCmZmJ7D65f5PQSmgjjWgijKqQmGfDU+pEkc+9777s9uLJPzeEQ3UfK6/zPrZx40Z+/PFHIiMjGV3TDLlGjNsNT7xnJ+Y/6WiMCv/r3KpS4VCRZTI2rCW5UxdCejdH6CSsKw76vlDmMijJhi4nGKW43WrWYMeOMHJk7T5AVBSMGQOffw55de83HJ2UQrxew7iMjaTbHDy4+0Ctzm9lP/+Mt7CQyLFjAfWcabroQmIeepDUX3+h5byfiX5gMni85L3+BhlXXsW+odeS//Y7OHbuPGnNsoV/kD7wWsrmzsSQ1oWWc38g7vHxZxQOC1welheXMzwm/Hj21aRJqpH1E0/U4pdSX4S1gFu+hRtmQulBeL8fLHwW3PaGjqzWSEYjcc88gysri8L3P6jx+PeWZdDKvZupJQ/AoucgbbDqWt3tzhrdCy5cCBUVtShZztkIHwyo8dpCpyF8WCs8BXbKltb+HtnjsZKbO4+//prM8hUXs2XrXeTm/0pEcFcu3FFGX/P/0bHD+8THX68Kh4ASeyFuc3dMtu+JGJkSEA6bCNWejY9mHP4OzAS2CyEmKoryv/oPLUBN8RQXY128hPKFC6lYtQrF5UITEUHI1VcTPHgQ5p49jzebPp+IGDOGkm+/ZXzRJt5eFMX1XZrXr/Pp6v+AKUIV2c5F+k1RGyYvfw2GTmvoaALUgYoNuXgLHYTd0d7n0sJzGXPHaOzbCnDuK8GYVruHKoqi8NHKfVwQH0Lv1MZZ2q/XSsSGGDlcaqfU7ibMfP6dFyrD7ZEptLoIM+urPUe4c3MRGi3ayMb5N65vhBAkRpjZm2clu9BGqxgLWo2EXOFWXX3DjYj6zvI/AU1wMPrkJNzZ2bgyM9EnJ590vSOEQGPWIRk0eEtdyOUuZLsHbZgByXj2xV9ZUag4xQ26rigeWXW31qrCrZAAj9eva/gDjQCTJFVbmlbXfeyuu+7CarXyyy+/IMsyzz//fI3LvxszL31lo+KhDCIsEnM7p5IWVPkDjyP79mItLqJV915IZh3mbrFUrDtC6JXJaEJ8yK768zMwhsEFQ/9+7ZNPYN8++Pnnuj0kf+ABeO89NcWqjs4gQgiSO3YhffVCHh80lJczj9A1xMyEFjE+z6EoCkWzZmFo0wbzGdL8DKmpGFJTiZo4EXdODuULF1L++0IK3n2Xghkz0DVvjqV3d5xZpdjWLUGYQol+9CWixo2odv2f80vwKjA89u/rD4tFFQ4nT1aNrf3QItI/CAEXXg8tB8DvT8HKN3Fvm8u+ix7AbWi6SSml1/Xl0OL/EplkQRvhW3m/yysTv3Y2/9P/huSMgRu/OHl/qQFz50JoKPicvO60wpKX4I/3VEOjG7+EC66p0ZrG1uGYOkWr5csdo9HFmH0a53YXk5+/iPyCBRQVrUCWXeh0EcTGDiE6+nIiwnshCT3suBJWvAWd7wDd3wJhxdrDOEqGEKV/Fq17GVCLDOYAZx2frpgURdkPDBJC3Ad8K4TYC3hO2aahWrkGOErRrE8pfP99tM3iCb/5JoIHDcLUpQtC03SfPPsDQ8sULAMG0H/jct6K6cXna7K5+9J6yggqzIDdv6jOZHrfDr5NjvAk6HoHbPwE+kyCiMaXXRWgehS3l/JF+9EnhWBs03Qv9PyJsU0EwqDBtjm/1uLhsj357Mm18sbIjo26b0uURU+JzcWhUgfBRi2acy1LuhbklTtQgNhqbqi9VityRQW6uLjz+vyq1UgkRZrJyK9gf5GN5HAz3jIXwqBBMp99QU4TFIRITsZ1ooB4SumZ0EhoI4zIZi3eEieeAjuSWaeKbWdR7DzkdFNYH67npqOfweln90w/o5UEoVoNoVoNQRoJ6ZRjpT/2sY8//hhJkkhKSuLpp5/m3nvv9UfojYIVeVbei9qH3qnlt16pJJvPfMxKX7cGSaOhZWe1gVrwJQlUrD2Mdc1hQq9IrnqhikLY9bOawaQ7Kk7a7fD889C7N1x9dd0+SJs2MHSo2thvyhQw1S3zKKVTN7YvXciN9kK2RIfyfMYhLrKY6R1uqX4wULFyJc696cT/+18+nb91CQlEjBlDxJgxeAoKKF+8mPL5v1P83x9B9mJq1YqE21LRdQtVS0o1p/cKPZG5ucW0Nhu54BQheMIEeP11VUS87DJVt2s0mCPguulw0SgqZt9Lm5XVu9k3akxAJ2DTAzUa1kUC60WjsQx5EYyhtVra61U9iIYMAZ9yffYuhJ8fhNL90G0cDHqm1muHXdMSx+5iiufsJfruDj4lFOzf/zFZ2e9iNDQjIeFWoqMuJyysK6qf7gkMfBpmXa32y+z9fwA4s8so+WkfxrRBKBVfI9a8Ax1GNbIvd4DK8PnqTgiRCFwPFAPfc4p4GKDhCb9xFMGDB2Ns365R37Q2BBFj78C6ZAkTnbuZsdTMTRe3INhY9Um8VqydoV4cXHy3/+duTFz6iOritfTfMKLm6f0BGh7r2sN4y1yE39gmcLw4itBJmC6Mwr69AGVYq1r1fvl4ZSaxIQaGdmxWDxH6DyEECeEmMvKsHCl1kBB+jj7s8BGnx0tRhZsIi77KPpCKouDJzUXodGh8zEo4lzHrtTQLNZJTYudIgY0oRVFNUhromCKZzeiTk3FlnSAgGk/PyJKMWkSMBm/50SxEh0fthWjS1jr2pUuX+rSdUyNC1IsAACAASURBVJYpdHsI12mI0NVdZFXcXrylLoQk0IQZoJFnkbsVhVKPlyK3h0KXB42AkKNCokWrQQK/7GPnakuGFUXl3LI1E0+hjumJqSRXkzmevn4tzdtdhNGiCmjaSBOmdpFY1x4meECLqkvbt34DXhd0OaHc+913IScHvvjCPzf6Dz+spll9/jmMH1+nqZI6dEJIEllb/mTaDbdw1cY9jN+exe/dWxNvqF6NKfpkFtroaEJrIYpqo6IIGTIc15FWiIiRhHU4QrBhIeydDbs+UUWd1lepWWGpA09LMDjocLG2tIIpKXGnHYMMBnjmGbjrLvjpJ7j22hqHV/+07EfFXSs5lLFeNddpwtg3babs558IuWYops6dfBoTHNmMFml1y6NavVptBVptyXJFAfz2OGz7DqJaw9jfIKlXndbWWPSEXZ1C8fd7sW3MJah7XLVjEhJuITr6CoKDL6z6vJncR/3Or5gKXcbgdRsp/HInmjADETe2Rey8D36apBq8pFxap88RoP7x6apFCDEOmAosAS5UFKXuzSkC+B1ds2bomjXuG9aGwty9O8Z27bhy1xLe6dyOj1dm8sAgP9vS24pg05fqkxOL72USTZLgOOgxAVa9BX0egNh2DR1RgBogOzyULzmAIS3Mv+5q5wDmjtHYNubi2F2E6cKa9YHcebiMFXsLeOzKNui1jT+Tz6zXEmkxUGB1EmbWE2Q4/3r3HSOvzIkQEFONA7VcXo5st6Nr1gwRyNYEICJIj83uocDpxmwyEFafbUF8QDKZ0Kck48rK+ltArCSjSUgCbagB2aRmIXqLHMhGLdowA6Ie999cpxsBxBt06Or4HZLtHjxFzqN9HU1nNXuyLoTrtMiKQrnHS6nHS5nHS7HbixAQ7bQTZrejCexjp/F7QSnj/srClWOgw9xUrp9T9UPwwpwDFB06SKcrTy5jtPRNwL69ENvGXCy9znDfoChqyXJCN9VpF6CsDF5+GQYPrkFdZTVceil06QJvvqmqY3X4mxuDLDRr3ZbMzRu45Kbb+fjCFK7auIe7/spiTudW6KuY27F7NxWrVxP94IOIWrR48pa5yP9oG54iB1F3dcPUJgIYrfYBzFiiZnDu/kUVZLUmSBsEbYdC6yvAFMYPeSXAySXLJzJmDLzyipp9eM01jbOlekJUOAlRlzd0GHVGufhyslf9hXPWXFJH3X3W2pPMmaMKxVdeeabAFNjyNcz/p1qu3O9x6PsQaGtm7nImzF1jqdiYS8kvmRgviEBjqXo/MBqbYTT6qDsMfAo+6I+y+l0K916JYvcQdW8nJLMOOtyoOniv/k9APGwCVHvoEULMA94AHlQUZVhAOAzQFBFCEDF2LGJ/NhMMuXy0IpPiCpd/F9nwMXjs0Ot+/87bWOkzGQzBaq+NAE0K68ocZJuH0MuTGzqURochNQzJosO2Jb/GYz9akYlJp+HWi5PqIbL6ITbEiE4jkVNiRz5HM3Wqw+H2UmxzEWnRo6tCfFGzDvMQej2asIDofhwFYjwKRiHIcbhwuhu+z55kNKJPSQFJwpWZibei4szb6jVoo01oQg0oTi/uXBteq6teMtfsXplit5conbbOwqHX5sZTaEdoNWijmo5weAxJCEJ1WhJNBtpZTLQ0G4jQajAXFuLS6tilNbDP5qDQ5cYtN+1MJn/wU14JY//KJLTMSP6kVrzyz+qrZ9LXrwWgVbeT+/fpk0LQtwjGujLnzMZBB9dD/q6Tsw6nTYPCQnjJj9d9QqjZh7t2wa+/1nm6lE7dyMvMoKKkmDZBRqa1TWRjmY1n0g9VOa7ok1kIk4nwG0fVeE1PsYO897fgLXEQNbb9UeHwKDoTtL0ahs2AR/bC6B+g821wcAPMGQ+vpcLnw5mbmU7nIB3JpsqFIK0WXngB/vpLNbgOUH8ISSL+ueeQbTZy//3KWVlTUdR+h4MGQXBwJRsUZcLnw2DuPWq24cQVMOAffhMOQX2gFj4iDcXlpXRept/mBVRX7guGUrq0GFdmGWEj0v52fNcZ1Yq9vfMhf7d/1w3gd3y50ggCOimKMrO+gwkQoD4JufIKtHFxDNu7lAqXh/eWZfhvco9TdSBuNQhiLvDfvI0ZcwT0nqQ+TT24saGjCeAj3go35StyMLaPRN+isiuU8xuhEZguisK+swjZ6Xt3jrwyBz9uyWFUt+aEmuuhJUI9oZEECWEmHG4vBVZnQ4fTIOSWOdAIQbSlml6HpaXITgfamJhARtQJeMtdCK9CYrgZBGQX2fA2AidjyWBQBUStFld2Nl6r9YzbCiHQBOvRxZoRBo3aDzHfjuxnITTX6UYSEKOv2zHCW+HGW+RAHBU+m5pweCqSEARrNcQ57ejdLnQxMUTpdThlhYMONzusDtIrHOQ53TjPQyFx9pEiJmzP4iJTEPsntGLYQC3du1c/LmP9WuJS0wiOPDmLXgiBpW8CnkIHjp2FlQ/e+CnoLaopBqii4euvw/Dh+LR4TRg5Epo3hzfeqPNUyZ26ApC15U8Aro0J454W0XySU8B3R4oqHePOy6N03jzCRoyo8YMhT4Gd/Pe2Ile4iRp3UdXVHBodtOwPQ16HB3fAXYug132kVzjYJpsZvuVN+PgKNQOrOOu04SNHqgbXTz+tGl4HqD8MqalE3X0XZT/9hHXVqnpfb9s2yMyspGTZ61GrvGb0Uu+1rn5dLVOup3tNXYyZ4H7NsW3Kw7G32K9z2+IfweoaQlDzbII6n1Kh1/0u0BrV9l8BGjW+XG0MUBQlq74DCRCgvhE6HRG334ayaSN3xbmYtTqL3DKHfybf9l+w5kKv+/wzX1Oh50QwR8Hi5xs6kgA+Ur78IIrLS+jlTSc77mxj7hQDHhn7jspvNCrj0zVZeGSFOy9Jqb/A6okQk45Qk468MifORujOWp/YXB5K7W6igg1oq8o6lGU8eXlIRiOa0No1JD8XkV1e5HIXUpAOo1lHYoQZh9tLTrG9UfSck/R6DCkpSDqdKiCWl1e5vVr+a0QTYUTxyHhybXhKnWfOzqoBNq9aohut16GtQ19Cr9WFt9iBMBzNOGzkPQ595cR9zBQeRjOjnrZBRloHGYk16PCicNjpZpfVwZ4KB0ecbuxeuVF8z+qTT3MKmLRzP33CLVzwQ0vKczW88EL146xFhRxO302r7pX3QjO1j0ITZqB8Rc7pbzrKYPv/4MIRYDhqNvLqq2C14tPiNUWng0mTYMkS2LSpTlPFJLckKCyczE0bjr/2RMtm9A6z8OjuA/xVbjttTPGXX4HHQ8To22u0lju3grz3t6B4vETf3QFDUojvgyUJmneDwc8z5/KZCODaVheCqwIWPAFvdYT3LoFlr0LuDlAUJElN+szIUA2vA9QvkRMmoE9O5shzzyM7/HS/eAbmzFGTcIeeaNJ8aDN8OAB+fxpSL4P7/lAz9Or54WXIgES0USaK56aj+OkBmju3guLfK9Bb8gkrngJlh0/eICgKOt4EW75RezoGaLRU++1TTjkrCyHChRAPCCGmCyGeFEK0qL/wAgTwL2EjRyKZzYzatxJZUXhn8d66T6oosGY6xF4ILQfUfb6mhCFY7bexbylkLm/oaAJUg7fMScXqQ5g7xaCLDWrocBot+sRgNGEG7Jt969Jhc3n4Yu1+rmgXR1Jk0/y9Ngs1IaDRiD5niyOlDrSSRFR1WYclJSgul5p1GDAYAtQybm+JEySBJkTtjRRs1BEXYqTE7qLQ6ufWILVE6HToU1KQDEZc+/fjLS2tensh0Jh16GLNSGYdcrkLT56tRpnIlXHY6UYjIFpf+96i3nIX3hInwqhVexyeI8IhVL6PCSEwaSTiDDraBJloazESb9AhULM491Q42F3h4JDDRYXXe84du97bn8eUPQcZFBnCq1EteW+ahttug/btqx+bsfEPAFp171np+0IjsFySgCurDNeBU0T1v/4Lbht0GaP+/6FD8M47+Lx4bbj7brBYYOrUOk0jhCC5Y1eyt25C9qrCh1YSvN8+iXCdljv/yqLY/fe+LNtsFH/zDcGDBqJP8v2hqivHSv77WwGIHt8BfYJvjs6noigKc/JK6B1mIW7AA3DPSpi0GS5/EXRBsORleLcXvNMVfn+aqztsoE9vmeefh3rWs857JIOBuGefxb1/PwUz3q3XtebOhT59IDYWcNlgwZPw4WVqYsqoz+CmLyE0oV5jOIbQSYQNb4W30EHZ4gN1nk92eCj8fCfCqCFydEeE4oTlr52+Yc/7wONQXZkDNFp86Xl4SAgRefTfKcAO4B/ABcC9wDYhRNt6jTJAAD+hCQkhbOQNeBYtYGzrIL5Zd4D9hac/hawRGYshb7uadXg+3lR2GwchCbDoBVVIDdBoKVt8AMWrEDIosaFDadQIITB3jMaxtwRvRfW1Qf/deJBSu5u7+ja9rMNj6LQSsaFGrE41E+98wOrwYHV6iA42oKlChFFkGU9+PpLJhFRpM6LzE7nCjeLyqu7KJ2RtRgcbCDHqOFzqoKKOgpu/EFot+hTVOMV14ACekpLqx2gktBFGtFEmFMCTb8dT7EDx1rxs1urxYvXIxOh1aGpxnaAoCt4yJ95SJ5JJizbSeE4Jh2rWYfX7mEGSiDHoSAsy0s5iJMGoQycJ8t0e0iuc7KxwcNDhotzTtIVERVGYmnWEZzMOMTQ6jJkXJvP6vyTcbnj2Wd/m2LtuDeHxzYhIOHOOR1D3WIRRQ/mKgye/8ednENMeEtQSYF56iRotXhvCwlTDlG++gYMHq9++CpI7dcFRYeVw+p7jr0XrdXzUPpnDTjf37cg+3uO3ZO5c5NJSIsaO9Xl+Z3YZ+R9uReg1xEzoWKeHsVutdvbZnYw40SglIgV6/x+Mmw8P74IhUyE8CdZMR3w8kEVD2vN4h0f4+Z1lallrgHojqGcPQocNo3DmTBx79lQ/oBZkZcHmzUdLljMWw4yesPodtTfmfX9Au+vO+v2lMTUMc5cYypcdxH3kzD2Dq0ORFYpm78FTZCfylgvQJKZC1zHw56dqH8cTiW4NaVeobcDc9jp+ggD1hS95r3HAMeu8l4FdQEtFUS4DWgIrgXrIYQ8QoH4Iv/12kGVuPrgWrUYwbWEdTwZrpoMl9u++MOcbOiP0ewwOroM98xs6mgBnwFPkoGLdEYK6x6KNPN15NMDJmDpGg6xg31Z1+YRXVpi5MpNOLcLomlS5S2JTITJIj1mv4VCJA08tBJKmhKIoHClzoNNIRAZV7SjoLSpCcbvRxsYGsg6PonhkvKUuhEGDZDo5k04IQYsIE3qtRHahDXcj+S4JjQZ9UhJSUBDugwfxFPnWlkAyatHFmJGC9cgVbtx5Nrw2t8/ilKKo5bY6SRBVi6xDVTh04S1zIZl1aCKM59z30FtUhOKp2T6mkySi9DpSzUbaB5loYdJjkiSK3B722Zxst9rZb3dS6vY0KTMoRVF4ad9hXs08wsi4cN5tl0ROtsSHH6raWsuW1c/hqLByYPtWWnXvVeXvUzJoCbo4HvtfBXiKj6axHd4KhzapRilCwL598MEHvi9eFyZPBllWsxzrQFKHzgghkbV5w0mvdw0N4sW0BBYXlfNG1hEUr5eiTz/F2LEDps6dfZrbkVFCwcfb0ATpiJ7QAW1U3a6n5uQWoxOCIdFnaIcRHAfdx8Htc+DRdBj+AYaWXbir6xfcUHEtymutYO69sPtXcAdSEeuDmCmPobFYOPLMsyj10HP1hx8g0lTI3dET4fPham/MO+bBtW+DqeGuK0OHtEQyaiiek17r1h3lyw7g2FFI6NUtMaQc/Y73fQQkLSz99+kDet8PtgLYOrsOkQeoT2paNN8DeEFRlAoARVEcqMJh5TnxAQI0QvTNmxN8+eW45n7PnV1imbM5hz25VfdBOiO5OyBjEVw83q+OV02OTrdCREtY/IJ64Reg0VG2MBskQchlgaxDX9DFB6GNMWHbUnXp8sKduWQV2ri7b8smf0MvhGqe4pVVYe1cptzhwebyEBNsQKoq69DrxZNfgGSxoLHUriztXMRTqprraMMrF7I0kkRSpBlZUcgutDUa8eaYgKgJDsZ96BCeAt96KwlJoA01oI0xIySBt8iBp9CB4qn+fFfu8WLzysTqtUg1PEYoioK31Hm8r6Qm3NDkjzOn4o99TCsJInRaUswG2ltMJJn0BGs1lHq8ZNldbLfaybI7KXZ78DaS72JlyIrCk3tz+M/+PEY3i+SttoloJcFzz4FGA08+6ds8mZs3Inu9ZyxZPhFL72aAwLrqqBvxn5+BxgAdjroOP/ecavXr6+J1ITkZrr8e3n9f7a9YS0yWYOLT2pC5+XQzv9HNIrkxLoI3snL5aclK3Nn7ibzjDp/2K/vuIgo+2Y4mzEj0hI5ow421jhHUv/ePeSUMiAgmTOfDgwVTOHS8EW76ku1D9jH82y/Y5rwcdv4MX98Er7aE2WPUPuyOsjrFFuBvtOHhxEyZgn3TJkpmf+ffyRWF8lWz2TO5OyFZ36nC2sRVkHyJf9epBZogHaFDWuLKLqNi/ZEaj3fsKaZsQTamjtFY+jT7+42QePW+eeu3kLfz5EHJfSGug5qYE7ifbJT4Kh4eO9MagFPvpHKBaL9FFCDAWSBy7B3I5eXcUriFIL2WqQtqmX24ZjrozNDtTv8G2NTQ6GDAE5D7l9pkO0Cjwp1bgW1THpbe8WhCz2ORuwaopcsxuLLK8JSc2YX4oxX7aB5u4or2sWcxuvrDpNcSFaynqMLVaEpO/c2xrEO9ViK8mqxDT2EhiteDLiamyu3OJ2S7B8XuQROiR2jPfBlp1GloHm7C5vJwpLTxiNFCktC1aIEmJAT3kSO48/J8ziKU9Bq0MWY0oQYUpxd3rg2v1XXG8YqicNjlRi8Jwn0RB04Z6y12IlvdSBa9Wh5+jgmH4P99TCMEYTotSSZVSEwxGwjXaanwyuw/KiTuszkpdHlwNwJX8GN4FYWHdx/g45wCJraI5pXWzZGEYMcO+PxzuP9+SPCx5Vn6ujUEhYUT36pNtdtqwwyYOkRRsf4Icnm5mvHT7lowR1CrxevKww9DaSnMnFmnaVI6dSV3XzoVJSc7xgoh+Hfr5lxkMfGwx0Be+4sIHjy42vnsfxVQ+NkOdDEmosdfdLzPa134o7SCQ043w2Nrnl3WtacZccFQ+k79gMJx6XDb/1TBN3s1fD8OXkuFL0eqrtkBA4o6EzrsOsw9epD3xhu483zrh10txdm4PrmBJ9vdTYU+BSYsh4FPqRVdjQRzlxgMLUMp/TUTb7nvfYw9xQ6KvtmFNsZM+PVpp5+7LnlQdXNf/OLJrwsBve6Hgt2QvtAPnyCAv/FVPFwmhNgKhAKn9jdMBAJHpQBNClPHjpi6dMHxzVfc3SeJ37YfYcuB6nsgnUR5LmybrWbdmSPqJ9CmRPsRao+cJS+B9/zomdZUKPs9G6HXENwv4G9VE8wdo0EB+9b8St/ffKCE9VnFjO2TUqVTb1MjJtiIXiNxsNjeaDLG/Emp3Y3D7SUuxFhlJpji8eAtKEATEoJkNp/FCBsviqzgKXEgdBKSRVft9mFmPVEWAwVWJ8W2xmGgAicIiGFhePLy8OTm+iwgCiHQBOvRxZoReglviRNPvh25ElfKEo8Xh1chzqCrUdahoih4ixzINjdSiB5NqP6cFA6P72PB9bOPSUIQotXQ3KinXZCRVLOBSJ0Whyxz0OFih9VOus1BvsuNqwGzXNyywn07svn6cBEPJcfyTGqz43/vp5+GoCCYMsW3uTwuF5mbN5LarQfCR1fW4EsSUJxenL9+Ac5StWT52OIWi++L+4MePVTniGnTwFt7p9eUzt0AyNry52nvmTQS07UO8Hh4evyD2EXVvyfbpjwKv9qJPsFC9N0d0FjqLhyCWrJskiQuj6qBS/MJvPAClJfDq2/oodVAGDpN7ZF453w1syt/F/w0CV5Pg0+GwNr3oKTuBhjnI0II4p59BsXpJO/flZTb1gTZqyafzOiJOLCGSb++Qv61CyC2nsyI6oAQgrDhrVA8MiU/Zfg0RnHLFH6xE8WrEHl7OyS95vSNzBFqX89dP0POKRnCF46A4Gaw5j9++AQB/I0vZ5XngG+B74HXgFPrO4cCK/wcV4AA9U7EHWNwHzzIze5MIoL0vL5gd80mWP+hKpL1vKd+AmxqSBJc9iQU7YPNXzV0NAGO4jpYjv2vQoL7JqAJqv5mP8DfaKNM6JpbsG2pXDz8aMU+go1abux+bomyGknQLMyE0+Mlv/zMWZdNEUVRyC1zYtRpCDXp2LVrFxMnTqRNmzaYzWZMJhOJiYn07t2bh+6/n4UrV6I9j7MOy8vLeeONNxg0aBDx8fEYTUYi0+LpNOBi7rrrLhYurD4zIC7USJBBS06xHbur9mKAvxFCoEtIwBMUxPvvvss1gy+nefPmGI1GgoKCSEtL45ZbbmHOnDnIlQhLQiuhjTKhCTeieGQ8eTY8Zc7jIqSiKOQ63Rg1gjBtJTdPZ0CRFTyFDmS7B02oAW3IuZlxCOApKECRZbSx9b+PCSGwaDUkGPVcEGSkdZCBGIMWj6JwyOFmp9XBngoHuU43jrPYp9Mpy9y9PZO5eSU82TKex1Lij/+9N2yA779Xk/Gionybb//2Lbgddlp17+VzDPrmwehTQpF2fokS0VItHazN4v7ioYcgM1O1oK0lMcktMYeGVVq6DBD0+ac8/dVH7NGbeGz3gTM+PLCuO0zR7N0YkkOJGnfRaT1ea4tbVvg5v4Qro0II0vh+fDiR9u3h1lvVFpGHDx99UdJAYk+44iWYvBUmrFBLYe1F8NsUmHYhfNAflr8O+fVjAHKuYkhJIXLiBMp++RXr8uW1m+TINvhoIMz/JyT3ZeK2P/jhyEQ6d6ndd+BsoIs2EzIgEfvWAuy7q+8VXPxDOu4cKxE3tkFXVU/QXveCOfL07EONDnpMgMxlag/WAI2KasVDRVGeO+Vn/invP6ooys2+LiiEaCOEmCyE+EIIsUsIIQshFCHEDVWMmXV0mzP97PJ1/QABjhE8cCC6xERsn3/Gvf1TWbG3gDUZhb4Ndtlg/cfQdghEptZvoE2JNldBQjdY9mqgcXMjoXRBNpJZi+WSs1RydI5h7hiDO8eKO/9kV/aDxTZ+/esIt1yciMXgn5uJxkSISUeoSUdeuRNnJRlVTZVimxunx0tsiJHZs2fTsWNH3n//fSoqKujfvz8jRoygbdu27Nmzh2nvv88z//kPkrHhSohmzZqFEII77rjjrK/9yy+/kJKSwiOPPMKqVatonZbGsCuHclm//ni8HmbOnMngwYMZOXJklfNIQpAYYUYjCbKLKhqVGc/69eu5sH9//u/551mwbCkJMTFcd911XHnllZjNZr7++mtGjBhBjx49Kh0vhEATpEMXa0YyaZHLXHhybchOD0VuL05ZIU6v81n8U4VDO4rDgybMgCa49hlOS5cuRQhB//79az1HfSK73XgKi9CEhp31fUwIgUmjId6gp22QiTZBRuIM6sO1I043uysc7LLaOex0YfPWn3OzzSszZmsmvxWU8XJaAvcnndz+4sknITISHnzQ9znT169FbzLRon2HGsUS0smJQdmGO26EWjpYm8X9xXXXQWoqvPFGracQkkRyxy5kb92ELJ98DnPn5FA2fwGXd2rPYylx/De3mJk5pxfRla/MoeR/6RhbhxM1tj2SwX8Cz7Licorc3lqVLJ/Is8+qRtgvvVTJm0JAfAe47Am4dw3cvxEGPQtCo/Yon94d/nMxLHpeNck5BysN/E3kXXehT03lyLPPIdts1Q84htsOC5+F9/tB6UG4YSYV133LV/NaMGzYWTdTrjHB/ZqjjTFRMicduYqHgNZ1h7FtyCV4QAtM7SKrntQQDJc8pDpMZ56Sh9Z1DOiC1AzNAI2KWtdZCSEkIarJ866ce4BpwK1AG6Amu8sq4NNKfubUIo4A5zlCoyFi9Gjsmzdzg7GY2BADry/Y7dtF4pav1Kd4ve6v/0CbEkLAwKeh7CBs/KShoznvce4rxbmnmOD+LZCM557AdTYwd4wCAfZTsg9nrcpCAGN6JzdIXGeDZmEmJAE5JfZ6u3k+m8iKQm6ZA7Nei62kgDvvvBOXy8Wbb75JdnY2v/zyC19++SULFiwgZ/NmFsyaxYgbzvhc85zmxx9/ZOjQoRQVFfH444+Tm5vLwu9+5fP3ZjH3px/ZvXs327dvZ+TIkaSnp1c7n04jkRhhxu1VOFjcOL5PGzZsoF+/fuzfv5+xY8eStWkTSz/7jM9ff53/fvcdW7ZsITs7mwkTJpCRUXW5ltBIaCNMaKNMKAq48+3kOlyYNBIhPmYdKrKCp8CO4vSiCTf6rTSyseLNzwcUtDEN3zbdqJGINehoHWTkAouRZkYdOkmQ5/Kwt8LJzgoHJW4Pa0qsfjNcsXq83LIlg+XF5bzZtgV3Nj/597B8OcyfD48/DiE+VrXKspeMDX+Q0rk7Wl3NKg0MJT+iIFF6pBfK0mU1X9yfaDTwwAOwZo36U0tSOnXFYS3nSPrJGXZFn38BQhBx+21MTorl8sgQnknPYX1pxfFtypbsp/TnfZjaRxJ5ezuEzr+ZYXNziwnTaugfEVyneVJTVSPsDz5QkzWrJKqV2mvu7kXw4A64+nUIjoWV09RsxGkXwa+PQ9YqtbQ2wGlIej3xzz2L+9Ah8qf7KGztWwbv9oaVb0Knm+G+dXDh9Sz4XeBwwLBh9RuzPxBaifDhaXhLnJQt3F/pNq4D5ZT8kIGhdTghg5N8m7j7OAiOV8XsE4+tpnDocjv89V8oO+SHTxDAX1Qr/gkhgoQQHwohtgoh/nX0tecAK1AhhJgthDiDv3yl/IVa/nwj0ApYVoOxHymKckclP/+owRwBAhwnbPgwpJAQrJ9/xqSBaWzMLmbp7spLFI8jy7BmBjTropYGBDiZlv0gpZ9aEuGsvVtegLqhKAqlC7KQQvRYesU3dDhNFk2I+BXkugAAIABJREFUAUNKKLYt+ccFjzKHm2/WH2BIh3iahVVRktHE0Wkk4kKMWJ0eSmxNv49pUYULt1cmLsTAvHnzsNls9OrViwceeADNCWVjssuFXFpKv0GDeeLppxsw4oahsLCQ0aNHI8syb7zxBv/6178IEkYUt4wm1IA46k7drl07Zs+ezVtvveXTvEEGLfGhRsocbvIauBze7XYzatQoHA4HkyZNYubMmSRceCHa2Fi8paW4DxxEkWUSExN57733mOtj+aRk1KKLNVMSrMUNRFd4URzVGw8pXlkVDl1eNBHGc77FhOxy4SkuRhMWjmRoXCZeekkiWq8j1WykfZCJ5kY9JknC6pUZvin9/9k77/AoqvWPf2ZrtqZ3ICF0UHoHkWJFRWzYURCxYe+941XvvdyfvVwQUERBFEQQLBeQ3otAKCEkQBLSk92UrXN+f0wIBEKy6Qns53nmgZ09Z867k9nZM+/5vu9L97V7eGrfUf7MteGsZZ7EAreHm3YcYoutmE+6xnFrdEWFjhDw4osQEwMPPeT7cTMO7KeksMCnKssV8LiQds3FGzkSZ7oe13tf1nzw+ubuuyEoqE7qw7gevZEkVYXQZa/dTsH8+VivuAJtdDQqSeLDLm1oHaBj0u7DZDpcFC5PwbY8FWPPcEJu61JlYajaUOKVWZpTyFXhgeh8zEtZFS+9pPhbX3+9Bp0CY6H/vXDXYng6Ca79BCIvgC0zYOZo+GdH+PlhOPg7eM6t9CV1xdi3L0E33UjezFk4EhPP3rAkDxY+BLPHKF/q8T/DtR+X58n/6ScIDoaLLmokw+uIvm0gpn5RFK05hiu94vOdt8hF7jeJqC06Qm7uVD5PqBatAS5+Bo5uhIO/VXxvwP0gZNj0RT19Aj/1gS93rHeBUcCPwOWSJM0E7gbuBSYCvYC3ztb5dIQQ/xVCPCOEmCeE8C3zph8/DYTKZCL45pux//EH10VCmxAj7y/fj1xVBb4DyyDvEAye0vx15k3FqFegJAc2ftrUlpy3OA7k40qxYR3Zpt5XzM83DD3D8WSX4k5XVAnfbzpKkdPDpKEJTWxZwxNi0mHUacgoLG1W4aY1xSsLsmxOzHoN5gAtWWXVEiMqyWfoKXvvbIqojRs38vTTT9O3b18iIyPR6XTExMRw4403smHDhkr7vPbaa0iSxGuvvUZmZib33XcfrVq1Qq/X07ZtW5577jkcjoqpHuLj45kwYQIAs2bNQpKk8u3UMOa9e/fyyiuvMHjwYGJiYtDpdISHhzN69GiWLVtW43P14YcfUlhYSI8ePXjssccQHhmvzYUUoKk039ewYcMqvD5hI8D06dMZMGAAVqtVCfF1lxBs1BEVaKgylDc+Ph5JkkhJSSnfd/fdd1c4B5Vtvobozpkzh8OHDxMREcF7771Xvl8bHo42Ohqv3YbryBFEmXPo9M8IkJOTw7PPPkvnzp0xGAxYrVYGDhzIx59+wnHZg0mlwizAk+vAk1vKq6+8Wn4NnMoJx+GsObPRt7Zyz4P3Vnj/1NB1u93O008/Tdu2bdHr9cTGxvLAAw+Ql1cxD9Xw4cMZMWIEAKtWrTrjHAkh6NBBqYB5tmsW4IYbbkCSJD755BOfzquvVPcday5oVBKhOg1tjXpi9Fq+6BbPRcFmFmblc/uuZC5Ys5sH9qSwOKuAYo9vSq1sl5sbdiSxp6iU6Re0ZWwlYavLlsGaNfDyy2CowfpU0pYNqNQa2vbs63snUOa1xdmoLp6ESiOwG7rVfPD6xmyG++9XPCzJybU6hMFsIapDRw5vP+k8LJj/A3JxMSGn3EMDtRpmXNCWQo+Xe9bsJ3/lUUz9owge1wlJXf/z/N9zCynxynUOWT5BbKxSEPvrr6EqX9ZZMYZAr9vhtu/gmUNw00xFCLD7J5hzI7zXDn64B/b85BcFlBHx5JOog4LIePU1xOmFfYSA3Qvg4/6wcy4MeUwJG0+4uLyJ2w2//ALXXAOaFhQYFHhlPCqjlvyfkhBlz8rCK8ibuw9vsYvQO7vWfPGr150QHK+oD09dkAlpC52vVhza/uuu2eCL8/BaYKIQ4jVgLDAeeEQIMUcIMRd4EBjTcCb68dOwBN9xB6jV2ObM4YlLO7I3w8bS3Rln77D+IwhsA12ubTwjWxqt+kKnq2Dth1Ca39TWtHjmzIH4eKUmTXy88roqhCywLU9BHRKAqW9k1Y39VIvxgjBQS5TszMLtlflq7WEGtA3hwlY1Ed23TCRJolWwAa8MGYUtN49pbpETjywTaVVyq7Vp0waAP//8k927d5e3kx0OvAUFaEJCUJ0l7O/FF19k2rRpuN1u+vfvz5gxYwgNDWXBggUMHTqU+fPnn9WOo0eP0qdPH3755RcGDRrE8OHDycrK4t1332XcuHEV2t54440MGTIEgHbt2nHXXXeVb0OHDi1v9+9//5s333yTgoICevTowXXXXUd8fDy//vorV155Jf/+979rdK4WLVoEwPjxSsVVT4GiOtEE1axwx8MPP8zkyZPR6/VcffXV9OnTB5VKRewpal2njw4XgKFDh1Y4B6du7dopuYfVPhYeOPEZb775ZvSnKd80oaFoY2ORi4pwpaSc+WAIJCUl0bt3b9577z0KCwu55pprGDZsGH///TcPT5nCfddfS4gko4kwog7UIzu8yMWKevfUkG3hkfFklyI8otrq1YWFhQwZMoQZM2bQs2dPLrvsMkpKSvjss8+49NJLcbtPqoOvuOIKLr/8cgAiIyMrnKsrrrgCSZJ4qExVdjbHYFpaGj///DMWi4U777yzulPqM758x5ojKkliTEQQn3WLZ8/QC/imewLXRASxKt/OvXtS6LZ2N3f9ncz3GXnkuytXm2Y4XVy/PYnkEiezu7fl8rAzf0NkWVEdJiTAxIm+2yeEIGnTetpc2AN9TStXb5sFlhhUHUdh2r8cR/vBuMf4nM6+4Xj4YUVS56O6uTLa9uxDZvJBSgoLEG43eV9/jbFfPwwXVKxs29kYwJs2HVvUXj4dHkLQde19V0/VkIWZBUTqNAwKMtfbMZ99VqnKXWexvN4C3a6DG2cojsTb5kO3sZC8AubfDe8lwNxbYfscRVl3nqIOCiLyuedw7NpF/tzvTr5RcBS+vRl+mAiBrWDySrj0dUVhdwqrV0N+Plx3XaOaXWdURi1BVyfgPmqneKPyrGz7LQXnoUKCx7ZHF1uLa1qthREvKsVk9p6m8h/8MDgKYUc1Dz5+Gg1ffN2hQDKAEOKIJEke4NQENweBxirDNUKSpO6AGcgE1gC/CyFarhzCT5OjjYwgcPSVFCxYwOgHH+TTSAv//u0AV3SLQqM+zb+etg1S18LlU0HdgpaKmoKRL8KnQ2DtB3DJq01tTYtlzhyYPBlO5GVOTVVeg1JlrzJKd+fgTi8m+OZO9R5ucz6iMmoJ6BBM6c5s/orWk17o4I1rL2hqs+rOr88pk7VqCAA6eb24PAKvVoW6HsKsak3UhXDlP2rUxeOVyS5yYg3QYiorbnPttdcSExNDeno6vXr14rLLLuPiiy/mwlat6N2uHRGdO5/1eE899RRz5swhMrKiY37x4sXccMMN3H///Vx11VUYK3mAnzFjBpMmTeLjjz9Gp1Ny2iUmJtK/f38WL17M2rVryx2G//znP5k5cyZr165l6NChzJw5s1J77rzzTl566SXi4+Mr7N+4cSOXXXYZzz33HOPGjaNVq1bVnyuPh127lOqG/fr1Qy71KMU7AvU1vpd8/fXXrF+/nv79+5+1zZHcEtqFm1H58JA+adIkJk2adMb+FStWMHfuXAwGA1OnTvXJtq1bFSVSv379Kn1fExwMkoT7WBqulBR0cXFIp8hDbrvtNo4ePcpNN93E7NmzCSgr+HE49QgjLrmEjStX8P5bb/LOO++gtuiUnLNln1Eu8SC7vUiShDunFLwCTVgAqmoU4gsXLmT06NGsW7cOs1l5QEtPT2fgwIFs27aNefPmcXvZj8Jzzz3HwIEDWb58OZ07d6702pkwYQIvvfQS8+fPZ9q0aYSGVgyd/fzzz/F4PIwfPx6LpW552U7Fk5WFpFKhCW/eqsOq0KtUXBJq5ZJQK+/Jgk2FxfyaU8DS7EKW59hQSzA4yMzo8CCuDAskSq/lSKmTm3YcItftYW6Pdgw8i+NowQLYvl1RkelqkPYy92gqBZkZ9BtzQ80+TMFRSPoThj0NPy3CvPRT7I9cTtGmbILHNvECWUwM3HorTJ+uVAYJrrlSr23PvqybN4eUnduItZfiycgg6uWXK7QRXkHe/P2M2JHDnZeEMkvnYlBWQaWq0LpS6PbwZ66Nu2PDUNdj9FJYmFKk+vXXYetW6NOnHg6q0UPHy5TN64GjGyDxF0hcDPuXKoVX4odCl2uUApLWmHoYtOVgvfoqChcuJHvaNCyjRqA9slgpPiNk5Tmx/31nfVZcuFAR9l52WSMbXQ8YeoSj35pJ4bIUEGBfdQzTgChMfaNqf9ALblByQq54G7qMOXneWveHVv1hwyfQb5JSTdxPk+KL9yMVGAp8K0nSAEAA/YE9Ze8PAI41jHlnML6SfXslSbpFCFH9E5CfcxKvzUnxlkyoKtS4GvRdrkAs+pnsf/yXB3tczqO7jjDnm11cF1tx4mDY/x4atRl74XD4I7WOltcddZAeY5/IGqlBGo3IbnDhjbDxMyVvhcWvgKsNL7540nF4gpISZX9lzkPhFdh+T0UTYcTYo+U+nDU3jD3Dyd2Xyxf/SyIh3MTIzmeGu57LaNUqPF4vTo+MQSch1ajWWdOSU+TEK4ty1SGAxWLhjz/+YPz48WzZsoWlS5eydOlSAFQqFQMHDuSRRx7h5ptvPuN4V1xxRaXjXHPNNdx00018++23rFixgquuuuqMNq1bt+aDDz4odxwCdOnShTvvvJNPP/2UP//8s9x56CsXX3xxpfsHDBjAlClTmDp1KosWLSpXmlVFbm4uclnYUHhYON5CJ5JWVa0qrjKeeeaZKh2HALLbgS07H0NILPpapFdITEzk+uuvx+Px8N133521KvLpZGcruY0rC1s/gSYoCEmlwnX0qOJAjI9H0mhYvXo1mzdvxmKx8Nlnn5U7DgECoqJ45t33eOiG6/j444959dVXCQgIUM6hsWzKLQs8WSXlaU804QZUuuo/u9lsZvr06eWOQ4CYmBimTJnCs88+y59//lnuPPSFwMBAxo8fz6effsr06dN55plnyt9zu918+eWXADz44IM+H7MqhCzjtdnw2mxowsMrOGNbMhqVxOBgM4ODzbzRPpad9lJ+zSlkaXYBzx84xvMHjtHHaiTD6abYKzOvZzt6W02VHsvjUZRjXbsqPrOakLR5A0gS7fr69h0o54Sip/utMHQ06vhojL0jKdmaifXSuKbPv/nEEzB7Nnz5JZxyjfpKZNt2GAODSN6+BcPqzeji4zEPP3nPFB6Z3Ln7cOzJxXp5HFMvbs2BHUk8vu8onUwBdDHXb+j20pxCXEIwNjKoXo8Lyqn68EMlB+Kvv9bzwdUaxVEYPxSueEepzryvzJG49Clli+0LbYcpTsfzAAmIuiKC5E0O0u64ElNwDgQnQKcrYCuw9fOz9jX9Au/2huIZUHzWVs0X4dEhnB0p+PkQ2lZmgq5pV7cDqtQw8iX47jYl1Lv3KWr3wVNg3njYtwS6+oNdmxpffrk/A2ZIknQv0BN4HJgqSdIFgBeYDNQ+m61v7ED5Gv4BHAGsQG/gbaAH8IckSb2FEGmVdZYkaXKZneWhSn7ODYQsyP0mEdcRex2PpEEd3hn78gX0Er3polLxSWI6FyXa0JU9JKvJwqJfTpH3Wmwr84DmIdd3HbETNLbhwivqxPDnYfePsPpfMPq96tv7OYMjlRc1O+v+ku1ZeLJLCb2jS/O8JlooAV1D2aUW7M4u4u3rLvBJKdXsqYGCTwK8DjeHc4qJsAYQdYojrjnj9srkFLkIMugwnOag6dKlC5s3b2bdunUsWbKE9atWsePvv8m32Vi3bh3r1q3j119/rVS1lZOTwy+//MLu3bspKCjA41HCFE+EQB84cKBS5+HIkSMxVJJHrHOZ0jE9vXZVBe12O0uWLGHHjh3k5eXhcrkAOHjwYLk9NcVb5AKLQB1adX7Cs3H99ddX2yY2wInZlUtaFhRrgrEatAT6WBk+MzOT0aNHU1BQwLRp07iuAeK/1FYrujZxuI4cwXn4MLr4eFatUur8XXPNNYSEhJS3dcsy2S4PV115JW9FR5ORkcHWrVvLncEnzqHKpEUVoEF2yWhCA3xyHAL06dOHqKgzlR11uXamTJnCp59+yueff85TTz2FqkxV/OOPP3L8+HGGDx9O165da3zcEwivF7moCK/Nhmy3I2QZSatFE9ZYAUuNiyRJ9LQa6Wk18nxCNAeKHfyaXciSnAIMKhVfd0+gWxXOqG++gX374McflWjdmpC0ZQPRHTphCqqBWk72wravod0IWLwK9u+HH3/EMrgVJVuzKN6QgXVUEz839egBo0bBBx8oFZhrIscEJJWK+O69OLR5Awm7dxP92qtIZde5cHvJ+ToR54F8Aq9OwDI0FoAvusVz6Zb93LM7hWV9O/pcMd0XfsrMJ96go5elhqHlPmC1wvPPw9NPK9W6K0nVWj9IEsT2VrZRr0D2fsWJmLgY1tQsTUZLRwdEdDeSuS2Q0jQrkAOrv6m233id0jTno4a2sOHQth2OLmEk3uMHQOpe9wN2Gg2xfWDlP6D7uJNO6M5XQ1CckjbM7zxscqqdoQkh/k+SpGxgEPCZEOJ7SZL2AG8CRmAaihOvwRBC/Oe0XcXAEkmSfkep1jwQeB6Ycpb+XwBfAPTt27f28jQ/zY7iTcdxHbETfFNHjL3rpgQq+kvm2H33Yx1i54Wug7lz+iZWXdOauwfHKw1+ewk2SJgffwNzYOu6G19XBNh+T8W+4ijC5SX4poZJ7FwnQtspq0dbZigrR0F+531NadNGCVWubP/pCI+M7Y9UtK3MBHQLPbOBn1qj0qmZZ5IJtElc1/38Cs05gSVAS5BRR7bdSZBBS0ALKMSTbXciBERaz66EGDx4MAN69MB1662ow8PZcugQr7/+Or/99huzZs3iqquu4qabbipv//nnn/PEE09Qcrok+BRsNlul+8+2gGm1WgHOKJriC4sWLWLixIlnFM3wxZ7TCQ0NRaVSIcsymUcy6NSho8/OrdOJi4urto05NBY510GMK490DGTbvGTZwO1VpmolTg9CiDOclyUlJVx99dWkpKTwyCOP8Nhjj9XItvDwcI4ePVpeOKcq1BYzuvg43KmpuA4f5ljZyk3btm0rtMtyeRBAlE5LQkICGRkZpKWduaYtqSQ0oTVXMzXEtdO1a1cuueQS/vjjD5YtW8bo0aOBk3kQfVGrno7wePDa7cg2G96iIhACSa1BFRiI2mpFZTKVO2/OdTqaAuhoCuDR+OojL5xOJTK3b18YO7Zm49hysshMTmLY7RNq1vHQCrAdg5GvwbVPlQ+ulST0HYMpWp+O5eJWTZ/+5MknYfRomDcP7rijxt3je/Vl7+oV2CPC6Hytkq9cdnrInbUX5+FCgq5vj7l/dHn7SL2WL7vFc8OOJB5JTGXGBW1R1UOET5bTzZr8Ih6Na7iIoYcegmnTlOiUv/5qpLqO4Z2UbdhTSrGQ84wQIFgIn0/2Ky/D1HcgMxNCW/JUXQiy/u8D8j7/BuEsJOadqXVTlEsSjHwZvh4LW76Cgfcr+1VqGPggLHsWjm6G1pWnG/HTOPj0ayCE+FYI8bAQ4vuy16uEEMOEEH2FEK+fmnNQkqQhkiQ1il5ZCOEC3il7OboxxvTTfPDaXBQuO4y+XSDG3hHVVmGsbjNfdBG6du3ImzmLIe1CGZQQyscrkih1e5GcdqRts5G6jUUKalPnseplU0kEXh6P9fI4SnZkk/ttIsLTDNN/DnsGJBWsfLepLWmRvP02nJ46TZIqj94p3nQcb4GTwMvjm2coewvmcE4xf9lKuA4tUp2Vzi2X6MAAVBKk5ZdWKPzQHHF5ZHKLXQSbtFWGxAoh8GRmImk0aMPDGTx4MEuXLqV3796AkmvuBJs3b+aBBx7A7Xbz/vvvs2/fPoqKipBlGSEEzz//fPkxK0NVz06TY8eOceutt5KXl8fzzz/Prl27sNlseL1ehBB8/vnnVdpzOhqNhu7dFQXBlr+3oa7C6VodlSksz0CSUAXHI6m1xIpMukQaaRVs4MS0MjWvhMTjdtLyS7A73MhCIMsyt956K1u2bOHaa69l2rRpNbatT1lCsM2bN/vUXm0yoYuPB68X2W4vM/3kPdYly+S6PYRoNOhPz5XsI7Jc9e93fV87J3j44YeBkw7D3bt389dffxETE8NYH71YstuNJzcX5+HDOPbtw52WhuxwoAkJQde2LfrOndDFxqK2WM4bx2FN+fJLZaFw6tSaO3ySNm8EoH2/gTXruG0WGENhdZoSznDK4JaLYpGL3JTsqN7B3uBcfjl06QL/+letnFMxQaEgBLb+vVAZDMilHnKm78aZUkjIuE4VHIcnGBBk5rX2sSzLsfFhav2cg5+zC5ChQXIpnsBgUAplr1mjVO1udCTpvNwklcrn57efFkoMGyYRFtYMniXr9ByqIvLxxwh/7DFsixeT9vjjyGVRD7UmYTjEXwSr/wmuUwK6e90B+kBFfeinSWmIX/BfgdgGOO7Z2Ff2b2OO6acZUPDLIYRHJui6DvXiKJFUKkLuvgtnYiKlmzbz1OWdyCly8dXaFNj+NThtMKhScWuTYh3RhsCrE3DsySVn9l6E2/fqlY1CYKyS5Hbnt5Bd89C5853bb4cvvoC4OGWOEh2thDPNm6fkRzqB7PJi+98R9AmB6NvXfy6d853pa5LRqiVu0Bsp3ZHd1OY0GVq1iujAAIpdHvJL6jhJbGCybIoSK8JSdYi1XFSEXFKi5GErc2yo1WpGjhwJnMyPB7BgwQKEEDzyyCM89dRTdOrUCZPJVP4blJSUdOYADcgvv/xCaWkpN9xwA1OnTuXCCy/EYrGUO5pqY8/Vlyvh1t/++F2DpT7QllXZLSoqUnJpBbcF2YOmMBWLViI78zgAsUEBmHRq8kuUkPnEDBuTHpjCzz//TP/+/fn2229r5VQbM0YJffr+++9xOp0+9VEZjeji44kpy5N4qCwkHCDTqVQ6jiwryJOcnKzYH3tyanoiz2VRUVGlx0+tTGLeCFx99dW0bduWX3/9lZSUlHIn4uTJk9FUoSKRnU7c2dk4Dx3CuX8/7owMhMeDJjwcfbt26Dt2RBsdjfqU74efyikuhrfeguHD4ZJLat7/0Jb1hLZqQ3B0DR6FirKUohddb4S3/3HG4Pr2QWijTNhXpzX9QpFKpST027EDVq6scfeSHxYQVOoiUyXwFrnI/mIXrrQiQm/rgrHX2aOW7okN4/rIYP5xOIOVeb6pt6tiYWY+XU0BdDI1bNqPiROVat0vvqhU7/bTfDh4EPbsaXlVlqsi7P77iHzheey//8Gxh6Yg10IFX44kKaHwxdlKzvwT6M3Q925I/BnyU+pqsp860BDOw8aeIZwQ/FY+G/NzTlK6L4/SXTlYR7RBG1Z/yYwDx4xBHRJC3ldf0ScumEu6RPDfVQeQ138KcUOU/B7NEMvQWIKub4/zYD45X+1Bdnqq79SYXPQEaI2w0rdKmH4qcvvtkJKiTALT05XCg6tWwXPPnWxTtC4duciN1a86rHfyi138sPUYY3vF0qp7BKV7cpufk74RCTbqMOk0ZBQ6cHub55OJw+0lv8RNqEmHrpKQuxMPw+WqQ60W9WmVPI+UhaeeWqX4RGhw69Znpq7Izs7m999/r7fPACcdTh5P5ff0quxxOp0sWLCgRuMJj8z9t92D1WJl59+7+M9/Ts8acyarV6+u0Rhw0qm2b1/Z+q/OCEGtwVXEbwu/K/+8VoOOuFATXaOtxIeamDfzc7764lNi28Tx3hdzyC4V5Je48NTwCfn2228nLi6OrKwsnn322Wrbn/iMKoOBEddcAyiO29z0dBxemTyPl1CtBp1KxfLly8nIyMBsNpcrHCv9zKcghGBZPcuEqrt2TqBSqXjwwQeRZZn333+fb775Bq1Wy+TJk8+wUS4txZ2ZifPgQZwHD+LJzARAExmJvkMHAjp0QBsZicpQuzyZ5ysffqiEML79ds1Vh6V2G0f37qZ9v0E167hzLsge2CVXOrgSkROLJ7ME58GCmh27IbjjDggPV9SHNcCTn0/hTwtp3aoNhWnZZH22A3d2KaHju2K4oOrcm5Ik8X6nVnQ2BfDAnlSOlPq20FAZqaVOtthKuK4BVYcn0OmUEPjt25X8mX6aD4sWKf+WRc+fM4SMH0/UG69TvGYNRyffh7eoDmVgWveHjlfC2v+D0vyT+/vfp0Sybfjs7H39NDjnQuzAuLJ/fYs98dPikV1eChYmoYkwYLm4VfUdaoBKryf4ttsoWrUK56FDPHlZJwa71qOyHYVBNc/905iY+0cTMq4TzpRCcqbvRi5tRg5EU5iSr2LPT5Cxs6mtafGMHw8PPqjMoefNA7nUg33lMQI6h6CPsza1eeccczam4nDLTLooAUOPcITLS2li8yiY1BRIkkRssAFZQEZhHVaYG5AsmwNJgnBL5WG3n3zyCRMmTGDDihVKeGVERLnq0OPx8OWXX/LDDz8AVKi4fKI4xezZsysoyOx2OxMnTqSgoH4fsk84nBITEyt9/4Q9CxYsILPMkQPgcrl4+OGHyxVwviCEwFPgJDw0nK9mzECSJJ544gleeOEF7PYzQ/UPHDjArbfeyiOPPFKTjwTAqFGjAHjjjTfKi7tgDGVPai4PP/3CGe1VKok/l/3CWy8/T3BwMIt+Xkz7uFhKXF6O5pWQmG4nObuI3CKnTw5tnU7H999/j16v5//+7/+YNGlSpfkP09LSmDJlSoXw3YsvuYR+fftiLy7mwXvvJSM7GxXrikSFAAAgAElEQVQQodOQlpZWnn9xypQpFSoxjxgxApVKxbJly1i7dm35fq/Xy4svvsimTZt8One+cuLaSUpKqtaBeM8992A0Gvnkk0+w2+2MHTuW6OhohBB4i4txZ2TgPHAA56FDeLKzQaNBGxWNvmNH9O3aoQ0PR6U/Pyqs1jcFBfDee3DVVTB4cM37J2/bjJDlmoUsCwHbZkNMX3h/+lkHN/YIR2XRYV99rOaG1TcBAUpCvyVL4Cz3w8oo+P57hMNB52tuY2TUbXjyHYRN6IahU0j1nQGTWs2MC9riRTBpdwqOWi6YLcpSfhuujWicyJDbblOqdr/8csUoFT9Ny8KF0KuXEk10rhE8bhwx771LydatHL3nHrw+5lqulJEvgaMQ1n14cl9gLFxwgxINWNoMFjTOU+qQ1bJxkCSpJ9AK+FUI4T1lvwZ4FDgxa6150hs/LRLbH6l4C5yE39e9QZI4B992K7lffknerNl0ef01nrb+TkppNKaYkYTX+2j1i7FXBJJWRe7cfWR/uYuwey5EbdI2tVkKg6fApi/gf2/B7fOb2poWz7RpyqryxInQ+/NjBDg8WC87B2cjTYzT42XW+lQu7hhOx0gLIlygsugo2ZmNsXtzvyM0HAFaNeFmPVl2B8FGLZaAZnKfAUpdHgpK3URYAtCeJf+c2+1m5syZzJw5k6jwcHr26UNISAh5eXns2rWrvHLtM888w+WXX17eb8KECfznP/9h27ZtJCQkMHToUIQQ/PXXX+h0OiZOnMiMGTPq7bMMHDiQqKgotm3bRt++fenWrRtarZYhQ4YwYcIExowZQ69evdi+fTsdOnRg+PDhBAQEsHbtWgoLC3nkkUf44IMPfBpLLvUgHB7UgXquv/EGFi5cyN13380777zDtGnTGDBgADExMZSWlrJ///5yh+Ytt9xS48/1/PPPM3/+fBYvXkynTp3o06cPx48fZ/PmzYwbcwWyLJN6LKNCn6eeegpZlomLi+PDaSfVRx6vjNsrcHll2iS0556HHsek0yiVmw0adGeplDpgwABWrFjBuHHjmD59OrNmzaJfv360adMGj8fDoUOH2LlzJ0IIBg6s6Jj5du5cRowYwbylS/mr+4UMGDIUr8fNihUrKC4uZtSoUbz22msV+rRp04YHHniAjz/+mBEjRnDRRRdhtVrZtm0b+fn5Nfpb+UJcXFz5tdG9e3f69OmDXq+nU6dOPP300xXaBgcHc8cdd/DFF18AcP+ECbjS0pQKyR4PSBJqsxlVeDhqq7VuSfH9VOBf/4L8fCVsuTYkbd6AOSSUyIT2vndKXQe5SeC9RPFenmVwSaPCPDga2/JU3MeL0UaZamdkffHgg/CPf8B//gNl+VyrQna5yJszB9OwK9HuNBOgFiQF76F1u5qVIW5r1PNRlzjG/32Y5w8e49+dWtdYWftTZj79rCbaGBrHya5WK3/W669XqnjffXejDOunCjIzYd06RRV6rhJ4zTVIAQGkPfEkqXffTZvp09EE10JtG3WB4ijc8CkMuB/MZekFBj0Eu75X8rUOebR+jffjE42uPJQkqbckSRtObMCJONCpp+0/QTywGMiSJOl3SZLmSJK0DEgF/lnW5hkhxPJG+xB+mgxXehFFa9Iw9YtC3zawQcbQhIQQeO21FC5ahGfXb8Q7EpnuvZJPVvmu4GhKDBeEETq+K+6sUrI/34XX1kzykgUEwtDH4eBvkLq+qa1p8eh0MH8+tAp1IbanoekShi7G3NRmnXMs2pFOtt3JvRclAEqlVGP3MBz785Ad5/dyfoRFj16jJq2gFFluPsVTMm1O1CqJMIvurG3uuecefvj6a+675RZatW7N33//zfz58/nrr78wm83cddddrF69mnffrVjoKTg4mC1btjB58mTMZjNLlixhy5YtXH/99Wzbtq3S8OG6oNfrWbZsGVdddRWHDx/mm2++Yfr06axatQpQCpysWrWKZ555hujoaH777TdWr17NsGHD2Lp1K7169fJpHOGV8RY4kbRqVGbFETxmzBgOHz7M+++/z6BBg0hMTOSHH37g999/R5IkJk2axMqVK5k7d26NP1e7du1Yu3YtY8aMoaCggCVLllBYWMj777/P7LnzKM+AI59MD+D1Kv/fsWMHs2bNKt/mfPM18+Z+w8J537J93UoirQF4hSCjsJR9x+0czLSTaXPgcHvPyN02aNAgDh48yKeffsqll15KamoqP/30E0uXLqWoqIjbbruNxYsXs27dugr92rdvz/bt27nv0ccwm0wsW7qElStX0q1bNz766CN+/fVX9JUo8T744APeffddEhISWLNmDWvWrGHAgAFs2bLF579VTfjxxx8ZN24ceXl5zJ07l+nTp7NkyZIz2gmvl1FDhgDQtX17BrVujbewEJXJhK51awI6d0YXF4cmJMTvOKxHsrKUhcCbb4aePWve3+10kLJzG+37DayZM2vbbNCZ4aPl1Q5uHhCNpFVhX31m5fBGJzxcCb2YPRuyq889bFv8C8KhRR19HcIjczjqIHv3rUaWa5525LKwQB6Pi2RuRh7fZOTWqO++4lISix2MjWzcfNRjxyoFtF97Tanm7adp+flnRfR7LuU7rAzrpZfS+uOPcB1KJvXOO3FXour3ieEvgMcJq09JVRDdQymosvFz8Lrrx2A/NUKq7yS4kiTZgJ5CiEo9LZIkDQdWVHccIYRU1r4tisKwPxCHkuNQAMeA1cDHQoitvtrXt29fsWXLFl+b+2lGCFmQ9ckOvAVOop7og8rYcEoXZ3IyyaOvImx4NOFtk3k5YR7f78hlxdPDiQ2qvxyLDYnjUAG5s/agsugIn3QhmuCGTdDsE64S+KAnhLSDCUtrntzHzxns/uwQ5uR03kntw2ffGf2ntB4RQnDFf1YjSfDroxeVP5w5j9jI/mQnwTd2xNQ3somtPDuJiYl06dKlQccocrhJzikmwqInKrDp743FTg+HsouICgyoslCKkGWcBw8iqTXo2iWc9/nZPPkO5GI3mggjKt3ZK1M3Gk67oowKCFSKqdTi7+P0eLGVeigsdVPiUhz9eo0aq0FDYIAWg05dp797scdLUomTaI2KwPQ0ZKcDXatWqAMbZmGzvhEeD167Hdlux2u3c/Mjj7D4f//jg7en8uCUh1CZzf7KyKfQEPfTxx9X8h3u3QsdO9a8f9LmDSz651vc+NJbxF3oo/exNB/+1RmK4+H9rT4Nnr8oieJNx4l+rj/qKhZlGoV9+5TKy6+9Bq++etZmQghSxt2LJm4c6uBAwiddQNLBzSz98J/c9ta/iO7QqcZDe4Xgjl3JrM0vYmHv9vS2+qbE/EdyBh+kZrJzSDfCdY2r0v/9d7jsMuU6m9L8aj6eV1x1lXL5JiWdH48/xRs3cfSBB9CEhRH31Qy0sbWobfvzw7DzO3h4m5IXGeDAcvh2HFz/X+h+U/0a7QcASZK2CiH6VvZeoxdMEUKsFEJI1W2ntD8shHhMCDFYCBErhAgQQhiEEB2EEBNr4jj007IpXp+O+1gRQVcnNKjjEECfkIB5cD/y1x9D7n4XD1x6IQAf/HGwmp7Nh4B2QYRNuhC52E32Z7vw5JQ2tUlKUvxhT8ORdXDoz6a2psXjKXAQdDSDI8ZIvphn5DSRlJ86svpgDvsz7Uy6qKJzSdfagjokgJKdtVxNPYcwB2gJNurItrtwNHERGSEEx20ONGoVoaaqQ8O8+fkItxtNZMR57ziUnR7kYjcqs655OA4B9Bawxio5j4oyq29f2SE0asItetpHmOkSbSU2yIBWLZFjd5GUXcS+43bSCkopcrhrXE1WCEGGy41GJRFq0KNrG4/KYMB19Cie/Pxq+zcVstuNJzcXZ0oKjv37caelIZeUsuvoUZasXEloaCgTH31ECU32Ow4blCNH4JNPlHDS2jgOQXEe6k0mWnW5wPdOf/8AHgfM2enz4JYhsSALital187Q+qRzZ8UL8/HHUHr2eW3hL2vRtLkJlVFHxH3d0UaaiOveCySJwztqJyJRSxKfdI0jUq9l0u4UclzVRx8IIfgpM5+Lgi2N7jgEpYD2xRcrIczFdahh4adu2Gzwxx+KGvR8mXKYBvQnbsZ0vPn5pNxxJ67U1Jof5OKygmarTnnAaX8phHWE9R8qUk4/jUq9zwyEEJazqQ79+KktnkInhb+lou8QhKFH4+QZC+mhwutUU5jThpggA3cMjOOHbcc4lN1yCnvr21gJv7c7wuMl6/OduDObwcyh910Q1Ab+fNN/068j9j+PAjDo0TbcfDO8+KIyOfFTP3y5OpkIi54xPWIq7JckCWOPcJxJBXjtzSQtQBMSHRiAWgXH8ktr7ISpT4qcHoqdHiIsetSqs8/OhSzjyc5GZTSiMp/fof5CCLz5TlCrUFubWFF0OqZwCAgCewY46pB4HdCqVYSa9SSEm+kSbaF1sBGjTk1+sYvknGISM2wczSvBVur2KQS/yCtT7JGJ0GlQSxKSWo0uLg6VyYQ7LQ1PXvMpqCQ7nXiyc3AmJ+Pcvx93RgbC5UITGsqUf/6Tu197lUvHjUOWZd544w1MpibOa3ee8Oabyr+vvFK7/rLXy6Ftm0jo3R+1r6HkQsDWWeAKgkzh8+CaMAMBXUIp3piB7GraRSIAnnxSCVueM6fStx2HCrCvcSE8JYRP6YMmTFHFG62BRLfryOEdtdedBGs1zLggnjy3h/v3pOCp5n6x3VZCqsPFdY0csnwCSVIKaWdmwkcfNYkJfoBly8DlOvdDlk/H0LMncbNmIhwOUu64A+fBGopwAltBv0mw41vIKeurUilFODN2Qsqa+jfaT5X47DyUJClEkqRPJUk6IElSgSRJtlO3hjTSj5+Cnw8hvILgse0bRyVSkofRvhx9jJm8735CyDIPjmiHXqNi2u8HGn78ekQXayZ8cndAIvvzXbjSmtj5qdHB8OchYwckLm5aW1ow7pxSircexzwgGm1wAP/9rxLJc8stiqLBT93Yf9zO6oM53DU4Hl0lhZmMPcNBQOnfOU1gXfNCo1YRFWigxOUhr7hpnKknVIc6tYoQU9VOMG9uLsLjQRMZ6Vcd2l0Ij4wmSI9UhcO1SZAkZaFJEwD5KeCpn2tLo1YRbNIRF2qiS7SVuFAjlgAtNoeblNxi9mbYSM0tpqDEhVc+s7KqEIIMpxutSiJUe9Jpc8KBqLZYcKen48lpmnuDEALZ4cCdlYUzKQnnwYO4M4+DLKOJiEDfvj36Dh3QRkUxY9Ys5s+fT1hYGO+//z4PPvhgk9h8vnHwIHz1Fdx/P7RpU7tjpO3bg8Nuo0O/Qb53St8OmX/DH5k1HtwyLBa5xEPJttopgeuV4cOVkrX//jec9h0t3Z9Hzoy/ke3ZGDrkoYuwVHg/vmcfjh86SImtsNbDX2gx8m7H1qwpKOKdwxlVtv0pKx+9SmJ0eNM4DwGGDFHEmu++q9TH8dP4LFyopOwcVIOv67lCQNeuxH09GwmJ1DvH49i7t2YHGPqEMg9YMfXkvh63gDEM1n9cv8b6qZaaKA+nA1cCM4HHgIdP2/z4aRBK9+Ti2JOL9ZI2aEIbKafW1q+QPCWETpiI69AhilevJsysZ+KQtvyyK4O96S3LX66NNBFxX3cknZrsL3fhTG1i+7vfDGGdlMrLtUhc7Qdsv6ciqVVYRig5QMxm+PFHZWXzhhvA4WhiA1s4/12djEGr5vYBlT9caSNNaKOMlOysPmn7+UCwUYtZr+G4zYHbe6bDpaGxOTyUurxEWANQVeEQFF4vnpwcVBYL6vNcYSXcMl67C5VBg8rQTItgqNRKzkME5B8+w1FQV9QqiUCDjtYhRrpEW2kbZiLIqKXY6eVIXgl7M+wczikmr9iJp+y6tnm8lHplonTaM641SaVC27o1amsg7uPHcWdlNYoaVwiBXFKC+/hxnAcP4kxKwpOVBSoV2qgo9B07om/fHm1EBKqAgHKnuRACr9dLcnIyTz31VIPb6Ufh1VdBr4cXXqj9MZI2b0Cj1RHfo3f1jU+wbTbIKkhS13hwXZwVbWsLRWvSEU1dIEuS4IknIDFRkXSVUbo7h9zZe8FbSOmWjwi544Yzurbt1QeEIHXntjqZcHN0CONjQvn4SBa/ZFXukfMKwaKsAkaFWLGepep7Y/HWW0pV73/9q/q2fuoXlwuWLIExY5Qq2Ocj+vbtifvmaySjgdS77qZk+3bfO5vDYeADsOdHyNil7NMaFEXigV9PKhL9NAo1cR6OAm4WQkwVQswUQsw6dWsoA/2c38hODwU/J6GJNGK5qBaJVmuDxwUbv4B2I7HeMglNZCS5M2cCcO+wBKwBGv712/7GsaUe0YQZCL+vO2qTlpzpf+M41ITLjyo1jHwRcvbDrnlNZ0cLxZVeROnObMxDYyskL+/YUSlCuGULPOxf0qk1WXYHi3akc1PfVgQZz65iM/SMwJVqw5Pv99RKkkRskAFZQHpB4+ZXFUKQWehAr1ETXE0+XE9ODsLrRRsR0UjWNU+EEHgKHICEOqjq/JBNjjYAguLAXQK2Yw02jEqSsARoaRVspEu0hXbhZkJNOpxuL8fyS0nMsHEou4g0mwMdEKyt/ClQcSC2Qh0UhCcrC09mZoM4EIUs4y0qwp2ejnP/fpzJyXhyc5F0OrQxMQR06oQ+IQFNWBgqXTMLST+P2bkT5s6Fxx6DyFrW2xJCkLRlA22690Qb4GMxPFcx7PwedjnggZoPLkkSlqGxeHJKcSQ2g7D8m2+G2FhFfQiUbM8i99tEtBEBFC1/k6CrL0UddKbaLyqhAwaLtU6hyyd4s0Msva1GHt13hIPFZ84D1uUXkeXyMDYyuM5j1ZWePZVTNm2aUuXbT+OxYoWS8/B8C1k+HV1cHPFff406JJgj90yieOMm3zsPflgpoLbi7ZP7+k0Ctd6vPmxkauI8zAJaTrI3P+cEtt9S8dpcBF/fAUndSMm7d/8ARcdh0BQkrZaQO++gZP0GHImJBBq03D+8HX/uy2JrajOYPNUQTXAA4ff1QB0UQM5Xe3Dsb8LP0GUMRPeElVPrLRztfMH2eypSgKZSh/rYsfD88/Df/yqbn5oze10qbllm4pC2VbYzdlfyr/rVhwp6rZoIi57CUje2UnejjVtQ4sbh8RJl1VcZhiw8Hjy5uaitgagMTV8ZuimRSz0Ipxd1oK7xflvrgiEIzJFQkgvFDR8OLEkSJr2GmCADnaIsdIgwE24JwOWV8ZR6cNuUoitZNkelhYIkSUIbG4s6JARPTg6ejOP14kAUsozXZsN17BjO/ftxpaTgKShAZTSibdWKgM6d0cfHowkJQdI2fnEGP9Xz8ssQFAR1EXpmpSRjy86ifb+Bvnfa8xN4SuCgvtaDGy4IQx2kx76m4Zz4PqPVwiOPwJ9/UrRgE3nz9qOPDwR5PcJhJ+SuuyrtJqlUxPfoTcrObYg6Kpn1KhX/7RaPQaVi4u7DFHkq3gt+ysrHpFZxaai1TuPUF2+8oUSl/OMfTW3J+cXChWAywahRTW1J06ONjSXu66/RxkRzdPJkilav9q2jIQiGPAYHlsGRjco+czj0uBl2zm2UeYEfhZrMGF8E3pAk6fzOLu6n0XAds1O0Lh3TgGj0cY30wysErPsIIrpCu5EABN10E5LRSF6Z+vDuwfGEmfW8t2x/kxYHqC1qq47wyReijTCQM3svpbub6IYrSTDyZSg4AttnN40NLRBnqg1HYh6Wi1udter4m2/CpZfCQw/B5s2NbGALp9Tl5ZuNqVzaJZL4sKrDWjUhAejaWCjd4XceniDcokevUZNeUIq3EULbZCHItDswaNVYDdWoDrOzlbxvkee56tAr4y1wIunUqEwtyMFkiQadBQqPKSqqRkKSJAw6DRFWPZi16Kw6ogIDkJA4bnNwINPO/uN2jhc6KHF5yucFkiShjY5GExqGJy8Xd3p6reYMwuvFU1CA68gRHPv24TpyBNluR2WxoGvThoDOndG1aYMmKAjpfI2JayFs2ACLF8Mzz0BwHcRoSZs3IEkq2vUZ4HunVR9Djhdur/3gklrCPCQW12EbrmP2Wh2jXrn3XuyDbqNgs5OAjsGE3NKOwu+/xTxqJLq4uLN2a9uzD6V2G8eT6x7uGBOg4/NucSSXOnl035Hy77hTllmSXciVYYEYmskCTceOcNddSpXvo0eb2przA1mGRYvgyivBV5HwuY42IoK42bPRtUvg6IMPYfv9d986DrgPTBHw5xsnC24OfEipHr9lRsMZ7KcCVd7NJEn6W5KkXZIk7UJxHl4GZEmSlHhi/ynv+/FTbwivIP/Hg6jMWgKviG+8gZNXQtYeGPSQ4twC1IGBBN1wA4VLluLOzMSo0/DwyPZsPJzHmqSWudKhNusIv7c7ulgzud8mUrK9iWIY2o+CNoNh1fvgKmkaG1oYtuUpqMxazENiztpGrYZvv4WoKLjxRmiivP0tkh+2HaOgxM29wxJ8am/sEY77eHHzqGTeDFBJEq2CDbi8Mln2hg/nzi924fLIRAYGVKk6lN1uPHl5qIOCUembeZhuA+MtdIEsUAdVrdRsdkgSBMeDWqsUUPF6GnX4PLcHlyyIMeqJsATQPsJM5ygrMUEGtGqJbLuTpKwi9h+3k15QSpFTsU8TFYkmPBxvfj7uY8d8UjsJjwdPXh7OlBQc+/bhPnYMuaQEdVAQuvh49J06oWvVCrXViqRqHo4JP9Xz4osQEaEI5urCoc3rie3cFaM10LcOmXuhYC8c0MOjj9ZpbFO/SCS9GvvqtDodpz6w7bBTOOx+DAf+InRUELYlP+MtKCB0woQq+8X16A2SxOHtdQ9dBhgSbOHFhBiWZBfy6VFlMXFlnp1Cj5frmkHI8qm88oridzlR7dtPw7JpE2RkKFFBfk6iCQkhbuZMDN26kfbY4xQu9qGAps4Ew56G1DWQvELZF9EZ2l8Km74Atz+FUGNQ3YzjB2DBKds/gXeB707bv6ABbfTjA3PmQHy8Ur08Pl553ZIpWpeOO72YoGvaoQpoxETu6z9SQqMuvKnC7pDxd4Isk/+NcmJv6d+a2CAD7y9vmepDAJVBQ9g9F6KPDyRv3n6KNlVdMa5BkCQY9bISJr75y8Yfv4XhSMrHmVyIZURrVLqqFSZhYbBgAWRmwq23gtdfl6ZaZFkwY81herQOom+cbxN+Q/dwkPyhy6di0msIMenIsbsodTWcg0eWBVl2JyadBou+6t8JT1mSJ01EeIPZ0xKQHR7kEjcqi67ae0izRK1RHIhet+JAbKTfX1kIMl0eTGoVllNURDqNijCznoRwM12iLbQKNhKgVZNb7CI5u4jEDDtpBaWUBoagiYzEW1hI8aFj/L1LZssW2LULcnPLxnC58OTk4ExOVhyG6ekIlwtNSCi6tgmKwzAmBrXZ3CIdhrm5yuc9/XOf6zz9URrxD/+PuGeXsL/j/+g5No261GoqyDxO9pGUmoUsL3obvAJGP0mdBgdUARpM/aMo/Tu7LG9q4yOEoHBZCrblqRjbGwn5+XX45CPyZs4i4MILMfSuuoiM0RpIVLsOpNRD3sMTPNA6nGvCg3jrUDpr8u38lJlPiFbNsGBL9Z0bkbg4pdD2jBlK1W8/DcvChaDRKNWu/VREbbXSZvp/MfbpQ/ozz5I/z4cc+H3ugsDWFdWHg6dAcTb87c+h3xhUOfsQQrzu69ZYBvs5kzlzYPJkSE1VvkepqcrrlupA9BQ4sP2eQkDnEAwXhjXewFmJkPQH9L8XNBWVKbrWrbFccgn533+PXFyMXqPm0Us6sOtYIb/tzWw8G+sZlV5N2IRuBHQMpuDHJOxrmmAlOW6wsmq0Zho4Cht//BaCEILC5amoA/WYB0T71KdvX/j4Y/jjD3jppQY28Bzgz31ZHM4pZtLQtj4rstQWHfr2QZTszG6xCwkNQZQ1ALVKIq2gtMHOS26xE7dXVkJIq1IdOp148wvQBIec14UjhBB4C5ygUVUotNTi0JkgsBW47GBvnEWvHJcHjyyI0mvPeq1p1CpCTDriw0x0jbbSJsSIWa+hsMRNSk4xB1w6CkyhqJ02ojiChIzkdlB8LIvi/Uk4DxzAffw4eGU04RHo27VD36ED2ugo1CZjy1KJnkZurjI3dZWlN3a5lNfnugPx6Y/SmHf4bzCVIkmgCSxln/lvnv6o9nOtpM3rAXx3HrodkPIrHNHCA0/WetxTORH5ULQ2vV6OVxOEEBQuTsa+8iim/lEET+yNdN21FM2ciSs1ldAJd/v0XWnbsw8Zhw5QYqufeackSUzr3Jp2Rj337UlleY6Nq8OD0Kqa3/f2hReUat+vvtrUlpz7LFwII0YoeU79nInKZKL1F59jumgox195lbzZ1aSx0uhh+HOQvh32/aLsa3sxRF6oFE7xz8MbHJ8lXZIkJQP9hBC5p+0PArYJIXyL8fJT77z4IpScFvFZUqLsv/32prGptgghKFh4CAQEjWnXuJPl9R+DxgB976n07ZAJd2P/7TcKfvyJkDvv4PpesXy26hD/+m0/l3SJRN0MJwi+IGnVhN7Zlby5+yj8JRnh9mId0aZxjRj5EnxxsfI3GPFC447dAhBCsPTHffx2NIsXxnRD0viuOrnnHti4UUmQ3b+/v9pbVXy5OpnYIANXXhBVo37GHuHk/3AQ97EidK2bl8qgqdCoVcQEBXAkr4TcYhdh5qpDhYUQlMoyhW4vMhCl16Ku4v7vlWWy7E4sAVpMvqgOVRKa8EZcjGqGyHYXwiOjCTMgtdDfq3JMYUr15aJM0BqVZOoNhFcIslxuLBoVZo1vak21SiLIqCPIqEMWgiKHB1upm2yvCadRJrIkn84B+1ChhDCXOg04tZGUqqx4hB4KUbZzBLv9zGc6WYaUlJbjQMzMrHnEb2L7/aitFWX/ktbL/P37eZ8zC575QtLmDYTHtSUwwsffqTmvg84L/e9TPEb1gCYoAMOF4RRvOo51VJtGixASsqDgpySKNwQ8OqMAACAASURBVB/HPCSGwKsTlOeEJ54gb+MmNGYzlssu8+lYbXv2Zf0Pc0ndtZ0uQ4fXi31mjZoZF7Tlyq0HKJXlZheyfILISKXa99Sp8Nxz0L17U1t0bpKYCPv31z1NQXNl//rV7F29gg79B9OuT38MltrVJ1AFBNDqo49If/IpMqe+g1xSStj99529Q/dbYM1/4H9vQ6fRoFIr6sOf7oOkP6HDJbX8RH58oSZxD/FAZbMmPdCqXqzxUyuOHKnZ/uZM6e5cHPvysF4ahyakETPLFmXBru+h521gDKm0ibFXLww9e5I3ezbC60WjVvHkpZ04kFnEzzubPvdLXZA0KkJu64KxZzi25akULk9pXBVVTE/oOlZxHvorZlXAnVPK/7N33uFVVFsffmdOr+kkQCCFEnrviICgiIoFBQUUpEgR9V779XoVlaveIuK1IyJN/MSKHRUQpfcivYUQAuntJKefs78/BkJJryQh7/OcJ8lkz95rZs6Zs2fttdbvk7lbeGTbCb7Bw9Sd8WTby6dO/dZb0LOnUij78OFqMrSOs/d0NlvjM5nYPxp1OYubG9qHgkrCvvsK1Q6tpQQYNJh1alJynHi8heu8CSHI8/pIcro5mO/kaL6LVI+XdI+X43YX3hIEV9Lz3Pj8gnBryQ/DfqcTX07OVa8+6/f48NncyAZ1zZYCqU4CIhXHYXZCtdY6SnN78AnFoV0RZEnCatAQGWzEnWohIy+cJHUEdrWeVEMg8dbGnDKFk6mx4kKDz0e9exU3nRDiyttWnmPIyyvfS7Y4ij5uY9HbS8Oek82ZwwfLHnXo88GWjyBPhqn/rNCYxWEZ0BTh8pG/LblK+y0O4RNkfnaY/G3JWAY3u+A4BBxmC3ajkeCc7DIHHYS3aIneYiW+ClOXAVqZ9HzYIZpJTUPpHVC5FPHq5IknlGi455670pbUX1asUH7edtuVtaO68DidpJ2M5+f33uC9qffy+ey/s+vn77Fllv85TtZqaTr3dawjRpD2xhukzn2j+OdQlRquexbSDsKfXyjb2o9URNU2vVWJI2qgLJQ6g5QkaeRFf94sSdLFa6EqYAgQX9WGNVB2mjdX0j+K2l6X8Du9ZH97HE1jE+b+FVuRrTBb5ys1lPo8WGKz4IkTSfrLX7CtXo31hhsY3iGC9k2szP31KDd3bIK2HBFhtQ1JJRE0Og5Jq8L2WyLC7btkclbtDH4WDn6rpC8Pe7lmxqzFCJ8f2x9JfPLrUf7td9A91My917XgqS//ZMz8LSyd3KvUaK7z6HTwxRfQvTuMHKlEIprN1XwAdYz56+Kx6NTc3bNZufeVDWr0ccHY96YTcHNs3Y/qqiIkSaJpkIGjKXmcyXEQFWJSorC8PnLOvXxCKX1qUamI0KqwqlXk+3wkON0cdziJNejQXFbfzevzk25zEWDQYNSWEnWYkoIkq1CHXr1RhwXpypKEKrAeicVIMgTFQPphyIqH0NZKBEIV4vUL0txeAjQqjFWgZKzVSrjdarLdoWQTgqTxIes8qAxefCoHPhwYtWqsBjUBeg06TR2sS1kEe/deSFm+GK0W2rateXsqysaN5Wsf/bABTIUdhZLdUKHxj+/YihB+WvbsW7Ydlr4N4U4IuxU0VVuqQBtpQRtjJW/DGcz9miKpqu97T3j9ZPzfIZz7M7AOiyqUHZO5aBGyTkfgviOKtO3IkcX0dAFZVhHdqSsn9+xE+P1VWkd0ULCVQcEVi8KqKYKC4MknlSy1zZuhTzlKaDZQNlasUDJ+mtbwI21N0WHw9bQfNJTU+OMc3bqRo1s2suaj91nz0fs0bhlHy159adWrL0GNy3YCJLWaJv96FVmvJ2PePPwOO+HPPFP0c2jb2yCiE6x9BdrfAWot9JoKq1+E5D8homMVH20D5ynLnfKLcy8BLLjo7y+Aj4HBQNUU0WigQrz8MhiNl24zGpXtdYmcn0/iz3MTNLJVtU5CCuFxwLYPIW44hLYssall6BA0kZFkLlwEgCxLPDEsjlOZdj7bnlgDxlYvkiwReEdLzP2bkLfhDNlfH0OUEP1TpYS1hs5jFEduTt2O5Kws7kQbqW/tZuHPR/iX38E1MSEsfeQabu8WyYcTehCfnsfd8zaRnFP2aJvmzeHTT+HQIZg0qaEsyMUkZTv48c+z3NOrGRZ9xaKLjF3C8NvcuOLrUa5hFaBTqwiz6MhxeDiWY2d/noN4h5tsrw+LWkWUQUt7s4EYo45grRq1LBGgURNj0OHyC47bXbgvU6dNy3PhF4Jwa8nR6X67HZ/Nhio0BEldT6LtKoDf7kW4fKgCtEjljKqt9ai1ioCK1wnZp6r8xpbq9uAXEKGtmqjVpk0VYTsFCeFRI+wGmpottA63EGHVI4QgOcfJ4RQbR1JsJOc6cbh9dbqm6qXHrSDL9feh+jyj4uIQnksdwMKjYlRcXIX6O7ZtE9awcMKiYkpv7PHAd68qT29jq+eBwDIgEl+2C8e+6ssYER4f6UsO4NyfQcAtsYUch54zZ8hduZLAMfegioqCOXPK3HdM1x44cnNIOXGsqs2uEzzyiKL+/eyzV9qS+kdSkqK0XN9VliVJIjy2JdfcM56Jc9/n/jnvcc094/H7/az7ZBEf/XUai5+YyYbPlpF68kSp32OSSkXESy8SNP4+spYsJfn5WYiiFB9lGYY8rwin7VqqbOsxUclG2PRu1R9oAwWUOosUQshCCBk4BTQ6//e5l04IESeE+L76TW2gOMaNgw8+UBS0JEn5+cEHdaveoetULvmbz2Lu26Tma4bt+T9wZELfh0ptKqlUBI8fj2PXLhy7dwMwqHUYPaKCeGvNUZyeui9pK0kSAbfEYhncjPytyWR9dhjhq6GHloFPg/DDH/+tmfFqGX6Xj+zvjpP67m4WZ+UwFyfXtwvnw8k9MZxTRr22dRhLJvUmJdfF6HmbSMy0l9LrBYYMUWrcfP45zJ1bXUdR91i0QQmev79/GR7IikHfJhhJq8LRoLoMKBFbGW4vJ+wuUvCDLGHP9xCgUhFj1NHebCDKoCNQoy6ytqFFrSLWoMMjFAei65wD0eP1k5HnJtCoRV9KVJYnJQVJpUYdElJsm0OHDjF9+nTi4uIwGo0YDAaaN29Ov379ePzxx/n1118L7SNJUp0RrxA+P74cF5JWhWys/rTtDRs2MHXqVNq2bUtAQABarZaIiAiGDh3KnDlzSE2thtR+nQUsTcCZrSguVhFuv590j5cgjQp9FTldQ0KUOdp53R6tVvk7JAT0GhWNrHpahVtoE2GhSYABlSyRmuvkaKqNwyk2zmY7yHd565wjsaTjrs/896GmjI7pCPkGxa+db2B0TEf++1D5vaZup4OEP3fTsmefst1/FsyHqHwI7AJB1ZOKpG8TjDrUgG3d6Wp5T/pdXtIX7sd1NIugka2wXFP4vGUu/RiA4PHjlUJ+GzcqoXRlILpzN5CkKk9driuYzYrjcM0aWL36SltTv/jmG+Xn1VZnPCSyGb3vGM29r87lgbc/YvCEB9BbLGz5ajlLn36EBY9MYe2SD0k6dADhL1zOBs45JJ95hpDp08j+/HPO/O0ZhNdbuGHLodCsD/z+HyUQyBAEXe+FPz+H3JoRU7sakeraBKSy9OjRQ2zfvv1Km9HARQifn9S3duO3ewh/rHvN1mPy++GdnsrDxwO/Kd7X0nbJz+fooMGY+vcn8g3FA7PlRAZ3f7CZZ29qywPX1h/toNzfTpH7cwL69iGEjGlTLqGOCvPjk7D9I5i5FUJaVP94tQTH4Uyyvz6GN9vJkqZa5idlMKJzE14f3RlNEQ+uuxOzGb9gCyadmmVTehMbVrY8ZCHgzjvh228VFeZBg6r4QOoYNqeHfq+uYXCbRrw5pmul+spcfhjHoUyaPNu7Zj4rpXDw4EHa1mBOoNvvL0hHzvf5QYBGlghQq9AJOJNhJ9Sso0lg2VP28n0+4u0uZEki1qAjI9dJpt1DXLgZbQniFb68PNwnT6KJiCg2ZXn58uWMHz8et9tN06ZN6dSpE0FBQaSlpbFz504yMjLo3r07l88Zzj+418b5U3R0NAkJCcTHxxMdHY0304nf4UHdyIhcjSmweXl5TJw4kS++UOoPxcTE0LFjR0wmE8nJyWzZsgW73Y7ZbGbVqlX07t27ag0QQkldduZASEvlO72SnHa6yfR4iTPpiYuNveS81iQenx+b00OOw0veOcehWiUToFdjNSiCQXIdcWbXZWr6fno5Rzav57u5/2L0rFdp1q6UlDyHA66LhmFOGL0U2t1abXblbT5D9orjhE3rhC4moMr69Tu8pC/ch/u0jeBRcRi7NirUxpeXx7FBgzFfey1NX5+jFJqMjIQbboDPPivTOMv+/iiSLDP2n2WPWKxPuFzQqhU0bqz4XBtuJVXDDTco2gOHDl1pS2oH9twcjm/fwtGtGzn15258Xi+mwCBa9OhNq179aNa+Iyp14QXO9PfnkfbGG1iuH0qTOXOQtZeVXzi5ARbdBNfPhv6PQOYJeLMbXPMoDG2QE68okiTtEEL0KOp/5fLSSJIUBAwHmgOXXD0hxEsVtrCBq5q89Ul4kvMJua9tzRdyP/ozZByDOxeU+RtTNpkIuns0GR8txH36NNrISHrHhnBt6zDeXXusUqmPtQ3r4OZIGhU5358gfckBQu9ri1TdNZgGPAE7l8Laf8Gd86t3rFqAL89N9vcncOxOQxWm56NOFhbuPcPoHpG8OrJTsSreXZoF8unUvty3YAuj521m2ZTexEWU/sAsSbBokVKH5e67YccOZa59tbJ8WyI2l5cpAyoedXgeQ+cw7LtScR7JwtCunofUnMPpu+AwdPiUVWSdLNFIqyZArcIgywXONpfJS0aei0Bj6bUKz2NSqWhh1HPc7uJYnhOR7yHYrC3RcSiEUGodajSogosWwEpOTmbSpEm43W7mzp3Lww8/jOqimnZ+v5/169ezfv36sp6KWoff6cVv9yBbtNXqOHS73QwbNoyNGzfSpk0bPvjgAwYMGHBJG5fLxeLFi5k1axZnz1ZDRIAkQWAUpB1W0phC45SU5gri8vvJ8HgJ0ajRVWEttIqgUckEm3QEm3T4/H5sTi85Dg9Zdg8Z+W5UsoRVr8Fq0GDRqZEbaq7WS45t24zBYqVpXLvSG7/3HkTZQBumlOSpRozdwsn9JQHbuqQqcx768tykL9iHJ9VOyNi2GDoUvQCU/cUX+PPyCJ44UdlgNsO0afDaaxAfDzGlf69Hd+nB5q8+xWHLrbBabF1Gp4MXXoDJk5VF5foq7lGTZGfDb7/B4w1F3QowWgPoeN0NdLzuBlx2O/G7tnF06yYOrlvL3lUr0RlNxHbvRatefYnu3A2NTilLEzp9GrLRQMorr3J65kNEvvUmsv6ikjXR/aHFEKVefvf7ITgW2t6iBKFc+wRoa69oUV2lzDMiSZL6AMeA14DZwCTgWeAJ4K5qsa6Beo8300nuqlPo24UoiqU1zaZ3wBoJ7cr3bRl0770gy2QuWVKw7ckb4siye1iwvn7pB1muaUrQyFa4jmaRvnA/flcRoeNVOmA49J6mhJ2nHKjesa4gQgjyd6SQ8voOHH+mYx7SjLdjdCzce4b7+0XzrxIch+dp18TK8ml9Uclw9web+PN02ertWa3w1VeQnw+jRikrz1cjXp+fhRtO0ismmE6RgZXuT98qENmoxl6PU5eFENh9Ps663BzKd3A430myywMoarRxJj1tzAYa67QYVapL0uvCA/SoVDJJWY5yRe0ZVDItjTqEy4cALKWk3/ptNvwOB+qwsGKL4H///ffY7Xb69u3LX//610schwCyLHPttdfy97//vcx21iaEXxFJkdQyKkvVCiVczksvvcTGjRuJjo5mw4YNhRyHADqdjqlTp7J79+7qi96SVRAco5S+yIpXflaQFJcHCQgvo5O7plDJMoFGLVEhJto1thIdYsKq15Dr9JCQkc+Bs7kkZOSTZXfjLSYlrIG6h8/r5cTObcR274VcmnBPbi7872WI00DP+0FVvYvZslaFqXdjnAcz8KRXTEX6Yny5btI++BNPmoPQ8e2KdRwKr5esJUsx9uiBoWOHC/94+GGlHtr//lem8WK6dAchOLl3V6Vtr6uMHw+tW8M//qEkZDVQOX74Abze+l/vsKLojEba9B/IiEf/xowPl3H7U8/Rsmdf4ndt59s5r/DulHF889rLHFj3G878PILHjyfipRfJX7+exKnT8OXlX9rhkOeU8mObz9U67PuQUsZk9yc1f3BXAeVZTv0vsAxoCjiB61AiELcD/6560xqo7wghyFpxDCSJwFuvQHrqmd1wch30mV7uyZUmIgLrTcPJ+eJLfLm5AHSMDGB4hwg+XBdPZn4RsoJ1GFOvCIJHx+E6mUP6gn34HdXsQOz/FyXt7Lc6pvpTRrwZDtIX7CPr8yOow4yEPNSZlzKzWbY1kRmDWjBrRLsyR4+0bGTm82n9MOvUjJ2/me0nM8u0X7t2sHChkqby2GOVOZq6y0/7kknKdvDAgKopNSCpZAwdQ3EeyMDvrvv1T88jzikkJzndHMx3cjTfRarLi1qSaKLX0Nasp7VJT7hOU2JtOLUs0yRAj8PjIz2vnPdIv0C4fcg6mQSXm3xv0ee3IOpQq0UVWLxD+HztvUaNCqfClYfly5fTt29fzGYzFouFIUOGFButuGXLFp588kl69OhBeHg4Wq2WJk2acNddd7G5mBpdPp+P999/n379+hXUEAwPD6dbt248/vjjpKUpjupFixYhSRIJCQkAxLaIRdvYjLaxGVklc/LkSQA8Hg9Lly5lzJgxxMXFYbFYMBqNtGvXjqeffprMzLLdP86Tm5vLm2++CcDrr79OcDGRnucJDw8n7jKxCCEES5cuZdCgQQQFBaHX62nRogUzZ84kMbGwENnJkyeRJKno9GGNAQKbIzVqg1SE8vLF9SqLu3YOn58sj49QjZplS5Zccl5jYmIK+pAkiZMnTzJ79mwkSWL69OnFHvd3332HJEn06tWrxPNTHmRZwmrQ0CzYSNvGVmJDTQSZtNjdPhIz7Rw8Y+NEWh4ZeS48vgaPQF3m9IF9uOz5ZVNZfuMNaJ4HEtBtfLXbBmDu1wRkibz1lRO782Y5SZ23B1+2k9CJ7dHHFX8/sf3yC54zZwieeP+l/4iMhHvugQULlBCwUoho2Qq9xcrJXVdvSSu1Gl56CfbtU4T1GqgcK1YoaeBVeLuvt2i0Olp0782ND/6VGR98zKjnXqbD4KEkHzvMT2/P4b0HxvHFy89xKshC4IuzsO/YQeLkyQXP3gA06Qptb4WNb0N+BjTrDU17KAFC/vozF68tlMd52Al4WyjhAj5AJ4RIAZ4GXqgG2xqo5zj2puE6koV1WBTqQF3NG7DpbdBaKjy5Crn/fvx2O9mff16w7bHrW5Pv9vL+78eryspag7FrI0LGtsWdlEfa/L348j3VOFgw9HsEDn0Pp+tPIWvhE9h+P03KGztxJ9oIvL0FAZM78PiaI3y1K4nHr2/NU8Piyi3G0DzEyGfT+hJm0XHfgq1sOFY25cNRo5S0inffhYuCaK8KhBB8uO4EMaEmhrSpnAPpYoydGyE8fpwHM6qszyuBXwhyvT4SnW4O5Ds5bneR4fGil2Ui9VramQ20NOoJ02rQliOtM8CgwaLXkJLrxO0tu0MjJdeJSpJoEWREI0kcd7iwFeFA9OXk4He5UDdqVGzUIUDz5oqAwOrVq9m3b1+Z7biY559/nrFjx6LVarn55puJjIxkzZo1DBkyhE2bNhVq/+yzzzJ37lw8Hg+9evXi1ltvJSQkhC+//JJrrrmGzy/6LjnP5MmTmTFjBrt376Z3797cdddddO7cmZycHF5//XWOH1e+a1q2bMmECRMwmZQUnTtuuo377rmXCRMmMGHCBMxmpSZqSkoK48eP5+effyYkJISbbrqJgQMHkpaWxn/+8x969uxJenrZlVN/++03bDYbgYGB3Hpr+euqCSG49957GT9+PBs3bqRnz57cfvvtCCF499136dKlC9u2bStfp4agC7/bi/4clnTtfvpjHbIEjbSaQuf1zjvvLDin58/r1KlT0Wq1LFu2jNyLH2gu4p133gFg5syZ5TuWMiJLEma9hqaBBtpEWGgZZibUosXj85OU7eDg2VyOp+aRZnPhLsbx3kDt5ei2Tah1OqI6dSm5YUaGkrJ7TRBED6ixutEqixZjl0bYd6Tgt1dsbuhJd5D2/l78+R5Cp3RE36L4xR8hBBkLF6GNisI8eHDhBo89ptQ/nF966RtZVhHdqSvxe3YWK+BwNTBqFHTuDM8/rwh1N1AxnE746Scl/fsKV7yoc8gqFc07dGbIpBlMfXcRY/85h+43305OajKrPnyHT776mB1D+rI/OZED90/Am5V1YefBz4I7DzbMVcqY9HtIyUA4/NOVO6B6SpkFUyRJSgP6CyGOSJJ0GPiLEGKlJEltge1CiDqRVN4gmFI78Ns9JL++A1WgjkYPdkGq6Ro9Oafhf52h1zS48ZUKd5Mw4X7cCQm0/PUXJI0SvfjYZ7v5Ye9Z/nhqMOFWfSk91D0chzPJWHoQdbCesCkdUVmrKSXOZYP/dYGIDjD+m+oZowZxJ+WR9eURPGfy0bcLIei2FniMah5ctpM1h1L5x81tmVLJCLg0m4t7P9xCfEY+79/bjevahJe6j9cL11+vRCBu3AhdK6cZUmfYdjKTUe9vYvbtHbivT1SV9Sv8guR/b0XTxEzohPZV1m9FKK3A/7+3/ptDmReqeQvAJwReIfAJ5W8JUEmgliRUkkRV3KmFENjdPlSyVKpiMiiOTIfbh0Yt0ymsHY/1eJITDhcuvyBar8WqUVJLhd+P69gxJFlG26JFiU54m81GmzZtOHPmDGq1mhtuuIGBAwfSrVs3evbsSUBA8bW7zvcbHBzML7/8Qvfu3RU7/X6mT5/O/PnzGTp0aCGl5pUrV9K1a1fCwy/9XH733XfceeedWCwWEhMTMRqNACQkJBAdHU2zZs3Ytm1bof12795NkyZNLomePC+YcnjzPlr1aIt0WSSozWZj7dq13HjjjWg0FyLuHQ4HM2fOZOHChUyfPp333nuv2OO/mOeff57Zs2dz3XXXsboCcp3vvvsuM2fOJDw8nNWrV9O+vfKZ8fl8PProo7z11ltERUVx+PBhdDplkfHkyZPExMQQFRVVEFF5OQWiNkm7ILQ1aI2XbC/p2vUeNJgVK38mQnfh/FwuRHM59913Hx9//DFvvfUWDz300CX/O3bsGK1btyY4OJjTp0+j19fcvEAIgcvrJ8fhIcfhwelRHIcGjQqrQUOAQYNOLZd7wepq5EoJpgi/nw9mTqRxyzhufbyUMgpPPQVfzIXxRhg5HzqNrhkjAU9yPilv7MQ6LArr4PKpO3tS8kn78E/wC0IndUTbtGQBOPuOHSSMu5eIWc8TNGZM0Y2uuw6OHoUTJ0BTcnbRgT/W8NM7rzPulblEtGhVLtvrEz/8ALfcAvPmwdSpV9qausn5c7hyJQwbdqWtqR8IIchITODo1k0c3baJtJMnAAjwQZsRt9Nm8FBCmkUhrZgB+7+GR3aDKQze6grWpjBp5RU+grpHSYIp5fGJ7wR6nvt9LfBPSZImAG8CeytlYQNXHTkrT+LP9xB0R6uadxwCbJmnqDP2KT7NqCwET7wfb3IyuSt/Ltj26NDW+IXgrTVHK2tlrcQQF0zoxPb4sp2kzduDN9tZPQPpLDDgcTixFk78Xj1j1AB+t4/sH0+Q+s4ufDY3wePaEnJfW5x6FZMWbeO3w6m8fEeHSjsOAcIsOj6d2oe4cAtTl+zgh72lCxOo1bB8OYSEKCrM5cxarLPM/+MEgUYNd3WrWrUYSZYwdArDeSSrwhEYNYkAvELg9Pux+/w4/YrjUC2BXpYwqWT0soy6ihyHoDhwtGoZn1/g9Ze+gOn2+pEkqUB1XCPLtDDo0csy8U432R6ljIIvOxvhditRh6U4QywWC6tWraJHjx54vV5+/PFHnn76aa6//nqCg4Pp378/y5cvL7GPF198scD5BEqdxNmzZwOwbt06PJeFb9x4442FHIAAI0aMYNSoUWRmZvLbb78VbD+fWt2tW7ci9+vSpUvhtOtzp1Nl0RZyHJ4/7hEjRlziOAQwGAy8/fbbqNVqvvzyyxKO+lLOp01XNP17zhxF4XT27NkFjkMAlUrFa6+9RvPmzUlISChQcS43slqJPvBdWmqjpGu3a9NGAqXyKWk//PDDAEU6Xd977z2EEEyaNKlGHYegfNb0GhXhVj2twy3ERVhoHGBAliRScp0cSbFxJCWPszkO7OeUnBuoXaScOEZeZgYte/YpueGZM/D22zCyFegDlTS+GkQTYULXKpC8jWcQ5YgqdyflkTZvLyARNrVTqY5DgIyFC1EFBBBQUlG5xx+H06ehiIjuy4nu3A2A+N1Xd3DJTTdBv35KCrOzmqb29Z2vv1bqihcVENtAxZAkidDm0fS9awzj//0mk9/8kL4Dr0d2u9nyw9csfvIhFj46jT8y23A2z4D4/T+gUkPvGXBqU73KYKsNlKcS9LPAeSnPfwBLgLeAI8DEKrargXqM62QO+VuTMV/TtEyThKo3wAY7FisiKYHlWx29HPO116KNjSVz4UKst9yMJEk0CzZyT8/m/N/WU0wd0ILmIcYqMrz2oG8RSOiUjqR/tI+09/cSNqUj6lBD1Q/UY5KSXr5mNsRcW2ZF7NqC82gWWV8fw5fpxNQrgoDhMcgGNblODxMXbmPXqSzmjOrMyCp0YAWZtCx7oDeTFm7j4f/bidPTmTu7l9x/o0bwxRdw7bUwbpyyclqf0y3i0/P59WAKMwe1xKCtehVaY+cw8tYl4diXgalXRJX3X1k8fkUh+a4OfyHP5wcBGlnCqlYRoFZhVlV/JJIQgmOpeXj9gtbhZlTFvOHynF5OpOfROMBAmOVCeQu1g2MR0wAAIABJREFULNHCqOOE3UWCw43f78eYmoZsMCBbSlcdB2jbti3btm1j48aN/PDDD2zZsoWdO3eSlZXFxo0b2bhxIz/99BOLFi0qcv9bbrml0Lbw8HCCgoLIysoiIyODiIhLr396ejrff/89+/btIzs7G69XcWqdT50+cuQIN998MwBt2rTBYrHwww8/8MorrzBu3DiiooqPkhU+P5xzxsqGkqd3u3btYvXq1Zw8eZL8/PwCp5FWqyUtLY2srCyCgoJK7KOynD59mhMnTiDLMvfdd1+h/2u1WsaNG8err77K2rVrGTduXPkHCY6B9KOQfRKCL6RwFnXtjCGhWAODyM3OIjszs9C1K4levXrRq1cvtm7dytq1axk0aBCgRHQuWrQIWZaZMWNG+e2vYnRqFWEWFWEWHR6fn9xzEYnpNjdpNhcalaxEJOrVmHTqhojEWsDRbZuQZJmYbj1Lbvjyy6D2gDUVOk0CTc1nvlgGRJL+0T7su9Mw9Sg988GVkEv6wn3IenWZ55HuhATyVq8hZNpUZEMJ7YcPhzZtYM4cGDOmxPmjMSCQ8NhWxO/eQd87i4lkvAqQJHjlFRg0SBHsfvTRK21R3cLnUxSrb74ZtNWrU3ZVExgeQb8H/0LXfgM5Mn06qUFWslsHsGP1b2zzdcCcuJ+Wif+mdd9ridRZkTa9BaMWXWmz6w1lfjwUQmwXQvx27vc0IcRwIYRVCNFDCPFn9ZnYQH1CeP1kfXUMVaAO6/VVlypYLnYuBVeOosZUSSRZJnjCBJwHDmDfeqEu08PXtUStknhj1ZFKj1Fb0TW3EvZAJ4THR+q8PXhS8kvfqbxo9DDwKTi9DY78XHr7WoIv30PmZ4dJX7APSVZW04NGtkI2qMnKdzNu/hb2JGbz9thuVeo4PI9Vr2HJ5F70bRHC45/v4ePNCaXu06ePIk64ciW8+GKVm1SrWLghHo0sM75f9dyDNE3NqEMN2PekVkv/FcHl95Pq8nA038mBPCdJTg9uvyBMo6alSUdbk55IvRaLWlUjDgNJkmgaZMDj85OcW7TctxCC5FwnGpVMiKnwTFwlScQadZjVMnnpGQivB3V4eLnt79evHy+//DKrVq0iPT2dDRs2cMMNNwCwePHiImsRwoW6iZdjtVoBcF4WujFv3jyioqKYOHEic+bMYcGCBSxevJjFixezd6+SwHFxzTyLxcJHH32EwWDg2WefJTo6msjISEaNGsWiRYsK9e/LvnAeizsHeXl53HbbbXTr1o0nn3ySd955h0WLFhXYYbfbC9lREmFhYcCFKMnykJSkiCs0bty42Ii82NjYS9qWG60JApoqi4a25ILNl187IQTJLg9mq+J4vvzcloVHHnkEUFKxz/Ppp5+SmZnJ8OHDiYmJqcgRVBsalUyIWUdsmJm2jS00CzZi1KrIyndzIl1Rbk7MtJPr8OAvQ4RwA9XDsW2badauIwZzCYsiJ07ABx/AAwPA76kxoZTL0bUKRB1uJG/96VKjWJ3Hs0lf8Ccqk4awaZ3KvACduXgJklpNcGmLCbKseL927oTfS89eienaneSjR3Dk2cpkR31l4ECllM0rr4Dt6j4V5WbTJkhLa1BZrikMXboQ99FHRGXn0XntZib97SWGT55MhDGffevX89m/XmZXWihi/wpO/vENHnfRc80Gyke5Y0skSeohSdLdkiSZzv1tkiSpPBGMDVzF2P44jTfVTuBtLZB1VR/xUyo+L2x5D5r3hcjupbcvAwG33YoqOJjMhQsLtjWy6pnQL5qvdydxJKX+fvtqm5oJm9oJkEibtxd3Ul7VD9JlHATHKtGHtbyYtRAC+65UUl7fjn13GpbrmhH+l27oYpX6aak2J/d8sJnDKTY+GN+dmzo2rjZbjFo1Cyb05Lo2jfjHin18uO5EqftMnw4TJigpK99/X22mXVGy7W4+336a27o0oZGleiIzJEnC0DkM14kcfMU4xqobIQQev+IQOZzv4FCek7MuDwKI0GlobdLTxqSniV6LSVUzDsPLMWrVhJp1ZOS5sLsKK7jbnF7sbi+NLLpi1cdVkkS0TkNITjZ2vYEMTeXEt2RZpl+/fvz4449066aksq1YsaLYtmVl27ZtzJgxA4/Hw3//+18OHTpEXl4efr8fIQTPPPMMQKEH7rvuuotTp06xaNEiJk2ahNls5osvvmDixIm0adOmQI3Y7/Tid3hLndU988wzfPvtt7Rr145vv/2WM2fO4Ha7EUIghKBx48ZF2lEc51N/d+7cic9XMSGOqn7v+S//njCGgiEY8i44Dy+/djavD7vPj6oStowaNYrw8HBWrFjB2bNKyYjzjsQHH3ywwv3WBGqVTJBRS1SIiXaNrUSFmLDqNeQ6PZzMUByJCRn5ZNvd+Gr593B9IvPMaTKTEktPWX7xRaUGSfMcaNpdqRV9BZAkCcuApniS7biOFa907DicSfrC/agC9YRN64w6qGzfxb7sbLK//hrriBGozy1clMh990FYmBJ9WAoxXbojhJ+EPTvLZEt95uWXIT1dEe5uoOx8/bUScXjjjVfakqsHfbt2RC1dgoREytTpxEbGcdvoITzYcgO3ThlPdtQI/ALSP3+G96aM47u5/+Lght9xnVsobaD8lHnmK0lSuCRJm4GtwCfA+Xj014HS78oNXPV40x3krjmFoWMohrYhV8aIQ99B9qkqiTo8j6zXEzRmDHlr1+I6EV+wffq1LTBr1cz55XCVjVUb0YSbaDStE5JWRdr8vbgSyhaxUmZUGkVFK2Uf7P+qavuuQryZTtIX7idz+WHUIQbCH+lKwA3RSBrlNnsm28Hd8zaTmGVn0f09yyRmUln0GhXv39udmzs25p8/HOTN1UdLdApIkpKq0rUr3HsvHDtW7SbWOMu2nMLh8VVJjcmSMHYJAwH2vWVXrq0sfiHYkZPPS8fO0HfLQZLdHlJcHlRINNFraGPW09qkJ1ynwVADqcllIdyqQ6OSOZ3twH/Re/N81KFWLRNURNThxfgzMpD9PpwhoZx1eUh2eSpdu02lUnHdddcBF+r6VYYvv/wSIQSPPPIITzzxBHFxcZhMpoJrcKyED1tgYCATJkxgwYIFHDp0iGPHjjF48GASEhJ4+umnEX6BN9uFpJZLLe1wPopy+fLljBgxgsaNGxfUP8zPzyc5Obmk3QsxePBgzGYz2dnZfPvtt+Xat2nTpgCcOXMGl6toJ/uJEycuaQtKOjMoUZRFkZBwWaS1JEFAM1AXHdkkhOCs24NWlsq/on4RWq2WadOm4fF4mD9/Plu3bmX79u3ExsZyYx16mpRliQCDhmbBRto2thITaiLQqCHf5eNUpp0DZ23Ep+eTme/C62twJFYnx7ZtBqBFjxKch/v3w9Kl8MgoyDp2xaIOz2Ps0gjZosG2ruhoYce+dDKWHEDTyEDYtE7lEt3L+nQ5wuEgeMKEsu1gMMCDDyqroYdLnotHtGyN3mwhfndDfbSePeGOOxTh7oyiBesbuAwhYMUKGDpUqXnYQM2ha9mSqI+XIhkNJEy4H7t5KBqDiVYZ33DdX15C6jCSbuFZdLymL6cP7uPHN//Lew+M5at/vcDe1T9jzyl+oaOBwpRnnjQXSAFCgIvdtZ8DN1SlUQ3UP4QQZK04hqSSCRxRvQ/tJRgBG99Wotjihldp10FjxyBptWQuXnxhm0nLlAGx/Lw/hT2J9fvGpA49Nwk0aUhf8CfO41V8vO1HQqP28NvL4KtdIhTCL7CtSyJl7g7cJ3MJvLUFYdM7o4m4IECfkJHPqPc3kW5zsXRyL/q1DK0x+7Rqmf/d04WR3Zry+q9H+PfKwyU6VgwG+PJLJeNn5EioT4tzLq+PRRtPMqBVKHERZauLV1E0YUY0TUzY91Te8VQSHr/gj0wbfztymq4b93PzzqPMP51GjEFHkEZFO7OeliY9YVoNulpYyFIlyzQJNOD0+EjPu+BAOq8MG2HVI5fgEBNeL770dFRWK00CrQRpVKS4PEqUZQnv87I4F0+dOgVAZGTlSwtknlMiatasWaH/paWlFVJmLokWLVrw7LPPArBnzx58Njd4/aiCdAWOtfO1FMtjxyeffFJup6vVai0QC3n88ccL+i+O1NRUDp97iI+MjCQ2Nha/38/HH39cqK3H42HZsmUABTUEQUmV1mq1ZGRkFOnY/fHHHwsPLMtK/cPz+C9ESWZ7fTh94hJ15csp7byeZ/r06Wg0Gj744APefPNNAGbMmFGuKNXahCxJWPQaIoOMtG1soUWYmRCTFpfXx+ksBwfP5nI8LY90mwt3OUQyGigbx7ZtIjy2FdbQEqLsnn8ezGbopgWNCTrcWXMGFoGkljH3bYLrSBae5EvL2dh3pZLxyUEla+UBZc5YVvxuN5nLPsbUvz/6uNZlN+jBB0Gng7lzS2wmyyqiOnXl5J6diIboWmbPVtKW//OfK21J3WDfPqV6QEPK8pVBGxVF9NKlqIKDODXzUfKD74RD30PSDuT+DyN77QzuoGXa+4u558X/0OXGEWQmJfLrB2/x/rTxLH/hb+z88Rty02tPuaHaSnlmM0OAZ4UQWZdtPw5UTnWigXqPfXcarmPZBNwYjcpaubSyCpO4FZK2Q58HQa7alGl1SAgBt91KzooVeC96eJo8IIZgk5bX6nn0IYA6SEk/UQXqSV+4H+fhKpTtlWUY8hxknoDdn1Rdv5XEfSaP1Hd3k/PDCXQtAgl/rDvmfk0uURA/lprH6HmbyHd7+eSBPnSPCq5xO9Uqmdfu6sy43s15//fjvPDt/hJrWMXEwCefKJOhqVMVv3t94Ls9Z0mzuXigmqMOz2Ps0ghPog1vhqNK+3X4/KxMy+GRgwl03LCP0XuOs/xsJj0CTLzTtjn7+rfn/zq3wKxSoakDTosAgwarXkNqrgu314cQgpRcF3qNigBDyQ+X3vR0hN9foLDcTK8lRKsmze0lqQQH4rvvvsvEiRPZunVr4T69XubPn1+g8Hv33XdX+hjbtGkDwJIlSy6JmLPZbEyaNIns7MILLrt27WL58uU4HIXfP9999x0AzZs1x29zIxs1yDp1QYTewYMHS7Tj4rp8ANu3by9InS4vs2bNonfv3sTHx3PNNdewfv36Qm3cbjcfffQRXbt2vcS2xx57DIDnnnuOQ4cOFWz3+Xw89dRTnDp1iqioKO66666C/2k0GgYMGFAw9sXXeP369Tz//PNFG6q+aO6RkwjnUrWTXR70KolAdfHzgtLO63kaN27MnXfeSVJSEsuWLUOv1zNp0qQS96krSJKESaemSaCBuHALrRqZCbPq8fkFZ3IcHErO5WiqjdRcJ05PxVLYG7hAXlYmZ48eLjlleft2+OoreOwhOPYDdBgJuupdGCsLpt6NkTQytvUXog/ztp4l87PD6KIDCJ3csVRRp8vJ/eFHfGnpBE8sp0Zno0ZK+vLixUpBuhKI6dIde042qSdLL/NS32nfXslAeestOFeFoYES+PprJcj91poVOW/gIjRNmxK1dCmaJo1JfHcteZmhsOaf0KQrRF0Dm99HFn6atmnHoPsmM/nND7nv32/Se+TdOPNs/LZ4PvNnTuLjZ/7Klq8/I+N04pU+pFpJeZ4qDIC7iO1hQIOgewPF4sv3kPP9cbTNLJh6V1+Nt1LZ9BboA6HL2GrpPvj++xEuF1mfflqwzaxT8+CgFqw7ms6m4/U/9l9l1RI2rROaRgbSlxzAsa8KUzZb3wiRPeH3f4Pnyt5yhMdHzsp4Ut/ehS/bRfDYNoRMaIc68FLH+IEzudw9bxM+Pyyf2peOkQFXyGIlFe2ft3fggQExLN6UwNNf7sVXggPxxhuVMkrLlsHbb9egodWEEIIP150gLtzCgFY1E/lp6KREi1RF9GGu18dXKVlM3hdPu/X7uH9fPD+n53J9qJWFHaLZf00HFnSI4c6IYAI0da8McZNAA0LAoUQnuw64cXl9mCR9ianVfo8Hb0YmqoBA5HOCG5Ik0VSnIUyrJsPtJdHpLtKB6PF4WLRoEb1796Zx48YMHz6ccePGMXz4cKKiopg6dSp+v5+nnnqKYcOGVfr4Jk6cSLNmzdi5cyexsbGMHDmSO+64g+joaLZv316kgykhIYF77rmH0NBQBgwYwNixY7nrrrto0aIF//vf/7BYLMx67FmQJVQBSmTcHXfcAcC4ceO46667mDJlClOmTCHjXO7Zecfa3//+d7p06cKYMWMYOHAgvXv3ZtiwYSWqOReHTqfj119/5fbbb+fgwYMMGDCAFi1acPvttzN27FiGDBlCSEgIkydPJi8vjyZNmhTs++CDDzJmzBjOnj1L586dGTZsGGPGjKF169a88cYbBAUF8fnnn6PTXXpvfemll9Bqtbz33nu0b9+eUaNG0atXLwYOHFi2+oKOLMhPJ9Pjw+0XRGg1Jb7XSjuvF3NeOAXgnnvuITi45heMqhtJkjBo1URY9bQOtxAXbiEiQI+ERHKukyMpNg4n20jOcWB3eytdRuBq5Pj2LQAlOw//8Q8ICYGhzcFjh25lTOetZlQmDcbu4dh3peKzubGtTyL7q2PoWwcROrF9uWueCyHIXLgQXatWmPr3K79Bjz0GTie8/36JzaI7K3Vu43dtL/8Y9ZAXXgCPR6mB2EDRLFsG0dEwa5ZS73DVqitt0dWNplEjopYuRdsilsTVenJ/3wjx66DfQ5B7Gg58U9BWkiQaRcfSf/Q4Jrz2DpPemMeAsfcjyyrWf7qERY/PYOGj01n/6RKSj5dc9umq4nyR7NJewPfAK+d+twExgAr4EvisrP1c6Vf37t1FAzVLxmeHReIz64TrTN4VNOK4ELMChFj1YrUOkzB1qjjcr7/wOZ0F2xxur+j98iox8t0Nwu/3V+v4tQWf3SNS3tklEp/5Q+TvSqm6jo+vFWKWVYhN71Zdn+XEcTRLnP3PVpH49B8i4/PDwpfvLrLdzoRM0XHWStHnlVXieKqt0uP6nE7h93or3Y/f7xev/3JYRD39vXjok53C7fUVP6ZPiBEjhFCrhVi3rtJDX1H+OJIqop7+XizfdqpGx015b7c4O2d7hT77qS63WJqULu7ZfUxE/rZbhK/ZJTqu/1M8deiUWJuRK9y+kvs8cOBARc2ucdLThdh1wCn2JGaJPaeyxe4TNrFjh1+kpxe/jzspSdj37bvkfnsev98vzjpdYndOvjhpdwrfZec/NzdXfP3112LmzJmiZ8+eomnTpkKj0Qij0Shat24tJkyYINYV86YHhDJ9KpqoqCgBiPj4+Eu2p6SkiKlTp4qYmBih1WpFZGSkmDJlijhz5oyYNWuWAMSsWbMK2p89e1a8+uqr4sYbbxTR0dHCYDCIgIAA0aFDB/H444+L4/uPCFdirvBedA/y+Xxi9uzZok2bNkKn0xXYerEtv/32mxg8eLAIDg4WJpNJdOnSRbz55pvC5/MVa3tZ+eOPP8TkyZNF69athcViERqNRoSHh4uhQ4eKuXPnivQiLqjf7xdLliwRAwYMEAEBAUKr1Yro6GgxY8YMcepU8Z/XdevWiSFDhgiz2SyMRqPo2bOn+Pjjj4UQxV+jgu3px4Q/aZeIz0oXh/McBZ/P4o6/LOf1PF6vV1itVgGIbdu2lePs1Q/cHp9IsznF8VSb2JuYLfYkZomDZ3JEUpZd2JyeOjsPqun76RcvPycW/OWB4s/X2rVCgBCvvSbEvEFCvN1biFp0bt1pdpH4tz9E/OvbROLTf4j0JfuF31P8fKMk8jZsEAfi2oisL76suEE33SREo0ZCOBwlNlv6t7+IT/7xRMXHqWdMny6ERiPEiRNla2/Pzaleg2oRH38shNGofAzPv4xGZXsDVxZvTo6IHz1aHGjTRmQ/1k8In1eIN7sL8f61ZbpP5makiZ0rvxOfvfR3MeeeEeK10TeLeQ/eL9YsnCdO7d8rfL7KP4/VZoDtohhfmiTK6EWVJKkd8DuwGxh4zpnYHggA+gshjlfSj1kj9OjRQ2zf3rCiVFM4j2eTPv9PLAMjCRgeU/oO1cWPT8H2j+Cvf4K1+qIf8zdt4tTESTT+52wCL0qzWrYlgWe/3sdH9/eoEaGM2oDf5SNj8X5c8TkE3dEKU6+Iqul48a0Q/weoq0cptzgEgM+P8J/TJFBJxUaq+ITA7fUjSUrNQZnKC1NkHtKR/qceyy2jsAy7AWOfPsjashcav5z3fz/Ov346xPXtwnl7bFd0xaTsZWdDjx6Qnw87d0LjKxg8XBkmfLSVA2dzWf/04GKPtTrI23yG7BXHafSXbmgbm0ptn+h081NaNj+m5bAlJx8BROm13BQWwM1hgXSzGkusAXgxBw8epG3btpU8gpph715wuwWakDwkjQ9Ppgnh1qDVQqdOhdv73W5cR4+iCgxC27RJ4QbnSD1X/9CqVhFl0Jb53NV2hM+PJ9mOpJVRhxpqhfhNncLvxZt6GCF8uEJaY9ZW3ffJN998w+23306vXr3YsmVLlfVbF/H6/OQ6veQ6PNhcSgSiWpaxGtRY9RrMenWd+UxW5H7qSUrCtmoVub/+ii8zi7BH/4r1+utL3c9lz+fdKePodtOtDLy3iLR3IWDAAIiPh43fwMIhcOO/oM+MctlXXZzOsvPz/hS+X3Oc43Y3v3aOpdHoOCRVxa71qQem4jx0kJarV1d83rN6taJm8eGHMHlysc02LF/Klq8/Z8aHyzCYr3wK+JUmKQlatoS774ZFi4pvJ4Rgw/Kl7F+7inGvvoE5qP5FXF9OZKRyfi4nKgpOnqxxcxq4DH9+Pon33oH94CkiZt5DUN/m8P2jcP+PEN2/zP04bLkc37GVY9s2cXLPTnweDwZrABNffw+DpX6q40iStEMI0aOo/5U5t0kIcUCSpI7Ag4AL0KOIpbwjhGiohtBAIYTXT/aKY6iC9ViGXMGymI4s2PUxdBxVrY5DAGOfPujatCFj0SIC7ryz4IFudI9mzPv9BK/9fIRBrRshy3VjslwZZJ2K0Intyfj4IFlfHcXv9mG5pmnpO5bGLXNh5xIQNVPQWgDeNAeuY9kIrw9tpBVtlOWSuoYXk5jl4Of9yVh0am7u1AR9OdNzikMXlIrJH0/uypVkf/klssmEedAgLNcPxTxgALKpdMfUxUwf2AKjVsXz3+xnyuLtfHBfDwzawrYGBiollfr0USaPq1eDpuw1zmsFR1Js/H4kjSduaF2jjkMAQ4dQsr89jmNPKtrGhRdQhBAcsbsKHIZ785T6dm1Neh6NDueWsEDamkpO360PuN0AEp4sE7LWi3BrLtpeGG+qUtRa3agEIQGgkU6DLEGS00O8w0W0QYeqHpxLX7YiLqMOrP/vjerAJ6k4aWhCbH4C5txTENISpMrXB/V6vcyePRu4UM/xakatkgk2aQk2afH5BTanh1yHlxy7h8x8N6pzgixWgxqLXoOqjs+NhBC4jx/HtmoVtl9+xXngAAC61q2RVCqSHn6E3OuHEv6P59CENyq2n/hd2/H7vLTs2bfoBj/9BBs2wHvvwf7PQKWFTpWvzVoZjqXaWLkvmZX7k9mXlAtAXJiZe5sHY7gttsKOQ9fRo+SvW0fYX/9SqQVTrrsOOneG11+HSZOKVaaP7tKDzV8tJ2HvLtr0u7bi49UTmjaFhx5STttTT0G7doXbCCFYu3g+O3/6lk5DbsQUEFjzhtYAQsDBg8qc+Ouvi3YcApzTWmvgCiObTDT7+EtO39GH5HeWI8yPEWwIhk1vl8t5aLBY6TBoKB0GDcXtdHBy9w7OHD1cbx2HpVGuwkhCiGSgmErUDTRwKba1iXjTHIRO6oBchFOixti+EDz50HdmtQ8lSRIhE+/nzNN/I3/9esznirprVDKPXd+avy7fzY/7znJLp+IjZeoTkkZFyH3tyPy/Q+R8fwLh8WEdXElHckgLuP7FqjGwFLzZTrJXHMd5KBNNpJmgka3QNjEX2/6X/ck89PsuWjQys3RyL8zmqhMHMt0ApplKxJV90yZyf/2VvNVryP3hByStFtM112AZOhTz4EGog4LK1Of4vtHoNSr+9uVeJny0lQX398CiL+wZ7NRJWawfNw6efBLeeKPKDqtG+HDdCfQamXG9y1/PrbKozFr0rYKw70nDOiwaSZIQQrDb5lAchuk5HLMrjqAeViPPtWjCTaEBxBivkLDUFUKrPeco9Mv4nRceEItyVPudTnzZ2ahDQpHL4MkO1WqQkDjtdBNvdxFjrNsORL/Di9/hRWXVImlqvyBObSTd7SVf0uGxNkOXewpyz0BAxVW1Fy5cyB9//MHWrVs5cOAAvXv3ZvTo0VVocd1HJUsEGrUEGrX4hSDP6SX3nDMx2+FGkiQsOjVWgwarXo1aVTfe20IInPv2YfvlV2yrVuGOjwfA0KULjZ58AsvQoWijohAeDxmLFpH+9jvk33wzjZ54gsDRo5CKELU6um0zxoBAmrSKKzyg36/UOoyNhfvGwFsdoe2tYKzZSC8hBHtP5/DzfsVheCJNUVbu2jyQZ4a3YVj7CKJDy7eoWRQZixYh6fUEVla4SpLg8cdh/Hj4+WelsHMRNG7VGr3JzMndOxqch+d4+mmYN08R9j6nI1aA3+9j1fx3+HPNL3S76TYGjZ9Srxa0hLigS/TVV3DkiLK9b19lcb0IrTOaN8jI1hpkk4XIV5/lzNN/J+Xfr6Of3BXj4Z8g/RiEtix3f1q9gdZ9rqF1n2uqwdq6QZmdh5IkxQK3A7EowTjHgRVCiJPVY1oDdRlPqp3c3xIxdA5D37psjoxqweuGrR9A7GCI6FAjQ1qHDyd1zutkLlxY4DwEGNG5Ce+tPc7rvxzhxvYRdWZiXFkktUzw2LZkfX6Y3J8TEG4/1huiavXkQvgF+ZvOkPNzAghBwC2xhVSUL+fbPWd4dPluOjYNYPHEXgQYqyc8T9ZqMQ8ciHngQMQLXuw7dypRDr+uIm/NGlCpMPbqiWXoUCxDh6IJLzlNfnSPZhg0Kh5dvpt7F2yJzXjPAAAgAElEQVRl8cSeBBoLr+6PHQtbtsD//ge9e8OYMdVyeFVOms3Fil1nGN0zkiBTJaIWKoGhcxh5nx/h98OprFJ5+CkthySXB5UE/QPNTI4MY3hoABG6OhbSWYU0bQoJCcpz8cV4vWCzgeWi7DFvaiqSLKMOK7vwTYhWjSzBKaeb43YXsQYd6joY5ST8Am+2C0kjI1uuzPu5ruP1C1LdSiq7zhgCPgfkp4HGWGEHzO+//87ixYsJCgpi9OjRvPHGG7X6O+5KI0uS4iQ0aBCBgny3j1yHhxyHh1ynBwkJk06F1aAhQK9Bo65d8yXh9WLfsRPbr79iW70a79mzoFJh6t2LoPvuxTJkaKHIQkmjIfSBB7DecANnZ71A8gsvkPP9dzR+6SV0sbEF7bweD/G7ttO2/8AiHYt8+SXs2gVLl8Lx/2fvvMOjKLc4/M723fQeAiEJLZRQQ0d6R0CwgNIEBFQQ1GtHvYIgKNdeUGmCgkoREKWDFCH0TqghpADpbTfJZuvcP4YWCJCeAPs+Tx7IzOzM2c3u7Pf9vnPObyPkZUGzEWX9lKXYbHYOxGSwMTKRTZGJXMnKQy4TaFPDi1Ftg+le3x9/t9JrAWBNTUW/5i/cnnyi0Iuid2XwYHj7bfjsszuKhzKZnKBGTbl49BCi3V7w3+Ahw9tb0l2nTIFDhyA8XNput9lY/93nnNm9g9aPD6btoGEPxH3PaoVdu25kGF66BHI5dO4ML78MAwZAQIBkljJuHOTm3nisTucwmKlsyJoOpuqAr7myKZtLi09Se6AM9s5G6Pt5RYd2X1KonoeCILwGzEQySEkGBCSXZRvwliiKX5RlkKWJo+dh2SOKIilzTmBJyMH/tXDkFTnBOfY7rHoehv4BtbuV22VT58wl5fPPCVm9Ck3dute3b4pMZNwvh5j1RCMGtQgst3gqA6JdJHN1FDn7E3FuF4Bb3xqVcpBhScwh44/zmOMNqOt44DGgFgrPuw+Glx2I562Vx2kR7MmCkS1wVpe/262U/RB5VUjcjDk6GgBt48a4dO+GS/fuqO7ipLr5VBITlhy+njXpXUDWpMUiDZ6OHIG9e6FhwzJ7OqXG55vO8s22KP55rRMhpZAFURRMdjs70w2sTcpgw6UMMlUCGplAJ08X+vi4093LFY8ydEa+n3oeAqSlSWVAZrOUiejvD8nJ0u+1aoGrK9iNRkwXLqDw8bmnMF4QWRYrsXlm1DKBGlo1yvtsYmjNNGHPNqPw0SKrgPvMg0BCnplks5U6Thq0cpnUAiM1CqxG8K4DSm1Fh/jQIooiRss1IdGKyWoDQKdS4KpV4KZRolZWTCXLqVOnCExOxrB5M9n/bMOWkYGgVktZ/9274dKpE3L3wpVriqJI1spVJM2ahZibi9eLL+A9ZgyCSsXFIwdZ+fEUHn97CiFNb2k5ZbVCWBgoFHDsGPzcX3IQnXgEyuheZrLa2B2VyoaTiWw5nUx6jhm1QkaHOj70bOBPt3q+BS44lgYpX39N6vc/UGPdWtQhpdQ3/eOP4Z134OhRqYy5ACJ3bGXD7C8YNvNL/GoUPTvpQUSvl5JdW7SQquatFgtrv5pF1IE9PPLMs7Qa8FRFh1gi8vIkp+RVq+DPP6XxiEYDPXvC449D377gWcDa0pIl8O67Uqly9eqScDh0aPnH7+AenFmL+OsQElP6oM3ZjlsNM7xxDsHJq6Ijq5TcrefhPcVDQRAeQTJK+Rj4TBTF9KvbvYDXgTeAjqIo7i7VqMsIh3hY9uQcTCRjxXncH6+Fc8sKdFcQRfihPditMH7PHfublAW2rCzOd+qMa8+eBHw886aQRAbMjiBFn8e2NzqVe/+1ikYURbL+jiZ79xWcWvrjPqDWXbP5yhPRYkf/TxyGHZeQaeW496uJtrHPPQXORRExfLAmkva1ve/YN7AiMF24gGGzJCTmRUYCUt8ll27dcOnRHXVo6G3Pbee5FMb9cpCq7lqWjGldYAZBQgI0awbOznDggFS2UVkxmm20/XgrzYM9mTuiwO/AUifbamNrup51KVlsTdOTbbPjIpfRwQCd4vJ4/LlmOKnKR/S538TDgrBYpDKhvDyoWRO0mTGIRuP1HmLFwWC1cdFoQiUI1NCpUd0nAqLdbMOanIvMSYnCo3wNox4ULHY7p3PycFPICdLetEBis0DKGRDk4FMHZA5htjKQd01IzLNgNEtCokZ5LSNRgUYpL9NFSNFmw56djU2v58z58yjHT0Dm7Hy133B3nNs/gkynK/b5rampJM2YiX7dOtS1a+H/4YfsPrCbMxE7eHHuryhubcvw009Sv75Vq+CRMPg2HLr+F9q/VsJnmp9sk5XtZ5PZcDKR7WdTyDZZcVEr6FLPl54N/OlYxwenMl68sBuNRHXugrZZMwJnf1d6J87IgMBAePLJOzqA5GRm8MPzw2k3eDitH6/YXpKViU8/lVrXbNtqIm3fDGKOHqLzyHE0692/okMrFgYDrFsnfZzWroXsbGmRsm9fSTDs1QuK2E7cQWVFFGFeV0R9Imm53fG2LcRgb4PzB2uLPZZ8kCmpeLgEMIuiOOoO+xcCSlEU7wud3SEeli22bDNJnx9C4aPD5/lGFSsMRW+Hnx+D/t9Cs+HlfvnEadPJWLaMWlu25Ctf2XU+lWHz9/FBv/qMaleBDtQVhCiK6DfFYtgWj66JDx5PFd+Br7QwRWeRsfI81lQjuma+uD1aA7nTvUtIv99+gU823NuxuKKxXL6MYetWDJs2k3v4MNjtKKtVw6V7d1y6d0fbpPH10pz9F9MZvfAAnk4qloxpRaDn7ROjXbukDMTevWH16jJLeCgxi/fG8t7qkywd15pWNcpudTHNbGVTWhbrUrLYmWHAZBfxUiro7e1GHx832nk4Yz+VTtri03g/F4amdvm0cngQxEOQkm3OnweMOQSrLqL080Phc3ejlHuRfVVAVFwVENWV9U18FVEUsSYbEW12lH46hIek7UVpcznPTKrFSl2dBvWtr6EpG9KiQO0CnjXKdcHRwb0xW22S2UqehVyTFRFQKWS4aaTyZ52qdIRE0WrFZjBg1+uxZWeDKCIoFERlZBBsteLUqhVCSYw7CsCwfTuJUz/EkpjItmahVG/anH6vv5v/IJMJ6tQBPz+ph8iWKRDxDbwaWSpmgOk5ZracTmLjyUT+jUrFbLXj5aSiRwM/ejbwp01Nr3Id42T8vpTEKVMI+uVndC1alO7JJ02CH36QLHEDCu5B/svbL6NQqXnmw1mle+37GKMR6oXm8nSzafhoTtJj3EQadulR0WEVidRUWLNGKkneskX6WPn6wmOPSYJhly5S5YODB5AL2+CXAYg9P8a8dR5yQzRJ9lEEzJyFoHAsGN5MScXDC8BoURR33GF/J2C+KIo1SxpoeeAQD8uW9KVnyT2egt+kpij9Kni5ZslTcOUIvHISlOWfpWGOi+NCz154jR2L739evb5dFEWGzN3H+WQDO9/sjK6cspAqG/ptceg3xqJt4IXnM3URKqCnkd1oJWv9RXL2JyL31OAxsFahhB1RFPli8zm+/ieKfo0D+HxQY5T3yWTempaG4Z9/MGzZQk7EHrBYkPt449K1Ky7duuPUqiXHEnMYMX8fTmoFS8a0oobP7SYxX38t9X6ZPl0q2ahs2O0i3T7fgbNGwZ8T2pV6dsqVPDPrUyXBcE9mNnagmkZJH293+vi40cLNKZ8ph2ixc2X6XrRh3ng+VadUY7kTD4p4CGC1imSfvYjcbsbkXwdvn5J/3nJsNi7mmpAJUgmzphJ/hm0GM7YsE3JPDfIy6qf6oGO22zmTk4eHQkGg9g6zw+xk0F8Glyrg4l++ATooNFabHX2eVNqcbbIiiiIKuQw3jWS44qRWICvCPd9usUhioV6PPUcy/hCUSuSurshcXZHpdJw5c6ZM76e27BxOzZjGpgsnCc/MI/ytd3Hp0vnGAd98I4lemzZBl07weX2o1hye+a3Y10zIMrIpMokNJxPZdzENuwhV3bX0bOBPrzB/woM8KsQBW7Tbie7zKDJnZ4KXLyv97NILF6B2ban/4YwZBR6y6/df2L96OePn/YrG+c5GeQ8TeTnZfP/KB1gyz1O90394ekKnig6pUMTHSwvdK1fCzp1Sb+WgIBg4UBIM27aVeho6eMARRVjUT6oy6P81/PYMV/a5Y6/Vn4DPPiuZm/sDxt3Ew8KoFv5A9F32XwAqsDbVQWUh73wGuUeScekSWPHCYcpZOL8JOr9bIcIhgKp6dVy6dSNj6VK8X3j+emmLIAi83jOUJ76P4KfdMUzo/HD2U3HtXB1BKSfr72jSfjmF17B6COXUy0gURYwn08hcE4U9x4Jzh2q4dqteKFdwURT5aO1p5u26yKDm1Zj5eKMKGVwXF4WXFx5PPYXHU09hMxjI3rETw5YtZK35i8zflyJzdcW3cyd+b9aO505ZGfTjXhaPaUldf9d855k4UUp+eP99aN5c6gtTmfjnTDLRqTl8/UzTUpt4XMjNY12KJBgeMUgdsuvoNEwK8qOPjxsNnbV3vJaglKEN88Z4MhVxQC2HS24REYzZqMVcMhRVuBIrwy5K2QIlwUkup6ZOw4VcExeMkomKthIKiKLVjk1vRtAokGkfzsWm0iDJZAHA727llk4+YMkFQ4JkoKJxvfOxDioMhVyGp5MaTyc1NrsdQ56VLKOFjFwLaTlm5DIB16sZiS5qBbICvqPtJpMkFur12I1GAAS1GoWPD3JXVwSNplz7MsudnUivXwfZxdNUUWm5NH48Lr164f/uZBTXXBg6dYJu3eDM35CTDM2eLfJ1olOy2RCZyMbIJI7FS1axtX2dGd+pFr3C/GkQ4Frh/aizt+/AHBNDwGeflk0sNWtKytEPP0irnwXUpoY0CWffqqXEnjhCaJv2BZzk4SJXn8WKj96H3Dg2Rb9D+oU2DHqx8laenD0rlSOvXCm12AGoXx8mT5b+9E2bOpLLHzoEQWrzML87JJ0CvzB8H0nj/C+buTThJap98zUyjaMlzL0ozChUC5just8M3N5Z38FDhWixkbk6CoWXBtfOlcAIZM+3oNBA8+cqNAzPUaMwbN5M5qpVeN7UQTc8yINu9Xz5cccFhrUKKjNn3sqOyyNVkankZKw6T+pPkXg9W7/MTQBsWSYy/rxA3qk0lAFOeI8MQ1W1cKvKdrvI+3+eZMm+OEa2Dea/fesXOCm5X5C7uODW91Hc+j6KPS+PnIg9V5vB/4Pw5xoWqNUc9KvLtxf2Me6tETSqe+OzLQgwZw6cOCE5MR86BMHBFfdcbmXuv9EEuGnoHVb87CFRFDmZbZQEw9QszubkAdDERcfkGlXo7e1GbafCDzR0jX3IPZRE3tl0tGGFdwp+2BFFEWtSEoJShX8tD3IvSs3J7XbJVKUkaOUyaunUXDCauJCbRw2dGl0lS0GwZkpDMIW7usIn9fcreTY76RYb3irF3XtcCgK4BYLFCBkx4BMKCscQtzIjl8lw16lw16mw20WyTdbrrs0ZuWZkgoCLRoGrRomzINm32/V67CbpcyXTalH4+UlZhuqK+1uLokjUgT1Ub9iYOq+/R9qCBaTO/p4LERH4hjXAPSkJYeVK6T16+GcpO7bWvY0ARVEk8oqejZGJbIxM5FxSNgCNq7nxRs9Qejbwp5Zv5cqsS1+4EEWVKrj2KMOS2Ndek5SlhQthwoTbdlepHYrayYmLRw499OJhdkY6K6a/R1ZSIgPfeB+fk+EMHy69fE8+WdHRSYiiZOZ3TTA8dUra3qIFzJwpCYahoRUbo4NKQGBLqNMbIr6GLu+jWPc61d56hUuzlhM/7nmqzZ6N3NnR6PJuFHaW/qggCFl32FeJ2+U7KC/0/8RjTcvDe0xYuWWP3ZHsZDi2FJoMgQp2UdI2bYKmcSPSF/2Mx9NP52vK+lqPUHp/9S9z/r3AGz3r3uUsDzZOLf0RlDLSl58ldf5JvEeFlUl2jWgXydmfQNb6GLCLuPUJwbld1UL3W7Ta7Ly54jgrj1zmhY41eavX7YYj9zMyjQaXLp1x6dIZ0Wol9+BBDJs202LTZprvOYZ14K+caNqcav374NK1CwofH5ycpEFa8+ZS6cfu3aCtBEalJy5lse9iOu/2qVfkcnKbKHIwK+e6YBifZ0YGtHZ3ZnrtqvT2dqOqpnilDeqa7sicleQeS3GIh0XArtdjz8tDWbUqMrmMGjWkVlWXLoHNJrWsKslHUXNNQMw1cSFXykB0qiT9S+1GC2KeFbmbukJaOzwoJJotyATwVRVioU4mB88QSDkH6RclB+bKml7jIB8ymYCrVso4FEWRHJOVTIMRvdFMltGCAGitIi4qJ9w8PFG5ulSaUrW0S3FkJibQvO/jCCoV3i+8gEvPniROfpfEiD3omzSlSkAAqqxLELVFMkmRFzxWstlFDsdlsOGkJBheyjAiE6BliCdT+tWnRwN/AtwrwZd1ARgjI8ndvx/fN99EuNUwpjRp0wZatYIvvoAXXritblUmlxPUqBkxxw4h2u3X+0I/bOhTklk+7V1ysjJ5fPJUAus3JLChJMi9/z4MGCCZf1cENhtEREjj0FWrIDZWulV36CD9SQcMkLxxHDjIR5f34Id2kHUJnP1xURwnYNYnXHn7HeKfe47AuXOQuzqqDu5EYT/u8++x/+6NEx080FiScjDsuISuqS+aWuVjBHBXDswHmwna3L6SWN4IgoDXqFFcfuVVDP/8g2v37tf31aviSv/GASzYFcPItiH4uDy82Q26pr4IShlpv50hZe5xvJ9rWCjDksJiScohY2UU5lg96trueAyohcKr8ANns9XOK0uPsO5EIq91r8NLXWo9UMLhrQgKBU6tW+PUujV+771LfMRBVn29hLBzh1FMmULi1KlomzbFpXt3qnfvxuLF1ejXD8aPhwULKr4UZN6uaJzVCga3LNyo0Wy3szsjm3WpWWxIzSLFbEUlCHTwdOHVYD96eLnhXQq9SQW5gLahNzkHkrCbrGWeZfsgIIoiluRkBLUa+VVrb5kMQkKkfxMSpAzEatVK9r5TyyQBMfpqCXOIVo1LBQuIol3EmmlCUMqQOT+c2emlgdFmI8tiw1etQFnYTHGFBjyCID0asuLBvXrF39gcFArRbseek4NNr0dhMOBlteIlCJid3cjROKOX60iy2UnKAye7GVetiKtWUeGGZ1EH9gJQs3mr69vUISFUrxFC5vp1JNeoSXT/xwgcURsn0Q5Nh+V7vNlqZ090GhtOJrL5VCKp2WZUchmP1PZmUpfadK3ni5dz5R9npv+0EJmTE+5PlXFKmyBI2YeDBkkOGgMH3nZISJNwzu35l+TYi/iF3Bet/UuVjITLLJ/2Hua8XJ58dxoBdaREB7lc6nf9+OOweDGMHFl+MZnN8M8/kmD455+QnCwZnPToAf/9L/TrByX0U3PwoOMfBmFPwv450OoF2PU5bi9OR/jyCy7/5zViR46k+vz5KDwqgaZRCbnnzEUUxYdzqcVBoRDtIhkro5Bp5Lg9Wgmcgy1GODBXSkn2rl3R0QDg0q0byqpVSV+4KJ94CPBq9zqsPZHA7O1RfNCvQQVFWDnQhnnjPaI+qb+cJuXH4/iMaYjctWQZAaLVjn5bPIbt8cjUcjyeqoOumW+RhL88i43xSw7zz5lk3nu0HmPa1yhRTPcbgkxG9UdaMqRxY4bN3Yvt4gVmeKeiPrqX5E8+IfmTT6hfrx6/P96N937txpxWtXn+hYqbZF/JNPL38QRGtQ3GVXNnwSXHZmN7uoF1KVlsTstCb7XjJJfR1cuVPt5udPVyLRPxSNfEl5w9CRhPpePUtIRN+x4CbJmZiCYTqsDAfJ9bQZAanstkkJQkCYjVS6jvqGQyaurURBtNXDSaCNKocFNWnMBr05vAJiL3vHMvTQf3JsFkRS6AT1GzmDRu4OwP2YmgcgInR7ZwZUW02bBnZ2PTG7AbDIh2G4JMhszFRSpHdnZGK5fjBlQRRUxWu1TabLSQkGUkIQu0SjmuWiVuWiVqhazcP3NRB/ZSpXYozh6eNzYmJSF89RUeffvi/PXXJH00HVXSYnJtHgjxekQnKzvOprAxMpGtZ5Ix5FlxUsnpVNeXXg386RTqg8tdvgcrG5aEBPTr1+M5bBhyF5eyv+DAgVK/lc8/v6N4CBBz9NBDJx6mxseyYvp72G02Bv13Jr7B+ce+AwZIVSdTpsAzz0BZVvzn5MCGDZJg+PffoNeDszM8+qj0Z+vdGxyJYg6KROfJELkKjOlSf+M93+E6YDay2d9x6aWJxA4fTvUFC1CWtLn2A0ipj4oFQVgLjBFFMaG0z+2g8pFzIBFzrB6PJ+sgd64EpR/HfofcNGj7UkVHch1BocBzxHCSZn6M8fhxtI0aXd8X4u3EU+HVWLI3jjHta1C1kpaRlBeaUE+8RzUgbVEkKT8ew3tsQxTuxWtea4rJImPleazJRnRNfHDrW6PI79Eck5WxPx9kT3QaHw0MY2iroGLF8iDg46Lm9+fbMGKBnCEJ/nw1dTjdPW0YNm/BsHkzjY58y5qQb4idFcTRc90IfbY7moYNy73UZ1FEDAAj2wXfti/TYmVzmp51KVlsT9djtIt4KuXXHZI7eLiUueOuqroLcnc1xqPJDvHwHoh2O9bkZGQaLbICZgaCIJUkyWSQmCgJiMHBJRMQlTIZNbUaoo0mYvLMBAHuFSAg2s027NkWZM5KZOrKUUJ9P5JjtWGw2vBXK1EUpz+tiz9YcqTyJqVWEhEdVApEqxWbQRILbQYDiCKCXI7M1RW5qwsyZ+cCv38EQUCjlKNRyvFz1WC22sgyWtEbLSTp80jS56FWyHHVKnDTKNGq5GUuJOpTU0iKPk/7ISPz75g5E/Ly4MMPUfr6Um1if1i8iH/iwlj42XoOV4nFhAwPnZLeYf70bOBPu1reaCq6fVAxSV+8GADPEcPL54IKBbz8Mrz6KuzfDy1b5tvt5O6Bb3BNLh49SKuBg8onpkpAUnQUK2b8F7lCweApH+NVrfptxwiCZFTdowfMnQsvlfK0Kz1dEgpXroSNG6WPgZeX1GNx4EDJN8jhbeGg2HjVhKZD4eivEPYEHF8GXf+Lc/v2BM6ZQ/yLLxI7bDhBPy1AWbVqRUdbqSiLWVIHJJMVBw84NoOZrPUxqGu4oQuvBJNgux32zoYqjSGoXUVHkw+3J55E5uJC2k8/3bZvUlcpQ/LrLefLO6xKiaamO95jGmLLsZDyw3GsqcYiPd6eZyVjdRQpPxxHNNvxHtUAz6frFlk41OdZGLFgP3uj0/jsqcYPtXB4DQ8nFUvGtqJJoDsTfzvMX0ngNWokwb8uofbOHbi8OYVURTXkaxcRM/hpojp3IXHadHL27kW0Wss8vmyTlV/3x9E7zJ9qHpK7eZLJwsLLqQw+eoGw3SeZeDqOo4ZchlTxYkWTmhxvG8aX9arTw9utzIVDkCauusY+5J3PxJZjKfPr3c/YMjIQLRYUfn53drEWoGpVqe9hWhpER0tfBSVBIROoqVOjk8mINZpJt5T9e/dmRFHElpEHcgG5a+UvM6ysiKJIgsmCQiYUv+2AIIB7MMiVUv9Dm+MzW5HYLRasaWmYYmLIO3sWy+XL2HONKDw8UQUHo65bF1W1qpJbciEXrlQKOT4uamr6OlOviitV3bUo5QKpBjNRKdmcSTRwOdOIyWLDaivhzeUOXDgolSzXatHmxsa4OPj+exg5kmT/6vyyN5Z9f3xJuujMRN8xXAioQ8/oCD49vZRt7VXMerIxXev53bfCoS07h8xly3Ht2aN8J+vPPQdubvDZZwXuDmkazpVzZ8jLyS6/mCqQK+dOs3zau6g0Gp6e8kmBwuE1unWTDMCnT5eyA0t87SswezZ07w6+vvDss5IZ39ixsG2btEg4fz707esQDh2UAh3fkv615ILdCvvnAuDUqiVBC+Zjy8ggZthwzLGxFRhk5cNRkuyg2GT+HY1oseE+sJL0f4vaDKnnoM3EStebSO7shPugpzBs3IT50uV8+wLctQxrHcSKw5e4kPJwDE7uhbq6Kz5jGyFabCT/eAxLUuFGJcbIVBI/P0TOvgScH6mK36vhaEI97/3AW8jIMTN07j6OxWfy7ZBmPN6sWpHP8aDiqlHy83MtaVPTi9eWH2PxXulLVeHjQ7XRg2mwdB5dL+1iofsnqBs2IvOPP4gbOYrzj7TnyjuTMfyz7brLZWmz9EA8hjwrj7asxuy4ZPodOk+TiEjePneJS3lmXgz0ZV14bQ61qc9HdarxiIdL8bKRSoi2sQ/YRYwnUsv92vcLos2GNSUFmU6H7B7Od4IgiYeBgZCRARcuFF5APHPmDC+88AKhoaHodDq0Wi3Vq1enfbt2zH5/Mkd3bCPeaCbVXDLRaOHChQiCwMhCNIeyZ1sQLXbJJOU+cnM3mUzMmTOHvn37Uq1aNTQaDU5OTtSuXZshQ4awatUq7CVVdotAts1Ojs2On0qBvCRjArkCPEKkyUVGjGTr6aDcsJtMWFNSMV2IxnT2LJaEBESzGYWXF+oaNVCH1kEZUAW5s3OJx6JKuQwvZzU1fJypV8WFQE8dOpWcjBwzKdlmmn+0hdeXH2PzqSTyLLZSeoZSybJn1UA8A26IZrEffcac8Md4vMFQWs3cyperd9PMuIcLVfqxfEIn9s0YwMdvD6KpLZ2EF1/k8n9ew5qWVmoxlTdZf6zAbjDgWZ4N9ABcXGDcOFixQnLiuoXgJuGIdjuxx4+Wb1wVQNzJ46yY/j5aV1cGT/kYd/8qdz1eEOCjj6TWId9+W7xrRkXB//4HbdtKC4ETJki6+RtvSMmgcXHw9deSSFlRxiwOHlDcqkGLMXD6b6jREQ7OB7M039Q2aULQooWIeXnEDBuG6bwjwecagljKgyBBEAxAY1EUo0v1xKVE8+bNxYMHD1Z0GPc9eWfTSf0pEtdu1XHtVkkyshb2lZqbv3xMyhKoZAmB308AACAASURBVFgSEojq3gPPoUPxe+ftfPtSs010mLWNLnV9+XZIswqKsPJhScohZd5JsNnxfq4hqqrOBR5n05vI/PMCxsg0lFWc8Hi8NqrA4vXLSTbkMXzefi6m5fDDsGZ0qetXkqfwwHK3XpCLFkkNtN94Az6eaiR71y6yt2zBsG07dr0emU6HU4cOuHTvhnPHjsidC/67FhZRFIk05PLM1xFY1DIym0su6w2dtfTxcaOPjzt1dOrKsciBFG/SF4eROSnwfb5xmV3n9OnT1KtXr8zOX5ZYUlKwJiWhCglB7lT4UtGUFMlx0cUFatW6zUAzH0uXLmXEiBGYzWaqVq1Ko0aN8PDwICUlhcOHD5OWlkZ4eDjLdu7GYLVRRa3EV12875aFCxcyatQonn32WRYuXHjH40SrHUtSLoJajsJLU2nes/di//79PPXUU8TFxaFQKAgPDycoKAir1UpUVBTHjx8HoHnz5hw4cKDM4xFFkfO5JqyiSF0nDbISvI7bt2+nc+fOdGzflu2/fwtOvuDmKGMqK0RRRDSZsOn1153WAWQazdWSZFcEdfnez+12kaMnIll8xsqW00no86zoVHI6h/rSo4EfXer6Fru3oDHbwPdjh9Ki/5N4dxrAxshENhyK5UyGGYCwqq70rO/P09bV+OyZDuP3gW/dG7GZzaTNnUvaDz8i0+nwfest3AYOuG/uHSCVoF/o2QuFvz/BSxaXfwCXLkkuXBMnSv0Pb8JuszF77BBqtWhDrxdfKf/YyomLRw6y5rMZuPn58+R70/P33rwHfftKrsfR0XDV1+yOiCKcOCGVI69cKf0foFkzqRz58cehXr1KlwPi4EElOwW+agxVwyFmJ/T5FFqOvb7bFBVF3KjRiBYL1RfMR1O/fgUGW34IgnBIFMXmBe1zaPgOiozdbCNjdRQKHy0unQrnZlrmJByDmH+h+4eVUjgEUFapgmuvXmSuWIH3SxPyNYP2dlYzul0I326L4sVOWTQIcKvASCsPSj8nfJ9vRMq8E5IL86gw1EE3ep+JdpGcA4lkrb+IaBVx7RWMS/uqCMUsP72SaWTovH0k6fNYOLIFbWs5GuTfCY1Szg/Dwnl16VGmrz1NrtnGxKsu1M8+C3v3SqvJLVtqefLJ7rh2745oNpOz/wCGLZsxbN2KYcMGBKUSXds2uHbvjnOXLig8CzdgtYsiR/S5rE3JYn1qJrEXs1BlmwluHMCrtQLo5e1GkLZylnxeK13Wb47FmmlC4V4546woRJsNW2qqZHZQBOEQJJdFmQwuXoTz5yUBsaBshcTEREaPHo3ZbOaLL75g4sSJyG9SGu12O7t27WLXrl0Ea1XE5ZlJMFmwA34qRZlMzEVRclcGULhXHrH7Xhw8eJCOHTuSl5fH6NGjmTlzJr63NBmPi4tjxowZLFu2rFxi0lttGG12AjWqEgmH+ZApQecNOcmg0oHW4cRYWoiiiGg0YtPrsen1iGZJOJPpdCj9/ZG5uiJTVVxfbZlMQKuS8/ngMMxWO3uj09gYmcimU0msPZGASi6jXS0vejbwp1t9P7wL6Wpst4us27qXXW4tWXnRn0vH/kUQoIUxifcObKDnT58SWKe6pLh8uxQCW+UTDgFkKhU+Eybg2qsXCe//l4TJk8n6aw1Vpk5FVf3OJaeVCcOWLVguX75tYb3cqFZNcl2eNw8++EAqY76KTC4nqGFTYo4dRhTF++a+XBTO74vg769m4V09iCcmf4jOtWhzkOnToWlTqfJ72rTb99vtsG/fDcEwOloSBx955IZXTXBw6TwXBw6KhLMPtBkPO/8HPvWk9mfNn5MGkoC6Vi2CFv9C7KhRxD47ksA5P6Jr2rSCg65YHJmHDopM5vqLZO+4hM+4hqhr3GOJqbxYOQ7OrIVXI0FbSWIqAGNkJDFPPInvG2/g9dzofPuyjBbaf/IPLYI9mT+yRQVFWDmxZuSROu8EtoxcvLbMRHNwE5YGLckYNA1zjgZ1DTc8Hq+Nwrv47VZj03IYMncfeqOFhaNbEB5U9HLnhxGrzc6bfxxn5eHLvNCxJm/1CkUQBEwm6NgRIiOl0pNbE+BEux3j0WMYNm/GsHkzlkuXQCZDFx6OS/fuuHTrijIgIN9jLHaRvZnZrE3NYkNKFolmC0pBoJ27E5e2XUKwiGx/vRPy+6DU05pqJPHTg7j1CcGlQ9mUxd+vmYeWpCSsKSmoa9ZEpi3eZzo9XRIQtVqoU+d2AXHevHmMHTuWNm3aEBERcc/ziaJIfJ6ZDIsNH5WCKmplkSaRhck8tOVasKXnIXdTI3epBAZkhcBisRAaGsrFixeZNGkSX3311V2P37lzJx06dCjTmERR5GyOlK0W6lTy7M3rmYcdO7J92z+Qeh6seeAdCkpH463iItrt2HNzsV8TDK1WEARkTk7IXV2Ru7ggFNUhuwwp6H5qt4scic9gw8lENkQmEp9uRCZA82BPejXwp2eY/21GeBabnX3R6WyITGBTZBLJBhMy0Ub7UD96hVWhmz0VnzbhMHmyVBMKEBsBP/WGx76DpsPuGKNot5O5bBnJn36GaLHgM/ElPEeORKjE9Z6iKBLz9NPYMjOpuW4dwt3SxcuSw4chPFxa9Xz99Xy7Tm7bzMYfvmL4J1/f5jp8v3P6322sn/0F/rXq8PjbU9A4Fa8SpE0bSSAEqF4dPvwQqlSBVatg9WpISAClErp2lbIL+/cHP0dhj4PKgDETvmoE7kGQeBye/hXqPprvEMvly8SOHo01JZXA77/HqVXLO5zswcCRefiwYEiUfsoQS6oR064zuDTwQq2JgStlernCYTLAyT+g5bhKLRwCaBs0QNeyJemLF+M5Yni+gbGbVskLnWoya8NZDsWmO8Srm1B4aPDxiSLlnI3U9q/j5F6fnEaPIqSZ8KiZg27sIyWaIEYlGxg6bx8mq51fx7amYTVH5mdhUchlfPpkY7RKOT/suIDRbOWDfg1QqwVWrJDG4gMHSgLizYa5gkyGrllTdM2a4vvmG5jOnsWwaTOGLVtImjGDpBkz0ISFoevalZMt2/Cnzp1NqXoyrTa0MhldvFzo4+1GNy9Xzl/W82TSWaY91uC+EA4BFN5alNWcyT2WUrB4mJcltWEIeLhWOMWrhghyN7diC4cAnp7SwvGFC3D2rCQg3qxDJCcnA9yWIXcnBEG4msVmIcVsJS42lkVffs7GjRu5fPkyOp2OJk2aMHbsWIYMGVKkWP/44w/+/vtv9kXs5UpiAnmmPKpVq0bPnj15++23CQy8PcO/U6dO7Nixg23btuHi4sLUqVPZvXs3OTk5hIaGMmnSJJ577rkCr5eTk8OXX37JsmXLiIqKAqB27doMGjSIV155BZ1OV+jYlyxZwsWLF/H19WXWrFn3PL4g4TA1NZX//e9//Pnnn8TGxqJUKqlfvz4jRoxg3LhxKG4RPqZMmcLUqVP54IMPmDJlym3n+27BAiaOGcMzw4fz688/X99+s4D7zTff8OGHH7JixQquXLmCt7c3/fv356OPPsLzpuzna68zwI4dOxBkN4SNjm1asO3fCOrUrUdUVBR79uyhdevWBT7vJ554gpUrV/Ldd98xfvz4e75ODyo2sxlrdjZCbi52gwHRZgOZDLmzs1SS7OJSceJRMZDJBMKDPAkP8mRyn3qcTjCwITKRTZGJfPj3KT78+xQNq7rRK8yfYC8ntp5JYuvpZLKMFrRKOR1qeyHbvYze4TXpP7q/dNL+L0m1nzcLWId/BpULNBh413gEmQyPp5/GuXNnEqdNI/nTz8hau44q06ahDWtQhq9E8TEeOULeseP4vf9exf7tmzWTGut9/bXkwHzTF0Zwk3BAKu19kMTD41s3sHnudwTWb8iAN99HpSned+6SJXD06I12sLGxktkJgE4HvXtLguGjj+ZL6nTgoHKgdYd2r8DWqeDsBxHf3iYeKqtWJeiXX4gbPZr4ceOo9u03OLdvX0EBVyyFFg8FQegARIiiaL1luwJoK4rizqubZgDppReig0Jz+BfYNr1ML6EE/JTAhas/lQVBDq2er+goCoXnyJFcGj8e/cZNuPXNf3Ma2TaYBbtimLXhLL+Pa/1AlkcUF/mUd/BJziR10GfkNBuI9vRW3Ld8jdzHFSYOKPZ5T13RM3z+PgRBYOm4NoT6F69X4sOMTCYwfUAYOpWcuf9eJNds4+MnGlGtmsDSpZIj3+jRsHx5wX1sBEFAU7cumrp18Zk0EXNMDIYtW0jYsIm8r74igK/oW6UqLdu2p0rvnrRu3QInxY1Jxrx/L+KmVfJE+P1lbKNr7EvW2mgsKbkofW4RbHZ+Cnu+hdbjofNkUBWtfPd+QrTZsBkMUgZSdjbYRRSFFPXuhrs71K4tNWS/JiBeq3ysfrWcb+vWrZw8eZKwsLB7nk8QBKqqlRzZt4+hj/XHkJVJSEgIAwcOJD09ne3bt7N9+3Y2bNjAokWLCn3/Hjx4MBqNhnq1QunatStmi5mjR48ye/Zsli1bxu7du6lTp06Bj92wYQOff/45oaGh9OjRg7i4OCIiIhgzZgyZmZm89tpr+Y5PTU2lS5cunDhxAg8PD3r27AnAtm3bePfdd1m2bBn//PNPPgHtbvz555/Xn4NaXfTy+6ioKLp06UJ8fDz+/v7069eP3Nxctm3bxoQJE1i1ahV///13oc9tF0X0V40sVHdw283KyqJdu3ZcvnyZDh06EBYWxq5du/jhhx/Yv38/e/fuRXlVOOjVqxcajYaNGzfi5+dHr169pJPYLNQN9ELIimPC+PG8+p//MHv27ALFw8uXL7NmzRpcXFwYPnx4kV+jB4nspASMZjNyUUSl1aBxcUXl7n5fCYZ3QhAE6ge4Uj/Alf90r8PF1Bw2RiayMTKR/208C0iLxF3r+dKrgT8d6vhw6dhB/lx7msath0on2bMH/voLZswAj6tl8cZMiFwNjZ8u9PeA0s+PwG+/Rb9pE0nTphMzaBCeI0bgM2kisiIsDpQH6T8tRObmhvvAuwuj5cJ//iOlxK1YAc88c32zs4cnPsE1uHj0EK0GDqrAAEuPQ2v/ZPvPcwlp2px+/3kHpar47VPefReutibNh4+PJCSWYB3QgYPyodXzsPd7UOogLgIuH5L6IN6E0tdXEhCfe45LE16i5uZNKB/C9NmiZB5uA6oAybdsd7u6Tw4giuLM0gnNQZFpMBD8ym5l0Xg2nZx9iTg/UhVNjUq2dORaBTyCKzqKQuHcqSOqkBDSf/oJ10f75Jtg6lQKJnapxQdrItkVlUr72j4VGGklwmCA2FjkgM+vE7F6BqJKOifti8ss9mmPxGXw7IL9OKkVLBnTiho+JTPueJgRBIHJfeqhVSn4eut58qx2Ph/UmE6dZHz8sWSe8r//wZtv3vtc5mqBfN6hFwtqNqd+rp4P4s9RZ+9uAlcvhz9+50pAFVy6dcO1e3eSg0LZeCqR8Z1qolPdX8n0usbeZK2LxngsBeWtxlPtX5Oyqvd8C6fXQN8voVbXUr1+4owZmE6fKdVzFhZRFMFmQ7RaEe02EKX3EAoFgkKBcAfhR12vLv6TJxf6Oq6ukmh4/jycOQOhoaBWw2OPPUZAQABXrlyhadOm9OjRg44dO9KsWTNatGiB2x3SI0wmExOGD8WQlcnQ8RP48JNZBDtpkQkCJ0+epGvXrvzyyy+0a9eO558v3ILWr7/+yqN9HkUjUyHXSaKV1Wpl6tSpTJ8+nZdffpn169cX+NhPPvmE+fPnM3r0jTYYixcvZvjw4Xz44Ye8+OKL+TIJx48fz4kTJ2jfvj1r1qzB/Wp3+4yMDPr27UtERAQTJkzgt99+K1Tshw4dAqBFi+K12hgyZAjx8fE89dRT/Pzzz2g0UhlwfHw83bp1Y8uWLUyZMoWZMws3tEy3WLHeox3P6tWr6dOnDxEREThfNWu6cuUKrVu35vDhwyxbtoyhQyUx5+2336Z169Zs3LiRunXr5i85z04C/RVGPdWX995/n+XLl/PFF1/g5eWV73o//vgjVquVESNG4OLycC9OOXn5IM82YLZaMOYZMWamI8/Wo3ZyRuPkhFKjfWAWTUO8nXihY01e6FiTxKw8LmXk0jjQHeVNPZmjDuxBrXOiWv0wKW1r8mTw9YVJk26c6MRysBoh/Nkix+DaowdOrVuT/NnnpC9ciGHzZvynTsX5kXal8RRLjDkuDsOWLXiNG1c5RM1HH5W+JD77DJ5+Ot9qZ0iTcA6s+YO8nOxil/ZWFvauXMrupb9Qu1VbHp30BnJFydoDxMUVvD011SEcOrhPUDlBhzdg/RuSgLjnO3hywW2HKTw8CFq4kJy9ex9K4RCKJh4KQEEjMi8gp3TCcVAivGtJP2WATW8i/bdDqGo0Rt07zGGDVQIEmQzPZ58lccoUjAcPortl0vV0y0Dm7IzmfxvP8kgt7wdmIF1s/voLbirzklmMN4RDkJqrFIN90WmMXngAL2c1S8a0ItCzEgxc73MEQeA/3eugU8n5eP0ZjGYb3w5pymuvydm/H955Rypj7noXDWxTahbvnLvEFZOF0VW9eadGQ5wVHeCFMVgzMsjevgPD5s1k/r6UjJ9/Ic/JlZd96vFkx2HYzTUqtKl+UZG7qlGHuJF7NAWXrtXzf9a17tDvS2j4FPz1Mix+HBoNhp4zwcnrzietxIiiCFYros0mlSsi3Q8FhVLqySWTURZ3O2fn/AJinTrg4uLCli1bGDFiBAcPHmTdunWsW7cOAJlMRuvWrZk0aRKDBw/Od67ly5cTHx9PcHAwn3wyi1Q7xBrNBGlVhIWFMXXqVF588UU+/fTTQouHgwbdnsmiUCiYNm0aCxYsYNOmTRgMhgKFpyeeeCKfcAgwbNgwZsyYwenTpzl48OD1UuHY2FhWrFiBTCZj7ty514VDAA8PD+bOnUvDhg1ZtmwZs2bNKrBc+lZSUlKAwpd/38y///7LgQMHcHFx4YcffrguHAIEBgby1Vdf0bt3b7777js++OCDfPsLwi6KJJmtqO8gPF/D2dmZ+fPnXxcOAQICAnjppZd466232Lp163Xx8K44+YI5F7e8TEYMfZrv58xn/vz5vHnTConFYmHu3LkAD3W58jUUOh3OV0Uiu82GKTeHvJxsjPoscrMykcnlqHVOaJydUWm0d1xEuN/wd9Pg75b//Wu32bhwaD81mrVArlDAli2wfbtUNnuzUdThn8G/IVRpUqxry11dqTJ1Cm59HyXhvx8QP2YMrv374ffOOyg8Ktb0J33Rz6BQ4DG0aK0eygyZDF59FV54Af79F25qsxDSJJz9q5cTd+IodVo/UoFBFh9RFNn1+8/sX72ceu070+vFV5CVQtZv9epShmFB2x04uG8IfxYivpF6Gkeuhm5Twf32cZDc1RXXHj0qIMDKwT3FQ0EQ1lz9rwgsFgTBdNNuORAG3LvbuIP7msw1FxBtIh4DajnErFLA7bH+pHz5JWk/LbxNPFQr5LzcrTZvrjjOxsgkeoX5V1CUFUxiotR3ZtkyCAuDMWNg1izIzb1xjE53o6F4EdhxLoXnfzlIVXctS8a0vm1Q76BkvNCxJjqVnP/+GcnYnw8yZ3hz5s+Xc/KktJh/+DDcqkukmC28e/4ya5IzCXXS8HeDYMLd8pdoKTw8cB84APeBA7Dn5JC0dTtrvvmVzgnHMbwykfNOTjh36oRL9244t2+PrIhOvRWBtokPmSujsFzJQVW1gGyG4Hbwwi749zPY9QWc3wy9PoZGg0q8iFOUDL7iIIoiosmETa/Hrtdjv1rXJNNopP5mrq4I6vJxFXZykhJKzp27UcJcr149Dhw4QEREBGvXrmXfvn0cPnyYjIwMIiIiiIiIYP369fmyza71vxsyZAhVnXWozRYu51m4aDQRrFUzcuRIxo8fT1RUFJcvX6Zq1aqFiu/cuXNs2LCBqKgosrOzsdvtgJSBaLfbiYqKomkBDn99+/Yt8Hx169bl9OnTXLlyozHxv//+iyiKtGnThtDQ0NseU79+fVq1asWePXvYuXNn4QS0EnDttezXr1+BZdK9evWiSpUqJCQkcOjQIdq1u3u2VKrZitUu4qa4+2Q4PDwcf//bv1fr1pVcbG9+ze6KIIB7dUjN46Uhffl+znx+/PFHXn/9dWRXRa+VK1eSmJhIp06dqF+/fuHO+5Agk8vRuriidXHFbrdjzs0hL+eqmGjQI8hkkpDo5IRK53T9NX1QuHz2FHkGPbVatrmRdVi9Oowbd+OgK0ekBv59Pi3x/V7XogUhq1eR9uOPpM6dR87Of/F7521c+/evkHG9LSuLzJUrcXv0UZSl0Kai1Bg+XKrD/eyzfOJhQJ16qHVOXDx66L4UD0VRZNuiORxZ/xeNuvai25jxpSbOf/SR9LYtheG5AwcVh0INnd6GP8eDIIN9P0BPx5v4Vgpz10i7+iMAGTf9ngZcAn4A7mz95eC+x3gqDePJNFy7BpbIzdbBDWRaLR5DniF72zZMFy/etv/xplWp4ePE55vPYrOXriN6pUcUYf58yZ539WqYNg0OHYIPPoA5cyAoSBpEBwVJvxdxgrspMpGxiw4S4u3M0ufbOITDMmJEm2BmPdmI3VGpPLtgPygtrFwJJhM8+aT0L0gD2l8T0mi/7wwbUrJ4K8Sfzc3r3CYc3orMyYlVrqHMDB+Cas0mAuf8iGuf3uTs2cPlV17lXJu2xI+fQObKVVgzMsrhGRcPXZg3yAVyj93aEeQmlBro8i48vxO8asKqcbD4CciIKbc4C4soithzc7EkJmI6fx5TVBTW5GQQZCj9/FHXro26Vi2Uvr7INCV3wi0KWq0kIMpkkoCYc7Vmom3btnz00Uds2bKF1NRUdu/eTY+rq8qLFi1i+fLl189x+fJlAEJCQgDwVimpplGRbbVzMdeEUq0m4KpL+LVj74bVamXcuHHUrVuXl19+mW+++YaffvqJRYsWsWjRouvGLnq9vsDHV79DaofrVXeivJsaUd0ae0HUqFGj0LED+PhIrTWuxVkUSjMemyiSbLbgopChkd99aFuU1+yeyOTgEUL9OiF069CW6OhoNmzYcH337NmzAZgwYULhz/kQIpPJ0Di74O7nj29QCB5VAtA4O2M25pKZlEhKTDQZiVcwGvTYr2Yt3+9EHdiLXKkkuHEz+PNPOHBAGufc3N/z8M+g0EgZ6KWATK3GZ9IkQv5YgSooiCtvvU38mLGYL10qlfMXhYylyxCNRjxHjSz3a98VnU6qdvnrL2m16SoyuZyghk2IOXpIyqK/j7DbbWye8w1H1v9Fsz6P0W3shFLN6h06tFSG5w4cVDyNBoNXbamM+dBCyCt47PUwc887hyiKo0RRHAVMBZ679vvVn+dFUZwpimJq2YfqoCKwm2xkrrmAwk+HS/v7y4ygsuMxZAiCUkn6okW37VPIZbzWPZRzSdmsOVa4SdwDwfnz0KWLlGXYqBEcPw7vvXfD5WDoUIiJAbtd+reII5M1x67w4pLD1A9w5fexrfF2Ln6DaAf3ZlDzQL56uimH4zIYNn8//tXNLFwoOS9PmgTRuSaePHqB/5yJp66Thn9ahvJqsP8djQ5uxmy1sygihva1vakX5I1zhw5UmTaN2v/uJOiXn3F/ejB5Z06TMHky5x9pT+zIUaQvWYIlKansn3gRkOmUaOp4YDyWgnivhQK/+jB6I/T+H8Tvg9ltJFc4m/XujytjRFHElp2N5UoCpnPnMEVHY01NQ1CpUFapgjo0FHXNGih8vJEVw1SjNNFoJAFRoZAERIMh/36ZTEbbtm1Zt24dzZo1A6Qeebdys+jppVJQXasix27nQq7ptmPvxldffcXcuXOpUqUKv//+O3FxceTl5UlZm1ezBIE7TlaLk41VmoJteLjUUPzAgQPFPkdpxJNitmATwV+tvJ61eSdKPYNNqQH3ICaOkgSea4LhyZMn2blzJwEBAQwYUHxTr4eNaxmHbj5++ASF4BlQDa2rG1aTiazkJJJjo0m/concrExsVktFh1ssRFEk6sBegho2QaVUwfvvS+nQI0bcOMicAydWQP0BUhuLUkRTpw5Bvy7B7733MB45QnS//qQt+AnRWj7fJaLZTMbixTi1bYumgCzoCmfCBGnc+cUX+TYHNw0nOyOdlNjbF/0rK3abjfXffs6JfzbR+vHBdBoxpkwW7Uo4PHfgoHIgV0iL9SYDmLOlBRwH+Sj0CEoUxamiKDp6Gz5k6DfHYss04TGwFoLiwSoZqWgU3t649u9H1uo/C8yM6h3mT4MAV77YfB6z9e6TofseiwVmzoSGDeHIEWnJcts2aZZfSiw7EM/Lvx8hPMiDxWNa4aYrWYNoB4WjX+MAvh8Wzukrep6es5cOPUy88bbIYkMSHfac4UR2Lp+GBrKyaS1q6QqfBfrXsSsk6U0890j+rCVBLkfXogX+kydTa+tWgleswGvMGKwpKSRNm05Ux05cHDyYtHnzMMfElPKzLR66xj7YssyYYwuxwimTQ6txMGEfhHSETe/CvK6QcLzsA70J0W7HptdjvnQZ05kzmGNisGakI9NoUVatiqZuKOrgYBReXsiUleuzplZLtxaVSlqvyMq6/Ri5XE6XLl2AG339gOtlyNHR0fmO91AqCNaoyMrNvV72WpiS5WtZjT/++CODBw8mMDAwn7NwVFRU0Z7cXbhT7DdzbV9hy6379+8PwNKlSzGZiiacFjce1dXFpOzsbACsdpEUsxU3pRydXE5sQc23yhqtO30HPEFI9aqsX7+emJiY6yLiuHHjUCjuLzOnyoIgCKi0Wly9ffCuHoxXtUCc3D2w22zoU1NIiY0h7XI8OZnpWM3mig630KTEXkSfkkStFm3g99/h5EmpyuLm90nkajDpodmIO5+oBAhyOZ7DhlJj7d84tWpF8qxZxAx+mrxTp8rkejejX78ea3Jy5cs6vIafHwwbBosWSa4fVwlpLC2WXDx6qKIiKxJWi4W/vviYM7t3UfE14gAAIABJREFU8Mgzz9Ju8HBH6ykHDu5FvcfAv5FUxrz3+wpfoK9sFFoNEgTBUxCE7wVBOCcIQqYgCPqbf8oySAcVg/lyNtm7L+PUyh91cCVzV35A8Hr2WcS8PDJ///22fTKZwOs9Q4lLz2XZwfgKiK6c2L8fmjeX+v307QunT8PYsVJtYSmxKCKGN/84ziO1vFk0qiXOasdErjzpXt+Pec82JyYth8e+j2BPr0hcxiaQG+HKd5p6DAvwQlaEAa0oiszbdZE6fs50rHNnR3JBENCGNcD31VeoufZvaqxbi8+rr4LNTvKnn3GhV2+i+/Un5etvyDt9usJKkTT1vRCUMnKPFqH0060aPPMbPLUQ9FdgTifY/F8w597rkcVGtNmwZWVhjo+XBMO4OOz6LGTOzqgCA9HUrYsqqDoKDw/JAKUSo1SK152Xo6IgswDT9rirFpLVqt3Iuu/YsSMAv/32G9ZbsnTc/s/eeYdHUbV9+J7dTbLpnRTSA6FLly6gNEEUUUBBwYKggA1FUECxYMPy2gDFgigoFpqC8IH03jtJIL1B+qZt3/P9MYCEmpAe5r6uuZLMnDnnmU0yc+Z3nmKnYefvSxFCEBIZiW9AwA3tyM3NBbhqcZL169eXEi4rSo8ePZAkid27dxN7STjeBU6dOsWePXtQqVQXi6zciFGjRhEaGkpmZiZTp069Yftt27Zd/P7CZ/nXX3+Rd5UFtHXr1pGRkYGLi8tFD0f4T0iMjpYrhWeazNgE+NvbIYQoFTZcGVwQKy//fV+Oyj2ICU88gs1mY8777/Hzzz9jZ2fHuEtz2CncNJIkYeegxdXLB5/gUHyCQ3Hx8gYBhTk5ZKckkZ2SRFFuDmajsVaHlp7ZtwtJUhHZuh28/jq0aSPn87iUg4vAuxGEdq1SW+wCAgiaN5eGn36C+dw5EoYNJ/Ojj7Dp9VUynhCCnB8W4tC4Ec7da3HuwBdfBL0e5s+/uMvFyxvf0HAS64B4aDYaWPnRO5zZt4vej42j05DKCX1XUKj3qFRw1+tgMUJBKpxaWdMW1SrK83b+HXA3sBB4AXj2sk2hHiGsgrxlp1E52+HeP6ymzam3ODRujHOPHuQuXoLtKl4bvaJ86RjmyRcbT2Mw1488PxcpKpInZ126QE6OnN/wjz+gDC/c5WHe5jjeWHXiooDlaF/xynIK5ad9hBc9+0aQmq8nbUsab3gE4LIgnKeG2ZGTU76+dsblcCqjgLHdI8q1iu4QEYHP+HGE//E7jTb+i99rr6H28CB7/nwS7h9KXN9+nHv/A0oOHkTcIPSxMlHZq9E290Z/LBthLce4kgQt7odJe6HNSNjxGczrCvGbK802YbFgycvDlJSEIToaU0oKtuJiVO7u2IeG4tC0KfbBwajd3ZEqoWpjdTF37lzGjXscnW4vTk6ygHhex8NisbBgwQL++OMPgFIVl4cNG0ZwcDAJCQm8+uqrpUJkT548yXtvvQnAmGefJ67EiPEGf0cXinTMmzevVF9xcXE8/fTTlXKtFwgNDeWBBx7AZrMxfvx4dJe4XObn5zN+/HhsNhvDhw8vU6VlkIW1pUuX4uDgwGeffcbYsWOvmv8wLS2NSZMmlQrf7dGjBx07dqSwsJCJEyeW8lxMS0vjhRdeAGDSpEmlKi337t0blUrF2rVr2bxtG9lmC552auwQTJ8+nb1795b7s7keF8TKM2fOXF9AlCSenDgZJ0dH5n79DYWFhQwZMoSASn6mKcho7O1x8fTCOygY35AwXH18UanVFOXlkpOaTHZKEoXZWZj0+lonJJ7Zt5vAJs1w+uNPiI+XK0tcumCaFQMpu2Wvw2rwFJMkCbe77yZy9d+43z+EnG+/I/7e+yjetavSxyrZvRtjdDRejz1Wu73gWrSAAQPgyy/hkjyo4W3akxZzEmNJ7Q3GM+lLWP7+myQeOUi/8c/R7u57a9okBYW6RaM+ENwZJDXs+FzOx68gcyGvzo02oADoVNb2tXVr3769ULgxBdtSRcrUraL4cGZNm1LvKdqxQ5xs0lTk/fHnVY/vjssWoVP/Ft9siatmy6qQNWuECA0VAoSYMEEIna7Sh7DZbOLjddEidOrfYtKSg8JksVb6GAplY0O2TrTfeVz4bTwkntwWLVq+sVZ0fneDWPFvobC3F6JvXyEslrL3N+b7PaL92+uFwVyOk66DOSdH5P3+u0gaN06catlKnGzSVMR07y7SX39DFG7bLmxGY6WMcz1KTmSLlKlbRUl0zs13Er9ViM/aCvGGmxDLnxEnjx+/qW6sRqMwZ2cLQ3y8KDl2TJQcOyb00dHClJ4uLEVFwmaz3byNtYRPP/1UAAIQ/v7+okePAaJ//5HizjsHiMDAwIvHXnnllSvO3bVrl/Dw8BCAiIyMFA899JDo16+fsLOzE4B49NFHRaHZLI4VFIsThSVCb7GKH374QQBizJgxpfrauXPnxfOioqLEiBEjRN++fYW9vb3o2bOn6Nq1qwDEpk2bSp3Xs2fPq+6/wJgxYwQgfvjhh1L7s7KyRMuWLQUgvLy8xNChQ8XQoUOFp6enAETr1q1FTk75/wZ37twpgoKCBCA0Go3o0qWLGDFihHjggQdEmzZthCRJAhCdO3cudd7p06cvnhcQECCGDx8u7rnnHuHs7CwAcddddwmDwXDFeBMnThSAsLOzE7f37Cnuve8+ERISIlxdXcVzzz131c/6Wr+DC2zatEkAomfPnlcca9u2rQBEs2bNxCOPPCKefPJJ8eGHH161n3FPPn7x72fzNX4/ClWHxWIWxbp8kZueJs7GnRYZZ2LFuYQ4ocs8JwzFRcJmu7m5wMmTJyvFvvxzGeKj4YPEvmVLhQgMFKJrVyEuv6eufU2IN72EKDxXKWOWl6Jdu8Xpfv3EySZNRdrUacKcm1tpfSc99ZSI6dZdWKvhuVph1q+X56nff39xV8qJY+Kj4YNEzO7tNWjYtdEXForF0yeLjx8aLE5u21TT5igo1F0Stsvz6TfchEjcUdPWVCvAfnENLa08noeZQFFFhEqFuoEl30jB/yXhEOWJ420+NW1OvcepSxccmjQhd+HCq66Od4rw5o4oX+ZuPkOhoW4mB79IZqacRXngQLmi3fbt8NVXcL7KZWUhhGD26lN8vvEMwzsE8b8RbbC7QQVOhcony2RmwskkRh2Nx1GlYlXbRnzbvQlLx3XBZLHx9s7dvP5xAevXy5FbZeH0uUI2x2QxuksoDprK8XTTeHnh8eCDhHz9NY137STw449wat8B3V9/kTJ2LLHdupP2yisUrF9fZaFc2ihPJEcN+sMVCFMN7wHP7IDuk+HoUijMgJLcMq2Y2oxGzFlZGOPiMMbGYs7IQFgsaHx9cYiMxCEqCruAANTOzrXbW6SMPPnkkyxfvpyJEycSHBxMfPwxNm78nZ07t+Lo6MKYMWPYtm0bH3zwwRXndu7cmcOHD/P0009jtVpZtmwZe/bsoUuXLvz888/8+OOPuGg0RDppsQmIKzFiuoYHYpcuXdi3bx+DBg1Cp9OxcuVKUlNTmT59OuvWrcOukvNF+vj4sGvXLt5++20aNpTz8/3zzz8EBwcze/ZsduzYgZeXV7n77dKlC6dPn2bevHn07duXpKQkli9fzpo1aygqKmLkyJH89ddf7Ny5s9R5jRo14tChQ0yZMgVXV1dWrlzJ5s2badGiBV9++SX//PNPqRyQF/j888+Z/f77NAwL5/CuXezcsYNOnTqxf/9+2rZte9Ofz7VYtmwZw4cPJzc3l19++YXvvvuO1atXX7Vt3wEDAWjRJJKe7aIq3RaF66NWa3Byc8czIBDf0HDc/fyxd3REX1RIXkY6WYkJ6DLPYigqumFxnargzL7dADQ6GQvp6fDuu6W9Cy1GOPILNBkILg2q3T4A586diFi5Eu9x49D9/Tfxg+5B9/fqCntwGs+coXjrNjxHPozqQiG82sxdd8nF+z755OJzNCCqKfaOTiQcqn2hyyUFOn57+zUyE+IYPPlVmnXvVdMmKSjUXcK6QXgvQILt/6tpa2oNUlkfBJIkjQCGA2OEEHVWROzQoYPYv39/TZtRq8ledBLj6Tz8XmyPxqvsBQwUbp785SvIePVVghcswKXHlTlgjqXqGPzldl7o05gX+tTBlxEhYNEimDxZLm86fTpMmyYnHKtkbDbBzJXHWbwnmce6hvH6Pc1Rqeq+2FGXEELw29k8Zp1Jo8hq4/lQP54NbYDDJWFZZzKLGPXtbowWG1Hpt/P71x6sWAH33Xf9vqf9eZQVh9PYOe0uvJyr9uXDZjBQvHMXhevXU7RxI1adDkmrxaVHd1z79MGlVy/U7pWXDzbvz9OUHMkiYEYnVBUNrz97nFPJ2TQLcgcHN3APBs1/n5cQAmEwYC0owFpQgDgfMqpydETl5obaza3GKyNXNzabHEGYnw9BQeDvX/E+DVYbcXo5/1qEkwNOdSi0u7aTrDeSb7HSzFmLXWVXUK4A999/PytWrGDuR+/wzMMDwTO80qvlKpQfm82GSV+CsbgYY0kxNqsVSZJwcHLGwdkZBydnVNf5/zx16hTNmjWrsB1LZ03DWFjA6B9/g/btYd260g1OLIffH4NRf0LjPhUer6IYYmLImDETw7FjON/Rg4A33sCujAWVLidj5kx0f/1No00b0Xh6VrKlVcSPP8Jjj8HatdC/PwCrPnmXjNMxjJu7sNYsphXl5vDH7Jnozp3lvpenE9am/Y1PUlBQuD7ph+Sc4gDPHgTvyBo1p7qQJOmAEKLD1Y6VZ7Y1A+gHZEqSdEqSpKOXbpViqUKNoz+ejeFkDm59QhXhsBpxHzQQja8vuT/8cNXjrYLcubulP99uSyC3uO5UFAQgLg769ZMnX82awZEj8MYbVSIcWqw2Xv79CIv3JPN0z0jeGKwIh9VNot7IiCNxPB+dTCMnLRs6NuHlcP9SwiFAowYu/D6+Ky4OGk767eG2O3MZPRquUsfhIlmFRpYdSuOBdkFVLhwCqLRaXO/sTeB779J4x3ZCFv6Ax9Ch6I8eI33qNGK7dSf5ybHk/forlkoobOHY2hdhsmKIzq248f4tZa8Vt4ZgKoKsU4iiTKzFxZgzMjDGxmKMi8OSlYWk0WAXEIBDVBQOkZHY+frecsIhyCnHIiLAywtSUyEtreJpbrRqFY2cHFBJEnElRoos9Sx3bQ2ht9rIM1vxsdPUKuHwwIEDrFq1Cm9vb0aPew7sHCE/GcyGG5+sUKWoVCq0zi64N/DDNzQcz8CGOLq5YTYa0GWeIyspgdyMNEoKdFhvUBznZikp0JEWfZJIo0XO9Tx79pWNDvwoL/ZE9q4SG8qLtkkTwn79Bb9Xp1Gy/wBxg+8ld9EihLV89zJLdja6latwH3Jf3REOAR5+WM7F/fHHF3eFt+lAUW4O2cmJNWfXJRRkZbJ01jQKsrMY+tqbinCooFBZBLaFxv3k77d9UrO21BLKM+P6A/gI+AD4Ffjzsk2hjmMzWMhfFYedvzMu3QNr2pxbCsneHs9RoyjeuRNDzNXVk8l9oygxWZi/Ja6arbtJLBb48ENo1Qr27IF582DrVllArAJMFhvP/XqIZYfSeKlvFFMHNKk1K8K3Ahab4KvkTHrvjeZgQQnvRwWxsl0jmjhfexEixNuJ38Z3oYGrA8Yue9GGZjN0qFxL52r8tDsJk8XGE93Dq+gqro2k0eDcuTP+r8+k0aaNhC39Fe/HH8OUmsLZWW9y+o6eJI4cRc73P2BKubnq6A4R7qhc7Sk5UkkVdiUJ4eSD1SkEk94eY9I5TAkJWHJzUWm12DVsiLZpUxzCw9F4e9eNMLIqRqWC8HDw8YGMDFlErKiA6KCSBUQ7SSJeb6RQERArzFmjGZUEDewrN6z7Zhk7diwPPfQQvXv3xmaz8dZbb+Hs6ip7HQLkJYBN+b3XFiRJwsHRCTefBviEhOHVMBgndw+sZjMFWZlkJSWQk5ZCcX4eFnPlpYuJO7AHIWw0Xv4XDB0KHS5z7MhLhPhN0PYRUNUeL2VJrcZrzBgi/1qFU4f2nHv3PRIfHokhJqbMfeT98ivCZMJr9JgqtLQKsLeHSZNg/Xo4dgyAsDbtAEioBVWX8zLS+PWNqeiLCnhw+tsEN29V0yYpKNQv+r4tfz36q5wK6BanzGHL9QUlbPna5K+Ko2hXOr7PtMYhpHJz0CncGGt+Pqd734nbgAEEvvfuVdtM/u0wq49msPWV3vi51WLP0IMHYexYOHQIhgyRq9XdZJhLWTCYrUxYfJCN0ZnMGNSMsT0iqmwshSs5WljCS9EpHCvSM8DHjfeigghwKLsQlVVo5JFv9xCXVUzG7+0Y3N6PX34pnQbKYLbS9f2NtAvx4NsxHavgKm4OIQTG06cp3LCBwvUbMJ46BYBD06a49u2Da9++ODRuXGYhO/+vOIr2ZBA4ozMqreambLKVlFC0bTtJri409vBA2GxIKhUqJwfUUgkqjRXJtQG4+Jeu8KlwESEgJUVO0+rrCyEhFS96arbZiNcbMdoEoVp73O1u7vd7q1NitXK62Iifgx3+DrVDPJQkCZVKRWhoKBMmTODll1/+76ChAHLjQOsBnmHVUj1X4eYQQmAxmTCWFGEoLsZyPp2DxsGB1HOZNPT1wSc49KYXJpd/+BbZhw8x9teVSMePQ/PmpRtsfAe2fgQvHAOPslU8r26EEBSsXsO5d9/FWlCA9xNP4DPhGVTaa89JbQYDZ3rfiWObNgTPm1uN1lYSubkQHAzDh8P5CKFFUyahdXFl+Bvv1ZhZ2SlJ/PHODGxWKw/OeIcGYcrcV0GhSljyMMSugW4vQN83a9qaKqeywpYV6jGmlEKKdqXj3DlAEQ5rCLWHBx7334/u778xZ2Zetc2LfaKwCcEXG09Xs3VlpLgYXn4ZOnaU3Xb+/BOWL69S4bDYaOGJhfvYFJPJ7PtbKsJhNVJitfHmmTQG7I/lnMnMty3C+KFleLmEQwBfVwd+HdeZZgGu+D1wgL8OZ/DZZ6XbLDuYRm6xqdb9fiVJQhsVhe+ECUQsX0bkhvU0mDoVlZMT2V9+RcK99xE3YACZH32E/vBhxA0S9Du1aQAWgf54TrnssObnk79iBSkTJxHbpStpzz+PMBhRubtjHxKCQ9Om2IdFog5qhuTkCUXnICsajIUVufx6iyTJ74r+/pCVBYmJFfdAtFOpiHTUolWpSDSYyDdXTWhkfSfDaEYtga997RFfhRBYrVbi4+NLC4cAWjdwDQBDPhRXklexQpUgSRJ2Dg64eHrjExSCT0gYrt4+SJIKY3Exi6ZM4vsXxrF18Q+kx0bf8H5+KSaDnqQjB2kUG4f0yCNXCodWCxxaDI361FrhEOTPyP2eQUSs/hv3e+4h55tvSLhvCMV79l7zHN3KVVjz8vB6/LHqM7Qy8fKCxx+HxYvluS0Q1rYDaTEnMZaU1IhJ5+LPsPTNV0GSGDHrfUU4VFCoSu5+D5Bg79dyUatbmDKLh5IkFUqSVHCtrSqNVKhahFWQt+w0Kld73PuH1bQ5tzReY0aDxULekiVXPR7s5cRDHUP4dW8KyTk1M2G5Jv/3f3KI8scfy16Hp07JYTlVSIHBzOjv97I7PoePh7VmVKfQKh1P4T+25BbSa28081KyGBXozbbbm3JPA4+b9sjwdLZn8VOdaBvqge99B3n9+1S2bpWP2WyCb7fH06qhO53Cy18JtjqxDwrC+/HHCFuymMZbt+A/axb2QcHkLPyRxIce5kyv3px9622Kd+1CXCUczi7IBbW3lpIjV19AuBTzuUxylywh+YkniO3WnYxpr2I4cQKPYcMI+fFH7Pz9sG/YELWbG9IFD0O1BjxDwSsSEJBzRs7JZlOErMuRJHndIzBQTk8WHy8XVakIGpVEpJMDTioVSXoTuSblcy8PhRYrRRYbfg52qOuSB5+LHzi4Q0EaGOtszcFbDo2dHc4enng3DMLF24c+Yyfi3sCfA6tX8MvMl/lmwmNs+G4eSccO3zBPYtKRQ1gtFhqlnYVZs65sEPcvFKZDu9FVczGVjMbTk8D33yPk++8QNhvJY8aQPmMGVp2uVDths5G7cCHaFi1w6lh7ogbKzQsvyOl4vvoKgPA27bFZrSQfP1ztpqTHnuL3t6djr9Xy0KwP8A4KqXYbFBRuKTzDIKo/mPWwe15NW1OjlKfa8uVJKuyAtsADwGwhxBeVbFuVoIQtX0nh1lR0axLwGtUMp1Y+NW3OLU/KpEno9+2n0aaNqJycrjieWWDgjjmbGNgygE9GtKkBCy8jO1uuovzTT9CkCXzzDdxxR5UPm1dsYvT3ezmVUcDnD7dlYKuAKh9TAXJMFt44k8Yf5/KIdHTgo6bBdPFwqbT+S0wWHv9+P3sScyje0hKHlFBytedo8OB+hge34cOJVefFWpVYdTqKtmyhcP0GirZtQxgMqN3dcendG9d+fXHu2vVi2JduXSKFm1MIeK0TatfSXpympKSLIdL6w/JLi31YGK59++Lary/ali0vCrg3rA5qs0LRWSjKBJUG3IPk0Mq6JMpUE+fOyWHM7u4QGVnxaG+rECTqjRRZbDTU2uFTS3L31WaEEJwpMWIWgqbOWlR17e/UZoGsWBBW8G0CaiXHaF3i0vupoaiI+EP7OL1nJ4lHDmIxGdG6uBLZ/nYa3d6V0NvaYGd/vujU4sUwfTpr/D1J8PflmSIbqg0brhzgl5GQuhdePAmauvW3YdPryfryS3IX/oja0xP/6a/hOmAAkiRRuHkzqU8/Q+CcObgPvqemTa0Y998v5+5OTsbq4MDcsSNp0rUH/cY9W20mJB8/yooP38LZ05NhM2fj5tOg2sZWULjI+fsayclyXpfZs2HUqJq2qmopyEB80oxCnGht+IZADyem9G/CkLZ1873kelwvbLnMMR9CiB+v0flB4C6gToiHCqWx5BooWJ+EtpkXji29a9ocBcD78cdJ2vAv+StW4DVy5BXHG7hpGdM1jG+2xvN0r0ii/FxrwErkGL4lS+TV2Px8mDFDfpBcJ+9NZZFZaODRb/eSkFPMN6Pbc2dTvyof81ZHCMGyc3nMPJNGgcXKi6F+PB/qh1ZdudkvnOw1/PhkR/q/dZCknsfJ3WjFLTITS4GWr6YF0Nqjbs5P1O7uuN97L+733otNr6do+3aKNmyg8N9/0a1YgeTkhEuPHnKOxGYdKNwE+mPZOHcJwBgbS+H/radw/XqM58tROzRvhu/zz+Haty/2kZE35/GpUsvVmLWeoEuWk/U7uMsiYh17ea1q/PxkwTApCU6fhkaNQF2BegZqSSLc0YFEvYk0gxmbgAa1JH9fbaXAYqXEaiNIa1/3hEOQBXqvcMiOhdxE8GkEkpI9qC6idXGheY/eNO/RG7PRQOKRg5zeu4sz+3ZzYsu/2DloCW/TnkZmGxHvfoCmsIj4tk1olHYW1fHT8ov3pQ+ywrMQuxa6TqqT916VoyN+U6bgPmgQGTNmkvbiZFxW/YX/6zPJ/WEhGn9/3Ab0r2kzK85LL8GKFfDjj6gnTCC0VRsSDh9ACFEtBfriD+3jr4/fw93PnwdnvIOLZ+2OxFCopyxeDOPGwYWQ/aQk+WeomxP0MrIizoanrTU9VYcZrtrE0vw7eXWZXESpPgqI16LCBVMkSYoAjgghakjBKB+K5+F/CCHIWXgCY4IOv8nt0XjU4gIctxBCCBJHPIRVl0/kmjVIV3lDzSs2cceHm2gW6MbAlv7Vb2RuLixdKocmh4XBww9DQNV7/gkgWW/i7/2pFBab+G5MR7o1Urxlq5pkvZGpsalsyi2kvZsTHzUJppmLY5WOGRZho/i2wzg3lfML5W1qSsHeSEJD5fxz9QVhMlG8dx+FG9ZTuOFfrNnZYGeHnX9z1N4BWHNOYE5JAUnCsX07XPv0wbVPX+yDbjxRuaHnYSlDBBRnQsFZkAC3QHDyUbwQLyMnBxISwMVFFhA1FUy7ZxOCZIMJndmKr70GX3sNdkoRmysQQhBbYsAmoEld9Dq8FH2eLNQ7+4B77c1tp1CastxPrRYzKSeOcWbfLk7v3UWJLh+V1YZfvo4Mb0/u276fRunnuOJBtu0T+PdNmHRAFpXrMMJiIXfRT2R9/jmoVIiSEhpMmYL3k0/UtGkVRwjo3FmeA0dHc3TzBtZ/8wVj5nyJT0hYlQ4du2cHqz+bg09IKA+89hZObu5VOp6CwjUJC5MFw8upbxP0y+j2/kZM+WnscZhEDm50NM4HoKGHIzum3VnD1lUuleJ5eB0eArIroR+FakZ/LBtDTB7ugyIU4bAWIUkS3o+NIW3ySxRt3ozrXXdd0cbT2Z4JvRvxwdpo9ibUUNn4oJ7yBrA/D8irtqGFRsLSzps5BXmcTBHc7etOkLburdbXdiw2wbepWXyQcBaVBLMbN+Sxhj7VkmssOVGFSGyDMKnRhmVTeETO6ZOcXOVDVyuSvT0u3bvh0r0b/jNnoj9yhML1G9D99Q/mI8dx6tIZ77Fjcb3rTjQ+VSiUS5Kcl03rAboU0KVCSZ6cuN+uaoXiuoS3t/xRJSRAbCxERVVMQFRJEqFae1IwkWWykGWy4KxW4W6nxl2jxl4REgHIt1gxWAUhjnXU6/BSHD3BVAwlufL/nBK+XG9Qa+wIa92OsNbtuPOJp8nwa8Dphn6caeiPk95A6LnzBXMufZDZbHBwEYR2r/PCIYCk0eD9xOO49u3D2VlvYoyNxWPYgzVtVuUgSXKanocegr//Jrx7NwASDh+oUvHw5LZNrJ37Kf6Nohg6bRZa58pLFaOgUG6uNRFPSvovjLkekp6vR+DFTlsLuqlO0IRkYgghPV9f06ZVK+XJeXgM2fHn4i7AD/ACnhFCLKh88yofxfNQxqa3cPaT/ajdHGgwoQ2Suo5PxusZwmIhrl9/NIEBhP388zXb6UrM2CpaArSsnDgOz78Ahw9D/34wZw4EVo2btt5mY2deEetzdGzOLURnsaJVqbjDy4W+3u49gJW4AAAgAElEQVQ0cXNii66QNVk6ThUbALjN1ZFBPh7c7etOlLMihleUE0V6Jkcnc6RQT19vN96PCqJhNQq0pRY2JQFCvkfV84XNi1hLzGCxoHa7eeGuXJ6HlyKE7B2lSwVhkwUOVz8lxPIS8vMhLk7O0hAVBXYVjDgWQmCw2dBZrOjOC2UAjmoV7hpZSKzsFAF1BSEE0cUGVBJEOWmrJTywyhE2sJpB41DTliiUkZu6n55/kAnkR5jqwnTt0gdZwlb4cTDc/w20HlF5BtcShM32X8Gu+oDFIrudh4TA1q38OGUSjq5uDH/93SoZ7uiGtaz/9iuCm7diyCszsdcqi3kKNcy1PA8v0KGDnB906FBo2rTazKpqur2/kbR8PQ3IxZ1iTiNHDiieh9fmj8t+tgFZwGYhRPTNGqdQM+jWJmArMuMzpoUiHNZCJI0Gz9GPkvn+B+iPHcOxVaurtnN3qoYcWXo9vPkmfPQR+PjAj9/CsGGVHs5YYLGyIaeA1Vn5bMwpRG+z4aFR0y/Qk0E+HvT0csXxkpfn271cmBIeQEKJkTXZOtZk5fNeQgbvJWTQ2MmBgb4e3O3jTmtXx/rxsllN6K02Pkk8y9yUTDw1Gr5uEcq9vjdfRflmmT37kpQq54VDJyd5/62A2skOuS5ZDSBJ4OQFDq5yddiis2DIA/cQcFA8HgA8PKBxYzhzBmJiZAHRvgLauiRJOKrVOKrV+DuA0fqfkHjWaOas0YyDSpKFRDs1jirVLXNfyzVbMdkEYY729eeaJZUiHN4KnH+QSSUlSBeEw8sfZAcXgdYdmt9bIyZWNfVKOATZ1fz552UPxH37CG/TngOrV2LSl2DveGWRw4pwYPVKNi9aQHjbDgye/Op/RXgUFGqSUhP08zg5wdtvg9UKy5bJOfCnT5fFw6FD5a1duzqdCmdK/ya8uuwYmWYvMpHzjTraqZnSv0kNW1a9VDjnYV1D8TwEY1IBWfOO4NItEI/BkTVtjsI1sBYVcaZXb1zuuIOGn3xcM0Zs3Cg/IOLi4MknZW9DT89K6z7LZGZdtiwYbs8rwiwEfvYaBvi4M8jXgy4eLtipyv6gyTCaWJtdwJqsfHbmF2EV0NDBjoG+7tzt40EnD+dqCbmtq2zPK2RKTAoJehMPB3jxemQgnnaVkd3i5rgVi7lVJjfteXg5hgI5lNlqkvMgugXIxR8UKCqSC6io1XKxeYcqeLcz2WwUnBcSi6w2EGB3QUjUqHFW118h0Xbe69BOkmjk5FBvr1Oh9nPT99PrPchKcuHjptB+DAycU7kGK1QdBQUQHAwDB5Iy41V+e+s17n15Oo07dqm0IXYvW8qOpT/RuFNXBj03BbVGKailUIu40QQ9LQ1WrpSFxM2bZVExJET2SLz/fujevWJV52qIFYfSmLMuhvR8PYEejrdkteVyi4eSJN0JNEcOYT4hhNhcYQurkVtdPBRWG+c+P4QwWPGb3B6VQ937x72VOPfBh+QuWkSj9f+HXWBg9Q2cmwsvvww//CCHZ3zzDfTuXSldJ+uN/JOt458sHXt0xQggzNGegT4eDPR1p52bU6XktMo1W1ifXcCa7Hw25xZitAm87TT093FjoK8HPTxdcKhvK+I3SZ7Zwptn0vn1bC7hjvbMaRJMd886UQNL4TpUmngIYLPKFUGLM0FlJ1dkdvSonL7rOMXFsoAoSbIHomMVRpVZbOKikFhotSIEqCUuCokuGnXdzwl4CVkmM+kGMxFODrhqlPmKQs1RqffTC+yeD2unwtPbwf/qESYKtZSXX4b//Q/r6dPMffMVmnbtSd9xkyrcrRCC7b8uYu+K32nWozcDnnkBVR0UWRQULpKTA3//LQuJ69aB0Qi+vnDffbKQeNddVbPyqnDTVIp4KElSQ2A50B5IP787ENgP3C+ESL/WubWJW108LNiUQsG6RLxHN8exuXdNm6NwA8zp6Zzp2w+vRx/Fb9rUqh9QCLmK8vPPywLilCkwc2aF3oblKplG1mTl80+WjqNFcmLZ5s5aBvrKgmEz56rNY1VssbIxt5A1WflsyCmg0GrDRa2ij7csJN7l5YrzLfhiKoRgZWY+M06nkW+xMCG4AS+G+ZcKD1eou1TJy66pGPJTwKKXQ+3cg5SCD8jZHWJj5VtoVJQcwVPVWIWg8LyQWGCxYhOgksDtvJDoqlHXaU9rqxBEFxnQqiUinZQ8tgo1S6XfT4WAeV3l8PVxmyuvX4XqITkZIiLg+edZGeDFufgzPPXV9xWaywqbjU2LFnDon7+47a4B9Bk7of6FfSvc2hQVwdq1spC4erXsxevqCvfcIwuJd98NLkp6nJrmeuJhee5InwNWoJEQIlgIEQw0Pr/v84qbqVDVWHL0FPybjGMLb0U4rCPYBQbiNmAA+b//jrWoqGoHS06GwYPh4YflZN7798O7796UcCiE4FBBCbPj0umxN5qee6P5IOEs9iqJ1yMD2d25GRtvb8rL4f40d6n6nITOGjWDG3gwr0UYx7u3ZPFtEdzXwINteUWMO5FI8x3HGX00nl8zcsg1W6rUltpCqsHEo8cSePpkEkFae9Z1aMJrkYGKcKhwfeydwTcKXAPlcObMaCjOkl+E6xCDBg1CkiSeeOKJ67bbsmULKpUKV1dXEhISrtnO0VEOW1ap5ByIxcUQFhaGJEkkVlGFH7Uk4WGnIdTRgRYujoQ7OeBotfD9ggXcO3gwgUFBOGi1ODs707hxY0aOHMny5cux2WxVYk9lk22yYBECf3slXE+hHpJ2ADJPQrsxNW2Jws0QEgLDh8OCBYQ3bUFhThY5qdeoQlsGbDYr6xd8yaF//qLdwPvo89RERThUqH+4uMCDD8KSJZCZCWvWwIgRsGGD/P/k4wP33gsLF8oeiwq1jvJ4HhYAvYQQBy/b3wH4VwjhXgX2VTq3quehEILs749jSi7Ef3J71O6Ke3BdQX/sOInDhtFg6lS8H3+s8gewWuGrr+C11+Sf33kHnn223LkoLDbBHl0Ra7J0rM3WkWY0o5agm4cLA309GODjjr9D7XoJtArBXl0x/2TpWJ2Vf9HmLu4ucp5EX3cCHOqXV5VVCH5Iy+a9+AxsAl6N8OfJIN867aGkcHWqxPPwUiwG2QvRVCSLiu4hYFc3PMTS09Np2bIleXl5rF69moEDB17Rpri4mNtuu434+Hjmz5/P+PHjb9iv0Sh7IJrNcP/9YSQnJ5GQkEBYWFgVXEVp9u7dy7Bhw0hOTkaj0dCqbTv8goMxmy2kJMQRe/w4AO07dGD/vn1Vbk9FsNgEp4r1uKjVhDs5sHnzZnr37k3Pnj3ZvHlzTZuncAtS6ffTVc/CsT/gpRjQulVevwrVx/790LEjhe/O5pvDO7njkSfoOHhoubuxWiysnfsp0Tu20HnoCLoOf0TJ76pwa2G1wo4dsHy57JWYnCy/h/bsKRdbGTIEGta/3IK1lcqqtgxynsOy7FOoZeiPZGE8nY/HvZGKcFjHcGzVEqcOHcj9aRFejz6CpKnEQgXHjsFTT8GePbKr+Lx5stdhGTFYbWzLK2RNto512TpyzVa0KoleXq5MjQigr7dbjRbcuBFqSaKLhwtdPFx4s1EgR4v0F4XE106n8drpNNq5OXH3+QIuEU51+3/nVJGel2JSOFhQQm8vVz6ICiLEsW5fk0INotGCdyPQ54IuDbKiwdUfXBrI1WRrMYGBgXzxxRc88sgjPPXUU5w4cQIPj9I5HKdNm0Z8fDz9+vUrk3AIctqeJk3+ExCri/3799OzZ08MBgNPPPEE7733Hg0aNEAIgd4mV24+FZ/IvDkf8n/LlxFbbLiYJ1FbC72Ns0xmbIJat+CkoFApGAvh2J/QYqgiHNZlOnSAO+7Adf7X+Dw4iMTD+8stHlrMZlZ/9gFn9u2m+8Nj6DRkWBUZq6BQi1Gr4Y475O2TT+Dgwf+ExEmT5K1TJ1lIvP9+aNy4pi2+ZSnPjPFf4AtJkoIv7JAkKQT43/ljCrUUW4mZ/L/isQt2xblzQE2bo3ATeD3xOJb0DArWraucDg0GmDED2rWD+Hi5atbq1WUSDossVlZm5jH+RCItdhzn0WMJ/J2ZTy8vN75tEcaJ7i1Z2CqC4f5etVo4vBxJkmjt6sS0iAC2dWrGttub8lpEAFYhmB2fQdc9p+i1N5oP4jM4XlhCXapUb7DaeD8+g777Y0jUG5nbPJQlt0UowqFCxZEkcPKGBs1A6wGFGZAVI+dGrOWMGjWKoUOHkp6eznPPPVfq2JYtW/jqq69wd3fnu+++K1e/9vaygHjBcaSgoLIsvjpms5nhw4djMBh47rnn+O6772jQoAEg39ec1GoCHOy5s1kUPy34hh9//wOAs0YzMcUGoov1ZBhNlFitteK+ZrbZyDJb8LBTK2kUFOonx5eBuViusqxQt3npJUhOJszRhdRTJzHpS8p8qtloYOVH73Bm3256PzZOEQ4VFECePLVvL0fCnTwJp07JabSsVpg6VU4s3aoVvPEGHD5c59Lm1HXKMyt7DnAG4iVJSpIkKQmIO7/vueueqVCj5K9JwKY343l/IySV4gZfF3Hp1Qv70FByf1hY8Ze7LVugdWuYPRtGjZJvyiNH/vemexVyTBaWZOTw6NF4Wuw4zvgTSezIK2KonydLbovgRPeWzG0eyj0NPHCuJ1XhGjtreS7Uj3UdmrC/S3PeadwQTzs1nyWdo8/+WG7ffYo3zqSxN78IWy1+cO3MK+KufTH8L+kcQ/082d6pGUP9PJWQGIXKRW0HXmHgFSFXZs6OlUOabdaatuy6zJ8/H19fX3766SdWrVoFyOHKTzzxBEIIPvvsM4KCghBC8NNPP9GrVy88PT3RarVERkYyceJEUlJSrujXzk7eABIT5fpTl1JcXMzs2bNp3bo1zs7OODs706ZNG959911KSsr+8gmwePFiEhISaNCgAR9++OF122rVKob0uZMoZy3NXLQEau3QSBIx6WeZ+NIUIps0RevoiJubG507d2bu3LlYLFfmgZ01axaSJDFr1qyrjrNw4UIkSeKxxx675v7CwkKmTJlCeHg4Dg4ONGzYkGeeeYaYs5kIuJjrsFevXvTu3RuQRV1Jki5uvXr1QghB48aNkSSJ3bt3X/PaH3jgASRJYu7cudf9jBQUqpyDi8C3KQR1rGlLFCrKPfdA48aEb9mOzWoh+fjRMp1m0pew7P1ZJB45SL/xz9Hu7nur2FAFhTpK06bw6quwbx8kJcFnn4G3tywutm0LkZGyiL9jB9SRnM51mTKLh0KIFKAdMBD46Px2txCinRAitYrsU6ggxngdJfvP4dI9CPtApXpRXUVSqfB6bAyG48fRHzhwc53k58O4cdCrF1gs8H//Jyek9b568Zw0g4lvU7N44NAZWu04zuToFE4V63ks0IcVbRtxpFsL5jQJ5k5vN+zreVLnIK09Y4N8Wd62MUe7teSTJsE0cdbyQ2o29x46Q+udJ3glJoVNOQWYasmDS2e28HJ0CkMPn8EsBEtbR/J5s1C86pA3qEIdROsueyE6+0JJNmSeAoOupq26Jr6+vsybNw+A8ePHk5uby9SpU4mPj2fw4MGMGTMGIQSPPPIIo0ePZufOnXTs2JEhQ4YghGDu3Lm0adOGfdfJIejsLDt4Z2fLP2dnZ9OlSxdmzJhBSkoK/fv3p3///iQlJTF9+nS6du1K7uVq43VYuXIlACNGjMDBoezexPYqFb72dpCeyuie3Vn42acUFRTQ8+6BtOnajaPHjjFx4kT6DhiA3mAoc79lQafT0a1bN77//nvatGlDv379KCkpYf78+QwfdDeuQuBw3utwwIAB9O/fHwA/Pz/GjBlzcRswYACSJDFx4kSAawqDaWlprFq1CldXVx599NFKvRYFhXJx7gSk7ZcLpSiLeHUflQpefJGGO3djZ2dPwuEb59U3FBXxxzszSYs+ycBJL9Hqzn7VYKiCQj0gJASeew42b4azZ+Hbb6FZM/jyS+jeXc6L+PTT8juuyVTT1tZLbvgWKUnS3cA84DYhRAGw/vyGJEnukiQlAk8JIdZXpaEK5UdYbOQtP43awwG3PiE1bY5CBXEfMoSs/31Gzg8Lcepw1RymV0cI+PNPuQhKVhZMmQKzZoGT0xVN40oMrMnSsTpLx+FC2fslyknL86F+DPR1p2U1VEau7fjYaxgZ6M3IQG8KLVb+zSlgTbaOP87lsSg9BzeNin7ecrGVXl6u1e6JKYTg7ywd00+nkmO2MCG4AS+H++OkhP8pXMa232LJTqnCKu7CCpZiELmg0oDGAajY/cMn2IUew6Mqx77zPPDAA4wcOZIlS5YwcOBA9u7di7e3NwsWLABg3rx5LFmyBD8/P/79919atGgBgNVq5cUXX+SLL75g2LBhxMTEXFW8CwuTo20SE+VF8UmTJnDs2DF69OjBqlWrLuZazMvL45577mHnzp1MnDiRX375pUz2Hzi/oNSx4815MY0cOZKUlBSGDRvGokWLsHNwoMBi5VRiIiMHDmTzv//y7PQZzHxnNu4aNa6ait/TVqxYwcCBA9m5cycuLvLCZnp6Oh07deLU4cNsW7mMiPMi37Rp0+jcuTPr1q2jadOmLFy48Ir+Hn/8cWbMmMHvv//Op59+ivdli2Jff/01FouF0aNH4+rqWmH7FRRumoOLQG0Pt42oaUsUKosxY1DPmEGowUzC4QMIIa45Vy4p0PHH7JnkpiYzePKrNO7YpZqNVVCoJ/j6wpNPyltBgVy5edky+Pln+PprcHeHwYPlPIn9+1/1vVeh/JTlbXISMOe8cFgKIYQO+AB4oawDSpLURJKk5yVJ+lmSpGhJkmySJAlJkh4sw7kjJUnaJkmSTpKkIkmS9kuSNFGSanlm9hqicEsqliw9Hvc3QmVfP0JJb2VUjo54PPwQRRs3YkpMLNtJqalyhaphwyAwUHb5/vDDizdQIQTHCkv4ID6DO/ZE021PNLPjMwCYHhHA9k5N2dqpKVMjAmjl6nTLC4eX46pRM8TPk29ahHGyW0sWtQpnoI8H/+YU8OTxRFpuP84TxxL4/Wwu+eYrQ/8qm3SDiceOJ/DUiUT87O34p30UrzcKVIRDhZpBUoOdo/yibLPIeRBt1VhFpBx88cUXBAQEsGfPHoQQfPXVV/j5+QHw8ccfA/D2229fFA4B1Go1H330ESEhISQlJfHHH39ctW+1Gho1Ag8P2LNHbqdSqViwYEGpIi2enp4sWLAAlUrFb7/9dtVw6KuRlZUFcDHPYXnYtm0b+/btw9XVlfnz56PValFLEp52Gro2bsTczz8DYOmCb8guKiZJb+JEkZ688/ezm03Z4OLiwnfffXdROATw8vNn2FNyYZotmzaVqz93d3dGjx6NwWC4Ikel2Wy+KARPmDDhpuxVUKgUzAY48is0vQecrx71oVAHcXKCZ54h/NBRCrOzyE27+r27KDeHpbOmkZeWypApMxXhUEGhsnBzg4cegt9+kx1lVq2SRcM1a+SvPj7y159+gry8mra2TlOW+LXbgMnXOb4RmF6OMZ8Bni9HewAkSfoKmAAYkAu0mIG7gC+BuyRJelAIUTviBWsB5qwSCjYl43ibD45NvGraHIVKwmvUKHK/+57cRYvwf/31aze02WD+fJg2TQ5R/ugjeP550GiwCsE+XbFcVTg7n1SDGRXQ2cOF0Q0bcrePOw219tV2TfUFrVpFPx93+vm4Y7EJduuKWJOl459sHWuydWgk6ObhykBfdwb4uONXiVVEbULwY3oOs+PSsQrB65GBjAvyRaPkOFW4DpXtwXddzAbQpYCpCOxdwCNYrtZcS/Dy8uK1117j2WefpX379owYIXsFpaamEh8fj0qlumq4q729PaNGjeK9995j8+bNjBo16qr9q1QQEQGrVm1DCEH79l2IimpyRbvmzZvTqVMndu3axdatW6/ZX2WxZcsWAAYPHoyX15VzhYF3301AQAAZGRnoY07SunMXdBYrlvOiYabJQlzJf5Wb7cqYwqJ9+/b4+/uX2nfWZCaiifyZpKenl/taJk2axLx58/j66695+eWXUZ23ZdmyZZw9e5ZevXrRvHnzcveroFBpnPoLDPlKoZT6yKRJhH35OQAJh/bjHVQ64qsgK5Pf355OsS6foa+9SXDzVjVhpYJC/cfRUfY4HDxYfgfeulWu3Hxh02jgzjtlMfG+++CyuYjC9SnLLM8XuJ4oJ4DyLJ8dB+YAI4BGwJYbnSBJ0gPIwuFZ5PDpe4QQ9wONgVPA/cCz5bChXiOEIH/5GSSNCo/BkTVtjkIlovH1xW3wYPKXLcdyrZWTkyehRw+YOBE6d4bjxzG9+CIbdSVMiUmh9Y4TDDl0hh/Ssmnm7MgnTYM52q0ly9o2YmyQryIcVgIalUR3T1fejQriQJfmrGnfmKeDG5BiMDE1NpU2O08w+MBp5iVnkqQ3VmismGID9x08w6uxqbR3c2bz7U2ZENJAEQ4Vahd2WvBuBO7BYNZDZjQUnoVatOZ3wQvuUm+4tLQ0AAICAtBqry52RkRElGp7LVQqMJnkNj4+4aSmXr1IYFn7u4Cvry8AmZmZZWp/KRfGCA8Pv2abC/akp6fjqlETpLXH53zuVGe1CpNNkGYwc7LIwOliA5lGM+Yb5H4NCSn9Yl1itaIzW2noKXtiGm4ix2Lz5s3p06cP8fHxrF279uL+C3kQL+RFVFCoMQ7+CB6hEHZHTVuiUNn4++M29EG8C4pI2Fe6cFNeRhq/vjEVfVEBD05/WxEOFRSqiwtC4RdfQHIy7N4tF1eJj5dzIwYGyrkSP/5Y3qdwQ8oiHqYiex9ei9uAss1wASHEt0KIV4QQvwkh4sp42qvnv04VQpy+pK9zyJ6MANOU8GWZkoOZGON1uN8djtpVEYLqG16PjUEYDOQvXVr6gNEo5zJs0wZiYij+6Sf+/nkpEwxqWu44zsij8Sw7l0c3TxfmNw/lRPeW/HRbBCMDvPGxV4poVBUqSaKdmzMzIgPZ0akpm29vwpRwfww2G2/GpdNp9ynu2hfNxwlnOVWkL3M1baPNxpyEDPrsiyFOb+DzZiH82jqCUMeyF0xQUKhWJAmcfeSCKlp3KMyArBg5nLmWU1kpGy504+goce6cPJetaLH29u3bA1y3aMuN7Srf9V1o76pR09RZS5SzFj8HO2xAhtFM+vlFEb3Vht5qu+K+prrMQ/Gs0YJaAo8KFnR69ll5HfmCYHj8+HG2bt1KYGAgQ4YMqVDfCgoVIicOErdBu0fllQSF+sfkyYSnnyMt9hQmgx6A7OREfn1jKhaTkeGvv0dgVNMaNlJB4RZFpYJOneD99yE2Fo4dgzffhOJiePlluWpz27bw1ltw/HjFJ2f1lLI8vVYDb0uS5Hj5AUmSnIC3zrepEiRJCgLaAybg98uPCyG2IIuX/kDnqrKj1rN4MYSFYXX2RPfzAeydjDh3VNxw6yPaqCicIyLI/fR/2NRqORv/G29A27bkf/wJv702i8fWbqdFcCvGnkhic24Bg3w9WNQqnBPdWvJ1izCG+HlWStJ7hfIhSRJNnR2ZHObP+o5N2NO5GbMiA3FRq/ko8Sy998XQdc8p3o5L54Cu+Jr5xPbkF9FnXwwfJ57j3gYebL29GcP9vZSclAp1A7UdeIWDZwTYrJAdC7pU+ftaRsOGDQHZ685ovLqXcPz51eoLbcvS37lz8fj7y6l5YmLg6FHYv1/+Ghtb9v4A7r33XgCWLl16TRtvZE/8dVbcr3Z99vbywmRRURGSJOGoVuHvYEcTZy1NXbQUpstrynqbjdhiA9HFBtINJozWKz0Siy1WCi1WfO3tUFfwHnbPPfcQHh7OP//8Q2Ji4kURcdy4cWg0yiKZQg1y6CeQVNDmkZq2RKGqaNmScK0LViFIjgznXPOmLJ0+GUmlYsSs92kQFlHTFlYZKw6l0e39jYRPW0239zey4lCZ/YoUFKofSYKWLWHmTDh0SPY6/PhjcHaWHXFatYImTWDqVNizR04HBhf1FlQq+evixTV4ETVDWcTD2YA7ECtJ0lRJku47v00DYs8fe7cKbWx7/usJIYT+Gm32Xdb21mLxYhg3DpKS0PV6BpvGEc8FzyH9sqSmLVOoChYvxmv3bqySRIGLK+cKi1l4+BTDx79Ey5VbeK7nQI6arIwK8ObPNpEc7dqST5uG0M/HHa1SOKNWEerowNMhDVjZrjFHurZgTpMgwhwd+Dolk0EHT9Nu50mmxaayLbcQs01QYLHySkwK9x06g95mY8ltEXzVPFTxHFWomzi6y16ITj5QnAVZ0WDQ1bRVpQgKCiIiIgKbzcbPP/98xXGz2czi85PHXr163bC/Hj16IEkSu3fvprg4Fk9PKCoCk0k+HhNzigMH9qBSqbjjjrKFNo4aNYrQ0FAyMzOZOnXqDdtv27bt4vc9e/YE4K+//iLvKqkw1q1bR0ZGBi4uLhc9HOE/ITE6OvqKc+wliW0b1gPgoVHTUGuHg0oiy2zhnEkumFNstVFosWITggyjGY1Kuu597IJYabFcv/CUSqViwoQJ2Gw25syZw88//4ydnR3jxo277nkKClWK1QyHl0Dj/uAWUNPWKFQVixfT8Ohx7MwWDkSF81uTUOzzdTzUrusVORDrEysOpfHqsmOk5esRQFq+nleXHVMERIW6Q3g4TJ4M27dDerpcNyA8HD75RE4BFhwM/frJlZ2TkmSvxKQkWX+5xQTEGyoJQohMoCtwDFkkXH5+mw0cBbqfDx+uKi4k4km6Tpvky9reWkyfDiUlGELaUdLqblz3/oJd6il5v0L9Y/p0nPNyMak1HGx5G22WrmXaC6+R5uvHM6F+/NM+igNdmjM7Kohunq5K7rs6QgMHOx4N9OGX1pGc6NaSL5uF0N7diaUZOQw7EkerHcfptucUP6fnMD7Ily0dm3Knt1tNm62gUDFUarl4indj2SsnNx5yE+XqzLWEyZPlmnEzZ84sJZZZrVZeeXhfagQAABTSSURBVOUVkpOTCQ0N5cEHH7xhX6GhoTzwwAPYbDaefno8Z8/+J5YWFubz3nvjsdls9Os3nODg4DLZZ29vz9KlS3FwcOCzzz5j7NixV81/mJaWxqRJk0qF7/bo0YOOHTtSWFjIxIkTS3kupqWl8cILLwByMZJLcz727t0blUrF2rVr2bFjR6nPZPr06ezduxeQ0zb42NsR4aSlhbMjXucFQpPNRnyJkRNFeoqtNvzsNdf1OrwgVp45c+aGAuKTTz6Jk5MTc+fOpbCwkCFDhhAQoAg2CjVI7DooOgftRte0JQpVyfTpqA0GQjKzSW3gjZPRxIiNO/F49/2atqxKmbMuBr25dOSA3mxlzrqYGrJIQaEC+PvD+PGwbh1kZsoVmjt1gg0b5BRhl1Ly/+3df5RXZZ3A8fdnGEQEgeFXKjpjKrlK6oqQui0BoW6G/bDUdZVctzy2g6Z7WtS1WrWy/HG0lAQLw1VPyjnpmlj2yxJI1CwQf5S6mT/ADPMHkuIgOPLsH/eOfRnvDDMw8/3OfOf9Ouc5d+Y+93Pn+Q53Hu73833u8zT1uXxLh4arpJRWAh+OiDqyRU4CeCKlVI61rltmLm9vUqR1+XbHosqIOBU4Fd45SXdVWJXlTpuH70rtS08z5N7rN9uvKrNqFQH8efgoakl86buzOezXS3nPqqeJLUxSr95haP9ajtlpOMfsNJymtzaxZM2r3PHiX3n5zWbOfvfOHDhkh0o3UepaAwbDqL2zN9jr19KxByPKY+bMmdxzzz0sWLCAAw44gClTpjB8+HB+85vf8NRTT1FXV8fNN9/MgAEdm2/06quv5vHHH2fx4sVMn74H48dPAWD58kW8+uorjB17ALNmzelUGw8++GAWLVrEcccdx/z587n++uuZOHEi9fX1NDc38+STT/LQQw+RUuKQQzaf4eWmm25i6tSpLFiwgMWLFzNp0iSamppYtGgRr7/+OtOmTeOCCy7YLKa+vp7GxkbmzJnD1KlTmTRpEkOGDOGBBx7glVde4YwzzmD27NmbxdTWBIP7ZdNlDOtfy+4Dt8tXbobhW5jrsKGhgQMPPJAVK1aw//77c9BBBzFgwAD23ntvzjrrrM2OraurY8aMGcybNw9woRT1AOueh5HvgbFHVLol6k75+67xf3gGgMOW/47Bb2yo+vdjf15b/GBgW/ulXqOuDmbMyEpbc9VW+d93a5161i1PFm79jNwVklKaB8wDmDBhQvXNfllfDytXMvjB2xn08B1Ey7xR1Zgo1dv/3v+0dBEBHN6yv6Ghgo1Sd9mhXw1HjhrGkaOGVbopUveKGthxZxj8ruzrHiIiuPHGGznyyCO55ppruP/++1m/fj277LILjY2NnHvuuR0eJQgwcuRI7rvvPq644gpuuOH73HvvTwCorx/LjBmzOP74Mxk6dFCn23nooYfyxBNPcN1113H77bfz0EMPsXz5cvr168eYMWM44YQTOP7445k+ffpmcXvttRcrVqzg0ksvZeHChSxcuJD+/fszbtw4TjrpJE499VT69+//jp83e/Zs6uvrufbaa1m6dClDhgxh6tSpXHjhhdx7773ttjXIPiQZ2okFUm699VbOOecclixZwoIFC3jrrbeYPHnyO5KHAIcffjjz5s1j3Lhxbz+aLVXMxFPgoE+7UEq1y+/P6198mfoXX958fxXbZdhAnitIFO4y7B3LJUi9V/73Xbi/D4mOruzZbQ2IWAxMBo5NKd1SUH8GcCVwW0rp6DbOcSVwBnB5SmlWez9vwoQJadmyZdvc7h6lZc7Dpqa/7dthB5g3D048sXLtUvfw31tSBzz22GPss88+lW6G2vHyy9m9aOmg8Zqa7LOgESMq167e7uijj+a2225j7ty5NDY2Vro5qgL2p9qiPnp/3jLnYemjywP79+OiT+zHxw/s2MJfUo/Xh/6+I2J5SmlCUV1v+AjsmXzb3rCqlo/8n2nnmOp14onZhdvQkK0e1NBQlReycv57S1JVGDEi68Lz9UDYbjsTh9tq+fLl3H777YwYMYKTTnKOOUll0kfvzz9+4Bgu+sR+jBk2kADGDBto4lDVp4/+fbfWG0Ye7ka2IMpGYFjRissR8SywK9niLfe0ri9VlSMPJUlqxZEy6ktOOeUU1q1bx49//GNee+015syZw8yZMyvdLFUJ+1NJUl/Q3sjDTs15WAkppWcj4gFgPHAscENpfURMJkscPg/cV/4WSpIkqZLmz59PTU0NDQ0NnHfeeSYOJUmSulCPTx7mLgJuBi6JiHtTSn8EiIjRwNz8mItTSi41K0mS1MdU+kkaSZKkalb25GFEjOdvCT+AffPt1yPi7cVOUkqHlHx9S0RcDTQCj0TEL4A3gWnAEOA24KrubrskSZIkSZLUl1Ri5OEQ4OCC/WPbC0opzYyIpcBpZHMk9gMeB64FrnbUoSRJkiRJktS1yp48TCktBmIrY28CburSBkmSVKVSSkRs1X+5kiR8JF6SJICaSjdAkiR1vZqaGjZtclC+JG2LTZs2UVPjWyZJUt/m/4SSJFWh7bffnqampko3Q5J6taamJgYOHFjpZkiSVFEmDyVJqkKDBw9m7dq1PnInSVsppcTatWsZNGhQpZsiSVJFmTyUJKkK1dXV0dzczOrVq9mwYYNJREnqoJQSGzZsYPXq1TQ3N1NXV1fpJkmSVFGVWG1ZkiR1s5qaGnbbbTfWrFnDqlWraG5urnSTJKnXqK2tZejQoYwePdo5DyVJfZ7JQ0mSqlRtbS2jR49m9OjRlW6KJEmSpF7Kj9EkSZIkSZIkFTJ5KEmSJEmSJKmQyUNJkiRJkiRJhUweSpIkSZIkSSpk8lCSJEmSJElSIZOHkiRJkiRJkgqZPJQkSZIkSZJUyOShJEmSJEmSpEImDyVJkiRJkiQVipRSpdtQVhHxIrCy0u3oRiOBlyrdCPUJXmsqF681lYvXmsrFa03l4rWmcvFaU7l4rXWfhpTSqKKKPpc8rHYRsSylNKHS7VD181pTuXitqVy81lQuXmsqF681lYvXmsrFa60yfGxZkiRJkiRJUiGTh5IkSZIkSZIKmTysPvMq3QD1GV5rKhevNZWL15rKxWtN5eK1pnLxWlO5eK1VgHMeSpIkSZIkSSrkyENJkiRJkiRJhUweSpIkSZIkSSpk8rCMImLviDgzIr4XEY9HxKaISBFxzBbidouIqyLiyYjYEBEvRcTPImJ6T4qT1LdERP+ImBYRl0fEsoh4NSI2RsRzEXFLREzZQvwJEXF3RPw1Itbl5zgtItr9vykiPhQRP4+INRHRFBG/i4gvRsSATrT9iLz/TRHxo47GSapuvalfi4gdIuLciHgwIl6PiNci4rcR8bmI6LeVvwJJVabc/Vr+XrIxIuZHxMMR0Zzfb83airafWnK/dlVn4yV1Hec8LKOIuAI4s6Dq2JTSLW3ETAR+CgwHVgIPADsBE4Fa4CsppfMrHSep74mIw4A782+fB5YDrwP7Au/N9381pXReQewcYCbwBvBL4E1gGrAj8APgmJTSpoK4s4FLgLeAxcArwGRgFPBrYFpKqWkL7R4KPALsCgRwR0rpqI6+bknVq7f0axExHLgLOCA//tdk92kHA0Py13BUSmnjVvwaJFWRcvdrEfEfwDcLmnJWSumyTrS7gex+bTDZ/dqclNLpHY2X1MVSSpYyFeAU4FLgOGBPshvERNbpFh2/PbAqP2Y2UFtS9w9kN4sJOLyScRaLpW8W4IPALcCkgrp/BprzPmNqq7pP5vtXA2NL9r8LeDSvO7PgnBOATWQ3vAeX7B8MLMnjvtmBdl9L9ib96jzmR5X+XVoslp5Reku/Bnw/r/sVMLJk/xiyD34T8LVK/z4tFkvlSwX6tY8BVwCfAvYBbsiPndWJNgfwC2AdcF0ef1Wlf5cWS18uFW9AXy5sOXn4L3n9H4H+BfWz8vq7KxlnsVgsRQX4bt5nzG+1f1m+/6SCmMklN6o1repuyevOK4jbgywhuAEY1k6bjszPcTlwMiYPLRZLJ0pP6NeAXcgSjs2lb+hL6ifk52wCdqz078xisfTs0tX9WsGxLcm/ziQPG/OYzwEXmDy0WCpfnPOwZ5uYb5eklN4sqP95vn1/ROxUwThJKrIi3+7asiMidgUOAjYCN7cOSCktAZ4jmy7hkJK47cgSfwA3FsQ9BdwHbAd8uKgxETEMuIbsA5IvdfrVSFLP6NcmkI3KWZlSeqIgbhnZ0yIDaaM/lKQSXdavdYWIeDfZ03pLAec5lHoIk4c92+B8+1Ib9S37AxhfwThJKjI2364u2Xdgvv19Sml9G3G/bXUswN7ADsCalNKTnYgrdSXZiJ1T2vnZktSentCvbel+rbTuoHaOkSTo2n5tm0REkE0vUwt8JqXkAg1SD1Fb6QaoXS/k2z3aqN+z5Ot3VzBOkjaTj04+Of/2f0uqWvqOle2Er2p1bOnXq2hbUVxLez4CnAR8O/+0XJI6pQf1a+3er0VELdBQECdJm+mGfm1bnQ5MAf4rpfSHLjyvpG3kyMOe7a58Oz0fOt5aY8nXQyoYJ0lvy9+4fg8YCvwypfTDkuqWETOvt3OKdfl2xy6IIyLqgO8AzwJntxMvSYV6WL92P9l8hiMj4pMFMZ8me9QZvF+T1IZu6te2pT17AheTzbXY4VWZJZWHycMeLKV0F9kqegOBOyNiWkTsGBF7RcS3yBY4aZmbcFOl4iSplW8D08iSdTMq3BaAbwE7A59NKb1W6cZI6pV6TL+W92OX59/Oj4iTI2JUROwUETOBb+L9mqQt6zH9Wsnjyv3JHld+q5LtkfROPrbc8x0L3Aq8n2y5+lJXAP9INnH2mgrHSRIRcSXwGeB5YFpK6flWh7R8Sj2ondO0fNpdmujbqriI+BhwInBDSukn7cRKUqGe1q/lvgyMAv4d+J9Wdb8CHgM+i/drkgp0Y7+2tc4APgB8JaX0cBecT1IXM3nYw6WUXoiIScBhwAeBEcBfgIUppWUR8ef80EcqGSdJEXE52c3fi2Q3ou9YBRR4Jt82FNS12K3VsaVf13cy7uh8u19ELG51fMuq8YeW1B2VUlqHJNFj+zXyUTmNETEX+Gh+jnXAYuAOskcRwfs1Sa10c7+2tVru1w6PiMmt6nZvOSYi3gusSykd1QU/U1InmDzsBfJVpu7My9vyeSF2Bl4GHqh0nKS+KyIuBT5P1j8cllJ6tI1DV+TbcRExsI0V/Ca2OhbgcWA9MDwi9mxjZdL3FcS1aG8lwOFAy42q/y9KAnpFv0ZK6RFaJQjzx//en3975zuCJPVZZejXttWh7dTtkpe/duHPk9RBznnYu83Kt/NSSht7cJykKhYRFwNnAa8Ah7f3uElK6VmyDx+2I5smofW5JgO7kj1Gc19J3Eag5bHjEwvi9iC74dxINuqmJe7klFIUFeDf8sPuKNm/tjOvXVJ16sn9WgccRzYS8b6U0vJOxEmqYuXo17ZWSmlKO/drX84Pm5PvG7atP09S55k87OEiYr+IGNRqX21EfJFsLps/Al+rdJykvikiLgTOAdaS3Yh25NPni/LtJRGxV8m5RgNz828vTim1nuj/YiAB50TE+0riBpNNsl0DzDUBKGlb9IZ+LSIaImLngrZ/BJgHbCCbD1GSyt2vSapCkT2hqnKIiPH8raMF2JdsafsnKJnQOqV0SEnMdWSf9jwAPEe2EvIhwOg87oiU0jMFP6uscZL6noj4KLAw/3YZ8Ps2Dn08pXRxq9i5QCPwBtniTG+Srfg3BLgNOKZopb2IOBu4BHgLuIvsJngyWR91P/DBlFJTB9t/MtlCA3c4d44k6D39Wt5/zQceBFYCzcD+wN5kixccm1L6WSdeuqQqVe5+Lf9g4wclu/YERgKrgNUl+49OKZV+31b7LwDOJxt5ePqWjpfUPZzbqbyGAAcX7B/bTsxtZJ3tAWTzSrwB/B9wKVkH+kYPiZPU9wwv+XpCXoosIRtd87aU0syIWAqcRvYmuR/Z/F/XAle39Sl2SunSiHgY+E+yPmp74ClgNnBZSmnD1r8cSeo1/dpyYAHZfeURZCMUVwLfyGO2+IZcUp9R7n5tAMXveevZfIGoAR1qvaQewZGHkiRJkiRJkgo556EkSZIkSZKkQiYPJUmSJEmSJBUyeShJkiRJkiSpkMlDSZIkSZIkSYVMHkqSJEmSJEkqZPJQkiRJkiRJUiGTh5IkSZIkSZIKmTyUJEmSJEmSVMjkoSRJkrZaRFwXESkvb0bECxGxKCJOi4j+nTjPlPwcI7uzvZIkSeock4eSJEnaVr8AdgZ2B44Afgh8Gbg7IgZVsF2SJEnaRiYPJUmStK02pJSeTyk9l1J6MKX0DWAKMB44GyAiZkTEbyPitXx04s0RMSav2x1YlJ/rxXwE4nV5XUTE2RHxZESsj4hHImJGmV+fJElSn2XyUJIkSV0upfQ74KfAJ/Nd2wHnAwcARwEjgQV53bMlx40jG8V4Zv79hcBngNOAfYGLgO9ExPRufgmSJEkCaivdAEmSJFWtR4HDAFJK15bsfyoiGoHHImLXlNKfImJNXvdCSuklgPyR588DR6SU7s7rn46I95ElE+8oy6uQJEnqw0weSpIkqbsEkAAiYjzZyMO/B4bndQD1wJ/aiN8X2B74aUSkkv39gWe6ob2SJElqxeShJEmSusu+ZKMMBwE/I1tY5VPAC2SPLd9N9jhzW1qm2PkIsKpV3Ztd21RJkiQVMXkoSZKkLhcR7wU+RDZn4d+RJQu/kFJ6Oq//RKuQjfm2X8m+R4ENQENK6a7ubbEkSZKKmDyUJEnSthoQETuRjRQcBUwDvgAsBy4DdiBLAp4eEXOAfYCvtjrHSrJHnKdHxA+B9Sml1yLiMuCyiAjgV8Bg4BBgU0ppXve/NEmSpL7N1ZYlSZK0rQ4DVpM9WvxL4KPABcAHUkqvp5ReBP4V+DjZaMLzyRZCeVtK6bl8/9eAvwBX5VX/nZ9rFvB74E6ylZmf7s4XJEmSpEyklLZ8lCRJkiRJkqQ+x5GHkiRJkiRJkgqZPJQkSZIkSZJUyOShJEmSJEmSpEImDyVJkiRJkiQVMnkoSZIkSZIkqZDJQ0mSJEmSJEmFTB5KkiRJkiRJKmTyUJIkSZIkSVKh/wdnzdsfqLN7hgAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "BtHUpG0bS1bq", - "colab_type": "text" - }, - "source": [ - "# Part 2: Comparing imputation methods\n", - "\n", - "We will compute approximate values for missing values in the time series. This is called [imputation](https://en.wikipedia.org/wiki/Imputation_(statistics)). We can calculate the imputation accuracy by comparing the imputed values with real values. Although in practice we don't hold the original values, we can determine the accuracy by artificial missing points. \n", - "\n", - "When sampling in Part 1, we made sure to only keep statistical variables for which some counties had time series holes, and some did not.\n", - "\n", - "In this step, we're going to utilize the counties with no missing values. We will artificially remove some of the dates and use the imputation methods to fill them. Then, we can compute the accuracy of each imputation method by comparing with the original (removed) values. Note that we want to compare the $R^2$ scores of different imputation methods and it's crucial to use \n", - "the same set of missing points for all of methods. \n", - "\n", - "In this notebook, the $R^2$ score $\\in [-\\infty , 1]$. Higher $R^2$ scores denote higher accuracy imputation. \n", - "\n", - "\n", - "You can learn more about $R^2$ score in [Coefficient of determination](https://en.wikipedia.org/wiki/Coefficient_of_determination). In short:\n", - "\n", - "$$ R^2 = 1- \\frac{\\sum{(y_i - f_i)^2}}{{\\sum{(y_i - mean)^2}}} = 1- \\frac{\\sum{(err)^2}}{{\\sum{(y_i - mean)^2}}} $$\n", - "\n", - "where $y_i$s are the actual values and $f_i$ are the imputed ones. $mean = \\frac{1}{n} \\sum{y_i} $." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "wi1jY4lzQ129", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 445 - }, - "outputId": "03a0953f-4540-45f9-d9c5-93ffed8f550e" - }, - "source": [ - "_METHODS = [\"Mean\", \"Median\", \"Spline_d1\", \"Spline_d2\", \"Spline_d3\", \"Spline_d4\", \n", - " \"Time\", \"Spline_d5\", \"InterpolateLinear\", \"Pchip\", \"Krogh\", \"InterpolateAkima\"]\n", - "\n", - "import warnings; warnings.simplefilter('ignore')\n", - "score = artificial_score_generator(random_stats)\n", - "pd.set_option('display.float_format', lambda x: '%.2f' % x)\n", - "score" - ], - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "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", - "
methodAverage of 20 rounds for Count_Death_85Years_EndocrineNutritionalMetabolicDiseases_FemaleAverage of 20 rounds for Count_Death_55To64Years_Male_WhiteAverage of 20 rounds for RetailDrugDistribution_DrugDistribution_PoppyStrawConcentrateAverage of 20 rounds for Count_Death_MentalBehaviouralDisorders_White
0Time0.890.880.670.94
1InterpolateLinear0.890.880.670.94
2Spline_d10.860.870.740.92
3Mean0.760.770.790.77
4Median0.750.750.780.75
5Pchip0.740.79-0.370.88
6Spline_d2-0.350.130.710.50
7InterpolateAkima-23.53-20.34-22.56-19.25
8Spline_d5-101.00-101.00-101.00-101.00
9Spline_d3-101.00-101.00-0.04-101.00
10Krogh-101.00-101.00-101.00-101.00
11Spline_d4-101.00-101.00-11.02-101.00
\n", - "
" - ], - "text/plain": [ - " method ... Average of 20 rounds for Count_Death_MentalBehaviouralDisorders_White\n", - "0 Time ... 0.94 \n", - "1 InterpolateLinear ... 0.94 \n", - "2 Spline_d1 ... 0.92 \n", - "3 Mean ... 0.77 \n", - "4 Median ... 0.75 \n", - "5 Pchip ... 0.88 \n", - "6 Spline_d2 ... 0.50 \n", - "7 InterpolateAkima ... -19.25 \n", - "8 Spline_d5 ... -101.00 \n", - "9 Spline_d3 ... -101.00 \n", - "10 Krogh ... -101.00 \n", - "11 Spline_d4 ... -101.00 \n", - "\n", - "[12 rows x 5 columns]" - ] - }, - "metadata": { - "tags": [] - }, - "execution_count": 5 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "xvZASllBtHUH", - "colab_type": "text" - }, - "source": [ - "You can sort the above **`score`** table by different statistical variables. The current table is sorted by $R^2$ values of the first variable. " - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "yvJSW-YF-J4K", - "colab_type": "text" - }, - "source": [ - "# Conclusion\n", - "\n", - "In this notebook, we used Data Commons to survey the missing value patterns across different time series. In our experiments, a time series might have random disjoint missing values, a missing interval (consecutive dates), or even multiple missing intervals. \n", - "\n", - "\n", - "We used cross-validation to evaluate multiple imputation methods. The method with the highest $R^2$ score may differ by time series. Although the best method might change across runs, in our experiments, we observed that in most cases **time**, **interpolate linear**, **mean**, and **median** perform well. Note that the linear method \"ignores the index and treat the values as equally spaced.\" ([pandas.Series.interpolate](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.interpolate.html)) thus, for equally spaced data series time and linear will have the same result. \n", - "\n", - "While performing imputation, we recommend to avoid any method with a negative score for a time series." - ] - } - ] -} \ No newline at end of file diff --git a/README.md b/README.md index 018bbb5c..08d1f9d1 100644 --- a/README.md +++ b/README.md @@ -2,123 +2,19 @@ This is a Python library for accessing data in the Data Commons Graph. -> See also: [Data Commons Pandas API](datacommons_pandas/README.md). - - -To get started, install this package from pip. - - pip install datacommons - -Once the package is installed, import `datacommons`. - - import datacommons as dc - -If you would like to provide an API key, follow the steps in -[Setting up access to the Data Commons API](https://docs.datacommons.org/api/setup.html), -add the following line to your code: - - dc.set_api_key('YOUR-API-KEY') - -Data Commons *does not charge* users, but uses the API key for -understanding API usage. - -For more detail on getting started with the API, please visit our -[API Overview](http://docs.datacommons.org/api/). - -When you are ready to use the API, you can refer to `datacommons/examples` for -examples on how to use this package to perform various tasks. More tutorials and -documentation can be found on our [tutorials page](https://datacommons.org/colab)! +See the `datacommons-client` [README](datacommons_client/README.md) for details on installation and usage. ## About Data Commons [Data Commons](https://datacommons.org/) is an open knowledge repository that provides a unified view across multiple public data sets and statistics. You can view what [datasets](https://datacommons.org/datasets) are currently ingested -and browse the graph using our [browser](https://browser.datacommons.org/). +and browse the graph using our [browser](https://datacommons.org/browser). ## License Apache 2.0 -## Development - -The Python API currently supports `python>=2.7`. - -To test, run: - -``` -$ ./run_tests_local.sh -``` - -To debug the continuous integration tests, run: - -``` -$ cloud-build-local --config=cloudbuild.yaml --dryrun=false . -``` - -Both commands will run the same set of tests. - -To run the examples: - -``` -$ python -m datacommons.examples.XXX -``` - -where XXX is the module you want to run. - -## Release - -Note: Always release `datacommons_pandas` when `datacommons` is released. - -**If this is your first time releasing to PyPI**, please review the PyPI guide -starting from the -[setup section](https://packaging.python.org/tutorials/packaging-projects/#creating-setup-py). - -### Release to Test PyPI - -1. In [setup_datacommons.py](setup_datacommons.py) and - [setup_datacommons_pandas.py](setup_datacommons_pandas.py): - - Append "-USERNAME" to the package "NAME". For example, - `NAME = 'foo_package-janedoe123'`. - - Increment the "VERSION" codes to something that has not been used in your - test project. This will not affect the production PyPI versioning. -1. Build the dists: - ```bash - rm dist/* - python3 -m pip install --user --upgrade setuptools wheel - python3 setup_datacommons.py sdist bdist_wheel - python3 setup_datacommons_pandas.py sdist bdist_wheel - ``` -1. Release the dists to TestPyPI: - ```bash - python3 -m pip install --user --upgrade twine - python3 -m twine upload --repository testpypi dist/* - ``` - -### Release to Production PyPI -1. In [setup_datacommons.py](setup_datacommons.py) and - [setup_datacommons_pandas.py](setup_datacommons_pandas.py): - - Revert the package name to `datacommons` and `datacommons_pandas` - - Update and double check "VERSION" -1. Update [CHANGELOG.md](CHANGELOG.md) and - [datacommons_pandas/CHANGELOG.md](datacommons_pandas/CHANGELOG.md) -1. Build the dists: - ```bash - rm dist/* - python3 -m pip install --user --upgrade setuptools wheel - python3 setup_datacommons.py sdist bdist_wheel - python3 setup_datacommons_pandas.py sdist bdist_wheel - ``` -1. Release the dists to PyPI: - ```bash - python3 -m pip install --user --upgrade twine - twine upload dist/* - ``` - ## Support -For general questions or issues about the API, please open an issue on our -[issues](https://github.com/google/datacommons/issues) page. For all other -questions, please send an email to `support@datacommons.org`. - -**Note** - This is not an officially supported Google product. +For questions, please send an email to `support@datacommons.org`. diff --git a/cloudbuild.yaml b/cloudbuild.yaml index 1d09ed16..40b3fe0e 100644 --- a/cloudbuild.yaml +++ b/cloudbuild.yaml @@ -1,8 +1,7 @@ steps: - -- id: api_python - name: python:3.7-slim - entrypoint: /bin/sh - args: - - -c - - 'pip3 install -r requirements.txt && python3 -m pytest' + - id: api_python + name: python:3.10-slim + entrypoint: /bin/bash + args: + - -c + - "./run_test.sh -s && hatch run test:all" diff --git a/datacommons/README.md b/datacommons/README.md new file mode 100644 index 00000000..218c00d4 --- /dev/null +++ b/datacommons/README.md @@ -0,0 +1 @@ +**DEPRECATED: This library has been deprecated. Please migrate to the [datacommons_client](https://pypi.org/project/datacommons-client/) library. For help on translating your requests, see the [Migration guide](https://docs.datacommons.org/api/python/v2/migration.html).** diff --git a/datacommons/__init__.py b/datacommons/__init__.py deleted file mode 100644 index 93d61ab4..00000000 --- a/datacommons/__init__.py +++ /dev/null @@ -1,34 +0,0 @@ -# Copyright 2017 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -################################## IMPORTANT ################################# -# All user-facing functions in this package must be symlinked to the # -# datacommons_pandas pkg. This is so that users do not need to import both # -# libraries for pd support. Please keep the below imports in sync with the # -# __init__.py in the datacommons_pandas/ dir, and add a symlink when # -# creating a new file. # -# TODO: https://github.com/datacommonsorg/api-python/issues/149 # -############################################################################## - -# Data Commons SPARQL query support -from datacommons.query import query - -# Data Commons Python API -from datacommons.core import get_property_labels, get_property_values, get_triples -from datacommons.places import get_places_in, get_related_places, get_stats -from datacommons.populations import get_populations, get_observations, get_pop_obs, get_place_obs -from datacommons.stat_vars import get_stat_value, get_stat_series, get_stat_all - -# Other utilities -from datacommons.utils import set_api_key diff --git a/datacommons/core.py b/datacommons/core.py deleted file mode 100644 index 75060388..00000000 --- a/datacommons/core.py +++ /dev/null @@ -1,258 +0,0 @@ -# Copyright 2017 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -""" Data Commons Python API Core. - -Provides primitive operations for working with collections of nodes. For a -collection of nodes identified by their dcids, this submodule implements the -following: - -- Getting all property labels -- Getting all property values -- Getting all triples -""" - -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - -from collections import defaultdict - -import datacommons.utils as utils - -# ----------------------------- WRAPPER FUNCTIONS ----------------------------- - - -def get_property_labels(dcids, out=True): - """ Returns the labels of properties defined for the given :code:`dcids`. - - Args: - dcids (:obj:`iterable` of :obj:`str`): A list of nodes identified by their - dcids. - out (:obj:`bool`, optional): Whether or not the property points away from - the given list of nodes. - - Returns: - A :obj:`dict` mapping dcids to lists of property labels. If `out` is `True`, - then property labels correspond to edges directed away from given nodes. - Otherwise, they correspond to edges directed towards the given nodes. - - Raises: - ValueError: If the payload returned by the Data Commons REST API is - malformed. - - Examples: - To get all outgoing property labels for - `California `_ and - `Colorado `_, we can write - the following. - - >>> get_property_labels(['geoId/06', 'geoId/08']) - { - "geoId/06": [ - "containedInPlace", - "geoId", - "kmlCoordinates", - "name", - "provenance", - "typeOf" - ], - "geoId/08",: [ - "containedInPlace", - "geoId", - "kmlCoordinates", - "name", - "provenance", - "typeOf" - ] - } - - We can also get incoming property labels by setting `out=False`. - - >>> get_property_labels(['geoId/06', 'geoId/08'], out=False) - { - "geoId/06": [ - "addressRegion", - "containedInPlace", - "location", - "overlapsWith" - ], - "geoId/08",: [ - "addressRegion", - "containedInPlace", - "location", - "overlapsWith" - ] - } - """ - # Generate the GetProperty query and send the request - dcids = filter(lambda v: v==v, dcids) # Filter out NaN values - dcids = list(dcids) - url = utils._API_ROOT + utils._API_ENDPOINTS['get_property_labels'] - payload = utils._send_request(url, req_json={'dcids': dcids}) - - # Return the results based on the orientation - results = {} - for dcid in dcids: - if out: - results[dcid] = payload[dcid]['outLabels'] - else: - results[dcid] = payload[dcid]['inLabels'] - return results - - -def get_property_values(dcids, - prop, - out=True, - value_type=None, - limit=utils._MAX_LIMIT): - """ Returns property values of given :code:`dcids` along the given property. - - Args: - dcids (:obj:`iterable` of :obj:`str`): dcids to get property values for. - prop (:obj:`str`): The property to get property values for. - out (:obj:`bool`, optional): A flag that indicates the property is directed - away from the given nodes when set to true. - value_type (:obj:`str`, optional): A type to filter returned property values - by. - limit (:obj:`int`, optional): The maximum number of property values returned - aggregated over all given nodes. - - Returns: - Returned property values are formatted as a :obj:`dict` from a given dcid - to a list of its property values. - - Raises: - ValueError: If the payload returned by the Data Commons REST API is - malformed. - - Examples: - We would like to get the `name` of a list of states specified by their dcid: - `geoId/06 `_, - `geoId/21 `_, and - `geoId/24 `_ - - First, let's try specifying the :code:`dcids` as a :obj:`list` of - :obj:`str`. - - >>> get_property_values(["geoId/06", "geoId/21", "geoId/24"], "name") - { - "geoId/06": ["California"], - "geoId/21": ["Kentucky"], - "geoId/24": ["Maryland"], - } - """ - # Convert the dcids field and format the request to GetPropertyValue - dcids = filter(lambda v: v==v, dcids) # Filter out NaN values - dcids = list(dcids) - if out: - direction = 'out' - else: - direction = 'in' - - req_json = { - 'dcids': dcids, - 'property': prop, - 'limit': limit, - 'direction': direction - } - if value_type: - req_json['value_type'] = value_type - - # Send the request - url = utils._API_ROOT + utils._API_ENDPOINTS['get_property_values'] - payload = utils._send_request(url, req_json=req_json) - - # Create the result format for when dcids is provided as a list. - unique_results = defaultdict(set) - for dcid in dcids: - # Get the list of nodes based on the direction given. - nodes = [] - if out: - if dcid in payload and 'out' in payload[dcid]: - nodes = payload[dcid]['out'] - else: - if dcid in payload and 'in' in payload[dcid]: - nodes = payload[dcid]['in'] - - # Add nodes to unique_results if it is not empty - for node in nodes: - if 'dcid' in node: - unique_results[dcid].add(node['dcid']) - elif 'value' in node: - unique_results[dcid].add(node['value']) - - # Make sure each dcid is in the results dict, and convert all sets to lists. - results = {dcid: sorted(list(unique_results[dcid])) for dcid in dcids} - - return results - - -def get_triples(dcids, limit=utils._MAX_LIMIT): - """ Returns all triples associated with the given :code:`dcids`. - - A knowledge graph can be described as a collection of `triples` which are - 3-tuples that take the form `(s, p, o)`. Here `s` and `o` are nodes in the - graph called the *subject* and *object* respectively while `p` is the property - label of a directed edge from `s` to `o` (sometimes also called the - *predicate*). - - Args: - dcids (:obj:`iterable` of :obj:`str`): A list of dcids to get triples for. - limit (:obj:`int`, optional): The maximum total number of triples to get. - - Returns: - A :obj:`dict` mapping dcids to a :obj:`list` of triples `(s, p, o)` where - `s`, `p`, and `o` are instances of :obj:`str` and either the subject - or object is the mapped dcid. - - Raises: - ValueError: If the payload returned by the Data Commons REST API is - malformed. - - Examples: - We would like to get five triples associated with - `California `_ - - >>> get_triples(["geoId/06"], limit=5) - { - "geoId/06": [ - ("geoId/06", "name", "California"), - ("geoId/06", "typeOf", "State"), - ("geoId/06", "geoId", "06"), - ("geoId/0687056", "containedInPlace", "geoId/06"), - ("geoId/0686440", "containedInPlace", "geoId/06") - ] - } - """ - # Generate the GetTriple query and send the request. - dcids = filter(lambda v: v==v, dcids) # Filter out NaN values - dcids = list(dcids) - url = utils._API_ROOT + utils._API_ENDPOINTS['get_triples'] - payload = utils._send_request(url, req_json={'dcids': dcids, 'limit': limit}) - - # Create a map from dcid to list of triples. - results = defaultdict(list) - for dcid in dcids: - # Make sure each dcid is mapped to an empty list. - results[dcid] - - # Add triples as appropriate - for t in payload[dcid]: - if 'objectId' in t: - results[dcid].append( - (t['subjectId'], t['predicate'], t['objectId'])) - elif 'objectValue' in t: - results[dcid].append( - (t['subjectId'], t['predicate'], t['objectValue'])) - return dict(results) diff --git a/datacommons/examples/__init__.py b/datacommons/examples/__init__.py deleted file mode 100644 index 7c07b241..00000000 --- a/datacommons/examples/__init__.py +++ /dev/null @@ -1,13 +0,0 @@ -# Copyright 2017 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. diff --git a/datacommons/examples/core.py b/datacommons/examples/core.py deleted file mode 100644 index 6eb4aa10..00000000 --- a/datacommons/examples/core.py +++ /dev/null @@ -1,56 +0,0 @@ -# Copyright 2017 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -""" Data Commons Python API examples. - -Basic demo for get_property_labels, get_property_values, and get_triples. -""" - -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - -import datacommons as dc - -def main(): - # Set the dcid to be that of Santa Clara County. - dcids = ['geoId/06085', 'dc/p/zsb968m3v1f97'] - - # Print all incoming and outgoing properties from Santa Clara County. - print('Property Labels for Santa Clara County') - in_labels = dc.get_property_labels(dcids) - out_labels = dc.get_property_labels(dcids, out=False) - print('> Printing properties for {}'.format(dcids)) - print('> Incoming properties: {}'.format(in_labels)) - print('> Outgoing properties: {}'.format(out_labels)) - - # Print all property values for "containedInPlace" for Santa Clara County. - print('Property Values for "containedInPlace" of Santa Clara County') - prop_vals = dc.get_property_values( - dcids, 'containedInPlace', out=False, value_type='City') - print('> Cities contained in {}'.format(dcids)) - for dcid in dcids: - for city_dcid in prop_vals[dcid]: - print(' - {}'.format(city_dcid)) - - # Print the first 10 triples associated with Santa Clara County - print('Triples for Santa Clara County') - triples = dc.get_triples(dcids) - for dcid in dcids: - print('> Triples for {}'.format(dcid)) - for s, p, o in triples[dcid][:5]: - print(' - ("{}", {}, "{}")'.format(s, p, o)) - - -if __name__ == '__main__': - main() diff --git a/datacommons/examples/places.py b/datacommons/examples/places.py deleted file mode 100644 index ee9c71ec..00000000 --- a/datacommons/examples/places.py +++ /dev/null @@ -1,73 +0,0 @@ -# Copyright 2017 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -""" Data Commons Python API examples. - -Basic demo for get_places_in -""" - -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - -import datacommons as dc - - -def main(): - # Create a list of dcids for Santa Clara and Montgomery County. - sc, mc = 'geoId/06085', 'geoId/24031' - dcids = [sc, mc] - - # Get all CensusTracts in these two counties. - print('Get Census Tracts') - tracts = dc.get_places_in(dcids, 'CensusTract') - if sc in tracts: - print('> 10 CensusTracts in Santa Clara County') - for dcid in tracts[sc][:10]: - print(' - {}'.format(dcid)) - if mc in tracts: - print('> 10 CensusTracts in Montgomery County') - for dcid in tracts[mc][:10]: - print(' - {}'.format(dcid)) - - # Get place stats. - print('Get place stats -- all') - stats = dc.get_stats(['geoId/05', 'geoId/06', 'dc/madDcid'], 'dc/0hyp6tkn18vcb', obs_dates='all') - print(stats) - - print('Get place stats -- latest') - stats = dc.get_stats(['geoId/05', 'geoId/06', 'dc/madDcid'], 'dc/0hyp6tkn18vcb') - print(stats) - - print('Get place stats -- 2014') - stats = dc.get_stats(['geoId/05', 'geoId/06', 'dc/madDcid'], 'dc/0hyp6tkn18vcb', obs_dates=['2014']) - print(stats) - - print('Get place stats -- 2014 badly formatted') - stats = dc.get_stats(['geoId/05', 'geoId/06', 'dc/madDcid'], 'dc/0hyp6tkn18vcb', obs_dates='2014') - print(stats) - - print('Get place stats -- 2015-2016') - stats = dc.get_stats(['geoId/05', 'geoId/06', 'dc/madDcid'], 'dc/0hyp6tkn18vcb', obs_dates=['2015', '2016']) - print(stats) - - # Get related places. -# TODO(*): Fix the related places example. -# print('Get related places') -# related_places = dc.get_related_places(['geoId/06085'], 'Person', 'count', -# 'CensusACS5yrSurvey', "measuredValue", {"gender": "Female"}) -# print(related_places) - - -if __name__ == '__main__': - main() diff --git a/datacommons/examples/populations.py b/datacommons/examples/populations.py deleted file mode 100644 index 3804dbf3..00000000 --- a/datacommons/examples/populations.py +++ /dev/null @@ -1,56 +0,0 @@ -# Copyright 2017 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -""" Data Commons Python API examples. - -Basic demo for get_populations and get_observations. -""" - -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - -import datacommons as dc -import pprint -import json - - -def main(): - # Create a list of dcids for California, Kentucky, and Maryland - ca, ky, md = 'geoId/06', 'geoId/21', 'geoId/24' - dcids = [ca, ky, md] - - # Get the population of all employed individuals in the above states. - print('Get Populations for All Employed Individuals') - employed = dc.get_populations(dcids, 'Person', constraining_properties={ - 'employment': 'BLS_Employed'}) - print(json.dumps(employed, indent=2)) - - # Get the count for all male / females for the above states in 2016 - print('Get Population Counts for Employed Individuals in Maryland') - pop_dcids = [employed[md]] - obs = dc.get_observations(pop_dcids, - 'count', - 'measuredValue', - '2018-12', - observation_period='P1M', - measurement_method='BLSSeasonallyAdjusted') - print(json.dumps(obs, indent=2)) - - # Get all population and observation data of Mountain View. - print('Get Mountain View population and observation') - popobs = dc.get_pop_obs("geoId/0649670") - pprint.pprint(popobs) - -if __name__ == '__main__': - main() diff --git a/datacommons/examples/query.py b/datacommons/examples/query.py deleted file mode 100644 index 8be1bfe4..00000000 --- a/datacommons/examples/query.py +++ /dev/null @@ -1,46 +0,0 @@ -# Copyright 2017 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -""" Data Commons Python API examples. - -Example on how to use the Client API SPARQL query wrapper. -""" - -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - -import datacommons as dc - - -def main(): - # Create a SPARQL query querying for the name of some states - query = (''' -SELECT ?name ?dcid -WHERE { - ?a typeOf Place . - ?a name ?name . - ?a dcid ("geoId/06" "geoId/21" "geoId/24") . - ?a dcid ?dcid -} -''') - print('> Issuing query.\n{}'.format(query)) - - # Iterate through all the rows in the results. - print('> Printing results.\n') - for row in dc.query(query_string=query): - print(' {}'.format(row)) - - -if __name__ == '__main__': - main() diff --git a/datacommons/examples/stat_vars.py b/datacommons/examples/stat_vars.py deleted file mode 100644 index 51218b98..00000000 --- a/datacommons/examples/stat_vars.py +++ /dev/null @@ -1,232 +0,0 @@ -# Copyright 2020 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -"""Basic examples for StatisticalVariable-based Data Commons API functions.""" - -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - -import datacommons as dc -import pprint - - -def main(): - param_sets = [ - { - 'place': 'geoId/06085', - 'stat_var': "Count_Person", - }, - { - 'place': 'geoId/06085', - 'stat_var': "Count_Person", - 'date': '2018', - }, - { - 'place': 'geoId/06085', - 'stat_var': "Count_Person", - 'date': '2018', - 'measurement_method': 'CensusACS5yrSurvey', - }, - { - 'place': 'geoId/06085', - 'stat_var': 'UnemploymentRate_Person', - }, - { - 'place': 'geoId/06085', - 'stat_var': 'UnemploymentRate_Person', - 'observation_period': 'P1Y', - }, - { - 'place': 'geoId/06085', - 'stat_var': 'UnemploymentRate_Person', - 'observation_period': 'P1Y', - 'measurement_method': 'BLSSeasonallyUnadjusted', - }, - { - 'place': - 'nuts/HU22', - 'stat_var': - 'Amount_EconomicActivity_GrossDomesticProduction_Nominal', - }, - { - 'place': - 'nuts/HU22', - 'stat_var': - 'Amount_EconomicActivity_GrossDomesticProduction_Nominal', - 'observation_period': - 'P1Y', - 'unit': - 'PurchasingPowerStandard' - }, - ] - - def call_str(pvs): - """Helper function to print the minimal call string.""" - s = "'{}', '{}'".format(pvs.get('place'), pvs.get('stat_var')) - if pvs.get('measurement_method'): - s += ", measurement_method='{}'".format( - pvs.get('measurement_method')) - if pvs.get('observation_period'): - s += ", observation_period='{}'".format( - pvs.get('observation_period')) - if pvs.get('unit'): - s += ", unit='{}'".format(pvs.get('unit')) - if pvs.get('scaling_factor'): - s += ", scaling_factor={}".format(pvs.get('scaling_factor')) - return s - - for pvs in param_sets: - print('\nget_stat_value({})'.format(call_str(pvs))) - print( - '>>> ', - dc.get_stat_value(pvs.get('place'), - pvs.get('stat_var'), - date=pvs.get('date'), - measurement_method=pvs.get('measurement_method'), - observation_period=pvs.get('observation_period'), - unit=pvs.get('unit'), - scaling_factor=pvs.get('scaling_factor'))) - for pvs in param_sets: - pvs.pop('date', None) - print('\nget_stat_series({})'.format(call_str(pvs))) - print( - '>>> ', - dc.get_stat_series(pvs.get('place'), - pvs.get('stat_var'), - measurement_method=pvs.get('measurement_method'), - observation_period=pvs.get('observation_period'), - unit=pvs.get('unit'), - scaling_factor=pvs.get('scaling_factor'))) - - pp = pprint.PrettyPrinter(indent=4) - print( - '\nget_stat_all(["geoId/06085", "country/FRA"], ["Median_Age_Person", "Count_Person"])' - ) - print('>>> ') - pp.pprint( - dc.get_stat_all(["geoId/06085", "country/FRA"], - ["Median_Age_Person", "Count_Person"])) - - print( - '\nget_stat_all(["badPlaceId", "country/FRA"], ["Median_Age_Person", "Count_Person"])' - ) - print('>>> ') - pp.pprint( - dc.get_stat_all(["badPlaceId", "country/FRA"], - ["Median_Age_Person", "Count_Person"])) - - - print('\nWhen no data for get_stat_value') - pp.pprint(dc.get_stat_value('foooo', 'barrrr')) - - print('\nWhen no data for get_stat_series') - pp.pprint(dc.get_stat_series('foobarbar', 'barfoo')) - - print('\nSTRESS TEST FOR GET_STAT_ALL') - try: - dc.get_stat_all( - dc.get_places_in(['country/USA'], 'County')['country/USA'], [ - 'Count_Person', 'LandAreaSqMeter', - 'PopulationDensityPerSqMeter', - 'Count_Person_BlackOrAfricanAmericanAlone', - 'PercentBlackOrAfricanAmericanAlone', 'Count_Person_Female', - 'Count_Person_Male', - 'Count_Person_AmericanIndianAndAlaskaNativeAlone', - 'Count_Person_AmericanIndianAndAlaskaNativeAloneOrInCombinationWithOneOrMoreOtherRaces', - 'Count_Person_AmericanIndianOrAlaskaNativeAlone', - 'Count_Person_AsianAlone', - 'Count_Person_AsianAloneOrInCombinationWithOneOrMoreOtherRaces', - 'Count_Person_BlackOrAfricanAmericanAloneOrInCombinationWithOneOrMoreOtherRaces', - 'Count_Person_HispanicOrLatino', - 'Count_Person_NativeHawaiianAndOtherPacificIslanderAlone', - 'Count_Person_NativeHawaiianAndOtherPacificIslanderAloneOrInCombinationWithOneOrMoreOtherRaces', - 'Count_Person_NativeHawaiianOrOtherPacificIslanderAlone', - 'Count_Person_SomeOtherRaceAlone', - 'Count_Person_SomeOtherRaceAloneOrInCombinationWithOneOrMoreOtherRaces', - 'Count_Person_TwoOrMoreRaces', 'Count_Person_WhiteAlone', - 'Count_Person_WhiteAloneNotHispanicOrLatino', - 'Count_Person_WhiteAloneOrInCombinationWithOneOrMoreOtherRaces', - 'Count_Person_Upto5Years', 'Count_Person_Upto18Years', - 'Count_Person_65OrMoreYears', 'Count_Person_75OrMoreYears', - 'Count_Person_ForeignBorn', - 'Count_Person_USCitizenByNaturalization', - 'Count_Person_NotAUSCitizen', 'Count_Person_Nonveteran', - 'Count_Person_Veteran', 'Count_Person_NotWorkedFullTime', - 'Count_Person_WorkedFullTime', 'Count_Person_Employed', - 'Count_Person_Unemployed', 'Count_Person_InLaborForce', - 'Count_Person_IncomeOf10000To14999USDollar', - 'Count_Person_IncomeOf15000To24999USDollar', - 'Count_Person_IncomeOf25000To34999USDollar', - 'Count_Person_IncomeOf35000To49999USDollar', - 'Count_Person_IncomeOf50000To64999USDollar', - 'Count_Person_IncomeOf65000To74999USDollar', - 'Count_Person_IncomeOf75000OrMoreUSDollar', - 'Count_Person_IncomeOfUpto9999USDollar', - 'Count_Person_EnrolledInSchool', - 'Count_Person_NotEnrolledInSchool', - 'Count_Person_EnrolledInCollegeUndergraduateYears', - 'Count_Person_EnrolledInGrade1ToGrade4', - 'Count_Person_EnrolledInGrade5ToGrade8', - 'Count_Person_EnrolledInGrade9ToGrade12', - 'Count_Person_EnrolledInKindergarten', - 'Count_Person_EnrolledInNurserySchoolPreschool', - 'Count_Person_GraduateOrProfessionalSchool', - 'Count_Person_EducationalAttainment10ThGrade', - 'Count_Person_EducationalAttainment11ThGrade', - 'Count_Person_EducationalAttainment12ThGradeNoDiploma', - 'Count_Person_EducationalAttainment1StGrade', - 'Count_Person_EducationalAttainment2NdGrade', - 'Count_Person_EducationalAttainment3RdGrade', - 'Count_Person_EducationalAttainment4ThGrade', - 'Count_Person_EducationalAttainment5ThGrade', - 'Count_Person_EducationalAttainment6ThGrade', - 'Count_Person_EducationalAttainment7ThGrade', - 'Count_Person_EducationalAttainment8ThGrade', - 'Count_Person_EducationalAttainment9ThGrade', - 'Count_Person_EducationalAttainmentAssociatesDegree', - 'Count_Person_EducationalAttainmentBachelorsDegree', - 'Count_Person_EducationalAttainmentBachelorsDegreeOrHigher', - 'Count_Person_EducationalAttainmentDoctorateDegree', - 'Count_Person_EducationalAttainmentGedOrAlternativeCredential', - 'Count_Person_EducationalAttainmentKindergarten', - 'Count_Person_EducationalAttainmentMastersDegree', - 'Count_Person_EducationalAttainmentNoSchoolingCompleted', - 'Count_Person_EducationalAttainmentNurserySchool', - 'Count_Person_EducationalAttainmentPrimarySchool', - 'Count_Person_EducationalAttainmentProfessionalSchoolDegree', - 'Count_Person_EducationalAttainmentRegularHighSchoolDiploma', - 'Count_Person_EducationalAttainmentSomeCollege1OrMoreYearsNoDegree', - 'Count_Person_EducationalAttainmentSomeCollegeLessThan1Year', - 'Count_Person_Divorced', 'Count_Person_MarriedAndNotSeparated', - 'Count_Person_NeverMarried', 'Count_Person_Separated', - 'Count_Person_Widowed', 'Count_Person_NowMarried', - 'Count_Person_AbovePovertyLevelInThePast12Months', - 'Count_Person_BelowPovertyLevelInThePast12Months', - 'Percent_Person_20OrMoreYears_WithDiabetes', - 'Percent_Person_20OrMoreYears_Obesity', - 'Percent_Person_20OrMoreYears_PhysicalInactivity', - 'Percent_Person_Upto64Years_NoHealthInsurance', - 'Median_Age_Person', 'Median_Income_Person', 'Count_Death', - 'Count_Death_CertainInfectiousParasiticDiseases', - 'Count_Death_DiseasesOfBloodAndBloodFormingOrgansAndImmuneDisorders', - 'Count_Death_DiseasesOfTheRespiratorySystem' - ]) - except ValueError: - print('Stress test for get_stat_all FAILED!') - else: - print('Stress test for get_stat_all succeeded.') - - -if __name__ == '__main__': - main() diff --git a/datacommons/places.py b/datacommons/places.py deleted file mode 100644 index b04badc5..00000000 --- a/datacommons/places.py +++ /dev/null @@ -1,250 +0,0 @@ -# Copyright 2017 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -""" Data Commons Python API Places Module. - -Provides convenience functions for working with Places in the Data Commons -Graph. This submodule implements the ability to access :obj:`Place`'s -within a collection of nodes identified by dcid. -""" - -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - -import datacommons.utils as utils - - -def get_places_in(dcids, place_type): - """ Returns :obj:`Place`s contained in :code:`dcids` of type - :code:`place_type`. - - Args: - dcids (:obj:`iterable` of :obj:`str`): Dcids to get contained in places. - place_type (:obj:`str`): The type of places contained in the given dcids to - filter by. - - Returns: - The returned :obj:`Place`'s are formatted as a :obj:`dict` from a given - dcid to a list of places identified by dcids of the given `place_type`. - - Raises: - ValueError: If the payload returned by the Data Commons REST API is - malformed. - - Examples: - We would like to get all Counties contained in - `California `_. Specifying - the :code:`dcids` as a :obj:`list` result in the following. - - >>> get_places_in(["geoId/06"], "County") - { - 'geoId/06': [ - 'geoId/06041', - 'geoId/06089', - 'geoId/06015', - 'geoId/06023', - 'geoId/06067', - ... - # and 53 more - ] - } - """ - dcids = filter(lambda v: v==v, dcids) # Filter out NaN values - dcids = list(dcids) - url = utils._API_ROOT + utils._API_ENDPOINTS['get_places_in'] - payload = utils._send_request(url, req_json = { - 'dcids': dcids, - 'place_type': place_type, - }) - - # Create the results and format it appropriately - result = utils._format_expand_payload(payload, 'place', must_exist=dcids) - return result - -def get_stats(dcids, stats_var, obs_dates='latest', measurement_method=None, - unit=None, obs_period=None): - """ Returns :obj:`TimeSeries` for :code:`dcids` \ - based on the :code:`stats_var`. - - Args: - dcids (:obj:`iterable` of :obj:`str`): Dcids of places to query for. - stats_var (:obj:`str`): The dcid of the :obj:StatisticalVariable. - obs_dates (:obj:`str` or :obj:`iterable` of :obj:`str`): - Which observation to return. - Can be 'latest', 'all', or an iterable of dates in 'YYYY-MM-DD' format. - measurement_method (:obj:`str`): Optional, the dcid of the preferred - `measurementMethod` value. - unit (:obj:`str`): Optional, the dcid of the preferred `unit` value. - obs_period (:obj:`str`): Optional, the dcid of the preferred - `observationPeriod` value. - Returns: - A :obj:`dict` mapping the :obj:`Place` identified by the given :code:`dcid` - to its place name and the :obj:`TimeSeries` associated with the - :obj:`StatisticalVariable` identified by the given :code:`stats_var` - and filtered by :code:`obs_dates` and optional args. - See example below for more detail about how the returned :obj:`dict` is - structured. - - Raises: - ValueError: If the payload returned by the Data Commons REST API is - malformed. - - Examples: - We would like to get the :obj:`TimeSeries` of the number of males - at least 25 years old that attended 12th grade but did not receive - a high school diploma - (`dc/0hyp6tkn18vcb `_) - in `Arkansas `_ - and `California `_. - - >>> get_stats(["geoId/05", "geoId/06"], "dc/0hyp6tkn18vcb") - { - 'geoId/05': { - 'place_name': 'Arkansas' - 'data': { - '2011':18136, - '2012':17279, - '2013':17459, - '2014':16966, - '2015':17173, - '2016':17041, - '2017':17783, - '2018':18003 - }, - }, - 'geoId/05': { - 'place_name': 'California' - 'data': { - '2011':316667, - '2012':324116, - '2013':331853, - '2014':342818, - '2015':348979, - '2016':354806, - '2017':360645, - '2018':366331 - }, - }, - } - """ - dcids = filter(lambda v: v==v, dcids) # Filter out NaN values - dcids = list(dcids) - url = utils._API_ROOT + utils._API_ENDPOINTS['get_stats'] - batches = -(-len(dcids) // utils._QUERY_BATCH_SIZE) # Ceil to get # of batches. - res = {} - for i in range(batches): - req_json = { - 'place': dcids[i * utils._QUERY_BATCH_SIZE:(i+1) * utils._QUERY_BATCH_SIZE], - 'stats_var': stats_var, - } - if measurement_method: - req_json['measurement_method'] = measurement_method - if unit: - req_json['unit'] = unit - if obs_period: - req_json['observation_period'] = obs_period - payload = utils._send_request(url, req_json) - if obs_dates == 'all': - res.update(payload) - elif obs_dates == 'latest': - for geo, stats in payload.items(): - if not stats: - continue - time_series = stats.get('data') - if not time_series: continue - max_date = max(time_series) - max_date_stat = time_series[max_date] - time_series.clear() - time_series[max_date] = max_date_stat - res[geo] = stats - elif obs_dates: - obs_dates = set(obs_dates) - for geo, stats in payload.items(): - if not stats: - continue - time_series = stats.get('data') - if not time_series: continue - for date in list(time_series): - if date not in obs_dates: - time_series.pop(date) - res[geo] = stats - return res - - -def get_related_places(dcids, population_type, measured_property, - measurement_method, stat_type, constraining_properties={}, - within_place='', per_capita=False, same_place_type=False): - """ Returns :obj:`Place`s related to :code:`dcids` for the given constraints. - - Args: - dcids (:obj:`iterable` of :obj:`str`): Dcids to get related places. - population_type (:obj:`str`): The type of statistical population. - measured_property (:obj:`str`): The measured property. - measurement_method(:obj:`str`): The measurement method for the observation. - stat_type (:obj:`str`): The statistical type for the observation. - constraining_properties (:obj:`map` from :obj:`str` to :obj:`str`, optional): - A map from constraining property to the value that the - :obj:`StatisticalPopulation` should be constrained by. - within_place(:obj:`str`): Optional, the DCID of the place that all the - related places are contained in. - per_capita(:obj:`bool`): Optional, whether to take into account - `PerCapita` when compute the relatedness. - same_place_type(:obj:`bool`): Optional, whether to require all the - related places under the same place type. - - Returns: - The returned :obj:`Place`'s are formatted as a :obj:`dict` from a given - dcid to a list of related places for the given constraints. - - Raises: - ValueError: If the payload returned by the Data Commons REST API is - malformed. - - Examples: - We would like to get all related places of - `Santa Clara county ` - Specifying the :code:`dcids` as a :obj:`list` result in the following. - - >>> get_related_places(["geoId/06"], "Person", { - "age": "Years21To64", - "gender": "Female" - }, "count", "CenusACS5yrSurvey", "measuredValue") - { - 'geoId/06085': [ - 'geoId/06041', - 'geoId/06089', - 'geoId/06015', - 'geoId/06023', - ] - } - """ - dcids = filter(lambda v: v==v, dcids) # Filter out NaN values - dcids = list(dcids) - url = utils._API_ROOT + utils._API_ENDPOINTS['get_related_places'] - pvs = [] - for p in constraining_properties: - pvs.append({'property': p, 'value': constraining_properties[p]}) - req_json = { - 'dcids': dcids, - 'populationType': population_type, - 'pvs': pvs, - 'measuredProperty': measured_property, - 'statType': '', # TODO: Set to stat_type when having it in BT data. - 'measurementMethod': measurement_method, - 'withinPlace': within_place, - 'perCapita': per_capita, - 'samePlaceType': same_place_type, - } - payload = utils._send_request(url, req_json=req_json) - return payload diff --git a/datacommons/populations.py b/datacommons/populations.py deleted file mode 100644 index 2b1bd42c..00000000 --- a/datacommons/populations.py +++ /dev/null @@ -1,418 +0,0 @@ -# Copyright 2017 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -""" Data Commons Python API Populations Module. - -Provides convenience functions for accessing :obj:`StatisticalPopulation`'s and -:obj:`Observation`'s in the Data Commons Graph. Implements the -following: - -- Get :obj:`StatisticalPopulation`'s located at a given collection of nodes. -- Get :obj:`Observation`'s observing a collection of - :obj:`StatisticalPopulation`'s -""" - -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - -import datacommons.utils as utils - - -def _flatten_results(result, default_value=None): - """ Formats results to map to a single value or default value if empty. """ - for k in list(result): - v = result[k] - if len(v) > 1: - raise ValueError( - 'Expected one result, but more returned for "{}": {}'.format(k, v)) - if len(v) == 1: - result[k] = v[0] - else: - if default_value is not None: - result[k] = default_value - else: - del result[k] - return result - - -def get_populations(dcids, population_type, constraining_properties={}): - """ Returns :obj:`StatisticalPopulation`'s located at the given :code:`dcids`. - - Args: - dcids (:obj:`iterable` of :obj:`str`): Dcids - identifying :obj:`Place`'s of populations to query for. These dcids are - treated as the property value associated with returned :obj:`Population`'s - by the property - `location `_ - population_type (:obj:`str`): The population type of the - :obj:`StatisticalPopulation` - constraining_properties (:obj:`map` from :obj:`str` to :obj:`str`, optional): - A map from constraining property to the value that the - :obj:`StatisticalPopulation` should be constrained by. - - Returns: - The returned :obj:`StatisticalPopulation` are formatted as a :obj:`dict` from a given - dcid to the unique :obj:`StatisticalPopulation` located at the dcid as - specified by the `population_type` and `constraining_properties` *if such - exists*. A given dcid will *NOT* be a member of the :obj:`dict` if such - a population does not exist. - - Raises: - ValueError: If the payload returned by the Data Commons REST API is - malformed. - - Examples: - We would like to get - - - The `population of employed persons in California `_ - - The `population of employed persons in Kentucky `_ - - The `population of employed persons in Maryland `_. - - These populations are specified as having a - `population_type` as :obj:`Person` and the `constraining_properties` - as `employment `_ - = BLS_Employed - - With a :obj:`list` of dcids for our states, we can get the populations we - want as follows. - - >>> dcids = ["geoId/06", "geoId/21", "geoId/24"] - >>> pvs = {'employment': 'BLS_Employed'} - >>> dc.get_populations(dcids, 'Person', constraining_properties=pvs) - { - "geoId/06": "dc/p/x6t44d8jd95rd", - "geoId/21": "dc/p/fs929fynprzs", - "geoId/24": "dc/p/lr52m1yr46r44" - } - """ - # Convert the dcids field and format the request to GetPopulations - dcids = filter(lambda v: v==v, dcids) # Filter out NaN values - dcids = list(dcids) - pv = [{'property': k, 'value': v} for k, v in constraining_properties.items()] - url = utils._API_ROOT + utils._API_ENDPOINTS['get_populations'] - payload = utils._send_request(url, req_json={ - 'dcids': dcids, - 'population_type': population_type, - 'pvs': pv, - }) - - # Create the results and format it appropriately - result = utils._format_expand_payload( - payload, 'population', must_exist=dcids) - - # Drop empty results while flattening - return _flatten_results(result) - - -def get_observations(dcids, - measured_property, - stats_type, - observation_date, - observation_period=None, - measurement_method=None): - """ Returns values of :obj:`Observation`'s observing the given :code:`dcids`. - - Args: - dcids (:obj:`iterable` of :obj:`str`): Dcids - identifying nodes that returning :obj:`Observation`'s observe. These dcids - are treated as the property value associated with returned - :obj:`Observation`'s by the property - `observedNode `_ - measured_property (:obj:`str`): The measured property. - stats_type (:obj:`str`): The statistical type for the observation. - observation_date (:obj:`str`): The associated observation date in ISO8601 - format. - observation_period (:obj:`str`, optional): An optional parameter specifying - the observation period. - measurement_method (:obj:`str`, optional): An optional parameter specifying - the measurement method. - - Raises: - ValueError: If the payload returned by the Data Commons REST API is - malformed. - - Returns: - When :code:`dcids` is an instance of :obj:`list`, the returned - :obj:`Observation`'s are formatted as a :obj:`dict` from a given dcid to the - unique :obj:`Observation` observing the dcid where the observation is - specified by what is given in the other parameters *if such exists*. A given - dcid will *NOT* be a member of the :obj:`dict` if such an observation does - not exist. - - Examples: - We would like to get the following for December, 2018: - - - The `total count of employed persons in California `_ - - The `total count of employed persons in Kentucky `_ - - The `total count of employed persons in Maryland `_. - - The observations we want are observations of the populations representing - employed individuals in each state (to get these, see - :any:module-datacommons.populations.get_populations). With a list of these - population dcids, we can get the observations like so. - - >>> dcids = [ - ... "dc/p/x6t44d8jd95rd", # Employed individuals in California - ... "dc/p/fs929fynprzs", # Employed individuals in Kentucky - ... "dc/p/lr52m1yr46r44" # Employed individuals in Maryland - ... ] - >>> get_observations(dcids, 'count', 'measuredValue', '2018-12', - ... observation_period='P1M', - ... measurement_method='BLSSeasonallyAdjusted' - ... ) - { - "dc/p/x6t44d8jd95rd": 18704962.0, - "dc/p/fs929fynprzs": 1973955.0, - "dc/p/lr52m1yr46r44": 3075662.0 - } - """ - dcids = filter(lambda v: v==v, dcids) # Filter out NaN values - dcids = list(dcids) - req_json = { - 'dcids': dcids, - 'measured_property': measured_property, - 'stats_type': stats_type, - 'observation_date': observation_date, - } - if observation_period: - req_json['observation_period'] = observation_period - if measurement_method: - req_json['measurement_method'] = measurement_method - - # Issue the request to GetObservation - url = utils._API_ROOT + utils._API_ENDPOINTS['get_observations'] - payload = utils._send_request(url, req_json=req_json) - - # Create the results and format it appropriately - result = utils._format_expand_payload( - payload, 'observation', must_exist=dcids) - - # Drop empty results by calling _flatten_results without default_value, then - # coerce the type to float if possible. - typed_results = {} - for k, v in _flatten_results(result).items(): - try: - typed_results[k] = float(v) - except ValueError: - typed_results[k] = v - return typed_results - - -def get_pop_obs(dcid): - """ Returns all :obj:`StatisticalPopulation` and :obj:`Observation` \ - of a :obj:`Thing`. - - Args: - dcid (:obj:`str`): Dcid of the thing. - - Returns: - A :obj:`dict` of :obj:`StatisticalPopulation` and :obj:`Observation` that - are associated to the thing identified by the given :code:`dcid`. The given - dcid is linked to the returned :obj:`StatisticalPopulation`, - which are the :obj:`observedNode` of the returned :obj:`Observation`. - See example below for more detail about how the returned :obj:`dict` is - structured. - - Raises: - ValueError: If the payload returned by the Data Commons REST API is - malformed. - - Examples: - We would like to get all :obj:`StatisticalPopulation` and - :obj:`Observations` of - `Santa Clara `_. - - >>> get_pop_obs("geoId/06085") - { - 'name': 'Santa Clara', - 'placeType': 'County', - 'populations': { - 'dc/p/zzlmxxtp1el87': { - 'popType': 'Household', - 'numConstraints': 3, - 'propertyValues': { - 'householderAge': 'Years45To64', - 'householderRace': 'USC_AsianAlone', - 'income': 'USDollar35000To39999' - }, - 'observations': [ - { - 'marginOfError': 274, - 'measuredProp': 'count', - 'measuredValue': 1352, - 'measurementMethod': 'CensusACS5yrSurvey', - 'observationDate': '2017' - }, - { - 'marginOfError': 226, - 'measuredProp': 'count', - 'measuredValue': 1388, - 'measurementMethod': 'CensusACS5yrSurvey', - 'observationDate': '2013' - } - ], - }, - }, - 'observations': [ - { - 'meanValue': 4.1583, - 'measuredProp': 'particulateMatter25', - 'measurementMethod': 'CDCHealthTracking', - 'observationDate': '2014-04-04', - 'observedNode': 'geoId/06085' - }, - { - 'meanValue': 9.4461, - 'measuredProp': 'particulateMatter25', - 'measurementMethod': 'CDCHealthTracking', - 'observationDate': '2014-03-20', - 'observedNode': 'geoId/06085' - } - ] - } - - Notice that the return value is a multi-level :obj:`dict`. The top level - contains the following keys. - - - :code:`name` and :code:`placeType` provides the name and type of the - :obj:`Place` identified by the given :code:`dcid`. - - :code:`populations` maps to a :obj:`dict` containing all - :obj:`StatisticalPopulation` that have the given :code:`dcid` as its - :obj:`location`. - - :code:`observations` maps to a :obj:`list` containing all - :obj:`Observation` that have the given :code:`dcid` as its - :obj:`observedNode`. - - The :code:`populations` dictionary is keyed by the dcid of each - :obj:`StatisticalPopulation`. The mapped dictionary contains the following - keys. - - - :code:`popType` which gives the population type of the - :obj:`StatisticalPopulation` identified by the key. - - :code:`numConstraints` which gives the number of constraining properties - defined for the identified :obj:`StatisticalPopulation`. - - :code:`propertyValues` which gives a :obj:`dict` mapping a constraining - property to its value for the identified :obj:`StatisticalPopulation`. - - :code:`observations` which gives a list of all :obj:`Observation`'s that - have the identified :obj:`StatisticalPopulation` as their - :obj:`observedNode`. - - Each :obj:`Observation` is represented by a :code:`dict` that have the keys: - - - :code:`measuredProp`: The property measured by the :obj:`Observation`. - - :code:`observationDate`: The date when the :obj:`Observation` was made. - - :code:`observationPeriod` (optional): The period over which the - :obj:`Observation` was made. - - :code:`measurementMethod` (optional): A field providing additional - information on how the :obj:`Observation` was collected. - - Additional fields that denote values measured by the :obj:`Observation`. - These may include the following: :code:`measuredValue`, :code:`meanValue`, - :code:`medianValue`, :code:`maxValue`, :code:`minValue`, :code:`sumValue`, - :code:`marginOfError`, :code:`stdError`, :code:`meanStdError`, and others. - """ - url = utils._API_ROOT + utils._API_ENDPOINTS['get_pop_obs'] + '?dcid={}'.format(dcid) - return utils._send_request(url, compress=True, post=False) - -def get_place_obs( - place_type, observation_date, population_type, constraining_properties={}): - """ Returns all :obj:`Observation`'s for all places given the place type, - observation date and the :obj:`StatisticalPopulation` constraints. - - Args: - place_type (:obj:`str`): The type of places to query - :obj:`StatisticalPopulation`'s and :obj:`Observation`'s for. - observation_date (:obj:`str`): The observation date in ISO-8601 format. - population_type (:obj:`str`): The population type of the - :obj:`StatisticalPopulation` - constraining_properties (:obj:`map` from :obj:`str` to :obj:`str`, optional): - A map from constraining property to the value that the - :obj:`StatisticalPopulation` should be constrained by. - - Returns: - A list of dictionaries, with each dictionary containng *all* - :obj:`Observation`'s of a place that conform to the :obj:`StatisticalPopulation` - constraints. See examples for more details on how the format of the - return value is structured. - - Raises: - ValueError: If the payload is malformed. - - Examples: - We would like to get all :obj:`StatisticalPopulation` and - :obj:`Observations` for all places of type :obj:`City` in year 2017 where - the populations have a population type of :obj:`Person` is specified by the - following constraining properties. - - - Persons should have `age `_ - with value `Years5To17 `_ - - Persons should have `placeOfBirth `_ - with value BornInOtherStateInTheUnitedStates. - - >>> props = { - ... 'age': 'Years5To17', - ... 'placeOfBirth': 'BornInOtherStateInTheUnitedStates' - ... } - >>> get_place_obs('City', '2017', Person', constraining_properties=props) - [ - { - 'name': 'Marcus Hook borough', - 'place': 'geoId/4247344', - 'populations': { - 'dc/p/pq6frs32sfvk': { - 'observations': [ - { - 'marginOfError': 39, - 'measuredProp': 'count', - 'measuredValue': 67, - 'type': 'Observation' - }, - # More observations... - ], - } - } - }, - # Entries for more cities... - ] - - The value returned by :code:`get_place_obs` is a :obj:`list` of - :obj:`dict`'s. Each dictionary corresponds to a :obj:`StatisticalPopulation` - matching the given :code:`population_type` and - :code:`constraining_properties` for a single place of the given - :code:`place_type`. The dictionary contains the following keys. - - - :code:`name`: The name of the place being described. - - :code:`place`: The dcid associated with the place being described. - - :code:`populations`: A :obj:`dict` mapping :code:`StatisticalPopulation` - dcids to a a :obj:`dict` with a list of :code:`observations`. - - Each :obj:`Observation` is represented by a :obj:`dict` with the following - keys. - - :code:`measuredProp`: The property measured by the :obj:`Observation`. - - :code:`measurementMethod` (optional): A field identifying how the - :obj:`Observation` was made - - Additional fields that denote values measured by the :obj:`Observation`. - These may include the following: :code:`measuredValue`, :code:`meanValue`, - :code:`medianValue`, :code:`maxValue`, :code:`minValue`, :code:`sumValue`, - :code:`marginOfError`, :code:`stdError`, :code:`meanStdError`, and others. - """ - # Create the json payload and send it to the REST API. - pv = [{'property': k, 'value': v} for k, v in constraining_properties.items()] - url = utils._API_ROOT + utils._API_ENDPOINTS['get_place_obs'] - payload = utils._send_request(url, req_json={ - 'place_type': place_type, - 'observation_date': observation_date, - 'population_type': population_type, - 'pvs': pv, - }, compress=True) - return payload['places'] diff --git a/datacommons/query.py b/datacommons/query.py deleted file mode 100644 index 94b8ab20..00000000 --- a/datacommons/query.py +++ /dev/null @@ -1,129 +0,0 @@ -# Copyright 2017 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -""" Data Commons Python API Query Module. - -Implements functions for sending graph queries to the Data Commons Graph. -""" - -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - -from datacommons.utils import _API_ROOT, _API_ENDPOINTS, _ENV_VAR_API_KEY - -import json -import os -import six.moves.urllib.error -import six.moves.urllib.request - -# ----------------------------- WRAPPER FUNCTIONS ----------------------------- - - -def query(query_string, select=None): - """ Returns the results of executing a SPARQL query on the Data Commons graph. - - Args: - query_string (:obj:`str`): The SPARQL query string. - select (:obj:`func` accepting a row in the query result): A function that - selects rows to be returned by :code:`query`. This function accepts a row - in the results of executing :code:`query_string` and return True if and - only if the row is to be returned by :code:`query`. The row passed in as - an argument is represented as a :obj:`dict` that maps a query variable in - :code:`query_string` to its value in the given row. - - Returns: - A table, represented as a :obj:`list` of rows, resulting from executing the - given SPARQL query. Each row is a :obj:`dict` mapping query variable to its - value in the row. If `select` is not `None`, then a row is included in the - returned :obj:`list` if and only if `select` returns :obj:`True` for that - row. - - Raises: - ValueError: If the payload returned by the Data Commons REST API is - malformed. - - Examples: - We would like to query for the name associated with three states identified - by their dcids - `California `_, - `Kentucky `_, and - `Maryland `_. - - >>> query_str = ''' - ... SELECT ?name ?dcid - ... WHERE { - ... ?a typeOf Place . - ... ?a name ?name . - ... ?a dcid ("geoId/06" "geoId/21" "geoId/24") . - ... ?a dcid ?dcid - ... } - ... ''' - >>> result = query(query_str) - >>> for r in result: - ... print(r) - {"?name": "Maryland", "?dcid": "geoId/24"} - {"?name": "Kentucky", "?dcid": "geoId/21"} - {"?name": "California", "?dcid": "geoId/06"} - - Optionally, we can specify which rows are returned by setting :code:`select` - like so. The following returns all rows where the name is "Maryland". - - >>> selector = lambda row: row['?name'] == 'Maryland' - >>> result = query(query_str, select=selector) - >>> for r in result: - ... print(r) - {"?name": "Maryland", "?dcid": "geoId/24"} - """ - - req_url = _API_ROOT + _API_ENDPOINTS['query'] - headers = { - 'Content-Type': 'application/json' - } - if os.environ.get(_ENV_VAR_API_KEY): - headers['x-api-key'] = os.environ[_ENV_VAR_API_KEY] - - req = six.moves.urllib.request.Request( - req_url, - data=json.dumps({'sparql': query_string}).encode("utf-8"), - headers=headers) - - try: - res = six.moves.urllib.request.urlopen(req) - except six.moves.urllib.error.HTTPError as e: - raise ValueError('Response error {}:\n{}'.format(e.code, e.read())) - - # Verify then store the results. - res_json = json.loads(res.read()) - - # Iterate through the query results - header = res_json.get('header') - if header is None: - raise ValueError('Ill-formatted response: does not contain a header.') - result_rows = [] - for row in res_json.get('rows', []): - # Construct the map from query variable to cell value. - row_map = {} - for idx, cell in enumerate(row.get('cells', [])): - if idx > len(header): - raise ValueError( - 'Query error: unexpected cell {}'.format(cell)) - if 'value' not in cell: - raise ValueError( - 'Query error: cell missing value {}'.format(cell)) - cell_var = header[idx] - row_map[cell_var] = cell['value'] - # Add the row to the result rows if it is selected - if select is None or select(row_map): - result_rows.append(row_map) - return result_rows diff --git a/datacommons/stat_vars.py b/datacommons/stat_vars.py deleted file mode 100644 index 6e9e79be..00000000 --- a/datacommons/stat_vars.py +++ /dev/null @@ -1,260 +0,0 @@ -# Copyright 2020 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -"""Data Commons Python API Stat Module. - -Provides functions for getting data on StatisticalVariables from Data Commons Graph. -""" - -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - -import collections -import six - -import datacommons.utils as utils - -# stat_var specific batch size. -_STAT_BATCH_SIZE = 2000 - - -def get_stat_value(place, - stat_var, - date=None, - measurement_method=None, - observation_period=None, - unit=None, - scaling_factor=None): - """Returns a value for `place` based on the `stat_var`. - - Args: - place (`str`): The dcid of Place to query for. - stat_var (`str`): The dcid of the StatisticalVariable. - date (`str`): Optional, the preferred date of observation - in ISO 8601 format. If not specified, returns the latest observation. - measurement_method (`str`): Optional, the dcid of the preferred - `measurementMethod` value. - observation_period (`str`): Optional, the preferred - `observationPeriod` value. - unit (`str`): Optional, the dcid of the preferred `unit` value. - scaling_factor (`int`): Optional, the preferred `scalingFactor` value. - Returns: - A `float` the value of `stat_var` for `place`, filtered - by optional args. If no data, returns nan. - - Raises: - ValueError: If the payload returned by the Data Commons REST API is - malformed. - - Examples: - >>> get_stat_value("geoId/05", "Count_Person") - 366331 - """ - url = utils._API_ROOT + utils._API_ENDPOINTS['get_stat_value'] - url += '?place={}&stat_var={}'.format(place, stat_var) - if date: - url += '&date={}'.format(date) - if measurement_method: - url += '&measurement_method={}'.format(measurement_method) - if observation_period: - url += '&observation_period={}'.format(observation_period) - if unit: - url += '&unit={}'.format(unit) - if scaling_factor: - url += '&scaling_factor={}'.format(scaling_factor) - - try: - res_json = utils._send_request(url, post=False, use_payload=False) - except ValueError: - return float('nan') - if 'value' not in res_json: - return float('nan') - return res_json['value'] - - -def get_stat_series(place, - stat_var, - measurement_method=None, - observation_period=None, - unit=None, - scaling_factor=None): - """Returns a `dict` mapping dates to value of `stat_var` for `place`. - - Args: - place (`str`): The dcid of Place to query for. - stat_var (`str`): The dcid of the StatisticalVariable. - measurement_method (`str`): Optional, the dcid of the preferred - `measurementMethod` value. - observation_period (`str`): Optional, the preferred - `observationPeriod` value. - unit (`str`): Optional, the dcid of the preferred `unit` value. - scaling_factor (`int`): Optional, the preferred `scalingFactor` value. - Returns: - A `dict` mapping dates to value of `stat_var` for `place`, - representing a time series that satisfies all input parameters. - - Raises: - ValueError: If the payload returned by the Data Commons REST API is - malformed. - - Examples: - >>> get_stat_series("geoId/05", "Count_Person") - {"1962":17072000,"2009":36887615,"1929":5531000,"1930":5711000} - """ - url = utils._API_ROOT + utils._API_ENDPOINTS['get_stat_series'] - url += '?place={}&stat_var={}'.format(place, stat_var) - if measurement_method: - url += '&measurement_method={}'.format(measurement_method) - if observation_period: - url += '&observation_period={}'.format(observation_period) - if unit: - url += '&unit={}'.format(unit) - if scaling_factor: - url += '&scaling_factor={}'.format(scaling_factor) - - try: - res_json = utils._send_request(url, post=False, use_payload=False) - except ValueError: - return {} - - if 'series' not in res_json: - return {} - return res_json['series'] - - -def get_stat_all(places, stat_vars): - """Returns a nested `dict` of all time series for `places` and `stat_vars`. - - Args: - places (`Iterable` of `str`): The dcids of Places to query for. - stat_vars (`Iterable` of `str`): The dcids of the StatisticalVariables. - Returns: - A nested `dict` mapping Places to StatisticalVariables and all available - time series for each Place and StatisticalVariable pair. - - Raises: - ValueError: If the payload returned by the Data Commons REST API is - malformed. - - Examples: - >>> get_stat_all(["geoId/05", "geoId/06"], ["Count_Person", "Count_Person_Male"]) - { - "geoId/05": { - "Count_Person": { - "sourceSeries": [ - { - "val": { - "2010": 1633, - "2011": 1509, - "2012": 1581, - }, - "observationPeriod": "P1Y", - "importName": "Wikidata", - "provenanceDomain": "wikidata.org" - }, - { - "val": { - "2010": 1333, - "2011": 1309, - "2012": 131, - }, - "observationPeriod": "P1Y", - "importName": "CensusPEPSurvey", - "provenanceDomain": "census.gov" - } - ], - } - }, - "Count_Person_Male": { - "sourceSeries": [ - { - "val": { - "2010": 1633, - "2011": 1509, - "2012": 1581, - }, - "observationPeriod": "P1Y", - "importName": "CensusPEPSurvey", - "provenanceDomain": "census.gov" - } - ], - } - }, - "geoId/02": { - "Count_Person": {}, - "Count_Person_Male": { - "sourceSeries": [ - { - "val": { - "2010": 13, - "2011": 13, - "2012": 322, - }, - "observationPeriod": "P1Y", - "importName": "CensusPEPSurvey", - "provenanceDomain": "census.gov" - } - ] - } - } - } - """ - url = utils._API_ROOT + utils._API_ENDPOINTS['get_stat_all'] - # Cast iterable-like to list. - places = list(places) - stat_vars = list(stat_vars) - - # Aiming for _STAT_BATCH_SIZE entries total. - # _STAT_BATCH_SIZE = num places x num stat_vars, so aim for - # _STAT_BATCH_SIZE/len(stat_vars) places per batch. - places_per_batch = _STAT_BATCH_SIZE // len(stat_vars) - # Get number of batches via an arithmetic ceiling trick: - # 11//10 rounds down to 1. - # -11//10 rounds down to -2. - # We can divide with, then remove the negative to get the ceiling. - batches = -(-len(places) // places_per_batch) - res = {} - for i in range(batches): - req_json = { - 'stat_vars': stat_vars, - 'places': places[i * places_per_batch:(i + 1) * places_per_batch] - } - # Send the request - res_json = utils._send_request(url, - req_json=req_json, - use_payload=False) - if 'placeData' not in res_json: - # The REST API spec will always return a dictionary under - # placeData, even if no places exist or have no - # data. If no Places are provided, REST will return an - # error, which will have been caught and passed on in - # _send_request. - raise ValueError("Unexpected response from REST stat/all API.") - - # Unnest the REST response for keys that have single-element values. - place_statvar_series = collections.defaultdict(dict) - for place_dcid, place in res_json['placeData'].items(): - stat_var_data = place.get('statVarData') - if not stat_var_data: - # The REST API spec will always return a dictionary under - # statVarData, even if no StatVars exist or have no - # data. If no StatVars are provided, REST will return an - # error, which will have been caught and passed on in - # _send_request. - raise ValueError("Unexpected response from REST stat/all API.") - for stat_var_dcid, stat_var in stat_var_data.items(): - place_statvar_series[place_dcid][stat_var_dcid] = stat_var - res.update(dict(place_statvar_series)) - - return res diff --git a/datacommons/test/__init__.py b/datacommons/test/__init__.py deleted file mode 100644 index 7c07b241..00000000 --- a/datacommons/test/__init__.py +++ /dev/null @@ -1,13 +0,0 @@ -# Copyright 2017 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. diff --git a/datacommons/test/core_test.py b/datacommons/test/core_test.py deleted file mode 100644 index e64064a6..00000000 --- a/datacommons/test/core_test.py +++ /dev/null @@ -1,523 +0,0 @@ -# Copyright 2017 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -""" Data Commons Python API unit tests. - -Unit tests for core methods in the Data Commons Python API. -""" - -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - -try: - from unittest.mock import patch -except ImportError: - from mock import patch - -import six.moves.urllib as urllib - -import datacommons as dc -import datacommons.utils as utils -import json -import unittest - - -def request_mock(*args, **kwargs): - """ A mock urlopen in the urllib package. """ - # Create the mock response object. - class MockResponse: - def __init__(self, json_data): - self.json_data = json_data - - def read(self): - return self.json_data - - # Get the request data - req = args[0] - data = json.loads(req.data) - - # Mock responses for urlopen requests to get_property_labels. - if req.get_full_url() == utils._API_ROOT + utils._API_ENDPOINTS['get_property_labels']: - if data['dcids'] == ['geoId/0649670']: - # Response for sending a single dcid to get_property_labels - out_arcs = ['containedInPlace', 'name', 'geoId', 'typeOf'] - res_json = json.dumps({ - 'geoId/0649670': { - 'inLabels': [], - 'outLabels': out_arcs - } - }) - return MockResponse(json.dumps({'payload': res_json})) - elif data['dcids'] == ['State', 'County', 'City']: - # Response for sending multiple dcids to get_property_labels - in_arcs = ['typeOf'] - out_arcs = ['name', 'provenance', 'subClassOf', 'typeOf', 'url'] - res_json = json.dumps({ - 'City': {'inLabels': in_arcs, 'outLabels': out_arcs}, - 'County': {'inLabels': in_arcs, 'outLabels': out_arcs}, - 'State': {'inLabels': in_arcs, 'outLabels': out_arcs} - }) - return MockResponse(json.dumps({'payload': res_json})) - elif data['dcids'] == ['dc/MadDcid']: - # Response for sending a dcid that doesn't exist to get_property_labels - res_json = json.dumps({ - 'dc/MadDcid': { - 'inLabels': [], - 'outLabels': [] - } - }) - return MockResponse(json.dumps({'payload': res_json})) - elif data['dcids'] == []: - # Response for sending no dcids to get_property_labels - res_json = json.dumps({}) - return MockResponse(json.dumps({'payload': res_json})) - - # Mock responses for urlopen requests to get_property_values - if req.get_full_url() == utils._API_ROOT + utils._API_ENDPOINTS['get_property_values']: - if data['dcids'] == ['geoId/06085', 'geoId/24031']\ - and data['property'] == 'containedInPlace'\ - and data['value_type'] == 'Town': - # Response for sending a request for getting Towns containedInPlace of - # Santa Clara County and Montgomery County. - res_json = json.dumps({ - 'geoId/06085': { - 'in': [ - { - 'dcid': 'geoId/0644112', - 'name': 'Los Gatos', - 'provenanceId': 'dc/sm3m2w3', - 'types': [ - 'City', - 'Town' - ] - }, - { - 'dcid': 'geoId/0643294', - 'name': 'Los Altos Hills', - 'provenanceId': 'dc/sm3m2w3', - 'types': [ - 'City', - 'Town' - ] - } - ], - 'out': [] - }, - 'geoId/24031': { - 'in': [ - { - 'dcid': 'geoId/2462850', - 'name': 'Poolesville', - 'provenanceId': 'dc/sm3m2w3', - 'types': [ - 'City', - 'Town' - ] - }, - ], - 'out': [] - } - }) - return MockResponse(json.dumps({'payload': res_json})) - if data['dcids'] == ['geoId/06085', 'geoId/24031']\ - and data['property'] == 'name': - # Response for sending a request for the name of multiple dcids. - res_json = json.dumps({ - 'geoId/06085': { - 'in': [], - 'out': [ - { - 'value': 'Santa Clara County', - 'provenanceId': 'dc/sm3m2w3', - }, - ] - }, - 'geoId/24031': { - 'in': [], - 'out': [ - { - 'value': 'Montgomery County', - 'provenanceId': 'dc/sm3m2w3', - }, - ] - } - }) - return MockResponse(json.dumps({'payload': res_json})) - if data['dcids'] == ['dc/p/1234'] and data['property'] == 'name': - # Response for sending a request for the name with no data - res_json = json.dumps({ - 'dc/p/1234': {} - }) - return MockResponse(json.dumps({'payload': res_json})) - if data['dcids'] == ['geoId/06085', 'geoId/24031']\ - and data['property'] == 'madProperty': - # Response for sending a request with a property that does not exist. - res_json = json.dumps({ - 'geoId/06085': { - 'in': [], - 'out': [] - }, - 'geoId/24031': { - 'in': [], - 'out': [] - } - }) - return MockResponse(json.dumps({'payload': res_json})) - if data['dcids'] == ['geoId/06085', 'dc/MadDcid']\ - and data['property'] == 'containedInPlace': - # Response for sending a request with a single dcid that does not exist. - res_json = json.dumps({ - 'geoId/06085': { - 'in': [ - { - 'dcid': 'geoId/0644112', - 'name': 'Los Gatos', - 'provenanceId': 'dc/sm3m2w3', - 'types': [ - 'City', - 'Town' - ] - }, - ], - 'out': [] - }, - 'dc/MadDcid': { - 'in': [], - 'out': [] - } - }) - return MockResponse(json.dumps({'payload': res_json})) - if data['dcids'] == ['dc/MadDcid', 'dc/MadderDcid']: - # Response for sending a request where both dcids do not exist. - res_json = json.dumps({ - 'dc/MadDcid': { - 'in': [], - 'out': [] - }, - 'dc/MadderDcid': { - 'in': [], - 'out': [] - } - }) - return MockResponse(json.dumps({'payload': res_json})) - if data['dcids'] == [] and data['property'] == 'containedInPlace': - # Response for sending a request where no dcids are given. - res_json = json.dumps({}) - return MockResponse(json.dumps({'payload': res_json})) - - # Mock responses for urlopen requests to get_triples - if req.get_full_url() == utils._API_ROOT + utils._API_ENDPOINTS['get_triples']: - if data['dcids'] == ['geoId/06085', 'geoId/24031']: - # Response for sending a request with two valid dcids. - res_json = json.dumps({ - 'geoId/06085': [ - { - "subjectId": "geoId/06085", - "predicate": "name", - "objectValue": "Santa Clara County" - }, - { - "subjectId": "geoId/0649670", - "subjectName": "Mountain View", - "subjectTypes": [ - "City" - ], - "predicate": "containedInPlace", - "objectId": "geoId/06085", - "objectName": "Santa Clara County" - }, - { - "subjectId": "geoId/06085", - "predicate": "containedInPlace", - "objectId": "geoId/06", - "objectName": "California" - }, - ], - 'geoId/24031': [ - { - "subjectId": "geoId/24031", - "predicate": "name", - "objectValue": "Montgomery County" - }, - { - "subjectId": "geoId/2467675", - "subjectName": "Rockville", - "subjectTypes": [ - "City" - ], - "predicate": "containedInPlace", - "objectId": "geoId/24031", - "objectName": "Montgomery County" - }, - { - "subjectId": "geoId/24031", - "predicate": "containedInPlace", - "objectId": "geoId/24", - "objectName": "Maryland" - }, - ] - }) - return MockResponse(json.dumps({'payload': res_json})) - if data['dcids'] == ['geoId/06085', 'dc/MadDcid']: - # Response for sending a request where one dcid does not exist. - res_json = json.dumps({ - 'geoId/06085': [ - { - "subjectId": "geoId/06085", - "predicate": "name", - "objectValue": "Santa Clara County" - }, - { - "subjectId": "geoId/0649670", - "subjectName": "Mountain View", - "subjectTypes": [ - "City" - ], - "predicate": "containedInPlace", - "objectId": "geoId/06085", - "objectName": "Santa Clara County" - }, - { - "subjectId": "geoId/06085", - "predicate": "containedInPlace", - "objectId": "geoId/06", - "objectName": "California" - }, - ], - 'dc/MadDcid': [] - }) - return MockResponse(json.dumps({'payload': res_json})) - if data['dcids'] == ['dc/MadDcid', 'dc/MadderDcid']: - # Response for sending a request where both dcids do not exist. - res_json = json.dumps({ - 'dc/MadDcid': [], - 'dc/MadderDcid': [] - }) - return MockResponse(json.dumps({'payload': res_json})) - if data['dcids'] == []: - # Response for sending a request where no dcids are given. - res_json = json.dumps({}) - return MockResponse(json.dumps({'payload': res_json})) - - # Otherwise, return an empty response and a 404. - return urllib.error.HTTPError(None, 404, None, None, None) - - -class TestGetPropertyLabels(unittest.TestCase): - """ Unit tests for get_property_labels. """ - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_single_dcid(self, urlopen_mock): - """ Calling get_property_labels with a single dcid returns a valid - result. - """ - # Test for outgoing property labels - out_props = dc.get_property_labels(['geoId/0649670']) - self.assertDictEqual(out_props, - {'geoId/0649670': ["containedInPlace", "name", "geoId", "typeOf"]}) - - # Test with out=False - in_props = dc.get_property_labels(['geoId/0649670'], out=False) - self.assertDictEqual(in_props, {'geoId/0649670': []}) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_multiple_dcids(self, urlopen_mock): - """ Calling get_property_labels returns valid results with multiple - dcids. - """ - dcids = ['State', 'County', 'City'] - expected_in = ["typeOf"] - expected_out = ["name", "provenance", "subClassOf", "typeOf", "url"] - - # Test for outgoing property labels - out_props = dc.get_property_labels(dcids) - self.assertDictEqual(out_props, { - 'State': expected_out, - 'County': expected_out, - 'City': expected_out, - }) - - # Test for incoming property labels - in_props = dc.get_property_labels(dcids, out=False) - self.assertDictEqual(in_props, { - 'State': expected_in, - 'County': expected_in, - 'City': expected_in, - }) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_bad_dcids(self, urlopen_mock): - """ Calling get_property_labels with dcids that do not exist returns empty - results. - """ - # Test for outgoing property labels - out_props = dc.get_property_labels(['dc/MadDcid']) - self.assertDictEqual(out_props, {'dc/MadDcid': []}) - - # Test for incoming property labels - in_props = dc.get_property_labels(['dc/MadDcid'], out=False) - self.assertDictEqual(in_props, {'dc/MadDcid': []}) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_no_dcids(self, urlopen_mock): - """ Calling get_property_labels with no dcids returns empty results. """ - - # Test for outgoing property labels - out_props = dc.get_property_labels([]) - self.assertDictEqual(out_props, {}) - - # Test for incoming property labels - in_props = dc.get_property_labels([], out=False) - self.assertDictEqual(in_props, {}) - - -class TestGetPropertyValues(unittest.TestCase): - """ Unit tests for get_property_values. """ - - # --------------------------- STANDARD UNIT TESTS --------------------------- - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_multiple_dcids(self, urlopen_mock): - """ Calling get_property_values with multiple dcids returns valid - results. - """ - dcids = ['geoId/06085', 'geoId/24031'] - - # Get the containedInPlace Towns for Santa Clara and Montgomery County. - towns = dc.get_property_values( - dcids, 'containedInPlace', out=False, value_type='Town') - self.assertDictEqual(towns, { - 'geoId/06085': ['geoId/0643294', 'geoId/0644112'], - 'geoId/24031': ['geoId/2462850'] - }) - - dcids = ['geoId/06085', 'geoId/24031', float('nan')] - # Handle NaN values - towns = dc.get_property_values( - dcids, 'containedInPlace', out=False, value_type='Town') - self.assertDictEqual(towns, { - 'geoId/06085': ['geoId/0643294', 'geoId/0644112'], - 'geoId/24031': ['geoId/2462850'] - }) - - # Get the name of Santa Clara and Montgomery County. - names = dc.get_property_values(dcids, 'name') - self.assertDictEqual(names, { - 'geoId/06085': ['Santa Clara County'], - 'geoId/24031': ['Montgomery County'] - }) - - # Return empty result when there is no data. - names = dc.get_property_values(['dc/p/1234'], 'name') - self.assertDictEqual(names, { - 'dc/p/1234': [] - }) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_bad_dcids(self, urlopen_mock): - """ Calling get_property_values with dcids that do not exist returns empty - results. - """ - bad_dcids_1 = ['geoId/06085', 'dc/MadDcid'] - bad_dcids_2 = ['dc/MadDcid', 'dc/MadderDcid'] - - # Get entities containedInPlace of Santa Clara County and a dcid that does - # not exist. - contained_1 = dc.get_property_values(bad_dcids_1, 'containedInPlace', out=False) - self.assertDictEqual(contained_1, { - 'geoId/06085': ['geoId/0644112'], - 'dc/MadDcid': [] - }) - - # Get entities containedInPlace for two dcids that do not exist. - contained_2 = dc.get_property_values(bad_dcids_2, 'containedInPlace') - self.assertDictEqual(contained_2, { - 'dc/MadDcid': [], - 'dc/MadderDcid': [] - }) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_bad_property(self, urlopen_mock): - """ Calling get_property_values with a property that does not exist returns - empty results. - """ - # Get propery values for a property that does not exist. - prop_vals = dc.get_property_values( - ['geoId/06085', 'geoId/24031'], 'madProperty') - self.assertDictEqual(prop_vals, { - 'geoId/06085': [], - 'geoId/24031': [] - }) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_no_dcids(self, urlopen_mock): - """ Calling get_property_values with no dcids returns empty results. """ - # Get property values with an empty list of dcids. - prop_vals = dc.get_property_values([], 'containedInPlace') - self.assertDictEqual(prop_vals, {}) - -class TestGetTriples(unittest.TestCase): - """ Unit tests for get_triples. """ - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_multiple_dcids(self, urlopen_mock): - """ Calling get_triples with proper dcids returns valid results. """ - # Call get_triples - triples = dc.get_triples(['geoId/06085', 'geoId/24031']) - self.assertDictEqual(triples, { - 'geoId/06085': [ - ('geoId/06085', 'name', 'Santa Clara County'), - ('geoId/0649670', 'containedInPlace', 'geoId/06085'), - ('geoId/06085', 'containedInPlace', 'geoId/06'), - ], - 'geoId/24031': [ - ('geoId/24031', 'name', 'Montgomery County'), - ('geoId/2467675', 'containedInPlace', 'geoId/24031'), - ('geoId/24031', 'containedInPlace', 'geoId/24'), - ] - }) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_bad_dcids(self, urlopen_mock): - """ Calling get_triples with dcids that do not exist returns empty - results. - """ - # Call get_triples where one dcid does not exist - triples_1 = dc.get_triples(['geoId/06085', 'dc/MadDcid']) - self.assertDictEqual(triples_1, { - 'geoId/06085': [ - ('geoId/06085', 'name', 'Santa Clara County'), - ('geoId/0649670', 'containedInPlace', 'geoId/06085'), - ('geoId/06085', 'containedInPlace', 'geoId/06'), - ], - 'dc/MadDcid': [] - }) - - # Call get_triples where both dcids do not exist - triples_1 = dc.get_triples(['dc/MadDcid', 'dc/MadderDcid']) - self.assertDictEqual(triples_1, { - 'dc/MadDcid': [], - 'dc/MadderDcid': [] - }) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_no_dcids(self, urlopen_mock): - """ Calling get_triples with no dcids returns empty results. """ - # Call get_triples with no dcids - triples_1 = dc.get_triples([]) - self.assertDictEqual(triples_1, {}) - - -if __name__ == '__main__': - unittest.main() diff --git a/datacommons/test/places_test.py b/datacommons/test/places_test.py deleted file mode 100644 index d4147655..00000000 --- a/datacommons/test/places_test.py +++ /dev/null @@ -1,473 +0,0 @@ -# Copyright 2017 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -""" Data Commons Python API unit tests. - -Unit tests for Place methods in the Data Commons Python API. -""" - -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - -try: - from unittest.mock import patch -except ImportError: - from mock import patch - -import datacommons as dc -import datacommons.utils as utils -import json -import unittest -import six.moves.urllib as urllib - - -def request_mock(*args, **kwargs): - """ A mock urlopen requests sent in the requests package. """ - # Create the mock response object. - class MockResponse: - def __init__(self, json_data): - self.json_data = json_data - - def read(self): - return self.json_data - - req = args[0] - data = json.loads(req.data) - - # Mock responses for urlopen requests to get_places_in. - if req.get_full_url() == utils._API_ROOT + utils._API_ENDPOINTS['get_places_in']: - if (data['dcids'] == ['geoId/06085', 'geoId/24031'] - and data['place_type'] == 'City'): - # Response returned when querying for multiple valid dcids. - res_json = json.dumps([ - { - 'dcid': 'geoId/06085', - 'place': 'geoId/0649670', - }, - { - 'dcid': 'geoId/24031', - 'place': 'geoId/2467675', - }, - { - 'dcid': 'geoId/24031', - 'place': 'geoId/2476650', - }, - ]) - return MockResponse(json.dumps({'payload': res_json})) - if (data['dcids'] == ['geoId/06085', 'dc/MadDcid'] - and data['place_type'] == 'City'): - # Response returned when querying for a dcid that does not exist. - res_json = json.dumps([ - { - 'dcid': 'geoId/06085', - 'place': 'geoId/0649670', - }, - ]) - return MockResponse(json.dumps({'payload': res_json})) - if data['dcids'] == ['dc/MadDcid', 'dc/MadderDcid']\ - and data['place_type'] == 'City': - # Response returned when both given dcids do not exist. - res_json = json.dumps([]) - return MockResponse(json.dumps({'payload': res_json})) - if data['dcids'] == [] and data['place_type'] == 'City': - res_json = json.dumps([]) - # Response returned when no dcids are given. - return MockResponse(json.dumps({'payload': res_json})) - - - # Mock responses for urlopen requests to get_stats. - if req.get_full_url() == utils._API_ROOT + utils._API_ENDPOINTS['get_stats']: - if (data['place'] == ['geoId/05', 'geoId/06'] and - data['stats_var'] == 'dc/0hyp6tkn18vcb'): - # Response returned when querying for multiple valid dcids. - res_json = json.dumps({ - 'geoId/05': { - 'data': { - '2011': 18136, - '2012': 17279, - '2013': 17459, - '2014': 16966, - '2015': 17173, - '2016': 17041, - '2017': 17783, - '2018': 18003 - }, - 'place_name': 'Arkansas' - }, - 'geoId/06': { - 'data': { - '2011': 316667, - '2012': 324116, - '2013': 331853, - '2014': 342818, - '2015': 348979, - '2016': 354806, - '2017': 360645, - '2018': 366331 - }, - 'place_name': 'California' - } - }) - return MockResponse(json.dumps({'payload': res_json})) - if (data['place'] == ['geoId/00'] and - data['stats_var'] == 'dc/0hyp6tkn18vcb'): - # No data for the request - res_json = json.dumps({ - 'geoId/00': None - }) - return MockResponse(json.dumps({'payload': res_json})) - if ((data['place'] == ['geoId/05', 'dc/MadDcid'] or - data['place'] == ['geoId/05']) and - data['stats_var'] == 'dc/0hyp6tkn18vcb'): - # Response ignores dcid that does not exist. - res_json = json.dumps({ - 'geoId/05': { - 'data': { - '2011': 18136, - '2012': 17279, - '2013': 17459, - '2014': 16966, - '2015': 17173, - '2016': 17041, - '2017': 17783, - '2018': 18003 - }, - 'place_name': 'Arkansas' - } - }) - return MockResponse(json.dumps({'payload': res_json})) - if (data['place'] == ['geoId/06'] and - data['stats_var'] == 'dc/0hyp6tkn18vcb'): - res_json = json.dumps({ - 'geoId/06': { - 'data': { - '2011': 316667, - '2012': 324116, - '2013': 331853, - '2014': 342818, - '2015': 348979, - '2016': 354806, - '2017': 360645, - '2018': 366331 - }, - 'place_name': 'California' - } - }) - return MockResponse(json.dumps({'payload': res_json})) - if (data['place'] == ['dc/MadDcid', 'dc/MadderDcid'] and - data['stats_var'] == 'dc/0hyp6tkn18vcb'): - # Response returned when both given dcids do not exist. - res_json = json.dumps({}) - return MockResponse(json.dumps({'payload': res_json})) - if data['place'] == [] and data['stats_var'] == 'dc/0hyp6tkn18vcb': - res_json = json.dumps({}) - # Response returned when no dcids are given. - return MockResponse(json.dumps({'payload': res_json})) - if (data['place'] == ['geoId/48'] and - data['stats_var'] == 'dc/0hyp6tkn18vcb'): - if (data.get('measurement_method') == 'MM1' and - data.get('unit') == 'Inch' and - data.get('observation_period') == 'P1Y'): - res_json = json.dumps({ - 'geoId/48': { - 'data': { - '2015': 1, - '2016': 1, - }, - 'place_name': 'Texas' - } - }) - elif data.get('measurement_method') == 'MM1': - res_json = json.dumps({ - 'geoId/48': { - 'data': { - '2015': 2, - '2016': 2, - }, - 'place_name': 'Texas' - } - }) - else: - res_json = json.dumps({ - 'geoId/48': { - 'data': { - '2015': 3, - '2016': 3, - }, - 'place_name': 'Texas' - } - }) - - return MockResponse(json.dumps({'payload': res_json})) - - # Otherwise, return an empty response and a 404. - return urllib.error.HTTPError(None, 404, None, None, None) - -class TestGetPlacesIn(unittest.TestCase): - """ Unit stests for get_places_in. """ - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_multiple_dcids(self, urlopen): - """ Calling get_places_in with proper dcids returns valid results. """ - # Call get_places_in - places = dc.get_places_in(['geoId/06085', 'geoId/24031'], 'City') - self.assertDictEqual(places, { - 'geoId/06085': ['geoId/0649670'], - 'geoId/24031': ['geoId/2467675', 'geoId/2476650'] - }) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_bad_dcids(self, urlopen): - """ Calling get_places_in with dcids that do not exist returns empty - results. - """ - # Call get_places_in with one dcid that does not exist - bad_dcids_1 = dc.get_places_in(['geoId/06085', 'dc/MadDcid'], 'City') - self.assertDictEqual(bad_dcids_1, { - 'geoId/06085': ['geoId/0649670'], - 'dc/MadDcid': [] - }) - - # Call get_places_in when both dcids do not exist - bad_dcids_2 = dc.get_places_in(['dc/MadDcid', 'dc/MadderDcid'], 'City') - self.assertDictEqual(bad_dcids_2, { - 'dc/MadDcid': [], - 'dc/MadderDcid': [] - }) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_no_dcids(self, urlopen): - """ Calling get_places_in with no dcids returns empty results. """ - # Call get_places_in with no dcids. - bad_dcids = dc.get_places_in(['dc/MadDcid', 'dc/MadderDcid'], 'City') - self.assertDictEqual(bad_dcids, { - 'dc/MadDcid': [], - 'dc/MadderDcid': [] - }) - - -class TestGetStats(unittest.TestCase): - """ Unit stests for get_stats. """ - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_multiple_dcids(self, urlopen): - """ Calling get_stats with proper dcids returns valid results. """ - # Call get_stats - stats = dc.get_stats(['geoId/05', 'geoId/06'], 'dc/0hyp6tkn18vcb', 'all') - self.assertDictEqual( - stats, { - 'geoId/05': { - 'data': { - '2011': 18136, - '2012': 17279, - '2013': 17459, - '2014': 16966, - '2015': 17173, - '2016': 17041, - '2017': 17783, - '2018': 18003 - }, - 'place_name': 'Arkansas' - }, - 'geoId/06': { - 'data': { - '2011': 316667, - '2012': 324116, - '2013': 331853, - '2014': 342818, - '2015': 348979, - '2016': 354806, - '2017': 360645, - '2018': 366331 - }, - 'place_name': 'California' - } - }) - - # Call get_stats for latest obs - stats = dc.get_stats(['geoId/05', 'geoId/06'], 'dc/0hyp6tkn18vcb', 'latest') - self.assertDictEqual( - stats, { - 'geoId/05': { - 'data': { - '2018': 18003 - }, - 'place_name': 'Arkansas' - }, - 'geoId/06': { - 'data': { - '2018': 366331 - }, - 'place_name': 'California' - } - }) - - # Call get_stats for specific obs - stats = dc.get_stats(['geoId/05', 'geoId/06'], 'dc/0hyp6tkn18vcb', ['2013', '2018']) - self.assertDictEqual( - stats, { - 'geoId/05': { - 'data': { - '2013': 17459, - '2018': 18003 - }, - 'place_name': 'Arkansas' - }, - 'geoId/06': { - 'data': { - '2013': 331853, - '2018': 366331 - }, - 'place_name': 'California' - } - }) - - # Call get_stats -- dates must be in interable - stats = dc.get_stats(['geoId/05', 'geoId/06'], 'dc/0hyp6tkn18vcb', '2018') - self.assertDictEqual( - stats, { - 'geoId/05': { - 'data': { - }, - 'place_name': 'Arkansas' - }, - 'geoId/06': { - 'data': { - }, - 'place_name': 'California' - } - }) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_opt_args(self, urlopen): - """ Calling get_stats with mmethod, unit, and obs period returns specific data. - """ - # Set the API key - dc.set_api_key('TEST-API-KEY') - - # Call get_stats with all optional args - stats = dc.get_stats(['geoId/48'], 'dc/0hyp6tkn18vcb', 'latest', 'MM1', - 'Inch', 'P1Y') - self.assertDictEqual( - stats, { - 'geoId/48': { - 'data': { - '2016': 1 - }, - 'place_name': 'Texas' - } - }) - - # Call get_stats with mmethod specified - stats = dc.get_stats(['geoId/48'], 'dc/0hyp6tkn18vcb', 'latest', 'MM1') - self.assertDictEqual( - stats, { - 'geoId/48': { - 'data': { - '2016': 2 - }, - 'place_name': 'Texas' - } - }) - - # Call get_stats without optional args - stats = dc.get_stats(['geoId/48'], 'dc/0hyp6tkn18vcb', 'latest') - self.assertDictEqual( - stats, { - 'geoId/48': { - 'data': { - '2016': 3 - }, - 'place_name': 'Texas' - } - }) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_bad_dcids(self, urlopen): - """ Calling get_stats with dcids that do not exist returns empty - results. - """ - # Call get_stats with one dcid that does not exist - bad_dcids_1 = dc.get_stats(['geoId/05', 'dc/MadDcid'], 'dc/0hyp6tkn18vcb') - self.assertDictEqual( - bad_dcids_1, { - 'geoId/05': { - 'data': { - '2018': 18003 - }, - 'place_name': 'Arkansas' - } - }) - - # Call get_stats when both dcids do not exist - bad_dcids_2 = dc.get_stats(['dc/MadDcid', 'dc/MadderDcid'], - 'dc/0hyp6tkn18vcb') - self.assertDictEqual({}, bad_dcids_2) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_no_dcids(self, urlopen): - """ Calling get_stats with no dcids returns empty results. """ - # Call get_stats with no dcids. - no_dcids = dc.get_stats([], 'dc/0hyp6tkn18vcb') - self.assertDictEqual({}, no_dcids) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_no_data(self, urlopen): - """ Calling get_stats with for None data. """ - # Call get_stats with no dcids. - result = dc.get_stats(['geoId/00'], 'dc/0hyp6tkn18vcb') - self.assertDictEqual({}, result) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_batch_request(self, mock_urlopen): - """ Make multiple calls to REST API when number of geos exceeds the batch size. """ - save_batch_size = dc.utils._QUERY_BATCH_SIZE - dc.utils._QUERY_BATCH_SIZE = 1 - - self.assertEqual(0, mock_urlopen.call_count) - stats = dc.get_stats(['geoId/05'], 'dc/0hyp6tkn18vcb', 'latest') - self.assertDictEqual( - stats, { - 'geoId/05': { - 'data': { - '2018': 18003 - }, - 'place_name': 'Arkansas' - }, - }) - self.assertEqual(1, mock_urlopen.call_count) - - stats = dc.get_stats(['geoId/05', 'geoId/06'], 'dc/0hyp6tkn18vcb', 'latest') - self.assertDictEqual( - stats, { - 'geoId/05': { - 'data': { - '2018': 18003 - }, - 'place_name': 'Arkansas' - }, - 'geoId/06': { - 'data': { - '2018': 366331 - }, - 'place_name': 'California' - } - }) - self.assertEqual(3, mock_urlopen.call_count) - - dc.utils._QUERY_BATCH_SIZE = save_batch_size - - -if __name__ == '__main__': - unittest.main() diff --git a/datacommons/test/populations_test.py b/datacommons/test/populations_test.py deleted file mode 100644 index f1fd3323..00000000 --- a/datacommons/test/populations_test.py +++ /dev/null @@ -1,383 +0,0 @@ -# Copyright 2017 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -""" Data Commons Python API unit tests. - -Unit tests for Population and Observation methods in the Data Commons Python -Client API. -""" - -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - -import base64 - -try: - from unittest.mock import patch -except ImportError: - from mock import patch - -import datacommons as dc -import datacommons.utils as utils -import json -import unittest -import six.moves.urllib as urllib -import zlib - - -def request_mock(*args, **kwargs): - """ A mock urlopen request sent in the requests package. """ - # Create the mock response object. - class MockResponse: - def __init__(self, json_data): - self.json_data = json_data - - def read(self): - return self.json_data - - # Get the request json and allowed constraining properties - req = args[0] - if req.data: - data = json.loads(req.data) - - constrained_props = [ - { - 'property': 'placeOfBirth', - 'value': 'BornInOtherStateInTheUnitedStates' - }, - { - 'property': 'age', - 'value': 'Years5To17' - } - ] - - def compare_constraint_helper(constrained_props, data_pvs): - """Py2 workaround for unicode vs str comparison.""" - for cpv in constrained_props: - satisfied = False - for k, v in cpv.items(): - for pv in data_pvs: - if k in pv and pv[k] == cpv[k]: - print("found ", k, v, " in", pv) - satisfied = True - if satisfied == False: - return False - return True - - # Mock responses for urlopen request to get_populations. - if req.get_full_url() == utils._API_ROOT + utils._API_ENDPOINTS['get_populations']\ - and data['population_type'] == 'Person'\ - and compare_constraint_helper(constrained_props, data['pvs']): - if data['dcids'] == ['geoId/06085', 'geoId/4805000']: - # Response returned when querying for multiple valid dcids. - res_json = json.dumps([ - { - 'dcid': 'geoId/06085', - 'population': 'dc/p/crgfn8blpvl35' - }, - { - 'dcid': 'geoId/4805000', - 'population': 'dc/p/f3q9whmjwbf36' - } - ]) - return MockResponse(json.dumps({'payload': res_json})) - if data['dcids'] == ['geoId/06085', 'dc/MadDcid']: - # Response returned when querying for a dcid that does not exist. - res_json = json.dumps([ - { - 'dcid': 'geoId/06085', - 'population': 'dc/p/crgfn8blpvl35' - }, - ]) - return MockResponse(json.dumps({'payload': res_json})) - if data['dcids'] == ['dc/MadDcid', 'dc/MadderDcid'] or data['dcids'] == []: - # Response returned when both given dcids do not exist or no dcids are - # provided to the method. - res_json = json.dumps([]) - return MockResponse(json.dumps({'payload': res_json})) - - # Mock responses for urlopen request to get_observations - if req.get_full_url() == utils._API_ROOT + utils._API_ENDPOINTS['get_observations']\ - and data['measured_property'] == 'count'\ - and data['stats_type'] == 'measuredValue'\ - and data['observation_date'] == '2018-12'\ - and data['observation_period'] == 'P1M'\ - and data['measurement_method'] == 'BLSSeasonallyAdjusted': - if data['dcids'] == ['dc/p/x6t44d8jd95rd', 'dc/p/lr52m1yr46r44', 'dc/p/fs929fynprzs']: - # Response returned when querying for multiple valid dcids. - res_json = json.dumps([ - { - 'dcid': 'dc/p/x6t44d8jd95rd', - 'observation': '18704962.000000' - }, - { - 'dcid': 'dc/p/lr52m1yr46r44', - 'observation': '3075662.000000' - }, - { - 'dcid': 'dc/p/fs929fynprzs', - 'observation': '1973955.000000' - } - ]) - return MockResponse(json.dumps({'payload': res_json})) - if data['dcids'] == ['dc/p/x6t44d8jd95rd', 'dc/MadDcid']: - # Response returned when querying for a dcid that does not exist. - res_json = json.dumps([ - { - 'dcid': 'dc/p/x6t44d8jd95rd', - 'observation': '18704962.000000' - }, - ]) - return MockResponse(json.dumps({'payload': res_json})) - if data['dcids'] == ['dc/MadDcid', 'dc/MadderDcid'] or data['dcids'] == []: - # Response returned when both given dcids do not exist or no dcids are - # provided to the method. - res_json = json.dumps([]) - return MockResponse(json.dumps({'payload': res_json})) - - # Mock responses for urlopen request to get_place_obs - if req.get_full_url() == utils._API_ROOT + utils._API_ENDPOINTS['get_place_obs']\ - and data['place_type'] == 'City'\ - and data['observation_date'] == '2017'\ - and data['population_type'] == 'Person'\ - and compare_constraint_helper(constrained_props, data['pvs']): - res_json = json.dumps({ - 'places': [ - { - 'name': 'Marcus Hook borough', - 'place': 'geoId/4247344', - 'populations': { - 'dc/p/pq6frs32sfvk': { - 'observations': [ - { - 'marginOfError': 39, - 'measuredProp': 'count', - 'measuredValue': 67, - } - ], - } - } - } - ] - }) - return MockResponse(json.dumps( - {'payload': base64.b64encode(zlib.compress(res_json.encode('utf-8'))).decode('ascii')})) - - # Mock responses for get requests to get_pop_obs. - if req.get_full_url() == utils._API_ROOT + utils._API_ENDPOINTS['get_pop_obs'] + '?dcid=geoId/06085': - # Response returned when querying for a city in the graph. - res_json = json.dumps({ - 'name': 'Mountain View', - 'placeType': 'City', - 'populations': { - 'dc/p/013ldrstf6lnf': { - 'numConstraints': 6, - 'observations': [ - { - 'marginOfError': 119, - 'measuredProp': 'count', - 'measuredValue': 225, - 'measurementMethod': 'CensusACS5yrSurvey', - 'observationDate': '2014' - }, { - 'marginOfError': 108, - 'measuredProp': 'count', - 'measuredValue': 180, - 'measurementMethod': 'CensusACS5yrSurvey', - 'observationDate': '2012' - } - ], - 'popType': 'Person', - 'propertyValues': { - 'age': 'Years16Onwards', - 'gender': 'Male', - 'income': 'USDollar30000To34999', - 'incomeStatus': 'WithIncome', - 'race': 'USC_HispanicOrLatinoRace', - 'workExperience': 'USC_NotWorkedFullTime' - } - } - } - }) - return MockResponse(json.dumps( - {'payload': base64.b64encode(zlib.compress(res_json.encode('utf-8'))).decode('ascii')})) - - # Otherwise, return an empty response and a 404. - return urllib.error.HTTPError(None, 404, None, None, None) - -class TestGetPopulations(unittest.TestCase): - """ Unit tests for get_populations. """ - - _constraints = { - 'placeOfBirth': 'BornInOtherStateInTheUnitedStates', - 'age': 'Years5To17' - } - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_multiple_dcids(self, urlopen): - """ Calling get_populations with proper dcids returns valid results. """ - # Call get_populations - populations = dc.get_populations(['geoId/06085', 'geoId/4805000'], 'Person', - constraining_properties=self._constraints) - self.assertDictEqual(populations, { - 'geoId/06085': 'dc/p/crgfn8blpvl35', - 'geoId/4805000': 'dc/p/f3q9whmjwbf36' - }) - - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_bad_dcids(self, urlopen): - """ Calling get_populations with dcids that do not exist returns empty - results. - """ - # Call get_populations - pops_1 = dc.get_populations(['geoId/06085', 'dc/MadDcid'], 'Person', - constraining_properties=self._constraints) - pops_2 = dc.get_populations(['dc/MadDcid', 'dc/MadderDcid'], 'Person', - constraining_properties=self._constraints) - - # Verify the results - self.assertDictEqual(pops_1, {'geoId/06085': 'dc/p/crgfn8blpvl35'}) - self.assertDictEqual(pops_2, {}) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_no_dcids(self, urlopen): - """ Calling get_populations with no dcids returns empty results. """ - pops = dc.get_populations( - [], 'Person', constraining_properties=self._constraints) - self.assertDictEqual(pops, {}) - -class TestGetObservations(unittest.TestCase): - """ Unit tests for get_observations. """ - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_multiple_dcids(self, urlopen): - """ Calling get_observations with proper dcids returns valid results. """ - dcids = ['dc/p/x6t44d8jd95rd', 'dc/p/lr52m1yr46r44', 'dc/p/fs929fynprzs'] - expected = { - 'dc/p/lr52m1yr46r44': 3075662.0, - 'dc/p/fs929fynprzs': 1973955.0, - 'dc/p/x6t44d8jd95rd': 18704962.0 - } - actual = dc.get_observations(dcids, 'count', 'measuredValue', '2018-12', - observation_period='P1M', - measurement_method='BLSSeasonallyAdjusted') - self.assertDictEqual(actual, expected) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_bad_dcids(self, urlopen): - """ Calling get_observations with dcids that do not exist returns empty - results. - """ - # Get the input - dcids_1 = ['dc/p/x6t44d8jd95rd', 'dc/MadDcid'] - dcids_2 = ['dc/MadDcid', 'dc/MadderDcid'] - - # Call get_observations - actual_1 = dc.get_observations(dcids_1, 'count', 'measuredValue', '2018-12', - observation_period='P1M', - measurement_method='BLSSeasonallyAdjusted') - actual_2 = dc.get_observations(dcids_2, 'count', 'measuredValue', '2018-12', - observation_period='P1M', - measurement_method='BLSSeasonallyAdjusted') - - # Verify the results - self.assertDictEqual(actual_1, {'dc/p/x6t44d8jd95rd': 18704962.0}) - self.assertDictEqual(actual_2, {}) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_no_dcids(self, urlopen): - """ Calling get_observations with no dcids returns empty results. """ - actual = dc.get_observations([], 'count', 'measuredValue', '2018-12', - observation_period='P1M', - measurement_method='BLSSeasonallyAdjusted') - self.assertDictEqual(actual, {}) - - -class TestGetPopObs(unittest.TestCase): - """ Unit tests for get_pop_obs. """ - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_valid_dcid(self, urlopen): - """ Calling get_pop_obs with valid dcid returns valid results. """ - # Call get_pop_obs - pop_obs = dc.get_pop_obs('geoId/06085') - self.assertDictEqual(pop_obs, { - 'name': 'Mountain View', - 'placeType': 'City', - 'populations': { - 'dc/p/013ldrstf6lnf': { - 'numConstraints': 6, - 'observations': [ - { - 'marginOfError': 119, - 'measuredProp': 'count', - 'measuredValue': 225, - 'measurementMethod': 'CensusACS5yrSurvey', - 'observationDate': '2014' - }, { - 'marginOfError': 108, - 'measuredProp': 'count', - 'measuredValue': 180, - 'measurementMethod': 'CensusACS5yrSurvey', - 'observationDate': '2012' - } - ], - 'popType': 'Person', - 'propertyValues': { - 'age': 'Years16Onwards', - 'gender': 'Male', - 'income': 'USDollar30000To34999', - 'incomeStatus': 'WithIncome', - 'race': 'USC_HispanicOrLatinoRace', - 'workExperience': 'USC_NotWorkedFullTime' - } - } - } - }) - -class TestGetPlaceObs(unittest.TestCase): - """ Unit tests for get_place_obs. """ - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_valid(self, urlopen): - """ Calling get_place_obs with valid parameters returns a valid result. """ - # Call get_place_obs - pvs = { - 'placeOfBirth': 'BornInOtherStateInTheUnitedStates', - 'age': 'Years5To17' - } - place_obs = dc.get_place_obs( - 'City', '2017', 'Person', constraining_properties=pvs) - self.assertListEqual(place_obs, [ - { - 'name': 'Marcus Hook borough', - 'place': 'geoId/4247344', - 'populations': { - 'dc/p/pq6frs32sfvk': { - 'observations': [ - { - 'marginOfError': 39, - 'measuredProp': 'count', - 'measuredValue': 67, - } - ], - } - } - } - ]) - - -if __name__ == '__main__': - unittest.main() diff --git a/datacommons/test/query_test.py b/datacommons/test/query_test.py deleted file mode 100644 index 75b12a66..00000000 --- a/datacommons/test/query_test.py +++ /dev/null @@ -1,176 +0,0 @@ -# Copyright 2017 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -""" Data Commons Python API unit tests. - -Unit tests for the SPARQL query wrapper. -""" - -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - -try: - from unittest.mock import patch -except ImportError: - from mock import patch - -import datacommons as dc -import datacommons.utils as utils - -import json -import unittest -import six.moves.urllib as urllib - - -def request_mock(*args, **kwargs): - """ A mock urlopen call sent in the urllib package. """ - # Create the mock response object. - class MockResponse: - def __init__(self, json_data): - self.json_data = json_data - - def read(self): - return self.json_data - - # The accepted query. - accepted_query = (''' -SELECT ?name ?dcid -WHERE { - ?a typeOf Place . - ?a name ?name . - ?a dcid ("geoId/06" "geoId/21" "geoId/24") . - ?a dcid ?dcid -} -''') - - accepted_query2 = (''' -SELECT ?name ?dcid -WHERE { - ?a typeOf Place . - ?a name ?name . - ?a dcid ("geoId/DNE") . - ?a dcid ?dcid -} -''') - req = args[0] - data = json.loads(req.data) - - if req.get_full_url() == utils._API_ROOT + utils._API_ENDPOINTS['query']: - if data['sparql'] == accepted_query: - return MockResponse(json.dumps({ - 'header': [ - '?name', - '?dcid' - ], - 'rows': [ - { - 'cells': [ - { - 'value': 'California' - }, - { - 'value': 'geoId/06' - } - ] - }, - { - 'cells': [ - { - 'value': 'Kentucky' - }, - { - 'value': 'geoId/21' - } - ] - }, - { - 'cells': [ - { - 'value': 'Maryland' - }, - { - 'value': 'geoId/24' - } - ] - } - ] - })) - elif data['sparql'] == accepted_query2: - return MockResponse(json.dumps({ - 'header': [ - '?name', - '?dcid' - ], - })) - - # Otherwise, return an empty response and a 404. - return urllib.error.HTTPError(None, 404, None, None, None) - - -class TestQuery(unittest.TestCase): - """ Unit tests for the Query object. """ - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_rows(self, urlopen): - """ Sending a valid query returns the correct response. """ - # Create the SPARQL query - query_string = (''' -SELECT ?name ?dcid -WHERE { - ?a typeOf Place . - ?a name ?name . - ?a dcid ("geoId/06" "geoId/21" "geoId/24") . - ?a dcid ?dcid -} -''') - selector = lambda row: row['?name'] != 'California' - - # Issue the query - results = dc.query(query_string) - selected_results = dc.query(query_string, select=selector) - - # Execute the query and iterate through the results. - for idx, row in enumerate(results): - if idx == 0: - self.assertDictEqual(row, {'?name': 'California', '?dcid': 'geoId/06'}) - if idx == 1: - self.assertDictEqual(row, {'?name': 'Kentucky', '?dcid': 'geoId/21'}) - if idx == 2: - self.assertDictEqual(row, {'?name': 'Maryland', '?dcid': 'geoId/24'}) - - # Verify that the select function works. - for idx, row in enumerate(selected_results): - if idx == 0: - self.assertDictEqual(row, {'?name': 'Kentucky', '?dcid': 'geoId/21'}) - if idx == 1: - self.assertDictEqual(row, {'?name': 'Maryland', '?dcid': 'geoId/24'}) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_no_rows(self, urlopen): - """ Handles row-less response. """ - # Create a SPARQL query - query_string = (''' -SELECT ?name ?dcid -WHERE { - ?a typeOf Place . - ?a name ?name . - ?a dcid ("geoId/DNE") . - ?a dcid ?dcid -} -''') - # Issue the query - self.assertEqual(dc.query(query_string), []) - -if __name__ == '__main__': - unittest.main() diff --git a/datacommons/test/set_api_key_test.py b/datacommons/test/set_api_key_test.py deleted file mode 100644 index 0c6260e3..00000000 --- a/datacommons/test/set_api_key_test.py +++ /dev/null @@ -1,108 +0,0 @@ -# Copyright 2017 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -""" Data Commons Python API unit tests. - -Unit tests setting the API Key. -""" - -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - -try: - from unittest.mock import patch -except ImportError: - from mock import patch -import datacommons as dc -import datacommons.utils as utils - -import os -import json -import unittest -import six.moves.urllib as urllib - -_TEST_API_KEY = 'TEST-API-KEY' - -_SPARQL_NO_KEY = 'query_no_key' -_SPARQL_W_KEY = 'query_w_key' - -_SEND_REQ_NO_KEY = 'https://send_request_no_key.com' -_SEND_REQ_W_KEY = 'https://send_request_w_key.com' - - - -def request_mock(*args, **kwargs): - """ A mock urlopen call sent in the urllib package. """ - # Create the mock response object. - class MockResponse: - def __init__(self, json_data): - self.json_data = json_data - - def read(self): - return self.json_data - - req = args[0] - - if req.get_full_url() == _SEND_REQ_NO_KEY or json.loads(req.data) == {'sparql': _SPARQL_NO_KEY}: - assert 'X-api-key' not in req.headers - else: - assert req.get_header('X-api-key') == _TEST_API_KEY - - if req.get_full_url() == utils._API_ROOT + utils._API_ENDPOINTS['query']: - # Return a dummy response that will parse into [] by query() - return MockResponse(json.dumps({ - 'header': [ - '?name', - '?dcid' - ], - })) - else: - # Return a dummy response that will parse into {} by _send_request() - return MockResponse(json.dumps({'payload': json.dumps({})})) - - -class TestApiKey(unittest.TestCase): - """Unit test for setting or not setting the API Key.""" - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_query_no_api_key(self, urlopen): - del os.environ[utils._ENV_VAR_API_KEY] - # Issue a dummy SPARQL query that tells the mock to not expect a key - self.assertEqual(dc.query(_SPARQL_NO_KEY), []) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_send_request_no_api_key(self, urlopen): - del os.environ[utils._ENV_VAR_API_KEY] - # Issue a dummy url that tells the mock to not expect a key - self.assertEqual(utils._send_request(_SEND_REQ_NO_KEY, {'foo': ['bar']}), {}) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_query_w_api_key(self, urlopen): - """ Handles row-less response. """ - # Set the API key - dc.set_api_key('make_sure_I_am_replaced') - dc.set_api_key(_TEST_API_KEY) - # Issue a dummy SPARQL query that tells the mock to expect a key - self.assertEqual(dc.query(_SPARQL_W_KEY), []) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_send_request_w_api_key(self, urlopen): - """ Handles row-less response. """ - # Set the API key - dc.set_api_key(_TEST_API_KEY) - # Issue a dummy url that tells the mock to expect a key - self.assertEqual(utils._send_request(_SEND_REQ_W_KEY), {}) - - -if __name__ == '__main__': - unittest.main() diff --git a/datacommons/test/stat_vars_test.py b/datacommons/test/stat_vars_test.py deleted file mode 100644 index b4f409d2..00000000 --- a/datacommons/test/stat_vars_test.py +++ /dev/null @@ -1,362 +0,0 @@ -# Copyright 2020 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -""" Data Commons Python API unit tests. - -Unit tests for StatVar methods in the Data Commons Python API. -""" - -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - -try: - from unittest.mock import patch -except ImportError: - from mock import patch - -import datacommons as dc -import datacommons.utils as utils -import math -import json -import unittest -import six -import six.moves.urllib as urllib - -# Reusable parts of REST API /stat/all response. -CA_COUNT_PERSON = { - "isDcAggregate": - "true", - "sourceSeries": [{ - "val": { - "1990": 23640, - "1991": 24100, - "1993": 25090, - }, - "observationPeriod": "P1Y", - "importName": "WorldDevelopmentIndicators", - "provenanceDomain": "worldbank.org" - }, { - "val": { - "1790": 3929214, - "1800": 5308483, - "1810": 7239881, - }, - "measurementMethod": "WikidataPopulation", - "importName": "WikidataPopulation", - "provenanceDomain": "wikidata.org" - }, { - "val": { - "1890": 28360, - "1891": 24910, - "1892": 25070, - }, - "measurementMethod": "OECDRegionalStatistics", - "observationPeriod": "P1Y", - "importName": "OECDRegionalDemography", - "provenanceDomain": "oecd.org" - }] -} - -CA_COUNT_PERSON_MALE = { - "sourceSeries": [{ - "val": { - "1990": 12000, - "1991": 14000, - "1992": 14000, - }, - "measurementMethod": "WikidataPopulation", - "importName": "WikidataPopulation", - "provenanceDomain": "wikidata.org" - },] -} - -HU22_COUNT_PERSON = { - "sourceSeries": [{ - "val": { - "1990": 2360, - "1991": 2410, - "1992": 2500, - }, - "measurementMethod": "OECDRegionalStatistics", - "observationPeriod": "P1Y", - "importName": "OECDRegionalDemography", - "provenanceDomain": "oecd.org" - }] -} - -HU22_COUNT_PERSON_MALE = { - "sourceSeries": [{ - "val": { - "1990": 1360, - "1991": 1410, - "1992": 1500, - }, - "measurementMethod": "OECDRegionalStatistics", - "observationPeriod": "P1Y", - "importName": "OECDRegionalDemography", - "provenanceDomain": "oecd.org" - }] -} - -CA_MEDIAN_AGE_PERSON = { - "sourceSeries": [{ - "val": { - "1990": 12, - "1991": 24, - "1992": 24, - }, - "measurementMethod": "WikidataPopulation", - "importName": "WikidataPopulation", - "provenanceDomain": "wikidata.org" - }] -} - - -def request_mock(*args, **kwargs): - """A mock urlopen requests sent in the requests package.""" - - # Create the mock response object. - class MockResponse: - - def __init__(self, json_data): - self.json_data = json_data - - def read(self): - return self.json_data - - req = args[0] - - stat_value_url_base = utils._API_ROOT + utils._API_ENDPOINTS[ - 'get_stat_value'] - stat_series_url_base = utils._API_ROOT + utils._API_ENDPOINTS[ - 'get_stat_series'] - stat_all_url_base = utils._API_ROOT + utils._API_ENDPOINTS['get_stat_all'] - - # Mock responses for urlopen requests to get_stat_value. - if req.get_full_url( - ) == stat_value_url_base + '?place=geoId/06&stat_var=Count_Person': - # Response returned when querying with basic args. - return MockResponse(json.dumps({"value": 123})) - if req.get_full_url( - ) == stat_value_url_base + '?place=geoId/06&stat_var=Count_Person&date=2010': - # Response returned when querying with observationDate. - return MockResponse(json.dumps({"value": 133})) - if (req.get_full_url() == stat_value_url_base + - '?place=geoId/06&stat_var=Count_Person&' + - 'date=2010&measurement_method=CensusPEPSurvey&' + - 'observation_period=P1Y&unit=RealPeople&scaling_factor=100'): - # Response returned when querying with above optional params. - return MockResponse(json.dumps({"value": 103})) - - # Mock responses for urlopen requests to get_stat_series. - if req.get_full_url( - ) == stat_series_url_base + '?place=geoId/06&stat_var=Count_Person': - # Response returned when querying with basic args. - return MockResponse(json.dumps({"series": {"2000": 1, "2001": 2}})) - if (req.get_full_url() == stat_series_url_base + - '?place=geoId/06&stat_var=Count_Person&' + - 'measurement_method=CensusPEPSurvey&observation_period=P1Y&' + - 'unit=RealPeople&scaling_factor=100'): - - # Response returned when querying with above optional params. - return MockResponse(json.dumps({"series": {"2000": 3, "2001": 42}})) - if (req.get_full_url() == stat_series_url_base + - '?place=geoId/06&stat_var=Count_Person&' + - 'measurement_method=DNE'): - - # Response returned when data not available for optional parameters. - # /stat/series?place=geoId/06&stat_var=Count_Person&measurement_method=DNE - return MockResponse(json.dumps({"series": {}})) - - # Mock responses for urlopen requests to get_stat_all. - if req.get_full_url() == stat_all_url_base: - data = json.loads(req.data) - if (data['places'] == ['geoId/06', 'nuts/HU22'] and - data['stat_vars'] == ['Count_Person', 'Count_Person_Male']): - # Response returned when querying with above params. - # Response with data for all Place+StatVar combos. - full_resp = { - "placeData": { - "geoId/06": { - "statVarData": { - "Count_Person": CA_COUNT_PERSON, - "Count_Person_Male": CA_COUNT_PERSON_MALE, - } - }, - "nuts/HU22": { - "statVarData": { - "Count_Person": HU22_COUNT_PERSON, - "Count_Person_Male": HU22_COUNT_PERSON_MALE - } - } - } - } - return MockResponse(json.dumps(full_resp)) - - if (data['places'] == ['geoId/06', 'nuts/HU22'] and - data['stat_vars'] == ['Count_Person', 'Median_Age_Person']): - # Response returned when querying with above params. - # Median Age missing for HU22. - resp = { - "placeData": { - "geoId/06": { - "statVarData": { - "Count_Person": CA_COUNT_PERSON, - "Median_Age_Person": CA_MEDIAN_AGE_PERSON - } - }, - "nuts/HU22": { - "statVarData": { - "Count_Person": HU22_COUNT_PERSON, - "Median_Age_Person": {} - } - } - } - } - return MockResponse(json.dumps(resp)) - - if (data['places'] == ['badPlaceId', 'nuts/HU22'] and - data['stat_vars'] == ['Count_Person', 'badStatVarId']): - # Response returned when querying with above params. - # Bad DCIDs for place or statvar. - resp = { - "placeData": { - "badPlaceId": { - "statVarData": { - "Count_Person": {}, - "badStatVarId": {} - } - }, - "nuts/HU22": { - "statVarData": { - "Count_Person": HU22_COUNT_PERSON, - "badStatVarId": {} - } - } - } - } - return MockResponse(json.dumps(resp)) - - # Otherwise, return an empty response and a 404. - return urllib.error.HTTPError(None, 404, None, None, None) - - -class TestGetStatValue(unittest.TestCase): - """Unit tests for get_stat_value.""" - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_basic(self, urlopen): - """Calling get_stat_value with minimal and proper args.""" - # Call get_stat_value - - self.assertEqual(dc.get_stat_value('geoId/06', 'Count_Person'), 123) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_opt_args(self, urlopen): - """Calling get_stat_value with optional args returns specific data.""" - # Call get_stat_value for specific obs - self.assertEqual(dc.get_stat_value('geoId/06', 'Count_Person', '2010'), - 133) - - # Call get_stat_value with all optional args - stat = dc.get_stat_value('geoId/06', 'Count_Person', '2010', - 'CensusPEPSurvey', 'P1Y', 'RealPeople', 100) - self.assertEqual(stat, 103) - - # Call get_stat_series with bogus required args - stat = dc.get_stat_value('foofoo', 'barrbar') - self.assertTrue(math.isnan(stat)) - -class TestGetStatSeries(unittest.TestCase): - """Unit tests for get_stat_series.""" - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_basic(self, urlopen): - """Calling get_stat_value with minimal and proper args.""" - # Call get_stat_series - stats = dc.get_stat_series('geoId/06', 'Count_Person') - self.assertEqual(stats, {"2000": 1, "2001": 2}) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_opt_args(self, urlopen): - """Calling get_stat_value with optional args returns specific data.""" - - # Call get_stat_series with all optional args - stats = dc.get_stat_series('geoId/06', 'Count_Person', - 'CensusPEPSurvey', 'P1Y', 'RealPeople', 100) - self.assertEqual(stats, {"2000": 3, "2001": 42}) - - # Call get_stat_series with bogus required args - stats = dc.get_stat_series('foofoofoo', 'barfoobar') - self.assertEqual(stats, {}) - - # Call get_stat_series with non-satisfiable optional args - stats = dc.get_stat_series('geoId/06', 'Count_Person', 'DNE') - self.assertEqual(stats, {}) - - -class TestGetStatAll(unittest.TestCase): - """Unit tests for get_stat_all.""" - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_basic(self, urlopen): - """Calling get_stat_all with proper args.""" - # Expecting at least one TS per Place+StatVar - stats = dc.get_stat_all(['geoId/06', 'nuts/HU22'], - ['Count_Person', 'Count_Person_Male']) - exp = { - "geoId/06": { - "Count_Person": CA_COUNT_PERSON, - "Count_Person_Male": CA_COUNT_PERSON_MALE, - }, - "nuts/HU22": { - "Count_Person": HU22_COUNT_PERSON, - "Count_Person_Male": HU22_COUNT_PERSON_MALE - } - } - self.assertDictEqual(stats, exp) - # Expecting proper handling of no TS for Place+StatVar combo - stats = dc.get_stat_all(['geoId/06', 'nuts/HU22'], - ['Count_Person', 'Median_Age_Person']) - exp = { - "geoId/06": { - "Count_Person": CA_COUNT_PERSON, - "Median_Age_Person": CA_MEDIAN_AGE_PERSON - }, - "nuts/HU22": { - "Count_Person": HU22_COUNT_PERSON, - "Median_Age_Person": {} - } - } - self.assertDictEqual(stats, exp) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_bad_dcids(self, urlopen): - stats = dc.get_stat_all(['badPlaceId', 'nuts/HU22'], - ['Count_Person', 'badStatVarId']) - exp = { - "badPlaceId": { - "Count_Person": {}, - "badStatVarId": {} - }, - "nuts/HU22": { - "Count_Person": HU22_COUNT_PERSON, - "badStatVarId": {} - } - } - self.assertDictEqual(stats, exp) - - -if __name__ == '__main__': - unittest.main() diff --git a/datacommons/utils.py b/datacommons/utils.py deleted file mode 100644 index 3a0ebd01..00000000 --- a/datacommons/utils.py +++ /dev/null @@ -1,149 +0,0 @@ -# Copyright 2017 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -""" Data Commons Utilities Library. - -Various functions that can aid in the extension of the Data Commons API. -""" - -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - -from collections import defaultdict - -import base64 -import json -import os -import six.moves.urllib.error -import six.moves.urllib.request -import zlib - - -# --------------------------------- CONSTANTS --------------------------------- - - -# REST API endpoint root -_API_ROOT = "http://api.datacommons.org" - -# REST API endpoint paths -_API_ENDPOINTS = { - 'query': '/query', - 'get_property_labels': '/node/property-labels', - 'get_property_values': '/node/property-values', - 'get_triples': '/node/triples', - 'get_places_in': '/node/places-in', - 'get_related_places': '/node/related-places', - 'get_populations': '/node/populations', - 'get_observations': '/node/observations', - 'get_pop_obs': '/bulk/pop-obs', - 'get_place_obs': '/bulk/place-obs', - 'get_stats': '/bulk/stats', - 'get_stat_value': '/stat/value', - 'get_stat_series': '/stat/series', - 'get_stat_all': '/stat/all', -} - -# The default value to limit to -_MAX_LIMIT = 100 - -# Batch size for heavyweight queries. -_QUERY_BATCH_SIZE = 500 - -# Environment variable names used by the package -_ENV_VAR_API_KEY = 'DC_API_KEY' - -# --------------------------- API UTILITY FUNCTIONS --------------------------- - - -def set_api_key(api_key): - """Sets an environment variable :code:`"DC_API_KEY"` to given :code:`api_key`. - - Users may supply an API key to the Python API, which simply passes it on to - the REST API for handling. The API key can be provided to the API after - importing the library, or set as an environment variable - :code:`"DC_API_KEY"`. - - For more details about how to get an API key and provide it to the Python - Client API, please visit :ref:`getting_started`. - Args: - api_key (:obj:`str`): The API key. - """ - os.environ[_ENV_VAR_API_KEY] = api_key - - -# ------------------------- INTERNAL HELPER FUNCTIONS ------------------------- - - -def _send_request(req_url, req_json={}, compress=False, post=True, use_payload=True): - """ Sends a POST/GET request to req_url with req_json, default to POST. - - Returns: - The payload returned by sending the POST/GET request formatted as a dict. - """ - headers = { - 'Content-Type': 'application/json' - } - - # Pass along API key if provided - if os.environ.get(_ENV_VAR_API_KEY): - headers['x-api-key'] = os.environ[_ENV_VAR_API_KEY] - - # Send the request and verify the request succeeded - if post: - req = six.moves.urllib.request.Request( - req_url, - data=json.dumps(req_json).encode('utf-8'), - headers=headers) - else: - req = six.moves.urllib.request.Request(req_url, headers=headers) - try: - res = six.moves.urllib.request.urlopen(req) - except six.moves.urllib.error.HTTPError as e: - raise ValueError( - 'Response error: An HTTP {} code was returned by the REST API. ' - 'Printing response\n\n{}'.format(e.code, e.read())) - if isinstance(res, six.moves.urllib.error.HTTPError): - raise ValueError( - 'Response error: An HTTP {} code was returned by the REST API. ' - 'Printing response\n\n{}'.format(res.code, res.msg)) - # Get the JSON - res_json = json.loads(res.read()) - if not use_payload: - return res_json - if 'payload' not in res_json: - raise ValueError( - 'Response error: Payload not found. Printing response\n\n' - '{}'.format(res.text)) - - # If the payload is compressed, decompress and decode it - payload = res_json['payload'] - if compress: - payload = zlib.decompress( - base64.b64decode(payload), zlib.MAX_WBITS|32) - return json.loads(payload) - - -def _format_expand_payload(payload, new_key, must_exist=[]): - """ Formats expand type payloads into dicts from dcids to lists of values. """ - # Create the results dictionary from payload - results = defaultdict(set) - for entry in payload: - if 'dcid' in entry and new_key in entry: - dcid = entry['dcid'] - results[dcid].add(entry[new_key]) - - # Ensure all dcids in must_exist have some entry in results. - for dcid in must_exist: - results[dcid] - return {k: sorted(list(v)) for k, v in results.items()} diff --git a/datacommons_client/README.md b/datacommons_client/README.md new file mode 100644 index 00000000..f4563663 --- /dev/null +++ b/datacommons_client/README.md @@ -0,0 +1,24 @@ +# Data Commons Python API + +This is a Python library for accessing data in the Data Commons Graph. + +To get started, install this package from pip. + +```bash +pip install datacommons-client +``` + +To get additional functionality to work with Pandas DataFrames, install the package +with the optional Pandas dependency. + +```bash +pip install "datacommons-client[Pandas]" +``` + +Once the package is installed, import `datacommons_client`. + +```python +import datacommons_client as dc +``` + +For more detail on getting started with the API, please visit . diff --git a/datacommons_client/__init__.py b/datacommons_client/__init__.py new file mode 100644 index 00000000..ad654341 --- /dev/null +++ b/datacommons_client/__init__.py @@ -0,0 +1,22 @@ +__version__ = "2.1.6" +""" +Data Commons Client Package + +This package provides a Python client for interacting with the Data Commons API. +""" + +from datacommons_client.client import DataCommonsClient +from datacommons_client.endpoints.base import API +from datacommons_client.endpoints.node import NodeEndpoint +from datacommons_client.endpoints.observation import ObservationEndpoint +from datacommons_client.endpoints.resolve import ResolveEndpoint +from datacommons_client.utils.context import use_api_key + +__all__ = [ + "DataCommonsClient", + "API", + "NodeEndpoint", + "ObservationEndpoint", + "ResolveEndpoint", + "use_api_key", +] diff --git a/datacommons_client/client.py b/datacommons_client/client.py new file mode 100644 index 00000000..cb8b90d1 --- /dev/null +++ b/datacommons_client/client.py @@ -0,0 +1,211 @@ +from typing import Literal, Optional + +from datacommons_client.endpoints.base import API +from datacommons_client.endpoints.node import NodeEndpoint +from datacommons_client.endpoints.observation import ObservationEndpoint +from datacommons_client.endpoints.resolve import ResolveEndpoint +from datacommons_client.models.observation import ObservationDate +from datacommons_client.utils.dataframes import add_entity_names_to_observations_dataframe +from datacommons_client.utils.dataframes import add_property_constraints_to_observations_dataframe +from datacommons_client.utils.decorators import requires_pandas +from datacommons_client.utils.error_handling import NoDataForPropertyError + +try: + import pandas as pd +except ImportError: + pd = None + + +class DataCommonsClient: + """ + A client for interacting with the Data Commons API. + + This class provides convenient access to the V2 Data Commons API endpoints. + + Attributes: + api (API): An instance of the API class that handles requests. + node (NodeEndpoint): Provides access to node-related queries, such as fetching property labels + and values for individual or multiple nodes in the Data Commons knowledge graph. + observation (ObservationEndpoint): Handles observation-related queries, allowing retrieval of + statistical observations associated with entities, variables, and dates (e.g., GDP of California in 2010). + resolve (ResolveEndpoint): Manages resolution queries to find different DCIDs for entities. + + """ + + def __init__(self, + api_key: Optional[str] = None, + *, + dc_instance: Optional[str] = "datacommons.org", + url: Optional[str] = None, + surface_header_value: Optional[str] = None): + """ + Initializes the DataCommonsClient. + + Args: + api_key (Optional[str]): The API key for authentication. Defaults to None. Note that + custom DC instances do not currently require an API key. + dc_instance (Optional[str]): The Data Commons instance to use. Defaults to "datacommons.org". + url (Optional[str]): A custom, fully resolved URL for the Data Commons API. Defaults to None. + """ + # If a fully resolved URL is provided, and the default dc_instance is used, + # ignore that default value + if dc_instance == "datacommons.org" and url: + dc_instance = None + + # Create an instance of the API class which will be injected to the endpoints + self.api = API(api_key=api_key, + dc_instance=dc_instance, + url=url, + surface_header_value=surface_header_value) + + # Create instances of the endpoints + self.node = NodeEndpoint(api=self.api) + self.observation = ObservationEndpoint(api=self.api) + self.resolve = ResolveEndpoint(api=self.api) + + def _find_filter_facet_ids( + self, + fetch_by: Literal["entity", "entity_type"], + date: ObservationDate | str, + variable_dcids: str | list[str], + entity_dcids: Literal["all"] | list[str] = "all", + entity_type: Optional[str] = None, + parent_entity: Optional[str] = None, + property_filters: Optional[dict[str, str | list[str]]] = None, + ) -> list[str] | None: + """Finds matching facet IDs for property filters. + + Args: + fetch_by (Literal["entity", "entity_type"]): Determines whether to fetch by entity or entity type. + variable_dcids (str | list[str]): The variable DCIDs for which to retrieve facet IDs. + entity_dcids (Literal["all"] | list[str], optional): The entity DCIDs, or "all" if filtering by entity type. + entity_type (Optional[str]): The entity type, required if fetching by entity type. + parent_entity (Optional[str]): The parent entity, used when fetching by entity type. + property_filters (Optional[dict[str, str | list[str]]): A dictionary of properties to match facets against. + + Returns: + list[str] | None: A list of matching facet IDs, or None if no filters are applied. + """ + + if not property_filters: + return None + + if fetch_by == "entity": + observations = self.observation.fetch_observations_by_entity_dcid( + date=date, + entity_dcids=entity_dcids, + variable_dcids=variable_dcids, + select=["variable", "entity", "facet"], + ) + else: + observations = self.observation.fetch_observations_by_entity_type( + date=date, + entity_type=entity_type, + parent_entity=parent_entity, + variable_dcids=variable_dcids, + select=["variable", "entity", "facet"], + ) + + facet_sets = [ + observations.find_matching_facet_id(property_name=p, value=v) + for p, v in property_filters.items() + ] + + facet_ids = list({facet for facets in facet_sets for facet in facets}) + + return facet_ids + + @requires_pandas + def observations_dataframe( + self, + variable_dcids: str | list[str], + date: ObservationDate | str, + entity_dcids: Literal["all"] | list[str] = "all", + entity_type: Optional[str] = None, + parent_entity: Optional[str] = None, + property_filters: Optional[dict[str, str | list[str]]] = None, + include_constraints_metadata: bool = False, + ): + """ + Fetches statistical observations and returns them as a Pandas DataFrame. + + The Observation API fetches statistical observations linked to entities and variables + at a particular date (e.g., "population of USA in 2020", "GDP of California in 2010"). + + Args: + variable_dcids (str | list[str]): One or more variable DCIDs for the observation. + date (ObservationDate | str): The date for which observations are requested. It can be + a specific date, "all" to retrieve all observations, or "latest" to get the most recent observations. + entity_dcids (Literal["all"] | list[str], optional): The entity DCIDs for which to retrieve data. + Defaults to "all". + entity_type (Optional[str]): The type of entities to filter by when `entity_dcids="all"`. + Required if `entity_dcids="all"`. Defaults to None. + parent_entity (Optional[str]): The parent entity under which the target entities fall. + Required if `entity_dcids="all"`. Defaults to None. + property_filters (Optional[dict[str, str | list[str]]): An optional dictionary used to filter + the data by using observation properties like `measurementMethod`, `unit`, or `observationPeriod`. + include_constraints_metadata (bool): If True, includes the dcid and name of any constraint + properties associated with the variable DCIDs (based on the `constraintProperties` property) + in the returned DataFrame. Defaults to False. + + Returns: + pd.DataFrame: A DataFrame containing the requested observations. + """ + + if entity_dcids == "all" and not (entity_type and parent_entity): + raise ValueError( + "When 'entity_dcids' is 'all', both 'parent_entity' and 'entity_type' must be specified." + ) + + if entity_dcids != "all" and (entity_type or parent_entity): + raise ValueError( + "Specify 'entity_type' and 'parent_entity' only when 'entity_dcids' is 'all'." + ) + + # If property filters are provided, fetch the required facet IDs. Otherwise, set to None. + facets = self._find_filter_facet_ids( + fetch_by="entity" if entity_dcids != "all" else "entity_type", + date=date, + variable_dcids=variable_dcids, + entity_dcids=entity_dcids, + entity_type=entity_type, + parent_entity=parent_entity, + property_filters=property_filters, + ) + + if not facets and property_filters: + raise NoDataForPropertyError + + if entity_dcids == "all": + observations = self.observation.fetch_observations_by_entity_type( + date=date, + parent_entity=parent_entity, + entity_type=entity_type, + variable_dcids=variable_dcids, + filter_facet_ids=facets, + ) + else: + observations = self.observation.fetch_observations_by_entity_dcid( + date=date, + entity_dcids=entity_dcids, + variable_dcids=variable_dcids, + filter_facet_ids=facets, + ) + + # Convert the observations to a DataFrame + df = pd.DataFrame(observations.to_observation_records().model_dump()) + + # Add entity names to the DataFrame + df = add_entity_names_to_observations_dataframe( + endpoint=self.node, + observations_df=df, + entity_columns=["entity", "variable"], + ) + + if include_constraints_metadata: + df = add_property_constraints_to_observations_dataframe( + endpoint=self.node, + observations_df=df, + ) + + return df diff --git a/datacommons_client/endpoints/__init__.py b/datacommons_client/endpoints/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/datacommons_client/endpoints/base.py b/datacommons_client/endpoints/base.py new file mode 100644 index 00000000..ff4adfdc --- /dev/null +++ b/datacommons_client/endpoints/base.py @@ -0,0 +1,192 @@ +import re +from typing import Any, Dict, Optional + +from datacommons_client.utils.context import _API_KEY_CONTEXT_VAR +from datacommons_client.utils.request_handling import check_instance_is_valid +from datacommons_client.utils.request_handling import post_request +from datacommons_client.utils.request_handling import resolve_instance_url + + +class API: + """Represents a configured API interface to the Data Commons API. + + This class handles environment setup, resolving the base URL, building headers, + or optionally using a fully qualified URL directly. It can be used standalone + to interact with the API or in combination with Endpoint classes. + """ + + def __init__( + self, + api_key: Optional[str] = None, + dc_instance: Optional[str] = None, + url: Optional[str] = None, + surface_header_value: Optional[str] = None, + ): + """ + Initializes the API instance. + + Args: + api_key: The API key for authentication. Defaults to None. + dc_instance: The Data Commons instance domain. Ignored if `url` is provided. + Defaults to 'datacommons.org' if both `url` and `dc_instance` are None. + url: A fully qualified URL for the base API. This may be useful if more granular control + of the API is required (for local development, for example). If provided, dc_instance` + should not be provided. + surface_header_value: indicates which DC surface (MCP server, etc.) makes a call to the python library. + If the call originated internally, this is null and we pass in "clientlib-python" as the surface header + + Raises: + ValueError: If both `dc_instance` and `url` are provided. + """ + if dc_instance and url: + raise ValueError("Cannot provide both `dc_instance` and `url`.") + + if not dc_instance and not url: + dc_instance = "datacommons.org" + + if url is not None: + # Use the given URL directly (strip trailing slash) + self.base_url = check_instance_is_valid(url.rstrip("/"), api_key=api_key) + else: + # Resolve from dc_instance + self.base_url = resolve_instance_url(dc_instance) + + self.headers = self.build_headers(surface_header_value=surface_header_value, + api_key=api_key) + + def __repr__(self) -> str: + """Returns a readable representation of the API object. + + Indicates the base URL and if it's authenticated. + + Returns: + str: A string representation of the API object. + """ + has_auth = " (Authenticated)" if "X-API-Key" in self.headers else "" + return f"" + + def post(self, + payload: dict[str, Any], + endpoint: Optional[str] = None, + *, + all_pages: bool = True, + next_token: Optional[str] = None) -> Dict[str, Any]: + """Makes a POST request using the configured API environment. + + If `endpoint` is provided, it will be appended to the base_url. Otherwise, + it will just POST to the base URL. + + Args: + payload: The JSON payload for the POST request. + endpoint: An optional endpoint path to append to the base URL. + all_pages: If True, fetch all pages of the response. If False, fetch only the first page. + Defaults to True. Set to False to only fetch the first page. In that case, a + `next_token` key in the response will indicate if more pages are available. + That token can be used to fetch the next page. + + Returns: + A dictionary containing the merged response data. + + Raises: + ValueError: If the payload is not a valid dictionary. + """ + if not isinstance(payload, dict): + raise ValueError("Payload must be a dictionary.") + + url = (self.base_url if endpoint is None else f"{self.base_url}/{endpoint}") + + headers = self.headers + ctx_api_key = _API_KEY_CONTEXT_VAR.get() + if ctx_api_key: + # Copy headers to avoid mutating the shared client state + headers = self.headers.copy() + headers["X-API-Key"] = ctx_api_key + + return post_request(url=url, + payload=payload, + headers=headers, + all_pages=all_pages, + next_token=next_token) + + def build_headers(self, + surface_header_value: Optional[str], + api_key: Optional[str] = None) -> dict[str, str]: + """Build request headers for API requests. + + Includes JSON content type. If an API key is provided, add it as `X-API-Key`. + + Args: + self: the API, which includes API key and surface header if available + + Returns: + A dictionary of headers for the request. + """ + headers = { + "Content-Type": "application/json", + "x-surface": "clientlib-python" + } + if api_key: + headers["X-API-Key"] = api_key + + if surface_header_value: + headers["x-surface"] = surface_header_value + + return headers + + +class Endpoint: + """Represents a specific endpoint within the Data Commons API. + + This class leverages an API instance to make requests. It does not + handle instance resolution or headers directly; that is delegated to the API instance. + + Attributes: + endpoint (str): The endpoint path (e.g., 'node'). + api (API): The API instance providing configuration and the `post` method. + """ + + def __init__(self, endpoint: str, api: API): + """ + Initializes the Endpoint instance. + + Args: + endpoint: The endpoint path (e.g., 'node'). + api: An API instance that provides the environment configuration. + """ + self.endpoint = endpoint + self.api = api + + def __repr__(self) -> str: + """Returns a readable representation of the Endpoint object. + + Shows the endpoint and underlying API configuration. + + Returns: + str: A string representation of the Endpoint object. + """ + return f"<{self.endpoint.title()} Endpoint using {repr(self.api)}>" + + def post(self, + payload: dict[str, Any], + all_pages: bool = True, + next_token: Optional[str] = None) -> Dict[str, Any]: + """Makes a POST request to the specified endpoint using the API instance. + + Args: + payload: The JSON payload for the POST request. + all_pages: If True, fetch all pages of the response. If False, fetch only the first page. + Defaults to True. Set to False to only fetch the first page. In that case, a + `next_token` key in the response will indicate if more pages are available. + That token can be used to fetch the next page. + next_token: Optionally, the token to fetch the next page of results. Defaults to None. + + Returns: + A dictionary with the merged API response data. + + Raises: + ValueError: If the payload is not a valid dictionary. + """ + return self.api.post(payload=payload, + endpoint=self.endpoint, + all_pages=all_pages, + next_token=next_token) diff --git a/datacommons_client/endpoints/node.py b/datacommons_client/endpoints/node.py new file mode 100644 index 00000000..808c3495 --- /dev/null +++ b/datacommons_client/endpoints/node.py @@ -0,0 +1,654 @@ +from concurrent.futures import ThreadPoolExecutor +import contextvars +from functools import partial +from functools import wraps +from typing import Literal, Optional +import warnings + +from datacommons_client.endpoints.base import API +from datacommons_client.endpoints.base import Endpoint +from datacommons_client.endpoints.payloads import NodeRequestPayload +from datacommons_client.endpoints.payloads import normalize_list_to_string +from datacommons_client.endpoints.response import NodeResponse +from datacommons_client.models.node import Name +from datacommons_client.models.node import Node +from datacommons_client.models.node import StatVarConstraint +from datacommons_client.models.node import StatVarConstraints +from datacommons_client.utils.graph import build_graph_map +from datacommons_client.utils.graph import build_relationship_tree +from datacommons_client.utils.graph import fetch_relationship_lru +from datacommons_client.utils.graph import flatten_relationship +from datacommons_client.utils.names import DEFAULT_NAME_LANGUAGE +from datacommons_client.utils.names import DEFAULT_NAME_PROPERTY +from datacommons_client.utils.names import extract_name_from_english_name_property +from datacommons_client.utils.names import extract_name_from_property_with_language +from datacommons_client.utils.names import NAME_WITH_LANGUAGE_PROPERTY + +PLACES_MAX_WORKERS = 10 + +CONSTRAINT_PROPERTY: str = "constraintProperties" + +_DEPRECATED_METHODS: dict[str, dict[str, str | dict[str, str]]] = { + "fetch_entity_parents": { + "new_name": "fetch_place_parents", + "arg_map": { + "entity_dcids": "place_dcids" + } + }, + "fetch_entity_ascendancy": { + "new_name": "fetch_place_ancestors", + "arg_map": { + "entity_dcids": "place_dcids" + } + } +} + + +class NodeEndpoint(Endpoint): + """Initializes the NodeEndpoint with a given API configuration. + + Args: + api (API): The API instance providing the environment configuration + (base URL, headers, authentication) to be used for requests. + """ + + def __init__(self, api: API): + """Initializes the NodeEndpoint with a given API configuration.""" + super().__init__(endpoint="node", api=api) + + def __getattr__(self, name): + if name in _DEPRECATED_METHODS: + method_info = _DEPRECATED_METHODS[name] + new_name = method_info["new_name"] + arg_map = method_info.get("arg_map", {}) + new_method = getattr(self, new_name) + + @wraps(new_method) + def wrapper(*args, **kwargs): + for old_arg, new_arg in arg_map.items(): + if old_arg in kwargs: + warnings.warn( + f"Argument '{old_arg}' has been renamed and will removed" + f" in a future version. Use '{new_arg}' instead.", + category=DeprecationWarning, + stacklevel=2) + if new_arg not in kwargs: + kwargs[new_arg] = kwargs.pop(old_arg) + + warnings.warn( + f"'{name}' is deprecated and will be removed in a future version. " + f"Use '{new_name}' instead.", + category=DeprecationWarning, + stacklevel=2) + return new_method(*args, **kwargs) + + return wrapper + raise AttributeError( + f"'{self.__class__.__name__}' object has no attribute '{name}'") + + def fetch( + self, + node_dcids: str | list[str], + expression: str, + *, + all_pages: bool = True, + next_token: Optional[str] = None, + ) -> NodeResponse: + """Fetches properties or arcs for given nodes and properties. + + Args: + node_dcids (str | List[str]): The DCID(s) of the nodes to query. + expression (str): The property or relation expression(s) to query. + all_pages: If True, fetch all pages of the response. If False, fetch only the first page. + Defaults to True. Set to False to only fetch the first page. In that case, a + `next_token` key in the response will indicate if more pages are available. + That token can be used to fetch the next page. + next_token: Optionally, the token to fetch the next page of results. Defaults to None. + + Returns: + NodeResponse: The response object containing the queried data. + + Example: + ```python + response = node.fetch( + node_dcids=["geoId/06"], + expression="<-" + ) + print(response) + ``` + """ + + # Create the payload + payload = NodeRequestPayload(node_dcids=node_dcids, + expression=expression).to_dict() + + # Make the request and return the response. + return NodeResponse.model_validate( + self.post(payload, all_pages=all_pages, next_token=next_token)) + + def fetch_property_labels( + self, + node_dcids: str | list[str], + out: bool = True, + *, + all_pages: bool = True, + next_token: Optional[str] = None, + ) -> NodeResponse: + """Fetches all property labels for the given nodes. + + Args: + node_dcids (str | list[str]): The DCID(s) of the nodes to query. + out (bool): Whether to fetch outgoing properties (`->`). Defaults to True. + all_pages: If True, fetch all pages of the response. If False, fetch only the first page. + Defaults to True. Set to False to only fetch the first page. In that case, a + `next_token` key in the response will indicate if more pages are available. + That token can be used to fetch the next page. + next_token: Optionally, the token to fetch the next page of results. Defaults to None. + + Returns: + NodeResponse: The response object containing the property labels. + + Example: + ```python + response = node.fetch_property_labels(node_dcids="geoId/06") + print(response) + ``` + """ + # Determine the direction of the properties. + expression = "->" if out else "<-" + + # Make the request and return the response. + return self.fetch( + node_dcids=node_dcids, + expression=expression, + all_pages=all_pages, + next_token=next_token, + ) + + def fetch_property_values( + self, + node_dcids: str | list[str], + properties: str | list[str], + constraints: Optional[str] = None, + out: bool = True, + *, + all_pages: bool = True, + next_token: Optional[str] = None, + ) -> NodeResponse: + """Fetches the values of specific properties for given nodes. + + Args: + node_dcids (str | List[str]): The DCID(s) of the nodes to query. + properties (str | List[str]): The property or relation expression(s) to query. + constraints (Optional[str]): Additional constraints for the query. Defaults to None. + out (bool): Whether to fetch outgoing properties. Defaults to True. + all_pages: If True, fetch all pages of the response. If False, fetch only the first page. + Defaults to True. Set to False to only fetch the first page. In that case, a + `next_token` key in the response will indicate if more pages are available. + That token can be used to fetch the next page. + next_token: Optionally, the token to fetch the next page of results. Defaults to None. + + + Returns: + NodeResponse: The response object containing the property values. + + Example: + ```python + response = node.fetch_property_values( + node_dcids=["geoId/06"], + properties="name", + out=True + ) + print(response) + ``` + """ + + # Normalize the input to a string (if it's a list), otherwise use the string as is. + properties = normalize_list_to_string(properties) + + # Construct the expression based on the direction and constraints. + direction = "->" if out else "<-" + expression = f"{direction}{properties}" + if constraints: + expression += f"{{{constraints}}}" + + return self.fetch( + node_dcids=node_dcids, + expression=expression, + all_pages=all_pages, + next_token=next_token, + ) + + def fetch_all_classes( + self, + *, + all_pages: bool = True, + next_token: Optional[str] = None, + ) -> NodeResponse: + """Fetches all Classes available in the Data Commons knowledge graph. + + Args: + all_pages: If True, fetch all pages of the response. If False, fetch only the first page. + Defaults to True. Set to False to only fetch the first page. In that case, a + `next_token` key in the response will indicate if more pages are available. + That token can be used to fetch the next page. + next_token: Optionally, the token to fetch the next page of results. Defaults to None. + + + Returns: + NodeResponse: The response object containing all statistical variables. + + Example: + ```python + response = node.fetch_all_classes() + print(response) + ``` + """ + + return self.fetch_property_values( + node_dcids="Class", + properties="typeOf", + out=False, + all_pages=all_pages, + next_token=next_token, + ) + + def fetch_entity_names( + self, + entity_dcids: str | list[str], + language: Optional[str] = DEFAULT_NAME_LANGUAGE, + fallback_language: Optional[str] = None, + ) -> dict[str, Name]: + """ + Fetches entity names in the specified language, with optional fallback to English. + Args: + entity_dcids: A single DCID or a list of DCIDs to fetch names for. + language: Language code (e.g., "en", "es"). Defaults to "en" (DEFAULT_NAME_LANGUAGE). + fallback_language: If provided, this language will be used as a fallback if the requested + language is not available. If not provided, no fallback will be used. + Returns: + A dictionary mapping each DCID to a dictionary with the mapped name, language, and + the property used. + """ + + # Check if entity_dcids is a single string. If so, convert it to a list. + if isinstance(entity_dcids, str): + entity_dcids = [entity_dcids] + + # If langauge is English, use the more efficient 'name' property. + name_property = (DEFAULT_NAME_PROPERTY if language == DEFAULT_NAME_LANGUAGE + else NAME_WITH_LANGUAGE_PROPERTY) + + # Fetch names the given entity DCIDs. + data = self.fetch_property_values( + node_dcids=entity_dcids, properties=name_property).get_properties() + + names: dict[str, Name] = {} + + # Iterate through the fetched data and populate the names dictionary. + for dcid, properties in data.items(): + if not properties: + continue + if language == "en": + name = extract_name_from_english_name_property( + properties=properties.get(name_property, [])) + lang_used = "en" + else: + name, lang_used = extract_name_from_property_with_language( + properties=properties.get(name_property, []), + language=language, + fallback_language=fallback_language, + ) + if name: + names[dcid] = Name( + value=name, + language=lang_used, + property=name_property, + ) + + return names + + def _fetch_contained_in_place( + self, + node_dcids: str | list[str], + out: bool = True, + contained_type: Optional[str] = None, + as_dict: bool = False, + ) -> dict[str, list[Node | dict]]: + """Fetches places that contain or are contained in the given nodes. Uses the + `containedInPlace` property to fetch parent or child place relationships. + + Args: + node_dcids (str | list[str]): One or more DCIDs representing geographic places. + out (bool, optional): If True, fetch places contained in the given node(s). + If False, fetch places that contain the given node(s). Defaults to True. + contained_type (str, optional): Optional type constraint (e.g., 'Country', + 'Country'). If provided, only fetches places of that type. + as_dict (bool, optional): If True, returns the result as a dictionary of + lists of dictionaries. If False, returns Node objects. Defaults to False. + + Returns: + dict[str, list[dict]] | dict[str, list[Any]]: A dictionary where keys are DCIDs + and values are lists of place relationships, either as raw objects or + dictionaries (if `as_dict` is True). + """ + if out and contained_type: + raise ValueError("When 'out' is True, `contained_type' must be None.") + + prop = "containedInPlace+" if contained_type else "containedInPlace" + + data = self.fetch_property_values( + node_dcids=node_dcids, + properties=prop, + out=out, + constraints=f"typeOf:{contained_type}" if contained_type else None, + ).get_properties() + + result = {} + for entity, property_nodes in data.items(): + nodes = property_nodes.get(prop, []) + result[entity] = [node.to_dict() for node in nodes] if as_dict else nodes + + return result + + def fetch_place_parents( + self, + place_dcids: str | list[str], + *, + as_dict: bool = True, + ) -> dict[str, list[Node | dict]]: + """Fetches the direct parents of one or more entities using the 'containedInPlace' property. + + Args: + place_dcids (str | list[str]): A single place DCID or a list of DCIDs to query. + as_dict (bool): If True, returns a dictionary mapping each input DCID to its + immediate parent entities. If False, returns a dictionary of Node objects. + + Returns: + dict[str, list[Node | dict]]: A dictionary mapping each input DCID to a list of its + immediate parent entities. Each parent is represented as a Node object or + as a dictionary with the same data. + """ + return self._fetch_contained_in_place( + node_dcids=place_dcids, + out=True, + contained_type=None, + as_dict=as_dict, + ) + + def fetch_place_children( + self, + place_dcids: str | list[str], + *, + children_type: Optional[str] = None, + as_dict: bool = True, + ) -> dict[str, list[Node | dict]]: + """Fetches the direct children of one or more entities using the 'containedInPlace' property. + + Args: + place_dcids (str | list[str]): A single place DCID or a list of DCIDs to query. + children_type (str, optional): The type of the child entities to + fetch (e.g., 'Country', 'State', 'IPCCPlace_50'). If None, fetches all child types. + as_dict (bool): If True, returns a dictionary mapping each input DCID to its + immediate children entities. If False, returns a dictionary of Node objects. + + Returns: + dict[str, list[Node | dict]]: A dictionary mapping each input DCID to a list of its + immediate children. Each child is represented as a Node object or as a dictionary with + the same data. + """ + return self._fetch_contained_in_place( + node_dcids=place_dcids, + out=False, + contained_type=children_type, + as_dict=as_dict, + ) + + def _fetch_place_relationships( + self, + place_dcids: str | list[str], + as_tree: bool = False, + *, + contained_type: Optional[str] = None, + relationship: Literal["parents", "children"], + max_concurrent_requests: Optional[int] = PLACES_MAX_WORKERS, + ) -> dict[str, list[dict[str, str]] | dict]: + """Fetches a full ancestors/descendants map per place DCID. + + For each input place DCID, this method builds the complete graph using a + breadth-first traversal and parallel fetching. + + Args: + place_dcids (str | list[str]): One or more DCIDs of the entities whose ancestry + will be fetched. + as_tree (bool): If True, returns a nested tree structure; otherwise, returns a flat list. + Defaults to False. + contained_type (Optional[str]): The type of the ancestry to fetch (e.g., 'Country', 'State'). + If None, fetches all ancestry types. + relationship (Literal["parents", "children"]): The type of relationship to fetch. + max_concurrent_requests (Optional[int]): The maximum number of concurrent requests to make. + Defaults to PLACES_MAX_WORKERS. + Returns: + dict[str, list[dict[str, str]] | dict]: A dictionary mapping each input DCID to either: + - A flat list of Node dictionaries (if `as_tree` is False), or + - A nested tree (if `as_tree` is True). + """ + + if isinstance(place_dcids, str): + place_dcids = [place_dcids] + + result = {} + + # Create a partial function to fetch relationships with the current parameters + fetch_fn = partial( + fetch_relationship_lru, + self, + contained_type=contained_type, + relationship=relationship, + ) + + # Use a thread pool to fetch ancestry graphs in parallel for each input entity + ctx = contextvars.copy_context() + with ThreadPoolExecutor(max_workers=max_concurrent_requests) as executor: + futures = [ + executor.submit(ctx.run, + build_graph_map, + root=dcid, + fetch_fn=fetch_fn) for dcid in place_dcids + ] + # Gather ancestry maps and postprocess into flat or nested form + for future in futures: + dcid, ancestry = future.result() + if as_tree: + ancestry = build_relationship_tree(root=dcid, + graph=ancestry, + relationship_key=relationship) + else: + ancestry = flatten_relationship(ancestry) + result[dcid] = ancestry + + return result + + def fetch_place_ancestors( + self, + place_dcids: str | list[str], + as_tree: bool = False, + *, + max_concurrent_requests: Optional[int] = PLACES_MAX_WORKERS, + ) -> dict[str, list[dict[str, str]] | dict]: + """Fetches the full ancestry (flat or nested) for one or more entities. + For each input DCID, this method builds the complete ancestry graph using a + breadth-first traversal and parallel fetching. + It returns either a flat list of unique parents or a nested tree structure for + each entity, depending on the `as_tree` flag. The flat list matches the structure + of the `/api/place/parent` endpoint of the DC website. + Args: + place_dcids (str | list[str]): One or more DCIDs of the entities whose ancestry + will be fetched. + as_tree (bool): If True, returns a nested tree structure; otherwise, returns a flat list. + Defaults to False. + max_concurrent_requests (Optional[int]): The maximum number of concurrent requests to make. + Defaults to PLACES_MAX_WORKERS. + Returns: + dict[str, list[dict[str, str]] | dict]: A dictionary mapping each input DCID to either: + - A flat list of parent dictionaries (if `as_tree` is False), or + - A nested ancestry tree (if `as_tree` is True). Each parent is represented by + a dict with 'dcid', 'name', and 'type'. + """ + + return self._fetch_place_relationships( + place_dcids=place_dcids, + as_tree=as_tree, + contained_type=None, + relationship="parents", + max_concurrent_requests=max_concurrent_requests, + ) + + def fetch_place_descendants( + self, + place_dcids: str | list[str], + descendants_type: Optional[str] = None, + as_tree: bool = False, + *, + max_concurrent_requests: Optional[int] = PLACES_MAX_WORKERS, + ) -> dict[str, list[dict[str, str]] | dict]: + """Fetches the full descendants (flat or nested) for one or more entities. + For each input DCID, this method builds the complete descendants graph using a + breadth-first traversal and parallel fetching. + + It returns either a flat list of unique child or a nested tree structure for + each entity, depending on the `as_tree` flag. + + Args: + place_dcids (str | list[str]): One or more DCIDs of the entities whose descendants + will be fetched. + descendants_type (Optional[str]): The type of the descendants to fetch (e.g., 'Country', 'State'). + If None, fetches all descendant types. + as_tree (bool): If True, returns a nested tree structure; otherwise, returns a flat list. + Defaults to False. + max_concurrent_requests (Optional[int]): The maximum number of concurrent requests to make. + Defaults to PLACES_MAX_WORKERS. + Returns: + dict[str, list[dict[str, str]] | dict]: A dictionary mapping each input DCID to either: + - A flat list of Node dictionaries (if `as_tree` is False), or + - A nested ancestry tree (if `as_tree` is True). Each child is represented by + a dict. + """ + + return self._fetch_place_relationships( + place_dcids=place_dcids, + as_tree=as_tree, + contained_type=descendants_type, + relationship="children", + max_concurrent_requests=max_concurrent_requests, + ) + + def _fetch_property_id_names(self, node_dcids: str | list[str], + properties: str | list[str]): + """Fetch target nodes for given properties and return only (dcid, name). + + For each input node and each requested property, returns the list of target + nodes as dictionaries with ``dcid`` and ``name``. + + Args: + node_dcids: A single DCID or a list of DCIDs to query. + properties: A property string or list of property strings. + + Returns: + A mapping: + `{ node_dcid: { property: [ {dcid, name}, ... ], ... }, ... }`. + """ + data = self.fetch_property_values(node_dcids=node_dcids, + properties=properties).get_properties() + + result: dict[str, dict[str, list[dict]]] = {} + + for node, props in data.items(): + result.setdefault(node, {}) + for prop, metadata in props.items(): + dest = result[node].setdefault(prop, []) + for n in metadata: + # Prefer 'dcid', but if property is terminal, fall back to 'value'. + dcid = n.dcid or n.value + name = n.name or n.value + dest.append({"dcid": dcid, "name": name}) + return result + + def fetch_statvar_constraints( + self, variable_dcids: str | list[str]) -> StatVarConstraints: + """Fetch constraint property/value pairs for statistical variables, using + the `constraintProperties` property. + + This returns, for each StatisticalVariable, the constraints that define it. + + Args: + variable_dcids: One or more StatisticalVariable DCIDs. + + Returns: + StatVarConstraints: + ``{ + : [ + { + "constraint_id": , + "constraint_name": , + "value_id": , + "value_name": , + }, + ... + ], + ... + }`` + """ + # Ensure variable_dcids is a list + if isinstance(variable_dcids, str): + variable_dcids = [variable_dcids] + + # Get constraints for the given variable DCIDs. + constraints_mapping = self._fetch_property_id_names( + node_dcids=variable_dcids, properties=[CONSTRAINT_PROPERTY]) + + # Per statvar mapping of dcid - name + per_sv_constraint_names = {} + # Global set of all constraint property IDs + all_constraint_prop_ids = set() + + for sv in variable_dcids: + # Get the constraint properties for this statvar + prop_entries = constraints_mapping.get(sv, + {}).get(CONSTRAINT_PROPERTY, []) + # Map the constraint properties to their names + id_to_name = {entry["dcid"]: entry.get("name") for entry in prop_entries} + # Add an entry for this statvar to the constraint names mapping + per_sv_constraint_names[sv] = id_to_name + # Update the global set of all constraint property IDs + all_constraint_prop_ids.update(id_to_name.keys()) + + # In a single request, fetch all values for all the constraints, for all statvars. + values_map = self._fetch_property_id_names( + node_dcids=variable_dcids, + properties=sorted(all_constraint_prop_ids), + ) + + # Build structured response. This will include vars with no constraints (empty dicts). + result = {sv: [] for sv in variable_dcids} + + for sv in variable_dcids: + constraint_names = per_sv_constraint_names.get(sv, {}) + sv_values = values_map.get(sv, {}) + + for constraintId, constraintName in constraint_names.items(): + values = sv_values.get(constraintId, []) + # Continue if the stat var doesn't actually define a value for one of its constraintProperties. + if not values: + continue + + # Build the StatVarConstraint object + result[sv].append( + StatVarConstraint( + constraintId=constraintId, + constraintName=constraintName, + valueId=values[0]["dcid"], + valueName=values[0].get("name"), + )) + + return StatVarConstraints.model_validate(result) diff --git a/datacommons_client/endpoints/observation.py b/datacommons_client/endpoints/observation.py new file mode 100644 index 00000000..a6871abb --- /dev/null +++ b/datacommons_client/endpoints/observation.py @@ -0,0 +1,191 @@ +from typing import Optional + +from datacommons_client.endpoints.base import API +from datacommons_client.endpoints.base import Endpoint +from datacommons_client.endpoints.payloads import ObservationRequestPayload +from datacommons_client.endpoints.response import ObservationResponse +from datacommons_client.models.observation import ObservationDate +from datacommons_client.models.observation import ObservationSelect +from datacommons_client.utils.data_processing import group_variables_by_entity + + +class ObservationEndpoint(Endpoint): + """ + A class to interact with the observation API endpoint. + + Args: + api (API): The API instance providing the environment configuration + (base URL, headers, authentication) to be used for requests. + """ + + def __init__(self, api: API): + """Initializes the ObservationEndpoint instance.""" + super().__init__(endpoint="observation", api=api) + + def fetch( + self, + variable_dcids: str | list[str], + date: ObservationDate | str = ObservationDate.LATEST, + select: Optional[list[ObservationSelect | str]] = None, + entity_dcids: Optional[str | list[str]] = None, + entity_expression: Optional[str] = None, + filter_facet_domains: Optional[str | list[str]] = None, + filter_facet_ids: Optional[str | list[str]] = None + ) -> ObservationResponse: + """ + Fetches data from the observation endpoint. + + Args: + variable_dcids (str | list[str]): One or more variable IDs for the data. + date (str | ObservationDate): The date for which data is being requested. + Defaults to the latest observation. + select (list[ObservationSelect]): Fields to include in the response. + Defaults to ["date", "variable", "entity", "value"]. + entity_dcids (Optional[str | list[str]]): One or more entity IDs to filter the data. + entity_expression (Optional[str]): A string expression to filter entities. + filter_facet_domains (Optional[str | list[str]]): One or more domain names to filter the data. + filter_facet_ids (Optional[str | list[str]]): One or more facet IDs to filter the data. + + Returns: + ObservationResponse: The response object containing observations for the specified query. + """ + # Construct the payload + payload = ObservationRequestPayload( + date=date, + variable_dcids=variable_dcids, + select=select, + entity_dcids=entity_dcids, + entity_expression=entity_expression, + filter_facet_domains=filter_facet_domains, + filter_facet_ids=filter_facet_ids, + ).to_dict() + + response = self.post(payload=payload) + + # Send the request + return ObservationResponse.model_validate(response) + + def fetch_observations_by_entity_type( + self, + date: ObservationDate | str, + parent_entity: str, + entity_type: str, + variable_dcids: str | list[str], + *, + select: Optional[list[ObservationSelect | str]] = None, + filter_facet_domains: Optional[str | list[str]] = None, + filter_facet_ids: Optional[str | list[str]] = None + ) -> ObservationResponse: + """ + Fetches all observations for a given entity type. + + Args: + date (ObservationDate | str): The date option for the observations. + Use 'all' for all dates, 'latest' for the most recent data, + or provide a date as a string (e.g., "2024"). + parent_entity (str): The parent entity under which the target entities fall. + For example, "africa" for African countries, or "Earth" for all countries. + entity_type (str): The type of entities for which to fetch observations. + For example, "Country" or "Region". + variable_dcids (str | list[str]): The variable(s) to fetch observations for. + This can be a single variable ID or a list of IDs. + select (Optional[list[ObservationSelect | str]]): Fields to include in the response. + If not provided, defaults to ["date", "variable", "entity", "value"]. + filter_facet_domains: Optional[str | list[str]: One or more domain names to filter the data. + filter_facet_ids: Optional[str | list[str]: One or more facet IDs to filter the data. + + Returns: + ObservationResponse: The response object containing observations for the specified entity type. + + Example: + To fetch all observations for African countries for a specific variable: + + ```python + api = API() + ObservationEndpoint(api).fetch_observations_by_entity_type( + date="all", + parent_entity="africa", + entity_type="Country", + variable_dcids="sdg/SI_POV_DAY1" + ) + ``` + """ + + return self.fetch( + variable_dcids=variable_dcids, + date=date, + select=[s for s in ObservationSelect] if not select else select, + entity_expression= + f"{parent_entity}<-containedInPlace+{{typeOf:{entity_type}}}", + filter_facet_domains=filter_facet_domains, + filter_facet_ids=filter_facet_ids) + + def fetch_observations_by_entity_dcid( + self, + date: ObservationDate | str, + entity_dcids: str | list[str], + variable_dcids: str | list[str], + *, + select: Optional[list[ObservationSelect | str]] = None, + filter_facet_domains: Optional[str | list[str]] = None, + filter_facet_ids: Optional[str | list[str]] = None + ) -> ObservationResponse: + """ + Fetches all observations for a given entity type. + + Args: + date (ObservationDate | str): The date option for the observations. + Use 'all' for all dates, 'latest' for the most recent data, + or provide a date as a string (e.g., "2024"). + entity_dcids (str | list[str]): One or more entity IDs to filter the data. + variable_dcids (str | list[str]): The variable(s) to fetch observations for. + This can be a single variable ID or a list of IDs. + select (Optional[list[ObservationSelect | str]]): Fields to include in the response. + If not provided, defaults to ["date", "variable", "entity", "value"]. + filter_facet_domains: Optional[str | list[str]: One or more domain names to filter the data. + filter_facet_ids: Optional[str | list[str]: One or more facet IDs to filter the data. + + Returns: + ObservationResponse: The response object containing observations for the specified entity type. + + Example: + To fetch all observations for Nigeria for a specific variable: + + ```python + api = API() + ObservationEndpoint(api).fetch_observations_by_entity_dcid( + date="all", + entity_dcids="country/NGA", + variable_dcids="sdg/SI_POV_DAY1" + ) + ``` + """ + + return self.fetch( + variable_dcids=variable_dcids, + date=date, + select=[s for s in ObservationSelect] if not select else select, + entity_dcids=entity_dcids, + filter_facet_domains=filter_facet_domains, + filter_facet_ids=filter_facet_ids) + + def fetch_available_statistical_variables( + self, + entity_dcids: str | list[str], + ) -> dict[str, list[str]]: + """ + Fetches available statistical variables (which have observations) for given entities. + Args: + entity_dcids (str | list[str]): One or more entity DCIDs(s) to fetch variables for. + Returns: + dict[str, list[str]]: A dictionary mapping entity DCIDs to their available statistical variables. + """ + + # Fetch observations for the given entity DCIDs. If variable is empty list + # all available variables are retrieved. + data = self.fetch( + entity_dcids=entity_dcids, + select=[ObservationSelect.VARIABLE, ObservationSelect.ENTITY], + variable_dcids=[]).get_data_by_entity() + + return group_variables_by_entity(data=data) diff --git a/datacommons_client/endpoints/payloads.py b/datacommons_client/endpoints/payloads.py new file mode 100644 index 00000000..af66334b --- /dev/null +++ b/datacommons_client/endpoints/payloads.py @@ -0,0 +1,139 @@ +from typing import Optional + +from pydantic import Field +from pydantic import field_serializer +from pydantic import field_validator +from pydantic import model_serializer +from pydantic import model_validator + +from datacommons_client.models.base import BaseDCModel +from datacommons_client.models.base import ListOrStr +from datacommons_client.models.observation import ObservationDate +from datacommons_client.models.observation import ObservationSelect +from datacommons_client.models.observation import ObservationSelectList + + +def normalize_list_to_string(value: str | list[str]) -> str: + """Converts a list of properties to a string.""" + + if isinstance(value, list): + return f"[{', '.join(value)}]" + + return value + + +class NodeRequestPayload(BaseDCModel): + """ + A Pydantic model to structure, normalize, and validate the payload for a Node V2 API request. + + Attributes: + node_dcids (str | list[str]): The DCID(s) of the nodes to query. + expression (str): The property or relation expression(s) to query. + """ + + node_dcids: ListOrStr = Field(..., serialization_alias="nodes") + expression: list | str = Field(..., serialization_alias="property") + + +class ObservationRequestPayload(BaseDCModel): + """ + A Pydantic model to structure, normalize, and validate the payload for an Observation V2 API request. + + Attributes: + date (str): The date for which data is being requested. + variable_dcids (str | list[str]): One or more variable IDs for the data. + select (list[ObservationSelect]): Fields to include in the response. + Defaults to ["date", "variable", "entity", "value"]. + entity_dcids (Optional[str | list[str]]): One or more entity IDs to filter the data. + entity_expression (Optional[str]): A string expression to filter entities. + filter_facet_domains (Optional[str | list[str]]): One or more domain names to filter the data. + filter_facet_ids (Optional[str | list[str]]): One or more facet IDs to filter the data. + """ + + date: ObservationDate | str = Field(default_factory=str, + validate_default=True) + variable_dcids: Optional[ListOrStr] = Field(default=None, + serialization_alias="variable") + select: Optional[list[str]] = None + entity_dcids: Optional[ListOrStr] = None + entity_expression: Optional[str | list[str]] = None + filter_facet_domains: Optional[ListOrStr] = None + filter_facet_ids: Optional[ListOrStr] = None + + @field_validator("date", mode="before") + def _validate_date(cls, v): + try: + return ObservationDate(v) + except ValueError: + return v + + @field_validator("select", mode="before") + def _coerce_select(cls, v): + return ObservationSelectList.model_validate(v).select + + @field_validator("entity_expression", mode="before") + def _coerce_expr(cls, v): + if v is None: + return v + if isinstance(v, list): + return normalize_list_to_string(v) + if isinstance(v, str): + return v + raise TypeError("expression must be a string or list[str]") + + @field_serializer("variable_dcids", "entity_dcids", when_used="unless-none") + def _serialise_dcids_fields(self, v): + return {"dcids": v} + + @field_serializer("entity_expression", when_used="unless-none") + def _serialise_expression_field(self, v): + return {"expression": v} + + @model_validator(mode="after") + def _check_one(self): + if bool(self.entity_dcids) == bool(self.entity_expression): + raise ValueError("Exactly one of dcids or expression must be set") + return self + + @model_serializer(mode="wrap") + def _wrap_filter(self, handler): + # Normal dump + data = handler(self) + + # pull out entity dcid or expression + entity = data.pop("entity_dcids", None) or data.pop("entity_expression", + None) + + # add entity to the data dictionary + data["entity"] = entity + + # pull out the two filter keys if present + domains = data.pop("filter_facet_domains", None) + ids = data.pop("filter_facet_ids", None) + + # only add "filter" if at least one is set + if domains or ids: + filter_dict = {} + if domains is not None: + filter_dict["domains"] = domains + if ids is not None: + filter_dict["facet_ids"] = ids + data["filter"] = filter_dict + + return data + + +class ResolveRequestPayload(BaseDCModel): + """ + A Pydantic model to structure, normalize, and validate the payload for a Resolve V2 API request. + + Attributes: + node_dcids (str | list[str]): The DCID(s) of the nodes to query. + expression (str): The relation expression to query. + """ + + node_dcids: ListOrStr = Field(..., serialization_alias="nodes") + expression: str | list[str] | None = Field(default=None, + serialization_alias="property") + resolver: str | None = Field(default=None, serialization_alias="resolver") + target: str | None = Field(default=None, serialization_alias="target") diff --git a/datacommons_client/endpoints/resolve.py b/datacommons_client/endpoints/resolve.py new file mode 100644 index 00000000..ca7c87c4 --- /dev/null +++ b/datacommons_client/endpoints/resolve.py @@ -0,0 +1,161 @@ +from typing import Optional + +from datacommons_client.endpoints.base import API +from datacommons_client.endpoints.base import Endpoint +from datacommons_client.endpoints.payloads import ResolveRequestPayload +from datacommons_client.endpoints.response import ResolveResponse + + +def _resolve_correspondence_expression(from_type: str, + to_type: str, + entity_type: str | None = None) -> str: + """ + Constructs a relation expression for fetching correspondence between entities of two types. + + Args: + from_type (str): The source entity type. + to_type (str): The target entity type. + entity_type (Optional[str]): Optional type of the entities. + + Returns: + str: The relation expression to fetch correspondence between entities of the given types. + """ + return (f"<-{from_type}{{typeOf:{entity_type}}}->{to_type}" + if entity_type else f"<-{from_type}->{to_type}") + + +class ResolveEndpoint(Endpoint): + """ + A class to interact with the resolve API endpoint. + + Args: + api (API): The API instance providing the environment configuration + (base URL, headers, authentication) to be used for requests. + """ + + def __init__(self, api: API): + """Initializes the ResolveEndpoint instance.""" + super().__init__(endpoint="resolve", api=api) + + def fetch(self, + node_ids: str | list[str], + expression: str | list[str] | None = None, + resolver: str | None = None, + target: str | None = None) -> ResolveResponse: + """ + Fetches resolved data for the given nodes and expressions, identified by name, + coordinates, or wiki ID. + + Args: + node_ids (str | list[str]): One or more node IDs to resolve. + expression (str): The relation expression to query. + resolver (str | None): The resolver type to use (e.g., "indicator"). + target (str | None): The resolution target (e.g., "custom_only"). + + Returns: + ResolveResponse: The response object containing the resolved data. + """ + # Check if the node_ids is a single string. If so, convert it to a list. + if isinstance(node_ids, str): + node_ids = [node_ids] + + # Construct the payload + payload = ResolveRequestPayload(node_dcids=node_ids, + expression=expression, + resolver=resolver, + target=target).to_dict() + + # Send the request and return the response + return ResolveResponse.model_validate(self.post(payload)) + + def fetch_indicators(self, + queries: str | list[str], + target: str | None = None) -> ResolveResponse: + """ + Fetches resolved indicators (StatisticalVariables or Topics) for the given queries. + + Args: + queries (str | list[str]): One or more queries (e.g. "population", "gdp"). + target (str | None): Optional target for resolution (e.g., "base_only", "custom_only", "base_and_custom"). + + Returns: + ResolveResponse: The response object containing the resolved indicators. + """ + return self.fetch(node_ids=queries, resolver="indicator", target=target) + + def fetch_dcids_by_name(self, + names: str | list[str], + entity_type: Optional[str] = None) -> ResolveResponse: + """ + Fetches DCIDs for entities by their names. + + Args: + names (str | list[str]): One or more entity names to resolve. + entity_type (Optional[str]): Optional type of the entities. + + Returns: + ResolveResponse: The response object containing the resolved DCIDs. + """ + + expression = _resolve_correspondence_expression(from_type="description", + to_type="dcid", + entity_type=entity_type) + + return self.fetch(node_ids=names, expression=expression) + + def fetch_dcids_by_wikidata_id( + self, + wikidata_ids: str | list[str], + entity_type: Optional[str] = None) -> ResolveResponse: + """ + Fetches DCIDs for entities by their Wikidata IDs. + + Args: + wikidata_ids (str | list[str]): One or more Wikidata IDs to resolve. + entity_type (Optional[str]): Optional type of the entities. + + Returns: + ResolveResponse: The response object containing the resolved DCIDs. + """ + expression = _resolve_correspondence_expression(from_type="wikidataId", + to_type="dcid", + entity_type=entity_type) + + return self.fetch(node_ids=wikidata_ids, expression=expression) + + def fetch_dcid_by_coordinates( + self, + latitude: str, + longitude: str, + entity_type: Optional[str] = None) -> ResolveResponse: + """ + Fetches DCIDs for entities by their geographic coordinates. + + Args: + latitude (str): Latitude of the entity. + longitude (str): Longitude of the entity. + entity_type (Optional[str]): Optional type of the entities to refine results + (e.g., "City", "State", "Country"). + + Returns: + ResolveResponse: The response object containing the resolved DCIDs. + + Example: + To find the DCID for "Mountain View" using its latitude and longitude: + ```python + latitude = "37.42" + longitude = "-122.08" + response = client.fetch_dcid_by_coordinates(latitude=latitude, longitude=longitude) + print(response.entities) + ``` + Note: + - For ambiguous results, providing an entity type (e.g., "City") can help disambiguate. + - The coordinates should be passed as strings in decimal format (e.g., "37.42", "-122.08"). + + + """ + expression = _resolve_correspondence_expression(from_type="geoCoordinate", + to_type="dcid", + entity_type=entity_type) + coordinates = f"{latitude}#{longitude}" + return self.fetch(node_ids=coordinates, expression=expression) diff --git a/datacommons_client/endpoints/response.py b/datacommons_client/endpoints/response.py new file mode 100644 index 00000000..9131ede4 --- /dev/null +++ b/datacommons_client/endpoints/response.py @@ -0,0 +1,266 @@ +from typing import Any, Dict, List, Optional + +from pydantic import Field +from pydantic import field_validator + +from datacommons_client.models.base import BaseDCModel +from datacommons_client.models.base import facetID +from datacommons_client.models.base import NextToken +from datacommons_client.models.base import NodeDCID +from datacommons_client.models.base import Property +from datacommons_client.models.node import Arcs +from datacommons_client.models.node import FlattenedPropertiesMapping +from datacommons_client.models.node import NodeDCIDList +from datacommons_client.models.node import NodeList +from datacommons_client.models.node import Properties +from datacommons_client.models.observation import ByVariable +from datacommons_client.models.observation import Facet +from datacommons_client.models.observation import ObservationRecords +from datacommons_client.models.observation import VariableByEntity +from datacommons_client.models.resolve import Entity +from datacommons_client.models.resolve import FlatCandidateMapping +from datacommons_client.utils.data_processing import flatten_properties +from datacommons_client.utils.data_processing import observations_as_records + + +class NodeResponse(BaseDCModel): + """Represents a response from the Node endpoint of the Data Commons API. + + Attributes: + data: A dictionary mapping node DCIDs to Arcs or Properties objects. + nextToken: A token for pagination, if present. + """ + + data: Dict[NodeDCID, Arcs | Properties] = Field(default_factory=dict) + nextToken: NextToken = None + + @field_validator("data", mode="before") + def _discriminate_data(cls, raw_data): + """Discriminates between Arcs and Properties based on the presence of 'arcs' key.""" + + def _parse_data( + data: Arcs | Properties | dict[str, Any]) -> Arcs | Properties: + if isinstance(data, (Arcs, Properties)): + return data + if "arcs" in data: + return Arcs.model_validate(data) + return Properties.model_validate(data) + + return {dcid: _parse_data(data) for dcid, data in raw_data.items()} + + def get_properties(self) -> FlattenedPropertiesMapping: + return flatten_properties(self.data) + + def extract_connected_nodes( + self, + subject_dcid: NodeDCID, + property_dcid: Property, + connected_node_types: Optional[str | list[str]] = None) -> NodeList: + """Retrieves Node objects in the NodeResponse connected to the subject node + via the specified property. + + Args: + subject_dcid: The DCID of the starting node in the arc. + property_dcid: The property connecting the subject node to the desired + target nodes. + connected_node_types: Optional. A type or list of types to filter the + connected nodes. If provided, only connected nodes that have at least + one of the specified types will be returned. If omitted, all nodes from + the arc are returned. + + Returns: + A list of Node objects that are connected to the subject node via the + specified property. + """ + if isinstance(connected_node_types, str): + connected_node_types = [connected_node_types] + + nodes = self.get_properties().get(subject_dcid, {}).get(property_dcid, []) + + connected_nodes = [] + for node in nodes: + if connected_node_types: + # Filter out nodes that are missing a list of types or do not have the + # desired type + if not node.types or not any(nt in node.types + for nt in connected_node_types): + continue + + connected_nodes.append(node) + + return NodeList.model_validate(connected_nodes) + + def extract_connected_dcids( + self, + subject_dcid: NodeDCID, + property_dcid: Property, + connected_node_types: Optional[str | list[str]] = None) -> NodeDCIDList: + """Retrieves DCIDs of the Nodes in the NodeResponse connected to the subject + node via the specified property. + + Args: + subject_dcid: The DCID of the starting node. + property_dcid: The property connecting the subject node to the desired + target nodes. + connected_node_types: Optional. A type or list of types to filter the + connected nodes. If provided, only DCIDs of connected nodes that have at + least one of the specified types will be returned. If omitted, DCIDs of + all nodes from the arc are returned. + + Returns: + A list of NodeDCIDs for the nodes connected via the specified property + from the subject node. + """ + + connected_nodes = self.extract_connected_nodes(subject_dcid, property_dcid, + connected_node_types) + + return NodeDCIDList.model_validate( + [node.dcid for node in connected_nodes if node.dcid]) + + +class ObservationResponse(BaseDCModel): + """Represents a response from the Observation endpoint of the Data Commons API. + + Attributes: + byVariable: A dictionary of variable DCIDs and their corresponding data. + facets: A dictionary of facet IDs and their corresponding data. + """ + + byVariable: ByVariable = Field(default_factory=ByVariable) + facets: Dict[facetID, Facet] = Field(default_factory=dict) + + def get_data_by_entity(self) -> VariableByEntity: + """Unpacks the data for each entity, for each variable. + + Returns: + Dict: The variables object from the response. + """ + raw_payload = { + var_dcid: var_model.byEntity + for var_dcid, var_model in self.byVariable.items() + } + return VariableByEntity.model_validate(raw_payload) + + def to_observation_records(self) -> ObservationRecords: + """Returns a flat list of observation records combining date, variable, entity, + observation, and facet metadata. + + This method transforms the nested `byVariable` and `facets` data in the ObservationResponse + into a flat list of dictionaries. Each dictionary (or "record") represents a single observation + for a variable and entity, enriched with its associated facet metadata (e.g., measurement method, + observation period, unit). + + This format is suitable for exporting to a DataFrame or serializing to JSON for tabular or analytical use. + + Returns: + ObservationRecord: A list of observation records, where each record contains the variable, + entity, date, value, facetId, and any additional metadata provided by the facet. + """ + return observations_as_records(data=self.get_data_by_entity(), + facets=self.facets) + + def get_facets_metadata(self) -> Dict[str, dict]: + """Extract metadata about StatVars from the response. This data is + structured as a dictionary of StatVars, each containing a dictionary of + facets with their corresponding metadata. + + Returns: + Dict[str, dict]: A dictionary of StatVars with their associated metadata, + including earliest and latest observation dates, observation counts, + measurementMethod, observationPeriod, and unit, etc. + """ + # Dictionary to store metadata + metadata = {} + + # Extract information from byVariable + data_by_entity = self.get_data_by_entity() + + # Extract facet information + facets_info = self.facets + + for dcid, variables in data_by_entity.items(): + metadata[dcid] = {} + + for entity_id, entity in variables.items(): + for facet in entity.orderedFacets: + facet_metadata = metadata[dcid].setdefault( + facet.facetId, + { + "earliestDate": {}, + "latestDate": {}, + "obsCount": {}, + }, + ) + + facet_metadata["earliestDate"][entity_id] = facet.earliestDate + facet_metadata["latestDate"][entity_id] = facet.latestDate + facet_metadata["obsCount"][entity_id] = facet.obsCount + + # Merge additional facet details + facet_metadata.update(facets_info.get(facet.facetId, {})) + + return metadata + + def find_matching_facet_id(self, property_name: str, + value: str | list[str]) -> list[str]: + """Finds facet IDs that match a given property and value. + + Args: + property_name (str): The property to match. + value (str | list): The value to match. Can be a string, number, or a list of values. + Returns: + list[str]: A list of facet IDs that match the property and value. + """ + # Initialize an empty list to store matching facet IDs + matching_facet_ids = [] + + # Iterate over the facets metadata to find matching facet IDs + for facet_data in self.get_facets_metadata().values(): + + # Iterate over each facet and its associated metadata + for facet_id, metadata in facet_data.items(): + + # Get the value of the specified property from the data + prop_value = metadata.get(property_name) + + # Check if the property value matches the specified value + if isinstance(value, list): + if prop_value in value: + matching_facet_ids.append(facet_id) + elif prop_value == value: + matching_facet_ids.append(facet_id) + + return matching_facet_ids + + +class ResolveResponse(BaseDCModel): + """Represents a response from the Resolve endpoint of the Data Commons API. + + Attributes: + entities (List[Entity]): A list of entities resolved by the API, each + containing the query node and its associated candidates. + """ + + entities: list[Entity] = Field(default_factory=list) + + def to_flat_dict(self) -> FlatCandidateMapping: + """ + Flattens resolved candidate data into a dictionary where each node maps to its candidates. + + Returns: + dict[str, Any]: A dictionary mapping nodes to their candidates. + If a node has only one candidate, it maps directly to the candidate instead of a list. + """ + items = {} + + for entity in self.entities: + node = entity.node + if len(entity.candidates) == 1: + items[node] = entity.candidates[0].dcid + else: + items[node] = [candidate.dcid for candidate in entity.candidates] + + items = FlatCandidateMapping.model_validate(items) + + return items diff --git a/datacommons_client/models/__init__.py b/datacommons_client/models/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/datacommons_client/models/base.py b/datacommons_client/models/base.py new file mode 100644 index 00000000..6f3e3e6f --- /dev/null +++ b/datacommons_client/models/base.py @@ -0,0 +1,123 @@ +from collections.abc import Mapping, MutableSequence +from pprint import pformat +from typing import Annotated, Any, Iterable, Optional, TypeAlias + +from pydantic import BaseModel +from pydantic import BeforeValidator +from pydantic import ConfigDict +from pydantic import RootModel + + +def listify(v: Any) -> list[str]: + if isinstance(v, (str, bytes)): + return [v] + if not isinstance(v, Iterable): + return [v] + return list(v) + + +variableDCID: TypeAlias = str +entityDCID: TypeAlias = str +facetID: TypeAlias = str +ListOrStr = Annotated[list[str] | str, BeforeValidator(listify)] +NextToken: TypeAlias = Optional[str] +NodeDCID: TypeAlias = str +ArcLabel: TypeAlias = str +Property: TypeAlias = str +PropertyList: TypeAlias = list[Property] +Query: TypeAlias = str +DominantType: TypeAlias = str + + +class BaseDCModel(BaseModel): + """Provides serialization methods for the Pydantic models used by the client.""" + + model_config = ConfigDict(validate_by_name=True, + validate_default=True, + validate_by_alias=True, + use_enum_values=True, + serialize_by_alias=True) + + def __str__(self) -> str: + """Returns a string representation of the instance.""" + return self.to_json() + + def to_dict(self, exclude_none: bool = True) -> dict[str, Any]: + """Converts the instance to a dictionary. + + Args: + exclude_none: If True, only include non-empty values in the response. + + Returns: + Dict[str, Any]: The dictionary representation of the instance. + """ + + return self.model_dump(mode="python", exclude_none=exclude_none) + + def to_json(self, exclude_none: bool = True) -> str: + """Converts the instance to a JSON string. + + Args: + exclude_none: If True, only include non-empty values in the response. + + Returns: + str: The JSON string representation of the instance. + """ + return self.model_dump_json(exclude_none=exclude_none, indent=2) + + +class DictLikeRootModel(RootModel, Mapping): + """A base class for models that can be treated as dictionaries.""" + + def __repr__(self) -> str: + return f"{self.__class__.__name__}({self.root})" + + def __str__(self) -> str: + return pformat(self.root, compact=True, width=80) + + def __getitem__(self, key: str) -> Any: + return self.root[key] + + def __iter__(self) -> Iterable[Any]: + return iter(self.root) + + def __len__(self) -> int: + return len(self.root) + + def __eq__(self, other: Any) -> bool: + if isinstance(other, DictLikeRootModel): + return self.root == other.root + else: + return self.root == other + + +class ListLikeRootModel(MutableSequence, RootModel): + """A base class for models that can be treated as lists.""" + + def __repr__(self) -> str: + return f"{self.__class__.__name__}({self.root})" + + def __str__(self) -> str: + return pformat(self.root, compact=True, width=80) + + def __getitem__(self, index: int) -> Any: + return self.root[index] + + def __setitem__(self, index: int, value: Any) -> None: + self.root[index] = value + + def __delitem__(self, index: int) -> None: + del self.root[index] + + def __len__(self) -> int: + return len(self.root) + + def __eq__(self, other: Any) -> bool: + if isinstance(other, ListLikeRootModel): + return self.root == other.root + else: + return self.root == other + + def insert(self, index: int, item: Any) -> None: + """Inserts an item at a specified index in the root list.""" + self.root.insert(index, item) diff --git a/datacommons_client/models/node.py b/datacommons_client/models/node.py new file mode 100644 index 00000000..00bf3472 --- /dev/null +++ b/datacommons_client/models/node.py @@ -0,0 +1,109 @@ +from typing import Optional + +from pydantic import Field + +from datacommons_client.models.base import ArcLabel +from datacommons_client.models.base import BaseDCModel +from datacommons_client.models.base import DictLikeRootModel +from datacommons_client.models.base import ListLikeRootModel +from datacommons_client.models.base import NodeDCID +from datacommons_client.models.base import Property +from datacommons_client.models.base import PropertyList + + +class Node(BaseDCModel): + """Represents an individual node in the Data Commons knowledge graph. + + Attributes: + dcid: The unique identifier for the node. + name: The name of the node. + provenanceId: The provenance ID for the node. + types: The types associated with the node. + value: The value of the node. + """ + dcid: Optional[str] = None + name: Optional[str] = None + provenanceId: Optional[str | list[str]] = None + types: Optional[list[str]] = None + value: Optional[str] = None + + +class Name(BaseDCModel): + """Represents a name associated with an Entity (node). + + Attributes: + value: The name of the Entity + language: The language of the name + property: The property used to get the name + """ + + value: str + language: str + property: str + + +class NodeGroup(BaseDCModel): + """Represents a group of nodes in the Data Commons knowledge graph. + + Attributes: + nodes: A list of Node objects in the group. + """ + + nodes: list[Node] = Field(default_factory=list) + + +class Arcs(BaseDCModel): + """Represents arcs in the Data Commons knowledge graph. + + Attributes: + arcs: A dictionary mapping arc labels to NodeGroup objects. + """ + + arcs: dict[ArcLabel, NodeGroup] = Field(default_factory=dict) + + +class Properties(BaseDCModel): + """Represents a group of properties in the Data Commons knowledge graph. + + Attributes: + properties: A list of property strings. + """ + + properties: Optional[PropertyList] = None + + +class FlattenedPropertiesMapping(BaseDCModel, + DictLikeRootModel[dict[NodeDCID, + PropertyList]]): + """A model to represent a mapping of node DCIDs to their properties.""" + + +class FlattenedArcsMapping(BaseDCModel, + DictLikeRootModel[dict[NodeDCID, dict[Property, + list[Node]]]]): + """A model to represent a mapping of node DCIDs to their arcs.""" + + +class NodeList(BaseDCModel, ListLikeRootModel[list[Node]]): + """A root model whose value is a list of Node objects.""" + + +class NodeDCIDList(BaseDCModel, ListLikeRootModel[list[NodeDCID]]): + """A root model whose value is a list of NodeDCID strings.""" + + +class StatVarConstraint(BaseDCModel): + """Represents a constraint for a statistical variable.""" + + constraintId: NodeDCID + constraintName: Optional[str] = None + valueId: NodeDCID + valueName: Optional[str] = None + + +class StatVarConstraints(BaseDCModel, + DictLikeRootModel[dict[NodeDCID, + list[StatVarConstraint]]]): + """A root model whose value is a dictionary of statvar ids - a list of StatVarConstraint objects. + This model is used to represent constraints associated with statistical variables. + """ diff --git a/datacommons_client/models/observation.py b/datacommons_client/models/observation.py new file mode 100644 index 00000000..43465889 --- /dev/null +++ b/datacommons_client/models/observation.py @@ -0,0 +1,208 @@ +from enum import Enum +from typing import List, Optional + +from pydantic import Field +from pydantic import field_validator +from pydantic import model_serializer +from pydantic import RootModel + +from datacommons_client.models.base import BaseDCModel +from datacommons_client.models.base import DictLikeRootModel +from datacommons_client.models.base import entityDCID +from datacommons_client.models.base import facetID +from datacommons_client.models.base import ListLikeRootModel +from datacommons_client.models.base import variableDCID +from datacommons_client.utils.error_handling import InvalidObservationSelectError + + +class ObservationDate(str, Enum): + LATEST = "LATEST" + ALL = "" + + @classmethod + def _missing_(cls, value): + if isinstance(value, str): + u = value.strip().upper() + if u == "LATEST": + return cls.LATEST + if u in ("ALL", ""): + return cls.ALL + raise ValueError(f"Invalid date value: '{value}'. Only 'LATEST' or" + f" '' (empty string) are allowed.") + + +class ObservationSelect(str, Enum): + DATE = "date" + VARIABLE = "variable" + ENTITY = "entity" + VALUE = "value" + FACET = "facet" + + @classmethod + def valid_values(cls): + """Returns a list of valid enum values.""" + return sorted(cls._value2member_map_.keys()) + + @classmethod + def _missing_(cls, value): + """Handle missing enum values by raising a custom error.""" + message = f"Invalid `select` Field: '{value}'. Only {', '.join(cls.valid_values())} are allowed." + raise InvalidObservationSelectError(message=message) + + +class ObservationSelectList(RootModel[list[ObservationSelect]]): + """A model to represent a list of ObservationSelect values. + + Attributes: + select (List[ObservationSelect]): A list of ObservationSelect enum values. + """ + + root: Optional[list[ObservationSelect | str]] = None + + @field_validator("root", mode="before") + def _validate_select(cls, v): + if v is None: + select = [ + ObservationSelect.DATE, + ObservationSelect.VARIABLE, + ObservationSelect.ENTITY, + ObservationSelect.VALUE, + ] + else: + select = v + + select = [ObservationSelect(s).value for s in select] + + required_select = {"variable", "entity"} + + missing_fields = required_select - set(select) + if missing_fields: + raise InvalidObservationSelectError(message=( + f"The 'select' field must include at least the following: {', '.join(required_select)} " + f"(missing: {', '.join(missing_fields)})")) + + return select + + @property + def select(self) -> list[str]: + """Return select values directly as list""" + return self.root or [] + + +class Observation(BaseDCModel): + """Represents an observation with a date and value. + + Attributes: + date (str): The date of the observation. + value (float): Optional. The value of the observation. + """ + + date: Optional[str] = None + value: Optional[float] = None + + +class OrderedFacet(BaseDCModel): + """Represents ordered facets of observations. + + Attributes: + earliestDate (str): The earliest date in the observations. + facetId (str): The identifier for the facet. + latestDate (str): The latest date in the observations. + obsCount (int): The total number of observations. + observations (List[Observation]): A list of observations associated with the facet. + """ + + earliestDate: Optional[str] = None + facetId: Optional[str] = None + latestDate: Optional[str] = None + obsCount: Optional[int] = None + observations: list[Observation] = Field(default_factory=list) + + +class OrderedFacets(BaseDCModel): + """Represents a list of ordered facets. + """ + orderedFacets: list[OrderedFacet] = Field(default_factory=list) + + +class Variable(BaseDCModel): + """Represents a variable with data grouped by entity. + + Attributes: + byEntity (dict[entityDCID, OrderedFacets]): A dictionary mapping + entities to their ordered facets. + """ + + byEntity: dict[entityDCID, OrderedFacets] = Field(default_factory=dict) + + +class Facet(BaseDCModel): + """Represents metadata for a facet. + + Attributes: + importName (str): The name of the data import. + measurementMethod (str): The method used to measure the data. + observationPeriod (str): The period over which the observations were made. + provenanceUrl (str): The URL of the data's provenance. + unit (str): The unit of the observations. + """ + + importName: Optional[str] = None + measurementMethod: Optional[str] = None + observationPeriod: Optional[str] = None + provenanceUrl: Optional[str] = None + unit: Optional[str] = None + + +class ByVariable(BaseDCModel, DictLikeRootModel[dict[variableDCID, Variable]]): + """A root model whose value is a dict mapping variableDCID to Variable.""" + + +class VariableByEntity(BaseDCModel, + DictLikeRootModel[dict[variableDCID, + dict[entityDCID, + OrderedFacets]]]): + """A root model whose value is a dict mapping entityDCID to Variable.""" + + +class ObservationRecord(Observation, Facet): + """Represents a record of observations for a specific variable and entity. + + Attributes: + date (str): The date of the observation. + value (float): The value of the observation. + """ + + entity: Optional[entityDCID] = None + variable: Optional[variableDCID] = None + facetId: Optional[facetID] = None + + _order = [ + "date", "entity", "variable", "facetId", "importName", + "measurementMethod", "observationPeriod", "provenanceUrl", "unit", "value" + ] + + @model_serializer(mode="wrap") + def _reorder(self, helper): + """Reorders the fields for serialization.""" + data = helper(self) + ordered = {} + + # Ensure the order of fields matches the specified order + for key in self._order: + if key in data: + ordered[key] = data.pop(key) + + # Add any remaining fields that were not in the order list + ordered.update(data) + + # Ensure the 'value' field is always at the end + if "value" in ordered: + ordered["value"] = ordered.pop("value") + + return ordered + + +class ObservationRecords(BaseDCModel, + ListLikeRootModel[list[ObservationRecord]]): + """A root model whose value is a list of ObservationRecord.""" diff --git a/datacommons_client/models/resolve.py b/datacommons_client/models/resolve.py new file mode 100644 index 00000000..919a9e36 --- /dev/null +++ b/datacommons_client/models/resolve.py @@ -0,0 +1,42 @@ +from typing import List, Optional + +from pydantic import Field + +from datacommons_client.models.base import BaseDCModel +from datacommons_client.models.base import DictLikeRootModel +from datacommons_client.models.base import DominantType +from datacommons_client.models.base import NodeDCID +from datacommons_client.models.base import Query + + +class Candidate(BaseDCModel): + """Represents a candidate in the resolution response. + + Attributes: + dcid (DCID): The Data Commons ID for the candidate. + dominantType (Optional[DominantType]): The dominant type of the candidate, + if available. This represents the primary type associated with the DCID. + """ + + dcid: NodeDCID = Field(default_factory=str) + dominantType: Optional[DominantType] = None + metadata: dict[str, str] | None = None + typeOf: list[str] | None = None + + +class Entity(BaseDCModel): + """Represents an entity with its resolution candidates. + + Attributes: + node (Query): The query string or node being resolved. + candidates (List[Candidate]): A list of candidates that match the query. + """ + + node: Query + candidates: list[Candidate] = Field(default_factory=list) + + +class FlatCandidateMapping(BaseDCModel, + DictLikeRootModel[dict[Query, + list[NodeDCID] | NodeDCID]]): + """A model to represent a mapping of queries to candidates.""" diff --git a/datacommons_client/tests/README.MD b/datacommons_client/tests/README.MD new file mode 100644 index 00000000..e69de29b diff --git a/datacommons_client/tests/endpoints/test_base.py b/datacommons_client/tests/endpoints/test_base.py new file mode 100644 index 00000000..eb81c71a --- /dev/null +++ b/datacommons_client/tests/endpoints/test_base.py @@ -0,0 +1,291 @@ +from unittest.mock import patch + +import pytest + +from datacommons_client.endpoints.base import API +from datacommons_client.endpoints.base import Endpoint + + +@patch( + "datacommons_client.endpoints.base.resolve_instance_url", + return_value="https://api.datacommons.org/v2", +) +@patch( + "datacommons_client.endpoints.base.check_instance_is_valid", + return_value="https://api.datacommons.org/v2", +) +def test_api_initialization_default(mock_check_instance, mock_resolve_instance): + """Tests default API initialization with `datacommons.org` instance.""" + api = API() + + assert api.base_url == "https://api.datacommons.org/v2" + assert api.headers == { + "Content-Type": "application/json", + "x-surface": "clientlib-python" + } + mock_resolve_instance.assert_called_once_with("datacommons.org") + + +@patch( + "datacommons_client.endpoints.base.check_instance_is_valid", + return_value="https://custom_instance.api/v2", +) +def test_api_initialization_with_url(mock_check_instance): + """Tests API initialization with a fully qualified URL.""" + api = API(url="https://custom_instance.api/v2") + assert api.base_url == "https://custom_instance.api/v2" + assert api.headers == { + "Content-Type": "application/json", + "x-surface": "clientlib-python" + } + mock_check_instance.assert_called_once_with("https://custom_instance.api/v2", + api_key=None) + + +@patch( + "datacommons_client.endpoints.base.resolve_instance_url", + return_value="https://custom-instance/api/v2", +) +def test_api_initialization_with_dc_instance(mock_resolve_instance_url): + """Tests API initialization with a custom Data Commons instance.""" + api = API(dc_instance="custom-instance") + + assert api.base_url == "https://custom-instance/api/v2" + assert api.headers == { + "Content-Type": "application/json", + "x-surface": "clientlib-python" + } + mock_resolve_instance_url.assert_called_once_with("custom-instance") + + +@patch( + "datacommons_client.endpoints.base.resolve_instance_url", + return_value="https://custom-instance/api/v2", +) +def test_api_initialization_with_surface_header(mock_url): + """Tests API initialization with a surface header """ + api = API(dc_instance="custom-instance", surface_header_value="mcp-1.1.0") + assert api.headers == { + "Content-Type": "application/json", + "x-surface": "mcp-1.1.0" + } + + +def test_api_initialization_invalid_args(): + """Tests API initialization with both `dc_instance` and `url` raises a ValueError.""" + with pytest.raises(ValueError): + API(dc_instance="custom-instance", url="https://custom.api/v2") + + +@patch( + "datacommons_client.endpoints.base.resolve_instance_url", + return_value="https://custom-instance/api/v2", +) +def test_build_headers_without_api_key(mock_url): + """Tests building headers without an API key.""" + api = API(dc_instance="custom-instance") + assert api.headers["Content-Type"] == "application/json" + assert "X-API-Key" not in api.headers + + +@patch( + "datacommons_client.endpoints.base.resolve_instance_url", + return_value="https://custom-instance/api/v2", +) +def test_build_headers_with_api_key_no_surface(mock_url): + """Tests building headers with an API key.""" + api = API(dc_instance="custom-instance", api_key="test_key") + assert api.headers["Content-Type"] == "application/json" + assert api.headers["X-API-Key"] == "test_key" + + +@patch( + "datacommons_client.endpoints.base.resolve_instance_url", + return_value="https://custom-instance/api/v2", +) +def test_build_headers_with_api_key_and_surface(mock_url): + """Tests building headers with an API key and a surface header.""" + api = API(dc_instance="custom-instance", + api_key="test_key", + surface_header_value="mcp-1.0") + assert api.headers["Content-Type"] == "application/json" + assert api.headers["X-API-Key"] == "test_key" + assert api.headers["x-surface"] == "mcp-1.0" + + +@patch( + "datacommons_client.endpoints.base.post_request", + return_value={"success": True}, +) +@patch( + "datacommons_client.endpoints.base.check_instance_is_valid", + return_value="https://custom_instance.api/v2", +) +def test_api_post_request(mock_check_instance, mock_post_request): + """Tests making a POST request using the API object.""" + api = API(url="https://custom_instance.api/v2") + payload = {"key": "value"} + + response = api.post(payload=payload, endpoint="test-endpoint", all_pages=True) + assert response == {"success": True} + mock_post_request.assert_called_once_with( + url="https://custom_instance.api/v2/test-endpoint", + payload=payload, + headers=api.headers, + all_pages=True, + next_token=True) + + +@patch( + "datacommons_client.endpoints.base.post_request", + return_value={"success": True}, +) +@patch( + "datacommons_client.endpoints.base.check_instance_is_valid", + return_value="https://custom.api/v2", +) +def test_endpoint_post_request(mock_check_instance, mock_post_request): + """Tests making a POST request using the Endpoint object.""" + api = API(url="https://custom.api/v2") + endpoint = Endpoint(endpoint="node", api=api) + payload = {"key": "value"} + + response = endpoint.post(payload=payload, all_pages=True) + assert response == {"success": True} + mock_post_request.assert_called_once_with(url="https://custom.api/v2/node", + payload=payload, + headers=api.headers, + all_pages=True, + next_token=None) + + +@patch( + "datacommons_client.endpoints.base.check_instance_is_valid", + return_value="https://custom_instance.api/v2", +) +def test_api_post_request_invalid_payload(mock_check_instance): + """Tests that an invalid payload raises a ValueError.""" + api = API(url="https://custom_instance.api/v2") + + with pytest.raises(ValueError): + api.post(payload=["invalid", "payload"], endpoint="test-endpoint") + + +@patch( + "datacommons_client.endpoints.base.check_instance_is_valid", + return_value="https://custom_instance.api/v2", +) +def test_endpoint_initialization(mock_check_instance): + """Tests initializing an Endpoint with a valid API instance.""" + api = API(url="https://custom_instance.api/v2") + endpoint = Endpoint(endpoint="node", api=api) + + assert endpoint.endpoint == "node" + assert endpoint.api is api + + +@patch( + "datacommons_client.endpoints.base.check_instance_is_valid", + return_value="https://custom.api/v2", +) +def test_endpoint_repr(mock_check_instance): + """Tests the string representation of the Endpoint object.""" + api = API(url="https://custom.api/v2") + endpoint = Endpoint(endpoint="node", api=api) + + assert ( + repr(endpoint) == ">") + + +@patch( + "datacommons_client.endpoints.base.post_request", + return_value={"success": True}, +) +@patch( + "datacommons_client.endpoints.base.check_instance_is_valid", + return_value="https://custom.api/v2", +) +def test_endpoint_post_request(mock_check_instance, mock_post_request): + """Tests making a POST request using the Endpoint object.""" + api = API(url="https://custom.api/v2") + endpoint = Endpoint(endpoint="node", api=api) + payload = {"key": "value"} + + response = endpoint.post(payload=payload, all_pages=True) + assert response == {"success": True} + mock_post_request.assert_called_once_with(url="https://custom.api/v2/node", + payload=payload, + headers=api.headers, + all_pages=True, + next_token=None) + + +@pytest.mark.parametrize("all_pages", [True, False]) +@pytest.mark.parametrize("next_token", ["token123", None]) +@patch( + "datacommons_client.endpoints.base.post_request", + return_value={"success": True}, +) +@patch( + "datacommons_client.endpoints.base.check_instance_is_valid", + return_value="https://custom_instance.api/v2", +) +def test_api_post_request(mock_check_instance, mock_post_request, all_pages, + next_token): + """Tests making a POST request using the API object with and without max_pages.""" + api = API(url="https://custom_instance.api/v2") + payload = {"key": "value"} + + response = api.post(payload=payload, + endpoint="test-endpoint", + all_pages=all_pages, + next_token=next_token) + assert response == {"success": True} + mock_post_request.assert_called_once_with( + url="https://custom_instance.api/v2/test-endpoint", + payload=payload, + headers=api.headers, + all_pages=all_pages, + next_token=next_token) + + +@patch( + "datacommons_client.endpoints.base.check_instance_is_valid", + return_value="https://custom.api/v2", +) +def test_endpoint_post_request_invalid_payload(mock_check_instance): + """Tests that an invalid payload raises a ValueError in the Endpoint post method.""" + api = API(url="https://custom.api/v2") + endpoint = Endpoint(endpoint="node", api=api) + + with pytest.raises(ValueError): + endpoint.post(payload=["invalid", "payload"]) + + +@patch( + "datacommons_client.endpoints.base.check_instance_is_valid", + return_value="https://custom.api/v2", +) +def test_api_repr(mock_check_instance): + """Tests the __repr__ method of the API class.""" + # Without API key + api = API(url="https://custom.api/v2") + assert repr(api) == "" + + # With API key + api_with_key = API(url="https://custom.api/v2", api_key="test_key") + assert ( + repr(api_with_key) == "") + + +@patch( + "datacommons_client.endpoints.base.check_instance_is_valid", + return_value="https://custom.api/v2", +) +def test_endpoint_repr(mock_check_instance): + """Tests the __repr__ method of the Endpoint class.""" + api = API(url="https://custom.api/v2") + endpoint = Endpoint(endpoint="node", api=api) + + expected_repr = ">" + assert repr(endpoint) == expected_repr diff --git a/datacommons_client/tests/endpoints/test_error_handling.py b/datacommons_client/tests/endpoints/test_error_handling.py new file mode 100644 index 00000000..89e841cc --- /dev/null +++ b/datacommons_client/tests/endpoints/test_error_handling.py @@ -0,0 +1,71 @@ +from requests import Request +from requests import Response + +from datacommons_client.utils.error_handling import APIError +from datacommons_client.utils.error_handling import DataCommonsError +from datacommons_client.utils.error_handling import DCAuthenticationError +from datacommons_client.utils.error_handling import DCConnectionError +from datacommons_client.utils.error_handling import DCStatusError +from datacommons_client.utils.error_handling import InvalidDCInstanceError +from datacommons_client.utils.error_handling import NoDataForPropertyError + + +def test_data_commons_error_default_message(): + """Tests that DataCommonsError uses the default message.""" + error = DataCommonsError() + assert str(error) == DataCommonsError.default_message + + +def test_data_commons_error_custom_message(): + """Tests that DataCommonsError uses a custom message when provided.""" + error = DataCommonsError("Custom message") + assert str(error) == "Custom message" + + +def test_api_error_without_response(): + """Tests APIError initialization without a Response object.""" + error = APIError() + assert str(error) == f"\n{APIError.default_message}" + + +def test_api_error_with_response(): + """Tests APIError initialization with a mocked Response object. + + Verifies that the string representation includes status code, + request URL, and response text. + """ + mock_request = Request("GET", "http://example.com").prepare() + mock_response = Response() + mock_response.request = mock_request + mock_response.status_code = 404 + mock_response._content = b"Not Found" + + error = APIError(response=mock_response) + assert "Status Code: 404" in str(error) + assert "Request URL: http://example.com" in str(error) + assert "Not Found" in str(error) + + +def test_subclass_default_messages(): + """Tests that subclasses use their default messages.""" + connection_error = DCConnectionError() + assert DCConnectionError.default_message in str(connection_error) + + status_error = DCStatusError() + assert DCStatusError.default_message in str(status_error) + + auth_error = DCAuthenticationError() + assert DCAuthenticationError.default_message in str(auth_error) + + instance_error = InvalidDCInstanceError() + assert InvalidDCInstanceError.default_message in str(instance_error) + + filter_error = NoDataForPropertyError() + assert NoDataForPropertyError.default_message in str(filter_error) + + +def test_subclass_custom_message(): + """Tests that subclasses use custom messages when provided.""" + error = DCAuthenticationError(response=Response(), + message="Custom auth error") + assert str(error) == "\nCustom auth error" diff --git a/datacommons_client/tests/endpoints/test_node_endpoint.py b/datacommons_client/tests/endpoints/test_node_endpoint.py new file mode 100644 index 00000000..c0f006e7 --- /dev/null +++ b/datacommons_client/tests/endpoints/test_node_endpoint.py @@ -0,0 +1,556 @@ +from unittest.mock import MagicMock +from unittest.mock import patch + +from datacommons_client.endpoints.base import API +from datacommons_client.endpoints.node import NodeEndpoint +from datacommons_client.endpoints.response import NodeResponse +from datacommons_client.models.node import Arcs +from datacommons_client.models.node import Name +from datacommons_client.models.node import Node +from datacommons_client.models.node import NodeGroup +from datacommons_client.models.node import StatVarConstraints +from datacommons_client.utils.names import DEFAULT_NAME_PROPERTY +from datacommons_client.utils.names import NAME_WITH_LANGUAGE_PROPERTY + + +def test_node_endpoint_initialization(): + """Test if the NodeEndpoint initializes correctly.""" + api_mock = MagicMock(spec=API) + endpoint = NodeEndpoint(api=api_mock) + + assert endpoint.endpoint == "node" + assert endpoint.api == api_mock + + +def test_node_endpoint_fetch(): + """Test the fetch method of NodeEndpoint.""" + api_mock = MagicMock(spec=API) + api_mock.post.return_value = {"data": {"test_node": {"properties": ["name"]}}} + + endpoint = NodeEndpoint(api=api_mock) + response = endpoint.fetch(node_dcids="test_node", expression="name") + + api_mock.post.assert_called_once_with(payload={ + "nodes": ["test_node"], + "property": "name" + }, + endpoint="node", + all_pages=True, + next_token=None) + assert isinstance(response, NodeResponse) + assert "test_node" in response.data + + +def test_node_endpoint_fetch_property_labels(): + """Test fetch_property_labels method.""" + api_mock = MagicMock(spec=API) + endpoint = NodeEndpoint(api=api_mock) + endpoint.fetch = MagicMock(return_value=NodeResponse( + data={"node1": { + "properties": [] + }})) + + response = endpoint.fetch_property_labels(node_dcids="node1", out=False) + endpoint.fetch.assert_called_once_with(node_dcids="node1", + expression="<-", + all_pages=True, + next_token=None) + assert isinstance(response, NodeResponse) + assert "node1" in response.data + + +def test_node_endpoint_fetch_property_values_out(): + """Test fetch_property_values method with constraints and direction (out)""" + + api_mock = MagicMock(spec=API) + api_mock.post.return_value = {"data": {"node1": {"properties": ["name"]}}} + + endpoint = NodeEndpoint(api=api_mock) + response = endpoint.fetch_property_values(node_dcids="node1", + properties="name", + constraints="typeOf:City", + out=True) + + expected_expression = "->name{typeOf:City}" + api_mock.post.assert_called_once_with(payload={ + "nodes": ["node1"], + "property": expected_expression + }, + endpoint="node", + all_pages=True, + next_token=None) + assert isinstance(response, NodeResponse) + assert "node1" in response.data + + +def test_node_endpoint_fetch_property_values_in(): + """Test fetch_property_values method with constraints and direction (in)""" + + api_mock = MagicMock(spec=API) + api_mock.post.return_value = {"data": {"node1": {"properties": ["name"]}}} + + endpoint = NodeEndpoint(api=api_mock) + response = endpoint.fetch_property_values(node_dcids="node1", + properties="name", + constraints="typeOf:City", + out=False) + + expected_expression = "<-name{typeOf:City}" + api_mock.post.assert_called_once_with(payload={ + "nodes": ["node1"], + "property": expected_expression + }, + endpoint="node", + all_pages=True, + next_token=None) + assert isinstance(response, NodeResponse) + assert "node1" in response.data + + +def test_node_endpoint_fetch_all_classes(): + """Test fetch_all_classes method.""" + api_mock = MagicMock(spec=API) + endpoint = NodeEndpoint(api=api_mock) + endpoint.fetch_property_values = MagicMock(return_value=NodeResponse( + data={"Class": { + "arcs": {} + }})) + + response = endpoint.fetch_all_classes() + endpoint.fetch_property_values.assert_called_once_with( + node_dcids="Class", + properties="typeOf", + out=False, + all_pages=True, + next_token=None, + ) + assert isinstance(response, NodeResponse) + assert "Class" in response.data + + +def test_node_endpoint_fetch_property_values_string_vs_list(): + """Test fetch_property_values with string and list expressions.""" + api_mock = MagicMock(spec=API) + api_mock.post.return_value = {"data": {"node1": {"properties": ["name"]}}} + + endpoint = NodeEndpoint(api=api_mock) + + # String input + response = endpoint.fetch_property_values(node_dcids="node1", + properties="name", + constraints=None, + out=True) + api_mock.post.assert_called_with(payload={ + "nodes": ["node1"], + "property": "->name" + }, + endpoint="node", + all_pages=True, + next_token=None) + + # List input + response = endpoint.fetch_property_values(node_dcids="node1", + properties=["name", "typeOf"], + constraints=None, + out=True) + api_mock.post.assert_called_with(payload={ + "nodes": ["node1"], + "property": "->[name, typeOf]" + }, + endpoint="node", + all_pages=True, + next_token=None) + + +@patch( + "datacommons_client.endpoints.node.extract_name_from_english_name_property") +def test_fetch_entity_names_english(mock_extract_name): + """Test fetching names in English (default behavior).""" + mock_extract_name.return_value = "Guatemala" + api_mock = MagicMock() + endpoint = NodeEndpoint(api=api_mock) + + # Mock the response from fetch_property_values + endpoint.fetch_property_values = MagicMock(return_value=NodeResponse( + data={ + 'dc/123': + Arcs(arcs={ + DEFAULT_NAME_PROPERTY: + NodeGroup(nodes=[Node(value='Guatemala')]) + }) + })) + + result = endpoint.fetch_entity_names("dc/123") + endpoint.fetch_property_values.assert_called_once_with( + node_dcids=["dc/123"], properties=DEFAULT_NAME_PROPERTY) + assert result == { + "dc/123": + Name( + value="Guatemala", + language="en", + property=DEFAULT_NAME_PROPERTY, + ) + } + + mock_extract_name.assert_called_once_with( + properties=[Node(value="Guatemala")]) + + +@patch( + "datacommons_client.endpoints.node.extract_name_from_property_with_language" +) +def test_fetch_entity_names_non_english(mock_extract_name): + """Test fetching names in a non-English language.""" + mock_extract_name.return_value = ("Californie", "fr") + api_mock = MagicMock() + endpoint = NodeEndpoint(api=api_mock) + + endpoint.fetch_property_values = MagicMock(return_value=NodeResponse( + data={ + 'dc/123': + Arcs( + arcs={ + NAME_WITH_LANGUAGE_PROPERTY: + NodeGroup(nodes=[Node(value='Californie')]) + }) + })) + + result = endpoint.fetch_entity_names("dc/123", language="fr") + endpoint.fetch_property_values.assert_called_once_with( + node_dcids=["dc/123"], properties=NAME_WITH_LANGUAGE_PROPERTY) + assert result == { + "dc/123": + Name( + value="Californie", + language="fr", + property=NAME_WITH_LANGUAGE_PROPERTY, + ) + } + + mock_extract_name.assert_called_once_with( + properties=[Node(value='Californie')], + language='fr', + fallback_language=None) + + +@patch( + "datacommons_client.endpoints.node.extract_name_from_property_with_language" +) +def test_fetch_entity_names_with_fallback(mock_extract_name_lang): + """Test fallback to another language when target language is unavailable.""" + mock_extract_name_lang.return_value = ("Chiquimula", "en") + api_mock = MagicMock() + endpoint = NodeEndpoint(api=api_mock) + + endpoint.fetch_property_values = MagicMock(return_value=NodeResponse( + data={ + 'dc/123': + Arcs( + arcs={ + NAME_WITH_LANGUAGE_PROPERTY: + NodeGroup(nodes=[Node(value='Chiquimula')]) + }) + })) + + result = endpoint.fetch_entity_names("dc/123", + language="fr", + fallback_language="en") + + assert result == { + "dc/123": + Name( + value="Chiquimula", + language="en", + property=NAME_WITH_LANGUAGE_PROPERTY, + ) + } + mock_extract_name_lang.assert_called_once_with( + properties=[Node(value='Chiquimula')], + language='fr', + fallback_language='en') + + +@patch( + "datacommons_client.endpoints.node.extract_name_from_property_with_language" +) +def test_fetch_entity_names_no_result(mock_extract_name_lang): + """Test case when no name is found.""" + mock_extract_name_lang.return_value = (None, None) + api_mock = MagicMock() + endpoint = NodeEndpoint(api=api_mock) + + endpoint.fetch_property_values = MagicMock(return_value=NodeResponse( + data={"dc/999": { + "properties": [] + }})) + + result = endpoint.fetch_entity_names("dc/999", + language="es", + fallback_language="en") + assert result == {} + + +@patch("datacommons_client.endpoints.node.flatten_relationship") +@patch("datacommons_client.endpoints.node.build_graph_map") +@patch("datacommons_client.endpoints.node.fetch_relationship_lru") +def test_fetch_entity_relationships_delegates_to_lru(mock_lru, mock_build_map, + mock_flatten): + """Ensure that the private helper builds a fetch‑function that ultimately + calls through to ``fetch_relationship_lru`` for each root DCID.""" + + mock_lru.return_value = [Node(dcid="B", name="B name", types=["Region"])] + + def _fake_build_graph_map(root, fetch_fn): + # simulate the internal traversal by invoking the provided fetch_fn once + fetch_fn(dcid=root) + return root, {} + + mock_build_map.side_effect = _fake_build_graph_map + mock_flatten.return_value = [] + + endpoint = NodeEndpoint(api=MagicMock()) + result = endpoint._fetch_place_relationships(place_dcids="X", + as_tree=False, + contained_type="Region", + relationship="parents") + + assert result == {"X": []} + mock_lru.assert_called_once_with( + endpoint, + dcid="X", + contained_type="Region", + relationship="parents", + ) + + +@patch("datacommons_client.endpoints.node.flatten_relationship") +@patch("datacommons_client.endpoints.node.build_graph_map") +def test_fetch_entity_ancestry_flat(mock_build_map, mock_flatten): + """Flat ancestry structure should be derived via ``flatten_relationship``.""" + mock_build_map.return_value = ( + "X", + { + "X": [Node(dcid="A", name="A name", types=["Country"])], + "A": [], + }, + ) + mock_flatten.return_value = [{ + "dcid": "A", + "name": "A name", + "type": "Country" + }] + + endpoint = NodeEndpoint(api=MagicMock()) + result = endpoint.fetch_place_ancestors("X", as_tree=False) + + assert result == {"X": [{"dcid": "A", "name": "A name", "type": "Country"}]} + mock_build_map.assert_called_once() + mock_flatten.assert_called_once() + + +@patch("datacommons_client.endpoints.node.build_relationship_tree") +@patch("datacommons_client.endpoints.node.build_graph_map") +def test_fetch_entity_ancestry_tree(mock_build_map, mock_build_tree): + """Nested ancestry structure should be derived via + ``build_relationship_tree``.""" + mock_build_map.return_value = ( + "Y", + { + "Y": [Node(dcid="Z", name="Z name", types=["Region"])], + "Z": [], + }, + ) + + mock_build_tree.return_value = { + "dcid": + "Y", + "name": + None, + "type": + None, + "parents": [{ + "dcid": "Z", + "name": "Z name", + "type": "Region", + "parents": [] + }], + } + + endpoint = NodeEndpoint(api=MagicMock()) + result = endpoint.fetch_place_ancestors("Y", as_tree=True) + + assert "Y" in result + assert result["Y"]["dcid"] == "Y" + assert result["Y"]["parents"][0]["dcid"] == "Z" + mock_build_map.assert_called_once() + mock_build_tree.assert_called_once_with(root="Y", + graph=mock_build_map.return_value[1], + relationship_key="parents") + + +def test__fetch_property_id_names_flattens_to_dcid_and_name(): + """Private helper should return only dcid and name per target node.""" + api_mock = MagicMock(spec=API) + endpoint = NodeEndpoint(api=api_mock) + + # Simulate fetch_property_values response with Arcs, NodeGroup, Node + endpoint.fetch_property_values = MagicMock(return_value=NodeResponse( + data={ + "sv/1": + Arcs( + arcs={ + "constraintProperties": + NodeGroup(nodes=[ + Node(dcid="p1", name="Prop One"), + Node(dcid="p2", name="Prop Two"), + ]) + }) + })) + + result = endpoint._fetch_property_id_names("sv/1", "constraintProperties") + + assert result == { + "sv/1": { + "constraintProperties": [ + { + "dcid": "p1", + "name": "Prop One", + }, + { + "dcid": "p2", + "name": "Prop Two", + }, + ] + } + } + endpoint.fetch_property_values.assert_called_once_with( + node_dcids="sv/1", properties="constraintProperties") + + +def test_fetch_statvar_constraints_builds_constraints_and_values(): + """fetch_statvar_constraints should combine constraint properties and values.""" + endpoint = NodeEndpoint(api=MagicMock()) + + # First call returns constraint property ids and names + constraints_map = { + "sv/1": { + "constraintProperties": [ + { + "dcid": "p1", + "name": "Prop One" + }, + { + "dcid": "p2", + "name": "Prop Two" + }, + ] + } + } + + # Second call returns values for those properties + values_map = { + "sv/1": { + "p1": [{ + "dcid": "v1", + "name": "Val One" + }], + "p2": [{ + "dcid": "v2", + "name": "Val Two" + }], + } + } + + with patch.object(endpoint, + "_fetch_property_id_names", + side_effect=[constraints_map, values_map]) as mock_helper: + result = endpoint.fetch_statvar_constraints(["sv/1"]) + + # Ensure helper called twice (once for constraintProperties, once for values) + assert mock_helper.call_count == 2 + assert isinstance(result, StatVarConstraints) + assert "sv/1" in result + # Two constraints returned + assert len(result["sv/1"]) == 2 + ids = {(c.constraintId, c.valueId) for c in result["sv/1"]} + assert ids == {("p1", "v1"), ("p2", "v2")} + + +def test_fetch_statvar_constraints_handles_string_input_and_no_constraints(): + """Single sv input and empty constraints should yield empty list for that sv.""" + endpoint = NodeEndpoint(api=MagicMock()) + + # No constraintProperties for sv/empty + constraints_map = {"sv/empty": {"constraintProperties": []}} + # Second call won't be used but provide empty map + values_map = {"sv/empty": {}} + + with patch.object(endpoint, + "_fetch_property_id_names", + side_effect=[constraints_map, values_map]): + # string input + result = endpoint.fetch_statvar_constraints("sv/empty") + + assert isinstance(result, StatVarConstraints) + assert result["sv/empty"] == [] + + +def test__fetch_property_id_names_handles_literal_values(): + """_fetch_property_id_names should handle string literal values gracefully.""" + api_mock = MagicMock(spec=API) + endpoint = NodeEndpoint(api=api_mock) + + # Simulate a response where the target value is a literal string (no dcid) + endpoint.fetch_property_values = MagicMock(return_value=NodeResponse( + data={ + "sv/1": + Arcs(arcs={"p1": NodeGroup(nodes=[Node(value="LiteralValue")])}) + })) + + result = endpoint._fetch_property_id_names("sv/1", "p1") + + assert result == { + "sv/1": { + "p1": [{ + "dcid": "LiteralValue", + "name": "LiteralValue" + }] + } + } + endpoint.fetch_property_values.assert_called_once_with(node_dcids="sv/1", + properties="p1") + + +def test_fetch_statvar_constraints_skips_missing_constraint_values(): + """If a constraintProperty has no value for a SV, skip it without error.""" + endpoint = NodeEndpoint(api=MagicMock()) + + constraints_map = { + "sv/1": { + "constraintProperties": [ + { + "dcid": "p1", + "name": "Prop One" + }, + { + "dcid": "p2", + "name": "Prop Two" + }, + ] + } + } + + # p1 has a value, p2 is missing/empty + values_map = {"sv/1": {"p1": [{"dcid": "v1", "name": "Val One"}], "p2": []}} + + with patch.object(endpoint, + "_fetch_property_id_names", + side_effect=[constraints_map, values_map]): + result = endpoint.fetch_statvar_constraints(["sv/1"]) + + assert isinstance(result, StatVarConstraints) + assert "sv/1" in result + # Only one well-formed constraint should be included (p1) + assert len(result["sv/1"]) == 1 + assert result["sv/1"][0].constraintId == "p1" + assert result["sv/1"][0].valueId == "v1" diff --git a/datacommons_client/tests/endpoints/test_observation_endpoint.py b/datacommons_client/tests/endpoints/test_observation_endpoint.py new file mode 100644 index 00000000..da6387b8 --- /dev/null +++ b/datacommons_client/tests/endpoints/test_observation_endpoint.py @@ -0,0 +1,156 @@ +from unittest.mock import MagicMock + +from datacommons_client.endpoints.base import API +from datacommons_client.endpoints.observation import ObservationEndpoint +from datacommons_client.endpoints.response import ObservationResponse +from datacommons_client.models.observation import ByVariable +from datacommons_client.models.observation import ObservationDate +from datacommons_client.models.observation import ObservationSelect + + +def test_fetch(): + """Tests the fetch method of ObservationEndpoint.""" + api_mock = MagicMock(spec=API) + api_mock.post.return_value = {"byVariable": {}} + endpoint = ObservationEndpoint(api=api_mock) + + response = endpoint.fetch(variable_dcids="dcid/variableID", + date=ObservationDate.LATEST, + select=["date", "variable", "entity", "value"], + entity_dcids="dc/EntityID", + filter_facet_domains="domain1", + filter_facet_ids="facet1") + + # Check the response + assert isinstance(response, ObservationResponse) + + # Check the post request + api_mock.post.assert_called_once_with(payload={ + "date": ObservationDate.LATEST, + "variable": { + "dcids": ["dcid/variableID"] + }, + "entity": { + "dcids": ["dc/EntityID"], + }, + "select": ["date", "variable", "entity", "value"], + "filter": { + "domains": ["domain1"], + "facet_ids": ["facet1"] + } + }, + endpoint="observation", + all_pages=True, + next_token=None) + + +def test_fetch_observations_by_entity_type(): + """Tests the fetch_observations_by_entity_type method.""" + api_mock = MagicMock(spec=API) + api_mock.post.return_value = {"byVariable": {}} + endpoint = ObservationEndpoint(api=api_mock) + + response = endpoint.fetch_observations_by_entity_type( + date="2023", + parent_entity="Earth", + entity_type="Country", + select=["variable", "entity", "facet"], + variable_dcids="dc/VariableID") + + # Check the response + assert isinstance(response, ObservationResponse) + + # Check the post request + api_mock.post.assert_called_once_with(payload={ + "date": "2023", + "variable": { + "dcids": ["dc/VariableID"] + }, + "entity": { + "expression": "Earth<-containedInPlace+{typeOf:Country}" + }, + "select": ["variable", "entity", "facet"], + }, + endpoint="observation", + all_pages=True, + next_token=None) + + +def test_fetch_observations_facets_by_entity_type(): + """Tests the fetch_observations_by_entity_type method.""" + api_mock = MagicMock(spec=API) + api_mock.post.return_value = {"byVariable": {}} + endpoint = ObservationEndpoint(api=api_mock) + + response = endpoint.fetch_observations_by_entity_type( + date="2023", + parent_entity="Earth", + entity_type="Country", + variable_dcids="dc/VariableID", + select=["variable", "entity", "facet"], + ) + + # Check the response + assert isinstance(response, ObservationResponse) + + # Check the post request + api_mock.post.assert_called_once_with(payload={ + "date": "2023", + "variable": { + "dcids": ["dc/VariableID"] + }, + "entity": { + "expression": "Earth<-containedInPlace+{typeOf:Country}" + }, + "select": ["variable", "entity", "facet"], + }, + endpoint="observation", + all_pages=True, + next_token=None) + + +def test_fetch_available_statistical_variables_single_entity(): + """Test fetching variables for a single entity.""" + mock_data = { + "var1": ["ent1"], + "var2": ["ent1"], + } + + # Mock the fetch method on the ObservationEndpoint instance + endpoint = ObservationEndpoint(api=MagicMock()) + endpoint.fetch = MagicMock() + endpoint.fetch.return_value.get_data_by_entity = MagicMock( + return_value=mock_data) + + result = endpoint.fetch_available_statistical_variables("ent1") + + expected = { + "ent1": ["var1", "var2"], + } + assert result == expected + + endpoint.fetch.assert_called_once_with( + entity_dcids="ent1", + select=[ObservationSelect.VARIABLE, ObservationSelect.ENTITY], + variable_dcids=[]) + + +def test_fetch_available_statistical_variables_multiple_entities(): + """Test fetching variables for multiple entities.""" + mock_data = { + "var1": ["ent1", "ent2"], + "var2": ["ent2"], + } + + endpoint = ObservationEndpoint(api=MagicMock()) + endpoint.fetch = MagicMock() + endpoint.fetch.return_value.get_data_by_entity = MagicMock( + return_value=mock_data) + + result = endpoint.fetch_available_statistical_variables(["ent1", "ent2"]) + + expected = { + "ent1": ["var1"], + "ent2": ["var1", "var2"], + } + assert result == expected diff --git a/datacommons_client/tests/endpoints/test_payloads.py b/datacommons_client/tests/endpoints/test_payloads.py new file mode 100644 index 00000000..28c7f1e1 --- /dev/null +++ b/datacommons_client/tests/endpoints/test_payloads.py @@ -0,0 +1,147 @@ +import pytest + +from datacommons_client.endpoints.payloads import NodeRequestPayload +from datacommons_client.endpoints.payloads import ObservationRequestPayload +from datacommons_client.endpoints.payloads import ResolveRequestPayload +from datacommons_client.models.observation import ObservationDate +from datacommons_client.models.observation import ObservationSelect +from datacommons_client.utils.error_handling import InvalidObservationSelectError + + +def test_node_payload_normalize(): + """Tests that NodeRequestPayload correctly normalizes single and multiple node_dcids.""" + payload = NodeRequestPayload(node_dcids="node1", expression="prop1") + assert payload.node_dcids == ["node1"] + + payload = NodeRequestPayload(node_dcids=["node1", "node2"], + expression="prop1") + assert payload.node_dcids == ["node1", "node2"] + + +def test_node_payload_validate(): + """Tests that NodeRequestPayload validates its inputs correctly.""" + with pytest.raises(ValueError): + NodeRequestPayload(node_dcids="node1", + expression=123) # `expression` must be a string + + +def test_node_payload_to_dict(): + """Tests NodeRequestPayload conversion to dictionary.""" + payload = NodeRequestPayload(node_dcids="node1", expression="prop1") + assert payload.to_dict() == {"nodes": ["node1"], "property": "prop1"} + + +def test_observation_payload_normalize(): + """Tests that ObservationRequestPayload normalizes inputs correctly.""" + payload = ObservationRequestPayload( + date="LATEST", + variable_dcids="var1", + select=["variable", "entity"], + entity_dcids="ent1", + filter_facet_domains="domain1", + filter_facet_ids="facets1", + ) + assert payload.variable_dcids == ["var1"] + assert payload.entity_dcids == ["ent1"] + assert payload.filter_facet_domains == ["domain1"] + assert payload.filter_facet_ids == ["facets1"] + assert payload.date == ObservationDate.LATEST + + assert "filter" in payload.to_dict() + assert "facet_ids" in payload.to_dict()["filter"] + assert "domains" in payload.to_dict()["filter"] + + # Check that when domain and facets are not included, they are not in the payload + payload = ObservationRequestPayload( + date="all", + variable_dcids=["var1"], + select=["variable", "entity"], + entity_dcids=["ent1"], + ) + assert payload.date == ObservationDate.ALL + assert payload.variable_dcids == ["var1"] + assert payload.entity_dcids == ["ent1"] + assert "filter" not in payload.to_dict() + + +def test_observation_select_invalid_value(): + """Tests that an invalid ObservationSelect value raises InvalidObservationSelectError.""" + with pytest.raises(InvalidObservationSelectError): + ObservationSelect("invalid") + + +def test_observation_payload_validate(): + """Tests that ObservationRequestPayload validates its inputs.""" + with pytest.raises(InvalidObservationSelectError): + ObservationRequestPayload( + date="LATEST", + variable_dcids="var1", + select=["variable"], + entity_dcids=None, + entity_expression=None, + ) # Requires either `entity_dcids` or `entity_expression` + + with pytest.raises(InvalidObservationSelectError): + ObservationRequestPayload( + date="LATEST", + variable_dcids="var1", + select=["value"], # Missing required "variable" and "entity" + entity_expression="expression", + ) + + with pytest.raises(ValueError): + ObservationRequestPayload( + date="LATEST", + variable_dcids="var1", + select=["variable", "entity"], + entity_dcids="ent1", + entity_expression= + "expression", # Both `entity_dcids` and `entity_expression` set + ) + + +def test_observation_payload_to_dict(): + """Tests ObservationRequestPayload conversion to dictionary.""" + payload = ObservationRequestPayload( + date="LATEST", + variable_dcids="var1", + select=["variable", "entity"], + entity_dcids="ent1", + filter_facet_ids="facets1", + ) + assert payload.to_dict() == { + "date": ObservationDate.LATEST, + "variable": { + "dcids": ["var1"] + }, + "entity": { + "dcids": ["ent1"] + }, + "select": ["variable", "entity"], + "filter": { + "facet_ids": ["facets1"] + } + } + + +def test_resolve_payload_normalize(): + """Tests that ResolveRequestPayload normalizes single and multiple node_dcids.""" + payload = ResolveRequestPayload(node_dcids="node1", expression="expr1") + assert payload.node_dcids == ["node1"] + + payload = ResolveRequestPayload(node_dcids=["node1", "node2"], + expression="expr1") + assert payload.node_dcids == ["node1", "node2"] + + +def test_resolve_payload_validate(): + """Tests that ResolveRequestPayload validates its inputs correctly.""" + with pytest.raises(ValueError): + ResolveRequestPayload(node_dcids="node1", + expression=123) # `expression` must be a string + + +def test_resolve_payload_to_dict(): + """Tests ResolveRequestPayload conversion to dictionary.""" + payload = ResolveRequestPayload(node_dcids="node1", expression="expr1") + assert payload.to_dict() == {"nodes": ["node1"], "property": "expr1"} diff --git a/datacommons_client/tests/endpoints/test_request_handling.py b/datacommons_client/tests/endpoints/test_request_handling.py new file mode 100644 index 00000000..8579db6b --- /dev/null +++ b/datacommons_client/tests/endpoints/test_request_handling.py @@ -0,0 +1,421 @@ +from unittest.mock import MagicMock +from unittest.mock import patch + +import pytest +import requests + +from datacommons_client.utils.error_handling import APIError +from datacommons_client.utils.error_handling import DCAuthenticationError +from datacommons_client.utils.error_handling import DCConnectionError +from datacommons_client.utils.error_handling import DCStatusError +from datacommons_client.utils.error_handling import InvalidDCInstanceError +from datacommons_client.utils.request_handling import _fetch_with_pagination +from datacommons_client.utils.request_handling import _merge_values +from datacommons_client.utils.request_handling import _recursively_merge_dicts +from datacommons_client.utils.request_handling import _send_post_request +from datacommons_client.utils.request_handling import check_instance_is_valid +from datacommons_client.utils.request_handling import post_request +from datacommons_client.utils.request_handling import resolve_instance_url + + +def test_resolve_instance_url_default(): + """Tests resolving the default Data Commons instance.""" + assert (resolve_instance_url("datacommons.org") == + "https://api.datacommons.org/v2") + + +@patch("requests.get") +def test_check_instance_is_valid_request_exception(mock_get): + """Tests that a RequestException raises InvalidDCInstanceError.""" + mock_get.side_effect = requests.exceptions.RequestException("Request failed") + with pytest.raises(InvalidDCInstanceError): + check_instance_is_valid("https://invalid-instance") + + +@patch("requests.post") +def test_send_post_request_connection_error(mock_post): + """Tests that a ConnectionError raises DCConnectionError.""" + mock_post.side_effect = requests.exceptions.ConnectionError( + "Connection failed") + with pytest.raises(DCConnectionError): + _send_post_request("https://api.test.com", {}, {}) + + +@patch("datacommons_client.utils.request_handling.check_instance_is_valid") +def test_resolve_instance_url_custom(mock_check_instance_is_valid): + """Tests resolving a custom Data Commons instance.""" + mock_check_instance_is_valid.return_value = ( + "https://custom-instance/core/api/v2") + + assert (resolve_instance_url("custom-instance") == + "https://custom-instance/core/api/v2") + mock_check_instance_is_valid.assert_called_once_with( + "https://custom-instance/core/api/v2") + + +@patch("requests.get") +def test_check_instance_is_valid_valid(mock_get): + """Tests that a valid instance URL is correctly validated.""" + + # Create a mock response object with the expected JSON data and status code + mock_response = MagicMock() + mock_response.json.return_value = {"data": {"country/GTM": {}}} + mock_response.status_code = 200 + mock_get.return_value = mock_response + + # Mock the instance URL to test + instance_url = "https://valid-instance" + + # Assert that the instance URL is returned if it is valid + assert check_instance_is_valid(instance_url) == instance_url + mock_get.assert_called_once_with( + f"{instance_url}/node?nodes=country%2FGTM&property=->name", headers={}) + + +@patch("requests.get") +def test_check_instance_is_valid_with_key_valid(mock_get): + """Tests that a valid instance URL is correctly validated.""" + + # Create a mock response object with the expected JSON data and status code + mock_response = MagicMock() + mock_response.json.return_value = {"data": {"country/GTM": {}}} + mock_response.status_code = 200 + mock_get.return_value = mock_response + + # Mock the instance URL to test + instance_url = "https://valid-instance" + api_key = "test-api-key" + # Assert that the instance URL is returned if it is valid + assert check_instance_is_valid(instance_url, api_key=api_key) == instance_url + mock_get.assert_called_once_with( + f"{instance_url}/node?nodes=country%2FGTM&property=->name", + headers={"X-API-Key": api_key}) + + +@patch("requests.get") +def test_check_instance_is_valid_invalid(mock_get): + """Tests that an invalid instance URL raises the appropriate exception.""" + mock_response = MagicMock() + mock_response.json.return_value = {"error": "Not Found"} + mock_response.status_code = 404 + mock_get.return_value = mock_response + + with pytest.raises(InvalidDCInstanceError): + check_instance_is_valid("https://invalid-instance") + + +@patch("requests.post") +def test_send_post_request_500_status_error(mock_post): + """Tests that a 500-level HTTP error raises DCStatusError.""" + mock_response = MagicMock() + mock_response.status_code = 500 + mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError( + response=mock_response) + mock_post.return_value = mock_response + + with pytest.raises(DCStatusError): + _send_post_request("https://api.test.com", {}, {}) + + +@patch("requests.post") +def test_send_post_request_other_http_error(mock_post): + """Tests that non-500 HTTP errors raise APIError.""" + mock_response = MagicMock() + mock_response.status_code = 404 + mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError( + response=mock_response) + mock_post.return_value = mock_response + + with pytest.raises(APIError): + _send_post_request("https://api.test.com", {}, {}) + + +@patch("requests.post") +def test_send_post_request_success(mock_post): + """Tests a successful POST request.""" + + # Create a mock response object with the expected JSON data and status code + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.json.return_value = {"success": True} + mock_post.return_value = mock_response + + # Mock the POST request + url = "https://api.test.com" + payload = {"key": "value"} + headers = {"Content-Type": "application/json"} + + response = _send_post_request(url, payload, headers) + assert response.status_code == 200 + assert response.json() == {"success": True} + + +@patch("requests.post") +def test_send_post_request_surface_header(mock_post): + """Tests a successful POST request with a surface header.""" + + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.json.return_value = {"success": True} + mock_post.return_value = mock_response + + # Mock the POST request + url = "https://api.test.com" + payload = {"key": "value"} + headers = {"Content-Type": "application/json", "x-surface": "mcp-1.0"} + + _send_post_request(url, payload, headers) + mock_post.assert_called_once_with(url, json=payload, headers=headers) + + +@patch("requests.post") +def test_send_post_request_http_error(mock_post): + """Tests handling an HTTP error during a POST request.""" + # Create a mock response object with a 401 status code + mock_response = MagicMock() + mock_response.status_code = 401 + mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError( + response=mock_response) + mock_post.return_value = mock_response + + # Mock the POST request and assert that a DCAuthenticationError is raised + with pytest.raises(DCAuthenticationError): + _send_post_request("https://api.test.com", {}, {}) + + +def test_recursively_merge_dicts(): + """Tests recursive merging of dictionaries.""" + # Test merging two dictionaries with nested dictionaries and lists + base = {"a": {"b": 1}, "c": [1, 2]} + new = {"a": {"d": 2}, "c": [3], "e": 5} + result = _recursively_merge_dicts(base, new) + + # Assert that the dictionaries are merged correctly + assert result == {"a": {"b": 1, "d": 2}, "c": [1, 2, 3], "e": 5} + + +def test_merge_values_dicts(): + """Tests merging of dictionary values.""" + base = {"a": 1} + new = {"b": 2} + result = _merge_values(base, new) + assert result == {"a": 1, "b": 2} + + +def test_merge_values_lists(): + """Tests merging of list values.""" + base = [1, 2] + new = [3, 4] + result = _merge_values(base, new) + assert result == [1, 2, 3, 4] + + +def test_merge_values_other(): + """Tests merging non-dict, non-list values.""" + base = "value1" + new = "value2" + result = _merge_values(base, new) + assert result == ["value1", "value2"] + + +def test_merge_values_complex_conflict(): + """Tests merging deeply nested, repeated objects.""" + + # Nested but simple base + base = { + "key1": { + "nested1": { + "subkey1": "value1", + "subkey2": [1, 2], + }, + "nested2": "value2", + }, + "key2": [1, 2, 3], + "key3": "conflict1", + } + + # Nested but complex new + new = { + "key1": { + "nested1": { + "subkey1": "new_value1", # Already in base + "subkey3": "new_value2", # New key + }, + "nested2": ["new_value3"], # Conflicts with base (type change) + }, + "key2": [4, 5], # Should merge lists + "key3": "conflict2", # Should create a list due to conflict + "key4": { + "new_nested": "new_value4" + }, # New key + } + + # Expected result which keeps all data + expected_result = { + "key1": { + "nested1": { + "subkey1": ["value1", "new_value1"], + "subkey2": [1, 2], + "subkey3": "new_value2", + }, + "nested2": ["value2", ["new_value3"]], + }, + "key2": [1, 2, 3, 4, 5], + "key3": ["conflict1", "conflict2"], + "key4": { + "new_nested": "new_value4" + }, + } + + result = _merge_values(base, new) + assert result == expected_result + + +@patch("datacommons_client.utils.request_handling._send_post_request") +def test_fetch_with_pagination(mock_send_post_request): + """Tests fetching and merging paginated API responses.""" + + # Mock the response JSON data for two pages + mock_response = MagicMock() + mock_response.json.side_effect = [ + { + "data": { + "page1": True + }, + "nextToken": "token1" + }, + { + "data": { + "page2": True + } + }, + ] + mock_send_post_request.side_effect = [mock_response, mock_response] + + # Mock the POST request and assert that the results are merged correctly + url = "https://api.test.com" + payload = {} + headers = {} + + result = _fetch_with_pagination(url, payload, headers) + assert result == {"data": {"page1": True, "page2": True}, 'nextToken': None} + + +@patch("datacommons_client.utils.request_handling._send_post_request") +def test_fetch_with_pagination_next_token(mock_send_post_request): + """Tests fetching and merging paginated API responses, including a next_token""" + + # Mock the response JSON data for two pages + mock_response = MagicMock() + + # Should stop at first page given that all_pages is set to False + mock_response.json.side_effect = [ + { + "data": { + "page1": True + }, + "nextToken": "token2" + }, + ] + mock_send_post_request.side_effect = [mock_response, mock_response] + + # Mock the POST request and assert that the results are merged correctly + url = "https://api.test.com" + payload = {} + headers = {} + + result = _fetch_with_pagination(url, + payload, + headers, + all_pages=False, + next_token="token1") + assert result == {"data": {"page1": True}, 'nextToken': "token2"} + + +@patch("datacommons_client.utils.request_handling._send_post_request") +def test_fetch_with_pagination_next_token_all_pages(mock_send_post_request): + """Tests fetching and merging paginated API responses, including a next_token""" + + # Mock the response JSON data for two pages + mock_response = MagicMock() + + mock_response.json.side_effect = [ + { + "data": { + "page1": True + }, + "nextToken": "token1" + }, + { + "data": { + "page2": True + }, + "nextToken": "token2", + }, + { + "data": { + "page3": True + }, + "nextToken": None, + }, + ] + mock_send_post_request.side_effect = [ + mock_response, mock_response, mock_response + ] + + # Mock the POST request and assert that the results are merged correctly + url = "https://api.test.com" + payload = {} + headers = {} + + result = _fetch_with_pagination(url, + payload, + headers, + all_pages=True, + next_token="token1") + assert result == { + "data": { + "page1": True, + "page2": True, + "page3": True + }, + 'nextToken': None + } + + +@patch("datacommons_client.utils.request_handling._send_post_request") +def test_fetch_with_pagination_invalid_json(mock_send_post_request): + """Tests that invalid JSON response raises APIError.""" + mock_response = MagicMock() + mock_response.json.side_effect = ValueError("Invalid JSON") + mock_send_post_request.return_value = mock_response + + with pytest.raises(APIError): + _fetch_with_pagination("https://api.test.com", {}, {}) + + +@patch("datacommons_client.utils.request_handling._fetch_with_pagination") +def test_post_request(mock_fetch_with_pagination): + """Tests the `post_request` function with mock pagination.""" + mock_fetch_with_pagination.return_value = {"result": "data"} + result = post_request("https://api.test.com", {}, {}) + assert result == {"result": "data"} + + +@patch("datacommons_client.utils.request_handling._fetch_with_pagination") +def test_post_request_next_token(mock_fetch_with_pagination): + """Tests the `post_request` function including a check for next_token""" + mock_fetch_with_pagination.return_value = {"result": "data"} + result = post_request("https://api.test.com", {}, {}, next_token="token123") + + mock_fetch_with_pagination.assert_called_once_with(url="https://api.test.com", + payload={}, + headers={}, + all_pages=True, + next_token="token123") + + +def test_post_request_invalid_payload(): + """Tests that a non-dictionary payload raises a ValueError.""" + with pytest.raises(ValueError): + post_request("https://api.test.com", ["not", "a", "dict"], {}) diff --git a/datacommons_client/tests/endpoints/test_resolve_endpoint.py b/datacommons_client/tests/endpoints/test_resolve_endpoint.py new file mode 100644 index 00000000..ea337bbb --- /dev/null +++ b/datacommons_client/tests/endpoints/test_resolve_endpoint.py @@ -0,0 +1,227 @@ +from unittest.mock import MagicMock + +from datacommons_client.endpoints.base import API +from datacommons_client.endpoints.resolve import _resolve_correspondence_expression +from datacommons_client.endpoints.resolve import ResolveEndpoint +from datacommons_client.endpoints.response import ResolveResponse +from datacommons_client.models.resolve import Candidate +from datacommons_client.models.resolve import Entity + + +def test_fetch(): + """Tests the fetch method of ResolveEndpoint.""" + api_mock = MagicMock(spec=API) + api_mock.post = MagicMock(return_value={}) + endpoint = ResolveEndpoint(api=api_mock) + + response = endpoint.fetch(node_ids="Node1", expression="some_expression") + + # Check the response + assert isinstance(response, ResolveResponse) + + # Check the post request + api_mock.post.assert_called_once_with(payload={ + "nodes": ["Node1"], + "property": "some_expression", + }, + endpoint="resolve", + all_pages=True, + next_token=None) + + +def test_fetch_dcid_by_name(): + """Tests the fetch_dcid_by_name method.""" + api_mock = MagicMock(spec=API) + api_mock.post = MagicMock(return_value={}) + endpoint = ResolveEndpoint(api=api_mock) + + response = endpoint.fetch_dcids_by_name(names=["Entity1"], + entity_type="Place") + + # Check the response + assert isinstance(response, ResolveResponse) + + # Check the post request + api_mock.post.assert_called_once_with(payload={ + "nodes": ["Entity1"], + "property": "<-description{typeOf:Place}->dcid" + }, + endpoint="resolve", + all_pages=True, + next_token=None) + + +def test_fetch_dcid_by_wikidata_id(): + """Tests the fetch_dcid_by_wikidata_id method.""" + api_mock = MagicMock(spec=API) + api_mock.post = MagicMock(return_value={}) + endpoint = ResolveEndpoint(api=api_mock) + + response = endpoint.fetch_dcids_by_wikidata_id(wikidata_ids="Q12345", + entity_type="Country") + + # Check the response + assert isinstance(response, ResolveResponse) + + # Check the post request + api_mock.post.assert_called_once_with(payload={ + "nodes": ["Q12345"], + "property": "<-wikidataId{typeOf:Country}->dcid", + }, + endpoint="resolve", + all_pages=True, + next_token=None) + + +def test_fetch_dcids_list_by_wikidata_id(): + """Tests the fetch_dcid_by_wikidata_id method.""" + api_mock = MagicMock(spec=API) + api_mock.post = MagicMock(return_value={}) + endpoint = ResolveEndpoint(api=api_mock) + + response = endpoint.fetch_dcids_by_wikidata_id( + wikidata_ids=["Q12345", "Q695660"]) + + # Check the response + assert isinstance(response, ResolveResponse) + + # Check the post request + api_mock.post.assert_called_once_with(payload={ + "nodes": ["Q12345", "Q695660"], + "property": "<-wikidataId->dcid", + }, + endpoint="resolve", + all_pages=True, + next_token=None) + + +def test_fetch_dcid_by_coordinates(): + """Tests the fetch_dcid_by_coordinates method.""" + api_mock = MagicMock(spec=API) + api_mock.post = MagicMock(return_value={}) + endpoint = ResolveEndpoint(api=api_mock) + + response = endpoint.fetch_dcid_by_coordinates(latitude="37.7749", + longitude="-122.4194", + entity_type="City") + + # Check the response + assert isinstance(response, ResolveResponse) + + # Check the post request + api_mock.post.assert_called_once_with(payload={ + "nodes": ["37.7749#-122.4194"], + "property": "<-geoCoordinate{typeOf:City}->dcid", + }, + endpoint="resolve", + all_pages=True, + next_token=None) + + +def test_resolve_correspondence_expression(): + """Tests the resolve_correspondence_expression function.""" + expression = _resolve_correspondence_expression(from_type="description", + to_type="dcid", + entity_type="Place") + assert expression == "<-description{typeOf:Place}->dcid" + + expression_no_entity_type = _resolve_correspondence_expression( + from_type="description", to_type="dcid") + assert expression_no_entity_type == "<-description->dcid" + + +def test_flatten_resolve_response(): + """Tests the flatten_resolve_response function.""" + # Mock ResolveResponse with multiple entities + mock_data = ResolveResponse(entities=[ + Entity(node="Node1", candidates=[Candidate(dcid="Candidate1")]), + Entity(node="Node2", + candidates=[ + Candidate(dcid="Candidate2"), + Candidate(dcid="Candidate3") + ]), + Entity(node="Node3", candidates=[]) # No candidates + ]) + + # Call the function + result = mock_data.to_flat_dict() + + # Expected output + expected = { + "Node1": "Candidate1", # Single candidate + "Node2": ["Candidate2", "Candidate3"], # Multiple candidates + "Node3": [], # No candidates + } + + # Assertions + assert result == expected + + +def test_fetch_indicators_calls_endpoints_correctly(): + """Tests the fetch_indicators method.""" + api_mock = MagicMock() + # Mock response data structure + mock_response_data = { + "entities": [{ + "node": + "population", + "candidates": [{ + "dcid": "Count_Person", + "dominantType": "StatisticalVariable", + "metadata": { + "score": "0.9", + "sentence": "population count" + }, + "typeOf": ["StatisticalVariable"] + }] + }] + } + api_mock.post = MagicMock(return_value=mock_response_data) + endpoint = ResolveEndpoint(api=api_mock) + + # Call the method + response = endpoint.fetch_indicators(queries=["population"], + target="custom_only") + + # Verify post was called with correct payload + api_mock.post.assert_called_once_with(payload={ + "nodes": ["population"], + "resolver": "indicator", + "target": "custom_only" + }, + endpoint="resolve", + all_pages=True, + next_token=None) + + # Verify response parsing + expected = ResolveResponse(entities=[ + Entity(node="population", + candidates=[ + Candidate(dcid="Count_Person", + dominantType="StatisticalVariable", + metadata={ + "score": "0.9", + "sentence": "population count" + }, + typeOf=["StatisticalVariable"]) + ]) + ]) + assert response == expected + + +def test_fetch_still_works_with_expression(): + """Tests that fetch still works with expression (regression test).""" + api_mock = MagicMock() + mock_response_data = {"entities": []} + api_mock.post = MagicMock(return_value=mock_response_data) + endpoint = ResolveEndpoint(api=api_mock) + + endpoint.fetch(node_ids=["geoId/06"], expression="<-containedInPlace") + + api_mock.post.assert_called_once_with(payload={ + "nodes": ["geoId/06"], + "property": "<-containedInPlace" + }, + endpoint="resolve", + all_pages=True, + next_token=None) diff --git a/datacommons_client/tests/endpoints/test_response.py b/datacommons_client/tests/endpoints/test_response.py new file mode 100644 index 00000000..9faa1d88 --- /dev/null +++ b/datacommons_client/tests/endpoints/test_response.py @@ -0,0 +1,1173 @@ +import json + +from datacommons_client.endpoints.response import NodeResponse +from datacommons_client.endpoints.response import ObservationResponse +from datacommons_client.endpoints.response import ResolveResponse +from datacommons_client.models.node import Node +from datacommons_client.models.node import NodeGroup +from datacommons_client.models.observation import ByVariable +from datacommons_client.models.observation import Facet +from datacommons_client.models.observation import Observation +from datacommons_client.models.observation import OrderedFacet +from datacommons_client.models.observation import OrderedFacets +from datacommons_client.models.observation import Variable +from datacommons_client.utils.data_processing import extract_observations +from datacommons_client.utils.data_processing import flatten_properties +from datacommons_client.utils.data_processing import unpack_arcs + +### ----- Test Node Response ----- ### + + +def test_node_response_model_validation(): + """Test that NodeResponse.model_validate correctly parses JSON data.""" + + # Mocking JSON data + json_data = { + "data": { + "geoId/06": { + "properties": [ + "affectedPlace", + "containedInPlace", + "location", + "member", + "overlapsWith", + ] + } + }, + "nextToken": "token123", + } + + response = NodeResponse.model_validate(json_data) + + assert response.nextToken == "token123" + assert response.data["geoId/06"].properties == [ + "affectedPlace", + "containedInPlace", + "location", + "member", + "overlapsWith", + ] + assert "geoId/06" in response.data + + +def test_node_as_dict(): + """Test that the NodeResponse.json property returns the correct dictionary.""" + json_data = { + "data": { + "geoId/06": { + "properties": [ + "affectedPlace", + "containedInPlace", + "location", + "member", + "overlapsWith", + ] + } + }, + "nextToken": "token123", + } + + response = NodeResponse.model_validate(json_data) + result = response.to_dict() + + assert result == json_data + + +def test_node_as_dict_exclude_none(): + """Test that the NodeResponse.json property returns the correct dictionary.""" + json_data = { + "data": { + "geoId/06": { + "properties": None + } + }, + "nextToken": "token123", + } + + expected = { + "data": { + "geoId/06": {} + }, + "nextToken": "token123", + } + + response = NodeResponse.model_validate(json_data) + result = response.to_dict(exclude_none=True) + + assert result == expected + + +def test_node_as_dict_include_none(): + """Test that the NodeResponse.json property returns the correct dictionary.""" + json_data = { + "data": { + "geoId/06": { + "properties": None + } + }, + "nextToken": "token123", + } + + response = NodeResponse.model_validate(json_data) + result = response.to_dict(exclude_none=False) + + assert result == json_data + + +def test_flatten_properties(): + """Test that the flatten_properties function correctly flattens the properties.""" + + # Mocking node data + json_data = { + "data": { + "geoId/06": { + "properties": [ + "affectedPlace", + "containedInPlace", + "location", + "member", + "overlapsWith", + ] + } + } + } + + response = NodeResponse.model_validate(json_data) + result = flatten_properties(response.data) + function_result = response.get_properties() + + assert result == function_result + assert "geoId/06" in result + assert result["geoId/06"] == [ + "affectedPlace", + "containedInPlace", + "location", + "member", + "overlapsWith", + ] + + +def test_flatten_arcs(): + """Test that the flatten_properties function correctly flattens the arcs.""" + json_data = { + "data": { + "dc/03lw9rhpendw5": { + "arcs": { + "name": { + "nodes": [{ + "provenanceId": "dc/base/EIA_860", + "value": "191 Peachtree Tower", + }] + } + } + } + } + } + response = NodeResponse.model_validate(json_data) + result = flatten_properties(response.data) + + assert "dc/03lw9rhpendw5" in result + assert result["dc/03lw9rhpendw5"] == { + "name": [ + Node(value="191 Peachtree Tower", provenanceId="dc/base/EIA_860") + ] + } + + +def test_flatten_multiple_arcs_with_multiple_nodes(): + """Test that the flatten_properties function correctly flattens the + NodeResponse containing multiple property arcs and mutliple nodes within the + arcs.""" + + # Mocking node data + json_data = { + "data": { + "geoId/06": { + "arcs": { + "containedInPlace": { + "nodes": [{ + "dcid": "country/USA", + "name": "United States", + "provenanceId": "dc/base/WikidataOtherIdGeos", + "types": ["Country"] + }, { + "dcid": "usc/PacificDivision", + "name": "Pacific Division", + "provenanceId": "dc/base/WikidataOtherIdGeos", + "types": ["CensusDivision"] + }] + }, + "name": { + "nodes": [{ + "provenanceId": "dc/base/WikidataOtherIdGeos", + "value": "California" + }] + } + } + } + } + } + + response = NodeResponse.model_validate(json_data) + result = flatten_properties(response.data) + function_result = response.get_properties() + + assert result == function_result + assert "geoId/06" in result + assert result["geoId/06"] == { + "containedInPlace": [ + Node(dcid='country/USA', + name='United States', + provenanceId='dc/base/WikidataOtherIdGeos', + types=['Country']), + Node(dcid='usc/PacificDivision', + name='Pacific Division', + provenanceId='dc/base/WikidataOtherIdGeos', + types=['CensusDivision']) + ], + "name": [ + Node( + value='California', + provenanceId='dc/base/WikidataOtherIdGeos', + ) + ], + } + + +def test_unpack_arcs_missing_nodes_key(): + """Test that unpack_arcs handles arcs with no 'nodes' key.""" + arcs = { + "prop1": NodeGroup(nodes=[Node( + dcid='node1'), Node(dcid='node2')]), + "prop2": NodeGroup(), # No 'nodes' key here + "prop3": NodeGroup(nodes=[]), + } + + result = unpack_arcs(arcs) + assert result == { + "prop1": [Node(dcid='node1'), Node(dcid='node2')], + "prop2": [], + "prop3": [], + } + + +def test_unpack_arcs_multiple_properties(): + """Test that _unpack_arcs correctly handles multiple properties with nodes.""" + arcs = { + "prop1": NodeGroup(nodes=[Node( + dcid='node1'), Node(dcid='node2')]), + "prop2": NodeGroup(nodes=[Node(dcid='node3')]), + "prop3": NodeGroup(nodes=[]), # Empty nodes for completeness + } + + result = unpack_arcs(arcs) + + # Expected output + expected = { + "prop1": [Node(dcid='node1'), Node(dcid='node2')], + "prop2": [Node(dcid='node3')], + "prop3": [], + } + + assert result == expected + + +def test_extract_connected_dcids(): + """Test that extract_connected_dcids is successful when multiple dcid and multiple + properties are in the response.""" + json_data = { + "data": { + "geoId/06": { + "arcs": { + "containedInPlace": { + "nodes": [{ + "dcid": "country/USA", + "name": "United States", + "provenanceId": "dc/base/WikidataOtherIdGeos", + "types": ["Country"] + }, { + "dcid": "usc/PacificDivision", + "name": "Pacific Division", + "provenanceId": "dc/base/WikidataOtherIdGeos", + "types": ["CensusDivision"] + }] + }, + "name": { + "nodes": [{ + "provenanceId": "dc/base/WikidataOtherIdGeos", + "value": "California" + }] + } + } + }, + "geoId/07": { + "arcs": { + "containedInPlace": { + "nodes": [{ + "dcid": "country/USA", + "name": "United States", + "provenanceId": "dc/base/WikidataOtherIdGeos", + "types": ["Country"] + }] + }, + } + } + } + } + response = NodeResponse.model_validate(json_data) + result = response.extract_connected_dcids(subject_dcid='geoId/06', + property_dcid='containedInPlace') + assert result == ['country/USA', 'usc/PacificDivision'] + + +def test_extract_connected_dcids_with_nonexistent_dcid(): + """Test that extract_connected_dcids returns empty when requested dcid is not in the + NodeResponse.""" + json_data = { + "data": { + "geoId/06": { + "arcs": { + "name": { + "nodes": [{ + "provenanceId": "dc/base/WikidataOtherIdGeos", + "value": "California" + }] + } + } + }, + } + } + response = NodeResponse.model_validate(json_data) + result = response.extract_connected_dcids(subject_dcid='geoId/07', + property_dcid='name') + assert result == [] + + +def test_extract_connected_dcids_with_nonexistent_property(): + """Test that extract_connected_dcids returns empty when requested property is not in + the NodeResponse.""" + json_data = { + "data": { + "geoId/06": { + "arcs": { + "name": { + "nodes": [{ + "provenanceId": "dc/base/WikidataOtherIdGeos", + "value": "California" + }] + } + } + }, + } + } + response = NodeResponse.model_validate(json_data) + result = response.extract_connected_dcids(subject_dcid='geoId/06', + property_dcid='containedInPlace') + assert result == [] + + +def test_extract_connected_dcids_does_not_include_none_for_value_only_nodes(): + """Test that extract_connected_dcids does not include None in the returned list + when the nodes in the response only contain values and not dcids.""" + json_data = { + "data": { + "geoId/06": { + "arcs": { + "name": { + "nodes": [{ + "provenanceId": "dc/base/WikidataOtherIdGeos", + "value": "California" + }] + } + } + }, + } + } + response = NodeResponse.model_validate(json_data) + result = response.extract_connected_dcids(subject_dcid='geoId/06', + property_dcid='name') + assert result == [] + + +def test_extract_connected_dcids_with_node_type_filter(): + """Test that extract_connected_dcids returns dcids with the corresponding + node_type.""" + + json_data = { + "data": { + "geoId/06": { + "arcs": { + "relatedPlaces": { + "nodes": [{ + "dcid": "country/USA", + "name": "United States", + "provenanceId": "dc/base/WikidataOtherIdGeos", + "types": ["Country"] + }, { + "dcid": "usc/PacificDivision", + "name": "Pacific Division", + "provenanceId": "dc/base/WikidataOtherIdGeos", + "types": ["CensusDivision"] + }, { + "dcid": "node3", + }] + } + } + }, + } + } + response = NodeResponse.model_validate(json_data) + result = response.extract_connected_dcids(subject_dcid='geoId/06', + property_dcid='relatedPlaces', + connected_node_types="Country") + assert result == ['country/USA'] + + +def test_extract_connected_dcids_with_multiple_node_type_filter(): + """Test that extract_connected_dcids returns dcids with the corresponding + connected_node_types.""" + json_data = { + "data": { + "geoId/06": { + "arcs": { + "relatedPlaces": { + "nodes": [{ + "dcid": "country/USA", + "name": "United States", + "provenanceId": "dc/base/WikidataOtherIdGeos", + "types": ["Country"] + }, { + "dcid": "usc/PacificDivision", + "name": "Pacific Division", + "provenanceId": "dc/base/WikidataOtherIdGeos", + "types": ["CensusDivision"] + }, { + "dcid": "node3", + "types": ["City"] + }] + } + } + }, + } + } + response = NodeResponse.model_validate(json_data) + result = response.extract_connected_dcids( + subject_dcid='geoId/06', + property_dcid='relatedPlaces', + connected_node_types=["Country", "City"]) + assert result == ['country/USA', 'node3'] + + +def test_extract_connected_nodes_with_multiple_node_type_filter(): + """Test that extract_connected_nodes returns only nodes with the corresponding + connected_node_types.""" + + json_data = { + "data": { + "geoId/06": { + "arcs": { + "relatedPlaces": { + "nodes": [{ + "dcid": "country/USA", + "name": "United States", + "provenanceId": "dc/base/WikidataOtherIdGeos", + "types": ["Country"] + }, { + "dcid": "usc/PacificDivision", + "name": "Pacific Division", + "provenanceId": "dc/base/WikidataOtherIdGeos", + "types": ["CensusDivision"] + }, { + "dcid": "node3", + "types": ["City"] + }] + } + } + }, + } + } + response = NodeResponse.model_validate(json_data) + result = response.extract_connected_nodes( + subject_dcid='geoId/06', + property_dcid='relatedPlaces', + connected_node_types=["Country", "City"]) + assert result == [ + Node(dcid="country/USA", + name="United States", + provenanceId="dc/base/WikidataOtherIdGeos", + types=["Country"]), + Node(dcid="node3", types=["City"]) + ] + + +### ----- Test Observation Response ----- ### + + +def test_get_data_by_entity(): + """Test that get_data_by_entity correctly extracts data grouped by entities.""" + # Mocking ObservationResponse with byVariable data + mock_data = { + "variable1": + Variable(byEntity={ + "entity1": { + "orderedFacets": [] + }, + "entity2": { + "orderedFacets": [] + }, + }), + "variable2": + Variable(byEntity={ + "entity3": { + "orderedFacets": [] + }, + }), + } + response = ObservationResponse.model_validate({"byVariable": mock_data}) + + result = response.get_data_by_entity() + + # Expected output + expected = { + "variable1": { + "entity1": { + "orderedFacets": [] + }, + "entity2": { + "orderedFacets": [] + }, + }, + "variable2": { + "entity3": { + "orderedFacets": [] + }, + }, + } + + assert result.to_dict() == expected + + +def test_observation_as_dict(): + """Test that the ObservationResponse.json property returns the correct dictionary.""" + json_data = { + "byVariable": { + "var1": { + "byEntity": { + "entity1": { + "orderedFacets": [{ + "facetId": "facet1" + }] + } + } + } + }, + "facets": { + "facet1": { + "unit": "GTQ", + "importName": "Import Name", + } + }, + } + + # Parsing JSON data + response = ObservationResponse.model_validate(json_data) + + # Getting it back as a dictionary + result = response.to_dict() + + assert "byVariable" in result + assert "facets" in result + assert "var1" in result["byVariable"] + assert "entity1" in result["byVariable"]["var1"]["byEntity"] + + +def test_observation_as_dict_exclude_none(): + """Test that the ObservationResponse.json property returns the correct dictionary.""" + json_data = { + "byVariable": { + "var1": { + "byEntity": { + "entity1": { + "orderedFacets": [{ + "facetId": "facet1" + }] + } + } + } + }, + "facets": { + "facet1": { + "unit": "GTQ", + "importName": "Import Name", + } + }, + } + + # Parsing JSON data + response = ObservationResponse.model_validate(json_data) + + # Getting it back as a dictionary + result = response.to_dict(exclude_none=True) + + assert ("latestDate" not in result["byVariable"]["var1"]["byEntity"] + ["entity1"]["orderedFacets"][0]) + + +def test_observation_response_model_validation(): + """Test that ObservationResponse.model_validate parses JSON correctly.""" + json_data = { + "byVariable": { + "var1": { + "byEntity": { + "entity1": { + "orderedFacets": [{ + "facetId": "facet1" + }] + } + } + } + }, + "facets": { + "facet1": { + "unit": "GTQ", + "importName": "Import Name", + } + }, + } + + # Parsing JSON data + response = ObservationResponse.model_validate(json_data) + + assert "var1" in response.byVariable + assert "entity1" in response.byVariable["var1"].byEntity + assert "facet1" in response.facets + assert response.facets["facet1"].unit == "GTQ" + + +def test_get_data_by_entity_from_method(): + """Test that get_data_by_entity correctly extracts data grouped by entities.""" + # Mocking ObservationResponse with byVariable data + mock_data = { + "variable1": + Variable(byEntity={ + "entity1": { + "orderedFacets": [] + }, + "entity2": { + "orderedFacets": [] + }, + }), + "variable2": + Variable(byEntity={ + "entity3": { + "orderedFacets": [] + }, + }), + } + response = ObservationResponse.model_validate({"byVariable": mock_data}) + + result = response.get_data_by_entity() + + # Expected output + expected = { + "variable1": { + "entity1": { + "orderedFacets": [] + }, + "entity2": { + "orderedFacets": [] + }, + }, + "variable2": { + "entity3": { + "orderedFacets": [] + }, + }, + } + + assert result.to_dict() == expected + + +def test_extract_observations(): + """Test that extract_observations correctly processes observations with typed inputs.""" + variable = "var1" + entity = "entity1" + + # Mocking OrderedFacet and Observations + entity_data = OrderedFacets.model_validate({ + "orderedFacets": [ + OrderedFacet( + facetId="facet1", + earliestDate="2023-01-01", + latestDate="2023-01-31", + obsCount=2, + observations=[ + Observation(date="2023-01-01", value=10.0), + Observation(date="2023-01-15", value=15.0), + ], + ) + ] + }) + + # Mocking facet metadata + facet_metadata = { + "facet1": + Facet( + importName="Example Import", + measurementMethod="Example Method", + observationPeriod="P1D", + provenanceUrl="http://example.com", + unit="Example Unit", + ) + } + + # Extracting observations + result = extract_observations(variable=variable, + entity=entity, + entity_data=entity_data, + facet_metadata=facet_metadata) + + # Assertions + assert len(result) == 2, "There should be two observation records." + assert result[0].date == "2023-01-01" + assert result[0].value == 10.0 + assert result[0].facetId == "facet1" + assert result[0].importName == "Example Import" + assert result[1].date == "2023-01-15" + assert result[1].value == 15.0 + + +def test_get_observations_as_records(): + """Test that get_observations_as_records correctly converts data into records.""" + # Minimal input setup for byVariable and facets + mock_data = ByVariable.model_validate({ + "variable1": + Variable( + byEntity={ + "entity1": { + "orderedFacets": [ + OrderedFacet( + facetId="facet1", + observations=[ + Observation(date="2023-01-01", value=10.0), + Observation(date="2023-01-15", value=15.0), + ], + ) + ] + } + }) + }) + + mock_facets = {"facet1": Facet(importName="ImportName")} + + # Create an ObservationResponse instance + response = ObservationResponse(byVariable=mock_data, facets=mock_facets) + + # Call the method and get the result + result = response.to_observation_records() + + # Expected output + expected = [ + { + "date": "2023-01-01", + "entity": "entity1", + "variable": "variable1", + "value": 10.0, + "facetId": "facet1", + "importName": "ImportName", + }, + { + "date": "2023-01-15", + "entity": "entity1", + "variable": "variable1", + "value": 15.0, + "facetId": "facet1", + "importName": "ImportName", + }, + ] + + # Assert the results + assert result.model_dump(exclude_none=True) == expected + + +### ----- Test Resolve Response ----- ### + + +def test_resolve_response_model_validation(): + """Test that ResolveResponse.model_validate parses entities and candidates.""" + # Mock input JSON + json_data = { + "entities": [ + { + "node": + "entity1", + "candidates": [ + { + "dcid": "dcid1", + "dominantType": "Type1" + }, + { + "dcid": "dcid2", + "dominantType": None + }, + ], + }, + { + "node": "entity2", + "candidates": [{ + "dcid": "dcid3", + "dominantType": "Type2" + },], + }, + ] + } + + # Parse the response + response = ResolveResponse.model_validate(json_data) + + # Assert the number of entities + assert len(response.entities) == 2 + + # Validate the first entity + entity1 = response.entities[0] + assert entity1.node == "entity1" + assert len(entity1.candidates) == 2 + assert entity1.candidates[0].dcid == "dcid1" + assert entity1.candidates[0].dominantType == "Type1" + assert entity1.candidates[1].dcid == "dcid2" + assert entity1.candidates[1].dominantType is None + + # Validate the second entity + entity2 = response.entities[1] + assert entity2.node == "entity2" + assert len(entity2.candidates) == 1 + assert entity2.candidates[0].dcid == "dcid3" + assert entity2.candidates[0].dominantType == "Type2" + + +def test_resolve_response_dict(): + """Test that ResolveResponse.to_dict and json are consistent.""" + # Input dictionary + input_data = { + "entities": [ + { + "node": + "entity1", + "candidates": [ + { + "dcid": "dcid1", + "dominantType": "Type1", + "metadata": None, + "typeOf": None, + }, + { + "dcid": "dcid2", + "dominantType": None, + "metadata": None, + "typeOf": None, + }, + ], + }, + { + "node": + "entity2", + "candidates": [{ + "dcid": "dcid3", + "dominantType": "Type2", + "metadata": None, + "typeOf": None, + },], + }, + ] + } + + # Create ResolveResponse from the dictionary + response = ResolveResponse.model_validate(input_data) + + # Convert back to dictionary using the json property + result = response.to_dict(exclude_none=False) + + # Assert that the resulting dictionary matches the original input + assert result == input_data + + +def test_resolve_response_dict_exclude_none(): + """Test that ResolveResponse.to_dict and json are consistent.""" + # Input dictionary + input_data = { + "entities": [ + { + "node": + "entity1", + "candidates": [ + { + "dcid": "dcid1", + "dominantType": "Type1" + }, + { + "dcid": "dcid2", + "dominantType": None + }, + ], + }, + { + "node": "entity2", + "candidates": [{ + "dcid": "dcid3", + "dominantType": "Type2" + },], + }, + { + "node": "entity3", + "candidates": [], + }, + ] + } + + # Expected data + expected_data = { + "entities": [ + { + "node": + "entity1", + "candidates": [ + { + "dcid": "dcid1", + "dominantType": "Type1" + }, + { + "dcid": "dcid2" + }, + ], + }, + { + "node": "entity2", + "candidates": [{ + "dcid": "dcid3", + "dominantType": "Type2" + },], + }, + { + "node": "entity3", + "candidates": [], + }, + ] + } + + # Create ResolveResponse from the dictionary + response = ResolveResponse.model_validate(input_data) + + # Convert back to dictionary using the json property + result = response.to_dict(exclude_none=True) + + # Assert that the resulting dictionary matches the original input + assert result == expected_data + + +def test_resolve_response_json_string_exclude_none(): + """Test that ResolveResponse.to_dict and json are consistent.""" + # Input dictionary + input_data = { + "entities": [ + { + "node": + "entity1", + "candidates": [ + { + "dcid": "dcid1", + "dominantType": "Type1", + "metadata": None, + "typeOf": None, + }, + { + "dcid": "dcid2", + "dominantType": None, + "metadata": None, + "typeOf": None, + }, + ], + }, + { + "node": + "entity2", + "candidates": [{ + "dcid": "dcid3", + "dominantType": "Type2", + "metadata": None, + "typeOf": None, + },], + }, + { + "node": "entity3", + "candidates": [], + }, + ] + } + + # Expected data + expected = json.dumps(input_data, indent=2) + + # Create ResolveResponse from the dictionary + response = ResolveResponse.model_validate(input_data) + + # Convert back to dictionary using the json property + result = response.to_json(exclude_none=False) + + # Assert that the resulting dictionary matches the original input + assert result == expected + + +def test_get_facets_metadata(): + """Test that get_facets_metadata correctly extracts and structures facet metadata.""" + payload = { + "byVariable": { + "variable1": { + "byEntity": { + "entity1": { + "orderedFacets": [{ + "facetId": "facet1", + "earliestDate": "2023", + "latestDate": "2025", + "obsCount": 5, + "observations": [] + }] + }, + "entity2": { + "orderedFacets": [{ + "facetId": "facet2", + "earliestDate": "2021", + "latestDate": "2021", + "obsCount": 3, + "observations": [] + }] + }, + } + }, + "variable2": { + "byEntity": { + "entity3": { + "orderedFacets": [{ + "facetId": "facet1", + "earliestDate": "2000", + "latestDate": "2013", + "obsCount": 7, + "observations": [] + }] + } + } + }, + }, + "facets": { + "facet1": { + "unit": "USD", + "importName": "Import Source" + }, + "facet2": { + "unit": "Year", + "importName": "Another Source" + }, + }, + } + + # build ObservationResponse + response = ObservationResponse.model_validate(payload) + + # Call the method + result = response.get_facets_metadata() + + # Expected structure + expected = { + "variable1": { + "facet1": { + "earliestDate": { + "entity1": "2023" + }, + "latestDate": { + "entity1": "2025" + }, + "obsCount": { + "entity1": 5 + }, + "unit": "USD", + "importName": "Import Source", + "measurementMethod": None, + "observationPeriod": None, + "provenanceUrl": None, + }, + "facet2": { + "earliestDate": { + "entity2": "2021" + }, + "latestDate": { + "entity2": "2021" + }, + "obsCount": { + "entity2": 3 + }, + "unit": "Year", + "importName": "Another Source", + "measurementMethod": None, + "observationPeriod": None, + "provenanceUrl": None, + }, + }, + "variable2": { + "facet1": { + "earliestDate": { + "entity3": "2000" + }, + "latestDate": { + "entity3": "2013" + }, + "obsCount": { + "entity3": 7 + }, + "unit": "USD", + "importName": "Import Source", + "measurementMethod": None, + "observationPeriod": None, + "provenanceUrl": None, + } + }, + } + + assert result == expected + + +def test_find_matching_facet_id(monkeypatch): + """Tests that find_matching_facet_id correctly finds facet IDs matching a given property and value.""" + mock_response = ObservationResponse(byVariable={}, facets={}) + mock_metadata = { + "statvar1": { + "facet1": { + "measurementMethod": "Census" + }, + "facet2": { + "measurementMethod": "Survey" + }, + }, + "statvar2": { + "facet3": { + "unit": "USD" + }, + }, + } + monkeypatch.setattr( + ObservationResponse, + "get_facets_metadata", + lambda self: mock_metadata, + ) + + result = mock_response.find_matching_facet_id("measurementMethod", "Census") + assert result == ["facet1"] + + result = mock_response.find_matching_facet_id("measurementMethod", + ["Census", "Survey"]) + assert result == ["facet1", "facet2"] + + result = mock_response.find_matching_facet_id("unit", "USD") + assert result == ["facet3"] + + result = mock_response.find_matching_facet_id("measurementMethod", + "Nonexistent") + assert result == [] diff --git a/datacommons_client/tests/models/test_node_models.py b/datacommons_client/tests/models/test_node_models.py new file mode 100644 index 00000000..ce70f2a6 --- /dev/null +++ b/datacommons_client/tests/models/test_node_models.py @@ -0,0 +1,153 @@ +from datacommons_client.models.node import Arcs +from datacommons_client.models.node import Node +from datacommons_client.models.node import NodeGroup +from datacommons_client.models.node import Properties +from datacommons_client.models.node import StatVarConstraint +from datacommons_client.models.node import StatVarConstraints + + +def test_node_model_validation(): + """Test that Node.model_validate parses data correctly.""" + json_data = { + "dcid": "node123", + "name": "Test Node", + "provenanceId": "prov123", + "types": ["TypeA", "TypeB"], + "value": "42", + } + node = Node.model_validate(json_data) + assert node.dcid == "node123" + assert node.name == "Test Node" + assert node.provenanceId == "prov123" + assert node.types == ["TypeA", "TypeB"] + assert node.value == "42" + + +def test_node_model_validation_partial(): + """Test Node.model_validate with partial data.""" + json_data = { + "dcid": "node123", + } + node = Node.model_validate(json_data) + assert node.dcid == "node123" + assert node.name is None + assert node.provenanceId is None + assert node.types is None + assert node.value is None + + +def test_nodegroup_model_validation(): + """Test that NodeGroup.model_validate parses data correctly.""" + json_data = { + "nodes": [ + { + "dcid": "node1", + "name": "Node 1" + }, + { + "dcid": "node2", + "name": "Node 2" + }, + ] + } + node_group = NodeGroup.model_validate(json_data) + assert len(node_group.nodes) == 2 + assert node_group.nodes[0].dcid == "node1" + assert node_group.nodes[1].name == "Node 2" + + +def test_nodegroup_model_validation_empty(): + """Test NodeGroup.model_validate with empty data.""" + json_data = {} + node_group = NodeGroup.model_validate(json_data) + assert len(node_group.nodes) == 0 + + +def test_arcs_model_validation(): + """Test that Arcs.model_validate parses data correctly.""" + json_data = { + "arcs": { + "label1": { + "nodes": [{ + "dcid": "node1" + }, { + "dcid": "node2" + }] + }, + "label2": { + "nodes": [{ + "dcid": "node3" + }] + }, + } + } + arcs = Arcs.model_validate(json_data) + assert len(arcs.arcs) == 2 + assert "label1" in arcs.arcs + assert len(arcs.arcs["label1"].nodes) == 2 + assert arcs.arcs["label1"].nodes[0].dcid == "node1" + assert len(arcs.arcs["label2"].nodes) == 1 + assert arcs.arcs["label2"].nodes[0].dcid == "node3" + + +def test_arcs_model_validation_empty(): + """Test Arcs.model_validate with empty data.""" + json_data = {} + arcs = Arcs.model_validate(json_data) + assert len(arcs.arcs) == 0 + + +def test_properties_model_validation(): + """Test that Properties.model_validate parses data correctly.""" + json_data = {"properties": ["prop1", "prop2", "prop3"]} + properties = Properties.model_validate(json_data) + assert len(properties.properties) == 3 + assert properties.properties == ["prop1", "prop2", "prop3"] + + +def test_properties_model_validation_empty(): + """Test Properties.model_validate with empty data.""" + json_data = {} + properties = Properties.model_validate(json_data) + assert properties.properties is None + + +def test_statvarconstraint_model_validation(): + """Test StatVarConstraint.model_validate parses data correctly.""" + data = { + "constraintId": "DevelopmentFinanceScheme", + "constraintName": "Development Finance Scheme", + "valueId": "ODAGrants", + "valueName": "Official Development Assistance Grants", + } + constraint = StatVarConstraint.model_validate(data) + + assert constraint.constraintId == "DevelopmentFinanceScheme" + assert constraint.constraintName == "Development Finance Scheme" + assert constraint.valueId == "ODAGrants" + assert constraint.valueName == "Official Development Assistance Grants" + + +def test_statvarconstraints_model_validation(): + """Test StatVarConstraints root model validates mapping properly.""" + constraints = StatVarConstraints.model_validate({ + "sv/1": [ + { + "constraintId": "DevelopmentFinanceScheme", + "constraintName": "Development Finance Scheme", + "valueId": "ODAGrants", + "valueName": "Official Development Assistance Grants", + }, + { + "constraintId": "DevelopmentFinanceRecipient", + "constraintName": "Development Finance Recipient", + "valueId": "country/GTM", + "valueName": "Guatemala", + }, + ], + "sv/2": [], + }) + + assert "sv/1" in constraints and "sv/2" in constraints + assert len(constraints["sv/1"]) == 2 + assert constraints["sv/2"] == [] diff --git a/datacommons_client/tests/models/test_observation_models.py b/datacommons_client/tests/models/test_observation_models.py new file mode 100644 index 00000000..670f85bb --- /dev/null +++ b/datacommons_client/tests/models/test_observation_models.py @@ -0,0 +1,157 @@ +import pytest + +from datacommons_client.models.observation import Facet +from datacommons_client.models.observation import Observation +from datacommons_client.models.observation import ObservationSelectList +from datacommons_client.models.observation import OrderedFacet +from datacommons_client.models.observation import Variable +from datacommons_client.utils.error_handling import InvalidObservationSelectError + + +def test_observation_model_validation(): + """Test that Observation.model_validate parses data correctly.""" + json_data = {"date": "2024-01-01", "value": 123.45} + observation = Observation.model_validate(json_data) + assert observation.date == "2024-01-01" + assert observation.value == 123.45 + assert isinstance(observation.value, float) + + +def test_observation_model_validation_partial(): + """Test Observation.model_validate with missing data.""" + json_data = {"date": "2024-01-01"} + observation = Observation.model_validate(json_data) + assert observation.date == "2024-01-01" + assert observation.value is None + + +def test_ordered_facets_model_validation(): + """Test that OrderedFacet.model_validate parses data correctly.""" + json_data = { + "earliestDate": + "2023-01-01", + "facetId": + "facet123", + "latestDate": + "2024-01-01", + "obsCount": + 2, + "observations": [ + { + "date": "2023-01-01", + "value": 100.0 + }, + { + "date": "2024-01-01", + "value": 200.0 + }, + ], + } + ordered_facets = OrderedFacet.model_validate(json_data) + assert ordered_facets.earliestDate == "2023-01-01" + assert ordered_facets.facetId == "facet123" + assert ordered_facets.latestDate == "2024-01-01" + assert ordered_facets.obsCount == 2 + assert len(ordered_facets.observations) == 2 + assert ordered_facets.observations[0].value == 100.0 + + +def test_ordered_facets_model_validation_empty_observations(): + """Test OrderedFacet.model_validate with empty observations.""" + json_data = { + "earliestDate": "2023-01-01", + "facetId": "facet123", + "latestDate": "2024-01-01", + "obsCount": 0, + "observations": [], + } + ordered_facets = OrderedFacet.model_validate(json_data) + assert len(ordered_facets.observations) == 0 + + +def test_variable_model_validation(): + """Test that Variable.model_validate parses data correctly.""" + json_data = { + "byEntity": { + "entity1": { + "orderedFacets": [{ + "earliestDate": + "2023-01-01", + "facetId": + "facet1", + "latestDate": + "2023-12-31", + "obsCount": + 2, + "observations": [ + { + "date": "2023-01-01", + "value": 50.0 + }, + { + "date": "2023-12-31", + "value": 75.0 + }, + ], + }] + } + } + } + variable = Variable.model_validate(json_data) + assert "entity1" in variable.byEntity + facets = variable.byEntity["entity1"].orderedFacets + assert len(facets) == 1 + assert facets[0].facetId == "facet1" + assert facets[0].observations[0].value == 50.0 + + +def test_variable_model_validation_empty(): + """Test Variable.model_validate with empty byEntity.""" + json_data = {"byEntity": {}} + variable = Variable.model_validate(json_data) + assert len(variable.byEntity) == 0 + + +def test_facet_model_validation(): + """Test that Facet.model_validate parses data correctly.""" + json_data = { + "importName": "Import 1", + "measurementMethod": "Method A", + "observationPeriod": "2023", + "provenanceUrl": "http://example.com", + "unit": "usd", + } + facet = Facet.model_validate(json_data) + assert facet.importName == "Import 1" + assert facet.measurementMethod == "Method A" + assert facet.observationPeriod == "2023" + assert facet.provenanceUrl == "http://example.com" + assert facet.unit == "usd" + + +def test_facet_model_validation_partial(): + """Test Facet.model_validate with missing data.""" + json_data = {"importName": "Import 1", "unit": "GTQ"} + facet = Facet.model_validate(json_data) + assert facet.importName == "Import 1" + assert facet.measurementMethod is None + assert facet.unit == "GTQ" + assert facet.provenanceUrl is None + + +def test_observation_select_list_defaults(): + """ObservationSelectList returns default selects when none provided.""" + osl = ObservationSelectList.model_validate(None) + assert osl.select == ["date", "variable", "entity", "value"] + + +def test_observation_select_list_custom(): + """ObservationSelectList accepts custom select lists.""" + osl = ObservationSelectList.model_validate(["variable", "entity", "facet"]) + assert osl.select == ["variable", "entity", "facet"] + + +def test_observation_select_list_missing_required(): + """Missing required select entries raises InvalidObservationSelectError.""" + with pytest.raises(InvalidObservationSelectError): + ObservationSelectList.model_validate(["date", "value"]) diff --git a/datacommons_client/tests/models/test_resolve_models.py b/datacommons_client/tests/models/test_resolve_models.py new file mode 100644 index 00000000..7a5e205e --- /dev/null +++ b/datacommons_client/tests/models/test_resolve_models.py @@ -0,0 +1,51 @@ +from datacommons_client.models.resolve import Candidate +from datacommons_client.models.resolve import Entity + + +def test_candidate_model_validation(): + """Test that Candidate.model_validate parses full data correctly.""" + json_data = {"dcid": "dcid123", "dominantType": "Place"} + candidate = Candidate.model_validate(json_data) + assert candidate.dcid == "dcid123" + assert candidate.dominantType == "Place" + + +def test_candidate_model_validation_partial(): + """Test Candidate.model_validate with missing optional dominantType.""" + json_data = {"dcid": "dcid456"} + candidate = Candidate.model_validate(json_data) + assert candidate.dcid == "dcid456" + assert candidate.dominantType is None + + +def test_entity_model_validation(): + """Test that Entity.model_validate handles multiple candidates.""" + json_data = { + "node": + "test_query", + "candidates": [ + { + "dcid": "dcid123", + "dominantType": "Place" + }, + { + "dcid": "dcid456", + "dominantType": "Event" + }, + ], + } + entity = Entity.model_validate(json_data) + assert entity.node == "test_query" + assert len(entity.candidates) == 2 + assert entity.candidates[0].dcid == "dcid123" + assert entity.candidates[0].dominantType == "Place" + assert entity.candidates[1].dcid == "dcid456" + assert entity.candidates[1].dominantType == "Event" + + +def test_entity_model_validation_empty_candidates(): + """Test Entity.model_validate with no candidates.""" + json_data = {"node": "test_query", "candidates": []} + entity = Entity.model_validate(json_data) + assert entity.node == "test_query" + assert len(entity.candidates) == 0 diff --git a/datacommons_client/tests/test_client.py b/datacommons_client/tests/test_client.py new file mode 100644 index 00000000..221befff --- /dev/null +++ b/datacommons_client/tests/test_client.py @@ -0,0 +1,473 @@ +from unittest.mock import MagicMock +from unittest.mock import patch + +import pandas as pd +import pytest + +from datacommons_client import use_api_key +from datacommons_client.client import DataCommonsClient +from datacommons_client.endpoints.base import API +from datacommons_client.endpoints.node import NodeEndpoint +from datacommons_client.endpoints.observation import ObservationEndpoint +from datacommons_client.endpoints.resolve import ResolveEndpoint +from datacommons_client.models.node import Name +from datacommons_client.models.node import StatVarConstraint +from datacommons_client.models.node import StatVarConstraints +from datacommons_client.models.observation import ObservationRecord +from datacommons_client.models.observation import ObservationRecords +from datacommons_client.utils.error_handling import NoDataForPropertyError + + +@pytest.fixture +def mock_client(): + """Fixture to create a DataCommonsClient instance with a mocked API.""" + with patch("datacommons_client.endpoints.base.API.post") as mock_post: + client = DataCommonsClient(api_key="test_key") + client.observation = MagicMock(spec=ObservationEndpoint) + return client + + +@patch( + "datacommons_client.endpoints.base.resolve_instance_url", + return_value="https://datacommons.org", +) +@patch( + "datacommons_client.utils.request_handling.check_instance_is_valid", + return_value="https://datacommons.org", +) +def test_datacommons_client_initialization(mock_check_instance, + mock_resolve_instance_url): + """Tests that DataCommonsClient initializes correctly with API and endpoints, using a fake address.""" + client = DataCommonsClient(api_key="test_key", dc_instance="test_instance") + + assert isinstance(client.api, API) + assert client.api.headers == { + "Content-Type": "application/json", + "X-API-Key": "test_key", + "x-surface": "clientlib-python" + } + + assert isinstance(client.node, NodeEndpoint) + assert isinstance(client.observation, ObservationEndpoint) + assert isinstance(client.resolve, ResolveEndpoint) + + assert client.node.api is client.api + assert client.observation.api is client.api + assert client.resolve.api is client.api + + +@patch( + "datacommons_client.endpoints.base.check_instance_is_valid", + return_value="https://test.url", +) +@patch( + "datacommons_client.endpoints.base.resolve_instance_url", + return_value="https://datacommons.org", +) +def test_datacommons_client_initialization_with_surface_header( + mock_check_instance, mock_resolve_instance_url): + """Tests that DataCommonsClient initializes correctly with a surface header value.""" + + client = DataCommonsClient(api_key="test_key", + dc_instance="test_instance", + surface_header_value="mcp-1.0") + + assert isinstance(client.api, API) + assert client.api.headers == { + "Content-Type": "application/json", + "X-API-Key": "test_key", + "x-surface": "mcp-1.0" + } + + +def test_datacommons_client_raises_error_when_both_url_and_instance_are_provided( +): + """Tests that DataCommonsClient raises a ValueError when both `dc_instance` and `url` are given.""" + with pytest.raises(ValueError, + match="Cannot provide both `dc_instance` and `url`."): + DataCommonsClient(api_key="test_key", + dc_instance="test_instance", + url="https://test.url") + + +def test_observations_dataframe_raises_error_when_entities_all_but_no_entity_type( + mock_client,): + """Tests that ValueError is raised if 'entities' is 'all' but 'entity_type' is not specified.""" + with pytest.raises( + ValueError, + match= + "When 'entity_dcids' is 'all', both 'parent_entity' and 'entity_type' must be specified.", + ): + mock_client.observations_dataframe(variable_dcids="var1", + date="2024", + entity_dcids="all", + parent_entity="africa") + + +def test_observations_dataframe_raises_error_when_entities_all_but_no_parent_entity( + mock_client,): + """Tests that ValueError is raised if 'entities' is 'all' but 'entity_type' is not specified.""" + with pytest.raises( + ValueError, + match= + "When 'entity_dcids' is 'all', both 'parent_entity' and 'entity_type' must be specified.", + ): + mock_client.observations_dataframe(variable_dcids="var1", + date="2024", + entity_dcids="all", + entity_type="Country") + + +def test_observations_dataframe_raises_error_when_invalid_entity_type_usage( + mock_client,): + """Tests that ValueError is raised if 'entity_type' or 'parent_entity' is specified with specific entities.""" + with pytest.raises( + ValueError, + match="Specify 'entity_type' and 'parent_entity'" + " only when 'entity_dcids' is 'all'.", + ): + mock_client.observations_dataframe( + variable_dcids="var1", + date="2024", + entity_dcids=["entity1"], + entity_type="Country", + ) + + +def test_observations_dataframe_calls_fetch_observations_by_entity_type( + mock_client): + """Tests that fetch_observations_by_entity_type is called with correct parameters.""" + mock_client.observation.fetch_observations_by_entity_type.return_value.to_observation_records.return_value = ( + ObservationRecords.model_validate([])) + + df = mock_client.observations_dataframe( + variable_dcids=["var1", "var2"], + date="2024", + entity_dcids="all", + entity_type="Country", + parent_entity="Earth", + ) + + mock_client.observation.fetch_observations_by_entity_type.assert_called_once_with( + date="2024", + variable_dcids=["var1", "var2"], + entity_type="Country", + parent_entity="Earth", + filter_facet_ids=None, + ) + + assert isinstance(df, pd.DataFrame) + assert df.empty + + +def test_observations_dataframe_calls_fetch_observations_by_entity(mock_client): + """Tests that fetch_observations_by_entity is called with correct parameters.""" + + mock_client.observation.fetch_observations_by_entity_dcid.return_value.to_observation_records.return_value = ( + ObservationRecords([])) + + df = mock_client.observations_dataframe(variable_dcids="var1", + date="latest", + entity_dcids=["entity1", "entity2"]) + + mock_client.observation.fetch_observations_by_entity_dcid.assert_called_once_with( + date="latest", + entity_dcids=["entity1", "entity2"], + variable_dcids="var1", + filter_facet_ids=None, + ) + + assert isinstance(df, pd.DataFrame) + assert df.empty + + +def test_observations_dataframe_returns_dataframe_with_expected_columns( + mock_client): + """Tests that the method returns a DataFrame with expected columns.""" + mock_client.observation.fetch_observations_by_entity_dcid.return_value.to_observation_records.return_value = ObservationRecords.model_validate( + [ + { + "date": "2024", + "entity": "entity1", + "variable": "var1", + "value": 100, + "unit": "unit1", + }, + { + "date": "2024", + "entity": "entity2", + "variable": "var2", + "value": 200, + "unit": "unit2", + }, + ]) + + # Mock entity name lookup to prevent API calls + mock_client.node.fetch_entity_names = MagicMock(return_value={ + "entity1": Name(value="Entity One", language="en", property="name"), + "entity2": Name(value="Entity Two", language="en", property="name"), + "var1": Name(value="Variable One", language="en", property="name"), + "var2": Name(value="Variable Two", language="en", property="name"), + },) + + df = mock_client.observations_dataframe(variable_dcids="var1", + date="2024", + entity_dcids=["entity1", "entity2"]) + + assert isinstance(df, pd.DataFrame) + assert set(df.columns) == { + "date", "entity", "entity_name", "variable", "variable_name", "value", + "unit" + } + assert len(df) == 2 + assert df.iloc[0]["entity"] == "entity1" + assert df.iloc[0]["entity_name"] == "Entity One" + assert df.iloc[1]["entity"] == "entity2" + assert df.iloc[1]["entity_name"] == "Entity Two" + assert df.iloc[0]["variable"] == "var1" + assert df.iloc[0]["variable_name"] == "Variable One" + assert df.iloc[0]["value"] == 100 + assert df.iloc[0]["unit"] == "unit1" + assert df.iloc[1]["variable"] == "var2" + assert df.iloc[1]["variable_name"] == "Variable Two" + assert df.iloc[1]["value"] == 200 + assert df.iloc[1]["unit"] == "unit2" + + +def test_observations_dataframe_includes_constraints_metadata(mock_client): + """When include_constraints_metadata=True, DataFrame includes constraint columns.""" + # Two observations with different variables + mock_client.observation.fetch_observations_by_entity_dcid.return_value.to_observation_records.return_value = ObservationRecords.model_validate( + [ + { + "date": "2021", + "entity": "geo/1", + "variable": "sv/A", + "value": 1, + "unit": "Count", + }, + { + "date": "2021", + "entity": "geo/2", + "variable": "sv/B", + "value": 2, + "unit": "Count", + }, + ]) + + # Avoid name lookups + mock_client.node.fetch_entity_names = MagicMock(return_value={}) + + mock_client.node.fetch_statvar_constraints = MagicMock( + return_value=StatVarConstraints.model_validate({ + "sv/A": [ + StatVarConstraint( + constraintId="DevelopmentFinanceScheme", + constraintName="Development Finance Scheme", + valueId="ODAGrants", + valueName="Official Development Assistance Grants", + ) + ], + "sv/B": [ + StatVarConstraint( + constraintId="sex", + constraintName="Sex", + valueId="Female", + valueName="Female", + ) + ], + })) + + df = mock_client.observations_dataframe( + variable_dcids=["sv/A", "sv/B"], + date="2021", + entity_dcids=["geo/1", "geo/2"], + include_constraints_metadata=True, + ) + + # Check presence and correctness of constraint columns + assert "DevelopmentFinanceScheme" in df.columns + assert "DevelopmentFinanceScheme_name" in df.columns + assert "sex" in df.columns and "sex_name" in df.columns + + row_a = df[df["variable"] == "sv/A"].iloc[0] + assert row_a["DevelopmentFinanceScheme"] == "ODAGrants" + assert (row_a["DevelopmentFinanceScheme_name"] == + "Official Development Assistance Grants") + + row_b = df[df["variable"] == "sv/B"].iloc[0] + assert row_b["sex"] == "Female" + assert row_b["sex_name"] == "Female" + + +@patch( + "datacommons_client.endpoints.base.check_instance_is_valid", + return_value="https://test.url", +) +def test_dc_instance_is_ignored_when_url_is_provided(mock_check_instance): + """Tests that dc_instance is ignored when a fully resolved URL is provided.""" + + client = DataCommonsClient(api_key="test_key", url="https://test.url") + + # Check that the API base_url is set to the fully resolved url + assert client.api.base_url == "https://test.url" + + +def test_find_filter_facet_ids_returns_none_when_no_filters(mock_client): + """Tests that _find_filter_facet_ids returns None when no filters are provided.""" + result = mock_client._find_filter_facet_ids(fetch_by="entity", + date="2024", + variable_dcids="var1", + property_filters=None) + assert result is None + + +def test_find_filter_facet_ids_returns_facet_ids(mock_client): + """Tests that _find_filter_facet_ids correctly returns facet IDs when filters are provided.""" + mock_client.observation.fetch_observations_by_entity_dcid.return_value.find_matching_facet_id.side_effect = [ + ["213"], ["3243"] + ] + + result = mock_client._find_filter_facet_ids( + fetch_by="entity", + date="2024", + variable_dcids="var1", + property_filters={ + "measurementMethod": "Census", + "unit": "USD" + }, + ) + + assert set(result) == {"213", "3243"} + + +def test_observations_dataframe_filters_by_facet_ids(mock_client): + """Tests that observations_dataframe includes facet filtering when property_filters are used.""" + mock_client._find_filter_facet_ids = MagicMock( + return_value=["facet_1", "facet_2"]) + + mock_client.observation.fetch_observations_by_entity_dcid.return_value.to_observation_records.return_value = ( + ObservationRecords.model_validate([])) + + df = mock_client.observations_dataframe( + variable_dcids="var1", + date="2024", + entity_dcids=["entity1"], + property_filters={"measurementMethod": "Census"}, + ) + + mock_client.observation.fetch_observations_by_entity_dcid.assert_called_once_with( + variable_dcids="var1", + date="2024", + entity_dcids=["entity1"], + filter_facet_ids=["facet_1", "facet_2"], + ) + assert isinstance(df, pd.DataFrame) + + +def test_observations_dataframe_raises_error_when_no_facet_match(mock_client): + """Tests that observations_dataframe raises NoDataForPropertyError when no facets match the filters.""" + mock_client._find_filter_facet_ids = MagicMock(return_value=None) + + with pytest.raises(NoDataForPropertyError): + mock_client.observations_dataframe( + variable_dcids="var1", + date="2024", + entity_dcids=["entity1"], + property_filters={"measurementMethod": "Nonexistent"}, + ) + + mock_client._find_filter_facet_ids = MagicMock(return_value=[]) + + with pytest.raises(NoDataForPropertyError): + mock_client.observations_dataframe( + variable_dcids="var2", + date="2024", + entity_dcids=["entity1"], + property_filters={"measurementMethodX": "Nonexistent"}, + ) + + +@patch("datacommons_client.utils.request_handling.requests.post") +@patch( + "datacommons_client.utils.request_handling.check_instance_is_valid", + return_value="https://datacommons.org", +) +def test_client_end_to_end_surface_header_propagation_observation( + mock_check_instance, mock_post): + """Tests that the surface_header_value is propagated from client to the final request via the observation endpoint.""" + + # Mock the response from requests.post + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.json.return_value = {"byVariable": {}, "facets": {}} + mock_post.return_value = mock_response + + # Initialize the client with a surface header value + client = DataCommonsClient(api_key="test_key", + surface_header_value="datagemma") + + # Call a method on the observation endpoint that will trigger a post request + client.observation.fetch_observations_by_entity_dcid( + entity_dcids=["country/USA"], + variable_dcids=["Count_Person"], + date="2021") + + # Check that requests.post was called with the correct headers + mock_post.assert_called_once() + _, kwargs = mock_post.call_args + headers = kwargs.get("headers") + assert headers is not None + assert headers.get("x-surface") == "datagemma" + assert headers.get("X-API-Key") == "test_key" + + +@patch("datacommons_client.endpoints.base.post_request") +def test_use_api_key_with_observation_fetch(mock_post_request): + """Test use_api_key override for observation fetches (non-threaded).""" + + # Setup client with default key + client = DataCommonsClient(api_key="default-key") + + # Configure mock to return valid response structure + mock_post_request.return_value = {"byVariable": {}, "facets": {}} + + # Default usage + client.observation.fetch(variable_dcids="sv1", entity_dcids=["geo1"]) + mock_post_request.assert_called() + _, kwargs = mock_post_request.call_args + assert kwargs["headers"]["X-API-Key"] == "default-key" + + # Context override + with use_api_key("context-key"): + client.observation.fetch(variable_dcids="sv1", entity_dcids=["geo1"]) + _, kwargs = mock_post_request.call_args + assert kwargs["headers"]["X-API-Key"] == "context-key" + + # Back to default + client.observation.fetch(variable_dcids="sv1", entity_dcids=["geo1"]) + _, kwargs = mock_post_request.call_args + assert kwargs["headers"]["X-API-Key"] == "default-key" + + +@patch("datacommons_client.endpoints.base.post_request") +def test_use_api_key_with_node_fetch_place_ancestors(mock_post_request): + """Test use_api_key propagation for node graph methods (threaded).""" + + client = DataCommonsClient(api_key="default-key") + + # Configure mock. fetch_place_ancestors expects a dict response or list of nodes. + # NodeResponse.data is a dict. + mock_post_request.return_value = {"data": {}} + + # Default usage + client.node.fetch_place_ancestors(place_dcids=["geoId/06"]) + _, kwargs = mock_post_request.call_args + assert kwargs["headers"]["X-API-Key"] == "default-key" + + # Context override + with use_api_key("context-key"): + # Use a different DCID to avoid hitting fetch_relationship_lru cache + client.node.fetch_place_ancestors(place_dcids=["geoId/07"]) + _, kwargs = mock_post_request.call_args + assert kwargs["headers"]["X-API-Key"] == "context-key" diff --git a/datacommons_client/tests/test_context.py b/datacommons_client/tests/test_context.py new file mode 100644 index 00000000..ef7117cb --- /dev/null +++ b/datacommons_client/tests/test_context.py @@ -0,0 +1,43 @@ +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from datacommons_client.utils.context import _API_KEY_CONTEXT_VAR +from datacommons_client.utils.context import use_api_key + + +def test_use_api_key_sets_var(): + """Test that use_api_key sets the context variable.""" + assert _API_KEY_CONTEXT_VAR.get() is None + with use_api_key("test-key"): + assert _API_KEY_CONTEXT_VAR.get() == "test-key" + assert _API_KEY_CONTEXT_VAR.get() is None + + +def test_use_api_key_nested(): + """Test nested usage of use_api_key.""" + with use_api_key("outer"): + assert _API_KEY_CONTEXT_VAR.get() == "outer" + with use_api_key("inner"): + assert _API_KEY_CONTEXT_VAR.get() == "inner" + assert _API_KEY_CONTEXT_VAR.get() == "outer" + assert _API_KEY_CONTEXT_VAR.get() is None + + +def test_use_api_key_none(): + """Test that use_api_key with None/empty does not set the variable.""" + assert _API_KEY_CONTEXT_VAR.get() is None + with use_api_key(None): + assert _API_KEY_CONTEXT_VAR.get() is None + with use_api_key(""): + assert _API_KEY_CONTEXT_VAR.get() is None diff --git a/datacommons_client/tests/test_dataframes.py b/datacommons_client/tests/test_dataframes.py new file mode 100644 index 00000000..076c1972 --- /dev/null +++ b/datacommons_client/tests/test_dataframes.py @@ -0,0 +1,88 @@ +from unittest.mock import MagicMock + +import pandas as pd + +from datacommons_client.endpoints.node import NodeEndpoint +from datacommons_client.models.node import StatVarConstraint +from datacommons_client.models.node import StatVarConstraints +from datacommons_client.utils.dataframes import add_property_constraints_to_observations_dataframe + + +def test_add_property_constraints_to_observations_dataframe_adds_columns(): + """Adds constraint id and name columns based on statvar metadata.""" + # Input observations + df = pd.DataFrame([ + { + "date": "2020", + "entity": "geo/1", + "variable": "sv/A", + "value": 10, + "unit": "Count", + }, + { + "date": "2020", + "entity": "geo/2", + "variable": "sv/B", + "value": 20, + "unit": "Count", + }, + ]) + + endpoint = MagicMock(spec=NodeEndpoint) + + endpoint.fetch_statvar_constraints.return_value = StatVarConstraints.model_validate( + { + "sv/A": [ + StatVarConstraint( + constraintId="DevelopmentFinanceScheme", + constraintName="Development Finance Scheme", + valueId="ODAGrants", + valueName="Official Development Assistance Grants", + ), + StatVarConstraint( + constraintId="DevelopmentFinanceRecipient", + constraintName="Development Finance Recipient", + valueId="country/GTM", + valueName="Guatemala", + ), + ], + "sv/B": [ + StatVarConstraint( + constraintId="sex", + constraintName="Sex", + valueId="Female", + valueName="Female", + ) + ], + }) + + out = add_property_constraints_to_observations_dataframe(endpoint=endpoint, + observations_df=df) + + # Columns for constraints should be present and filled per variable + assert "DevelopmentFinanceScheme" in out.columns + assert "DevelopmentFinanceScheme_name" in out.columns + assert ("DevelopmentFinanceRecipient" in out.columns and + "DevelopmentFinanceRecipient_name" in out.columns) + assert "sex" in out.columns and "sex_name" in out.columns + + # Row-wise checks + row_a = out[out["variable"] == "sv/A"].iloc[0] + assert row_a["DevelopmentFinanceScheme"] == "ODAGrants" + assert row_a[ + "DevelopmentFinanceScheme_name"] == "Official Development Assistance Grants" + assert row_a["DevelopmentFinanceRecipient"] == "country/GTM" + assert row_a["DevelopmentFinanceRecipient_name"] == "Guatemala" + + row_b = out[out["variable"] == "sv/B"].iloc[0] + assert row_b["sex"] == "Female" + assert row_b["sex_name"] == "Female" + + +def test_add_property_constraints_to_observations_dataframe_empty(): + """Empty DataFrame returns unchanged.""" + endpoint = MagicMock(spec=NodeEndpoint) + empty_df = pd.DataFrame([]) + out = add_property_constraints_to_observations_dataframe( + endpoint=endpoint, observations_df=empty_df) + assert out.empty diff --git a/datacommons_client/tests/test_decorators.py b/datacommons_client/tests/test_decorators.py new file mode 100644 index 00000000..ed143143 --- /dev/null +++ b/datacommons_client/tests/test_decorators.py @@ -0,0 +1,46 @@ +from unittest import mock + +import pytest + +from datacommons_client.utils.decorators import requires_pandas + +try: + import pandas as pd + + PANDAS_AVAILABLE = True +except ImportError: + PANDAS_AVAILABLE = False + + +@requires_pandas +def function_requiring_pandas(): + return "Pandas is available" + + +def test_requires_pandas_with_pandas(): + """Test that the function executes normally when Pandas is available.""" + if PANDAS_AVAILABLE: + assert function_requiring_pandas() == "Pandas is available" + + +def test_requires_pandas_without_pandas(monkeypatch): + """Test that the decorator raises ImportError when Pandas is not available.""" + # Simulate Pandas being unavailable + monkeypatch.setattr("datacommons_client.utils.decorators.pd", None) + with pytest.raises(ImportError, match="Pandas is required for this method"): + function_requiring_pandas() + + +def test_importerror_handling(monkeypatch): + """Test that the ImportError block is executed when Pandas is not installed.""" + + # Simulate pandas not being available + with mock.patch.dict("sys.modules", {"pandas": None}): + import importlib + + # Reload the module so that a new check of Pandas is performed + import datacommons_client.utils.decorators + importlib.reload(datacommons_client.utils.decorators) + + # Ensure pd is set to None + assert datacommons_client.utils.decorators.pd is None diff --git a/datacommons_client/tests/test_names.py b/datacommons_client/tests/test_names.py new file mode 100644 index 00000000..311b094a --- /dev/null +++ b/datacommons_client/tests/test_names.py @@ -0,0 +1,72 @@ +from datacommons_client.models.node import Node +from datacommons_client.utils.names import extract_name_from_english_name_property +from datacommons_client.utils.names import extract_name_from_property_with_language + + +def test_extract_name_from_english_name_property_with_list(): + """Test extracting name from a list of Nodes.""" + properties = [Node(value="Test Name")] + result = extract_name_from_english_name_property(properties) + assert result == "Test Name" + + +def test_extract_name_from_english_empty_list(): + """Test extracting name from an empty list.""" + result = extract_name_from_english_name_property([]) + assert result == "" + + +def test_extract_name_from_english_not_list(): + """Test extracting name from a single Node (not in a list).""" + property_node = Node(value="Single Node Name") + result = extract_name_from_english_name_property(property_node) + assert result == "Single Node Name" + + +def test_extract_name_from_property_with_language_match(): + """Test extracting name when desired language is present.""" + properties = [ + Node(value="Nombre@es"), + Node(value="Name@en"), + ] + result = extract_name_from_property_with_language(properties, + language="es", + fallback_language="en") + assert result[0] == "Nombre" + assert result[1] == "es" + + +def test_extract_name_from_property_with_language_fallback(): + """Test fallback to English when desired language is not found.""" + properties = [ + Node(value="Name@en"), + Node(value="Nom@fr"), + Node(value="Nome@it"), + ] + result = extract_name_from_property_with_language(properties, + language="de", + fallback_language="it") + assert result[0] == "Nome" + assert result[1] == "it" + + +def test_extract_name_from_property_with_language_no_fallback(): + """Test no result when language is not found and fallback is disabled.""" + properties = [ + Node(value="Name@en"), + Node(value="Nom@fr"), + ] + result = extract_name_from_property_with_language(properties, language="de") + assert result[0] is None + assert result[1] is None + + +def test_extract_name_from_property_without_language_tags(): + """Test that properties without language tags are skipped.""" + properties = [ + Node(value="Plain str"), + Node(value="Name@en"), + ] + result = extract_name_from_property_with_language(properties, language="en") + assert result[0] == "Name" + assert result[1] == "en" diff --git a/datacommons_client/tests/test_utils.py b/datacommons_client/tests/test_utils.py new file mode 100644 index 00000000..166b7ef7 --- /dev/null +++ b/datacommons_client/tests/test_utils.py @@ -0,0 +1,40 @@ +from datacommons_client.utils.data_processing import group_variables_by_entity + + +def test_group_variables_by_entity_basic(): + """Test grouping with simple variable-entity mapping.""" + input_data = { + "var1": ["ent1", "ent2"], + "var2": ["ent2", "ent3"], + "var3": ["ent1"], + } + expected_output = { + "ent1": ["var1", "var3"], + "ent2": ["var1", "var2"], + "ent3": ["var2"], + } + + result = group_variables_by_entity(input_data) + assert result == expected_output + + +def test_group_variables_by_entity_duplicate_entities(): + """Test grouping when a variable has duplicate entities.""" + input_data = { + "var1": ["ent1", "ent1", "ent2"], + } + result = group_variables_by_entity(input_data) + assert result["ent1"].count("var1") == 2 # duplicates are preserved + assert "ent2" in result + assert result["ent2"] == ["var1"] + + +def test_group_variables_by_entity_preserves_order(): + """Test if the order of variables is preserved in the resulting entity lists.""" + input_data = { + "var1": ["ent1"], + "var2": ["ent1"], + "var3": ["ent1"], + } + result = group_variables_by_entity(input_data) + assert result["ent1"] == ["var1", "var2", "var3"] diff --git a/datacommons_client/tests/utils/test_graph.py b/datacommons_client/tests/utils/test_graph.py new file mode 100644 index 00000000..0a922eff --- /dev/null +++ b/datacommons_client/tests/utils/test_graph.py @@ -0,0 +1,273 @@ +from collections import defaultdict +from unittest.mock import MagicMock + +from datacommons_client.models.node import Node +from datacommons_client.utils.graph import _assemble_tree +from datacommons_client.utils.graph import _fetch_relationship_uncached +from datacommons_client.utils.graph import _postorder_nodes +from datacommons_client.utils.graph import build_graph_map +from datacommons_client.utils.graph import build_relationship_tree +from datacommons_client.utils.graph import fetch_relationship_lru +from datacommons_client.utils.graph import flatten_relationship + + +def test_fetch_parents_uncached_returns_data(): + """Test _fetch_parents_uncached delegates to endpoint correctly.""" + endpoint = MagicMock() + endpoint.fetch_place_parents.return_value.get.return_value = [ + Node(dcid="parent1", name="Parent 1", types=["Country"]) + ] + + result = _fetch_relationship_uncached(endpoint, + "test_dcid", + contained_type=None, + relationship="parents") + assert isinstance(result, list) + assert result[0].dcid == "parent1" + endpoint.fetch_place_parents.assert_called_once_with( + "test_dcid", + as_dict=False, + ) + + +def test_fetch_relationship_lru_caches_results(): + """Test fetch_relationship_lru uses LRU cache and returns list.""" + endpoint = MagicMock() + endpoint.fetch_place_parents.return_value.get.return_value = [ + Node(dcid="parentX", name="Parent X", types=["Region"]) + ] + + result1 = fetch_relationship_lru(endpoint, + "nodeA", + contained_type=None, + relationship="parents") + result2 = fetch_relationship_lru(endpoint, + "nodeA", + contained_type=None, + relationship="parents") + fetch_relationship_lru(endpoint, + "nodeA", + contained_type=None, + relationship="parents") + + assert isinstance(result1, list) + assert result1[0].dcid == "parentX" + assert result1 == result2 + assert endpoint.fetch_place_parents.call_count == 1 + + +def test_build_ancestry_map_linear_tree(): + """A -> B -> C""" + + def fetch_mock(dcid): + return { + "C": [Node(dcid="B", name="Node B", types=["Type"])], + "B": [Node(dcid="A", name="Node A", types=["Type"])], + "A": [], + }.get(dcid, []) + + root, graph = build_graph_map("C", fetch_mock, max_workers=2) + + assert root == "C" + assert set(graph.keys()) == {"C", "B", "A"} + assert graph["C"][0].dcid == "B" + assert graph["B"][0].dcid == "A" + assert graph["A"] == [] + + +def test_build_ancestry_map_branching_graph(): + r""" + Graph: + F + / \ + D E + / \ / + B C + \/ + A + """ + + def fetch_mock(dcid): + return { + "A": (Node(dcid="B", name="Node B", + types=["Type"]), Node(dcid="C", + name="Node C", + types=["Type"])), + "B": (Node(dcid="D", name="Node D", types=["Type"]),), + "C": (Node(dcid="D", name="Node D", + types=["Type"]), Node(dcid="E", + name="Node E", + types=["Type"])), + "D": (Node(dcid="F", name="Node F", types=["Type"]),), + "E": (Node(dcid="F", name="Node F", types=["Type"]),), + "F": tuple(), + }.get(dcid, tuple()) + + root, ancestry = build_graph_map("A", fetch_mock, max_workers=4) + + assert root == "A" + assert set(ancestry.keys()) == {"A", "B", "C", "D", "E", "F"} + assert [p.dcid for p in ancestry["A"]] == ["B", "C"] # A has two parents + assert [p.dcid for p in ancestry["B"]] == ["D"] # B has one parent + assert [p.dcid for p in ancestry["C"]] == ["D", "E"] # C has two parents + assert [p.dcid for p in ancestry["D"]] == ["F"] # D has one parent + assert [p.dcid for p in ancestry["E"]] == ["F"] # E has one parent + assert ancestry["F"] == [] # F has no parents + + +def test_build_ancestry_map_cycle_detection(): + """ + Graph with a cycle: + A -> B -> C -> A + (Should not loop infinitely) + """ + + call_count = defaultdict(int) + + def fetch_mock(dcid): + call_count[dcid] += 1 + return { + "A": (Node(dcid="B", name="B", types=["Type"]),), + "B": (Node(dcid="C", name="C", types=["Type"]),), + "C": (Node(dcid="A", name="A", types=["Type"]),), # Cycle back to A + }.get(dcid, tuple()) + + root, ancestry = build_graph_map("A", fetch_mock, max_workers=2) + + assert root == "A" # Since we start from A + assert set(ancestry.keys()) == {"A", "B", "C"} + assert [p.dcid for p in ancestry["A"]] == ["B"] # A points to B + assert [p.dcid for p in ancestry["B"]] == ["C"] # B points to C + assert [p.dcid for p in ancestry["C"]] == ["A" + ] # C points back to A but it's ok + + # Check that each node was fetched only once (particularly for A to avoid infinite loop) + assert call_count["A"] == 1 + assert call_count["B"] == 1 + assert call_count["C"] == 1 + + +def test_postorder_nodes_simple_graph(): + """Test postorder traversal on a simple graph.""" + ancestry = { + "C": [Node(dcid="B", name="B", types=["Type"])], + "B": [Node(dcid="A", name="A", types=["Type"])], + "A": [], + } + + order = _postorder_nodes("C", ancestry) + assert order == ["A", "B", "C"] + + new_order = _postorder_nodes("B", ancestry) + assert new_order == ["A", "B"] + + +def test_postorder_nodes_ignores_disconnected(): + """ + Graph: + A <- B <- C + D (disconnected) + """ + graph = { + "A": [Node(dcid="B", name="B", types=["Type"])], + "B": [Node(dcid="C", name="C", types=["Type"])], + "C": [], + "D": [Node(dcid="Z", name="Z", types=["Type"])], + } + order = _postorder_nodes("A", graph) + assert order == ["C", "B", "A"] + assert "D" not in order + + +def test_assemble_tree_creates_nested_structure(): + """Test _assemble_tree creates a nested structure.""" + ancestry = { + "C": [Node(dcid="B", name="Node B", types=["Type"])], + "B": [Node(dcid="A", name="Node A", types=["Type"])], + "A": [], + } + postorder = ["A", "B", "C"] + tree = _assemble_tree(postorder, ancestry, relationship_key="parents") + + assert tree["dcid"] == "C" + assert tree["parents"][0]["dcid"] == "B" + assert tree["parents"][0]["parents"][0]["dcid"] == "A" + + +def test_postorder_nodes_ignores_unreachable_nodes(): + """ + Graph: + A → B → C + Ancestry map also includes D (unconnected) + """ + ancestry = { + "A": [Node(dcid="B", name="B", types=["Type"])], + "B": [Node(dcid="C", name="C", types=["Type"])], + "C": [], + "D": [Node(dcid="X", name="X", types=["Type"])], + } + + postorder = _postorder_nodes("A", ancestry) + + # Only nodes reachable from A should be included + assert postorder == ["C", "B", "A"] + assert "D" not in postorder + + +def test_assemble_tree_shared_parent_not_duplicated(): + """ + Structure: + A → C + B → C + Both A and B have same parent C + """ + + ancestry = { + "A": [Node(dcid="C", name="C name", types=["City"])], + "B": [Node(dcid="C", name="C name", types=["City"])], + "C": [], + } + + postorder = ["C", "A", "B"] # C first to allow bottom-up build + tree = _assemble_tree(postorder, ancestry, relationship_key="parents") + + assert tree["dcid"] == "B" + assert len(tree["parents"]) == 1 + assert tree["parents"][0]["dcid"] == "C" + + # Confirm C only appears once + assert tree["parents"][0] is not None + assert tree["parents"][0]["name"] == "C name" + + +def test_build_ancestry_tree_nested_output(): + """Test build_ancestry_tree creates a nested structure.""" + ancestry = { + "C": [Node(dcid="B", name="B", types=["Type"])], + "B": [Node(dcid="A", name="A", types=["Type"])], + "A": [], + } + + tree = build_relationship_tree("C", ancestry, relationship_key="parents") + + assert tree["dcid"] == "C" + assert tree["parents"][0]["dcid"] == "B" + assert tree["parents"][0]["parents"][0]["dcid"] == "A" + + +def test_flatten_ancestry_deduplicates(): + """Test flatten_ancestry deduplicates parents.""" + + ancestry = { + "X": [Node(dcid="A", name="A", types=["Country"])], + "Y": [ + Node(dcid="A", name="A", types=["Country"]), + Node(dcid="B", name="B", types=["City"]) + ], + } + + flat = flatten_relationship(ancestry) + + assert {"dcid": "A", "name": "A", "types": ["Country"]} in flat + assert {"dcid": "B", "name": "B", "types": ["City"]} in flat + assert len(flat) == 2 diff --git a/datacommons_client/utils/__init__.py b/datacommons_client/utils/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/datacommons_client/utils/context.py b/datacommons_client/utils/context.py new file mode 100644 index 00000000..c76944c5 --- /dev/null +++ b/datacommons_client/utils/context.py @@ -0,0 +1,56 @@ +# Copyright 2025 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from contextlib import contextmanager +from contextvars import ContextVar +from typing import Generator + +_API_KEY_CONTEXT_VAR: ContextVar[str | None] = ContextVar("api_key", + default=None) + + +@contextmanager +def use_api_key(api_key: str | None) -> Generator[None, None, None]: + """Context manager to set the API key for the current execution context. + + If api_key is None or empty, this context manager does nothing, allowing + the underlying client to use its default API key. + + Args: + api_key: The API key to use. If None or empty, no change is made. + + Example: + from datacommons_client import use_api_key + # ... + client = DataCommonsClient(api_key="default-key") + + # Uses "default-key" + client.observation.fetch(...) + + with use_api_key("temp-key"): + # Uses "temp-key" + client.observation.fetch(...) + + # Back to "default-key" + client.observation.fetch(...) + """ + if not api_key: + yield + return + + token = _API_KEY_CONTEXT_VAR.set(api_key) + try: + yield + finally: + _API_KEY_CONTEXT_VAR.reset(token) diff --git a/datacommons_client/utils/data_processing.py b/datacommons_client/utils/data_processing.py new file mode 100644 index 00000000..5e1f6bf3 --- /dev/null +++ b/datacommons_client/utils/data_processing.py @@ -0,0 +1,198 @@ +from dataclasses import asdict +import json +from typing import Any, Dict, List + +from datacommons_client.models.base import ArcLabel +from datacommons_client.models.base import facetID +from datacommons_client.models.base import NodeDCID +from datacommons_client.models.base import Property +from datacommons_client.models.node import Arcs +from datacommons_client.models.node import FlattenedArcsMapping +from datacommons_client.models.node import FlattenedPropertiesMapping +from datacommons_client.models.node import Name +from datacommons_client.models.node import Node +from datacommons_client.models.node import NodeGroup +from datacommons_client.models.node import Properties +from datacommons_client.models.observation import Facet +from datacommons_client.models.observation import ObservationRecord +from datacommons_client.models.observation import ObservationRecords +from datacommons_client.models.observation import OrderedFacets +from datacommons_client.models.observation import VariableByEntity + + +def unpack_arcs(arcs: Dict[ArcLabel, NodeGroup]) -> dict[Property, list[Node]]: + """Simplify the 'arcs' structure.""" + # Return dictionary of property nodes + return { + prop: getattr(arc_data, "nodes", []) for prop, arc_data in arcs.items() + } + + +def flatten_properties( + data: Dict[NodeDCID, Arcs | Properties] +) -> FlattenedPropertiesMapping | FlattenedArcsMapping: + """ + Flatten the properties of a node response. + + Processes a dictionary of node responses, extracting and + simplifying their properties and arcs into a flattened dictionary. + + Args: + data (Dict[NodeDCID, Arcs | Properties]): + The input dictionary containing node responses. Each node maps to + a dictionary with potential "arcs" and "properties" keys. + + Returns: + FlattenedPropertiesMapping | FlattenedArcsMapping: + A flattened dictionary where keys are node identifiers, and values + are the simplified properties or nodes. + """ + if not data: + return FlattenedPropertiesMapping.model_validate({}) + + first_node = next(iter(data.values())) + is_properties = isinstance(first_node, Properties) + mapping_cls = FlattenedPropertiesMapping if is_properties else FlattenedArcsMapping + + # Store simplified properties + items = {} + for node_id, node_data in data.items(): + if is_properties: + props = getattr(node_data, "properties", None) + if props: + items[node_id] = props + else: + arcs = getattr(node_data, "arcs", None) + if arcs: + items[node_id] = unpack_arcs(arcs) + + return mapping_cls.model_validate(items) + + +def extract_observations( + variable: str, entity: str, entity_data: OrderedFacets, + facet_metadata: dict[facetID, Facet]) -> list[ObservationRecord]: + """ + Extracts observations for a given variable, entity, and its data. + + Args: + variable (str): The variable name. + entity (str): The entity name. + entity_data (OrderedFacets): Data for the entity, including ordered facets. + facet_metadata (dict[facetID, Facet]): Metadata for facets. + + Returns: + list[dict]: A list of observation records. + """ + observations = [] + for facet in entity_data.orderedFacets: + for observation in facet.observations: + observations.append( + ObservationRecord.model_validate({ + "date": observation.date, + "entity": entity, + "variable": variable, + "value": observation.value, + "facetId": facet.facetId, + **facet_metadata.get(facet.facetId, Facet()).to_dict(), + })) + + return observations + + +def observations_as_records(data: VariableByEntity, + facets: dict[facetID, Facet]) -> ObservationRecords: + """ + Converts observation data into a list of records. + + Args: + data (VariableByEntity): A mapping of variables to entities and their data. + facets (dict): Facet metadata for the observations. + + Returns: + ObservationRecords: A flattened list of observation records. + """ + + records = [] + for variable, entities in data.items(): + for entity, entity_data in entities.items(): + for record in extract_observations( + variable=variable, + entity=entity, + entity_data=entity_data, + facet_metadata=facets, + ): + records.append(record) + + return ObservationRecords.model_validate(records) + + +def group_variables_by_entity( + data: dict[str, list[str]]) -> dict[str, list[str]]: + """Groups variables by the entities they are associated with. + Takes a dictionary mapping statistical variable DCIDs to a list of entity DCIDs, + and returns a new dictionary mapping each entity DCID to a list of statistical + variables available for that entity. + Args: + data: A dictionary where each key is a variable DCID and the value is a list + of entity DCIDs that have observations for that variable. + Returns: + A dictionary where each key is an entity DCID and the value is a list of + variable DCIDs available for that entity. + """ + result: dict[str, list[str]] = {} + for variable, entities in data.items(): + for entity in entities: + result.setdefault(entity, []).append(variable) + return result + + +class SerializableMixin: + """Provides serialization methods for the Response dataclasses.""" + + def to_dict(self, exclude_none: bool = True) -> Dict[str, Any]: + """Converts the instance to a dictionary. + + Args: + exclude_none: If True, only include non-empty values in the response. + + Returns: + Dict[str, Any]: The dictionary representation of the instance. + """ + + def _remove_none(data: Any) -> Any: + """Recursively removes None or empty values from a dictionary or list.""" + if isinstance(data, dict): + return {k: _remove_none(v) for k, v in data.items() if v is not None} + elif isinstance(data, list): + return [_remove_none(item) for item in data] + return data + + result = asdict(self) + return _remove_none(result) if exclude_none else result + + def to_json(self, exclude_none: bool = True) -> str: + """Converts the instance to a JSON string. + + Args: + exclude_none: If True, only include non-empty values in the response. + + Returns: + str: The JSON string representation of the instance. + """ + return json.dumps(self.to_dict(exclude_none=exclude_none), indent=2) + + +def flatten_names_dictionary(names_dict: dict[str, Name]) -> dict[str, str]: + """ + Flattens a dictionary which contains Name objects into a flattened dictionary + with DCIDs as keys and names as values. + + Args: + names_dict (dict[str, Name]): The input dictionary to flatten. + + Returns: + dict[str, str]: A flattened dictionary with DCIDs as keys and names as values. + """ + + return {dcid: name.to_dict()['value'] for dcid, name in names_dict.items()} diff --git a/datacommons_client/utils/dataframes.py b/datacommons_client/utils/dataframes.py new file mode 100644 index 00000000..3eb634f3 --- /dev/null +++ b/datacommons_client/utils/dataframes.py @@ -0,0 +1,95 @@ +from datacommons_client.endpoints.node import NodeEndpoint +from datacommons_client.utils.data_processing import flatten_names_dictionary + +try: + import pandas as pd +except ImportError: + pd = None + +from datacommons_client.utils.decorators import requires_pandas + + +@requires_pandas +def add_entity_names_to_observations_dataframe( + endpoint: NodeEndpoint, + observations_df: "pd.DataFrame", # type: ignore[reportInvalidTypeForm] + entity_columns: str | list[str], +) -> "pd.DataFrame": # type: ignore[reportInvalidTypeForm] + """ + Adds entity names to the observations DataFrame. + + Args: + endpoint (NodeEndpoint): The NodeEndpoint instance for fetching entity names. + observations_df (dict): The DataFrame containing observations. + entity_columns (str | list[str]): The column(s) containing entity DCIDs. + """ + + # Guard against empty DataFrame + if observations_df.empty: + return observations_df + + if not isinstance(entity_columns, list): + entity_columns = [entity_columns] + + for entity_column in entity_columns: + if entity_column not in observations_df.columns: + raise ValueError( + "The specified entity column does not exist in the DataFrame.") + + # Get unique entity DCIDs from the DataFrame + unique_values = observations_df[entity_column].dropna().unique().tolist() + + # Guard against empty unique values + if not unique_values: + continue + + # Fetch entity names from the endpoint + response = endpoint.fetch_entity_names(entity_dcids=unique_values) + + # Flatten the response to get a dictionary of names + names = flatten_names_dictionary(response) + + # Insert the names into a column next to the entity column + name_column = f"{entity_column}_name" + if name_column not in observations_df.columns: + observations_df.insert( + loc=observations_df.columns.get_loc(entity_column) + 1, + column=name_column, + value=observations_df[entity_column].map(names), + ) + + return observations_df + + +@requires_pandas +def add_property_constraints_to_observations_dataframe( + endpoint: NodeEndpoint, + observations_df: "pd.DataFrame", # type: ignore[reportInvalidTypeForm] +) -> "pd.DataFrame": # type: ignore[reportInvalidTypeForm] + """ + Adds property constraint dcids and names to the observations DataFrame. + + Args: + endpoint (NodeEndpoint): The NodeEndpoint instance for fetching entity names. + observations_df (dict): The DataFrame containing observations. + """ + + # Guard against empty DataFrame + if observations_df.empty: + return observations_df + + # Get constraints + constraints_data = endpoint.fetch_statvar_constraints( + variable_dcids=observations_df.variable.unique().tolist()) + + for statvar, constraints in constraints_data.items(): + for constraint in constraints: + # Fill the columns with the corresponding values + observations_df.loc[observations_df.variable == statvar, + constraint.constraintId] = constraint.valueId + + observations_df.loc[observations_df.variable == statvar, + constraint.constraintId + + "_name"] = constraint.valueName + + return observations_df diff --git a/datacommons_client/utils/decorators.py b/datacommons_client/utils/decorators.py new file mode 100644 index 00000000..d27da444 --- /dev/null +++ b/datacommons_client/utils/decorators.py @@ -0,0 +1,18 @@ +from functools import wraps + +try: + import pandas as pd +except ImportError: + pd = None + + +def requires_pandas(func): + """Decorator to check if Pandas is available before executing a method.""" + + @wraps(func) + def wrapper(*args, **kwargs): + if pd is None: + raise ImportError("Pandas is required for this method") + return func(*args, **kwargs) + + return wrapper diff --git a/datacommons_client/utils/error_handling.py b/datacommons_client/utils/error_handling.py new file mode 100644 index 00000000..4a7f89ce --- /dev/null +++ b/datacommons_client/utils/error_handling.py @@ -0,0 +1,89 @@ +from typing import Optional + +from requests import Response + + +class DataCommonsError(Exception): + """Base exception for all Data Commons-related errors.""" + + default_message = "An error occurred getting data from Data Commons API." + + def __init__(self, message: Optional[str] = None): + """Initializes a DataCommonsError with a default or custom message.""" + super().__init__(message or self.default_message) + + +class APIError(DataCommonsError): + """Represents an error interacting with Data Commons API.""" + + default_message = "An API error occurred." + + def __init__( + self, + response: Optional[Response] = None, + message: Optional[str] = None, + ): + """Initializes an APIError. + + Args: + response (Optional[Response]): The response, if available. + message (Optional[str]): A descriptive error message. + """ + super().__init__(message or self.default_message) + self.response = response + self.request = getattr(response, "request", None) + self.status_code = getattr(response, "status_code", None) + + def __str__(self) -> str: + """Returns a detailed string representation of the error. + + Returns: + str: A string describing the error, including the request URL if available. + """ + + details = f"\n{self.args[0]}" + if self.status_code: + details += f"\nStatus Code: {self.status_code}" + if getattr(self.request, "url", None): + details += f"\nRequest URL: {self.request.url}" + if getattr(self.response, "text", None): + details += f"\nResponse: {self.response.text}" + + return details + + +class DCConnectionError(APIError): + """Raised for network-related errors in the Data Commons API.""" + + default_message = ( + "A network error occurred while connecting to the Data Commons API.") + + +class DCStatusError(APIError): + """Raised for non-2xx HTTP status code errors in the Data Commons API.""" + + default_message = "The Data Commons API returned a non-2xx status code." + + +class DCAuthenticationError(APIError): + """Raised for 401 Unauthorized errors in the Data Commons API.""" + + default_message = "Authentication failed. Please check your API key." + + +class InvalidDCInstanceError(DataCommonsError): + """Raised when an invalid Data Commons instance is provided.""" + + default_message = "The specified Data Commons instance is invalid." + + +class InvalidObservationSelectError(DataCommonsError): + """Raised when an invalid ObservationSelect field is provided.""" + + default_message = "The ObservationSelect field is invalid." + + +class NoDataForPropertyError(DataCommonsError): + """Raised when there is no data that meets the specified property filters.""" + + default_message = "No available data for the specified property filters." diff --git a/datacommons_client/utils/graph.py b/datacommons_client/utils/graph.py new file mode 100644 index 00000000..db636b5d --- /dev/null +++ b/datacommons_client/utils/graph.py @@ -0,0 +1,266 @@ +from collections import deque +from concurrent.futures import FIRST_COMPLETED +from concurrent.futures import Future +from concurrent.futures import ThreadPoolExecutor +from concurrent.futures import wait +import contextvars +from functools import lru_cache +from typing import Callable, Literal, Optional, TypeAlias + +from datacommons_client.models.node import Node + +GRAPH_MAX_WORKERS = 10 + +RelationMap: TypeAlias = dict[str, list[Node]] +AncestorsMap = RelationMap +DescendantsMap = RelationMap + +# -- -- Fetch tools -- -- + + +def _fetch_relationship_uncached( + endpoint, + dcid: str, + contained_type: str | None, + relationship: Literal["parents", "children"], +) -> list[Node]: + """Fetches the immediate parents/children of a given DCID from the endpoint, without caching. + + This function performs a direct, uncached call to the API. It exists + primarily to serve as the internal, cache-free fetch use by functions with lru. + + By isolating the pure fetch logic here, we ensure that caching is handled separately + and cleanly via `@lru_cache`, which requires its wrapped + function to be deterministic and side-effect free. + + Args: + endpoint: A client object with a `fetch_entity_parents` and `fetch_entity_children` method. + dcid (str): The entity ID for which to fetch parents. + contained_type (str): The type of the entity to be fetched. + relationship (str): The type of relationship to fetch, either "parents" or "children". + Returns: + A list of Node objects. + """ + + if relationship == "parents": + result = endpoint.fetch_place_parents(dcid, as_dict=False).get(dcid, []) + + else: + result = endpoint.fetch_place_children(dcid, + children_type=contained_type, + as_dict=False).get(dcid, []) + + return result if isinstance(result, list) else [result] + + +@lru_cache(maxsize=512) +def fetch_relationship_lru( + endpoint, + dcid: str, + contained_type: str | None, + relationship: Literal["parents", "children"], +) -> list[Node]: + """Fetches parents of a DCID using an LRU cache for improved performance. + Args: + endpoint: A Node client object. + dcid (str): The entity ID to fetch parents/children for. + contained_type (str): The type of the entity to be fetched. + relationship (str): The type of relationship to fetch, either "parents" or "children". + Returns: + A list of `Node` objects corresponding to the entity's parents or children. + """ + return _fetch_relationship_uncached( + endpoint=endpoint, + dcid=dcid, + contained_type=contained_type, + relationship=relationship, + ) + + +# -- -- Ancestry tools -- -- + + +def build_graph_map( + root: str, + fetch_fn: Callable[..., tuple[Node, ...]], + *, + max_workers: Optional[int] = GRAPH_MAX_WORKERS, +) -> tuple[str, RelationMap]: + """Constructs a complete ancestry/descendancy map for the root node using parallel + Breadth-First Search (BFS). + + Traverses the graph from the root node, discovering all parent/children + relationships (depending on the fetch_fn) by fetching in parallel. + + Args: + root (str): The DCID of the root entity to start from. + fetch_fn (Callable): A function that takes a DCID and returns Node tuples. + max_workers (Optional[int]): Max number of threads to use for parallel fetching. + Optional, defaults to `PARENTS_MAX_WORKERS`. + + Returns: + A tuple containing: + - The original root DCID. + - A dictionary mapping each DCID to a Node list. + """ + graph_map: RelationMap = {} + visited: set[str] = set() + in_progress: dict[str, Future] = {} + + original_root = root + + ctx = contextvars.copy_context() + with ThreadPoolExecutor(max_workers=max_workers) as executor: + queue = deque([root]) + + # Standard BFS loop, but fetches are executed in parallel threads + while queue or in_progress: + # Submit fetch tasks for all nodes in the queue + while queue: + dcid = queue.popleft() + # Check if the node has already been visited or is in progress + if dcid not in visited and dcid not in in_progress: + # Submit the fetch task + in_progress[dcid] = executor.submit(ctx.run, fetch_fn, dcid=dcid) + + # Check if any futures are still in progress + if not in_progress: + continue + + # Wait for at least one future to complete + done_futures, _ = wait(in_progress.values(), return_when=FIRST_COMPLETED) + + # Find which DCIDs have completed + completed_dcids = [ + dcid for dcid, future in in_progress.items() if future in done_futures + ] + + # Process completed fetches and enqueue any unseen parents + for dcid in completed_dcids: + future = in_progress.pop(dcid) + nodes = list(future.result()) + graph_map[dcid] = nodes + visited.add(dcid) + + for node in nodes: + if (node and node.dcid not in visited and + node.dcid not in in_progress): + queue.append(node.dcid) + + return original_root, graph_map + + +def _postorder_nodes(root: str, graph: RelationMap) -> list[str]: + """Generates a postorder list of all nodes reachable from the root. + + Postorder ensures children are processed before their parents. That way the tree + is built bottom-up. + + Args: + root (str): The root DCID to start traversal from. + graph (RelationMap): The ancestry/descendancy map. + Returns: + A list of DCIDs in postorder (i.e children before parents). + """ + # Initialize stack and postorder list + stack, postorder, seen = [root], [], set() + + # Traverse the graph using a stack + while stack: + node = stack.pop() + # Skip if already seen + if node in seen: + continue + seen.add(node) + postorder.append(node) + # Push all unvisited Nodes onto the stack + for relation in graph.get(node, []): + if not relation: + continue + relation_dcid = relation.dcid + if relation_dcid not in seen: + stack.append(relation_dcid) + + # Reverse to get postorder relative to the adjacency direction + return list(reversed(postorder)) + + +def _assemble_tree(postorder: list[str], ancestry: RelationMap, + relationship_key: str) -> dict: + """Builds a nested dictionary tree from a Node list and RelationMa[. + Constructs a nested representation of the graph, ensuring that parents/children + are embedded after their root Node (which is enabled by postorder). + Args: + postorder (list[str]): List of node DCIDs in postorder. + ancestry (RelationMap): Map from DCID to list of Node objects. + relationship_key (str): The key to use for the relationship in the tree. + Returns: + A nested dictionary representing the ancestry tree rooted at the last postorder node. + """ + tree_cache: dict[str, dict] = {} + + for node in postorder: + # Initialize the node dictionary. + node_dict = {"dcid": node, "name": None, "type": None, relationship_key: []} + + # For each relationship of the current node, fetch its details and add it to the node_dict. + for relationship in ancestry.get(node, []): + if not relationship: + continue + relationship_dcid = relationship.dcid + name = relationship.name + entity_type = relationship.types + + # If the node is not already in the cache, add it. + if relationship_dcid not in tree_cache: + tree_cache[relationship_dcid] = { + "dcid": relationship_dcid, + "name": name, + "type": entity_type, + relationship_key: [], + } + + relationship_node = tree_cache[relationship_dcid] + + # Ensure name/type are up to date (in case of duplicates) + relationship_node["name"] = name + relationship_node["type"] = entity_type + node_dict[relationship_key].append(relationship_node) + + tree_cache[node] = node_dict + + # The root node is the last one in postorder, that's what gets returned + return tree_cache[postorder[-1]] + + +def build_relationship_tree(root: str, graph: RelationMap, + relationship_key: str) -> dict: + """Builds a nested ancestry tree from an ancestry map. + Args: + root (str): The DCID of the root node. + graph (RelationMap): A dictionary mapping DCIDs to lists of Node objects. + relationship_key (str): The key to use for the relationship in the tree. + Returns: + A nested dictionary tree rooted at the specified DCID. + """ + postorder = _postorder_nodes(root, graph) + return _assemble_tree(postorder, graph, relationship_key=relationship_key) + + +def flatten_relationship(graph: RelationMap) -> list[dict[str, str]]: + """Flattens the RelationMap into a deduplicated list of parent/child records. + Args: + graph (GraphMap): mapping of DCIDs to lists of Node objects. + Returns: + A list of dictionaries with keys 'dcid', 'name', and 'type', containing + each unique parent/child in the graph. + """ + + flat: list = [] + seen: set[str] = set() + for relationships in graph.values(): + for relationship in relationships: + if relationship and relationship.dcid not in seen: + seen.add(relationship.dcid) + flat.append(relationship.to_dict()) + return flat diff --git a/datacommons_client/utils/names.py b/datacommons_client/utils/names.py new file mode 100644 index 00000000..490ae480 --- /dev/null +++ b/datacommons_client/utils/names.py @@ -0,0 +1,62 @@ +from typing import Optional + +from datacommons_client.models.node import Node + +DEFAULT_NAME_PROPERTY: str = "name" +NAME_WITH_LANGUAGE_PROPERTY: str = "nameWithLanguage" +DEFAULT_NAME_LANGUAGE: str = "en" + + +def extract_name_from_english_name_property(properties: list | Node) -> str: + """ + Extracts the name from a list of properties with English names. + Args: + properties (list): A list of properties with English names. + Returns: + str: The extracted name. + """ + if not properties: + return '' + + if isinstance(properties, Node): + properties = [properties] + + return properties[0].value + + +def extract_name_from_property_with_language( + properties: list, + language: str, + fallback_language: Optional[str] = None) -> tuple[str | None, str | None]: + """ + Extracts the name from a list of properties with language tags. + Args: + properties (list): A list of properties with language tags. + language (str): The desired language code. + fallback_language: If provided, this language will be used as a fallback if the requested + language is not available. If not provided, no fallback will be used. + + Returns: + tuple[str,str]: A tuple containing the extracted name and its language. + """ + # If a non-English language is requested, unpack the response to get it. + fallback_name = None + + # Iterate through the properties to find the name in the specified language + for candidate in properties: + # If no language is specified, skip the candidate + if "@" not in candidate.value: + continue + + # Split the candidate value into name and language + name, lang = candidate.value.rsplit("@", 1) + + # If the language matches, add the name to the dictionary. + if lang == language: + return name, lang + # If language is 'en', store the name as a fallback + if fallback_language and (lang == fallback_language): + fallback_name = name + + # If no name was found in the specified language, use the fallback name (if available) + return fallback_name, fallback_language if fallback_language else None diff --git a/datacommons_client/utils/request_handling.py b/datacommons_client/utils/request_handling.py new file mode 100644 index 00000000..79f2cb80 --- /dev/null +++ b/datacommons_client/utils/request_handling.py @@ -0,0 +1,281 @@ +from typing import Any, Dict, Optional + +import requests +from requests import exceptions +from requests import Response + +from datacommons_client.utils.error_handling import APIError +from datacommons_client.utils.error_handling import DCAuthenticationError +from datacommons_client.utils.error_handling import DCConnectionError +from datacommons_client.utils.error_handling import DCStatusError +from datacommons_client.utils.error_handling import InvalidDCInstanceError + +BASE_DC_V2: str = "https://api.datacommons.org/v2" +CUSTOM_DC_V2: str = "/core/api/v2" + + +def check_instance_is_valid(instance_url: str, + api_key: str | None = None) -> str: + """Check that the given instance URL points to a valid Data Commons instance. + + This function attempts a GET request against a known node in Data Commons to + validate the given instance URL. If the node is found and the response has the + expected data, the URL is considered valid. + + If an api_key is provided, it will be included in the request headers. + + Args: + instance_url: The Data Commons instance URL to validate. + api_key: Optional API key for authentication. + + Returns: + The validated instance URL. + + Raises: + InvalidDCInstanceError: If the instance URL does not seem to be a valid + Data Commons instance. + """ + # Test URL for a known node in Data Commons + test_url = f"{instance_url}/node?nodes=country%2FGTM&property=->name" + + headers = {} + if api_key: + headers["X-API-Key"] = api_key + + try: + response = requests.get(test_url, headers=headers) + response.raise_for_status() + except requests.exceptions.RequestException as exc: + raise InvalidDCInstanceError(exc.response) from exc + + data = response.json() + if "data" not in data or "country/GTM" not in data["data"]: + raise InvalidDCInstanceError( + f"{instance_url} is not a valid Data Commons instance.") + + return instance_url + + +def resolve_instance_url(dc_instance: str) -> str: + """Resolve the base API URL for a given Data Commons instance. + + If the instance is `datacommons.org`, the default URL is returned. Otherwise, + the custom URL is validated via `_check_instance_is_valid`. + + Args: + dc_instance: The identifier or domain of the Data Commons instance. + + Returns: + The resolved base API URL. + """ + # if https or http included in the string, remove it + dc_instance = dc_instance.replace("https://", "").replace("http://", "") + + # If the instance is the default, return the base URL + if dc_instance == "datacommons.org": + return BASE_DC_V2 + + # Otherwise, validate the custom instance URL + url = f"https://{dc_instance}{CUSTOM_DC_V2}" + return check_instance_is_valid(url) + + +def _send_post_request(url: str, payload: dict[str, Any], + headers: dict[str, str]) -> Response: + """Send a POST request and handle common HTTP errors with custom exceptions. + + Args: + url: The target endpoint URL. + payload: The JSON payload to send with the request. + headers: The request headers, including authentication. + + Returns: + The successful Response object. + + Raises: + DCConnectionError: If a network-related error occurs. + DCAuthenticationError: If a 401 Unauthorized error is received. + DCStatusError: for 500-level HTTP errors. + APIError: For other HTTP errors. + """ + try: + response = requests.post(url, json=payload, headers=headers) + response.raise_for_status() + return response + + # if ConnectionError + except exceptions.ConnectionError as exc: + raise DCConnectionError(exc.response) from exc + + # if HTTPError + except exceptions.HTTPError as exc: + status_code = (exc.response.status_code + if exc.response is not None else None) + + # if 401 Unauthorized + if status_code == 401: + raise DCAuthenticationError(exc.response) from exc + + # if 500-level HTTP errors + if status_code >= 500: + raise DCStatusError(exc.response) from exc + + # for other HTTP errors + raise APIError(exc.response) from exc + + +def _recursively_merge_dicts( + base: dict[str, Any], + new: dict[str, Any], + keys_to_skip: Optional[set[str]] = None, +) -> dict[str, Any]: + """Recursively merge two dictionaries, skipping specified keys. + + Uses `_merge_values` to handle nested structures and different types. + + Args: + base: The base dictionary. + new: The dictionary to merge into `base`. + keys_to_skip: A set of keys to skip during merging. + + Returns: + A new dictionary that is the result of merging `new` into `base`. + """ + if keys_to_skip is None: + keys_to_skip = {"nextToken"} + + result = dict(base) + for k, v in new.items(): + # Skip keys that should be excluded from merging + if k in keys_to_skip: + continue + # If the key is already present, merge the values + if k in result: + result[k] = _merge_values(result[k], v) + # Otherwise, add the new key-value pair + else: + result[k] = v + return result + + +def _merge_values(base: Any, new: Any) -> Any: + """Merge two values based on their structure using pattern matching. + + - If both are dicts, recursively merge them. + - If both are lists, concatenate them. + - Otherwise, if they differ, combine into a list. If they are equal, return one of them. + + Args: + base: Existing value in the data structure. + new: New value to merge in. + + Returns: + The merged value. + """ + match base, new: + case dict(), dict(): + return _recursively_merge_dicts(base, new) + case list(), list(): + # Merge two lists by concatenation + return base + new + case _: + # If they are the same, return one. Otherwise, combine into a list. + return base if base == new else [base, new] + + +def _fetch_with_pagination( + url: str, + payload: dict[str, Any], + headers: dict[str, str], + all_pages: bool = True, + next_token: Optional[str] = None, +) -> dict[str, Any]: + """Fetch and (if necessary) merge paginated results from an API. + + Continues fetching pages until `nextToken` is not found or `max_pages` is reached. + + Args: + url: The API endpoint URL. + payload: The request payload (JSON-serializable). + headers: The request headers. + all_pages: Whether to fetch all available pages. Defaults to True. + next_token: Optionally, the token to fetch the next page of results. Defaults to None. + + Returns: + A dictionary containing all merged results from all fetched pages. + """ + combined_results: dict[str, Any] = {} + + # If a next token is provided, use it to fetch the next page + if next_token: + payload["nextToken"] = next_token + + while True: + # Send a POST request and parse the JSON response + response = _send_post_request(url, payload, headers) + + try: + page_data = response.json() + except ValueError: + raise APIError(response) + + # Merge current page data into combined results + combined_results = _recursively_merge_dicts(combined_results, page_data) + + # Update the payload with the next token + next_token = page_data.get("nextToken") + + # Update the payload with the next token + payload["nextToken"] = next_token + + # Stop if the user only wants one page or if there is no next token + if not all_pages or not next_token: + break + + # Add the final next token to the response + combined_results["nextToken"] = next_token + + return combined_results + + +def post_request( + url: str, + payload: dict[str, Any], + headers: dict[str, str], + *, + all_pages: bool = True, + next_token: Optional[str] = None, +) -> Dict[str, Any]: + """Send a POST request with optional pagination support and return a DCResponse. + + Args: + url: The target endpoint URL. + payload: The payload to send with the request. + headers: The request headers, including authentication. + all_pages: Fetch all available pages automatically. Defaults to True. Set to + False to only fetch the first page. In that case, a `nextToken` key in the + response will indicate if more pages are available. That token can be used + to fetch the next page. + next_token: Optionally, the token to fetch the next page of results. Defaults to None. + If combined with `all_pages=False`, this token will be used to fetch only the next page. + If combined with `all_pages=True`, all remaining pages will be fetched starting from this token. + + + Returns: + A dictionary containing the aggregated API response data. + + Raises: + ValueError: If `json` is not a dictionary. + """ + if not isinstance(payload, dict): + raise ValueError("Payload must be a dictionary.") + + # Fetch and merge paginated results + combined_results = _fetch_with_pagination(url=url, + payload=payload, + headers=headers, + all_pages=all_pages, + next_token=next_token) + + # Return the combined results as a dictionary + return combined_results diff --git a/datacommons_pandas/CHANGELOG.md b/datacommons_pandas/CHANGELOG.md index 42bedc43..9b776927 100644 --- a/datacommons_pandas/CHANGELOG.md +++ b/datacommons_pandas/CHANGELOG.md @@ -1,5 +1,15 @@ # Changelog +## 0.0.4 + +**Date** - 01/12/2026 + +**Release Tag** - [pd.0.0.4](https://github.com/datacommonsorg/api-python/releases/tag/pd0.0.4) + +**Release Status** - Current head of branch [`master`](https://github.com/datacommonsorg/api-python/tree/master) + +Added deprecation notice to legacy `datacommons_pandas` package. + ## 0.0.3 **Date** - 11/10/2020 diff --git a/datacommons_pandas/README.md b/datacommons_pandas/README.md index 7db05ea9..218c00d4 100644 --- a/datacommons_pandas/README.md +++ b/datacommons_pandas/README.md @@ -1,46 +1 @@ -# Data Commons Pandas API - -This is a Python library for creating pandas objects with data in the -Data Commons Graph. - -To get started, install this package from pip. - - pip install datacommons_pandas - -Once the package is installed, import `datacommons_pandas`. - - import datacommons_pandas as dcpd - -For more detail on getting started with the API, please visit our -[API Overview](http://docs.datacommons.org/api/). - -When you are ready to use the API, you can refer to `datacommons_pandas/examples` for -examples on how to use this package to perform various tasks. More tutorials and -documentation can be found on our [tutorials page](https://datacommons.org/colab)! - -## About Data Commons - -[Data Commons](https://datacommons.org/) is an open knowledge repository that -provides a unified view across multiple public data sets and statistics. You can -view what [datasets](https://datacommons.org/datasets) are currently ingested -and browse the graph using our [browser](https://browser.datacommons.org/). - -## License - -Apache 2.0 - -## Development - -Please follow the [Development instructions](../README.md#development). - -## Release - -Please follow the [Release instructions](../README.md#release). - -## Support - -For general questions or issues about the API, please open an issue on our -[issues](https://github.com/datacommonsorg/api-python/issues) page. For all other -questions, please send an email to `support@datacommons.org`. - -**Note** - This is not an officially supported Google product. +**DEPRECATED: This library has been deprecated. Please migrate to the [datacommons_client](https://pypi.org/project/datacommons-client/) library. For help on translating your requests, see the [Migration guide](https://docs.datacommons.org/api/python/v2/migration.html).** diff --git a/datacommons_pandas/__init__.py b/datacommons_pandas/__init__.py deleted file mode 100644 index 353c395d..00000000 --- a/datacommons_pandas/__init__.py +++ /dev/null @@ -1,33 +0,0 @@ -# Copyright 2020 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -from datacommons_pandas.df_builder import build_time_series, build_time_series_dataframe, build_multivariate_dataframe - -################################ SYMLINK FILES ################################ -# We include symlinks to all user-facing functions from the datacommons pkg. # -# This is so that users do not need to import both libraries for pd support. # -# Please keep the below in sync with the __init__.py in the datacommons/ dir # -# TODO: enforce this. https://github.com/datacommonsorg/api-python/issues/149 # -##############################################@################################ -# Data Commons SPARQL query support -from datacommons_pandas.query import query - -# Data Commons Python API -from datacommons_pandas.core import get_property_labels, get_property_values, get_triples -from datacommons_pandas.places import get_places_in, get_related_places, get_stats -from datacommons_pandas.populations import get_populations, get_observations, get_pop_obs, get_place_obs -from datacommons_pandas.stat_vars import get_stat_value, get_stat_series, get_stat_all - -# Other utilities -from datacommons_pandas.utils import set_api_key diff --git a/datacommons_pandas/core.py b/datacommons_pandas/core.py deleted file mode 120000 index 15f455cf..00000000 --- a/datacommons_pandas/core.py +++ /dev/null @@ -1 +0,0 @@ -../datacommons/core.py \ No newline at end of file diff --git a/datacommons_pandas/df_builder.py b/datacommons_pandas/df_builder.py deleted file mode 100644 index 44dcb69f..00000000 --- a/datacommons_pandas/df_builder.py +++ /dev/null @@ -1,317 +0,0 @@ -# Copyright 2020 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -"""Data Commons Pandas API DataFrame Builder Module. - -Provides functions for building pandas DataFrames using the Data Commons Graph. -""" - -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - -import collections -import pandas as pd -import six - -import datacommons_pandas.stat_vars as dc - - -def build_time_series(place, - stat_var, - measurement_method=None, - observation_period=None, - unit=None, - scaling_factor=None): - """Constructs a pandas Series with `dates` as the index and corresponding `stat_var` statistics as values. - - Args: - place (`str`): The dcid of Place to query for. - stat_var (`str`): The dcid of the StatisticalVariable. - measurement_method (`str`): Optional, the dcid of the preferred - `measurementMethod` value. - observation_period (`str`): Optional, the preferred - `observationPeriod` value. - unit (`str`): Optional, the dcid of the preferred `unit` value. - scaling_factor (`int`): Optional, the preferred `scalingFactor` value. - Returns: - A pandas Series with Place IDs as the index and observed statistics as - values, representing a time series satisfying all optional args. - """ - return pd.Series( - dc.get_stat_series(place, stat_var, measurement_method, - observation_period, unit, scaling_factor)) - - -def _group_stat_all_by_obs_options(places, stat_vars, keep_series=True): - """Groups the result of `get_stat_all` by StatVarObservation options for time series or multivariates. - - Note that this function does not preserve `(place, stat_var)` pairs that - yield no data `from get_stat_all`. In the extreme case that there is no - data for any pairs, raise a ValueError instead of returning an empty dict. - - Args: - places (`str` or `iterable` of `str`): The dcids of Places to query for. - stat_vars (`Iterable` of `str`): The dcids of the StatisticalVariables. - keep_series (`boolean`): if True, output time series grouped by - StatVarObservation options; if False, output latest statistics grouped - by StatVarObservation options. - Returns: - A nested dict mapping each StatisticalVariable in `stat_vars` to its - StatVarObservation options. In turn, each StatVarObservation option - maps to a list of rows, one per place, with the place id and stat data. - - Raises: - ValueError: If the payload returned by the Data Commons REST API is - malformed, or if there is no data for any (Place, StatisticalVariables) - pair. - """ - if keep_series: - if len(stat_vars) != 1: - raise ValueError( - 'When `keep_series` is set, only one StatisticalVariable for `stat_vars` is allowed.' - ) - res = collections.defaultdict(list) - else: - res = collections.defaultdict(lambda: collections.defaultdict(list)) - - stat_all = dc.get_stat_all(places, stat_vars) - for place, place_data in stat_all.items(): - if not place_data: - continue - for stat_var, stat_var_data in place_data.items(): - if not stat_var_data: - continue - for source_series in stat_var_data['sourceSeries']: - series = source_series['val'] - # Convert dict of SVO options into nested tuple (hashable key). - obs_options = (('measurementMethod', - source_series.get('measurementMethod')), - ('observationPeriod', - source_series.get('observationPeriod')), - ('unit', source_series.get('unit')), - ('scalingFactor', - source_series.get('scalingFactor'))) - if keep_series: - res[obs_options].append(dict({'place': place}, **series)) - else: - date = max(series) - res[stat_var][obs_options].append({ - 'place': place, - 'date': date, - 'val': series[date] - }) - if not res: - raise ValueError( - 'No data for any of specified Places and StatisticalVariables.') - if keep_series: - return dict(res) - else: - return {k: dict(v) for k, v in res.items()} - - -def _time_series_pd_input(places, stat_var): - """Returns a `list` of `dict` per element of `places` based on the `stat_var`. - - Data Commons will pick a set of StatVarObservation options that covers the - maximum number of queried places. Among ties, Data Commons selects an option - set with the latest Observation. - - Args: - places (`str` or `iterable` of `str`): The dcids of Places to query for. - stat_var (`str`): The dcid of the StatisticalVariable. - Returns: - A `list` of `dict`, one per element of `places`. Each `dict` consists of - the time series and place identifier. - - Examples: - >>> _time_series_pd_input(["geoId/29", "geoId/33"], "Count_Person") - [ - {'2020-03-07': 20, '2020-03-08': 40, 'place': 'geoId/29'}, - {'2020-08-21': 428, '2020-08-22': 429, 'place': 'geoId/33'} - ] - """ - - rows_dict = _group_stat_all_by_obs_options(places, [stat_var], - keep_series=True) - most_geos = [] - max_geo_count_so_far = 0 - latest_date = [] - latest_date_so_far = '' - for options, rows in rows_dict.items(): - current_geos = len(rows) - if current_geos > max_geo_count_so_far: - max_geo_count_so_far = current_geos - most_geos = [options] - # Reset tiebreaker stats. Recompute after this if-else block. - latest_date = [] - latest_date_so_far = '' - elif current_geos == max_geo_count_so_far: - most_geos.append(options) - else: - # Do not compute tiebreaker stats if no change to most_geos. - # Skip to top of the for loop. - continue - - for row in rows: - dates = set(row.keys()) - dates.remove('place') - row_max_date = max(dates) - if row_max_date > latest_date_so_far: - latest_date_so_far = row_max_date - latest_date = [options] - elif row_max_date == latest_date_so_far: - latest_date.append(options) - for options in most_geos: - if options in latest_date: - return rows_dict[options] - - -def build_time_series_dataframe(places, stat_var, desc_col=False): - """Constructs a pandas DataFrame with `places` as the index and dates of the time series as the columns. - - To ensure statistics are comparable across all Places, when multiple - StatVarObservations options are available for Place and StatVar combos, - Data Commons selects the StatVarObservation options that covers the most - Places, and breaks ties using the StatVarObservation options that yield - the latest Observation for any Place. - - Args: - places (`str` or `iterable` of `str`): The dcids of Places to query for. - stat_var (`str`): The dcid of the StatisticalVariable. - desc_col: Whether to order columns in descending order. - Returns: - A pandas DataFrame with Place IDs as the index, and sorted dates as columns. - """ - try: - if isinstance(places, six.string_types): - places = [places] - else: - places = list(places) - assert all(isinstance(place, six.string_types) for place in places) - except: - raise ValueError( - 'Parameter `places` must be a string object or list-like object of string.' - ) - if not isinstance(stat_var, six.string_types): - raise ValueError('Parameter `stat_var` must be a string.') - - df = pd.DataFrame.from_records(_time_series_pd_input(places, stat_var)) - df.set_index('place', inplace=True) - df.sort_index(inplace=True) - return df[sorted(df.columns, reverse=desc_col)] - - -def _multivariate_pd_input(places, stat_vars): - """Returns a `list` of `dict` per element of `places` based on the `stat_var`. - - Data Commons will pick a set of StatVarObservation options that covers the - maximum number of queried places. Among ties, Data Commons selects an option - set with the latest Observation. - - Args: - places (`str` or `iterable` of `str`): The dcids of Places to query for. - stat_vars (`Iterable` of `str`): The dcids of the StatisticalVariables. - Returns: - A `list` of `dict`, one per element of `places`. Each `dict` consists of - the time series and place identifier. - - Examples: - >>> _multivariate_pd_input(["geoId/29", "geoId/33"], - ["Count_Person", "Median_Income_Person"]) - [ - {'Count_Person': 20, 'Median_Income_Person': 40, 'place': 'geoId/29'}, - {'Count_Person': 428, 'Median_Income_Person': 429, 'place': 'geoId/33'} - ] - """ - - rows_dict = _group_stat_all_by_obs_options(places, - stat_vars, - keep_series=False) - place2cov = collections.defaultdict(dict) # {geo: {var1: 3, var2: 33}} - - for stat_var, candidates_dict in rows_dict.items(): - selected_rows = None - most_geos = [] - max_geo_count_so_far = 0 - latest_date = [] - latest_date_so_far = '' - for options, rows in candidates_dict.items(): - current_geos = len(rows) - if current_geos > max_geo_count_so_far: - max_geo_count_so_far = current_geos - most_geos = [options] - # Reset tiebreaker stats. Recompute after this if-else block. - latest_date = [] - latest_date_so_far = '' - elif current_geos == max_geo_count_so_far: - most_geos.append(options) - else: - # Do not compute tiebreaker stats if not in most_geos. - continue - - for row in rows: - row_date = row['date'] - if row_date > latest_date_so_far: - latest_date_so_far = row_date - latest_date = [options] - elif row_date == latest_date_so_far: - latest_date.append(options) - for options in most_geos: - if options in latest_date: - selected_rows = candidates_dict[options] - - for row in selected_rows: - place2cov[row['place']][stat_var] = row['val'] - return [ - dict({'place': place}, **multivariates) - for place, multivariates in place2cov.items() - ] - - -def build_multivariate_dataframe(places, stat_vars): - """Constructs a pandas DataFrame with `places` as the index and `stat_vars` as the columns. - - To ensure statistics are comparable across all Places, when multiple - StatVarObservations options are available for Place and StatVar combos, - Data Commons selects the StatVarObservation options that covers the most - Places, and breaks ties using the StatVarObservation options that yield - the latest Observation for any Place. - - Args: - places (`str` or `iterable` of `str`): The dcids of Places to query for. - stat_vars (`Iterable` of `str`): The dcids of the StatisticalVariables. - Returns: - A pandas DataFrame with Place IDs as the index and `stat_vars` as columns. - """ - try: - if isinstance(places, six.string_types): - places = [places] - else: - places = list(places) - assert all(isinstance(place, six.string_types) for place in places) - if isinstance(stat_vars, six.string_types): - stat_vars = [stat_vars] - else: - stat_vars = list(stat_vars) - assert all( - isinstance(stat_var, six.string_types) - for stat_var in stat_vars) - except: - raise ValueError( - 'Parameter `places` and `stat_vars` must be string object or list-like object.' - ) - df = pd.DataFrame.from_records(_multivariate_pd_input(places, stat_vars)) - df.set_index('place', inplace=True) - df.sort_index(inplace=True) - return df diff --git a/datacommons_pandas/examples/__init__.py b/datacommons_pandas/examples/__init__.py deleted file mode 100644 index 2c79033c..00000000 --- a/datacommons_pandas/examples/__init__.py +++ /dev/null @@ -1,13 +0,0 @@ -# Copyright 2020 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. diff --git a/datacommons_pandas/examples/df_builder.py b/datacommons_pandas/examples/df_builder.py deleted file mode 100644 index 6dff26bf..00000000 --- a/datacommons_pandas/examples/df_builder.py +++ /dev/null @@ -1,138 +0,0 @@ -# Copyright 2020 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -"""Basic examples for building pandas objects using the Data Commons Pandas API.""" - -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - -import datacommons_pandas as dcpd - - -def build_time_series_example(): - - print(""" -# Build a pd.Series of time series for one variable and one place. -$ dcpd.build_time_series('country/CAN', 'Count_WildlandFireEvent') -{}""".format(dcpd.build_time_series('country/CAN', 'Count_WildlandFireEvent'))) - - print(""" -# Build a pd.Series of time series for one variable and one place and optional args. -$ dcpd.build_time_series('country/USA', 'Count_Person', 'CensusPEPSurvey') -{}""".format( - dcpd.build_time_series('country/USA', 'Count_Person', - 'CensusPEPSurvey'))) - - -def build_time_series_dataframe_example(): - - def demonstrate_build_time_series_dataframe(intro_str, - places, - stat_var, - desc_col=False): - arg_str = "{}, '{}'".format(places, stat_var) - if desc_col: - arg_str += ", desc_col=True" - print(""" - # {} - $ dcpd.build_time_series_dataframe({}) - {}""".format(intro_str, arg_str, - dcpd.build_time_series_dataframe(places, stat_var, desc_col))) - - build_time_series_dataframe_params = [{ - 'intro_str': - 'Build a DataFrame of time series for one variable in multiple places.', - 'places': ['geoId/33', 'geoId/29', 'country/USA'], - 'stat_var': - 'Median_Income_Person' - }, { - 'intro_str': - 'Build a DataFrame of time series with columns sorted in descending order.', - 'places': ['country/USA'], - 'stat_var': - 'Median_Income_Person', - 'desc_col': - True - }] - - for param_set in build_time_series_dataframe_params: - demonstrate_build_time_series_dataframe(**param_set) - - -def build_multivariate_dataframe_example(): - - def demonstrate_build_multivariate_dataframe(intro_str, places, stat_vars): - print(""" - # {} - $ dcpd.build_multivariate_dataframe({}, {}) - {}""".format(intro_str, places, stat_vars, - dcpd.build_multivariate_dataframe(places, stat_vars))) - - build_multivariate_dataframe_params = [{ - 'intro_str': - 'Build a DataFrame of latest observations for multiple variables in multiple places.', - 'places': ['geoId/06', 'country/FRA'], - 'stat_vars': ['Median_Age_Person', 'Count_Person', 'Count_Household'] - }] - - for param_set in build_multivariate_dataframe_params: - demonstrate_build_multivariate_dataframe(**param_set) - - -def expect_err_examples(): - - print("\n\nExpect 6 errors, starting HERE:") - try: - dcpd.build_time_series_dataframe( - ['geoId/33'], ['Median_Income_Person', 'Count_Person']) - except ValueError as e: - print("Successfully errored on: ", e) - try: - dcpd.build_time_series_dataframe(24, ['Median_Income_Person']) - except ValueError as e: - print("Successfully errored on: ", e) - try: - dcpd.build_multivariate_dataframe( - [3], ['Median_Income_Person', 'Count_Person']) - except ValueError as e: - print("Successfully errored on: ", e) - try: - dcpd.build_multivariate_dataframe('country/USA', True) - except ValueError as e: - print("Successfully errored on: ", e) - # If the following two do not error due to the addition of - # Median_Income_Person statistics for NUTS geos, then please - # replace either the places or the StatVar. - try: - dcpd.build_time_series_dataframe(['nuts/HU2', 'nuts/HU22'], - 'Median_Income_Person') - except ValueError as e: - print("Successfully errored on: ", e) - try: - dcpd.build_multivariate_dataframe(['nuts/HU2', 'nuts/HU22'], - ['Median_Income_Person']) - except ValueError as e: - print("Successfully errored on: ", e) - print("until HERE.") - - -def main(): - build_time_series_example() - build_time_series_dataframe_example() - build_multivariate_dataframe_example() - expect_err_examples() - - -if __name__ == '__main__': - main() diff --git a/datacommons_pandas/places.py b/datacommons_pandas/places.py deleted file mode 120000 index 7206307a..00000000 --- a/datacommons_pandas/places.py +++ /dev/null @@ -1 +0,0 @@ -../datacommons/places.py \ No newline at end of file diff --git a/datacommons_pandas/populations.py b/datacommons_pandas/populations.py deleted file mode 120000 index 3e74c37b..00000000 --- a/datacommons_pandas/populations.py +++ /dev/null @@ -1 +0,0 @@ -../datacommons/populations.py \ No newline at end of file diff --git a/datacommons_pandas/query.py b/datacommons_pandas/query.py deleted file mode 120000 index d7db3c39..00000000 --- a/datacommons_pandas/query.py +++ /dev/null @@ -1 +0,0 @@ -../datacommons/query.py \ No newline at end of file diff --git a/datacommons_pandas/stat_vars.py b/datacommons_pandas/stat_vars.py deleted file mode 120000 index ab7359b6..00000000 --- a/datacommons_pandas/stat_vars.py +++ /dev/null @@ -1 +0,0 @@ -../datacommons/stat_vars.py \ No newline at end of file diff --git a/datacommons_pandas/test/__init__.py b/datacommons_pandas/test/__init__.py deleted file mode 100644 index 2c79033c..00000000 --- a/datacommons_pandas/test/__init__.py +++ /dev/null @@ -1,13 +0,0 @@ -# Copyright 2020 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. diff --git a/datacommons_pandas/test/df_builder_test.py b/datacommons_pandas/test/df_builder_test.py deleted file mode 100644 index e686b16d..00000000 --- a/datacommons_pandas/test/df_builder_test.py +++ /dev/null @@ -1,295 +0,0 @@ -# Copyright 2020 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -""" Data Commons Python API unit tests. - -Unit tests for StatVar methods in the Data Commons Pandas API. -""" - -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - -try: - from unittest.mock import patch -except ImportError: - from mock import patch - -import datacommons_pandas.df_builder as dcpd -import datacommons_pandas.utils as utils -import json -import unittest -import six -import six.moves.urllib as urllib - -# Reusable parts of REST API /stat/all response. -CA_COUNT_PERSON = { - "isDcAggregate": - "true", - "sourceSeries": [{ - "val": { - "1990": 23640, - "1991": 24100, - "1993": 25090, - }, - "observationPeriod": "P1Y", - "importName": "WorldDevelopmentIndicators", - "provenanceDomain": "worldbank.org" - }, { - "val": { - "1790": 3929214, - "1800": 5308483, - "1810": 7239881, - }, - "measurementMethod": "WikidataPopulation", - "importName": "WikidataPopulation", - "provenanceDomain": "wikidata.org" - }, { - "val": { - "1890": 28360, - "1891": 24910, - "1892": 25070, - }, - "measurementMethod": "OECDRegionalStatistics", - "observationPeriod": "P1Y", - "importName": "OECDRegionalDemography", - "provenanceDomain": "oecd.org" - }] -} - -HU22_COUNT_PERSON = { - "sourceSeries": [{ - "val": { - "1990": 2360, - "1991": 2410, - "1992": 2500, - }, - "measurementMethod": "OECDRegionalStatistics", - "observationPeriod": "P1Y", - "importName": "OECDRegionalDemography", - "provenanceDomain": "oecd.org" - }] -} - -CA_MEDIAN_AGE_PERSON = { - "sourceSeries": [{ - "val": { - "1990": 12, - "1991": 24, - "1992": 24, - }, - "measurementMethod": "WikidataPopulation", - "importName": "WikidataPopulation", - "provenanceDomain": "wikidata.org" - }] -} - - -def request_mock(*args, **kwargs): - """A mock urlopen requests sent in the requests package.""" - - # Create the mock response object. - class MockResponse: - - def __init__(self, json_data): - self.json_data = json_data - - def read(self): - return self.json_data - - req = args[0] - - stat_value_url_base = utils._API_ROOT + utils._API_ENDPOINTS[ - 'get_stat_value'] - stat_series_url_base = utils._API_ROOT + utils._API_ENDPOINTS[ - 'get_stat_series'] - stat_all_url_base = utils._API_ROOT + utils._API_ENDPOINTS['get_stat_all'] - - # Mock responses for urlopen requests to get_stat_series. - if req.get_full_url( - ) == stat_series_url_base + '?place=geoId/06&stat_var=Count_Person': - # Response returned when querying with basic args. - return MockResponse(json.dumps({"series": {"2000": 1, "2001": 2}})) - if (req.get_full_url() == stat_series_url_base + - '?place=geoId/06&stat_var=Count_Person&' + - 'measurement_method=CensusPEPSurvey&observation_period=P1Y&' + - 'unit=RealPeople&scaling_factor=100'): - - # Response returned when querying with above optional params. - return MockResponse(json.dumps({"series": {"2000": 3, "2001": 42}})) - if (req.get_full_url() == stat_series_url_base + - '?place=geoId/06&stat_var=Count_Person&' + - 'measurement_method=DNE'): - - # Response returned when data not available for optional parameters. - # /stat/series?place=geoId/06&stat_var=Count_Person&measurement_method=DNE - return MockResponse(json.dumps({"series": {}})) - - # Mock responses for urlopen requests to get_stat_all. - if req.get_full_url() == stat_all_url_base: - data = json.loads(req.data) - - if (data['places'] == ['geoId/06', 'nuts/HU22'] and - data['stat_vars'] == ['Count_Person', 'Median_Age_Person']): - # Response returned when querying with above params. - # Median Age missing for HU22. - resp = { - "placeData": { - "geoId/06": { - "statVarData": { - "Count_Person": CA_COUNT_PERSON, - "Median_Age_Person": CA_MEDIAN_AGE_PERSON - } - }, - "nuts/HU22": { - "statVarData": { - "Count_Person": HU22_COUNT_PERSON, - "Median_Age_Person": {} - } - } - } - } - return MockResponse(json.dumps(resp)) - - if (data['places'] == ['geoId/06', 'nuts/HU22'] and - data['stat_vars'] == ['Count_Person']): - # Response returned when querying with above params. - resp = { - "placeData": { - "geoId/06": { - "statVarData": { - "Count_Person": CA_COUNT_PERSON, - } - }, - "nuts/HU22": { - "statVarData": { - "Count_Person": HU22_COUNT_PERSON, - } - } - } - } - return MockResponse(json.dumps(resp)) - - if (data['places'] == ['geoId/06'] and - data['stat_vars'] == ['Count_Person']): - # Response returned when querying with above params. - resp = { - "placeData": { - "geoId/06": { - "statVarData": { - "Count_Person": CA_COUNT_PERSON, - } - } - } - } - return MockResponse(json.dumps(resp)) - - if (data['places'] == ['geoId/06', 'nuts/HU22'] and - data['stat_vars'] == ['Count_Person', 'Median_Age_Person']): - # Response returned when querying with above params. - # Median Age missing for HU22. - resp = { - "placeData": { - "geoId/06": { - "statVarData": { - "Count_Person": CA_COUNT_PERSON, - "Median_Age_Person": CA_MEDIAN_AGE_PERSON - } - }, - "nuts/HU22": { - "statVarData": { - "Count_Person": HU22_COUNT_PERSON, - "Median_Age_Person": {} - } - } - } - } - return MockResponse(json.dumps(resp)) - # Otherwise, return an empty response and a 404. - return urllib.error.HTTPError(None, 404, None, None, None) - - -class TestPdTimeSeries(unittest.TestCase): - """Unit tests for _time_series_pd_input.""" - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_basic(self, urlopen): - """Calling _time_series_pd_input with proper args.""" - rows = dcpd._time_series_pd_input(['geoId/06', 'nuts/HU22'], - 'Count_Person') - exp = [{ - "1890": 28360, - "1891": 24910, - "1892": 25070, - "place": "geoId/06" - }, { - "1991": 2410, - "1990": 2360, - "1992": 2500, - "place": "nuts/HU22" - }] - six.assertCountEqual(self, rows, exp) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_one_place(self, urlopen): - """Calling _time_series_pd_input with single place.""" - rows = dcpd._time_series_pd_input(['geoId/06'], 'Count_Person') - exp = [{ - "1990": 23640, - "1991": 24100, - "1993": 25090, - "place": "geoId/06" - }] - self.assertEqual(rows, exp) - - -class TestPdMultivariates(unittest.TestCase): - """Unit tests for _multivariate_pd_input.""" - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_basic(self, urlopen): - """Calling _multivariate_pd_input with proper args.""" - rows = dcpd._multivariate_pd_input( - ['geoId/06', 'nuts/HU22'], ['Count_Person', 'Median_Age_Person']) - exp = [{ - "place": "geoId/06", - "Median_Age_Person": 24, - "Count_Person": 25070 - }, { - "place": "nuts/HU22", - "Count_Person": 2500 - }] - six.assertCountEqual(self, rows, exp) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_one_each(self, urlopen): - """Calling _multivariate_pd_input with single place and var.""" - rows = dcpd._multivariate_pd_input(['geoId/06'], ['Count_Person']) - exp = [{"place": "geoId/06", "Count_Person": 25090}] - self.assertEqual(rows, exp) - - @patch('six.moves.urllib.request.urlopen', side_effect=request_mock) - def test_no_data(self, urlopen): - """Error if there is no data.""" - with self.assertRaises(ValueError): - dcpd._group_stat_all_by_obs_options( - ['FOO/100'], ['Count_Person', 'Median_Age_Person']) - with self.assertRaises(ValueError): - dcpd._time_series_pd_input(['FOO/100', 'BAR/200'], ['Count_Person']) - with self.assertRaises(ValueError): - dcpd._multivariate_pd_input(['FOO/100', 'BAR/200'], - ['Count_Person', 'Median_Age_Person']) - - -if __name__ == '__main__': - unittest.main() diff --git a/datacommons_pandas/utils.py b/datacommons_pandas/utils.py deleted file mode 120000 index 06c545f5..00000000 --- a/datacommons_pandas/utils.py +++ /dev/null @@ -1 +0,0 @@ -../datacommons/utils.py \ No newline at end of file diff --git a/docs/development.md b/docs/development.md new file mode 100644 index 00000000..03071c10 --- /dev/null +++ b/docs/development.md @@ -0,0 +1,55 @@ +# Python API Development + +This client library supports `python>=3.10`. + +## Set up +If you haven't already, clone this repository. + +```bash +git clone https://github.com/datacommonsorg/api-python.git +cd api-python +``` + +To set up the Python environment for development, run: + +```bash +./run_test.sh -s +``` + +This will install `hatch`, which is the main tool used to manage the +environment, dependencies, and development tools. You can also manually install +`hatch` and create a virtual environment. + +```bash +pip install hatch +hatch env create +``` + +## Code style and linting +We use `isort` and `yapf` for code formatting. Check formatting with: + +```bash +hatch run lint:check +``` + +To automatically fix formatting run: + +```bash +hatch run lint:format +``` + +## Running tests + +To test, run: + +```bash +hatch run test:all +``` + +To debug the continuous integration tests, run: + +```bash +gcloud builds submit . --project=datcom-ci --config=cloudbuild.yaml +``` + +Both commands will run the same set of tests. \ No newline at end of file diff --git a/docs/release.md b/docs/release.md new file mode 100644 index 00000000..96425cb4 --- /dev/null +++ b/docs/release.md @@ -0,0 +1,32 @@ +# Python API Release + +## Releasing the `datacommons_client` package +Support for V2 of the Data Commons API is being released as a new client library +called `datacommons_client`. + +To release: +1. Update [CHANGELOG.md](../CHANGELOG.md) with relevant changes. +2. Bump the version by running `hatch version` followed by `patch`, `minor`, `major`, a +specific version number, or `--pre beta` for a beta version, for example. +3. Build the package +```bash +hatch build +``` +4. (optionally) Test the deployment process locally +```bash +hatch run release:localtest +``` +5. Test the deployment process on Test PyPi +```bash +hatch run release:testpypi +``` + +6. Once verified, upload to PyPI: +```bash +hatch run release:pypi +``` + +7. Create a version tag on Git: +```bash +hatch run release:tag +``` diff --git a/notebooks/COVID_19_Feature_Exploration_Analysis_with_Data_Commons.ipynb b/notebooks/COVID_19_Feature_Exploration_Analysis_with_Data_Commons.ipynb deleted file mode 100644 index 4f736f8c..00000000 --- a/notebooks/COVID_19_Feature_Exploration_Analysis_with_Data_Commons.ipynb +++ /dev/null @@ -1,3728 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "name": "COVID-19 Feature Exploration Analysis with Data Commons", - "provenance": [], - "collapsed_sections": [], - "toc_visible": true, - "include_colab_link": true - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - } - }, - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "view-in-github", - "colab_type": "text" - }, - "source": [ - "\"Open" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "8f_bICClsb5p", - "colab_type": "text" - }, - "source": [ - "Copyright 2020 Google LLC.\n", - "SPDX-License-Identifier: Apache-2.0\n", - "\n", - "**Authors**: Yi Gao, Xianzhi Helen Wang" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "CKiH1L7wHYlX", - "colab_type": "text" - }, - "source": [ - "# Welcome!\n", - "\n", - "Welcome to this Colab notebook! We will walk you through two examples of exploration analyses with the Data Commons dataset here:\n", - "\n", - "1. How do the COVID-19 cases trends differ across different counties?\n", - "2. What features are potentially correlated with COVID-19 mortality rate? \n", - "\n", - "We hope the examples can help you better understand what data are available on Data Commons and how to use them, so that further research or analysis can be conducted easily.\n", - "\n", - "**More about the dataset used in this Colab**\n", - "\n", - "The analyses here use a frozen version of the data set which was generated around mid July, 2020. \n", - "* For COVID-19 case data, we fix the analysis period as 2020-02-26 to 2020-07-10 so that the results in this Colab are reproducible. (The start date is chosen since it's the time of the first instance of community spread as reported [here](https://www.cdc.gov/media/releases/2020/s0226-COVID-19-spread.html).)\n", - "* For context data, they are the most recent values at the time when this data set was generated (2020-07-15). More details about the context features' definition can be found on Data Commons ([link](http://docs.datacommons.org/statistical_variables.html)).\n", - "\n", - "You can find live versions of the data sets in the Appendix section of this Colab.\n", - "\n", - "Hope you enjoy the exploratory analysis here!" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "4GQojUtPY05J", - "colab_type": "text" - }, - "source": [ - "# Prepare" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "oFqaXbHiMp1f", - "colab_type": "text" - }, - "source": [ - "## Load Packages" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "iLO0z5aRGKjr", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 303 - }, - "outputId": "a364b400-e7ce-4b40-d831-9c31b4a8559a" - }, - "source": [ - "!pip install -U plotly\n", - "\n", - "import json\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import pandas as pd\n", - "import plotly.express as px\n", - "import random\n", - "import seaborn as sns\n", - "import statsmodels.api as sm\n", - "\n", - "from collections import defaultdict\n", - "from datetime import datetime\n", - "from sklearn.cluster import KMeans\n", - "from sklearn.decomposition import PCA\n", - "from sklearn.ensemble import RandomForestClassifier\n", - "from sklearn.ensemble import RandomForestRegressor\n", - "from sklearn.metrics import silhouette_score\n", - "from urllib.request import urlopen\n", - "\n", - "# This is used for map plots.\n", - "counties_geo_path = 'https://raw.githubusercontent.com/plotly/datasets/master/geojson-counties-fips.json'\n", - "with urlopen(counties_geo_path) as response:\n", - " COUNTIES_GEO = json.load(response)\n", - "\n", - "pd.set_option('max_colwidth', 400)\n" - ], - "execution_count": 1, - "outputs": [ - { - "output_type": "stream", - "text": [ - "Collecting plotly\n", - "\u001b[?25l Downloading https://files.pythonhosted.org/packages/04/20/c2d77eef33dbd40c5e3263a9a8763ffca610a4c3d2b2da21c5601e5fc5d8/plotly-4.10.0-py2.py3-none-any.whl (13.0MB)\n", - "\u001b[K |████████████████████████████████| 13.0MB 323kB/s \n", - "\u001b[?25hRequirement already satisfied, skipping upgrade: six in /usr/local/lib/python3.6/dist-packages (from plotly) (1.15.0)\n", - "Requirement already satisfied, skipping upgrade: retrying>=1.3.3 in /usr/local/lib/python3.6/dist-packages (from plotly) (1.3.3)\n", - "Installing collected packages: plotly\n", - " Found existing installation: plotly 4.4.1\n", - " Uninstalling plotly-4.4.1:\n", - " Successfully uninstalled plotly-4.4.1\n", - "Successfully installed plotly-4.10.0\n" - ], - "name": "stdout" - }, - { - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.6/dist-packages/statsmodels/tools/_testing.py:19: FutureWarning:\n", - "\n", - "pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.\n", - "\n" - ], - "name": "stderr" - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "s-CG75mgMtxM", - "colab_type": "text" - }, - "source": [ - "## Load and join data sets" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "ATtiFNuIGWtJ", - "colab_type": "code", - "cellView": "code", - "colab": {} - }, - "source": [ - "# The Google files are in this Google Drive Folder:\n", - "# https://drive.google.com/drive/u/1/folders/1mM1scQxsD38tlSk7IcSKJrN7Ez5-J22F\n", - "\n", - "analysis_data_start = datetime.strptime('2020-02-26', '%Y-%m-%d')\n", - "analysis_data_end = datetime.strptime('2020-07-10', '%Y-%m-%d')\n", - "date_range = pd.date_range(analysis_data_start, analysis_data_end).format(\n", - " formatter=lambda x: x.strftime('%Y-%m-%d'))\n", - "count_data_columns = ['County', 'Name'] + date_range\n", - "\n", - "STATE_COVARIATE_PATH = 'https://docs.google.com/spreadsheets/d/e/2PACX-1vR12v_MRKdDa6u2mdD0aPFlDilV0SJtbeYyrNbqI3qZDuImw_RnDcpNAmwbJkRP7O7fAC-9EYsoV4Dm/pub?output=csv'\n", - "df_state_context = pd.read_csv(STATE_COVARIATE_PATH)\n", - "COUNTY_COVARIATE_PATH = 'https://docs.google.com/spreadsheets/d/e/2PACX-1vSSeYEVT9wH-F6X7qxnhyXke1JoudkpqAJqVdZWlkTLF0Ah5529VDB4gLLICrqpczbvl-qi_P7Eyte7/pub?output=csv'\n", - "df_county_context = pd.read_csv(COUNTY_COVARIATE_PATH)\n", - "\n", - "COUNTY_POSITIVE_COUNT_PATH = 'https://docs.google.com/spreadsheets/d/e/2PACX-1vSv2PsEqsv4wyVUG9F3SCBMgMm9vXQg05a_Hyjc7xw5uOmlNUFYSg75JxvRQ3yuHodoZMFcK_FB1J3H/pub?output=csv'\n", - "df_county_case = pd.read_csv(COUNTY_POSITIVE_COUNT_PATH)\n", - "df_county_case = df_county_case[count_data_columns]\n", - "\n", - "COUNTY_DEATH_COUNT_PATH = 'https://docs.google.com/spreadsheets/d/e/2PACX-1vRqhlJ7yAGMEJtnS8-8BISwB7ZfB9WyHFtOpbGe5v_hVmUHXvkXyJCXCDX-jp8u6KC-SdbVBs4c78aI/pub?output=csv'\n", - "df_county_death = pd.read_csv(COUNTY_DEATH_COUNT_PATH)\n", - "df_county_death = df_county_death[count_data_columns]" - ], - "execution_count": 2, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "pEll5ECdQzLY", - "colab_type": "code", - "colab": {} - }, - "source": [ - "# Create geoid - county / state name mapping.\n", - "df_county_name = df_county_context[['County', 'Name']].copy()\n", - "df_county_name['State'] = df_county_name['County'].apply(lambda x: x[:-3])\n", - "df_county_name = pd.merge(df_county_name, df_state_context[['State', 'Name']],\n", - " on='State', suffixes=('_county', '_state'))\n", - "df_county_name['full_name'] = df_county_name['Name_county'] + ', '+ \\\n", - " df_county_name['Name_state']\n", - "\n", - "county_name_mapping = defaultdict(str)\n", - "for _, row in df_county_name.iterrows():\n", - " county_name_mapping[row['County']] = row['full_name']\n", - "\n", - "def get_name_by_geoid(geoid):\n", - " return county_name_mapping[geoid]" - ], - "execution_count": 3, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "2H_19sCyydGG", - "colab_type": "code", - "colab": {} - }, - "source": [ - "# Merge the county level DataFrames.\n", - "df_county_joined = pd.merge(df_county_case, df_county_death, how='outer', \n", - " suffixes=('_case', '_death'), \n", - " on=['County', 'Name']).pipe(\n", - " pd.merge,right=df_county_context, how='outer')\n", - "df_county_joined = df_county_joined.set_index('County')\n", - "df_county_joined = df_county_joined.join(df_county_name)\n", - "\n", - "case_columns = [date + '_case' for date in date_range]\n", - "death_columns = [date + '_death' for date in date_range]" - ], - "execution_count": 4, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "iV3voC4IuUet", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 112 - }, - "outputId": "ee9e669b-9266-4b3f-c4b0-426a314af326" - }, - "source": [ - "# Check the shapes of the loaded DataFrames\n", - "print(f'The shape of df_state_context is {df_state_context.shape}.')\n", - "print(f'The shape of df_county_context is {df_county_context.shape}.')\n", - "print(f'The shape of df_county_case is {df_county_case.shape}.')\n", - "print(f'The shape of df_county_death is {df_county_death.shape}.')\n", - "print(f'The shape of df_county_joined is {df_county_joined.shape}.')" - ], - "execution_count": 5, - "outputs": [ - { - "output_type": "stream", - "text": [ - "The shape of df_state_context is (52, 192).\n", - "The shape of df_county_context is (3190, 182).\n", - "The shape of df_county_case is (3076, 138).\n", - "The shape of df_county_death is (3138, 138).\n", - "The shape of df_county_joined is (3258, 458).\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "ZKZEyb51ZHpC", - "colab_type": "text" - }, - "source": [ - "# How do COVID-19 cases trends differ across different counties?\n", - "\n", - "In this section, we give an example of discovering different case trends across counties. \n", - "\n", - "Here are the main steps in this example:\n", - "1. Calculate normalized case trends.\n", - "2. Cluster the counties of similar case growth patterns.\n", - "3. Visualize the main trend of each cluster.\n", - "4. Visualize the clustering result on the U.S. map.\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "K6OCxuXDZZNz", - "colab_type": "text" - }, - "source": [ - "## Calculate normalized trends\n", - "\n", - "The positive case counts available in DataCommons are cumulative counts. In this part, we calculate daily incremental case counts and normalize them by population, so that trends can be compared between different counties. \n", - "\n", - "**Technical detail**\n", - "\n", - "We will cluster the counties by their smoothed trends of incremental positive cases normalized by population: \n", - "\n", - "$$\\frac{\\#\\ of\\ incremental\\ positive\\ cases}{county\\ population}.$$\n", - "\n", - "The $\\#\\ of\\ incremental\\ positive\\ cases$ is the number of new cases diagnosed with COVID-19 on each day in each county. We want to look at incremental changes instead of the cumulative trends because it's easier to distinguish / interpret incremental change patterns (which can go up / down) compared to cumulative trend patterns (which all go up).\n", - "\n", - "The incremental cases are normalized by population as we expect to see higher case numbers in counties with more people. Simply clustering the counties using the incremental case numbers will possibly generate clusters just reflecting county populations. After the normalization, we can have the numbers that are roughly comparable among the counties, regardless of their population, so that the clustering results can better reflect the severity of the counties.\n", - "\n", - "In addition, the trends are smoothed with centered 7-day moving average to adjust for weekday effects.\n", - "\n", - "We will see what are the main trend patterns during the analysis period and how they are distributed in the U.S." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "4WgG4ZfxMSN8", - "colab_type": "code", - "cellView": "both", - "colab": {} - }, - "source": [ - "def obtain_incremental_trend(df, count_columns, smooth=True, clip=True):\n", - " \"\"\"Obtains the normalized incremental changes.\n", - "\n", - " The input df contains cumulative counts of interest, and this function\n", - " calculates normalized incremental changes from that df.\n", - "\n", - " Args:\n", - " df: A data frame with joined data.\n", - " count_columns: Columns in the joined data dataframe specifying the columns\n", - " of cumulative counts. They should have the format YYYY-MM-DD_[case|death].\n", - " smooth: Whether to take rolling averages of the counts. If True, the output\n", - " will be 7-day centered rolling averages of incremental changes in each\n", - " county. Otherwise the raw incremental trends will be returned. Note that\n", - " first 3 days and last 3 days will be removed if smooth=True.\n", - " clip: Whether to replace negative incremental changes as 0.\n", - " \n", - " Returns:\n", - " A dataframe with dates as index and county geoId as columns names. Each\n", - " column is a series of incremental changes in the county.\n", - " \"\"\"\n", - " trends = df[count_columns].apply(lambda x: x / df['Count_Person'])\n", - " trends = trends.transpose()\n", - " trends.index = pd.to_datetime([idx.split('_')[0] for idx in trends.index])\n", - " trends = trends.dropna(axis=1, how='all')\n", - " trend_changes = trends.sort_index().diff()\n", - " # Some incremental changes of cumulative positive cases are negative, and this\n", - " # is an issue existing in the source data (JHU dataset) we are using. We \n", - " # simply replace the negative ones as 0 here.\n", - " if clip:\n", - " trend_changes = trend_changes.clip(lower=0.)\n", - " if smooth:\n", - " trend_changes = trend_changes.apply(\n", - " lambda x: x.rolling(7,center=True).mean())\n", - " return trend_changes.dropna()\n", - "\n", - "case_incremental_trends = obtain_incremental_trend(df_county_joined,\n", - " case_columns)" - ], - "execution_count": 6, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "bppHEz5HaHgw", - "colab_type": "text" - }, - "source": [ - "## Cluster the counties\n", - "\n", - "After preparing the trend data, we run a K-means algorithm to cluster the counties into 9 clusters. The cluster labels are ordered so that smaller labels indicate larger cluster sizes.\n", - "\n", - "**Technical detail**\n", - "\n", - "The number of clusters, 9, is decided in this Appendix section." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "zBBcLfaHtFri", - "colab_type": "code", - "colab": {} - }, - "source": [ - "def get_cluster_labels(trend_df, n_cluster, **kmeans_kwargs):\n", - " \"\"\"Generates cluster labels for data containing incremental trends.\n", - " \n", - " Args:\n", - " trend_df: A dataframe containing incremental trends generated from the \n", - " function 'obtain_incremental_trend'.\n", - " n_cluster: The number of clusters desired.\n", - " random_seed: A random seed to fix the results of the k-means algorithm.\n", - " **kmeans_kwargs: Named arguments passed to the KMeans function.\n", - "\n", - " Returns:\n", - " A data frame with two columns. The first column 'County' contains the\n", - " geoIds and the second column 'Cluster' contains the cluster labels. The\n", - " cluster labels are ordered so that clusters with smaller labels are larger\n", - " clusters containing more conties.\n", - " \"\"\"\n", - " cluster_data_df = trend_df.transpose()\n", - " km_model = KMeans(n_clusters=n_cluster, **kmeans_kwargs).fit(cluster_data_df)\n", - " cluster_labels = pd.DataFrame({\n", - " 'County': trend_df.columns,\n", - " 'Cluster': km_model.predict(cluster_data_df)})\n", - " cluster_counts = cluster_labels['Cluster'].value_counts().sort_values(\n", - " ascending=False)\n", - " new_cluster_mapping = {cluster_counts.index[i]: i for\n", - " i in range(len(cluster_counts))}\n", - " cluster_labels['Cluster'] = cluster_labels['Cluster'].apply(\n", - " lambda x: new_cluster_mapping[x])\n", - " return cluster_labels\n", - "\n", - "case_cluster_labels = get_cluster_labels(case_incremental_trends, 9,\n", - " random_state=42, n_init=1000)\n" - ], - "execution_count": 7, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "jupmVpx-tRiS", - "colab_type": "text" - }, - "source": [ - "## Check the main trend of each cluster\n", - "\n", - "The median trend values of the clusters are shown below. (The shadow area is specified by 2.5%-tile and 97.5%-tile values in each cluster on each day.) A few clusters are very small because they are essentially 'outliers' in the data set. The first few clusters are of special interest:\n", - "\n", - "* Cluster '0' is the counties with low case ratio over the whole analysis period.\n", - "* Cluster '1' is the counties where new case ratio started to increase after June.\n", - "* Cluster '2' is the severe counties during April and May.\n", - "* Cluster '3' is the very severe counties where new cases peaked in early June and then dropped.\n", - "* Cluster '4' is the very severe counties where new cases peaked in early May and then dropped.\n", - "* Cluster 5-8 are basically some 'outliers'." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "-QoYKcG-YCvE", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 351 - }, - "outputId": "9ecd5066-167f-42d4-c72f-ff7524984338" - }, - "source": [ - "def plot_cluster_medians(rate_df, label_df, nc=5, ylim=None):\n", - " \"\"\"Plots cluster medians with bounds of 2.5 and 97.5 percentiles.\n", - "\n", - " Args:\n", - " rate_df: The dataframe containing incremental rates.\n", - " label_df: The dataframe containing cluster labels of each county.\n", - " nc: The number of columns in the output plot.\n", - " ylim: The y-limits of the plots.\n", - "\n", - " Returns:\n", - " A dataframe containing the median trends of the clusters. A group of trend\n", - " plots with median trends with bounds of 2.5 and 97.5 percentiles is plotted.\n", - " \"\"\"\n", - " n_cluster = label_df['Cluster'].nunique()\n", - " nr = int(np.ceil(n_cluster / nc))\n", - " fig, ax = plt.subplots(nr, nc, sharex=True, sharey=True, figsize=[20, 3*nr])\n", - " ax = ax.flatten()\n", - " all_trend = pd.DataFrame()\n", - " if ylim is None:\n", - " ylim = [0, rate_df.max().max()]\n", - " for i, cluster in enumerate(sorted(label_df['Cluster'].unique())):\n", - " temp_county = label_df[label_df['Cluster'] == cluster]['County'].values\n", - " temp_rates = rate_df[temp_county]\n", - " temp_stats = temp_rates.transpose().describe(percentiles=[0.025, 0.975])\n", - " up_bound = temp_stats.loc['97.5%']\n", - " low_bound = temp_stats.loc['2.5%']\n", - " median_trend = temp_stats.loc['50%']\n", - " all_trend[f'cluster_{i}'] = median_trend\n", - " median_trend.plot(ax=ax[i], label='median')\n", - " ax[i].set_title(f'cluster_{i} (n={len(temp_county)})')\n", - " ax[i].fill_between(median_trend.index, low_bound.values, up_bound.values, \n", - " alpha=0.3, label='[2.5%, 97.75%]-tiles')\n", - " ax[i].set_ylim(ylim)\n", - " if i==0:\n", - " ax[i].legend()\n", - " return all_trend\n", - "\n", - "median_case_trends = plot_cluster_medians(case_incremental_trends,\n", - " case_cluster_labels, ylim=[0, 0.002])" - ], - "execution_count": 8, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "VV6meXkEaZiC", - "colab_type": "text" - }, - "source": [ - "## Geographical distribution of the clusters\n", - "\n", - "Plot the heatmap of the distribution of the different trend patterns." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "ygdTyEMmYt0D", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 542 - }, - "outputId": "16f4746c-270b-45da-d8be-5bf6f596bcf4" - }, - "source": [ - "def norm_by_range(x):\n", - " \"\"\"Normalizes an array by it's range.\n", - "\n", - " Args:\n", - " x: an array or a pd.Series.\n", - "\n", - " Returns:\n", - " A normalized array or pd.Series whose values are normalized to the range\n", - " between 0 and 1.\n", - " \n", - " \"\"\"\n", - " return (x - x.min()) / (x.max() - x.min())\n", - "\n", - "def show_values_on_map(values, title, adjust_cmap=False, **kwargs):\n", - " \"\"\"Shows the values associated with counties on a U.S. map.\n", - "\n", - " Args:\n", - " values: A pd.Series containing the values of interest indexed by county geo\n", - " IDs. The values can either be strings or numbers. Strings will be\n", - " interpreted as groups and numbers will be used as continuous values.\n", - " title: The title of the plot.\n", - " adjust_cmap: Whether to adjust the color map. Only set this as True for\n", - " numerical values. It will adjust the color scale so that the the plot is\n", - " not influenced by severe outliers.\n", - " **kwargs: Other key-value arguments passed to px.choropleth.\n", - " \n", - " Returns:\n", - " A plotly.graph_objs._figure.Figure project.\n", - " \"\"\"\n", - " plot_df = pd.DataFrame({\n", - " 'county': values.index,\n", - " 'value': values.values\n", - " })\n", - " plot_df['full_name'] = plot_df['county'].apply(get_name_by_geoid)\n", - " plot_df['fips'] = plot_df['county'].apply(lambda x: x.split('/')[1])\n", - " if adjust_cmap:\n", - " value_describe = plot_df['value'].describe(\n", - " percentiles=[0.01, 0.99])[['min','1%', '50%', '99%', 'max']]\n", - " value_describe_norm = norm_by_range(value_describe)\n", - " new_color_scale = [(0, 'green'), \n", - " (value_describe_norm['1%'], 'green'),\n", - " (value_describe_norm['50%'], 'white'),\n", - " (value_describe_norm['99%'], 'orange'),\n", - " (1, 'orange')]\n", - " fig = px.choropleth(plot_df, locations='fips', geojson=COUNTIES_GEO, \n", - " color='value', scope=\"usa\",\n", - " hover_data=['full_name'],\n", - " color_continuous_scale=new_color_scale,\n", - " title=title, **kwargs)\n", - " else:\n", - " fig = px.choropleth(plot_df, locations='fips', geojson=COUNTIES_GEO, \n", - " color='value', scope=\"usa\",\n", - " hover_data=['full_name'],\n", - " title=title, **kwargs)\n", - " return fig\n", - "\n", - "str_cluster_labels = case_cluster_labels.sort_values(\n", - " 'Cluster').set_index('County')['Cluster'].apply(lambda x: f'cluster_{x}')\n", - "color_sequence = ['#2ca02c', '#ff7f0e', '#9467bd', '#8c564b', '#1f77b4',\n", - " '#d62728', '#17becf', '#bcbd22', '#7f7f7f']\n", - "show_values_on_map(str_cluster_labels, 'Case trend cluster distribution',\n", - " color_discrete_sequence = color_sequence)" - ], - "execution_count": 9, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "
\n", - "
\n", - "\n", - "" - ] - }, - "metadata": { - "tags": [] - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "r7fXJIExredF", - "colab_type": "text" - }, - "source": [ - "# What features are potentially correlated with COVID-19 mortality rate?\n", - "\n", - "In this example, we will explore the available context features and demonstrate two simple approaches (pairwise correlation / logistic regression) to discover features with potentially high correlation with the COVID-19 mortality rate.\n", - "\n", - "Main steps in this analysis:\n", - "1. Context feature cleaning\n", - "2. Death ratio calculation\n", - "3. Pairwise correlation analysis\n", - "4. Logistic regression with PCA components" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "6P6NWyBNy0NK", - "colab_type": "text" - }, - "source": [ - "## Context feature cleaning\n", - "\n", - "It's usually necesary to clean up a data set before using it. In this part, we normalized / transform variables and imopute missing values so that we can easily use them for the following analysis.\n", - "\n", - "**Technical details**\n", - "\n", - "* Given the purpose of our next step is to use these variables to better understand death-to-case ratio, most of features on raw counts are not very helpful. We need to have normalized counts for the counties so that we can compare. Here we simply devide all the counts by county's populations. A prefix 'Norm_' is added to such variables.\n", - "* The distribution of some features are highly skewed. We take a log transformation for these variables:\n", - " * log transformation for Count_Person, LandAreaSqMeter, PopulationDensityPerSqMeter.\n", - "* Deal with missing values:\n", - " * Features with > 40% missing values are dropped.\n", - " * Missing values of each county are filled by the its state median. If a value is missed for all counties in a state, they are filled by the median of all available states." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "KlKWRx_pRYIN", - "colab_type": "code", - "colab": {} - }, - "source": [ - "features_updated = df_county_context.drop('Name', axis=1).copy()\n", - "\n", - "# Normalized count variables by population.\n", - "# The variable names are updated to have prefix 'Norm_Count_'. The reason we\n", - "# we don't use 'percent' here because some counts are not about 'person', for\n", - "# example, 'Count_Household_With3Person'. Normalized version of these features\n", - "# are not percentages. Although the new variables have the term 'count' in it,\n", - "# they are no longer 'counts', but actually 'ratios'.\n", - "count_feature_columns = [c for c in df_county_context if \n", - " c.startswith('Count_') and c != 'Count_Person']\n", - "population_col = df_county_context['Count_Person']\n", - "retaildrug_cols = [c for c in df_county_context if \n", - " c.startswith('RetailDrugDistribution_')]\n", - "for c in count_feature_columns + retaildrug_cols:\n", - " features_updated['Norm_' + c] = df_county_context[c] / population_col\n", - "\n", - "# The feature Percent_NoHealthInsurance_AmongUpto64Years is a little confusing:\n", - "# It's the percent of people up to 64 years without insurance among all people.\n", - "# We normalize it by percent of people up to 64 years.\n", - "features_updated['Percent_NoHealthInsurance_AmongUpto64Years'] = \\\n", - " features_updated['Percent_Person_Upto64Years_NoHealthInsurance'] / \\\n", - " (1 - features_updated['Norm_Count_Person_65OrMoreYears'])\n", - "\n", - "# Take log for some features (population, area, retail drug distribution etc.)\n", - "features_updated['Log_Count_Person'] = np.log(df_county_context['Count_Person'])\n", - "features_updated['Log_LandAreaSqMeter'] = np.log(\n", - " df_county_context['LandAreaSqMeter'])\n", - "features_updated['Log_PopulationDensityPerSqMeter'] = np.log(\n", - " features_updated['PopulationDensityPerSqMeter'])\n", - "\n", - "# Remove the raw count variables.\n", - "features_updated = features_updated.drop(\n", - " count_feature_columns + retaildrug_cols + [\n", - " 'Count_Person', 'LandAreaSqMeter', 'PercentBlackOrAfricanAmericanAlone',\n", - " 'UnemploymentRate_Person', 'PopulationDensityPerSqMeter',\n", - " 'Percent_Person_Upto64Years_NoHealthInsurance'], axis=1)\n", - "\n", - "# Remove columns with >40% missing values\n", - "col_missing_ratio = features_updated.apply(\n", - " lambda x: sum(x.isna()) * 1. / len(x))\n", - "col_remove = col_missing_ratio[col_missing_ratio > 0.4].index.values\n", - "features_updated = features_updated.drop(col_remove, axis=1)\n", - "\n", - "# Augment missing values\n", - "features_updated['State'] = features_updated['County'].apply(lambda x: x[:-3])\n", - "state_medians = features_updated.groupby('State').apply(lambda x: x.median())\n", - "state_medians = state_medians.apply(lambda x: np.where(x.isna(), x.median(), x))\n", - "for c in features_updated.columns:\n", - " if c in ['County', 'State']:\n", - " continue\n", - " features_updated[c] = np.where(\n", - " features_updated[c].isna(),\n", - " state_medians.loc[features_updated['State']][c],\n", - " features_updated[c]\n", - " )\n", - "\n", - "features_updated = features_updated.drop('State', axis=1).set_index('County')" - ], - "execution_count": 10, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "bXB5oFsmE-BU", - "colab_type": "text" - }, - "source": [ - "## Death ratio calculation\n", - "\n", - "Death ratios are calculated as the ratio between total death cases devided by total positive cases for each county. \n", - "\n", - "Counties with total case counts < 10 are removed from this analysis." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "yHXn2-rAdsUm", - "colab_type": "code", - "colab": {} - }, - "source": [ - "case_counts = df_county_joined[case_columns]\n", - "death_counts = df_county_joined[death_columns]\n", - "\n", - "death_ratio = death_counts.max(axis=1) / case_counts.max(axis=1)\n", - "death_ratio = death_ratio[case_counts.max(axis=1) >= 10]\n", - "death_ratio = death_ratio[death_ratio < 1].dropna()\n", - "death_ratio = pd.DataFrame(death_ratio).reset_index()\n", - "death_ratio.columns = ['County', 'death_ratio']\n", - "death_ratio = death_ratio.set_index('County')" - ], - "execution_count": 11, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "86ABpK6VdzdP", - "colab_type": "code", - "cellView": "both", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 542 - }, - "outputId": "f52128d5-a8e2-4f53-efcd-9a1c6eaa5728" - }, - "source": [ - "show_values_on_map(death_ratio['death_ratio'], 'Death ratio distribution', True)" - ], - "execution_count": 12, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "
\n", - "
\n", - "\n", - "" - ] - }, - "metadata": { - "tags": [] - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "-WDnVMpezlt4", - "colab_type": "text" - }, - "source": [ - "## Pairwise correlation analysis\n", - "\n", - "We show the pairwise correlation among the context features and death ratio is plotted in the heatmap below. We also list the top features with largest correlation with death ratio." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "OnWpLIAvasYp", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 949 - }, - "outputId": "41445b8e-297b-429e-a043-df1154ab2223" - }, - "source": [ - "df_death_ratio_joined = death_ratio.join(\n", - " features_updated, how='inner'\n", - ")\n", - "corr_full = df_death_ratio_joined.corr('spearman')\n", - "fig, _ = plt.subplots(figsize=(25,20))\n", - "sns.heatmap(corr_full, cmap='coolwarm', vmin=-1, vmax=1)" - ], - "execution_count": 13, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "" - ] - }, - "metadata": { - "tags": [] - }, - "execution_count": 13 - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "j-Mepj8saGyj", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 210 - }, - "outputId": "0d75adb3-0fc1-4a77-a7e2-2fbd34f061c4" - }, - "source": [ - "df_corr = corr_full[['death_ratio']].drop('death_ratio')\n", - "df_corr.columns = ['corr']\n", - "df_corr['abs_corr'] = abs(df_corr['corr'])\n", - "\n", - "sorted_corr = df_corr.sort_values(['abs_corr'], ascending=False)\n", - "sorted_corr.head(5)" - ], - "execution_count": 14, - "outputs": [ - { - "output_type": "execute_result", - "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", - "
corrabs_corr
Log_PopulationDensityPerSqMeter0.2826780.282678
Log_Count_Person0.2619470.261947
Norm_Count_Person_BlackOrAfricanAmericanAloneOrInCombinationWithOneOrMoreOtherRaces0.2318680.231868
Norm_Count_Person_BlackOrAfricanAmericanAlone0.2267280.226728
Norm_Count_Household_With3Person0.1954540.195454
\n", - "
" - ], - "text/plain": [ - " corr abs_corr\n", - "Log_PopulationDensityPerSqMeter 0.282678 0.282678\n", - "Log_Count_Person 0.261947 0.261947\n", - "Norm_Count_Person_BlackOrAfricanAmericanAloneOrInCombinationWithOneOrMoreOtherRaces 0.231868 0.231868\n", - "Norm_Count_Person_BlackOrAfricanAmericanAlone 0.226728 0.226728\n", - "Norm_Count_Household_With3Person 0.195454 0.195454" - ] - }, - "metadata": { - "tags": [] - }, - "execution_count": 14 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "k7rgAdWR9S2T", - "colab_type": "text" - }, - "source": [ - "### Deep dive for population density\n", - "\n", - "You can use density plot to better understand the relationship between a context feature and the death ratio. A visulization of the values on map would be helpful, too. Here we use population density as an example to generate those plots." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "35_8GwYRjUQP", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 460 - }, - "outputId": "48a8db32-f713-4bd5-e137-3ed72bd36cbf" - }, - "source": [ - "sns.jointplot(data=df_death_ratio_joined,\n", - " x='Log_PopulationDensityPerSqMeter', \n", - " y='death_ratio', kind='kde', ylim=[0, 0.1])" - ], - "execution_count": 15, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "" - ] - }, - "metadata": { - "tags": [] - }, - "execution_count": 15 - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "4EfAEXlYr-gK", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 542 - }, - "outputId": "14db4943-9fa0-42aa-9584-28ea2e028c9b" - }, - "source": [ - "show_values_on_map(features_updated['Log_PopulationDensityPerSqMeter'], \n", - " 'Log population density', True)" - ], - "execution_count": 16, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "
\n", - "
\n", - "\n", - "" - ] - }, - "metadata": { - "tags": [] - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "CbbpC_EU1bEd", - "colab_type": "text" - }, - "source": [ - "## Logistic regression with PCA\n", - "\n", - "Here we demonstrate another approach to discover useful features by using a logistic regression with components generated from PCA (principle component analysis)." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "luGnh0A71za6", - "colab_type": "text" - }, - "source": [ - "### Principle Component Analysis\n", - "\n", - "The main purpose of PCA is to reduce the number of features by combining similar features. After this step, we will use 15 components generated from PCA instead of the set of ~165 features. \n", - "\n", - "**Technical details**\n", - "\n", - "We have lots of features (~165) in the data set. This could introduce misleading results for further analysis. For example, if we identify variables with significant effect with alpha=5%, we would expect about 8 'significant' features as false positive. In order to deal with it, we conduct a PCA to combine similar features.\n", - "\n", - "All variables are normalized between [0, 1] before PCA. The explained variance vs number of principle components are plotted. We choose 15 components for further analysis as the curve starts to be flat after that." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "x110wqrEblxH", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 279 - }, - "outputId": "4f95f39c-0194-47e2-b194-dfe8294606db" - }, - "source": [ - "features_norm = features_updated.apply(norm_by_range)\n", - "\n", - "pca_full = PCA(n_components=40).fit(features_norm)\n", - "pca_var = pd.Series(pca_full.explained_variance_ratio_, \n", - " index=range(1, 41), name='explained_var')\n", - "ax = pca_var.cumsum().plot()\n", - "ax.set_xlabel('pca')\n", - "ax.set_ylabel('cumulative_expained_var')\n", - "\n", - "pca_n = 15\n", - "pca = PCA(n_components=pca_n).fit(features_norm)\n", - "county_pcas = pd.DataFrame(features_norm.dot(pca.components_.transpose()))\n", - "county_pcas.columns = [f'pca_{i}' for i in range(1, pca_n+1)]" - ], - "execution_count": 17, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Gj5zvnKj4aZY", - "colab_type": "text" - }, - "source": [ - "#### How to interpret a PCA component?\n", - "\n", - "A PCA component can be understood as a weighted sum of a list of features. The meaning of the PCA is mainly decided by the few features with highest weights. \n", - "\n", - "For example, the top features with most weights in first PCA component are shown below. You can also visualize it on the U.S. map to have a better understanding of its distribution." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "62evLu0UcIH5", - "colab_type": "code", - "cellView": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 146 - }, - "outputId": "c13c5aed-e6bf-4c2f-8802-4e8b51a8a73b" - }, - "source": [ - "pca_weights = pd.DataFrame(pca.components_,\n", - " index=[f'pca_{i}' for i in range(1, pca_n+1)],\n", - " columns=features_norm.columns)\n", - "\n", - "def get_top_features(compo_weights, top_n=3):\n", - " \"\"\"Gets top features for a component from its weight.\n", - "\n", - " Args:\n", - " compo_weights: A series containing features weights of a component, indexed\n", - " by the feature names.\n", - " top_n: Show the top_n features of the component.\n", - "\n", - " Returns:\n", - " A dataframe with three columns:\n", - " rank: The rank of the feature in the list.\n", - " top_feature: The name of the feature.\n", - " weight: The weight of the feature.\n", - " \"\"\"\n", - " abs_weights = abs(compo_weights)\n", - " top_n_compos = abs_weights.sort_values(ascending=False).index.values[: top_n]\n", - " return pd.DataFrame({\n", - " 'rank': range(1, top_n+1),\n", - " 'top_feature': top_n_compos,\n", - " 'weight': compo_weights[top_n_compos].values},\n", - " index=range(1, top_n+1))\n", - "\n", - "top_compos_df = pd.DataFrame(columns=['pca', 'rank', 'top_feature', 'weight'])\n", - "for i, row in pca_weights.iterrows():\n", - " temp_top_compo = get_top_features(row)\n", - " temp_top_compo['pca'] = i\n", - " top_compos_df = top_compos_df.append(temp_top_compo)\n", - "top_copos_df = top_compos_df[['pca', 'rank', 'top_feature', 'weight']]\n", - "\n", - "pca_of_interest = 'pca_1'\n", - "top_copos_df.query(f'pca==\"{pca_of_interest}\"')" - ], - "execution_count": 18, - "outputs": [ - { - "output_type": "execute_result", - "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", - "
pcaranktop_featureweight
1pca_11Norm_Count_Person_WhiteAloneNotHispanicOrLatino-0.262586
2pca_12Norm_Count_HousingUnit_OwnerOccupied-0.185548
3pca_13Norm_Count_Household_With2Person-0.185315
\n", - "
" - ], - "text/plain": [ - " pca rank top_feature weight\n", - "1 pca_1 1 Norm_Count_Person_WhiteAloneNotHispanicOrLatino -0.262586\n", - "2 pca_1 2 Norm_Count_HousingUnit_OwnerOccupied -0.185548\n", - "3 pca_1 3 Norm_Count_Household_With2Person -0.185315" - ] - }, - "metadata": { - "tags": [] - }, - "execution_count": 18 - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "Y2C0FikfcSYB", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 542 - }, - "outputId": "d0b41cde-c53c-4a7c-f880-a350cfb4119d" - }, - "source": [ - "show_values_on_map(county_pcas['pca_1'], 'PCA_1 distrubtion', True)" - ], - "execution_count": 19, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "
\n", - "
\n", - "\n", - "" - ] - }, - "metadata": { - "tags": [] - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "buxRzcPTqAm1", - "colab_type": "text" - }, - "source": [ - "### Logistic regression\n", - "\n", - "We use a logistic model to find which PCA components are most correlated with death ratio. We rank the PCA components by their p-values. The smaller p-value indicates stronger relationship between the PCA components and the death ratio.\n", - "\n", - "**Technical details**\n", - "\n", - "The model is specified as:\n", - "$$logit(P(death|positive)) = \\theta X,$$\n", - "where $X$ is the features of interest.\n", - "\n", - "When training the model, each observation is a positive case associated with the corresponding county-level components, and the dependent variable is whether the patient died or not.\n", - "\n" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "Z6lsaBf6eIXH", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 210 - }, - "outputId": "5707a049-82d0-4441-b2fc-ed81c233590c" - }, - "source": [ - "total_case_counts = df_county_joined[case_columns].max(axis=1)\n", - "total_death_counts = df_county_joined[death_columns].max(axis=1)\n", - "\n", - "# recover binary data for logistic regression.\n", - "death_data = pd.DataFrame({'case': total_case_counts,\n", - " 'death': total_death_counts},\n", - " index=total_case_counts.index).dropna()\n", - "death_data = death_data[death_data['case'] >= 10]\n", - "death_data['survival'] = death_data['case'] - death_data['death']\n", - "death_data = death_data.drop('case', axis=1)\n", - "death_data = death_data.clip(lower=0)\n", - "\n", - "def run_logistic_model(death_data, features=county_pcas):\n", - " \"\"\"Fits a logistic model to get feature coefficients.\n", - "\n", - " Args:\n", - " death_data: A dataframe with two columns 'death' and 'survival', indexed by\n", - " county geo IDs.\n", - " features: A dataframe containing the features used for this analysis,\n", - " indexed by county geo IDs.\n", - " \n", - " Returns:\n", - " A list of two objects:\n", - " * A data frame indexed by feature names, containing the corresponding \n", - " p-value and coefficients.\n", - " * The fitted model.\n", - " \"\"\"\n", - " joined_data = features.join(death_data, how='inner')\n", - " X = sm.add_constant(joined_data.drop(['death', 'survival'], axis=1))\n", - " y = joined_data[['death', 'survival']].values\n", - " \n", - " observed_cases = joined_data['death'] + joined_data['survival']\n", - " glm = sm.GLM(y, X, sm.families.Binomial())\n", - " res = glm.fit()\n", - " \n", - " coefs = pd.DataFrame({\n", - " 'p-value': res.pvalues,\n", - " 'coef': res.params}, index=X.columns).sort_values('p-value')\n", - " return coefs, res\n", - "\n", - "logistic_coef, logistic_model = run_logistic_model(death_data, county_pcas)\n", - "logistic_coef.head(5)" - ], - "execution_count": 20, - "outputs": [ - { - "output_type": "execute_result", - "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", - "
p-valuecoef
const0.000000e+00-6.665520
pca_30.000000e+000.730977
pca_60.000000e+00-1.758059
pca_90.000000e+001.882122
pca_51.217416e-172-0.919432
\n", - "
" - ], - "text/plain": [ - " p-value coef\n", - "const 0.000000e+00 -6.665520\n", - "pca_3 0.000000e+00 0.730977\n", - "pca_6 0.000000e+00 -1.758059\n", - "pca_9 0.000000e+00 1.882122\n", - "pca_5 1.217416e-172 -0.919432" - ] - }, - "metadata": { - "tags": [] - }, - "execution_count": 20 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "ImP9qqiImTzX", - "colab_type": "text" - }, - "source": [ - "# Appendix" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "xNObMh_Axsng", - "colab_type": "text" - }, - "source": [ - "## How to load live data set?\n", - "\n", - "You can directly query Data Commons for the latest COVID-19 and covariate data. Note that most covariate sources are not updated as frequently as COVID-19 sources." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "yl2NOcuSmVUu", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 227 - }, - "outputId": "319717f3-3ade-4586-d3b7-4bf314a51dae" - }, - "source": [ - "!pip install datacommons_pandas\n", - "import datacommons_pandas as dc" - ], - "execution_count": 21, - "outputs": [ - { - "output_type": "stream", - "text": [ - "Collecting datacommons_pandas\n", - "\u001b[?25l Downloading https://files.pythonhosted.org/packages/a1/94/6a826e6c175e93be81168ef5d29a30b27e490f3fbc0e900e0b848aaf709b/datacommons_pandas-0.0.2-py3-none-any.whl (75kB)\n", - "\r\u001b[K |████▍ | 10kB 15.9MB/s eta 0:00:01\r\u001b[K |████████▊ | 20kB 1.5MB/s eta 0:00:01\r\u001b[K |█████████████ | 30kB 2.0MB/s eta 0:00:01\r\u001b[K |█████████████████▍ | 40kB 1.6MB/s eta 0:00:01\r\u001b[K |█████████████████████▊ | 51kB 1.9MB/s eta 0:00:01\r\u001b[K |██████████████████████████ | 61kB 2.1MB/s eta 0:00:01\r\u001b[K |██████████████████████████████▍ | 71kB 2.2MB/s eta 0:00:01\r\u001b[K |████████████████████████████████| 81kB 1.9MB/s \n", - "\u001b[?25hRequirement already satisfied: six in /usr/local/lib/python3.6/dist-packages (from datacommons_pandas) (1.15.0)\n", - "Requirement already satisfied: pandas in /usr/local/lib/python3.6/dist-packages (from datacommons_pandas) (1.0.5)\n", - "Requirement already satisfied: numpy>=1.13.3 in /usr/local/lib/python3.6/dist-packages (from pandas->datacommons_pandas) (1.18.5)\n", - "Requirement already satisfied: python-dateutil>=2.6.1 in /usr/local/lib/python3.6/dist-packages (from pandas->datacommons_pandas) (2.8.1)\n", - "Requirement already satisfied: pytz>=2017.2 in /usr/local/lib/python3.6/dist-packages (from pandas->datacommons_pandas) (2018.9)\n", - "Installing collected packages: datacommons-pandas\n", - "Successfully installed datacommons-pandas-0.0.2\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "k4d8TnH5srHp", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 310 - }, - "outputId": "e6001b0c-1b25-4363-8a48-69cf9790e048" - }, - "source": [ - "# COVID-19 cases and deaths for state and county.\n", - "df_state_positive = dc.build_time_series_dataframe(df_state_context['State'], 'CumulativeCount_MedicalTest_ConditionCOVID_19_Positive', desc_col=True)\n", - "df_state_deaths = dc.build_time_series_dataframe(df_state_context['State'], 'CumulativeCount_MedicalConditionIncident_COVID_19_PatientDeceased', desc_col=True)\n", - "\n", - "df_county_positive = dc.build_time_series_dataframe(df_county_context['County'], 'CumulativeCount_MedicalTest_ConditionCOVID_19_Positive', desc_col=True)\n", - "df_county_deaths = dc.build_time_series_dataframe(df_county_context['County'], 'CumulativeCount_MedicalConditionIncident_COVID_19_PatientDeceased', desc_col=True)\n", - "\n", - "df_county_deaths.head()" - ], - "execution_count": 29, - "outputs": [ - { - "output_type": "execute_result", - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
2020-09-162020-09-152020-09-142020-09-132020-09-122020-09-112020-09-102020-09-092020-09-082020-09-072020-09-062020-09-052020-09-042020-09-032020-09-022020-09-012020-08-312020-08-302020-08-292020-08-282020-08-272020-08-262020-08-252020-08-242020-08-232020-08-222020-08-212020-08-202020-08-192020-08-182020-08-172020-08-162020-08-152020-08-142020-08-132020-08-122020-08-112020-08-102020-08-092020-08-08...2020-02-292020-02-282020-02-272020-02-262020-02-252020-02-242020-02-232020-02-222020-02-212020-02-202020-02-192020-02-182020-02-172020-02-162020-02-152020-02-142020-02-132020-02-122020-02-112020-02-102020-02-092020-02-082020-02-072020-02-062020-02-052020-02-042020-02-032020-02-022020-02-012020-01-312020-01-302020-01-292020-01-282020-01-272020-01-262020-01-252020-01-242020-01-232020-01-222020-01-21
place
geoId/010012424242424242424.024.024.024.024.024.024.024.024.023.023.023.023.023.023.023.023.023.023.023.023.023.023.023.023.023.023.023.023.023.022.022.022.0...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
geoId/010034747474747474646.046.046.046.046.046.044.042.042.042.040.040.039.037.036.035.035.035.035.035.034.033.033.032.032.032.032.032.032.032.028.027.026.0...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
geoId/0100577777777.07.07.07.07.07.07.07.07.07.07.07.07.07.07.07.07.07.07.07.07.07.06.06.06.06.06.06.06.06.05.05.05.0...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
geoId/0100799999999.09.09.09.09.09.08.08.08.08.07.07.06.06.06.06.06.06.06.06.06.06.06.06.06.06.06.06.06.06.05.05.05.0...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
geoId/010091313131313121212.012.012.012.012.012.011.011.011.011.010.09.09.07.07.06.06.06.06.06.05.05.05.05.05.05.05.05.05.05.04.04.04.0...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
\n", - "

5 rows × 240 columns

\n", - "
" - ], - "text/plain": [ - " 2020-09-16 2020-09-15 ... 2020-01-22 2020-01-21\n", - "place ... \n", - "geoId/01001 24 24 ... NaN NaN\n", - "geoId/01003 47 47 ... NaN NaN\n", - "geoId/01005 7 7 ... NaN NaN\n", - "geoId/01007 9 9 ... NaN NaN\n", - "geoId/01009 13 13 ... NaN NaN\n", - "\n", - "[5 rows x 240 columns]" - ] - }, - "metadata": { - "tags": [] - }, - "execution_count": 29 - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "jcbbIGjXsyAO", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 292 - }, - "outputId": "a9d93aad-9804-4baf-9d22-6d591ac68043" - }, - "source": [ - "# State covariates\n", - "df_state = dc.build_multivariate_dataframe(df_state_context['State'], df_state_context.columns[2:])\n", - "df_state.head()" - ], - "execution_count": 23, - "outputs": [ - { - "output_type": "execute_result", - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Count_Person_BlackOrAfricanAmericanAloneOrInCombinationWithOneOrMoreOtherRacesCount_Person_InLaborForceCount_Person_IncomeOf75000OrMoreUSDollarCount_Person_EducationalAttainmentBachelorsDegreeMedian_Income_Household_HouseholderRaceSomeOtherRaceAloneMedian_Income_PersonCount_Person_TwoOrMoreRacesCount_Person_WhiteAloneNotHispanicOrLatinoCount_Person_UnemployedCount_Person_IncomeOf25000To34999USDollarCount_Person_NotEnrolledInSchoolCount_Person_NowMarriedCount_UnemploymentInsuranceClaim_ShortTimeCompensation_ScaledForPartTimeUnemploymentBenefitsCount_Household_NoComputerCount_Household_With2AvailableVehiclesCount_HousingUnit_IncompletePlumbingFacilities_OccupiedHousingUnitCount_Person_EducationalAttainment11ThGradeCount_Person_AsianAloneCount_Person_IncomeOf35000To49999USDollarCount_Person_SeparatedCount_UnemploymentInsuranceClaim_UCXOnlyMedian_Income_Household_HouseholderRaceBlackOrAfricanAmericanAloneRetailDrugDistribution_DrugDistribution_CodeineCount_Person_Upto18YearsCount_Person_WorkedFullTimeCount_Person_ResidesInGroupQuartersCount_Person_WidowedMedian_Income_Household_HouseholderRaceHispanicOrLatinoCount_HousingUnitCount_Worker_NAICSRealEstateRentalLeasingCount_Person_ForeignBornCount_Person_EducationalAttainment8ThGradeCount_Worker_NAICSConstructionCount_Worker_NAICSHealthCareSocialAssistanceCount_Person_IncomeOf50000To64999USDollarCount_Person_EducationalAttainment6ThGradeCount_Death_DiseasesOfBloodAndBloodFormingOrgansAndImmuneDisordersCount_Death_65To74YearsCount_Household_MarriedCoupleFamilyHouseholdCount_Person_AmericanIndianAndAlaskaNativeAloneOrInCombinationWithOneOrMoreOtherRaces...Count_UnemploymentInsuranceClaim_ShortTimeCompensationCount_Person_SomeOtherRaceAloneCount_Person_VeteranCount_Person_EducationalAttainment1StGradeCount_Person_EducationalAttainmentKindergartenCount_Person_AbovePovertyLevelInThePast12MonthsPercent_Person_Upto64Years_NoHealthInsuranceCount_Death_1To4YearsCount_Household_NoInternetAccessCount_Household_With3PersonCount_Establishment_NAICSGoodsProducingCount_Person_EnrolledInGrade1ToGrade4Count_Household_With0AvailableVehiclesCount_Person_AmericanIndianAndAlaskaNativeAloneCount_Person_IncomeOf10000To14999USDollarCount_Person_EducationalAttainmentBachelorsDegreeOrHigherMedian_Age_PersonCount_Death_25To34YearsCount_Death_85YearsCount_Household_FamilyHouseholdCount_Worker_NAICSManagementOfCompaniesEnterprisesCount_Establishment_NAICSInformationCount_Person_NotAUSCitizenCount_Person_NonveteranCount_Person_EnrolledInCollegeUndergraduateYearsCount_Person_EducationalAttainment3RdGradeCount_Person_EducationalAttainmentDoctorateDegreeCount_Person_DivorcedCount_Death_55To64YearsCount_Worker_NAICSNonclassifiableCount_Worker_NAICSServiceProvidingCount_Person_MaleCount_Person_EnrolledInSchoolCount_Person_GraduateOrProfessionalSchoolCount_Person_EducationalAttainment12ThGradeNoDiplomaCount_Person_EducationalAttainment7ThGradeCount_Person_EducationalAttainmentMastersDegreeCount_Person_EducationalAttainmentSomeCollegeLessThan1YearRetailDrugDistribution_DrugDistribution_AnabolicSteroidsRetailDrugDistribution_DrugDistribution_Heroin
place
geoId/0113348932231116389487.05154433518125375916193196730176637441491.03510836997750030897368705967979775864609453527.093182.0783218851998.541098793866765118799278504.038314224446224104168111.04435694679220319312302.02139276.011208.088338661432...070055335599801496391280811.019.04166692957311788624619211536025576395135.082259538.91016.013033.01229905161092385105024.03417733257248530434881485226.08095.03.0125271223557991182234509576097622023221842199534NaNNaN
geoId/0236217340749109758.0880536734833413624614507543966262032.0519136143272016864964211043073904655671602.010188.062582096214.241861381461102739921802.066283315386443657399.03617147974810756305.0147312.0861.0125847145816...01102767452406664280914.8NaN31017410003672404962395910666040294.013964534.0175.0723.0167633270739324617.046779235996642529267546.0709.0193.01971693855791871429987556111263679435716NaNNaN
geoId/043901813562146655175.083512043471288152528833825886377307654157.04929111136060610472552379586861627095350228887693220.096755.02524531073062.8616337831250194156005311369.045610297093557732933152.068009175526401651450732.065142133.011439.01200133391620...44374718234876843815896569679312.175.037097135725320636366621160011309580468919.0133807137.41337.016821.01648126308003874538326.048068843976861372457317688267.07215.0740.0218976534534391764220793099667615961362611352036NaNNaN
geoId/054883641304752198214.0288720385892497775852217384992133295901.0214059462679237618274344420658315799043988291480.056486.0473075870238.2470594353568884212165379.039787136204014020142480.03042053087176323181499.01775814.06881.055886756532...18827898120257254438323926669.310.0269399179694127191577027361920037250357.045162137.9429.08255.076481634300134296818.02077852152073484819967313719.04737.00.07993191468412737199279963291912708115355136060NaNNaN
geoId/062753574188040375309629.05445781528003079718822271469583625101033113504.02722914876705785760107937148389805739748159456043393189114.0650108.0271149334449781.76907365574545258194791572902.0550841408482430959410537529.031009388714424419412431787.0769722638.048020.06437416757628...25042541541016188613624610025329202628.2229.01586892216179614958819456879390342964752799154.0871873736.35119.091354.08915228254164296065184310.02832850026832031720734224282953748.034134.03147.012719875194537691046881252586668063412453922226361498152NaNNaN
\n", - "

5 rows × 187 columns

\n", - "
" - ], - "text/plain": [ - " Count_Person_BlackOrAfricanAmericanAloneOrInCombinationWithOneOrMoreOtherRaces ... RetailDrugDistribution_DrugDistribution_Heroin\n", - "place ... \n", - "geoId/01 1334893 ... NaN\n", - "geoId/02 36217 ... NaN\n", - "geoId/04 390181 ... NaN\n", - "geoId/05 488364 ... NaN\n", - "geoId/06 2753574 ... NaN\n", - "\n", - "[5 rows x 187 columns]" - ] - }, - "metadata": { - "tags": [] - }, - "execution_count": 23 - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "zUowxx6nsxxA", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 292 - }, - "outputId": "b0b80270-0778-4556-90a4-8ffd38a5ea9a" - }, - "source": [ - "# County covariates (this query takes a while: ~3000 counties for 200 variables)\n", - "df_county = dc.build_multivariate_dataframe(df_county_context['County'], df_county_context.columns[2:])\n", - "df_county.head()" - ], - "execution_count": 24, - "outputs": [ - { - "output_type": "execute_result", - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Count_Household_NoInternetAccessCount_Person_NotEnrolledInSchoolCount_Person_EducationalAttainment12ThGradeNoDiplomaCount_Person_EducationalAttainmentPrimarySchoolCount_Person_EducationalAttainmentSomeCollege1OrMoreYearsNoDegreeCount_Person_75OrMoreYearsCount_Person_EmployedCount_Person_BelowPovertyLevelInThePast12MonthsMedian_Age_PersonPercent_Person_Upto64Years_NoHealthInsuranceMedian_Income_Household_HouseholderRaceHispanicOrLatinoMedian_Cost_HousingUnit_OccupiedHousingUnit_OwnerOccupied_SelectedMonthlyOwnerCostsCount_Person_MaleCount_Person_SomeOtherRaceAloneOrInCombinationWithOneOrMoreOtherRacesCount_Person_EducationalAttainment10ThGradePercent_Person_20OrMoreYears_ObesityCount_Worker_NAICSTotalAllIndustriesCount_Person_ForeignBornCount_Person_EnrolledInGrade1ToGrade4Count_Person_NeverMarriedCount_Establishment_NAICSHealthCareSocialAssistanceMedian_HomeValue_HousingUnit_OccupiedHousingUnit_OwnerOccupiedCount_EstablishmentCount_Worker_NAICSPublicAdministrationRetailDrugDistribution_DrugDistribution_CodeineCount_Person_NativeHawaiianOrOtherPacificIslanderAloneCount_Death_25To34YearsCount_HousingUnit_RenterOccupiedCount_Person_BlackOrAfricanAmericanAloneOrInCombinationWithOneOrMoreOtherRacesCount_Person_IncomeOf15000To24999USDollarCount_Worker_NAICSArtsEntertainmentRecreationCount_Worker_NAICSGoodsProducingCount_HousingUnitCount_Person_BlackOrAfricanAmericanAloneCount_Person_EnrolledInNurserySchoolPreschoolCount_Person_EducationalAttainment9ThGradeCount_Person_WidowedCount_Establishment_NAICSAccommodationFoodServicesCount_Establishment_NAICSInformationCount_Person_IncomeOf65000To74999USDollar...RetailDrugDistribution_DrugDistribution_AmphetamineCount_Household_With2AvailableVehiclesCount_Person_HispanicOrLatinoCount_Person_Upto5YearsCount_Person_IncomeOf25000To34999USDollarCount_Person_EducationalAttainment2NdGradeCount_MedicareEnrolleeCount_Worker_NAICSProfessionalScientificTechnicalServicesCount_Person_AsianAloneCount_Person_EducationalAttainment6ThGradeCount_Death_85YearsUnemploymentRate_PersonCount_Person_EducationalAttainmentBachelorsDegreeCount_Person_EducationalAttainmentNurserySchoolCount_Household_With1AvailableVehiclesCount_Worker_NAICSInformationCount_Person_EducationalAttainmentSomeCollegeLessThan1YearCount_Household_OtherFamilyHouseholdCount_Person_AmericanIndianOrAlaskaNativeAloneCount_Household_With3PersonCount_Person_AmericanIndianAndAlaskaNativeAloneOrInCombinationWithOneOrMoreOtherRacesCount_HousingUnit_OwnerOccupiedCount_Worker_NAICSAccommodationFoodServicesCount_Worker_NAICSManagementOfCompaniesEnterprisesMedian_Income_Household_HouseholderRaceSomeOtherRaceAloneCount_Establishment_NAICSRetailTradeCount_Person_WhiteAloneNotHispanicOrLatinoCount_Person_NonveteranCount_Person_EducationalAttainment7ThGradeCount_Death_15To24YearsCount_Worker_NAICSHealthCareSocialAssistanceMedian_Income_Household_HouseholderRaceAmericanIndianOrAlaskaNativeAloneCount_Worker_NAICSMiningQuarryingOilGasExtractionCount_Death_DiseasesOfBloodAndBloodFormingOrgansAndImmuneDisordersCount_Worker_NAICSNonclassifiableMedian_Income_Household_HouseholderRaceNativeHawaiianOrOtherPacificIslanderAloneCount_Death_1To4YearsCount_Death_5To14YearsRetailDrugDistribution_DrugDistribution_AnabolicSteroidsRetailDrugDistribution_DrugDistribution_Heroin
place
geoId/010014018.039826.0667.00.0000015319.03339.023450.08422.037.88.783423.0877.026874.0427.0892.033.28766.01114.03009.011192.095.0147900.0851.0191.0626.6532.013.05301.010962.06267.0306.02388.023315.010565.0488.0840.02467.097.06.01436.0...1266.238161.01528.03263.04398.00.04767.0260.0568.0122.0103.06.65903.00.05988.025.02235.03173.0159.03386.0464.015814.01269.063.089423.0168.041412.036213.0108.011.01063.040658.082.0NaNNaNNaNNaNNaNNaNNaN
geoId/0100313235.0156873.02264.046.00000022336.016114.091103.021653.042.811.343279.0912.0101188.02648.03314.031.165560.07170.09861.042192.0497.0189800.05235.03236.02090.629.022.020741.020311.025871.01807.09291.0111945.019764.02857.02012.012711.0535.082.05535.0...6292.6133259.09353.011609.022030.00.023735.02239.01680.0515.0631.07.330431.014.025764.0407.09930.09907.01522.09983.03185.057881.012893.0296.045634.0990.0172768.0142768.0343.026.09573.053289.072.013.00.0NaNNaNNaNNaNNaN
geoId/010053133.019738.0575.00.0000012030.01814.08062.06597.039.912.230417.0526.013697.0800.0913.041.76772.0646.01106.07337.043.092900.0452.0328.0305.521.010.03546.012492.03283.045.03020.011937.012266.0278.0789.01789.051.04.0343.0...642.222930.01106.01390.02178.042.02945.07.096.0112.068.08.91417.04.03275.016.01257.02122.072.01311.0301.05640.0734.012.026793.088.011898.018785.0250.010.07.0NaN142.0NaNNaNNaNNaNNaNNaNNaN
geoId/010072000.017371.0141.018.0000002186.01539.07835.02863.039.910.242708.0501.012152.09.0490.037.73546.0325.0922.06020.026.096500.0290.0180.0300.200.010.01705.05117.03235.09.01606.09161.05018.0136.0440.01623.017.04.0704.0...785.582338.0547.01275.01902.00.01802.067.037.0163.042.08.61197.00.01968.016.0752.01321.08.01115.090.05135.0176.055.0NaN52.016801.016590.0127.0NaN389.020724.0NaNNaNNaNNaNNaNNaNNaNNaN
geoId/010095634.043649.0808.02.0000005648.04101.023044.08220.040.813.435495.0609.028434.0479.01689.033.76545.02513.03064.09543.058.0124700.0675.0442.0677.3718.017.04403.01124.06795.052.02044.024222.0862.0448.01166.03678.040.011.01555.0...1832.377332.05261.03485.05630.050.05174.0225.0198.0834.0143.05.73217.012.05421.057.02844.03162.0141.03234.0714.016197.0763.019.030500.0128.050232.040361.0228.013.0938.065385.015.0NaNNaNNaNNaNNaNNaNNaN
\n", - "

5 rows × 177 columns

\n", - "
" - ], - "text/plain": [ - " Count_Household_NoInternetAccess ... RetailDrugDistribution_DrugDistribution_Heroin\n", - "place ... \n", - "geoId/01001 4018.0 ... NaN\n", - "geoId/01003 13235.0 ... NaN\n", - "geoId/01005 3133.0 ... NaN\n", - "geoId/01007 2000.0 ... NaN\n", - "geoId/01009 5634.0 ... NaN\n", - "\n", - "[5 rows x 177 columns]" - ] - }, - "metadata": { - "tags": [] - }, - "execution_count": 24 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "U0eXxDRRpBE1", - "colab_type": "text" - }, - "source": [ - "## Decide cluster number in trend analysis\n", - "\n", - "We will use a k-means algorithm to cluster the counties by their incremental case trends. \n", - "\n", - "The first step is to decide the proper number of clusters. In order to do that, we utilize within-cluster sum of squares and Silhouette average.\n", - "\n", - "Looking at the Silhouette average, we see that it has highest value at 2. However, if we proceed with a small cluster number less than 5, we will see that the model only separates some of the outliers. \n", - "\n", - "The 1-step difference of within-cluster sum of squres is very helpful in finding the elbow point of the within-cluster SS curve: starting from step 10, the 1-step diffs are very small. This suggests that 9 may be a good choice of cluster number." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "Il3SwBemPca3", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 573 - }, - "outputId": "9bb389b5-8691-476b-b9bf-29ed9c07a987" - }, - "source": [ - "def find_proper_n_cluster(incremental_trend_df, max_clusters=30, \n", - " min_clusters=2, random_seed=42, **kmeans_kwargs):\n", - " \"\"\"Finds the proper number of K-Means clusters.\n", - " \n", - " This functions doesn't automatically find the best number of clusters, but\n", - " only shows plots of within-cluster sum of squares and Silhuette averages to\n", - " help decide the cluster number.\n", - "\n", - " Args:\n", - " incremental_trend_df: A dataframe containing incremental trends generated\n", - " from the function 'obtain_incremental_trend'.\n", - " max_clusters: The maximal number of clusters we want to check.\n", - " min_clusters: The minimal number of clusters we want to check.\n", - " random_seed: A random seed to fix the k-means algorithm results.\n", - " **kmeans_kw: Named arguments passed to the KMeans fucntion at each step.\n", - "\n", - " Returns:\n", - " Two dataframes are returned. They contain within-cluster sum of squares and \n", - " Silhouette averages at each choice of cluster number respectively.\n", - " \"\"\"\n", - " np.random.seed(random_seed)\n", - " cluster_data_df = incremental_trend_df.transpose()\n", - " ss = []\n", - " silhouette_avgs = []\n", - " num_cluster_choices = range(min_clusters, max_clusters + 1)\n", - " for nc in num_cluster_choices:\n", - " temp_km = KMeans(n_clusters=nc,\n", - " random_state=np.random.randint(0, 1e5),\n", - " **kmeans_kwargs).fit(cluster_data_df)\n", - " temp_ss = temp_km.inertia_\n", - " temp_labels = temp_km.predict(cluster_data_df)\n", - " temp_sa = silhouette_score(cluster_data_df, temp_labels)\n", - " ss.append(temp_ss)\n", - " silhouette_avgs.append(temp_sa)\n", - " ss = pd.Series(ss, index=num_cluster_choices)\n", - " silhouette_avgs = pd.Series(silhouette_avgs, index=num_cluster_choices)\n", - " fig, ax = plt.subplots(ncols=2, figsize=(13, 4.5))\n", - " ax = ax.flatten()\n", - " ss.plot(title='plot of within-cluster sum of squares', ax=ax[0])\n", - " (-ss.diff()).plot(title='plot of 1-step diff of within-cluster SS', ax=ax[1])\n", - " fig = plt.figure()\n", - " silhouette_avgs.plot(title='plot of silhouette scores')\n", - " return ss, silhouette_avgs\n", - "\n", - "ss, sa = find_proper_n_cluster(case_incremental_trends, n_init=50)" - ], - "execution_count": 25, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "CX_QRLqBxz4v", - "colab_type": "text" - }, - "source": [ - "## What if we specify more clusters in the trend clustering analysis?\n", - "\n", - "You may wonder what happens if we specify more than 9 clusters in the trend cluster analysis. We try to answer that question here.\n", - "\n", - "By looking at the plot about '1-step diff of within-cluster SS' (here), we see that there is a relatively steep drop between step 14 and step 15. Hence we choose 14 as the number of clusters for our analysis in this part.\n", - "\n", - "The trends of the clusters are shown below. \n", - "\n", - "* The patterns of the largest three clusters are bascially the same as they in the 9-cluster result. \n", - "* The main difference between the two versions is that 'cluster_0' has 400 less counties in this 14-cluster result. Some of these counties are contributing to exsiting clusters, like cluster_1 or cluster_2, and some others are forming up new clusters.\n", - "* Some clusters in the 14-cluster result share similar patterns, for example cluster_1 and cluster_3 are both counties with increasing trends, while cluster_3 is slightly more severe.\n", - "* The 14-cluster result has more small groups containing less than 5 counties.\n", - "\n", - "Based on these observations, the 9-cluster result is preferred as it is granular enough and easy to interpret." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "oCHbvb2ppAqC", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 493 - }, - "outputId": "f8944b62-beb0-461d-a894-cd8328c8f735" - }, - "source": [ - "case_cluster_labels_detailed = get_cluster_labels(case_incremental_trends, 14,\n", - " random_state=42, n_init=1000)\n", - "median_case_trends = plot_cluster_medians(case_incremental_trends, \n", - " case_cluster_labels_detailed,\n", - " ylim=[0,0.002])" - ], - "execution_count": 26, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - } - ] - } - ] -} \ No newline at end of file diff --git a/notebooks/Estimating_(Temperature)_Distributions_With_DataCommons_.ipynb b/notebooks/Estimating_(Temperature)_Distributions_With_DataCommons_.ipynb new file mode 100644 index 00000000..0689ac54 --- /dev/null +++ b/notebooks/Estimating_(Temperature)_Distributions_With_DataCommons_.ipynb @@ -0,0 +1,919 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "collapsed_sections": [ + "XQfQekexygxn", + "oXfNxahXzCXH", + "xySpvIoAYT1m", + "BX_FwVZ82DV5", + "1VEx6Zm84-0W" + ] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Preamble\n", + "This work was done in collaboration with Prof. Aditi Sheshadri's research group at Stanford University.\n", + "\n", + "**Context**\n", + "\n", + " The climate at a specific location (as recorded by observations) can be seen as a sample from a \"real\" probability distribution function (PDF). We have a number of climate models, from many agencies across the world, that use physics to approximate this underlying PDF. Each simulation run of each of these models can be seen as a sample from the PDF embodied by the code in that model.\n", + "\n", + " Some agencies publish the results of multiple simulation runs for their models while others publish a single set of predictions (from either a single simulation or an aggregation of multiple simulations).\n", + "\n", + " Each model defines a set of polygons covering the earth. Results are typically hourly predictions (over the next several decades, starting from 10-20 years ago), for a number of variables (such as the maximum and minimum temperatures, precipitation) for each of the polygons. The polygons are typically 100km x 100km or 0.5arc degree S2 cells. Combining results from different models is complicated by the differences in these geometries. Further, the large size of these polygons means that it is difficult to make predictions about most cities and counties, which are much smaller. Fortunately, NASA produces downscaled, normalized versions of the outputs of the most well regarded models. We use these downscaled models for our analysis.\n", + "\n", + " Models also tend to have a bias, i.e., they either over or under estimate the temperature. Since the models typically start their prediction at some time in the past (e.g., 2005), the differences between observed and predicted values can be used to estimate and compensate for these biases. The NASA downscaled data incorporates this bias correction.\n", + "\n", + " We would like to answer the following class of questions: given a place (typically an administrative area), what is the highest / lowest temperature that is likely to be reached, for some period of time (e.g., one day), during some period of time (e.g., 2024 or 2030-2040) with X% likelihood (for X=1% and X=5%). To answer these questions, we first reconstruct the PDF of the variable (highest or lowest temperature) in question and then answer the question by sampling from this PDF.\n", + "\n", + " Consider the case of estimating the highest temperature $T$ on a single day, in a single given year, with a likelihood of $X$%. To do this, we\n", + " 1. construct the PDF of daily highest temperature.\n", + " 2. pick a $T$. Let the cumulative probability of the highest temperature being less than $T$ on a randomly chosen day be $p$.\n", + " 3. We compute the probability of the temperature being less than $T$ on every day of that year. We iterate on $T$ till we find a $T$ where this probability is $1-X$.\n", + "\n", + "\n", + " **Constructing the PDF**\n", + "\n", + " We have some number of models (see below for the list of models we use in this analysis) and for each we have a table of maximum temperature and date. From this, we construct the PDF. We try the following approaches.\n", + " 1. We quantize the temperature into $1^oC$ ranges and build the histogram of temperatures vs the number of days where that is the highest temperature. The probability of the highest temperature being $T$ can be read off this histogram. This is a very conservative approach, where the temperatures are bound to within the range of predictions for that year. Given that the table from the model itself is just an estimate, the actual highest temperature could indeed be higher than what is in the table. The next approach tries to do this.\n", + " 2. We can fit a distribution to the points in the table. We experiment with Gaussian, Gamma, and mixture of Gaussians. We notice that the problem with simple Gaussian and Gamma is that while they do predict much higher temperatures, they are not aware of physical limits (e.g., they assign a non-zero probability to the temperature exceeding $100^oC$). So, as the time period (over which the prediction is done) gets longer, the probability of much more extreme events goes up, well into unrealistic territory. We notice that mixture of Gaussians does have more realistic behaviour.\n", + "\n", + " The purpose of this exercise is to enable planning for extreme weather events. We notice that even with the most conservative histogram based approach, there are likely to be days, in the next decade, where the temperature exceeds $50^oC$, a dangerous threshold.\n", + "\n", + " **Independence**\n", + "\n", + " Let the cumulative probability of the temperature being less than $T$ on a randomly chosen day be $p$. If the temperatures on different days were indepdentent of each other, the probability of the peak temperature exceeding $T$ on at least one day in the year would simply be $(1 - p^{N})$, where $N=365$. However, the temperature on consecutive days are not independent of each other. In this analysis, we approximately capture this by using a lower $N$. For example, if we can assume that the temperatures on days 7 or more days apart are independent, we can use $N=52$." + ], + "metadata": { + "id": "2mLV1WsYJ5PW" + } + }, + { + "cell_type": "markdown", + "source": [ + "# Setup" + ], + "metadata": { + "id": "XQfQekexygxn" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Imports" + ], + "metadata": { + "id": "w2JnB_1iymIx" + } + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import datetime\n", + "from IPython.display import display\n", + "from ipywidgets import Box\n", + "import ipywidgets as widgets\n", + "from matplotlib import pyplot as plt\n", + "from sklearn.mixture import GaussianMixture as GMM\n", + "import warnings\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import scipy.stats as stats\n", + "from scipy.interpolate import interp1d\n", + "from sklearn.mixture import GaussianMixture as GMM\n", + "\n", + "from pydrive.auth import GoogleAuth\n", + "from pydrive.drive import GoogleDrive\n", + "from google.colab import auth\n", + "from oauth2client.client import GoogleCredentials\n", + "\n", + "# Authenticate and create the PyDrive client.\n", + "auth.authenticate_user()\n", + "gauth = GoogleAuth()\n", + "gauth.credentials = GoogleCredentials.get_application_default()\n", + "drive = GoogleDrive(gauth)\n" + ], + "metadata": { + "id": "yA9qvF2Vylao" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "MIN_TEMP_C = -100\n", + "MAX_TEMP_C = 120" + ], + "metadata": { + "id": "476GscrIce7Z" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## General Helper Functions" + ], + "metadata": { + "id": "oXfNxahXzCXH" + } + }, + { + "cell_type": "code", + "source": [ + "def convert_to_kelvins(val_c):\n", + " return val_c + 273.15\n", + "\n", + "def convert_to_celsius(val_k):\n", + " return val_k - 273.15" + ], + "metadata": { + "id": "pV0wsQdIzEf3" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Data Extracts Retrieval" + ], + "metadata": { + "id": "xySpvIoAYT1m" + } + }, + { + "cell_type": "code", + "source": [ + "def get_data_extract(file_id):\n", + " downloaded = drive.CreateFile({'id':file_id})\n", + " downloaded.FetchMetadata(fetch_all=True)\n", + " downloaded.GetContentFile(downloaded.metadata['title'])\n", + " return pd.read_csv(downloaded.metadata['title'], keep_default_na=False)" + ], + "metadata": { + "id": "971ZLMqaYWc_" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Computing Probabilities - Helpers" + ], + "metadata": { + "id": "BX_FwVZ82DV5" + } + }, + { + "cell_type": "code", + "source": [ + "def gmm_choose_best_num_mixture(obs):\n", + " opt_bic = None\n", + " min_bic = 0\n", + " counter=1\n", + " for i in range (1, 5, 1): # test the AIC/BIC metric between 1 and 10 components\n", + " gmm = GMM(n_components = i, max_iter=1000, random_state=0, covariance_type = 'full')\n", + " gmm.fit(obs).predict(obs)\n", + " bic = gmm.bic(obs)\n", + " if bic < min_bic or min_bic == 0:\n", + " min_bic = bic\n", + " opt_bic = i\n", + "\n", + " return opt_bic" + ], + "metadata": { + "id": "ElsydGcc2o-t" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def fit_dist(df_subset, dist_type):\n", + " obs_list = df_subset[\"value\"].tolist()\n", + " params = []\n", + "\n", + " if dist_type == \"Gamma\":\n", + " params = stats.gamma.fit(obs_list)\n", + " elif dist_type == \"Gaussian\":\n", + " params = stats.norm.fit(obs_list)\n", + " elif dist_type == \"GaussianMixture\":\n", + " obs= np.array(obs_list)\n", + " obs = obs.reshape(-1, 1)\n", + " best_num_mixture = gmm_choose_best_num_mixture(obs)\n", + " # print(f\"Best GMM mixture has {best_num_mixture} components.\")\n", + " gmm = GMM(n_components = best_num_mixture, max_iter=2000, random_state=0, covariance_type = 'full')\n", + " params = gmm.fit(obs)\n", + " elif dist_type == \"Histogram\":\n", + " return []\n", + "\n", + " return params" + ], + "metadata": { + "id": "1wLNOYh02IMt" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def generate_smooth_pdf(x_min, x_max, dist_type, params):\n", + " y = []\n", + "\n", + " bins = []\n", + " for b in range(x_min, x_max):\n", + " bins.append(b)\n", + "\n", + " if dist_type == \"Gamma\":\n", + " shape = params[0]\n", + " loc = params[1]\n", + " scale = params[2]\n", + " y = stats.gamma.pdf(bins, shape, loc, scale)\n", + " elif dist_type == \"Gaussian\":\n", + " loc = params[0]\n", + " scale = params[1]\n", + " y = stats.norm.pdf(bins, loc, scale)\n", + " elif dist_type == \"GaussianMixture\":\n", + " mean = params.means_\n", + " covs = params.covariances_\n", + " weights = params.weights_\n", + "\n", + " num_gaussians = mean.shape[0]\n", + " y = None\n", + " for i in range(num_gaussians):\n", + " y_i = stats.norm.pdf(bins, float(mean[i][0]), np.sqrt(float(covs[i][0][0])))*weights[i] # i-th gaussian\n", + " if y is None:\n", + " y = y_i\n", + " else:\n", + " y += y_i\n", + "\n", + " elif dist_type == \"Histogram\":\n", + " return []\n", + "\n", + " return y" + ], + "metadata": { + "id": "-eAOkeM924bF" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def cdf(x, dist_type, params):\n", + " if dist_type == \"Gamma\":\n", + " shape = params[0]\n", + " loc = params[1]\n", + " scale = params[2]\n", + " return stats.gamma.cdf(x, shape, loc, scale)\n", + " elif dist_type == \"Gaussian\":\n", + " loc = params[0]\n", + " scale = params[1]\n", + " return stats.norm.cdf(x, loc, scale)\n", + " elif dist_type == \"GaussianMixture\":\n", + " means = params.means_\n", + " covs = params.covariances_\n", + " weights = params.weights_\n", + "\n", + " mcdf = 0.0\n", + " for i in range(len(weights)):\n", + " mcdf += weights[i] * stats.norm.cdf(x, loc=means[i][0], scale=np.sqrt(covs[i][0][0])) # i-th gaussian\n", + " return mcdf" + ], + "metadata": { + "id": "05GS_9SS3yCQ" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def compute_histogram_cdf(df_hist_subset):\n", + " sum = 0\n", + " temp2pdf = dict(zip(df_hist_subset['temp'], df_hist_subset['prob']))\n", + " temp2cdf = {}\n", + " for temp in range(int(MIN_TEMP_C), int(MAX_TEMP_C)):\n", + " sum += temp2pdf.get(temp, 0)\n", + " temp2cdf[temp] = sum\n", + " return temp2cdf" + ], + "metadata": { + "id": "AOaNRVgDS2Tf" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def icdf_percent_n(dist_type, temp2cdf_hist, params, var=\"Max_Temperature\", percent=0.01, n=1):\n", + " low = MIN_TEMP_C\n", + " high = MAX_TEMP_C\n", + " mid = int((low + high) / 2.0)\n", + "\n", + " is_max = True\n", + " if \"Min\" in var:\n", + " is_max = False\n", + "\n", + " if dist_type == \"Histogram\":\n", + " curr_cdf = temp2cdf_hist[mid]\n", + " else:\n", + " curr_cdf = cdf(mid, dist_type, params)\n", + "\n", + " if is_max:\n", + " icdf = 1.0 - (curr_cdf**n)\n", + " else:\n", + " icdf = 1.0 - (1.0 - curr_cdf)**n\n", + "\n", + " iter = 0;\n", + " while (abs(icdf - percent) > 0.00025):\n", + " if iter > 500:\n", + " return mid\n", + " if (icdf > percent):\n", + " if is_max:\n", + " low = mid\n", + " else:\n", + " high = mid\n", + " else:\n", + " if is_max:\n", + " high = mid\n", + " else:\n", + " low = mid\n", + "\n", + " mid = int((low + high) / 2.0)\n", + " if dist_type == \"Histogram\":\n", + " curr_cdf = temp2cdf_hist[mid]\n", + " else:\n", + " curr_cdf = cdf(mid, dist_type, params)\n", + "\n", + " if is_max:\n", + " icdf = 1.0 - (curr_cdf**n)\n", + " else:\n", + " icdf = 1.0 - (1.0 - curr_cdf)**n\n", + "\n", + " iter += 1\n", + " return mid" + ], + "metadata": { + "id": "96AIFiQX4RGZ" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Plotting Helpers" + ], + "metadata": { + "id": "52bi_iHT83H5" + } + }, + { + "cell_type": "code", + "source": [ + "def plot_fits(df_subset, df_hist, df_act, county_name, n, year_start, year_end, ssp, model, var):\n", + " dists = [\"NoFitting\", \"Histogram\", \"GaussianMixture\"] #[\"Histogram\", \"Gamma\", \"Gaussian\", \"GaussianMixture\"]\n", + "\n", + " num_rows = len(dists)\n", + " num_cols = 1\n", + " fig, axs = plt.subplots(num_rows, num_cols, sharey=False, sharex=True, tight_layout=True)\n", + " fig.set_size_inches(10*num_cols, 4*num_rows, forward=True)\n", + "\n", + " actual_val_col = \"tmax\"\n", + " is_max = True\n", + " if \"Min\" in var:\n", + " is_max = False\n", + " actual_val_col = \"tmin\"\n", + "\n", + "\n", + " x_min = int(df_subset[\"value\"].min()) - 5\n", + " x_max = int(df_subset[\"value\"].max()) + 20\n", + " x_array = list(range(x_min, x_max))\n", + " for i in range(len(dists)):\n", + " # Generate the bins for the data and show the histogram.\n", + "\n", + " nbins = x_max - x_min\n", + " # If there is no actual data, only plot the CMIP6 model data.\n", + " count, bins, ignored = axs[i].hist(df_subset[\"value\"], nbins, density=True, color='lavender', label=\"CMIP6 Model Data Histogram\")\n", + " if not df_act.empty:\n", + " # If there is actual data, plot two histograms on top of each other. One histogram is represented as dots.\n", + " count_, bins_ = np.histogram(df_act[actual_val_col], nbins, density=True)\n", + " axs[i].scatter(bins_[:-1], count_, s=5, color='gray', label=\"Actual Data Histogram (dots)\")\n", + "\n", + " no_fitting = False\n", + " dist = dists[i]\n", + " if dist == \"NoFitting\":\n", + " # When \"NoFitting\" is chosen, this just means N = 1 for the \"histogram fit\".\n", + " dist = \"Histogram\"\n", + " no_fitting = True\n", + "\n", + " params = fit_dist(df_subset, dist)\n", + "\n", + " # No smoothed_pdf produced for the Histogram fit.\n", + " smoothed_pdf_y = generate_smooth_pdf(x_min, x_max, dist, params)\n", + " if len(smoothed_pdf_y):\n", + " axs[i].plot(x_array, smoothed_pdf_y, linewidth=3, color='r', label=f\"{dist} \\nFitted (to CMIP6 Model Data)\")\n", + "\n", + " # Get the 1% and 5% thresholds.\n", + " temp2cdf_hist = compute_histogram_cdf(df_hist)\n", + "\n", + " if no_fitting:\n", + " n_to_use = 1\n", + " else:\n", + " n_to_use = n\n", + "\n", + " p01 = icdf_percent_n(dist, temp2cdf_hist, params, var=var, percent=0.01, n=n_to_use)\n", + " p05 = icdf_percent_n(dist, temp2cdf_hist, params, var=var, percent=0.05, n=n_to_use)\n", + " p50 = icdf_percent_n(dist, temp2cdf_hist, params, var=var, percent=0.5, n=n_to_use)\n", + " p95 = icdf_percent_n(dist, temp2cdf_hist, params, var=var, percent=0.95, n=n_to_use)\n", + "\n", + " # Add the p01 and p05 lines on the axes.\n", + " axs[i].axvline(p95, linestyle='--', color='limegreen', linewidth=2, label=\"95% threshold = {0}C\".format(p95))\n", + " axs[i].axvline(p50, linestyle='--', color='blue', linewidth=2, label=\"50% threshold = {0}C\".format(p50))\n", + " axs[i].axvline(p05, linestyle='--', color='darkorange', linewidth=2, label=\"5% threshold = {0}C\".format(p05))\n", + " axs[i].axvline(p01, linestyle='--', color='crimson', linewidth=2, label=\"1% threshold = {0}C\".format(p01))\n", + "\n", + "\n", + " # Add labels and title to the plot\n", + " if is_max:\n", + " axs[i].set_xlabel('Max Temperature (in C)')\n", + " else:\n", + " axs[i].set_xlabel('Min Temperature (in C)')\n", + " axs[i].set_ylabel('Probability Density')\n", + "\n", + " if no_fitting:\n", + " axs[i].set_title(f'{model} ({ssp}). No Fitting (N= {n_to_use}). Period: ({year_start}-{year_end}). {county_name}')\n", + " else:\n", + " axs[i].set_title(f'{model} ({ssp}). Fit: {dist} (N= {n_to_use}). Period: ({year_start}-{year_end}). {county_name}')\n", + " if is_max:\n", + " axs[i].legend(loc=\"upper left\")\n", + " else:\n", + " axs[i].legend(loc=\"upper right\")\n", + "\n", + " axs[i].xaxis.set_tick_params(which='both', labelbottom=True)\n", + "\n", + "\n", + " plt.show()" + ], + "metadata": { + "id": "yh4vrJuQ85Jh" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def plot_trends(data_p1d, data_hist, county_dcid, ssp, model, var, n):\n", + " dists = [\"NoFitting\", \"Histogram\", \"GaussianMixture\"] #[\"Histogram\", \"Gamma\", \"Gaussian\", \"GaussianMixture\"]\n", + "\n", + " year_starts = [1980, 1990, 2000, 2020, 2030, 2040]\n", + " colors_y = ['cyan', 'green', 'blue', 'gold', 'orange', 'red']\n", + "\n", + " num_rows = len(dists) + 1\n", + " num_cols = 1\n", + " fig, axs = plt.subplots(num_rows, num_cols, sharey=False, sharex=False, tight_layout=True)\n", + " fig.set_size_inches(8*num_cols, 3*num_rows, forward=True)\n", + "\n", + "\n", + " is_max = True\n", + " if \"Min\" in var:\n", + " is_max = False\n", + "\n", + " df_hist_ext = data_hist[var]\n", + " df_future_ext = data_p1d[(var, \"future\")]\n", + " df_past_ext = data_p1d[(var, \"past\")]\n", + "\n", + " # Filters.\n", + " df_future_ext = df_future_ext[(df_future_ext['scenario'] == ssp) &\n", + " (df_future_ext['county'] == county_dcid)]\n", + " df_past_ext = df_past_ext[(df_past_ext['scenario'] == \"historical\") &\n", + " (df_past_ext['county'] == county_dcid)]\n", + "\n", + " if Model != 'Ensemble':\n", + " df_future_ext = df_future_ext[df_future_ext[\"cmip6_model\"] == model]\n", + " df_past_ext = df_past_ext[df_past_ext[\"cmip6_model\"] == model]\n", + "\n", + " df_hist_past_ext = df_hist_ext[(df_hist_ext['scenario'] == '') &\n", + " (df_hist_ext['county'] == county_dcid) &\n", + " (df_hist_ext['cmip6_model'] == model)]\n", + " df_hist_future_ext = df_hist_ext[(df_hist_ext['scenario'] == ssp) &\n", + " (df_hist_ext['county'] == county_dcid) &\n", + " (df_hist_ext['cmip6_model'] == model)]\n", + "\n", + "\n", + " x_min = min(int(df_future_ext[\"value\"].min()) - 5, int(df_past_ext[\"value\"].min()) - 5)\n", + " x_max = max(int(df_future_ext[\"value\"].max()) + 20, int(df_past_ext[\"value\"].max()) + 20)\n", + " x_array = list(range(x_min, x_max))\n", + " for i in range(len(dists)):\n", + "\n", + " no_fitting = False\n", + " dist = dists[i]\n", + " if dist == \"NoFitting\":\n", + " dist = \"Histogram\"\n", + " no_fitting = True\n", + "\n", + " p95s = []\n", + " p50s = []\n", + " p05s = []\n", + " p01s = []\n", + " fit_params = []\n", + " for y in year_starts:\n", + " y_end = y + 10\n", + "\n", + " # We have two cases: past (prior to 2010) and future (after 2010).\n", + " if y < 2010:\n", + " df_hist_y = df_hist_past_ext[(df_hist_past_ext[\"year\"] >= y) & (df_hist_past_ext[\"year\"] < y_end)]\n", + " df_subset_y = df_past_ext[(df_past_ext[\"year\"] >= y) & (df_past_ext[\"year\"] < y_end)]\n", + " else:\n", + " df_hist_y = df_hist_future_ext[(df_hist_future_ext[\"year\"] >= y) & (df_hist_future_ext[\"year\"] < y_end)]\n", + " df_subset_y = df_future_ext[(df_future_ext[\"year\"] >= y) & (df_future_ext[\"year\"] < y_end)]\n", + "\n", + " if df_hist_y.empty or df_subset_y.empty:\n", + " print(\"No data matched this selection. Please try a different selection.\")\n", + " return\n", + "\n", + " temp2cdf_hist = compute_histogram_cdf(df_hist_y)\n", + "\n", + " params = fit_dist(df_subset_y, dist)\n", + " fit_params.append(params)\n", + "\n", + " if no_fitting:\n", + " n_to_use = 1\n", + " else:\n", + " n_to_use = n\n", + "\n", + " # Trends for the various probability levels.\n", + " p01 = icdf_percent_n(dist, temp2cdf_hist, params, var=var, percent=0.01, n=n_to_use)\n", + " p05 = icdf_percent_n(dist, temp2cdf_hist, params, var=var, percent=0.05, n=n_to_use)\n", + " p50 = icdf_percent_n(dist, temp2cdf_hist, params, var=var, percent=0.5, n=n_to_use)\n", + " p95 = icdf_percent_n(dist, temp2cdf_hist, params, var=var, percent=0.95, n=n_to_use)\n", + "\n", + " p95s.append(p95)\n", + " p50s.append(p50)\n", + " p05s.append(p05)\n", + " p01s.append(p01)\n", + "\n", + "\n", + " # Plot trend for the dist.\n", + " axs[i].plot(year_starts, p95s, 'yellowgreen', label='p95')\n", + " axs[i].plot(year_starts, p50s, 'mediumorchid', label='p50')\n", + " axs[i].plot(year_starts, p05s, 'darkorange', label='p05')\n", + " axs[i].plot(year_starts, p01s, 'maroon', label='p01')\n", + " if no_fitting:\n", + " axs[i].set_title(f\"{var}, No Distribution, N={n_to_use}\")\n", + " else:\n", + " axs[i].set_title(f\"{var}, {dist} fit, N={n_to_use}\")\n", + " axs[i].set_xlabel(\"Decade\")\n", + " axs[i].set_ylabel(f\"{var} (C)\")\n", + " axs[i].legend(loc=\"upper left\")\n", + " axs[i].xaxis.set_tick_params(which='both', labelbottom=True)\n", + "\n", + " # Please the fitted PDF for the Gaussian Mixture.\n", + " if dist == \"GaussianMixture\":\n", + " for y_ind in range(len(year_starts)):\n", + " smoothed_pdf_y = generate_smooth_pdf(x_min, x_max, dist, fit_params[y_ind])\n", + " if len(smoothed_pdf_y):\n", + " axs[num_rows - 1].plot(x_array, smoothed_pdf_y, linewidth=1.5, color=colors_y[y_ind], label=f\"{year_starts[y_ind]}\")\n", + " axs[num_rows - 1].set_title(f\"{var}, GaussianMixture Fits Across Decades, N={n_to_use}\")\n", + " axs[num_rows - 1].set_xlabel(f\"{var} (C)\")\n", + " axs[num_rows - 1].set_ylabel(f\"Probability\")\n", + " axs[num_rows - 1].legend(loc=\"upper left\")\n", + "\n", + "\n", + " plt.show()" + ], + "metadata": { + "id": "LqWlT77aFx7j" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Pre-Computation (Takes a Minute or Two)\n", + "\n", + "The data for 100 counties across the US is made available as an extract on a Google Drive location. This data is retrieved directly and the distribution parameters are then estimated (here in this colab). The histogram fitting is precomputed (using SQL), the code for which is provided at: https://gist.github.com/pradh/2fda9a4e30f7fd9d0086ec685e94aeb5 (but not used directly in this Colab)." + ], + "metadata": { + "id": "1VEx6Zm84-0W" + } + }, + { + "cell_type": "code", + "source": [ + "#@title Counties List (Do Not Edit)\n", + "COUNTIES_MAP = {\n", + " 'Sarpy County': 'geoId/31153',\n", + " 'Franklin County': 'geoId/39049',\n", + " 'Ellis County': 'geoId/48139',\n", + " 'Mayes County': 'geoId/40097',\n", + " 'Kern County': 'geoId/06029',\n", + " 'Atkinson County': 'geoId/13003',\n", + " 'Pierce County': 'geoId/13229',\n", + " 'Ware County': 'geoId/13299',\n", + " 'Brantley County': 'geoId/13025',\n", + " 'Telfair County': 'geoId/13271',\n", + " 'Charlton County': 'geoId/13049',\n", + " 'Imperial County': 'geoId/06025',\n", + " 'Inyo County': 'geoId/06027',\n", + " 'Riverside County': 'geoId/06065',\n", + " 'Cheyenne County': 'geoId/08017',\n", + " 'Highlands County': 'geoId/12055',\n", + " 'Clinch County': 'geoId/13065',\n", + " 'Wheeler County': 'geoId/13309',\n", + " 'Garfield County': 'geoId/30033',\n", + " 'Chesterfield County': 'geoId/45025',\n", + " 'Okeechobee County': 'geoId/12093',\n", + " 'Polk County': 'geoId/12105',\n", + " 'Berrien County': 'geoId/13019',\n", + " 'La Paz County': 'geoId/04012',\n", + " 'Maricopa County': 'geoId/04013',\n", + " 'Yuma County': 'geoId/04027',\n", + " 'San Bernardino County': 'geoId/06071',\n", + " 'Hardee County': 'geoId/12049',\n", + " 'Osceola County': 'geoId/12097',\n", + " 'Bacon County': 'geoId/13005',\n", + " 'Coffee County': 'geoId/13069',\n", + " 'Irwin County': 'geoId/13155',\n", + " 'Jeff Davis County': 'geoId/13161',\n", + " 'Lanier County': 'geoId/13173',\n", + " 'Todd County': 'geoId/21219',\n", + " 'Frontier County': 'geoId/31063',\n", + " 'Union County': 'geoId/37179',\n", + " 'Hill County': 'geoId/48217',\n", + " 'McMullen County': 'geoId/48311',\n", + " 'Montague County': 'geoId/48337',\n", + " 'Dodge County': 'geoId/13091',\n", + " 'Marlboro County': 'geoId/45069',\n", + " 'Christian County': 'geoId/21047',\n", + " 'Mohave County': 'geoId/04015',\n", + " 'Pima County': 'geoId/04019',\n", + " 'Crowley County': 'geoId/08025',\n", + " 'Prowers County': 'geoId/08099',\n", + " 'Hamilton County': 'geoId/12047',\n", + " 'Hillsborough County': 'geoId/12057',\n", + " 'Baker County': 'geoId/13007',\n", + " 'Bulloch County': 'geoId/13031',\n", + " 'Camden County': 'geoId/13039',\n", + " 'Echols County': 'geoId/13101',\n", + " 'Emanuel County': 'geoId/13107',\n", + " 'Jefferson County': 'geoId/13163',\n", + " 'Lowndes County': 'geoId/13185',\n", + " 'Mitchell County': 'geoId/13205',\n", + " 'Montgomery County': 'geoId/13209',\n", + " 'Treutlen County': 'geoId/13283',\n", + " 'Washington County': 'geoId/13303',\n", + " 'Wayne County': 'geoId/13305',\n", + " 'Wilcox County': 'geoId/13315',\n", + " 'Scott County': 'geoId/18143',\n", + " 'Logan County': 'geoId/21141',\n", + " 'Trimble County': 'geoId/21223',\n", + " 'Petroleum County': 'geoId/30069',\n", + " 'Luna County': 'geoId/35029',\n", + " 'Anson County': 'geoId/37007',\n", + " 'Randolph County': 'geoId/37151',\n", + " 'Richmond County': 'geoId/37153',\n", + " 'Robeson County': 'geoId/37155',\n", + " 'Beckham County': 'geoId/40009',\n", + " 'Cherokee County': 'geoId/45021',\n", + " 'Fairfield County': 'geoId/45039',\n", + " 'Kershaw County': 'geoId/45055',\n", + " 'Lancaster County': 'geoId/45057',\n", + " 'Newberry County': 'geoId/45071',\n", + " 'Saluda County': 'geoId/45081',\n", + " 'Perkins County': 'geoId/46105',\n", + " 'Brazos County': 'geoId/48041',\n", + " 'Burleson County': 'geoId/48051',\n", + " 'La Salle County': 'geoId/48283',\n", + " 'Orange County': 'geoId/12095',\n", + " 'Cook County': 'geoId/13075',\n", + " 'Jenkins County': 'geoId/13165',\n", + " 'Johnson County': 'geoId/13167',\n", + " 'Laurens County': 'geoId/13175',\n", + " 'Worth County': 'geoId/13321',\n", + " 'Beaver County': 'geoId/40007',\n", + " 'Butler County': 'geoId/01013',\n", + " 'Choctaw County': 'geoId/01023',\n", + " 'Coffee County': 'geoId/01031',\n", + " 'Colbert County': 'geoId/01033',\n", + " 'Covington County': 'geoId/01039',\n", + " 'Dale County': 'geoId/01045',\n", + " 'Dallas County': 'geoId/01047',\n", + " 'Henry County': 'geoId/01067',\n", + " 'Lauderdale County': 'geoId/01077',\n", + " 'Marengo County': 'geoId/01091',\n", + " 'Wilcox County': 'geoId/01131',\n", + " 'Cochise County': 'geoId/04003',\n", + " 'Otero County': 'geoId/08089',\n", + " 'Columbia County': 'geoId/12023',\n", + " 'Manatee County': 'geoId/12081',\n", + "}" + ], + "metadata": { + "id": "nj4MhvJBSrks", + "cellView": "form" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "#@title Retrieve Data Extracts (takes some time)\n", + "\n", + "# Data files available at: # https://drive.google.com/drive/folders/1IrNkjewMq_0aLyeaKpvnsA5-Y01_k32B\n", + "df_p1d_max_temp_future = get_data_extract('1251dC0opkFURYqQnpSL2f36BmCeUqxiH')\n", + "df_p1d_max_temp_past = get_data_extract('1jTaS8OFMKWRaJIWRNHp7rKKdMoT0nlUP')\n", + "\n", + "df_p1d_min_temp_future = get_data_extract('1_GtY6kzn_eVvSJjD2TjZN-9jSIT1jWC4')\n", + "df_p1d_min_temp_past = get_data_extract('1s4GSXtWH8o0kDizzZ8xUZCs-a4v83-9B')\n", + "\n", + "df_hist_max_temp = get_data_extract('1A-WekLGrzuyvbApEIev88Kyi-uQ23_af')\n", + "df_hist_min_temp = get_data_extract('1cLuvoWUwCwRz5bb0Uhv9cxr4nbSIG0xO')\n", + "\n", + "df_hist_max_temp.rename(columns={\"decade\": \"year\", \"model\": \"cmip6_model\"}, inplace=True)\n", + "df_hist_min_temp.rename(columns={\"decade\": \"year\", \"model\": \"cmip6_model\"}, inplace=True)\n", + "\n", + "data_p1d = {\n", + " (\"Max_Temperature\", \"future\"): df_p1d_max_temp_future,\n", + " (\"Max_Temperature\", \"past\"): df_p1d_max_temp_past,\n", + " (\"Min_Temperature\", \"future\"): df_p1d_min_temp_future,\n", + " (\"Min_Temperature\", \"past\"): df_p1d_min_temp_past,\n", + "}\n", + "data_hist = {\n", + " \"Max_Temperature\": df_hist_max_temp,\n", + " \"Min_Temperature\": df_hist_min_temp,\n", + "}\n", + "\n", + "# Actual Observations (from 1980-2020).\n", + "df_actual = get_data_extract('1q8HmVM1r02FE5DSrDlrx0T20_SzHhepF')\n", + "df_actual[\"year\"] = df_actual.date.str.slice(0, 4)\n", + "df_actual[\"year\"] = df_actual[\"year\"].astype('int')" + ], + "metadata": { + "id": "rmFURQHk-yhb", + "cellView": "form" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Fitted Distributions; Probability Thresholds" + ], + "metadata": { + "id": "tyep7ThVj0jR" + } + }, + { + "cell_type": "code", + "source": [ + "#@markdown Specify a county, variable, scenario, cmip6 model, start year (decade) and specify a positive integer N (read the preamble for an explanation).\n", + "#@markdown
Note: That the SSP245, SSP585 scenarios are only applicable post-2020 while the 'historical' scenario is only applicable prior to 2010.\n", + "\n", + "County = \"Imperial County\" #@param ['Anson County', 'Atkinson County', 'Bacon County', 'Baker County', 'Beaver County', 'Beckham County', 'Berrien County', 'Brantley County', 'Brazos County', 'Bulloch County', 'Burleson County', 'Butler County', 'Camden County', 'Charlton County', 'Cherokee County', 'Chesterfield County', 'Cheyenne County', 'Choctaw County', 'Christian County', 'Clinch County', 'Cochise County', 'Coffee County', 'Colbert County', 'Columbia County', 'Cook County', 'Covington County', 'Crowley County', 'Dale County', 'Dallas County', 'Dodge County', 'Echols County', 'Ellis County', 'Emanuel County', 'Fairfield County', 'Franklin County', 'Frontier County', 'Garfield County', 'Hamilton County', 'Hardee County', 'Henry County', 'Highlands County', 'Hill County', 'Hillsborough County', 'Imperial County', 'Inyo County', 'Irwin County', 'Jeff Davis County', 'Jefferson County', 'Jenkins County', 'Johnson County', 'Kern County', 'Kershaw County', 'La Paz County', 'La Salle County', 'Lancaster County', 'Lanier County', 'Lauderdale County', 'Laurens County', 'Logan County', 'Lowndes County', 'Luna County', 'Manatee County', 'Marengo County', 'Maricopa County', 'Marlboro County', 'Mayes County', 'McMullen County', 'Mitchell County', 'Mohave County', 'Montague County', 'Montgomery County', 'Newberry County', 'Okeechobee County', 'Orange County', 'Osceola County', 'Otero County', 'Perkins County', 'Petroleum County', 'Pierce County', 'Pima County', 'Polk County', 'Prowers County', 'Randolph County', 'Richmond County', 'Riverside County', 'Robeson County', 'Saluda County', 'San Bernardino County', 'Sarpy County', 'Scott County', 'Telfair County', 'Todd County', 'Treutlen County', 'Trimble County', 'Union County', 'Ware County', 'Washington County', 'Wayne County', 'Wheeler County', 'Wilcox County', 'Worth County', 'Yuma County']\n", + "Variable = \"Max_Temperature\" #@param [\"Max_Temperature\", \"Min_Temperature\"]\n", + "Scenario = 'historical' #@param [\"SSP245\", \"SSP585\", \"historical\"]\n", + "Model = 'Ensemble' #@param ['Ensemble', 'GFDL-CM4','GFDL-ESM4','HADGEM3-GC31-LL','HADGEM3-GC31-MM','MPI-ESM1-2-HR','MPI-ESM1-2-LR']\n", + "Decade_Start = '2000' #@param [\"2040\", \"2030\", \"2020\", \"2000\", \"1990\", \"1980\"]\n", + "N = \"52\" #@param {type:\"string\"}\n", + "\n", + "\n", + "year_start = int(Decade_Start)\n", + "year_end = year_start + 10\n", + "proceed = False\n", + "try:\n", + " N = int(N)\n", + " if N > 0:\n", + " proceed = True\n", + "except:\n", + " pass\n", + "\n", + "if not N:\n", + " print(\"N must be a positive integer\")\n", + "\n", + "county_dcid = COUNTIES_MAP[County]\n", + "\n", + "print()\n", + "print(f\"Place Page ({County}): https://datacommons.org/place/{county_dcid}\")\n", + "print()\n", + "\n", + "hist_scenario = Scenario\n", + "tuple_1 = Variable\n", + "tuple_2 = \"future\"\n", + "if Scenario == \"historical\":\n", + " hist_scenario = ''\n", + " tuple_2 = \"past\"\n", + "\n", + "if tuple_2 == \"future\":\n", + " print(\"Note: there is no actual observed data for this decade\")\n", + "\n", + "df_p1d = data_p1d[(tuple_1, tuple_2)]\n", + "df_hist = data_hist[tuple_1]\n", + "\n", + "# Get the Data from BQ.\n", + "if proceed:\n", + " df_all_extract = df_p1d[(df_p1d[\"year\"] >= year_start) & (df_p1d[\"year\"] < year_end) &\n", + " (df_p1d['scenario'] == Scenario) & (df_p1d['county'] == county_dcid)]\n", + "\n", + " if Model != 'Ensemble':\n", + " df_all_extract = df_all_extract[df_all_extract[\"cmip6_model\"] == Model]\n", + "\n", + " df_hist_extract = df_hist[(df_hist[\"year\"] >= year_start) & (df_hist[\"year\"] < year_end) &\n", + " (df_hist['scenario'] == hist_scenario) & (df_hist['county'] == county_dcid) & (df_hist['cmip6_model'] == Model)]\n", + "\n", + " df_actual_extract = df_actual[(df_actual[\"year\"] >= year_start) &\n", + " (df_actual[\"year\"] < year_end) &\n", + " (df_actual[\"dcid\"] == county_dcid)]\n", + " if (not df_all_extract.empty) and (not df_hist_extract.empty):\n", + " plot_fits(df_all_extract, df_hist_extract, df_actual_extract, County, N, year_start, year_end, Scenario, Model, Variable)\n", + " else:\n", + " print(\"***** This combination of Variable, Scenario and Model is not valid. Please try a different combination. ******\")\n", + " print(len(df_all_extract), len(df_hist_extract))\n" + ], + "metadata": { + "id": "FlR1Ejk4eEbj", + "cellView": "form" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Trends Over Decades: Proability Levels; Mixture Distribution Fits" + ], + "metadata": { + "id": "1yiwQbxTFk_4" + } + }, + { + "cell_type": "code", + "source": [ + "#@markdown Specify a county, variable, scenario, cmip6 model, and specify a positive integer N (read the preamble for an explanation).\n", + "#@markdown
Note: Before 2010, only historical runs are used and after 2010 the selection SSP scenario is used.\n", + "\n", + "County = \"Imperial County\" #@param ['Anson County', 'Atkinson County', 'Bacon County', 'Baker County', 'Beaver County', 'Beckham County', 'Berrien County', 'Brantley County', 'Brazos County', 'Bulloch County', 'Burleson County', 'Butler County', 'Camden County', 'Charlton County', 'Cherokee County', 'Chesterfield County', 'Cheyenne County', 'Choctaw County', 'Christian County', 'Clinch County', 'Cochise County', 'Coffee County', 'Colbert County', 'Columbia County', 'Cook County', 'Covington County', 'Crowley County', 'Dale County', 'Dallas County', 'Dodge County', 'Echols County', 'Ellis County', 'Emanuel County', 'Fairfield County', 'Franklin County', 'Frontier County', 'Garfield County', 'Hamilton County', 'Hardee County', 'Henry County', 'Highlands County', 'Hill County', 'Hillsborough County', 'Imperial County', 'Inyo County', 'Irwin County', 'Jeff Davis County', 'Jefferson County', 'Jenkins County', 'Johnson County', 'Kern County', 'Kershaw County', 'La Paz County', 'La Salle County', 'Lancaster County', 'Lanier County', 'Lauderdale County', 'Laurens County', 'Logan County', 'Lowndes County', 'Luna County', 'Manatee County', 'Marengo County', 'Maricopa County', 'Marlboro County', 'Mayes County', 'McMullen County', 'Mitchell County', 'Mohave County', 'Montague County', 'Montgomery County', 'Newberry County', 'Okeechobee County', 'Orange County', 'Osceola County', 'Otero County', 'Perkins County', 'Petroleum County', 'Pierce County', 'Pima County', 'Polk County', 'Prowers County', 'Randolph County', 'Richmond County', 'Riverside County', 'Robeson County', 'Saluda County', 'San Bernardino County', 'Sarpy County', 'Scott County', 'Telfair County', 'Todd County', 'Treutlen County', 'Trimble County', 'Union County', 'Ware County', 'Washington County', 'Wayne County', 'Wheeler County', 'Wilcox County', 'Worth County', 'Yuma County']\n", + "Variable = \"Max_Temperature\" #@param [\"Max_Temperature\", \"Min_Temperature\"]\n", + "Scenario = 'SSP585' #@param [\"SSP245\", \"SSP585\"]\n", + "Model = 'Ensemble' #@param ['Ensemble', 'GFDL-CM4','GFDL-ESM4','HADGEM3-GC31-LL','HADGEM3-GC31-MM','MPI-ESM1-2-HR','MPI-ESM1-2-LR']\n", + "N = \"520\" #@param {type:\"string\"}\n", + "\n", + "\n", + "proceed = False\n", + "try:\n", + " N = int(N)\n", + " if N > 0:\n", + " proceed = True\n", + "except:\n", + " pass\n", + "\n", + "if not N:\n", + " print(\"N must be a positive integer\")\n", + "\n", + "county_dcid = COUNTIES_MAP[County]\n", + "\n", + "print()\n", + "print(f\"Place Page ({County}): https://datacommons.org/place/{county_dcid}\")\n", + "print()\n", + "\n", + "if proceed:\n", + " plot_trends(data_p1d, data_hist, county_dcid, Scenario, Model, Variable, N)\n" + ], + "metadata": { + "id": "3Se--BR6Fjrz", + "cellView": "form" + }, + "execution_count": null, + "outputs": [] + } + ] +} diff --git a/notebooks/README.md b/notebooks/README.md index dff5a215..c18a50c2 100644 --- a/notebooks/README.md +++ b/notebooks/README.md @@ -1,21 +1,3 @@ # Python API Notebooks -This directory contains iPython notebooks that use the Python API to -perform various statistical analyses on interesting datasets. You can click on -each link to see a live colab version. - -Notebook | Description --------- | ----------- -[`analyzing_census_data.ipynb`](https://colab.research.google.com/drive/1qCPZZD0MPWx6CC34wFVJc_9B2-q0F-h_) | A notebook that analyzes the relationship between population size and median age for each State, County, and City in the United States. -[`COVID_19_Feature_Exploration_Analysis_with_Data_Commons.ipynb`](https://colab.research.google.com/drive/1LLteGjXifwSsD-YsGwBnI-i96G777Q7j) | A notebook that explores how COVID-19 cases trends differ across different counties, and examines hundreds of variables across dozens of sources to see which variables are potentially correlated with COVID-19 mortality rate. -[`analyzing_income_distribution.ipynb`](https://colab.research.google.com/drive/1uZtHeQ5FJoKPdjYjaHnIPXcAe0nKLcKO) | A notebook that plots the distribution of income using statistics provided by the 2017 [American Community Survey](https://www.census.gov/programs-surveys/acs). The final result is a histogram charting the number of individuals in income brackets ranging from "0 to 10,000USD" up to "Above 200,000USD". -[`analyzing_obesity_prevalence.ipynb`](https://colab.research.google.com/drive/1cawpFQzuoRcZX0H_kpbBvhBNZzGjBN8t) | A notebook that analyzes the relationship between prevalence of obesity in 500 US Cities (as provided by the [CDC Wonder](https://wonder.cdc.gov/) dataset) to health and socio-economic indicators such as prevalence of high blood pressure and poverty rate. -[`analyzing_genomic_data.ipynb`](https://colab.research.google.com/drive/1Io7EDr4LjfPLl_l2JYY8__WbfitfNlOf) | A notebook that analyzes genetic variants within RUNX1 (provided by multiple datasets from UCSC Genome Browser, NCBI/gene, and ClinVar). - -## Maintenance - -To maintain up to date versions of these notebooks, developers can save a copy -of the above notebooks to a GitHub repository and PR this repository. Navigate -to `File > Save a copy in GitHub...` - -![How to save to a GitHub repository.](https://user-images.githubusercontent.com/4650701/62900477-10787680-bd0f-11e9-84d0-ee69f8c17df9.png) +This directory contains Colab notebooks that use the Python API. diff --git a/notebooks/analyzing_census_data.ipynb b/notebooks/analyzing_census_data.ipynb index aa9ccef9..f4f67167 100644 --- a/notebooks/analyzing_census_data.ipynb +++ b/notebooks/analyzing_census_data.ipynb @@ -1,267 +1,291 @@ { - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "name": "Analyzing Census Data with Data Commons", - "provenance": [], - "collapsed_sections": [], - "machine_shape": "hm", - "include_colab_link": true - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - } - }, "cells": [ { "cell_type": "markdown", "metadata": { - "id": "view-in-github", - "colab_type": "text" + "id": "ZXL-qge7bmCa" }, "source": [ - "\"Open" + "Copyright 2025 Google LLC.\n", + "SPDX-License-Identifier: Apache-2.0\n", + "\n", + "**Notebook Version** - 2.0.0" ] }, { "cell_type": "markdown", - "metadata": { - "id": "ZXL-qge7bmCa", - "colab_type": "text" - }, + "metadata": {}, "source": [ - "Copyright 2019 Google LLC.\n", - "SPDX-License-Identifier: Apache-2.0\n", - "\n", - "**Notebook Version** - 1.0.0" + "\"Open" ] }, { "cell_type": "markdown", "metadata": { - "id": "knFLVFogCWq0", - "colab_type": "text" + "id": "knFLVFogCWq0" }, "source": [ "# Analyzing Census Data with Data Commons\n", "\n", - "Every year, the American Community Survey (published by the US Census) reports thousands of variables about demographics, economics, housing, and more. This information, stored in Data Commons, is available to everyone for data science projects, education, and exploration. This tutorial introduces the Data Commons graph and two of its tools to help integrate its data into your data science projects: (1) the [browser](https://browser.datacommons.org/) and (2) the [Pandas API](https://github.com/datacommonsorg/api-pandas).\n", + "Every year, the American Community Survey (published by the US Census) reports thousands of variables about demographics, economics, housing, and more. This information, stored in Data Commons, is available to everyone for data science projects, education, and exploration. This tutorial introduces the Data Commons graph and two of its tools to help integrate its data into your data science projects: (1) the knowledge graph [browser](https://datacommons.org/browser) and (2) the [Python API](https://docs.datacommons.org/api/python/v2).\n", "\n", "## What is Data Commons?\n", "\n", - "Data Commons is an open knowledge repository that combines data from public datasets using mapped common entities. It contains statements about real world objects such as\n", + "Data Commons is an open knowledge repository that combines data from public datasets using mapped common entities. It contains statements about real-world objects such as:\n", + "\n", + "* [Santa Clara County](https://datacommons.org/browser/geoId/06085) is contained in the [State of California](https://datacommons.org/browser/geoId/06)\n", + "* The latitude of [Berkeley, CA](https://datacommons.org/browser/geoId/0606000) is 37.8703\n", + "* [The population of Maryland](https://datacommons.org/browser/geoId/24) was [6.26 M in 2024](https://datacommons.org/browser/geoId/24?statVar=Count_Person).\n", "\n", - "* [Santa Clara County](https://browser.datacommons.org/kg?dcid=geoId/06085) is contained in the [State of California](https://browser.datacommons.org/kg?dcid=geoId/06)\n", - "* The latitude of [Berkeley, CA](https://browser.datacommons.org/kg?dcid=geoId/0606000) is 37.8703\n", - "* [The population of Maryland](https://browser.datacommons.org/kg?dcid=dc/p/psjx4xy30nws1) was [6,003,435 in 2018](https://browser.datacommons.org/kg?dcid=dc%2Fo%2Fx1tlfg4ll9yr9).\n", + "In the graph, [*entities*](https://docs.datacommons.org/data_model.html#entity) like Santa Clara County are represented by nodes. Every node has a type corresponding to what the node represents. For example, California is a [State](https://datacommons.org/browser/State). *Relations* between entities are represented by edges between these nodes. For example, the statement \"Santa Clara County is contained in the State of California\" is represented in the graph as two nodes: \"Santa Clara County\" and \"California\" with an edge labeled \"[containedInPlace](https://datacommons.org/browser/containedInPlace)\" pointing from Santa Clara to California. Data Commons closely follows the [Schema.org data model](https://schema.org/docs/datamodel.html) and leverages Schema.org schema to provide a common set of types and properties.\n", "\n", - "In the graph, [*entities*](https://en.wikipedia.org/wiki/Entity) like [Santa Clara County](https://browser.datacommons.org/kg?dcid=geoId/06085) are represented by nodes. Every node has a type corresponding to what the node represents. For example, [California](https://browser.datacommons.org/kg?dcid=geoId/06) is a [State](https://schema.org/State). *Relations* between entities are represented by edges between these nodes. For example, the statement \"Santa Clara County is contained in the State of California\" is represented in the graph as two nodes: \"Santa Clara County\" and \"California\" with an edge labeled \"[containedInPlace](https://schema.org/containedInPlace)\" pointing from Santa Clara to California. Data Commons closely follows the [Schema.org data model](https://schema.org/docs/datamodel.html) and leverages Schema.org schema to provide a common set of types and properties.\n", + "## Data Commons knowledge graph browser\n", "\n", - "## Data Commons Browser\n", + "The [Data Commons browser](https://datacommons.org/browser) provides a way to explore the data in a human-readable format. It is the best way to explore what is in Data Commons. Searching in the browser for an entity like [Mountain View](https://datacommons.org/browser/geoId/0649670), takes you to a page about the entity, including properties like [containedInPlace](https://datacommons.org/browser/containedInPlace) and [timezone](https://datacommons.org/browser/timezone).\n", "\n", - "The [Data Commons browser](https://browser.datacommons.org/) provides a way to explore the data in a human-readable format. It is the best way to explore what is in Data Commons. Searching in the browser for an entity like [Mountain View](https://browser.datacommons.org/kg?dcid=geoId/0649670), takes you to a page about the entity, including properties like [containedInPlace](https://browser.datacommons.org/kg?dcid=containedInPlace) and [timezone](https://browser.datacommons.org/kg?dcid=timezone).\n", + "An important property for all entities is the **`dcid`** (Data Commons identifier). This is a unique identifier assigned to each entity in the knowledge graph. With this identifier, you can to search for and query information on the given entity in ways that we will discuss later. The `dcid` is listed at the top of the page next to \"About: \" and also in the list of properties.\n", "\n", - "An important property for all entities is the **`dcid`**. The `dcid` (Data Commons identifier) is a unique identifier assigned to each entity in the knowledge graph. With this identifier, you will be able to search for and query information on the given entity in ways that we will discuss later. The `dcid` is listed at the top of the page next to \"About: \" and also in the list of properties.\n", + "## Python API\n", "\n", - "## Pandas API\n", + "The [Python API](https://github.com/datacommonsorg/api-python/tree/master/datacommons_client) provides functions for users to extract structured information from Data Commons programmatically and view them in different formats such as Python `dict`s and [pandas](https://pandas.pydata.org/) DataFrames. DataFrames allow access to all the data processing, analytical and visualization tools provided by packages such as pandas, NumPy, SciPy, and Matplotlib.\n", "\n", - "The [Pandas API](https://github.com/datacommonsorg/api-pandas) provides functions for users to extract structured information from Data Commons programmatically and view them in different formats such as Python `dict`s and [pandas](https://pandas.pydata.org/) DataFrames. DataFrames allow access to all the data processing, analytical and visualization tools provided by packages such as pandas, NumPy, SciPy, and Matplotlib.\n", + "Note: Before you can use the API, you must obtain a Data Commons API key. Please see [Obtain an API key](https://docs.datacommons.org/api/#obtain-an-api-key) for details. In this Colab, we'll use a trial key. You may use it for a limited number of requests, but you will need to get your own key for longer use.\n", "\n", - "Let's begin by loading the Data Commons Pandas API and the standard data science libraries:\n" + "Let's begin by loading the Data Commons Python API and the standard data science libraries:" ] }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "zxg_UfUgIq-Y", - "colab_type": "code", - "colab": {} + "id": "zxg_UfUgIq-Y" }, + "outputs": [], "source": [ - "# Install datacommons_pandas\n", - "!pip install datacommons_pandas --upgrade --quiet\n", + "# Install datacommons client\n", + "!pip install \"datacommons-client[Pandas]\" --upgrade --quiet\n", + "\n", "# Import Data Commons\n", - "import datacommons_pandas as dc\n", + "from datacommons_client import DataCommonsClient\n", "\n", "# Import other required libraries\n", "import matplotlib.pyplot as plt\n", "import matplotlib.patches as mpatches\n", "import pandas as pd\n", - "\n", "import json" - ], - "execution_count": 15, - "outputs": [] + ] }, { "cell_type": "markdown", "metadata": { - "id": "rrkDVNp0JI6g", - "colab_type": "text" + "id": "7YDkBlc8jLQE" }, "source": [ - "## Example: Median Age vs Population by State, County, and City\n", - "For this exercise, we will be comparing the median ages and population count for US states, counties, and cities. First, let's lookup the dcid for the '[United States](https://browser.datacommons.org/kg?dcid=country/USA)'." + "Now we'll create a Data Commons client, and authenticate to the API server. The client object manages all the interactions with the server, so you only need to authenticate one time." ] }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "0peszosKQU_g", - "colab_type": "code", - "colab": {} + "id": "uml1CmB9PeyU" }, + "outputs": [], "source": [ - "# In the browser, we saw that the dcid for United States is country/USA\n", - "usa = 'country/USA'" - ], - "execution_count": 16, - "outputs": [] + "# Create a client using the Data Commons Trial API key.\n", + "dc_client = DataCommonsClient(api_key=\"AIzaSyCTI4Xz-UW_G2Q2RfknhcfdAnTHq5X5XuI\")" + ] }, { "cell_type": "markdown", "metadata": { - "id": "kiPXhAJkDyjk", - "colab_type": "text" + "id": "PLCFs0ItjiZl" }, "source": [ - "### Using `get_places_in` to Query Administrative Areas\n", - "\n", - "The Pandas API defines a number of convenience functions for building Pandas dataframes with information in the datacommons graph. We will be using **`get_places_in`** which requires three arguments:\n", - "\n", - "- `dcids` - A list or `pandas.Series` of dcids identifying administrative areas that we wish to get containing places for.\n", - "- `place_type` - The type of the administrative area that we wish to query for.\n", + "The client provides access to the three main endpoints:\n", "\n", - "In Data Commons, the 'containedInPlace' property relates administrative areas to its containing administrative areas. Concretely, every US 'State' node has a directed edge to the USA 'Country' node where the name of this edge is 'containedInPlace'. The same also goes for 'County' to 'State' nodes and 'City' to 'County'.\n", - "\n", - "When we provide a list of places to `get_places_in`, we get back a `dict` mapping each place to all the places contained inside it. In this case, we are only providing a single-element list of USA." + "`node`: Gets information about the relations between nodes in the knowledge graph.\n", + "`observation`: Gets statistical data for selected entities and variables.\n", + "`resolve`: Looks up DCIDs of selected entities.\n", + "In addition, the client provides the facility to get statistical observations as Pandas DataFrames." ] }, { - "cell_type": "code", + "cell_type": "markdown", "metadata": { - "id": "MXy_j6VS04g5", - "colab_type": "code", - "colab": {} + "id": "rrkDVNp0JI6g" }, "source": [ - "# Get lists of states, counties, and cities within the United States, respectively.\n", - "states = dc.get_places_in([usa], 'State')[usa]\n", - "counties = dc.get_places_in([usa], 'County')[usa]\n", - "cities = dc.get_places_in([usa], 'City')[usa]" + "## Example: Median age vs. population by state, county, and city\n", + "For this exercise, we will be comparing the median ages and population count for U.S. states, counties, and cities. First, let's look up the DCID for the United States using the `fetch_dcids_by_name` method of the [`resolve` endpoint](https://docs.datacommons.org/api/python/v2/resolve.html#fetch_dcids_by_name)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "0peszosKQU_g", + "outputId": "a0d5c9d9-2c97-44a2-bbd4-a1969a0f3c49" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'country/USA'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } ], - "execution_count": 17, - "outputs": [] + "source": [ + "# Using the resolve endpoint, we can find the dcid of United States from its name\n", + "usa_name = 'United States'\n", + "usa = dc_client.resolve.fetch_dcids_by_name(usa_name).to_flat_dict()[usa_name]\n", + "usa" + ] }, { "cell_type": "markdown", "metadata": { - "id": "fKbexXS60mLw", - "colab_type": "text" + "id": "kiPXhAJkDyjk" }, "source": [ - "Let's see what states are in the USA:" + "### Using the `node` `fetch_place_*` methods to query administrative areas\n", + "\n", + "We can use the `fetch_place_children` method of the [`node` endpoint](https://docs.datacommons.org/api/python/v2/node.html#fetch_place_children) to get the DCIDs of all the places contained in the United States. We use the `children_type` parameter to list out the states, counties, and cities. To make the results more manageable, we limit the results to 5 each.\n", + "\n", + "You can use the `fetch_place_parents` method to do the reverse: get the administrative areas that contain places of interest." ] }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "5ZnJp5ns0nXt", - "colab_type": "code", "colab": { - "base_uri": "https://localhost:8080/", - "height": 207 + "base_uri": "https://localhost:8080/" }, - "outputId": "7edbd492-15f9-475d-efd6-bd2a34b1a824" + "id": "MXy_j6VS04g5", + "outputId": "1ed98354-1059-4e52-cfae-f62bf67a4e05" }, - "source": [ - "# Display the first 10 states\n", - "states[:10]" + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "states: [{'dcid': 'geoId/01', 'name': 'Alabama'}, {'dcid': 'geoId/02', 'name': 'Alaska'}, {'dcid': 'geoId/04', 'name': 'Arizona'}, {'dcid': 'geoId/05', 'name': 'Arkansas'}, {'dcid': 'geoId/06', 'name': 'California'}]\n", + "counties: [{'dcid': 'geoId/01001', 'name': 'Autauga County'}, {'dcid': 'geoId/01003', 'name': 'Baldwin County'}, {'dcid': 'geoId/01005', 'name': 'Barbour County'}, {'dcid': 'geoId/01007', 'name': 'Bibb County'}, {'dcid': 'geoId/01009', 'name': 'Blount County'}]\n", + "cities: [{'dcid': 'geoId/0100100', 'name': 'Abanda'}, {'dcid': 'geoId/0100124', 'name': 'Abbeville'}, {'dcid': 'geoId/0100148', 'name': 'Abel'}, {'dcid': 'geoId/0100220', 'name': 'Abernant'}, {'dcid': 'geoId/0100388', 'name': 'Ada, Alabama'}]\n" + ] + } ], - "execution_count": 18, + "source": [ + "# Get lists of states, counties, and cities within the United States, respectively.\n", + "states = dc_client.node.fetch_place_children(usa, children_type='State')[usa]\n", + "print('states:', states[:5])\n", + "\n", + "counties = dc_client.node.fetch_place_children(usa, children_type='County')[usa]\n", + "print('counties:', counties[:5])\n", + "\n", + "cities = dc_client.node.fetch_place_children(usa, children_type='City')[usa]\n", + "print('cities:', cities[:5])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "B0ClMNc-XjxB", + "outputId": "623d8c1c-3932-43ec-f897-46958c7ed61c" + }, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ - "['geoId/01',\n", - " 'geoId/02',\n", - " 'geoId/04',\n", - " 'geoId/05',\n", - " 'geoId/06',\n", - " 'geoId/08',\n", - " 'geoId/09',\n", - " 'geoId/10',\n", - " 'geoId/11',\n", - " 'geoId/12']" + "['geoId/01', 'geoId/02', 'geoId/04', 'geoId/05', 'geoId/06']" ] }, - "metadata": { - "tags": [] - }, - "execution_count": 18 + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" } + ], + "source": [ + "# Extract just the DCIDs\n", + "states = [state['dcid'] for state in states]\n", + "counties = [county['dcid'] for county in counties]\n", + "cities = [city['dcid'] for city in cities]\n", + "\n", + "states[:5]" ] }, { "cell_type": "markdown", "metadata": { - "id": "Nki51plW3uK_", - "colab_type": "text" + "id": "Nki51plW3uK_" }, "source": [ - "Great! With the place dcids ready, we can build a dataframe with the population and median age for each state. To do that, we'll need to understand a little bit about queryng statistical data." + "Great! With the place DCIDs ready, we can build a DataFrame with the population and median age for each state. To do that, we'll need to understand a little bit about queryng statistical data." ] }, { "cell_type": "markdown", "metadata": { - "id": "PJQ1kDAhEc2d", - "colab_type": "text" + "id": "PJQ1kDAhEc2d" }, "source": [ - "### Querying Statistics from Data Commons\n", + "### Querying statistics from Data Commons\n", "\n", - "Data Commons has a large corpus of statistical data, which can be queried and joined with other statistics. For example, we can query the median income of women living in Berkeley, California or the number of individuals who are insured in Maryland. \n", + "Data Commons has a large corpus of statistical data, which can be queried and joined with other statistics. For example, we can query the median income of women living in Berkeley, California or the number of individuals who are insured in Maryland.\n", "\n", - "Before we explore how to do this, we need to understand how Data Commons stores statistical data. In particular, there are two types of entities: [StatisticalVariable](https://browser.datacommons.org/kg?dcid=StatisticalVariable) and [StatVarObservation](https://browser.datacommons.org/kg?dcid=StatVarObservation).\n", + "Before we explore how to do this, we need to understand how Data Commons stores statistical data. In particular, there are two types of entities: [`StatisticalVariable`](https://datacommons.org/browser/StatisticalVariable) and [`StatVarObservation`](https://datacommons.org/browser/StatVarObservation).\n", "\n", - "A StatisticalVariable represents any type of statistical metric that can be measured at a place and time. Some examples include: median income, median income of females, number of high school graduates, unemployment rate, prevalence of diabetes, essentially anything you might call a metric, statistic, or measure. A StatVarObservation represents an actual measurement of a StatisticalVariable in a given place and time.\n", + "A `StatisticalVariable` represents any type of statistical metric that can be measured at a place and time. Some examples include: median income, median income of females, number of high school graduates, unemployment rate, prevalence of diabetes -- essentially anything you might call a metric, statistic, or measure. A `StatVarObservation` represents an actual measurement of a `StatisticalVariable` in a given place and time.\n", "\n", - "One example of a StatisticalVariable is the median age of people in San Antonio, Texas in 2014. The statistical metric, time, and place here are median age, 2014, and San Antonio respectively. A list of StatisticalVariables can be found [here](http://docs.datacommons.org/statistical_variables.html). To read more about StatisticalVariable and StatVarObservation, please see [representing_statistics.md](https://github.com/datacommonsorg/data/blob/master/docs/representing_statistics.md).\n", + "One example of a `StatVarObservation` is the median age of people in San Antonio, Texas in 2024. The statistical metric, time, and place here are median age, 2024, and San Antonio respectively. You can see a list of statistical variables in the [Statistical Variable Explorer](https://datacommons.org/tools/statvar) tool.\n", "\n", - "Data Commons defines APIs allowing us to fetch data over these two types. To begin with, we can use the [**`build_multivariate_dataframe`**](https://docs.datacommons.org/api/pandas/multivariate_dataframe.html) function to build a dataframe with the latest StatVarObservations of multiple StatisticalVariables for multiple places.\n", + "Data Commons defines APIs allowing us to fetch data over these two types. To begin with, we can use the [**`observations_dataframe`**](https://docs.datacommons.org/api/python/v2/pandas.html) function to build a Pandas DataFrame with the latest observations of multiple statistical variables for multiple places.\n", "\n", - "We are going to retrieve the total count and median age of populations (StatisticalVariables [Count_Person](https://datacommons.org/browser/Count_Person) and [Median_Age_Person](https://datacommons.org/browser/Median_Age_Person)) for US states, counties, and cities.\n", + "We are going to retrieve the total count and median age of populations (statistical variables [`Count_Person`](https://datacommons.org/browser/Count_Person) and [`Median_Age_Person`](https://datacommons.org/browser/Median_Age_Person)) for US states, counties, and cities.\n", "\n", "**Note** - This query may take a minute!\n" ] }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "n6y3DTAvkNjD", - "colab_type": "code", - "colab": {} + "id": "n6y3DTAvkNjD" }, + "outputs": [], "source": [ "# Get StatVarObservations for states.\n", - "df_state = dc.build_multivariate_dataframe(states, ['Count_Person', 'Median_Age_Person'])\n", + "df_state = dc_client.observations_dataframe(entity_dcids=states, variable_dcids=['Count_Person', 'Median_Age_Person'], date='latest')\n", + "\n", "# Get StatVarObservations for counties.\n", - "df_county = dc.build_multivariate_dataframe(counties, ['Count_Person', 'Median_Age_Person'])\n", + "df_county = dc_client.observations_dataframe(entity_dcids=counties, variable_dcids=['Count_Person', 'Median_Age_Person'], date='latest')\n", + "\n", "# Get StatVarObservations for cities.\n", - "df_city = dc.build_multivariate_dataframe(cities, ['Count_Person', 'Median_Age_Person'])\n" - ], - "execution_count": 19, - "outputs": [] + "df_city1 = dc_client.observations_dataframe(entity_dcids=cities[:25000], variable_dcids=['Count_Person', 'Median_Age_Person'], date='latest')\n", + "df_city2 = dc_client.observations_dataframe(entity_dcids=cities[25000:], variable_dcids=['Count_Person', 'Median_Age_Person'], date='latest')\n", + "df_city = pd.concat([df_city1, df_city2])" + ] }, { "cell_type": "markdown", "metadata": { - "id": "_L-17qzh5uEH", - "colab_type": "text" + "id": "_L-17qzh5uEH" }, "source": [ "We view the data we've queried for." @@ -269,26 +293,26 @@ }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "iIQs9MXr5wPH", - "colab_type": "code", "colab": { "base_uri": "https://localhost:8080/", - "height": 242 + "height": 206 }, - "outputId": "6f72d5fc-703a-48a5-e4cc-253d08960166" + "id": "iIQs9MXr5wPH", + "outputId": "2604b8fa-357f-4687-dd84-39100c767301" }, - "source": [ - "# View the first 5 rows of the state table.\n", - "df_state.head(5)" - ], - "execution_count": 20, "outputs": [ { - "output_type": "execute_result", "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "variable_name": "df_city" + }, "text/html": [ - "
\n", + "\n", + "
\n", + "
\n", "\n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" ], "text/plain": [ - " Count_Person Median_Age_Person\n", - "place \n", - "geoId/01 4864680 38.9\n", - "geoId/02 738516 34.0\n", - "geoId/04 6946685 37.4\n", - "geoId/05 2990671 37.9\n", - "geoId/06 39148760 36.3" + " date entity entity_name variable \\\n", + "0 2023 geoId/1778929 Warrenville Median_Age_Person \n", + "1 2021 geoId/1778929 Warrenville Median_Age_Person \n", + "2 2023 geoId/0135632 Hollywood Median_Age_Person \n", + "3 2021 geoId/0135632 Hollywood Median_Age_Person \n", + "4 2023 geoId/1250525 Oakland Median_Age_Person \n", + "\n", + " variable_name value facetId \\\n", + "0 Median Age of Population 37.2 3795540742 \n", + "1 Median Age of Population 37.8 815809675 \n", + "2 Median Age of Population 44.1 3795540742 \n", + "3 Median Age of Population 50.0 815809675 \n", + "4 Median Age of Population 40.2 3795540742 \n", + "\n", + " importName measurementMethod \\\n", + "0 CensusACS5YearSurvey CensusACS5yrSurvey \n", + "1 CensusACS5YearSurvey_SubjectTables_S0101 CensusACS5yrSurveySubjectTable \n", + "2 CensusACS5YearSurvey CensusACS5yrSurvey \n", + "3 CensusACS5YearSurvey_SubjectTables_S0101 CensusACS5yrSurveySubjectTable \n", + "4 CensusACS5YearSurvey CensusACS5yrSurvey \n", + "\n", + " observationPeriod provenanceUrl unit \n", + "0 None https://www.census.gov/programs-surveys/acs/da... Year \n", + "1 None https://data.census.gov/table?q=S0101:+Age+and... Years \n", + "2 None https://www.census.gov/programs-surveys/acs/da... Year \n", + "3 None https://data.census.gov/table?q=S0101:+Age+and... Years \n", + "4 None https://www.census.gov/programs-surveys/acs/da... Year " ] }, - "metadata": { - "tags": [] - }, - "execution_count": 20 + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" } + ], + "source": [ + "# View the first 5 rows of the city table.\n", + "df_city.head(5)" ] }, { "cell_type": "markdown", "metadata": { - "id": "Ka5_ycQJWkjG", - "colab_type": "text" + "id": "B2ZkXliiVbXy" }, "source": [ - "To get the name of places, we can use the `get_property_values` function:" + "### Cleaning and plotting the data\n", + "Great! It looks like we have all the data we need. Before we finish, let's do some post-processing.\n", + "\n" ] }, { - "cell_type": "code", + "cell_type": "markdown", "metadata": { - "id": "5JBYSuTqW1hF", - "colab_type": "code", - "colab": {} + "id": "CLYWGSXwoivj" }, "source": [ - "def add_name_col(df):\n", - " # Add a new column called name, where each value is the name for the place dcid in the index.\n", - " df['name'] = df.index.map(dc.get_property_values(df.index, 'name'))\n", - " \n", - " # Keep just the first name, instead of a list of all names.\n", - " df['name'] = df['name'].str[0]\n" - ], - "execution_count": 21, - "outputs": [] + "We're interested in just the statistical values, so we'll select a single data point for each place-statvar pair:\n", + "\n" + ] }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "4I-FOGf2W9RO", - "colab_type": "code", "colab": { "base_uri": "https://localhost:8080/", - "height": 242 + "height": 206 }, - "outputId": "f3235019-3322-4e3e-b293-f43dfd1913e3" + "id": "tbgI8NrpoWH3", + "outputId": "0fa9214a-6003-4cd6-d58b-05c19c927222" }, - "source": [ - "add_name_col(df_state)\n", - "df_state.head()" - ], - "execution_count": 22, "outputs": [ { - "output_type": "execute_result", "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"df_city\",\n \"rows\": 29640,\n \"fields\": [\n {\n \"column\": \"Count_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 61604.07013111626,\n \"min\": 0.0,\n \"max\": 8258035.0,\n \"num_unique_values\": 9146,\n \"samples\": [\n 5735.0,\n 3714.0,\n 239807.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Median_Age_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 11.344127725719476,\n \"min\": 1.9,\n \"max\": 93.0,\n \"num_unique_values\": 735,\n \"samples\": [\n 67.4,\n 35.5,\n 76.2\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe", + "variable_name": "df_city" + }, "text/html": [ - "
\n", + "\n", + "
\n", + "
\n", "\n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" ], "text/plain": [ - " Count_Person Median_Age_Person name\n", - "place \n", - "geoId/01 4864680 38.9 Alabama\n", - "geoId/02 738516 34.0 Alaska\n", - "geoId/04 6946685 37.4 Arizona\n", - "geoId/05 2990671 37.9 Arkansas\n", - "geoId/06 39148760 36.3 California" + " Count_Person Median_Age_Person\n", + "Aaronsburg 246.0 22.4\n", + "Aastad Township 214.0 NaN\n", + "Abanda 48.0 32.4\n", + "Abbeville 2844.0 55.3\n", + "Abbot 677.0 NaN" ] }, - "metadata": { - "tags": [] - }, - "execution_count": 22 + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "B2ZkXliiVbXy", - "colab_type": "text" - }, + ], "source": [ - "### Cleaning and Plotting the Data\n", - "Great! It looks like we have all the data we need. Before we finish, let's do some post-processing.\n", - "\n" + "def filter_to_stats_only(df, keep_stat_var_dcid=True):\n", + " df = df[df['measurementMethod'] != 'AgeAdjustedPrevalence']\n", + " columns = 'variable' if keep_stat_var_dcid else 'variable_name'\n", + " df = df.pivot_table(index='entity_name', columns=columns, values='value', aggfunc='first')\n", + " df = df.rename_axis(None, axis=1)\n", + " df.index.name = None\n", + " return df\n", + "\n", + "df_state = filter_to_stats_only(df_state)\n", + "df_county = filter_to_stats_only(df_county)\n", + "df_city = filter_to_stats_only(df_city)\n", + "\n", + "df_city.head(5)" ] }, { "cell_type": "code", + "execution_count": null, "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, "id": "4Cnlt_HYVluo", - "colab_type": "code", - "colab": {} + "outputId": "53cbfe12-6618-4410-dc8e-167e1277759c" }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"df_city\",\n \"rows\": 21393,\n \"fields\": [\n {\n \"column\": \"Count_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 72110.83808470755,\n \"min\": 0.0,\n \"max\": 8258035.0,\n \"num_unique_values\": 7927,\n \"samples\": [\n 10914.0,\n 78.0,\n 6936.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Median_Age_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 11.344127725719476,\n \"min\": 1.9,\n \"max\": 93.0,\n \"num_unique_values\": 735,\n \"samples\": [\n 67.4,\n 35.5,\n 76.2\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe", + "variable_name": "df_city" + }, + "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", + "
Count_PersonMedian_Age_Person
Aaronsburg246.022.4
Abanda48.032.4
Abbeville2844.055.3
Abbotsford2321.036.5
Abbott364.038.4
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + " Count_Person Median_Age_Person\n", + "Aaronsburg 246.0 22.4\n", + "Abanda 48.0 32.4\n", + "Abbeville 2844.0 55.3\n", + "Abbotsford 2321.0 36.5\n", + "Abbott 364.0 38.4" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Filter for all cities that have at least one person\n", - "df_city = df_city[df_city['Count_Person'] >= 1]" - ], - "execution_count": 23, - "outputs": [] + "df_city = df_city[df_city['Median_Age_Person'] >= 1]\n", + "\n", + "df_city.head(5)" + ] }, { "cell_type": "markdown", "metadata": { - "id": "uMQI-5I-IjBR", - "colab_type": "text" + "id": "uMQI-5I-IjBR" }, "source": [ "and finally, let's visualize our results." @@ -530,11 +1322,11 @@ }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "9fMo0pAEIlr4", - "colab_type": "code", - "colab": {} + "id": "9fMo0pAEIlr4" }, + "outputs": [], "source": [ "def plot_data(title, pd_table):\n", " \"\"\" Generate a scatter plot comparing median age and population count. \"\"\"\n", @@ -542,116 +1334,101 @@ " plt.title(title)\n", " plt.xlabel('Median Age in Years')\n", " plt.ylabel('Population Count (log scale)')\n", - " \n", + "\n", " # Scatter plot the information\n", " ax = plt.gca()\n", " ax.set_yscale('log')\n", " ax.scatter(pd_table['Median_Age_Person'], pd_table['Count_Person'], alpha=0.7)" - ], - "execution_count": 24, - "outputs": [] + ] }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "80OD87CN-xJQ", - "colab_type": "code", "colab": { "base_uri": "https://localhost:8080/", - "height": 513 + "height": 718 }, - "outputId": "459f6595-e3ee-403f-f3c1-0f8746ed3aaa" + "id": "80OD87CN-xJQ", + "outputId": "9d837346-81c3-4561-bde1-0881fc129c70" }, - "source": [ - "# Generate the plot for state data\n", - "plot_data('Median Age vs. Population Count for States', df_state)" - ], - "execution_count": 25, "outputs": [ { - "output_type": "display_data", "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "tags": [], - "needs_background": "light" - } + "metadata": {}, + "output_type": "display_data" } + ], + "source": [ + "# Generate the plot for state data\n", + "plot_data('Median Age vs. Population Count for States', df_state)" ] }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "H6E8iTHztzLq", - "colab_type": "code", "colab": { "base_uri": "https://localhost:8080/", - "height": 513 + "height": 718 }, - "outputId": "b6d1634d-af79-4ac6-f6f5-bd532312a714" + "id": "H6E8iTHztzLq", + "outputId": "7865eaa0-db85-43f7-8768-57b0f8e12b7d" }, - "source": [ - "# Generate the plot for county data\n", - "plot_data('Median Age vs. Population Count for Counties', df_county)" - ], - "execution_count": 26, "outputs": [ { - "output_type": "display_data", "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "tags": [], - "needs_background": "light" - } + "metadata": {}, + "output_type": "display_data" } + ], + "source": [ + "# Generate the plot for county data\n", + "plot_data('Median Age vs. Population Count for Counties', df_county)" ] }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "if72r7Z-tzQw", - "colab_type": "code", "colab": { "base_uri": "https://localhost:8080/", - "height": 513 + "height": 718 }, - "outputId": "75ac4acd-8f20-4256-e356-c0e13d2b5816" + "id": "if72r7Z-tzQw", + "outputId": "0c23862c-a998-440e-83eb-7379dfbb4862" }, - "source": [ - "# Generate the plot for city data\n", - "plot_data('Median Age vs. Population Count for Cities', df_city)" - ], - "execution_count": 27, "outputs": [ { - "output_type": "display_data", "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "tags": [], - "needs_background": "light" - } + "metadata": {}, + "output_type": "display_data" } + ], + "source": [ + "# Generate the plot for city data\n", + "plot_data('Median Age vs. Population Count for Cities', df_city)" ] }, { "cell_type": "markdown", "metadata": { - "id": "-yji5Buntzjq", - "colab_type": "text" + "id": "-yji5Buntzjq" }, "source": [ "We can also plot each administrative area granularity on the same plot to see how they relate." @@ -659,34 +1436,46 @@ }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "7tdrGFe6tzz3", - "colab_type": "code", "colab": { "base_uri": "https://localhost:8080/", - "height": 513 + "height": 718 }, - "outputId": "55a51751-bfe1-4654-d1b3-88d7f3b83463" + "id": "7tdrGFe6tzz3", + "outputId": "10986915-c764-4236-a5f0-02c103b94da7" }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "def plot_all_data(state_table, county_table, city_table):\n", " plt.figure(figsize=(12, 8))\n", " plt.title('Median Age vs. Population Count')\n", " plt.xlabel('Median Age in Years')\n", " plt.ylabel('Population Count (log scale)')\n", - " \n", + "\n", " # Make things pretty\n", " state_color = \"#ffa600\"\n", " county_color = \"#bc5090\"\n", " city_color = \"#003f5c\"\n", - " \n", + "\n", " # Scatter plot the information\n", " ax = plt.gca()\n", " ax.set_yscale('log')\n", " ax.scatter(state_table['Median_Age_Person'], state_table['Count_Person'], color=state_color, alpha=0.75)\n", " ax.scatter(county_table['Median_Age_Person'], county_table['Count_Person'], color=county_color, alpha=0.5)\n", " ax.scatter(city_table['Median_Age_Person'], city_table['Count_Person'], color=city_color, alpha=0.4)\n", - " \n", + "\n", " # Create the legend\n", " state_patch = mpatches.Patch(color=state_color, label='States')\n", " county_patch = mpatches.Patch(color=county_color, label='Counties')\n", @@ -695,35 +1484,32 @@ "\n", "# Plot all the data together.\n", "plot_all_data(df_state, df_county, df_city)" - ], - "execution_count": 28, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - } ] }, { "cell_type": "markdown", "metadata": { - "id": "bBVuVI5fEh4Q", - "colab_type": "text" + "id": "bBVuVI5fEh4Q" }, "source": [ - "## What's Next\n", + "## What's next\n", "\n", "Congratulations - you've completed your first Data Commons task! Now that you have completed the tutorial, you can explore the other Data Commons notebooks to get ideas for querying and joining data from the graph." ] } - ] -} \ No newline at end of file + ], + "metadata": { + "colab": { + "include_colab_link": true, + "machine_shape": "hm", + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/notebooks/analyzing_genomic_data.ipynb b/notebooks/analyzing_genomic_data.ipynb deleted file mode 100644 index e85be1f2..00000000 --- a/notebooks/analyzing_genomic_data.ipynb +++ /dev/null @@ -1,943 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "name": "AnalyzingGenomicDatawithBiomedicalDataCommons.ipynb", - "provenance": [], - "collapsed_sections": [], - "include_colab_link": true - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - } - }, - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "view-in-github", - "colab_type": "text" - }, - "source": [ - "\"Open" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "BrpyeNL6QY7u", - "colab_type": "text" - }, - "source": [ - "# Analyzing Genomic Data with Biomedical Data Commons\n", - "Datacommons is intended for various data science tasks. This tutorial introduces the datacommons knowledge graph and discusses two tools to help integrate its data into your data science projects: (1) the [datacommons browser](https://browser.datacommons.org/) and (2) the [Python API](https://github.com/datacommonsorg/api-python). Before getting started, we will need to install the Python API package.\n" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "qGeY05pnQSeW", - "colab_type": "code", - "colab": {} - }, - "source": [ - "# Install datacommons\n", - "!pip install --upgrade --quiet datacommons" - ], - "execution_count": 1, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "vvXt7uRwQgJE", - "colab_type": "text" - }, - "source": [ - "#What is Biomedical Data Commons?\n", - "Data Commons is an open knowledge graph of structured data. It contains statements about real world objects such as\n", - "* The genome assembly [hg38](https://browser.datacommons.org/kg?dcid=bio%2Fhg38) is a reference genome for the species *[Homo sapiens](https://browser.datacommons.org/kg?dcid=bio%2Fhs)*.\n", - "* For the [hg38](https://browser.datacommons.org/kg?dcid=bio%2Fhg38) genome assembly [chr17](https://browser.datacommons.org/kg?dcid=bio%2Fhg38_chr17) has [83,257,441 base pairs](https://browser.datacommons.org/kg?dcid=BasePairs83257441).\n", - "* [BRCA1](https://browser.datacommons.org/kg?dcid=bio/hg38_BRCA1) genomic coordinates are [chr17](https://browser.datacommons.org/kg?dcid=bio%2Fhg38_chr17):[43,044,294-43,125,483](https://browser.datacommons.org/kg?dcid=Position43044294To43125483) for genome assembly [hg38](https://browser.datacommons.org/kg?dcid=bio%2Fhg38).\n", - "\n", - "In the graph, [entities](https://en.wikipedia.org/wiki/Entity) like the genome assembly [hg38](https://browser.datacommons.org/kg?dcid=bio%2Fhg38) are represented by nodes. Every node has a type corresponding to what the node represents. For example, *[Homo sapiens](https://browser.datacommons.org/kg?dcid=bio%2Fhs)* is a [Species](https://browser.datacommons.org/kg?dcid=Species). Relations between entities are represented by edges between these nodes. For example, the statement \"The genome assembly hg38 is a reference genome for the species *Homo sapiens*.\" is represented in the graph as two nodes: \"hg38\" and \"HomoSapiens\" with an edge labeled \"[is_species](https://browser.datacommons.org/kg?dcid=is_chromosome)\" pointing from \"hg38\" to \"HomoSapiens\". Data Commons follows the [Schema.org data model](https://schema.org/docs/datamodel.html) and leverages schema.org schema to provide a common set of types and properties. To accomodate biological data this schema has been expanded to reflect the schema that has been used across biological databases created by the scientific community." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "S3GA2E_pQmet", - "colab_type": "text" - }, - "source": [ - "#Data Commons Browser\n", - "The Data Commons browser provides a way to explore the data in a human-readable format. It is the best way to explore what is in Data Commons. Searching in the browser for an entity like [BRACA1](https://browser.datacommons.org/kg?dcid=bio/hg38_BRCA1), takes you to a page about the entity, including properties like [refSeqID](https://browser.datacommons.org/kg?dcid=refSeqID) and [typeOfGene](https://browser.datacommons.org/kg?dcid=typeOfGene).\n", - "\n", - "An important property for all entities is the dcid. The dcid (DataCommons identifier) is a unique identifier assigned to each entity in the knowledge graph. With this identifier, you will be able to search for and query information on the given entity in ways that we will discuss later. The dcid is listed at the top of the page next to \"About: \" and also in the list of properties." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "wKXZNB9bQowR", - "colab_type": "text" - }, - "source": [ - "# Python API\n", - "\n", - "The [Python API](https://github.com/datacommonsorg/api-python) provides functions for users to extract structured information from Data Commons programmatically and view them in different formats such as Python `dict`'s and [Pandas](https://pandas.pydata.org/) DataFrames. DataFrames allow access to all the data processing, analytical and visualization tools provided by packages such as Pandas, NumPy, SciPy, and Matplotlib. For more information check out the [documentation](https://datacommons.readthedocs.io/en/latest/modules.html) on the Python API's modules.\n", - "\n", - "Every notebook begins by loading the datacommons library as follows:" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "49VGt66oQjeq", - "colab_type": "code", - "colab": {} - }, - "source": [ - "# Import Data Commons\n", - "import datacommons as dc\n", - "\n", - "# Import other required libraries\n", - "import matplotlib.pyplot as plt\n", - "import matplotlib.patches as mpatches\n", - "import pandas as pd\n", - "import requests\n", - "import json" - ], - "execution_count": 2, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "LRntKMDWQ1Ml", - "colab_type": "text" - }, - "source": [ - "##Example: Identify the Genome Assemblies Supported by Biomedical Data Commons\n", - "For this exercise we will identify the genome assemblies and their related species that are currently supported by Biomedical Data Commons. We will start by looking up the dcid for '[GenomeAssembly](https://browser.datacommons.org/kg?dcid=GenomeAssembly)'.\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "WGEx_kC5Q2Oz", - "colab_type": "text" - }, - "source": [ - "## Using get_property_value to Access Node Properties\n", - "Our first task for this tutorial will be to extract the genome assemblies from Data Commons using the Python API and view it in a Pandas DataFrame. For all properties, one can use [**`get_property_values`**](https://datacommons.readthedocs.io/en/latest/_autosummary/datacommons_core/datacommons.core.get_property_values.html) to get the associated values. Let's look up the dcid of [GenomeAssembly](https://browser.datacommons.org/kg?dcid=GenomeAssembly). We would then like to initialize our Pandas dataframe for the dcid bio/GenomeAssembly.\n", - "\n", - "For all properties, one can use `get_property_values` to get the associated values. We would like to know the instances of \"GenomeAssembly\" by getting the the typeOf instances that are oriented towards the \"GenomeAssembly\" identified by \"bio/GenomeAssembly\". `get_property_values` accepts the following parameters:\n", - "\n", - "\n", - "* **`dcids`** - A list of dcids to get property values for.\n", - "* **`prop`** - The property to get property values for.\n", - "* **`out`**`[=True]` - An optional flag that indicates the property is oriented away from the given nodes if true.\n", - "* **`value_type`**`[=None]` - An optional parameter which filters property values by the given type.\n", - "* **`limit`**`[=100]` - An optional parameter which limits the total number of property values returned aggregated over all given nodes.\n", - "\n", - "When the dcids are given as a Pandas Series, the returned list of property values is a Pandas Series where the i-th entry corresponds to property values associated with the i-th given dcid. Some properties, like containedInPlace, may have many property values. Consequently, the cells of the returned series will always contain a list of property values. Let's take a look:" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "wKxlsd5CQ6dJ", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 36 - }, - "outputId": "349f1b0e-0dda-48b6-876b-25f9009a2395" - }, - "source": [ - "# Call get_property_values. The return value is a dict keyed by 'GenomeAssembly'.\n", - "genomeAssembly_dcids = dc.get_property_values(['GenomeAssembly'], 'typeOf', out=False)['GenomeAssembly']\n", - "# Display the frame\n", - "print(genomeAssembly_dcids)" - ], - "execution_count": 3, - "outputs": [ - { - "output_type": "stream", - "text": [ - "['bio/ce10', 'bio/ce9', 'bio/danRer10', 'bio/danRer11', 'bio/dm3', 'bio/dm6', 'bio/galGal5', 'bio/galGal6', 'bio/hg19', 'bio/hg38', 'bio/mm10', 'bio/mm9', 'bio/sacCer3', 'bio/xenLae2']\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "s9etKR8DQ84d", - "colab_type": "text" - }, - "source": [ - "## Example: List All Genome Assemblies in Human Readable Format\n", - "Let's continue learning about the genome assemblies supported by Biomedical Data Commons. We are next going to find the names and species of the genome assemblies that are associated with the list of dcids of genome assemblies that we found. We are going to display the information in a human readable table." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "Tvl9YAzJQ-z7", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 302 - }, - "outputId": "8e06043a-f323-4d7d-da71-1cf10d021fe0" - }, - "source": [ - "# Intialize the Data Frame\n", - "df_genomeAssemblies = pd.DataFrame()\n", - "\n", - "# Add genome assemblies name and dcid\n", - "df_genomeAssemblies['name'] = pd.Series(dc.get_property_values(genomeAssembly_dcids, 'name'))\n", - "df_genomeAssemblies.reset_index(level=0, inplace=True)\n", - "df_genomeAssemblies = df_genomeAssemblies.rename(columns={\"index\": \"dcid\"}).explode('name')\n", - "\n", - "# Add Species dcid\n", - "df_genomeAssemblies['species_dcid'] = df_genomeAssemblies['dcid'].map(\n", - " dc.get_property_values(df_genomeAssemblies['dcid'], 'ofSpecies'))\n", - "df_genomeAssemblies = df_genomeAssemblies.explode('species_dcid')\n", - "\n", - "# Add Species name\n", - "df_genomeAssemblies['species_name'] = df_genomeAssemblies['species_dcid'].map(\n", - " dc.get_property_values(df_genomeAssemblies['species_dcid'], 'name'))\n", - "df_genomeAssemblies = df_genomeAssemblies.explode('species_name')\n", - "\n", - "print(df_genomeAssemblies)" - ], - "execution_count": 4, - "outputs": [ - { - "output_type": "stream", - "text": [ - " dcid name species_dcid species_name\n", - "0 bio/ce10 ce10 bio/ce CaenorhabditisElegans\n", - "1 bio/ce9 ce9 bio/ce CaenorhabditisElegans\n", - "2 bio/danRer10 danRer10 bio/danRer DanioRerio\n", - "3 bio/danRer11 danRer11 bio/danRer DanioRerio\n", - "4 bio/dm3 dm3 bio/dm DrosophilaMelanogaster\n", - "5 bio/dm6 dm6 bio/dm DrosophilaMelanogaster\n", - "6 bio/galGal5 galGal5 bio/galGal GallusGallus\n", - "7 bio/galGal6 galGal6 bio/galGal GallusGallus\n", - "8 bio/hg19 hg19 bio/hs HomoSapiens\n", - "9 bio/hg38 hg38 bio/hs HomoSapiens\n", - "10 bio/mm10 mm10 bio/mm MusMusculus\n", - "11 bio/mm9 mm9 bio/mm MusMusculus\n", - "12 bio/sacCer3 sacCer3 bio/sacCer SaccharomycesCerevisiae\n", - "13 bio/xenLae2 xenLae2 bio/xenLae XenopusLaevis\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "vXeKzZxlRBc8", - "colab_type": "text" - }, - "source": [ - "Congratulations! You've found the basic information on all the genome assemblies and species currently supported by Biomedical Data Commons. As you can see we currently support data from 8 model organisms across 14 different genome assemblies." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "W4_hSQvJREsA", - "colab_type": "text" - }, - "source": [ - "# Example: Analyze Genetic Variants within RUNX1\n", - "For this exercise, we will be analyzing genetic variants within the gene RUNX1. We will start by identifying the genetic variants within the gene region and then limit our list to those within the coding region of BRCA1 and then to those with known clinical significance. First, let's start by looking up the dcid for '[RUNX1](https://browser.datacommons.org/kg?dcid=bio/hg38_RUNX1)'. \n", - "\n", - "Note that 'Gene' defines the Data Commons type. Let's start by using [**`get_property_labels`**](https://datacommons.readthedocs.io/en/latest/_autosummary/datacommons_core/datacommons.core.get_property_labels.html) to identify all the properties associated with RUNX1. `get_property_labels` accepts the following parameters:\n", - "- **`dcids`** `[list of str]` – A list of nodes identified by their dcids.\n", - "- **`out`** `[bool, optional]` – Whether or not the property points away from the given list of nodes.\n", - "\n", - "The output of `get_property_labels` is a dict mapping dcids to lists of property labels. If out is True, then property labels correspond to edges directed away from given nodes. Otherwise, they correspond to edges directed towards the given nodes." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "IHiMmiBERG3B", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 397 - }, - "outputId": "37911039-8999-4656-bbec-d6d100ba5796" - }, - "source": [ - "# Call get_property_labels\n", - "dc.get_property_labels(['bio/hg38_RUNX1'])" - ], - "execution_count": 5, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "{'bio/hg38_RUNX1': ['description',\n", - " 'fullName',\n", - " 'geneSymbol',\n", - " 'genomicCoordinates',\n", - " 'hasRNATranscript',\n", - " 'inChromosome',\n", - " 'inGenomeAssembly',\n", - " 'mRNA',\n", - " 'mapLocation',\n", - " 'modificationDate',\n", - " 'name',\n", - " 'ncbiGeneID',\n", - " 'ncbiTaxonID',\n", - " 'nomenclatureStatus',\n", - " 'ofSpecies',\n", - " 'provenance',\n", - " 'refSeqID',\n", - " 'strandOrientation',\n", - " 'typeOf',\n", - " 'typeOfGene']}" - ] - }, - "metadata": { - "tags": [] - }, - "execution_count": 5 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "_CXvFjSJRI4_", - "colab_type": "text" - }, - "source": [ - "### Identify RUNX1 Genomic Coordinates\n", - "Great, now we see the type of information known about RUNX1. To identify the genetic variants within the gene region we need to know what the chromosome and ther genomic coordinates of RUNX1. Let's grab that information using `get_property_values`." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "d75k6KVhRMzp", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 55 - }, - "outputId": "23135fce-93d6-4b27-97d7-52b411c89fc3" - }, - "source": [ - "# Initialize the Data Frame\n", - "df_RUNX1 = pd.DataFrame({'gene': ['bio/hg38_RUNX1']})\n", - "\n", - "# Grab the chromosome and genomic coordinates using get_property_values\n", - "df_RUNX1['chromosome'] = df_RUNX1['gene'].map(dc.get_property_values(df_RUNX1['gene'], 'inChromosome'))\n", - "df_RUNX1['genomicCoordinates'] = df_RUNX1['gene'].map(dc.get_property_values(df_RUNX1['gene'], 'genomicCoordinates'))\n", - "\n", - "# display the genomic coordinates\n", - "print(df_RUNX1)\n", - "\n", - "# define start and stop of RUNX1\n", - "start, stop = df_RUNX1['genomicCoordinates'][0][0].strip('Position').split('To')\n", - "start = int(start)\n", - "stop = int(stop)" - ], - "execution_count": 6, - "outputs": [ - { - "output_type": "stream", - "text": [ - " gene chromosome genomicCoordinates\n", - "0 bio/hg38_RUNX1 [bio/hg38_chr21] [Position34787800To35049344]\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "kJoGt1wrRPHu", - "colab_type": "text" - }, - "source": [ - "## Find All The Genetic Variants Within RUNX1\n", - "We found the coordinates of RUNX1 in the hg38 genome: chr21:34787800-35049344. Now that we know this let's find all the genetic variants of class [GeneticVariant](https://browser.datacommons.org/kg?dcid=GeneticVariant) that occur in the region. But first let's establish the information that we know on genetic variants using `get_property_values`.\n" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "ozoN1sE6RROW", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 56 - }, - "outputId": "87898f5a-29f7-4358-a5c3-027850c7ea74" - }, - "source": [ - "# Identify all the properties of genetic variants\n", - "print(dc.get_property_values(['GeneticVariant'], 'domainIncludes', value_type='Property', out=False))" - ], - "execution_count": 7, - "outputs": [ - { - "output_type": "stream", - "text": [ - "{'GeneticVariant': ['alleleOrigin', 'alleleType', 'averageHeterozygosity', 'averageHeterozygositySE', 'clinVarAlleleID', 'clinVarFilterStatus', 'clinVarID', 'clinVarQualityScore', 'clinVarReviewStatus', 'clinicalSignificance', 'clinicalSignificanceConflicting', 'clinicalSignificanceType', 'clinicalSource', 'dbSNPBuildID', 'dbVarID', 'diseaseDescription', 'diseaseName', 'experimentalFactorOntologyID', 'geneID', 'geneReviewsID', 'geneSymbol', 'geneticTestingRegistryID', 'geneticVariantAlignmentQuality', 'geneticVariantAttribute', 'geneticVariantClass', 'geneticVariantExceptions', 'geneticVariantFunctionalCategory', 'geneticVariantImpercise', 'geneticVariantLength', 'geneticVariantLocType', 'geneticVariantSubmitterCount', 'geneticVariantValidationStatus', 'geneticsHomeReferenceID', 'genomicPosition', 'hg19GenomicLocation', 'hg19GenomicPosition', 'hg38GenomicLocation', 'hg38GenomicPosition', 'humanGenomeVariationSocietyNomenclature', 'humanPhenotypeOntologyID', 'medGenID', 'medicalGeneticSummariesID', 'medicalSubjectHeadingID', 'mm10GenomicLocation', 'mm9GenomicLocation', 'molecularType', 'mondoID', 'ncbiGeneID', 'numberOfAllelesWithFreq', 'observedAllele', 'omimID', 'orphaNumber', 'pharmGKBID', 'referenceAlleleNCBI', 'referenceAlleleUCSC', 'referenceSNPClusterID', 'sequenceOntologyID', 'snomedCT', 'submitter', 'suspectReasonCode', 'translocationToChromosome', 'variationEndCI', 'variationPositionCI', 'variationType']}\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "AiMokiMfRTe4", - "colab_type": "text" - }, - "source": [ - "### Using SPARQL and get_property_values to find genetic variants in RUNX1\n", - "Like genes, genetic variants also point to the chromosome on which they reside. Their positions on the chromosome is specified by hg38GenomicPosition. Using [**`query`**](https://datacommons.readthedocs.io/en/latest/_autosummary/datacommons.query.html) we will identify the dcids of all genetic variants on chr21. `query` accepts the following parameter\n", - "- **`query`** `[query_string[, select]]` – Returns the results of executing a SPARQL query on the Data Commons graph.\n", - "\n", - "`query` parameter is a SPARQL query that quickly searches and returns the data that matches the query on multiple parameters. There is no limit to the number of values that can be returned by a SPARQL query. In our query here we will be specifying that we want all genetic variants on chr21. Then we will format all the returned genetic variant dcids into a list and use `get_property_values` again to filter for genetic variants whose hg38GenomicPosition is within RUNX1. " - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "4rFcLP0rRVz5", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 207 - }, - "outputId": "c2f6f4e5-6bd9-4ef1-aea3-53a9525d11ae" - }, - "source": [ - "# Query for genetic variants associated with RUNX1\n", - "query = '''\n", - "SELECT ?gv ?p\n", - "WHERE { \n", - " ?chr dcid \"bio/hg38_chr21\" . \n", - " ?gv inChromosome ?chr .\n", - " ?gv typeOf GeneticVariant .\n", - " ?gv hg38GenomicPosition ?p\n", - "}\n", - "'''\n", - "print(query)\n", - "rows = dc.query(query)\n", - "dcids = set()\n", - "for row in rows:\n", - " dcids.add(row['?gv'])\n", - "dcids = list(dcids)\n", - "print(len(dcids))" - ], - "execution_count": 8, - "outputs": [ - { - "output_type": "stream", - "text": [ - "\n", - "SELECT ?gv ?p\n", - "WHERE { \n", - " ?chr dcid \"bio/hg38_chr21\" . \n", - " ?gv inChromosome ?chr .\n", - " ?gv typeOf GeneticVariant .\n", - " ?gv hg38GenomicPosition ?p\n", - "}\n", - "\n", - "8028\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "Zp3uhwfJRYcA", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 55 - }, - "outputId": "f5effb12-eacc-4182-c570-a0d930c44cbe" - }, - "source": [ - "# filter all genetic variants for the ones within RUNX1\n", - "RUNX1_geneticVariants = []\n", - "gen_positions = dc.get_property_values(dcids, 'hg38GenomicPosition')\n", - "data = pd.DataFrame(gen_positions).transpose()\n", - "data.reset_index(level=0, inplace=True)\n", - "data = data.rename(columns={\"index\": \"dcid\", 0: \"position\"})\n", - "data['position'] = pd.to_numeric(data['position'])\n", - "data = data[data['position'] >= start]\n", - "data = data[data['position'] < stop]\n", - "RUNX1_geneticVariants = list(set(data['dcid']))\n", - "\n", - "# print the first few genetic variants\n", - "print(RUNX1_geneticVariants[:5])\n", - "\n", - "# check how many genetic variants are in RUNX1\n", - "print(len(RUNX1_geneticVariants))" - ], - "execution_count": 9, - "outputs": [ - { - "output_type": "stream", - "text": [ - "['bio/rs1569084170', 'bio/643883', 'bio/rs1569002337', 'bio/839054', 'bio/rs150481777']\n", - "504\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "0Zb9dsK_RfMD", - "colab_type": "text" - }, - "source": [ - "## Identify Which Genetic Variants Are In Coding Regions\n", - "We've identified 360 genetic varaints within RUNX1. However, these can be in introns or exons. Let's further restrict genetic variant list to ones in the coding region of RUNX1. To do this we need to identify the positions of the exons of RUNX1. We know that RUNX1 has a property called rnaTranscript. Let's use `get_property_values` to find out more information on the RUNX1 transcript." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "rbJMK_pbRf2Z", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 93 - }, - "outputId": "9b274fb7-0b75-4508-e980-4e4ce3b000c5" - }, - "source": [ - "# Get property values for rnaTranscript of RUNX1\n", - "df_RUNX1['rnaTranscript'] = df_RUNX1['gene'].map(dc.get_property_values(df_RUNX1['gene'], 'hasRNATranscript'))\n", - "print(df_RUNX1)" - ], - "execution_count": 10, - "outputs": [ - { - "output_type": "stream", - "text": [ - " gene ... rnaTranscript\n", - "0 bio/hg38_RUNX1 ... [bio/hg38_ENST00000300305.7, bio/hg38_ENST0000...\n", - "\n", - "[1 rows x 4 columns]\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "QmXRJpriRift", - "colab_type": "text" - }, - "source": [ - "### Identify the properties of RNATranscripts\n", - "There are several dcids associated with this property which are pointing to nodes of class [RNATranscript](https://browser.datacommons.org/kg?dcid=RNATranscript). Let's verify that this is indeed the case and then check the properties of RNATrancript using `get_property_values`." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "Cbwu_Et1Rk3C", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 150 - }, - "outputId": "64b4424a-ae33-4e40-d8a7-83bb012150a1" - }, - "source": [ - "# Specify an rnaTranscript associated with RUNX1\n", - "RUNX1_transcript = df_RUNX1.iloc[0]['rnaTranscript'][0]\n", - "\n", - "# Check what type the rnaTranscript is\n", - "print(dc.get_property_values([RUNX1_transcript], 'typeOf'))\n", - "\n", - "# Identify properties of RNATranscript\n", - "dict_temp = dc.get_property_values(['RNATranscript'], 'domainIncludes', value_type='Property', out=False)\n", - "for prop in dict_temp['RNATranscript']:\n", - " print(prop)" - ], - "execution_count": 11, - "outputs": [ - { - "output_type": "stream", - "text": [ - "{'bio/hg38_ENST00000300305.7': ['RNATranscript']}\n", - "codingCoordinates\n", - "exonCoordinates\n", - "exonFrame\n", - "makesProtein\n", - "refSeqID\n", - "transcriptionCoordinates\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "rZXoXHFzRm7Q", - "colab_type": "text" - }, - "source": [ - "### Explore the difference between codingCoordinates and exonCoordinates\n", - "There are two properties that may be useful for us in identifying which genetic variants are in the coding region of RUNX1. Let's figure out which one that we'd like to use moving forward by grabbing the values associated with both these properties using `get_property_values`." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "OSH4nzL7RpEy", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 264 - }, - "outputId": "2e49a555-4fc6-4138-c19e-55b883d50468" - }, - "source": [ - "# Get the values for codingCoordinates and exonCoordiantes\n", - "temp_dict = dc.get_property_values([RUNX1_transcript], 'codingCoordinates')\n", - "print('Coding Coordinate Values:')\n", - "for value in temp_dict[RUNX1_transcript]:\n", - " print(value)\n", - "print('\\n')\n", - "temp_dict = dc.get_property_values([RUNX1_transcript], 'exonCoordinates')\n", - "print('Exon Coordinate Values:')\n", - "for value in temp_dict[RUNX1_transcript]:\n", - " print(value)" - ], - "execution_count": 12, - "outputs": [ - { - "output_type": "stream", - "text": [ - "Coding Coordinate Values:\n", - "Position34792134To35048899\n", - "\n", - "\n", - "Exon Coordinate Values:\n", - "Position34787800To34792610\n", - "Position34799300To34799462\n", - "Position34834409To34834601\n", - "Position34859473To34859578\n", - "Position34880556To34880713\n", - "Position34886842To34887096\n", - "Position34892924To34892963\n", - "Position35048841To35049344\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "BqtiSfKFRrIP", - "colab_type": "text" - }, - "source": [ - "### Find the exon coordinates reported for all RNA transcripts of RUNX1\n", - "From the values of codingCoordinates and exonCoordinates we observe that coding coordinates contains the range of base pairs spanning the entire coding region of RUNX1 including introns. Whereas exonCoordinates reports the genomic coordinates of all exons of RUNX1. We want to find all genetic variants in exons of RUNX1, so going forward we want to grab the exonCoordinates of transcripts. There are multiple RNA transcripts reported for RUNX1. Let's make a unique list of all exonCoordinates recorded for RUNX1 using `get_property_values`." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "OHd3PtgLRtkv", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 55 - }, - "outputId": "9a927890-275d-4ee3-b53b-4f2c971ce453" - }, - "source": [ - "# Initiate an empty set\n", - "RUNX1_exonCoordinates = set()\n", - "\n", - "# Using get_property_values get all the exon coordinates for all rnaTranscripts\n", - "for rnaTranscript_dcid in df_RUNX1['rnaTranscript'][0]:\n", - " temp_dict = dc.get_property_values([rnaTranscript_dcid], 'exonCoordinates')\n", - " for item in temp_dict[rnaTranscript_dcid]:\n", - " RUNX1_exonCoordinates.add(item)\n", - "\n", - "# check the firs few exons\n", - "RUNX1_exonCoordinates = list(RUNX1_exonCoordinates)\n", - "print(RUNX1_exonCoordinates[:5])\n", - "\n", - "# check how many unique exon coordinates have been reported for RUNX1\n", - "print(len(RUNX1_exonCoordinates))" - ], - "execution_count": 13, - "outputs": [ - { - "output_type": "stream", - "text": [ - "['Position35049167To35049298', 'Position34791754To34792610', 'Position35988129To35988171', 'Position35984571To35984830', 'Position34859473To34859578']\n", - "41\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "4E26lXFDRvYe", - "colab_type": "text" - }, - "source": [ - "### Identify the genetic variants in the exon coding regions\n", - "Now that we know all the possible reported exon coordinates for RUNX1 we can identify which genetic variants are in exons. Note that RUNX1 has 4 - 9 variants depending on the isoform. Many of these exon coordinates from transcripts of different isoforms are overlapping with each other, but not exact resulting in 41 unique coordinate ranges to be observed. We are interested in genetic variants within any reported exon coordinates in this example and will therefore use them all for our next filtering step. For filtering by overlap in position please remember that the range of the coordinates is [) in which the first number, but not the last number is considered as inside of the range." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "b5i3FNxxRyge", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 36 - }, - "outputId": "125d623a-3a4e-4e56-fe91-0d0ae4a9c10a" - }, - "source": [ - "# initialize empty list for storing genetic variants in RUNX1 exons\n", - "RUNX1_exon_geneticVariants = []\n", - "\n", - "# for each genetic variant identify their hg38GenomicPosition and check if it's in an exon\n", - "for geneticVariant_dcid in RUNX1_geneticVariants:\n", - " position = int(dc.get_property_values([geneticVariant_dcid], 'hg38GenomicPosition')[geneticVariant_dcid][0])\n", - " for exonCoordinates in RUNX1_exonCoordinates:\n", - " start, stop = exonCoordinates.strip('Position').split('To')\n", - " start, stop = int(start), int(stop)\n", - " # filter for variants within RUNX1 exons\n", - " if position >= start and position < stop:\n", - " RUNX1_exon_geneticVariants.append(geneticVariant_dcid)\n", - " break\n", - "RUNX1_exon_geneticVariants = list(set(RUNX1_exon_geneticVariants))\n", - "\n", - "# check how many of the genetic variants are in exons\n", - "print(len(RUNX1_exon_geneticVariants))" - ], - "execution_count": 14, - "outputs": [ - { - "output_type": "stream", - "text": [ - "474\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "6LPPL03eR0ft", - "colab_type": "text" - }, - "source": [ - "### Filter genetic variants for ones that have been clinically studied\n", - "Great! We've identified 345 genetic variants in exons that are worth further consideration. Let's narrow our candidate list further by identifying genetic variants with clinical data associated with them (reported in ClinVar). We can do this by checking if the genetic variant has the property `clinVarID` using `get_property_values`. For ones that have been clinically reported we are going to grab the following additional clinical information for the genetic variant: `diseaseName`, `clinicalSignificance`, and `clinVarReviewStatus`." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "uGmUfs8TR2Fb", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 188 - }, - "outputId": "ef66e1f5-33a9-431d-80b9-9d0e10d759a3" - }, - "source": [ - "# initialize Empty Data Frame\n", - "column_names = ['name', 'clinVarAlleleID', 'diseaseName', 'clinicalSignificance', 'clinVarReviewStatus', 'dcid']\n", - "df_RUNX1_genVar_clinical = pd.DataFrame(columns=column_names)\n", - "\n", - "for geneticVariant_dcid in RUNX1_exon_geneticVariants:\n", - " clinVarID = dc.get_property_values([geneticVariant_dcid], 'clinVarAlleleID')[geneticVariant_dcid][0]\n", - " if clinVarID.isdigit():\n", - " name = geneticVariant_dcid.strip('bio/')\n", - " diseaseName = dc.get_property_values( [geneticVariant_dcid], 'diseaseName')[geneticVariant_dcid][0]\n", - " clinicalSignificance = dc.get_property_values( [geneticVariant_dcid], 'clinicalSignificance')[geneticVariant_dcid][0]\n", - " clinVarReviewStatus = dc.get_property_values( [geneticVariant_dcid], 'clinVarReviewStatus')[geneticVariant_dcid][0]\n", - " df_RUNX1_genVar_clinical = df_RUNX1_genVar_clinical.append({'name': name, 'clinVarAlleleID': clinVarID, 'diseaseName': diseaseName, \\\n", - " 'clinicalSignificance': clinicalSignificance, 'clinVarReviewStatus': clinVarReviewStatus, \\\n", - " 'dcid': geneticVariant_dcid}, ignore_index=True)\n", - "\n", - "# visualize the head of the dataframe containing the clinical info\n", - "print(df_RUNX1_genVar_clinical.head())\n", - "\n", - "# see how many clinical genetic variants in RUNX1\n", - "print(df_RUNX1_genVar_clinical.shape[0])" - ], - "execution_count": 15, - "outputs": [ - { - "output_type": "stream", - "text": [ - " name ... dcid\n", - "0 rs1569084170 ... bio/rs1569084170\n", - "1 643883 ... bio/643883\n", - "2 rs1569002337 ... bio/rs1569002337\n", - "3 839054 ... bio/839054\n", - "4 rs150481777 ... bio/rs150481777\n", - "\n", - "[5 rows x 6 columns]\n", - "474\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "4m57MS1gR4Wp", - "colab_type": "text" - }, - "source": [ - "## Filter For Pathogenic Genetic Variants\n", - "There are 345 genetic variants in the exons of RUNX1 that have recorded clinical information on them. Filter out the ones that are benign to establish our final candidate list of genetic variants that effect the function of RUNX1. We'll do this by filtering our pandas dataframe with the clinical information on the genetic variants." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "PNoAw2XjR6M5", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 55 - }, - "outputId": "2ddae2f0-5b5c-4655-ec85-fbe0d8b775be" - }, - "source": [ - "# identify the clinical significance types for the genetic variants\n", - "print(df_RUNX1_genVar_clinical.clinicalSignificance.unique())" - ], - "execution_count": 16, - "outputs": [ - { - "output_type": "stream", - "text": [ - "['ClinSigPathogenic' 'ClinSigUncertain' 'ClinSigBenign'\n", - " 'ClinSigConflictingPathogenicity']\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "xpmj5i3dR8sb", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 549 - }, - "outputId": "953deea3-fea1-4f84-b4a5-0653010abe74" - }, - "source": [ - "# filter genetic variants for those with pathogenicity\n", - "clinSig = ['ClinSigPathogenic']\n", - "df_final_geneticVariants = df_RUNX1_genVar_clinical[df_RUNX1_genVar_clinical.clinicalSignificance.isin(clinSig)]\n", - "\n", - "# check how many genetic variants made the final cut\n", - "print(df_final_geneticVariants.shape[0])\n", - "\n", - "# identify the diseases associated with these pathogenic variants\n", - "print(df_final_geneticVariants.diseaseName.unique())\n", - "\n", - "# print the final genetic variant dataframe\n", - "print(df_final_geneticVariants)" - ], - "execution_count": 17, - "outputs": [ - { - "output_type": "stream", - "text": [ - "21\n", - "['not provided'\n", - " 'Familial platelet disorder with associated myeloid malignancy'\n", - " 'Acute myeloid leukemia']\n", - " name ... dcid\n", - "0 rs1569084170 ... bio/rs1569084170\n", - "26 871175 ... bio/871175\n", - "64 rs1555889984 ... bio/rs1555889984\n", - "65 rs1569084082 ... bio/rs1569084082\n", - "90 rs587776811 ... bio/rs587776811\n", - "95 rs74315451 ... bio/rs74315451\n", - "129 rs1569008655 ... bio/rs1569008655\n", - "143 rs1569084530 ... bio/rs1569084530\n", - "183 rs1555899813 ... bio/rs1555899813\n", - "192 rs74315450 ... bio/rs74315450\n", - "205 rs1060499616 ... bio/rs1060499616\n", - "207 rs121912498 ... bio/rs121912498\n", - "240 840868 ... bio/840868\n", - "266 rs121912499 ... bio/rs121912499\n", - "321 647118 ... bio/647118\n", - "326 rs1057519748 ... bio/rs1057519748\n", - "377 rs1569061762 ... bio/rs1569061762\n", - "394 rs1569061831 ... bio/rs1569061831\n", - "408 rs1569061768 ... bio/rs1569061768\n", - "444 rs1555884790 ... bio/rs1555884790\n", - "463 869209 ... bio/869209\n", - "\n", - "[21 rows x 6 columns]\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "KF3dr_kAR8Xk", - "colab_type": "text" - }, - "source": [ - "##Conclusion of RUNX1 Analysis\n", - "In this exercise we were able to filter millions of genetic variants to identify a handful that meet our specific parameters. To do this we used multiple datasets from UCSC Genome Browser, NCBI/gene, and ClinVar all in a single python notebook. We found that there are 16 genetic variants in exons of RUNX1, which have been reported to be pathogenic by clinical data. We also learned that these pathogenic variants are associated with Familial platelet disorder with associated myeloid malignancy. Such analyses can preformed using any gene and is a way to easily identify candidate genetic variants of interest. The synthesis of data of different types acorss multiple databases enables easy complex analyses all in a single python notebook." - ] - } - ] -} \ No newline at end of file diff --git a/notebooks/analyzing_income_distribution.ipynb b/notebooks/analyzing_income_distribution.ipynb index 54e27fc6..50e8b5b1 100644 --- a/notebooks/analyzing_income_distribution.ipynb +++ b/notebooks/analyzing_income_distribution.ipynb @@ -1,161 +1,114 @@ { - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "name": "Case Study: Analyzing Income Distribution", - "provenance": [], - "collapsed_sections": [], - "toc_visible": true, - "include_colab_link": true - }, - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - } - }, "cells": [ { "cell_type": "markdown", "metadata": { - "id": "view-in-github", - "colab_type": "text" + "colab_type": "text", + "id": "view-in-github" }, "source": [ - "\"Open" + "\"Open" ] }, { "cell_type": "markdown", "metadata": { - "id": "nnY4S5m_boXI", - "colab_type": "text" + "id": "nnY4S5m_boXI" }, "source": [ - "Copyright 2020 Google LLC.\n", - "SPDX-License-Identifier: Apache-2.0\n", - "\n", - "**Notebook Version** - 1.0.1" + "Copyright 2025 Google LLC.\n", + "SPDX-License-Identifier: Apache-2.0" ] }, - { - "cell_type": "code", - "metadata": { - "id": "9_SFWWxoSoMn", - "colab_type": "code", - "colab": {} - }, - "source": [ - "# Install datacommons\n", - "!pip install datacommons_pandas --upgrade --quiet" - ], - "execution_count": 1, - "outputs": [] - }, { "cell_type": "markdown", "metadata": { - "id": "vWo_v5cI-JXC", - "colab_type": "text" + "id": "vWo_v5cI-JXC" }, "source": [ "# Analyzing Income Distribution\n", "\n", - "The American Community Survey (published by the US Census) annually reports the number of individuals in a given income bracket at the state level. We can use this information, stored in Data Commons, to visualize disparity in income for each state in the US. Our goal for this tutorial will be to generate a plot that visualizes the total number of individuals across a given set of income brackets for a given state. \n", + "The American Community Survey (published by the US Census) annually reports the number of individuals in a given income bracket at the state level. We can use this information, stored in Data Commons, to visualize disparity in income for each state in the US. Our goal for this tutorial will be to generate a plot that visualizes the total number of individuals across a given set of income brackets for a given state.\n", "\n", - "Before we begin, we'll setup our notebook." + "Before we begin, we'll set up our notebook." ] }, { "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/66.3 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m66.3/66.3 kB\u001b[0m \u001b[31m2.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h" + ] + } + ], + "source": [ + "# Install datacommons\n", + "!pip install \"datacommons-client[Pandas]\" --upgrade --quiet" + ] + }, + { + "cell_type": "code", + "execution_count": null, "metadata": { - "id": "OwquZnRa-JXD", - "colab_type": "code", - "colab": {} + "id": "OwquZnRa-JXD" }, + "outputs": [], "source": [ - "# Import the Data Commons Pandas library\n", - "import datacommons_pandas as dc\n", + "# Import the Data Commons library\n", + "import datacommons_client\n", "\n", "# Import other libraries\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", - "import numpy as np\n" - ], - "execution_count": 2, - "outputs": [] + "import numpy as np\n", + "\n", + "YOUR_API_KEY = \"Replace this string with your API key\"\n", + "\n", + "dc_client = datacommons_client.DataCommonsClient(api_key=YOUR_API_KEY)\n" + ] }, { "cell_type": "markdown", "metadata": { - "id": "Hnk34Wgr-JXG", - "colab_type": "text" + "id": "Hnk34Wgr-JXG" }, "source": [ - "## Getting the Data\n", + "## 1. Getting the data\n", "\n", - "The Data Commons graph identifies 16 different income brackets. The list of these variable can be found under the \"Household\" category in our [list of StatisticalVariables](http://docs.datacommons.org/statistical_variables.html).\n", + "The Data Commons graph identifies 16 different income brackets. The list of these variable can be found under the **Economy > Household income** category the [Statistical Variable Explorer](https://datacommons.org/tools/statvar).\n", "\n", - "\n", - "We can use **`get_places_in`** to get all states within the United States. We can then call **`build_multivariate_dataframe`** on the list of states to get a dataframe per-income bracket population counts for each state.\n" + "We can use the [`observations_dataframe`](https://docs.datacommons.org/api/python/v2/pandas.html) method to get a dataframe of values for each of the income brackets for each state in the US." ] }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "2iaVzRE4Z8xG", - "colab_type": "code", - "colab": {} - }, - "source": [ - "states = dc.get_places_in(['country/USA'], 'State')['country/USA']" - ], - "execution_count": 3, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "TBVni9L-Ewmx", - "colab_type": "code", "colab": { "base_uri": "https://localhost:8080/", - "height": 262 + "height": 487 }, - "outputId": "0508eec5-0266-4f4c-983c-dfbd134a25a5" + "id": "TBVni9L-Ewmx", + "outputId": "cd096216-d72c-4c1e-9c08-1a7de9457987" }, - "source": [ - "# A list of income bracket StatisticalVariables\n", - "income_brackets = [\n", - " \"Count_Household_IncomeOfUpto10000USDollar\",\n", - " \"Count_Household_IncomeOf10000To14999USDollar\",\n", - " \"Count_Household_IncomeOf15000To19999USDollar\",\n", - " \"Count_Household_IncomeOf20000To24999USDollar\",\n", - " \"Count_Household_IncomeOf25000To29999USDollar\",\n", - " \"Count_Household_IncomeOf30000To34999USDollar\",\n", - " \"Count_Household_IncomeOf35000To39999USDollar\",\n", - " \"Count_Household_IncomeOf40000To44999USDollar\",\n", - " \"Count_Household_IncomeOf45000To49999USDollar\",\n", - " \"Count_Household_IncomeOf50000To59999USDollar\",\n", - " \"Count_Household_IncomeOf60000To74999USDollar\",\n", - " \"Count_Household_IncomeOf75000To99999USDollar\",\n", - " \"Count_Household_IncomeOf100000To124999USDollar\",\n", - " \"Count_Household_IncomeOf125000To149999USDollar\",\n", - " \"Count_Household_IncomeOf150000To199999USDollar\",\n", - " \"Count_Household_IncomeOf200000OrMoreUSDollar\",\n", - "]\n", - "\n", - "data = dc.build_multivariate_dataframe(states, income_brackets)\n", - "data.head()" - ], - "execution_count": 4, "outputs": [ { - "output_type": "execute_result", "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "repr_error": "Out of range float values are not JSON compliant: nan", + "type": "dataframe", + "variable_name": "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
nameCount_Household_IncomeOf25000To29999USDollarCount_Household_IncomeOf75000To99999USDollarCount_Household_IncomeOf40000To44999USDollarCount_Household_IncomeOf100000To124999USDollarCount_Household_IncomeOf125000To149999USDollarCount_Household_IncomeOfUpto10000USDollarCount_Household_IncomeOf15000To19999USDollarCount_Household_IncomeOf35000To39999USDollarCount_Household_IncomeOf200000OrMoreUSDollarCount_Household_IncomeOf30000To34999USDollarCount_Household_IncomeOf60000To74999USDollarCount_Household_IncomeOf150000To199999USDollarCount_Household_IncomeOf50000To59999USDollarCount_Household_IncomeOf10000To14999USDollarCount_Household_IncomeOf20000To24999USDollarCount_Household_IncomeOf45000To49999USDollar
place
geoId/01Alabama10024421331986970139638824091633121140888921669504984081764647845214785711762910873674023
geoId/02Alaska883036073975929553200431023079628630201348897273112369218000760985678172
geoId/04Arizona125448315900123277211274131233170434118026118929133692125317262334133172210570111075126194107425
geoId/05Arkansas6955612425460069783384481693423706176137537690656751114573992895124745347357651743
geoId/06California51011415895114958841225091877148656515499894480115142105251310811845051082448880868573531536077439574
\n", - "
" + "\n", + " \n", + "
\n", + "\n", + "
\n", + " \n" ], "text/plain": [ - " name ... Count_Household_IncomeOf45000To49999USDollar\n", - "place ... \n", - "geoId/01 Alabama ... 74023\n", - "geoId/02 Alaska ... 8172\n", - "geoId/04 Arizona ... 107425\n", - "geoId/05 Arkansas ... 51743\n", - "geoId/06 California ... 439574\n", - "\n", - "[5 rows x 17 columns]" + " date entity entity_name variable \\\n", + "0 2023 geoId/35 New Mexico Count_Household_IncomeOf100000To124999USDollar \n", + "1 2023 geoId/40 Oklahoma Count_Household_IncomeOf100000To124999USDollar \n", + "2 2023 geoId/10 Delaware Count_Household_IncomeOf100000To124999USDollar \n", + "3 2023 geoId/15 Hawaii Count_Household_IncomeOf100000To124999USDollar \n", + "4 2023 geoId/20 Kansas Count_Household_IncomeOf100000To124999USDollar \n", + "\n", + " variable_name value facetId \\\n", + "0 Households With an Income Between $100,000 and... 73365 1145703171 \n", + "1 Households With an Income Between $100,000 and... 147257 1145703171 \n", + "2 Households With an Income Between $100,000 and... 41828 1145703171 \n", + "3 Households With an Income Between $100,000 and... 53322 1145703171 \n", + "4 Households With an Income Between $100,000 and... 122949 1145703171 \n", + "\n", + " importName measurementMethod observationPeriod \\\n", + "0 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "1 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "2 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "3 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "4 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "\n", + " provenanceUrl unit \n", + "0 https://www.census.gov/programs-surveys/acs/da... None \n", + "1 https://www.census.gov/programs-surveys/acs/da... None \n", + "2 https://www.census.gov/programs-surveys/acs/da... None \n", + "3 https://www.census.gov/programs-surveys/acs/da... None \n", + "4 https://www.census.gov/programs-surveys/acs/da... None " ] }, - "metadata": { - "tags": [] - }, - "execution_count": 5 + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" } + ], + "source": [ + "# A list of income bracket statistical variables\n", + "income_brackets = [\n", + " \"Count_Household_IncomeOfUpto10000USDollar\",\n", + " \"Count_Household_IncomeOf10000To14999USDollar\",\n", + " \"Count_Household_IncomeOf15000To19999USDollar\",\n", + " \"Count_Household_IncomeOf20000To24999USDollar\",\n", + " \"Count_Household_IncomeOf25000To29999USDollar\",\n", + " \"Count_Household_IncomeOf30000To34999USDollar\",\n", + " \"Count_Household_IncomeOf35000To39999USDollar\",\n", + " \"Count_Household_IncomeOf40000To44999USDollar\",\n", + " \"Count_Household_IncomeOf45000To49999USDollar\",\n", + " \"Count_Household_IncomeOf50000To59999USDollar\",\n", + " \"Count_Household_IncomeOf60000To74999USDollar\",\n", + " \"Count_Household_IncomeOf75000To99999USDollar\",\n", + " \"Count_Household_IncomeOf100000To124999USDollar\",\n", + " \"Count_Household_IncomeOf125000To149999USDollar\",\n", + " \"Count_Household_IncomeOf150000To199999USDollar\",\n", + " \"Count_Household_IncomeOf200000OrMoreUSDollar\",\n", + "]\n", + "\n", + "data = dc_client.observations_dataframe(variable_dcids=income_brackets, date='latest', entity_dcids='all', entity_type='State', parent_entity='country/USA')\n", + "data.head()" ] }, { "cell_type": "markdown", "metadata": { - "id": "A6azivEu-JXP", - "colab_type": "text" + "id": "A6azivEu-JXP" }, "source": [ - "## Analyzing the Data\n", + "## 2. Analyzing the data\n", "\n", - "Let's plot our data as a histogram. **Notice that the income ranges as tabulated by the US Census are not equal.** At the low end, the range is 0-9999, whereas, towards the top, the range 150,000-199,999 is five times as broad! **We will make the width of each of the columns correspond to their range, and will give us an idea of the total earnings, not just the number of people in that group.**\n", + "Let's plot our data as a histogram. Notice that the income ranges as tabulated by the US Census are not equal. At the low end, the range is 0-9999, whereas, towards the top, the range 150,000-199,999 is five times as broad! We will make the width of each of the columns correspond to their range, and will give us an idea of the total earnings, not just the number of people in that group.\n", "\n", "First we provide code for generating the plot." ] }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "Bi3lWnu8-JXR", - "colab_type": "code", - "colab": {} + "id": "Bi3lWnu8-JXR" }, + "outputs": [], "source": [ "# Bar chart endpoints (for calculating bar width)\n", "label_to_range = {\n", @@ -588,18 +532,18 @@ "\n", "def plot_income(data, state_name):\n", " # Assert that specified \"state_name\" is a valid state name\n", - " frame_search = data.loc[data['name'] == state_name].squeeze()\n", + " frame_search = data.loc[data['entity_name'] == state_name].squeeze()\n", " if frame_search.shape[0] == 0:\n", " print('{} does not have sufficient income data to generate the plot!'.format(state_name))\n", " return\n", - " \n", + "\n", " # Print the resulting series\n", - " data = frame_search[1:]\n", + " data = frame_search.set_index('variable')['value']\n", "\n", " # Calculate the lengths without intervals\n", " widths_without_interval = []\n", " for bracket in income_brackets:\n", - " r = label_to_range[bracket] \n", + " r = label_to_range[bracket]\n", " widths_without_interval.append(int((r[1] - r[0]) / 18))\n", "\n", " # Calculate the x-axis positions\n", @@ -611,7 +555,7 @@ " # Calculate the bar lengths\n", " widths = []\n", " for bracket in income_brackets:\n", - " r = label_to_range[bracket] \n", + " r = label_to_range[bracket]\n", " # 50 here to be the intervals between bars\n", " widths.append(int((r[1] - r[0]) / 18 - 50))\n", "\n", @@ -623,15 +567,12 @@ "\n", " # Return the resulting frame.\n", " return frame_search" - ], - "execution_count": 6, - "outputs": [] + ] }, { "cell_type": "markdown", "metadata": { - "id": "YsOnc8o4Wpq-", - "colab_type": "text" + "id": "YsOnc8o4Wpq-" }, "source": [ "We can then call this code with a state to plot the income bracket sizes." @@ -639,45 +580,40 @@ }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "JkNBx9KsWtey", - "colab_type": "code", "colab": { "base_uri": "https://localhost:8080/", - "height": 852 + "height": 1000 }, - "outputId": "b5782902-07ed-49dd-8be7-58df79335aea" + "id": "JkNBx9KsWtey", + "outputId": "137a9234-00ca-4710-d764-f5335648f355" }, - "source": [ - "#@title Enter State to plot { run: \"auto\" }\n", - "state_name = \"Idaho\" #@param [\"Missouri\", \"Arkansas\", \"Arizona\", \"Ohio\", \"Connecticut\", \"Vermont\", \"Illinois\", \"South Dakota\", \"Iowa\", \"Oklahoma\", \"Kansas\", \"Washington\", \"Oregon\", \"Hawaii\", \"Minnesota\", \"Idaho\", \"Alaska\", \"Colorado\", \"Delaware\", \"Alabama\", \"North Dakota\", \"Michigan\", \"California\", \"Indiana\", \"Kentucky\", \"Nebraska\", \"Louisiana\", \"New Jersey\", \"Rhode Island\", \"Utah\", \"Nevada\", \"South Carolina\", \"Wisconsin\", \"New York\", \"North Carolina\", \"New Hampshire\", \"Georgia\", \"Pennsylvania\", \"West Virginia\", \"Maine\", \"Mississippi\", \"Montana\", \"Tennessee\", \"New Mexico\", \"Massachusetts\", \"Wyoming\", \"Maryland\", \"Florida\", \"Texas\", \"Virginia\"]\n", - "result = plot_income(data, state_name)\n", - "\n", - "# Show the plot\n", - "plt.show()" - ], - "execution_count": 7, "outputs": [ { - "output_type": "display_data", "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/QAAASXCAYAAABP4jQYAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA+zlJREFUeJzs3XmcVnXdP/73DAwM24Agi4gCruCK4oaWuQEZN+ZSWZn7kn5BU+5cqNzv0jRxud3qdiG9M8SylFCBQCETFUHUcCOlsATUUFAQGJjP7w9vrp/TLMzKNWfm+Xw8fNA557O858x1Tuc113WdU5BSSgEAAABkSmG+CwAAAABqT6AHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIINa57uApqysrCzefffd6NSpUxQUFOS7HAAAAJq5lFJ8/PHH0bt37ygsrP49eIG+Gu+++25ss802+S4DAACAFuadd96JPn36VNtGoK9Gp06dIuKzHVlSUpLnahpWaWlpTJ06NYYNGxZFRUV5H1e/ptEvX+NmvZbG0Nx/vvqwb6pm32SD3xM0HMcTzdHKlStjm222yeXR6gj01dj4MfuSkpJmGejbt28fJSUlDR746jKufk2jX77GzXotjaG5/3z1Yd9Uzb7JBr8naDiOJ5qzmnzt203xAAAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMig1vkuAMifSZNq1z6lz/59/PGIgoKa9Rk5snZzAAAANeMdegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAyqFaB/oorroiCgoJy/w0YMCC3fc2aNTFq1Kjo1q1bdOzYMY477rhYtmxZuTEWL14cI0aMiPbt20ePHj3iwgsvjPXr15dr89RTT8Xee+8dbdu2jR122CHGjx9foZbbbrst+vXrF8XFxbH//vvH888/X257TWoBAACArKr1O/S77rprLFmyJPff008/ndt2wQUXxKRJk+Khhx6KmTNnxrvvvhvHHntsbvuGDRtixIgRsW7dunjmmWfil7/8ZYwfPz4uu+yyXJtFixbFiBEj4tBDD4358+fH+eefH2eccUZMmTIl1+bBBx+MMWPGxOWXXx7z5s2LPffcM4YPHx7vvfdejWsBAACALGtd6w6tW0evXr0qrF+xYkXcfffd8cADD8Rhhx0WERH33ntvDBw4MJ599tk44IADYurUqfHqq6/GH//4x+jZs2cMGjQorr766rj44ovjiiuuiDZt2sSdd94Z/fv3jxtuuCEiIgYOHBhPP/103HjjjTF8+PCIiBg3blyceeaZceqpp0ZExJ133hmTJ0+Oe+65Jy655JIa1VKZtWvXxtq1a3PLK1eujIiI0tLSKC0tre2uatI2/jwN/XPVdVz98tMvpVoNGymVlvu3ZrXUbo6aj9s4r+Gmorn/fPVh31TNvskGvydoOI4nmqPavJ4LUqr5Jf0VV1wR119/fXTu3DmKi4tjyJAhcc0118S2224bM2bMiMMPPzw+/PDD6NKlS65P37594/zzz48LLrggLrvssnj00Udj/vz5ue2LFi2K7bbbLubNmxd77bVXHHzwwbH33nvHTTfdlGtz7733xvnnnx8rVqyIdevWRfv27eM3v/lNHH300bk2J598cnz00UfxyCOP1KiWqn6+K6+8ssL6Bx54INq3b1/T3QQAAAB1snr16vj2t78dK1asiJKSkmrb1uod+v333z/Gjx8fO++8cyxZsiSuvPLK+OIXvxh/+ctfYunSpdGmTZtyAToiomfPnrF06dKIiFi6dGn07NmzwvaN26prs3Llyvj000/jww8/jA0bNlTa5vXXX8+NsalaKjN27NgYM2ZMbnnlypWxzTbbxLBhwza5I7OmtLQ0pk2bFkOHDo2ioqK8j6tffvo9/niNh4yIje/MT4uIoVFQULN6jjyydnPUVGO9hpuK5v7z1Yd9UzX7Jhv8nqDhOJ5ojjZ+UrwmahXoj/zclfkee+wR+++/f/Tt2zcmTpwY7dq1q81QTVLbtm2jbdu2FdYXFRU12xNEY/1sdR1Xv83br6Cg1kNGShEFBUU1DvSNfeg05+Mzovn/fPVh31TNvskGvydoOI4nmpPavJbr9di6Ll26xE477RR//etfo1evXrFu3br46KOPyrVZtmxZ7jv3vXr1qnCn+Y3Lm2pTUlIS7dq1iy233DJatWpVaZvPj7GpWgAAACDL6hXoP/nkk3jrrbdiq622isGDB0dRUVFMnz49t/2NN96IxYsXx5AhQyIiYsiQIfHKK6+Uuxv9tGnToqSkJHbZZZdcm8+PsbHNxjHatGkTgwcPLtemrKwspk+fnmtTk1oAAAAgy2r1kfvvf//7MXLkyOjbt2+8++67cfnll0erVq3iW9/6VnTu3DlOP/30GDNmTHTt2jVKSkri3HPPjSFDhuTuKj9s2LDYZZdd4sQTT4zrrrsuli5dGj/60Y9i1KhRuY+6n3322XHrrbfGRRddFKeddlrMmDEjJk6cGJMnT87VMWbMmDj55JNjn332if322y9uuummWLVqVe6u9zWpBQAAALKsVoH+H//4R3zrW9+Kf/3rX9G9e/f4whe+EM8++2x07949IiJuvPHGKCwsjOOOOy7Wrl0bw4cPj9tvvz3Xv1WrVvGHP/whzjnnnBgyZEh06NAhTj755Ljqqqtybfr37x+TJ0+OCy64IG6++ebo06dP3HXXXblH1kVEHH/88fH+++/HZZddFkuXLo1BgwbFE088Ue5GeZuqBQAAALKsVoF+woQJ1W4vLi6O2267LW677bYq2/Tt2zcee+yxasc55JBD4sUXX6y2zejRo2P06NH1qgUAAACyql7foQcAAADyQ6AHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADKpXoL/22mujoKAgzj///Ny6NWvWxKhRo6Jbt27RsWPHOO6442LZsmXl+i1evDhGjBgR7du3jx49esSFF14Y69evL9fmqaeeir333jvatm0bO+ywQ4wfP77C/Lfddlv069cviouLY//994/nn3++3Paa1AIAAABZVOdAP2fOnPj5z38ee+yxR7n1F1xwQUyaNCkeeuihmDlzZrz77rtx7LHH5rZv2LAhRowYEevWrYtnnnkmfvnLX8b48ePjsssuy7VZtGhRjBgxIg499NCYP39+nH/++XHGGWfElClTcm0efPDBGDNmTFx++eUxb9682HPPPWP48OHx3nvv1bgWAAAAyKo6BfpPPvkkTjjhhPif//mf2GKLLXLrV6xYEXfffXeMGzcuDjvssBg8eHDce++98cwzz8Szzz4bERFTp06NV199Nf73f/83Bg0aFEceeWRcffXVcdttt8W6desiIuLOO++M/v37xw033BADBw6M0aNHx9e+9rW48cYbc3ONGzcuzjzzzDj11FNjl112iTvvvDPat28f99xzT41rAQAAgKxqXZdOo0aNihEjRsQRRxwR//Vf/5VbP3fu3CgtLY0jjjgit27AgAGx7bbbxuzZs+OAAw6I2bNnx+677x49e/bMtRk+fHicc845sWDBgthrr71i9uzZ5cbY2GbjR/vXrVsXc+fOjbFjx+a2FxYWxhFHHBGzZ8+ucS3/bu3atbF27drc8sqVKyMiorS0NEpLS+uyq5qsjT9PQ/9cdR1Xv/z0S6lWw0ZKpeX+rVkttZuj5uM2zmu4qWjuP1992DdVs2+ywe8JGo7jieaoNq/nWgf6CRMmxLx582LOnDkVti1dujTatGkTXbp0Kbe+Z8+esXTp0lybz4f5jds3bquuzcqVK+PTTz+NDz/8MDZs2FBpm9dff73Gtfy7a665Jq688soK66dOnRrt27evtE/WTZs2rUmNq1/T6FeDkWv8x4DHHmukEjZW0mg/Y9PQ3H+++rBvqmbfZIPfEzQcxxPNyerVq2vctlaB/p133onvfe97MW3atCguLq51YU3d2LFjY8yYMbnllStXxjbbbBPDhg2LkpKSPFbW8EpLS2PatGkxdOjQKCoqyvu4+uWn3+OP13jIiNj4zvy0iBgaBQU1q+fII2s3R0011mu4qWjuP1992DdVs2+ywe8JGo7jieZo4yfFa6JWgX7u3Lnx3nvvxd57751bt2HDhpg1a1bceuutMWXKlFi3bl189NFH5d4ZX7ZsWfTq1SsiInr16lXhbvQb7zz/+Tb/fjf6ZcuWRUlJSbRr1y5atWoVrVq1qrTN58fYVC3/rm3bttG2bdsK64uKiprtCaKxfra6jqvf5u1XUFDrISOliIKCohoH+sY+dJrz8RnR/H+++rBvqmbfZIPfEzQcxxPNSW1ey7W6Kd7hhx8er7zySsyfPz/33z777BMnnHBC7n8XFRXF9OnTc33eeOONWLx4cQwZMiQiIoYMGRKvvPJKubvRT5s2LUpKSmKXXXbJtfn8GBvbbByjTZs2MXjw4HJtysrKYvr06bk2gwcP3mQtAAAAkFW1eoe+U6dOsdtuu5Vb16FDh+jWrVtu/emnnx5jxoyJrl27RklJSZx77rkxZMiQ3E3ohg0bFrvsskuceOKJcd1118XSpUvjRz/6UYwaNSr37vjZZ58dt956a1x00UVx2mmnxYwZM2LixIkxefLk3LxjxoyJk08+OfbZZ5/Yb7/94qabbopVq1bFqaeeGhERnTt33mQtAAAAkFV1ust9dW688cYoLCyM4447LtauXRvDhw+P22+/Pbe9VatW8Yc//CHOOeecGDJkSHTo0CFOPvnkuOqqq3Jt+vfvH5MnT44LLrggbr755ujTp0/cddddMXz48Fyb448/Pt5///247LLLYunSpTFo0KB44oknyt0ob1O1AAAAQFbVO9A/9dRT5ZaLi4vjtttui9tuu63KPn379o3HNnHr60MOOSRefPHFatuMHj06Ro8eXeX2mtQCAAAAWVSr79ADAAAATYNADwAAABkk0AMAAEAGCfQAAACQQQI9AAAAZJBADwAAABkk0AMAAEAGCfQAAACQQQI9AAAAZJBADwAAABkk0AMAAEAGCfQAAACQQQI9AAAAZJBADwAAABkk0AMAAEAGCfQAAACQQQI9AAAAZJBADwAAABkk0AMAAEAGtc53AdDcTJpUcV1Kn/37+OMRBQXlt40c2fg1AQAAzY936AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIoNb5LoDsmjSp4rqUPvv38ccjCgr+//UjR26emgAAAFoK79ADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABrXOdwE0nEmTat42pc/+ffzxiIKCmvcbObJ2NQEAANA4vEMPAAAAGSTQAwAAQAYJ9AAAAJBBAj0AAABkkEAPAAAAGSTQAwAAQAYJ9AAAAJBBAj0AAABkkEAPAAAAGSTQAwAAQAYJ9AAAAJBBAj0AAABkkEAPAAAAGSTQAwAAQAYJ9AAAAJBBAj0AAABkkEAPAAAAGSTQAwAAQAYJ9AAAAJBBAj0AAABkkEAPAAAAGSTQAwAAQAYJ9AAAAJBBAj0AAABkkEAPAAAAGSTQAwAAQAYJ9AAAAJBBAj0AAABkkEAPAAAAGSTQAwAAQAYJ9AAAAJBBAj0AAABkkEAPAAAAGVSrQH/HHXfEHnvsESUlJVFSUhJDhgyJxx9/PLd9zZo1MWrUqOjWrVt07NgxjjvuuFi2bFm5MRYvXhwjRoyI9u3bR48ePeLCCy+M9evXl2vz1FNPxd577x1t27aNHXbYIcaPH1+hlttuuy369esXxcXFsf/++8fzzz9fbntNagEAAICsqlWg79OnT1x77bUxd+7ceOGFF+Kwww6Lr371q7FgwYKIiLjgggti0qRJ8dBDD8XMmTPj3XffjWOPPTbXf8OGDTFixIhYt25dPPPMM/HLX/4yxo8fH5dddlmuzaJFi2LEiBFx6KGHxvz58+P888+PM844I6ZMmZJr8+CDD8aYMWPi8ssvj3nz5sWee+4Zw4cPj/feey/XZlO1AAAAQJbVKtCPHDkyvvKVr8SOO+4YO+20U/z4xz+Ojh07xrPPPhsrVqyIu+++O8aNGxeHHXZYDB48OO6999545pln4tlnn42IiKlTp8arr74a//u//xuDBg2KI488Mq6++uq47bbbYt26dRERceedd0b//v3jhhtuiIEDB8bo0aPja1/7Wtx44425OsaNGxdnnnlmnHrqqbHLLrvEnXfeGe3bt4977rknIqJGtQAAAECWta5rxw0bNsRDDz0Uq1atiiFDhsTcuXOjtLQ0jjjiiFybAQMGxLbbbhuzZ8+OAw44IGbPnh2777579OzZM9dm+PDhcc4558SCBQtir732itmzZ5cbY2Ob888/PyIi1q1bF3Pnzo2xY8fmthcWFsYRRxwRs2fPjoioUS2VWbt2baxduza3vHLlyoiIKC0tjdLS0jruqc0npdq0LS33b019fjdUNl9V425q923cv7Xdz02xX232y2dj1W+++vSrzWvms/a1f9001qFT132TFc3956sP+6Zq9k02+D1Bw3E80RzV5vVc60D/yiuvxJAhQ2LNmjXRsWPH+N3vfhe77LJLzJ8/P9q0aRNdunQp175nz56xdOnSiIhYunRpuTC/cfvGbdW1WblyZXz66afx4YcfxoYNGypt8/rrr+fG2FQtlbnmmmviyiuvrLB+6tSp0b59+yr7Zdu0WoW6xx6r27g17Tdt2rSaF5PBfpXt75rsm81f5yZHrvHrpuavmTpW0mg/Y9PQ3H+++rBvqmbfZIPfEzQcxxPNyerVq2vcttaBfuedd4758+fHihUr4je/+U2cfPLJMXPmzNoO0ySNHTs2xowZk1teuXJlbLPNNjFs2LAoKSnJY2U187n7E27SZ++wTouIoVFQUFTjfkceWf18VY37+X6VKS0tjWnTpsXQoUOjqKjm9TTFfrXZLxHV75vG/vlq85qJqNvrZlO/+7qq677Jiub+89WHfVM1+yYb/J6g4TieaI42flK8Jmod6Nu0aRM77LBDREQMHjw45syZEzfffHMcf/zxsW7duvjoo4/KvTO+bNmy6NWrV0RE9OrVq8Ld6Dfeef7zbf79bvTLli2LkpKSaNeuXbRq1SpatWpVaZvPj7GpWirTtm3baNu2bYX1RUVFmThBFBTUrn1KEQUFRbUK9J/fDVXNV9m4Nd19dd3XTalfbfbLZ2PVb7769Kvtayai9q+bxj50snJ81lVz//nqw76pmn2TDX5P0HAcTzQntXkt1/s59GVlZbF27doYPHhwFBUVxfTp03Pb3njjjVi8eHEMGTIkIiKGDBkSr7zySrm70U+bNi1KSkpil112ybX5/Bgb22wco02bNjF48OBybcrKymL69Om5NjWpBQAAALKsVu/Qjx07No488sjYdttt4+OPP44HHnggnnrqqZgyZUp07tw5Tj/99BgzZkx07do1SkpK4txzz40hQ4bkbkI3bNiw2GWXXeLEE0+M6667LpYuXRo/+tGPYtSoUbl3xs8+++y49dZb46KLLorTTjstZsyYERMnTozJkyfn6hgzZkycfPLJsc8++8R+++0XN910U6xatSpOPfXUiIga1QIAAABZVqtA/95778VJJ50US5Ysic6dO8cee+wRU6ZMiaFDh0ZExI033hiFhYVx3HHHxdq1a2P48OFx++235/q3atUq/vCHP8Q555wTQ4YMiQ4dOsTJJ58cV111Va5N//79Y/LkyXHBBRfEzTffHH369Im77rorhg8fnmtz/PHHx/vvvx+XXXZZLF26NAYNGhRPPPFEuRvlbaoWAAAAyLJaBfq777672u3FxcVx2223xW233VZlm759+8Zjm7jt9SGHHBIvvvhitW1Gjx4do0ePrlctAAAAkFX1/g49AAAAsPkJ9AAAAJBBAj0AAABkkEAPAAAAGSTQAwAAQAYJ9AAAAJBBAj0AAABkkEAPAAAAGSTQAwAAQAYJ9AAAAJBBAj0AAABkkEAPAAAAGSTQAwAAQAYJ9AAAAJBBAj0AAABkkEAPAAAAGSTQAwAAQAYJ9AAAAJBBAj0AAABkkEAPAAAAGSTQAwAAQAYJ9AAAAJBBAj0AAABkkEAPAAAAGSTQAwAAQAYJ9AAAAJBBAj0AAABkkEAPAAAAGSTQAwAAQAYJ9AAAAJBBAj0AAABkkEAPAAAAGSTQAwAAQAYJ9AAAAJBBAj0AAABkkEAPAAAAGSTQAwAAQAYJ9AAAAJBBAj0AAABkkEAPAAAAGSTQAwAAQAYJ9AAAAJBBAj0AAABkkEAPAAAAGSTQAwAAQAYJ9AAAAJBBAj0AAABkUOt8FwDU36RJ5ZdT+uzfxx+PKCgov23kyM1TEwAA0Li8Qw8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZ1DrfBQCfmTSp4rqUPvv38ccjCgrKbxs5svFrAgAAmi7v0AMAAEAGCfQAAACQQQI9AAAAZJBADwAAABkk0AMAAEAGCfQAAACQQQI9AAAAZJBADwAAABkk0AMAAEAGCfQAAACQQQI9AAAAZJBADwAAABkk0AMAAEAGCfQAAACQQQI9AAAAZJBADwAAABkk0AMAAEAGCfQAAACQQQI9AAAAZJBADwAAABkk0AMAAEAGCfQAAACQQQI9AAAAZJBADwAAABkk0AMAAEAGCfQAAACQQQI9AAAAZJBADwAAABkk0AMAAEAGCfQAAACQQQI9AAAAZJBADwAAABkk0AMAAEAGCfQAAACQQQI9AAAAZJBADwAAABkk0AMAAEAGCfQAAACQQQI9AAAAZJBADwAAABkk0AMAAEAGCfQAAACQQQI9AAAAZJBADwAAABkk0AMAAEAGCfQAAACQQQI9AAAAZJBADwAAABkk0AMAAEAGCfQAAACQQQI9AAAAZJBADwAAABkk0AMAAEAGCfQAAACQQQI9AAAAZJBADwAAABkk0AMAAEAGCfQAAACQQQI9AAAAZJBADwAAABkk0AMAAEAGCfQAAACQQQI9AAAAZJBADwAAABkk0AMAAEAGCfQAAACQQQI9AAAAZJBADwAAABkk0AMAAEAG1SrQX3PNNbHvvvtGp06dokePHnH00UfHG2+8Ua7NmjVrYtSoUdGtW7fo2LFjHHfccbFs2bJybRYvXhwjRoyI9u3bR48ePeLCCy+M9evXl2vz1FNPxd577x1t27aNHXbYIcaPH1+hnttuuy369esXxcXFsf/++8fzzz9f61oAAAAgi2oV6GfOnBmjRo2KZ599NqZNmxalpaUxbNiwWLVqVa7NBRdcEJMmTYqHHnooZs6cGe+++24ce+yxue0bNmyIESNGxLp16+KZZ56JX/7ylzF+/Pi47LLLcm0WLVoUI0aMiEMPPTTmz58f559/fpxxxhkxZcqUXJsHH3wwxowZE5dffnnMmzcv9txzzxg+fHi89957Na4FAAAAsqp1bRo/8cQT5ZbHjx8fPXr0iLlz58bBBx8cK1asiLvvvjseeOCBOOywwyIi4t57742BAwfGs88+GwcccEBMnTo1Xn311fjjH/8YPXv2jEGDBsXVV18dF198cVxxxRXRpk2buPPOO6N///5xww03RETEwIED4+mnn44bb7wxhg8fHhER48aNizPPPDNOPfXUiIi48847Y/LkyXHPPffEJZdcUqNaAAAAIKtqFej/3YoVKyIiomvXrhERMXfu3CgtLY0jjjgi12bAgAGx7bbbxuzZs+OAAw6I2bNnx+677x49e/bMtRk+fHicc845sWDBgthrr71i9uzZ5cbY2Ob888+PiIh169bF3LlzY+zYsbnthYWFccQRR8Ts2bNrXMu/W7t2baxduza3vHLlyoiIKC0tjdLS0jrto80ppdq0LS33b019fjdUNl9V425q923cv7Xdz02xX232y2dj1a9fZX3r2m9T6vK6aaxDp66/w6xo7j9ffdg3VbNvssHvCRqO44nmqDav5zoH+rKysjj//PPjoIMOit122y0iIpYuXRpt2rSJLl26lGvbs2fPWLp0aa7N58P8xu0bt1XXZuXKlfHpp5/Ghx9+GBs2bKi0zeuvv17jWv7dNddcE1deeWWF9VOnTo327dtXtSsyblqtQt1jj9Vt3Jr2mzZtWs2LyWC/yvZ3zfbN5u5X+3Gr0jDzVVNJnX8X2dDcf776sG+qZt9kg98TNBzHE83J6tWra9y2zoF+1KhR8Ze//CWefvrpug7R5IwdOzbGjBmTW165cmVss802MWzYsCgpKcljZTXz+OM1b/vZO6zTImJoFBQU1bjfkUdWP19V436+X2VKS0tj2rRpMXTo0Cgqqnk9TbFfbfZLxP+/b+rar7K+de23KXV53Wzqd19Xdf0dZkVz//nqw76pmn2TDX5P0HAcTzRHGz8pXhN1CvSjR4+OP/zhDzFr1qzo06dPbn2vXr1i3bp18dFHH5V7Z3zZsmXRq1evXJt/vxv9xjvPf77Nv9+NftmyZVFSUhLt2rWLVq1aRatWrSpt8/kxNlXLv2vbtm20bdu2wvqioqJMnCAKCmrXPqWIgoKiWgX6z++GquarbNya7r667uum1K82++WzserXr6q+de23KbV93TT2oZOV47OumvvPVx/2TdXsm2zwe4KG43iiOanNa7lWd7lPKcXo0aPjd7/7XcyYMSP69+9fbvvgwYOjqKgopk+fnlv3xhtvxOLFi2PIkCERETFkyJB45ZVXyt2Nftq0aVFSUhK77LJLrs3nx9jYZuMYbdq0icGDB5drU1ZWFtOnT8+1qUktAAAAkFW1eod+1KhR8cADD8QjjzwSnTp1yn0XvXPnztGuXbvo3LlznH766TFmzJjo2rVrlJSUxLnnnhtDhgzJ3YRu2LBhscsuu8SJJ54Y1113XSxdujR+9KMfxahRo3Lvjp999tlx6623xkUXXRSnnXZazJgxIyZOnBiTJ0/O1TJmzJg4+eSTY5999on99tsvbrrppli1alXurvc1qQUAAACyqlaB/o477oiIiEMOOaTc+nvvvTdOOeWUiIi48cYbo7CwMI477rhYu3ZtDB8+PG6//fZc21atWsUf/vCHOOecc2LIkCHRoUOHOPnkk+Oqq67Ktenfv39Mnjw5Lrjggrj55pujT58+cdddd+UeWRcRcfzxx8f7778fl112WSxdujQGDRoUTzzxRLkb5W2qFgAAAMiqWgX6VIPbWhcXF8dtt90Wt912W5Vt+vbtG49t4tbXhxxySLz44ovVthk9enSMHj26XrUAAABAFtXqO/QAAABA0yDQAwAAQAYJ9AAAAJBBAj0AAABkkEAPAAAAGSTQAwAAQAYJ9AAAAJBBAj0AAABkkEAPAAAAGSTQAwAAQAYJ9AAAAJBBAj0AAABkkEAPAAAAGSTQAwAAQAYJ9AAAAJBBAj0AAABkkEAPAAAAGSTQAwAAQAYJ9AAAAJBBAj0AAABkkEAPAAAAGdQ63wVAY5s0qeK6lD779/HHIwoKym8bObLxawIAAKgv79ADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZJNADAABABgn0AAAAkEECPQAAAGSQQA8AAAAZ1DrfBQAtx6RJDTdWSp/9+/jjEQUFDTPmyJENMw4AAGwO3qEHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMgggR4AAAAySKAHAACADBLoAQAAIIMEegAAAMigWgf6WbNmxciRI6N3795RUFAQv//978ttTynFZZddFltttVW0a9cujjjiiFi4cGG5NsuXL48TTjghSkpKokuXLnH66afHJ598Uq7Nyy+/HF/84hejuLg4ttlmm7juuusq1PLQQw/FgAEDori4OHbfffd47LHHal0LAAAAZFGtA/2qVatizz33jNtuu63S7dddd13ccsstceedd8Zzzz0XHTp0iOHDh8eaNWtybU444YRYsGBBTJs2Lf7whz/ErFmz4qyzzsptX7lyZQwbNiz69u0bc+fOjeuvvz6uuOKK+MUvfpFr88wzz8S3vvWtOP300+PFF1+Mo48+Oo4++uj4y1/+UqtaAAAAIIta17bDkUceGUceeWSl21JKcdNNN8WPfvSj+OpXvxoREffdd1/07Nkzfv/738c3v/nNeO211+KJJ56IOXPmxD777BMREf/93/8dX/nKV+JnP/tZ9O7dO371q1/FunXr4p577ok2bdrErrvuGvPnz49x48blgv/NN98cX/7yl+PCCy+MiIirr746pk2bFrfeemvceeedNaoFAAAAsqrWgb46ixYtiqVLl8YRRxyRW9e5c+fYf//9Y/bs2fHNb34zZs+eHV26dMmF+YiII444IgoLC+O5556LY445JmbPnh0HH3xwtGnTJtdm+PDh8dOf/jQ+/PDD2GKLLWL27NkxZsyYcvMPHz489xWAmtTy79auXRtr167NLa9cuTIiIkpLS6O0tLR+O2czSKk2bUvL/VtTn98Nlc1X1bib2n0b929t93NN+tWmzs/Gys989anz3/vWtd+m1OV1U5/5GrqWTWlKh3ldj4mWwL6pmn2TDX5P0HAcTzRHtXk9N2igX7p0aURE9OzZs9z6nj175rYtXbo0evToUb6I1q2ja9eu5dr079+/whgbt22xxRaxdOnSTc6zqVr+3TXXXBNXXnllhfVTp06N9u3bV/FTZ920WoWsf7tNQY3HrWm/adOm1byYBuhX2c9fk1o393ybv1/tx61Kw8xXndq9hqvT+LXWXt1fa82ffVM1+yYb/J6g4TieaE5Wr15d47YNGuizbuzYseXe9V+5cmVss802MWzYsCgpKcljZTXz+OM1b/vZu5rTImJoFBQU1bjf579tUdl8VY1bxbc0ckpLS2PatGkxdOjQKCqqeT016VebOjdVa2POV586/71vXfttSl1eN/WZr6Fr2ZRNvU43p7oeEy2BfVM1+yYb/J6g4TieaI42flK8Jho00Pfq1SsiIpYtWxZbbbVVbv2yZcti0KBBuTbvvfdeuX7r16+P5cuX5/r36tUrli1bVq7NxuVNtfn89k3V8u/atm0bbdu2rbC+qKgoEyeIgoLatU8poqCgqFZh6PO7oar5Khu3pruvrvu6un61qfOzsfIzX33qrKxvXfttSm1fN/WdryFr2ZSmeJhn5fyTD/ZN1eybbPB7gobjeKI5qc1ruUGfQ9+/f//o1atXTJ8+Pbdu5cqV8dxzz8WQIUMiImLIkCHx0Ucfxdy5c3NtZsyYEWVlZbH//vvn2syaNavcdwemTZsWO++8c2yxxRa5Np+fZ2ObjfPUpBYAAADIqloH+k8++STmz58f8+fPj4jPbj43f/78WLx4cRQUFMT5558f//Vf/xWPPvpovPLKK3HSSSdF79694+ijj46IiIEDB8aXv/zlOPPMM+P555+PP//5zzF69Oj45je/Gb17946IiG9/+9vRpk2bOP3002PBggXx4IMPxs0331zu4/Df+9734oknnogbbrghXn/99bjiiivihRdeiNGjR0dE1KgWAAAAyKpaf+T+hRdeiEMPPTS3vDFkn3zyyTF+/Pi46KKLYtWqVXHWWWfFRx99FF/4whfiiSeeiOLi4lyfX/3qVzF69Og4/PDDo7CwMI477ri45ZZbcts7d+4cU6dOjVGjRsXgwYNjyy23jMsuu6zcs+oPPPDAeOCBB+JHP/pR/OAHP4gdd9wxfv/738duu+2Wa1OTWgAAACCLah3oDznkkEjV3FK6oKAgrrrqqrjqqquqbNO1a9d44IEHqp1njz32iD/96U/Vtvn6178eX//61+tVCwAAAGRRg36HHgAAANg8BHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIoNb5LgBqatKkiutS+uzfxx+PKCgov23kyMavCQAAIF8EeqiCPyAAAABNmY/cAwAAQAYJ9AAAAJBBAj0AAABkkEAPAAAAGeSmeAAANCmV3ZgWKlPdDYuhMs3tRtbeoQcAAIAMEugBAAAggwR6AAAAyCDfoQf4N03hu5tN7TuBze37ZgAAzYF36AEAACCDvEMPQI359EJ5PrmwaU3hNdPUNKXXcFPieAKoPe/QAwAAQAYJ9AAAAJBBAj0AAABkkO/Qs9lV9n3K6r5P6Dt1AAAAFXmHHgAAADJIoAcAAIAMEugBAAAggwR6AAAAyCCBHgAAADJIoAcAAIAMEugBAAAggwR6AAAAyKDW+S4AAJqDSZPyXUFESp/9+/jjEQUF+a1l5Mj8zg8ALYF36AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMkigBwAAgAwS6AEAACCDBHoAAADIIIEeAAAAMqhFBPrbbrst+vXrF8XFxbH//vvH888/n++SAAAAoF6afaB/8MEHY8yYMXH55ZfHvHnzYs8994zhw4fHe++9l+/SAAAAoM5a57uAxjZu3Lg488wz49RTT42IiDvvvDMmT54c99xzT1xyySXl2q5duzbWrl2bW16xYkVERCxfvjxKS0s3X9F1tGpVzdumVBoRqyPiX1FQUFTjfv/6V/XzVTVuXft9vq9+lferrG9d+21KXV439ZmvoWvZlOp+F5tbY/x89WHfVK6xXt911RT3TVPYL01NU/o9NSVN7XgiGxxP1NbnzzVN1ccffxwRESmlTbZt1oF+3bp1MXfu3Bg7dmxuXWFhYRxxxBExe/bsCu2vueaauPLKKyus79+/f6PWCQAAAJ/38ccfR+fOnatt06wD/QcffBAbNmyInj17llvfs2fPeP311yu0Hzt2bIwZMya3XFZWFsuXL49u3bpFQUFBo9e7Oa1cuTK22WabeOedd6KkpCTv4+rXNPrla9ys19IYmvvPVx/2TdXsm2zwe4KG43iiOUopxccffxy9e/feZNtmHehrq23bttG2bdty67p06ZKfYjaTkpKSRjn51XVc/ZpGv3yNWxdNqZbG0Nx/vvqwb6pm32SD3xM0HMcTzc2m3pnfqFnfFG/LLbeMVq1axbJly8qtX7ZsWfTq1StPVQEAAED9NetA36ZNmxg8eHBMnz49t66srCymT58eQ4YMyWNlAAAAUD/N/iP3Y8aMiZNPPjn22Wef2G+//eKmm26KVatW5e5631K1bds2Lr/88gpfMcjXuPo1jX75GjfrtTSG5v7z1Yd9UzX7Jhv8nqDhOJ5o6QpSTe6Fn3G33nprXH/99bF06dIYNGhQ3HLLLbH//vvnuywAAACosxYR6AEAAKC5adbfoQcAAIDmSqAHAACADBLoAQAAIIMEegAAAMgggb6FWL9+fdx3332xbNmyBhtzw4YNMWvWrPjoo4+aRD3VSSnF4sWLY82aNebL45j10dTqaWj1OZ6au9LS0jj88MNj4cKF+S4FgDxr7tcDUFsCfQvRunXrOPvssxv05NeqVasYNmxYfPjhh5utntLS0mjdunX85S9/qVW/lFLssMMO8c4775gvj2PWR1Orp6HV53hq7oqKiuLll1/OdxlNUmlpaWy//fbx2muv5bsUqlHXcztQUXO/HoDaEuhbkP322y/mz5/foGPutttu8fbbb2+2eoqKimLbbbeNDRs21KpfYWFh7LjjjvGvf/3LfHkcsz6aWj2NoT7HU3P3ne98J+6+++58l9HkFBUVeZcqA+p6bgcqagnXA1AbnkPfgkycODHGjh0bF1xwQQwePDg6dOhQbvsee+xR6zGfeOKJGDt2bFx99dWVjllSUtLg9dx9993x8MMPx/333x9du3atca2TJk2K6667Lu64447Ybbfdatyvuc+3ucdsTvU0tPocT83dueeeG/fdd1/suOOOle6bcePG5amy/PvJT34Sb775Ztx1113RunXrfJdDFep6bgcqau7XA1AbAn0LUlhY8QMZBQUFkVKKgoKCOr1z8PkxCwoKcv+7JmPWtZ699tor/vrXv0ZpaWn07du3woX9vHnzKu23xRZbxOrVq2P9+vXRpk2baNeuXbnty5cvb5HzVacxxqyPplZPQ6vP8dTcHXrooVVuKygoiBkzZmzGapqWY445JqZPnx4dO3aM3XffvcI54+GHH85TZXxeXc/tQEXN/XoAasOf8luQRYsWNfiYTz75ZJ371rWeo48+uk79brrpJvM1gTHro6nV09Dqczw1d/ZN1bp06RLHHXdcvstgE+p6bgcqau7XA1Ab3qEHAACADPIOfQv06quvxuLFi2PdunXl1h911FF1HnP16tWVjlmT7+U3Rj2bsmbNmgrzNeb3k5vDfJv7Z9iUplZPQ6rP8dScvfDCCzFx4sRK942PlQO0TM35egBqQqBvQd5+++045phj4pVXXsl9Vz3i//+ubl2+n/v+++/HqaeeGo8//nil26sbs671bNiwIW688cYqL+yr+t7UqlWr4uKLL46JEydWemfUljpfdRpjzPpoavU0tPocT83dhAkT4qSTTorhw4fH1KlTY9iwYfHmm2/GsmXL4phjjsl3eXn3m9/8pspzhu9mNw11PbcDFTX36wGoDY+ta0G+973vRf/+/eO9996L9u3bx4IFC2LWrFmxzz77xFNPPVWnMc8///z46KOP4rnnnot27drFE088Eb/85S9jxx13jEcffbRR6rnyyitj3Lhxcfzxx8eKFStizJgxceyxx0ZhYWFcccUVVfa76KKLYsaMGXHHHXdE27Zt46677oorr7wyevfuHffdd1+Lna86jTFmfTS1ehpafY6n5u4nP/lJ3HjjjTFp0qRo06ZN3HzzzfH666/HN77xjdh2223zXV5e3XLLLXHqqadGz54948UXX4z99tsvunXrFm+//XYceeSR+S6P/1PXcztQUXO/HoBaSbQY3bp1Sy+99FJKKaWSkpL0+uuvp5RSmj59eho0aFCdxuzVq1d67rnnUkopderUKb3xxhsppZQeeeSRdNBBBzVKPdttt136wx/+kFJKqWPHjumvf/1rSimlm2++OX3rW9+qst8222yTnnzyyVytCxcuTCmldN9996Ujjzyyxc5XncYYsz6aWj0NrT7HU3PXvn37tGjRopRSSl27dk0vv/xySimlV199NfXq1SuPleXfzjvvnB544IGU0mfnjLfeeiullNKll16aRo0alc/S+Jy6ntuBipr79QDUhnfoW5ANGzZEp06dIiJiyy23jHfffTciIvr27RtvvPFGncZctWpV9OjRIyI+e4TI+++/HxERu++++yY/5lnXepYuXRq77757RER07NgxVqxYERER//Ef/xGTJ0+ust/y5ctju+22i4jPvlu18eONX/jCF2LWrFktdr7qNMaY9dHU6mlo9TmemrstttgiPv7444iI2HrrreMvf/lLRER89NFHsXr16nyWlneLFy+OAw88MCIi2rVrl9tPJ554Yvz617/OZ2l8Tl3P7UBFzf16AGpDoG9Bdtttt3jppZciImL//feP6667Lv785z/HVVddlTsp1tbOO++cC9977rln/PznP49//vOfceedd8ZWW23VKPX06dMnlixZEhER22+/fUydOjUiIubMmRNt27atst92222Xe1TegAEDYuLEiRERMWnSpOjSpUuLna86jTFmfTS1ehpafY6n5u7ggw+OadOmRUTE17/+9fje974XZ555ZnzrW9+Kww8/PM/V5VevXr1yF7PbbrttPPvssxHx2aNBkwfZNBl1PbcDFTX36wGolXx/RIDN54knnki//e1vU0opLVy4MO28886poKAgbbnllmn69Ol1GvP+++9P9957b0oppRdeeCFtueWWqbCwMBUXF6cJEyY0Sj0XX3xx+vGPf5xSSmnChAmpdevWaYcddkht2rRJF198cZX9xo0bl26++eaUUkrTpk1LxcXFqW3btqmwsDDddNNNLXa+6jTGmPXR1OppaPU5npq7f/3rX+mf//xnSimlDRs2pGuuuSaNHDkyjRkzJi1fvjzP1eXX6aefnq644oqUUkq33nprateuXTriiCNSly5d0mmnnZbn6tiorud2oKLmfj0AteE59C3c8uXLY4sttsjdWb6+Vq9eHa+//npsu+22seWWW26WembPnh2zZ8+OHXfcMUaOHFnjfn//+99j7ty5scMOO9TqcWDNfb7NPWZzqqeh1fd4omUoKyuLsrKyaN36swfXTJgwIZ555pnYcccd47vf/W60adMmzxVSmbqe24GKmvv1AFRHoAegSVq5cmWN23rmMADQEgn0zdyxxx5b47YPP/xwjdqNGTOmxmOOGzeuQeqpzSO7jjrqqNz/vuWWW2rc77zzzmsx81WnMcasj6ZWT0Orz/HU3BUWFm7y0zoppSgoKGhxzxx++eWXa9zWu1X5U9dzO1BRc78egLoS6Ju5U089tcZt77333hq1O/TQQ2vUrqCgIGbMmNEg9RQW1uz+jf9+Yd+/f/8a93v77bdbzHzVaYwx66Op1dPQ6nM8NXczZ86scdsvfelLjVhJ07Pxjx2b+r/wlvjHjqakrud2oKLmfj0AdSXQA0DG/P3vf69x2759+zZiJQBAPgn0ADRJPlYOAFA9gb6Z22uvvWp8x/h58+bVqF19vpdf13rq+r2pun4/ubnPV52m9p3uplZPQ2uM+1w0Fz5WXjXfzc4G3/mFhtPcrwegrlrnuwAa19FHH93gY3bu3LnOfetaz4033lijdgUFBeUuil588cUa92tJ81WnMcasj6ZWT0Orz/HU3C1atCjfJTRZNT2XtsQ/djQldT23AxU19+sBqCvv0AMAAEAGeYe+BZo7d2689tprERGx6667xl577VXvMd9///144403IiJi5513ju7du2+Wejb+Paq2f439xz/+ERERffr0qVW/5j7f5h6zPppaPQ2pPsdTc/bWW2/FTTfdlDtf7LLLLvG9730vtt9++zxXBrVT13M7UFFzvh6AmqjZ81RoFt5777047LDDYt99943zzjsvzjvvvBg8eHAcfvjh8f7779dpzFWrVsVpp50WW221VRx88MFx8MEHR+/eveP000+P1atXN1o99913X+y+++7Rrl27aNeuXeyxxx5x//33V9unrKwsrrrqqujcuXP07ds3+vbtG126dImrr746ysrKWvR8m3PM+mhq9TS0+hxPzd2UKVNil112ieeffz722GOP2GOPPeK5556LXXfdNaZNm5bv8vJu5syZMXLkyNhhhx1ihx12iKOOOir+9Kc/5bss/k1dzu1ARc39egBqJdFifOMb30j77LNPevXVV3PrFixYkPbZZ5/0zW9+s05jnnXWWWm77bZLjz32WFqxYkVasWJFmjx5ctp+++3T2Wef3Sj13HDDDal9+/bpoosuSo888kh65JFH0oUXXpjat2+fxo0bV2W/Sy65JHXv3j3dfvvt6aWXXkovvfRSuu2221L37t3TD37wgxY7X3UaY8z6aGr1NLT6HE/N3aBBg9LFF19cYf3FF1+c9tprrzxU1HTcf//9qXXr1ukb3/hGuvnmm9PNN9+cvvGNb6SioqL0q1/9Kt/l8X/qem4HKmru1wNQGwJ9C1JSUpKef/75Cuufe+651Llz5zqN2a1bt/Tkk09WWD9jxoy05ZZbNko9/fr1S7/85S8rrB8/fnzq169flf222mqr9Mgjj1RY//vf/z717t27xc5XncYYsz6aWj0NrT7HU3PXtm3b9Oabb1ZY/8Ybb6S2bdvmoaKmY8CAAZUGwhtuuCENGDAgDxVRmbqe24GKmvv1ANSGj9y3IGVlZVFUVFRhfVFRUZ0/nrR69ero2bNnhfU9evTY5EeE61rPkiVL4sADD6yw/sADD4wlS5ZU2W/58uUxYMCACusHDBgQy5cvb7HzVacxxqyPplZPQ6vP8dTcde/ePebPn19h/fz586NHjx6bv6Am5O23346RI0dWWH/UUUd5UkATUtdzO1BRc78egNoQ6FuQww47LL73ve/Fu+++m1v3z3/+My644II4/PDD6zTmkCFD4vLLL481a9bk1n366adx5ZVXxpAhQxqlnh122CEmTpxYYf2DDz4YO+64Y5X99txzz7j11lsrrL/11ltjzz33bLHzVacxxqyPplZPQ6vP8dTcnXnmmXHWWWfFT3/60/jTn/4Uf/rTn+Laa6+N7373u3HmmWfmu7y82mabbWL69OkV1v/xj3+MbbbZJg8VUZm6ntuBipr79QDUhsfWtSDvvPNOHHXUUbFgwYLcRd4777wTu+22Wzz66KN1ujvoX/7ylxg+fHisXbs2dwJ96aWXori4OKZMmRK77rprg9fz29/+No4//vg44ogj4qCDDoqIiD//+c8xffr0mDhxYhxzzDGV9ps5c2aMGDEitt1221w4mj17drzzzjvx2GOPxRe/+MUWOV91GmPM+mhq9TS0+hxPzV1KKW666aa44YYbcn8E7N27d1x44YVx3nnntei7hd9xxx1x/vnnx2mnnZZ7B/jPf/5zjB8/Pm6++eb47ne/m+cKiaj7uR2oqLlfD0BtCPQtTEop/vjHP8brr78eEREDBw6MI444ol5jrl69On71q1+VG/OEE06Idu3aNVo9c+fOjRtvvDH3+KqBAwfGf/7nf27ykXf//Oc/4/bbby833//7f/8vevfu3aLn29xj1kdTq6eh1ed4aik+/vjjiIjo1KlTnitpOn73u9/FDTfcUO6cceGFF8ZXv/rVPFfG59X13A5U1NyvB6CmBHoAMuGDDz6Iv/3tb1FQUBD9+vWLbt265bskAIC8ap3vAtg8ysrKYvz48fHwww/nLoj79+8fX/va1+LEE0+s88dVZ8yYUW7M7bbbLo477rg4+OCDG62eFStWxLRp08rNefjhh0dJSUm1cy5cuDAeeeSRcv2OPvro6N+/f7X9mvt8m3vM+mhq9TS0uh5Pzd2CBQvinHPOiT//+c/l1n/pS1+KO+64I3beeec8VdY0pJRi7ty55V43gwYNatFfQ2iK6npuBypq7tcDUCv5ur0+m09ZWVkaMWJEKigoSIMGDUrf/OY30/HHH5/22GOPVFBQkL761a/Wadzvfve7qaCgIHXt2jUdcMABaf/9909du3ZNhYWFafTo0Y1Sz/333586d+6cCgoKyv3XpUuXNGHChCr7/eQnP0mtW7dOhYWFqVevXqlnz56psLAwFRUVpeuvv77FzledxhizPppaPQ2trsdTc7dkyZLUrVu3NGDAgHTTTTelJ554Ij3++OO5R7J17949LVu2LN9l5s2MGTNS//79U2FhYe58UVhYmLbffvs0c+bMfJfH/6nruR2oqLlfD0BtCfQtwD333JM6deqUZsyYUWHb9OnTU6dOnSp9Nm51Hn744dSmTZt07733prKystz6DRs2pLvvvju1adOm0ueD1qeeuXPnptatW6eTTz45zZ8/P61ZsyZ9+umnae7cuenEE09MRUVFaf78+RX6zZgxIxUWFqbLL788LV++PLf+X//6V7r00ktTq1atKr3wbe7zVacxxqyPplZPQ6vP8dTcXXTRRWnvvfdOn376aYVtq1evTnvvvXe65JJL8lBZ/i1cuDC1b98+HXrooen3v/99ev3119Nrr72Wfvvb36YvfelLqUOHDumtt97Kd5ktXl3P7UBFzf16AOrCd+hbgGHDhsVhhx0Wl1xySaXbf/KTn8TMmTNjypQpNR7zqKOOil133TWuueaaSrdffPHF8frrr8cjjzzSYPWceuqp8cknn8RDDz1Uab+vfe1rUVJSEvfcc0+59ccff3x06dIlfv7zn1fa76yzzoqPP/44fv3rX7eo+arTGGPWR1Orp6HV53hq7vbee++45JJL4hvf+Eal2ydMmBDXXXddzJs3bzNXln+jR4+O1157rdJH1qWU4ogjjohddtkl/vu//zsP1bFRXc/tQEXN/XoA6iTPf1BgM+jZs2d68cUXq9w+b9681LNnz1qNufXWW6fnnnuuyu3PPvts2nrrrRu0nh133DFNmzatyn7Tpk1LO+64Y4X1/fr1S3/605+q7Ddr1qzUr1+/FjdfdRpjzPpoavU0tPocT81d586d08KFC6vcvnDhwtS5c+fNV1ATsuuuu6ZHH320yu2PPvpo2nXXXTdjRVSmrud2oKLmfj0AdVGY7z8o0PiWL18ePXv2rHJ7z54948MPP6zVmB988EG1z63v06dP/Otf/2rQet59993Yaaedquy30047xT//+c8K65ctWxb9+vWrsl///v1j6dKlLW6+6jTGmPXR1OppaPU5npq7jz/+uNqbhnXq1Ck++eSTzVhR07F48eLYfffdq9y+2267xd///vfNWBGVqeu5HaiouV8PQF24y30LsGHDhmjduupfdatWrWL9+vW1GnPdunVRVFRU5fbWrVvHunXrGrSe1atXR3FxcZX92rZtG2vWrKmwfs2aNdGmTZsq+xUVFVVaa3OfrzqNMWZ9NLV6Glp9jqeW4OOPP67y2Fi5cmWkFvrNsU8++STat29f5fb27dvH6tWrN2NFVKau53agouZ+PQB1IdC3ACmlOOWUU6Jt27aVbl+7dm2dxr300kurvJis7iKyPvVMmTIlOnfuXOm2jz76qMp+d911V3Ts2LHSbR9//HGLna86jTFmfTS1ehpaXY+n5i6lVO27mymlFv14tldffbXKd6M++OCDzVwNVanruR2oqLlfD0BtuSleC3DqqafWqN29995b4zEPOeSQGl1EP/nkkw1WT2Hhpr8hUlBQEBs2bCi3rl+/fjWqddGiRS1qvuo0xpj10dTqaWj1OZ6au5kzZ9ao3Ze+9KVGrqTpKSwsjIKCgko/obBxfWXnDDavup7bgYqa+/UA1IVADwAZVNPvx/ft27eRKwEA8kWgb8H+/ve/x6pVq2LAgAE1egehJtavXx9r1qyp8qNQm7seyLL6HE/Nxfr162PDhg3lvqKzbNmyuPPOO2PVqlVx1FFHxRe+8IU8VggAkD9SUwtwzz33xLhx48qtO+uss2K77baL3XffPXbbbbd45513ajXmpEmTYvz48eXW/fjHP46OHTtGly5dYtiwYVXeOb+u9bz55pvx/PPPl1s3ffr0OPTQQ2O//faLn/zkJ5XON3v27PjDH/5Qbt19990X/fv3jx49esRZZ51V6ff2m/t81WmMMeujqdXT0OpzPDV3Z555Zpx33nm55Y8//jj23XffuO2222LKlClx6KGHxmOPPZbHCvPngw8+qPAu/YIFC+LUU0+Nb3zjG/HAAw/kqTI+r67ndqCi5n49AHUh0LcAv/jFL2KLLbbILT/xxBNx7733xn333Rdz5syJLl26xJVXXlmrMceNGxerVq3KLT/zzDNx2WWXxaWXXhoTJ06Md955J66++uoGrefiiy8udxJftGhRjBw5Mtq0aRNDhgyJa665Jm666aYK/a666qpYsGBBbvmVV16J008/PY444oi45JJLYtKkSXHNNde0uPmq0xhj1kdTq6eh1ed4au7+/Oc/x3HHHZdbvu+++2LDhg2xcOHCeOmll2LMmDFx/fXX57HC/Dn33HPjlltuyS2/99578cUvfjHmzJkTa9eujVNOOSXuv//+PFZIRN3P7UBFzf16AOpkcz/4ns2va9eu6eWXX84tn3322em4447LLT/55JOpX79+tRqze/fuad68ebnlCy64IA0fPjy3PHny5LTDDjs0aD19+vRJzzzzTG756quvTnvuuWdu+a677iq3vFGvXr3SnDlzcss/+MEP0kEHHZRbnjhxYho4cGCLm686jTFmfTS1ehpafY6n5q59+/bp7bffzi0fc8wx6dxzz80tL1iwIHXv3j0fpeVdv3790lNPPZVbvv7669P222+fSktLc8v7779/vsrj/9T13A5U1NyvB6AuvEPfAnz66adRUlKSW37mmWfi4IMPzi1vt912VT72qCoff/xxdOvWLbf89NNPx+GHH55b3nXXXePdd99t0Ho++OCD6NOnT275ySefjJEjR+aWDznkkPjb3/5Wod+HH34YPXv2zC3PnDkzjjzyyNzyvvvuW+lH/Jv7fNVpjDHro6nV09Dqczw1d8XFxfHpp5/mlp999tnYf//9y23/5JNP8lFa3i1dujT69euXW54xY0Yce+yx0br1Z0+kPeqoo2LhwoV5qo6N6npuBypq7tcDUBcCfQvQt2/fmDt3bkR8dmGxYMGCOOigg3Lbly5dWuXzcauy9dZbx2uvvRYREZ988km89NJLceCBB+a2/+tf/6rymdp1radr166xZMmSiIgoKyuLF154IQ444IDc9nXr1lX6+KaePXvmHl+ybt26mDdvXrl+H3/8cRQVFbW4+arTGGPWR1Orp6HV53hq7gYNGpT72Pif/vSnWLZsWRx22GG57W+99Vb07t07X+XlVUlJSblnmD///PPl/thRUFDgu6RNQF3P7UBFzf16AOpCoG8BTj755Bg1alRcffXV8fWvfz0GDBgQgwcPzm1/5plnYrfddqvVmF//+tfj/PPPj/vvvz/OPPPM6NWrV7kT6gsvvBA777xzg9ZzyCGHxNVXXx3vvPNO3HTTTVFWVhaHHHJIbvurr75a7t2qjb7yla/EJZdcEn/6059i7Nix0b59+/jiF7+Y2/7yyy/H9ttv3+Lmq05jjFkfTa2ehlaf46m5u+yyy+Lmm2+O7bffPoYPHx6nnHJKbLXVVrntv/vd78r9QbAlOeCAA+KWW26JsrKy+M1vfhMff/xxuT92vPnmm7HNNtvksUIi6n5uBypq7tcDUCf5/cQ/m8OGDRvSpZdemgYNGpS+/OUvp1dffbXc9q997WvprrvuqtWYq1evTieeeGLq0qVLGjBgQJo1a1a57Ycccki69tprG7SeRYsWpR122CEVFBSk1q1bp9tvv73c9q9+9avp/PPPr9Dv/fffT1/84hdTQUFB6tSpU3r44YfLbT/ssMPSD37wgxY3X3UaY8z6aGr1NLT6HE8twYIFC9JNN92UJkyYkDZs2FBu289//vP04osv5qewPHvppZfSlltumdq0aZMKCwvTj370o3Lbv/Od76Tvfve7eaqOjep6bgcqau7XA1AXnkNPpqxfvz4WLFgQ3bt3r/Ax25deein69OlT7rvIn7dixYro2LFjtGrVqtz65cuXR8eOHaNNmzYtbr5NaYwx66Op1QP59sEHH8Sf//zn6NWrV7mP20dETJ48OXbZZZfo379/nqpjo/qc24GKXA/A/0+gbwFWrlxZ6foOHTpUOBFuDk2tHqDp+vxj2T6vc+fOsdNOO8WQIUM2c0UAAE2HQN8CFBYWRkFBQYX1rVq1iv79+8f3v//9OPPMM2s15hZbbFHpmBsvsr///e/H0KFDG7SeY489ttLxNs55xhlnRPfu3Sts32uvvaqt9fzzz4+BAwe2uPmq0xhj1kdTq6eh1ed4au6qenf5o48+ihUrVsSBBx4Yjz76aHTt2nUzV5Z/Y8aMqXT9xtfNscceG23btt3MVfHv6npuBypq7tcDUBet810Aje/JJ5+sdP1HH30Uc+fOjQsvvDBat24dp556ao3HvOmmm6od8z/+4z/iN7/5TblH89S3nqruxP/RRx/F//zP/8T1118fs2bNqnBDvaOPPrrKfvPmzYtBgwbFjBkzKtxYq7nPV53GGLM+mlo9Da0+x1Nzt/FuxpV5++234zvf+U786Ec/ittvv30zVtU0vPjii5Wu/+ijj+Kvf/1rXHrppTFjxozYdtttN3NlfF5dz+1ARc39egDqwjv0xD333BO33nprzJs3r8HGHDduXPzmN7+JZ555ZrPUU1ZWFmeeeWa89957MWnSpFrN98Mf/jCeffbZmD59uvnyOGZ9NLV6Glp9jqfmbtasWXHaaafFX//613yX0qSsXLkyTjjhhOjUqVM88MAD+S6HKtTn3A5U1NyvB6AyAj3x1ltvxV577VXld9vr4s0334wDDjggli9fvtnqeemll+LII4+Md999t1b9FixYEIceemi899575svjmPXR1OppaPU5npq7v/3tb7HbbrvFJ598ku9Smpznn38+vv71r8ff//73fJdCNep6bgcqau7XA1AZz6EnVqxYUeVHAutq7dq1db7DaF3r6dChQ6xevbrW/Vq1ahVlZWXmy/OY9dHU6mlo9TmemrtXXnkl+vbtm+8ymqQtt9zSH4EyoK7ndqCi5n49AJXxHfoWrrS0NK6//voKjzuqr7vvvjsGDRq0WeuZNm1a7LTTTrXu9/DDD8cuu+xivjyPWR9NrZ6GVtfjqTmo6pM6K1asiLlz58Z//ud/xsknn7yZq8qGZ599Nrbffvt8l8Em1PXcDlTU3K8HoDICfQtQ1R12V6xYEQsWLIiCgoL405/+VKsxq7q78ooVK2LevHnx5ptvxqxZsxq0nkcffbTKfnPnzo277ror7rrrrgrbq3rs1cZ+kydPjscff7zFzVedxhizPppaPQ2tPsdTc9elS5dK72gcEVFQUBBnnHFGXHLJJZu5qqbh5ZdfrnT9xuPiJz/5SVx++eWbuSr+XV3P7UBFzf16AOrCd+hbgKruXl9SUhI777xznHDCCbX+iPuhhx5a7ZjnnHNOlY+bqms9hYWVf0OkU6dOsfPOO8eYMWPim9/8ZoXtVdWxcb4LLrig0mdZN/f5qtMYY9ZHU6unodXneGruZs6cWen6kpKS2HHHHaNjx46buaKmY+MjQCv7v/Ett9wyxowZExdffHGVfxBh86jruR2oqLlfD0BdCPQAkEFV3eyupKQktthii81cDQCQDwJ9C7NixYpYunRpRET06tWrwW+GV1sbNmyIDz74IAoLC6N79+55rQVout5+++14+umnY8mSJVFYWBjbbbddDB06NEpKSvJdGgB5sm7duli0aFFsv/320bq1bxLTMnnltxB33XVXjBs3Lt54442IiEgpRUFBQey8887xn//5n3H66afXesyXXnopbrjhhgoX2UcffXRceOGF1V5oT548OX7605/G888/H6WlpRHx2ccPR44cGT/+8Y9j2223rbTfp59+Gr/+9a8rnfPwww+vcr4lS5bEHXfcUWm/U045JVq1atUi56tOY4xZH02tnoZWn+OpOVu1alWccsop8dvf/jYiPvvefI8ePeL999+Pdu3axbXXXhujRo3Kc5X5NWPGjAqvm6OOOip23HHHfJfG/6nruR2o3OrVq+Pcc8+NX/7ylxHx2eNdt9tuuzj33HNj6623brH3VqGFSjR71113XWrfvn265JJL0pNPPpleffXV9Oqrr6Ynn3wyjR07NnXo0CFdf/31tRrziSeeSO3atUvHHXdc+s53vpPat2+fRo8enS6++OK0ww47pO233z4tWbKk0r733Xdf6tSpU/rP//zP9MMf/jD16tUrXXLJJemOO+5IX/rSl9KWW26Z3nzzzQr9Fi5cmPr27Zt69OiRttlmm1RQUJBGjBiR9t9//9SqVav09a9/PZWWllboN2fOnNS5c+c0ePDg9IUvfCG1atUqnXjiien4449PXbp0SQceeGBauXJli5uvOo0xZn00tXoaWn2Op+burLPOSgcddFB65ZVX0sKFC9PXvva1dNFFF6VVq1alu+++O7Vv3z796le/yneZebFs2bK03377pcLCwtS6detUWFiYBg8enHr16pVatWqVLrzwwnyXSKr7uR2o2nnnnZcGDx6c/vSnP6UOHTqkt956K6WU0u9///s0aNCgPFcHm5dA3wJsu+226cEHH6xy+4QJE9I222xTqzEHDRqU7rjjjtzy1KlT04ABA1JKKa1bty4dfvjh6ZRTTqm074ABA9KECRNyy3PmzEl9+vRJZWVlKaWUjj/++HTMMcdU6HfkkUem7373u7l21157bTryyCNTSim9+eabqV+/funyyy+v0O+ggw5KV1xxRW75/vvvT/vvv39KKaXly5enQYMGpfPOO6/FzVedxhizPppaPQ2tPsdTc7flllumF154Ibe8fPnyVFxcnFatWpVSSunWW29tsRdvxx9/fDr66KPTihUr0po1a9Lo0aPTSSedlFJKafr06albt27ppptuynOV1PXcDlRt2223TbNnz04ppdSxY8dcoF+4cGHq1KlTPkuDzU6gbwGKi4vTq6++WuX2BQsWpHbt2tV6zEWLFuWWy8rKUlFRUXr33XdTSinNmjUrde/evdK+7dq1K9c3pZRat26d/vnPf6aUUnruuedSly5dKvRr3759uXfu165dm4qKitIHH3yQUvrsr7L9+vWrdL6NJ/qUUtqwYUMqKipKS5cuTSl9Fp569+7d4uarTmOMWR9NrZ6GVp/jqbnr0qVLueNi3bp1qXXr1um9995LKX0WiIqLi/NVXl6VlJSkv/zlL7nlTz75JBUVFaUVK1aklD77w9fOO++cr/L4P3U9twNV+/x1wecD/fz581NJSUk+S4PNrvJnqdCs7LvvvnHttdfG+vXrK2zbsGFD/PSnP4199923VmNuvfXWue/jR0S89dZbUVZWFt26dYuIiD59+sQnn3xSad9+/frFCy+8kFueN29eFBYWRs+ePSMiomvXrrnv1X9ely5d4uOPP84tr169OtavXx9t2rSJiIg99tgjlixZUqFfjx49yq1ftmxZrF+/Pved5B133DGWL1/e4uarTmOMWR9NrZ6GVp/jqbnbd9994+abb84t33zzzdG9e/fcTTQ/+eSTFvvourZt25Z7JF1hYWFs2LAhd64/8MAD429/+1ueqmOjup7bgarts88+MXny5NzyxnPhXXfd5bF1tDhuitcC3HrrrTF8+PDo1atXHHzwwbngvGzZspg1a1a0adMmpk6dWqsxTzrppDjjjDPihz/8YbRt2zbGjRsXRx11VO4CZf78+VU+K3TUqFFxxhlnxJw5c6K4uDjuuuuuOPHEE3M3NXvuuedip512qtBv6NChMWbMmLjzzjujbdu2MXbs2Bg0aFB06tQpIiIWL14cPXr0qNDv6KOPjrPPPjuuv/76aNu2bVx99dXxpS99Kdq1axcREW+88UZsvfXWLW6+6jTGmPXR1OppaPU5npq7a6+9NoYOHRq//e1vo02bNrF06dLcTZAiIp555pn4yle+kscK8+cLX/hCXHbZZfHLX/4y2rRpEz/4wQ9iu+22i65du0ZExPvvv+/xdU1AXc/tQNV+8pOfxJFHHhmvvvpqrF+/Pm6++eZ49dVX45lnnomZM2fmuzzYvPL9EQE2j5UrV6bbb789nXTSSWnYsGFp2LBh6aSTTkp33HFH7uOZtVFaWpouuuii1Lt379StW7f07W9/O73//vu57c8991yaOXNmlf1vv/32dOCBB6bBgwenH/zgB+nTTz/NbXvzzTfTa6+9VqHPsmXL0gEHHJAKCgpSYWFh6tu3b5o3b15u+0MPPZRuueWWCv0+/vjj9I1vfCO1bt06FRQUpAMPPDC9/fbbue1TpkxJEydObHHzVacxxqyPplZPQ6vv8dTcvfvuu+kXv/hF+u///u+0YMGCfJfTZLz11ltp++23T61bt05FRUWpS5cuadq0abnt9957b7rkkkvyWCEp1f3cDlTvrbfeSmeccUbad99908CBA9MJJ5yQXn755XyXBZud59CTOQsXLoy1a9fGgAEDavXM0TVr1sT69etr/fHc5j7f5h6zPppaPZBvq1evjqeffjrWrVsXBxxwQGy55Zb5Lokq1PXcDpRXWloa3/3ud+PSSy9tsZ9eg88T6FuQpUuXxnPPPRdLly6NiIitttoq9ttvv+jVq1e9xt2wYUN88MEHUVhYmPtea00tXry43DN5N35nGFqq+hxPzZlnrQOwUefOnVv019Hg89wUrwVYtWpVfOc734k+ffrE1772tbjsssvisssui+OOOy769OkTJ554YqxevbrW406ePDkOPvjg6NChQ/Tu3Tt69eoVXbp0iRNPPDEWL15cbd/bb789+vbtG/37948DDzwwDjjggOjRo0d84QtfiLlz51bZb8mSJXHZZZfFYYcdFgMHDoxdd901Ro4cGXfffXds2LChyn4vvfRSnHTSSbHddttFu3btokOHDrH77rvHpZdeGitXrmyx81WnMcasj6ZWT0Orz/HUnL333nux//77x9ChQ+Pqq6+OX/ziF/Hcc8/Fz372sxg4cGBcdNFF+S4xrz799NO455574rTTTosjjzwyRowYEeeee25Mnz4936XxOXU9twOVO/roo+P3v/99vsuAJkGgbwG+973vxfPPPx+TJ0+ONWvWxLJly2LZsmWxZs2aeOyxx+L555+P733ve7Ua8/77749vfetbsd9++8X3v//96NGjR1x00UVx7bXXxjvvvBODBw+OhQsXVtr3Zz/7Wfz4xz+OCy+8MH7+85/HzjvvHFdccUVMnjw5tttuuzj44IPL3QV/oxdeeCEGDhwYjz32WJSWlsbChQtj8ODB0aFDh/j+978fBx98cLk7CW80ZcqUGDJkSKxevToOOuigKCwsjNNOOy1GjBgREyZMiL333jv3qYWWNF91GmPM+mhq9TS0+hxPzd15550XvXv3jg8//DA++eST+H//7//FrrvuGkuWLImpU6fGPffcU+4u+C3JX//61xg4cGCMHTs2/vjHP8aUKVOioKAg5syZE8OHD49vfOMblT7dhM2rrud2oGo77rhjXHXVVfG1r30trrnmmrjlllvK/QctSn6/ws/m0KVLl/TnP/+5yu1PP/10pc99r86AAQPShAkTcstz5sxJffr0SWVlZSmllI4//vh0zDHHVNq3X79+6bHHHsstv/HGG6lbt26ptLQ0pZTSeeedl4YOHVqh30EHHZSuuOKK3PL999+f9t9//5RSSsuXL0+DBg1K5513XoV+gwYNSnfccUdueerUqWnAgAEppc+eaX344YenU045pcXNV53GGLM+mlo9Da0+x1Nz51nrVTvyyCPTd7/73dzr5Nprr01HHnlkSumzm4v269cvXX755XmskJTqfm4HqtavX78q/+vfv3++y4PNSqBvAUpKStKcOXOq3P7888+nkpKSWo3Zrl27tGjRonLrWrdunf75z3+mlD67K3dVfyRo3759ub5lZWWpdevW6d13300ppTR//vzUsWPHSud86623cssbNmxIRUVFaenSpSmlz0Je7969K/QrLi6uMF9RUVFuvlmzZqXu3bu3uPmq0xhj1kdTq6eh1ed4au66d+9e7s72q1evToWFhelf//pXSumzuxy3bds2X+XlVfv27dObb76ZW167dm0qKipKH3zwQUoppd///vepX79++SqP/1PXczsA1ISP3LcA//Ef/xFnnXVWvPjiixW2vfjii3HOOefEyJEjazVmv379yn0sft68eVFYWJh7xn3Xrl2jtLS00r477bRTTJs2Lbf85JNPRps2bXI35ysuLo6CgoIK/Xr06BFLlizJLS9btizWr18fJSUlEfHZx6+WL19eod/WW28db7zxRm75rbfeirKystwN+Pr06ROffPJJi5uvOo0xZn00tXoaWn2Op+Zu47PWV61aFaWlpZ61/jldunQp91Ht1atXx/r166NNmzYREbHHHnuUO6eQH3U9twM1kz57gzLfZUDeeG5KC3DrrbfGt7/97Rg8eHBsscUW0aNHj4j47GZTH330UQwfPjxuvfXWWo05atSoOOOMM2LOnDlRXFwcd911V5x44onRqlWriIh47rnnYqeddqq079ixY+M73/lO/PGPf4zi4uJ4+OGH47zzzsuF+Keeeip22223Cv2OPvroOPvss+P666+Ptm3bxtVXXx1f+tKXol27dhER8cYbb8TWW29dod9JJ50UZ5xxRvzwhz+Mtm3bxrhx4+Koo47KXfRWdZfU5j5fdRpjzPpoavU0tPocT83dz372sxg2bFh06dIlCgoKokOHDvHQQw/ltr/22mtxyimn5K/APBo6dGiMGTMm7rzzzmjbtm2MHTs2Bg0aFJ06dYqIz54isvF8T/7U9dwOVO++++6L66+/PnePmZ122ikuvPDCOPHEE/NcGWxm+f6IAJvPq6++mu655570k5/8JP3kJz9J99xzT3rttdfqPN7tt9+eDjzwwDR48OD0gx/8IH366ae5bW+++Wa1Yz/22GPp29/+djruuOPSL37xi3LbPvjgg9xHRj/v448/Tt/4xjdS69atU0FBQTrwwAPT22+/nds+ZcqUNHHixAr9SktL00UXXZR69+6dunXrlr797W+n999/P7f9ueeeSzNnzmxx81WnMcasj6ZWT2Ooz/HU3K1atSpNmTIlTZo0qdzvvaVbtmxZOuCAA1JBQUEqLCxMffv2TfPmzcttf+ihh9Itt9ySxwpJqe7ndqBqN9xwQ2rfvn266KKL0iOPPJIeeeSRdOGFF6b27duncePG5bs82Kw8h57MWbNmTaxfvz46duxoPqDFW7hwYaxduzYGDBgQrVv74F1T5dwODad///5x5ZVXxkknnVRu/S9/+cu44oorYtGiRXmqDDY/gb6FWLduXfz+97+P2bNn5x7v1atXrzjwwAPjq1/9au6jy3WxePHiWLJkSRQWFsZ2222X+17zpqxatSrmzp1bru/ee+9d6ffnG8qGDRvigw8+iMLCwujevXujzdOc5tvcP0PW6mlodT2emrNPP/00fv3rX8fTTz9dbt8cffTRcfjhh+e7PAA2s+Li4vjLX/4SO+ywQ7n1CxcujN133z3WrFmTp8pg83NTvBZg47OKTz755HjxxRejrKwsysrK4sUXX4yTTjopdt111/jrX/9a63Fvv/326Nu3b/Tv3z8OPPDAOOCAA6JHjx7xhS98IebOnVtlv7Kysrjooouie/fuceihh8a3v/3tOP7442PfffeN/v37x6RJk6rs+9JLL8VJJ50U2223XbRr1y46dOgQu+++e1x66aWxcuXKKvtNnjw5Dj744OjQoUP07t07evXqFV26dIkTTzwxFi9e3GLnq05jjFkfTa2ehlbX46m586z16i1ZsiQuu+yyOOyww2LgwIGx6667xsiRI+Puu++ODRs25Ls8/k9dz+1A5XbYYYeYOHFihfUPPvhg7LjjjnmoCPJHoG8BzjnnnNh9991j2bJl8dRTT8WDDz4YDz74YDz11FOxbNmy2HXXXWPUqFG1GvNnP/tZ/PjHP44LL7wwfv7zn8fOO+8cV1xxRUyePDm22267OPjgg8vdtfvzfvCDH8Qf/vCHmDhxYkyZMiW+8IUvxLXXXhuvvvpqnHTSSfH1r389pk6dWqHflClTYsiQIbF69eo46KCDorCwME477bQYMWJETJgwIfbee+/cpw8+7/77749vfetbsd9++8X3v//96NGjR1x00UVx7bXXxjvvvBODBw/O3VClJc1XncYYsz6aWj0NrT7HU3N33nnnxZe//OVYunRpLF68OK655pooKyuLZ599Nl577bWYM2dO/Nd//Ve+y8yLF154IQYOHBiPPfZYlJaWxsKFC2Pw4MHRoUOH+P73vx8HH3xwubvgkx91PbcDVbvyyivjsssuiy9/+ctx9dVXx9VXXx1f/vKX48orr4yrrroq3+XB5pXfr/CzObRr1y698sorVW5/+eWXU7t27Wo1Zr9+/dJjjz2WW37jjTdSt27dUmlpaUoppfPOOy8NHTq00r5bbbVVmjVrVm75H//4R+rYsWNas2ZNSimlq666Kg0ZMqRCv0GDBqU77rgjtzx16tQ0YMCAlFJK69atS4cffng65ZRTKvQbMGBAmjBhQm55zpw5qU+fPqmsrCyllNLxxx+fjjnmmBY3X3UaY8z6aGr1NLT6HE/NnWetV+2ggw5KV1xxRW75/vvvT/vvv39KKaXly5enQYMGpfPOOy9f5fF/6npuB6r3wgsvpBNOOCHtvffeae+9904nnHBCuRuDQksh0LcAW221VZo0aVKV2x999NG01VZb1WrM9u3bp0WLFuWWy8rKUuvWrdO7776bUkpp/vz5qWPHjpX27dSpU3rrrbdyyxs2bEitW7dOS5YsSSmltGDBgtS+ffsK/YqLiyvMWVRUlJtz1qxZqXv37hX6tWvXrly/lFJq3bp1+uc//5lS+uwO6V26dGlx81WnMcasj6ZWT0Orz/HU3PXu3TvNnTs3t/zhhx+mgoKCtHLlypRSSm+//XZq27ZtvsrLq3bt2lU4lxYVFaWlS5emlD4Ljr17985Xefyfup7bAaAmfOS+BTjjjDPipJNOihtvvDFefvnlWLZsWSxbtixefvnluPHGG+OUU06Js846q1Zj7rTTTjFt2rTc8pNPPhlt2rSJXr16RcRnNyup6uZ2u+++e/z617/OLU+cODE6duyY61tWVhZt27at0G/rrbeON954I7f81ltvRVlZWe6mYX369IlPPvmkQr9+/fqV+7jyvHnzorCwMHr27BkREV27do3S0tIWN191GmPM+mhq9TS0+hxPzd3GZ62//vrrsWjRojj77LM9a/3/9OjRI5YsWZJbXrZsWaxfvz5KSkoiImLHHXeM5cuX56s8/k9dz+0AUBOeb9MCXHXVVdGhQ4e4/vrr4z//8z9zwSClFL169YqLL744LrroolqNOXbs2PjOd74Tf/zjH6O4uDgefvjhOO+883JjP/XUU7HbbrtVWc+IESPi0UcfjeLi4njmmWfi+uuvz21/4oknYq+99qrQ76STToozzjgjfvjDH0bbtm1j3LhxcdRRR+Xu0D9//vzo379/hX6jRo2KM844I+bMmRPFxcVx1113xYknnhitWrWKiIjnnnsudtpppxY3X3UaY8z6aGr1NLT6HE/N3XXXXRdf/epXY5dddomCgoLYZptt4ne/+11u+/vvvx8XXnhhHivMn6OPPjrOPvvsuP7666Nt27Zx9dVXx5e+9KVo165dRES88cYbsfXWW+e5Sup6bgcq2vj/+5vipqC0JB5b18K8/fbbsWzZsoj47LF19bmIePzxx+N///d/Y+3atTF8+PA488wzc9v+9a9/RURU+citl156KSZOnJjrO3To0E3Ot379+vjhD39Ybs6bb745ttxyy4iIeP7552PNmjVx8MEHV+h7xx13lOt36aWXRnFxcUR89oiTDRs2xIABA1rUfJvSGGPWR1Orp6HV53hqCTxrvaJPPvkkTj/99Hj44Ydjw4YNMWTIkPjf//3f3Hl96tSpsWLFivj617+e50pbtvqc24HyCgsLo2/fvnHyySdX+ubPRl/96lc3Y1WQXwI9AJmzaNGi2GabbYT7iFizZk2sX78+OnbsmO9SABrVCy+8EHfffXdMmDAh+vfvH6eddlqccMIJscUWW+S7NMgbgb6FePXVV+PWW2+N2bNn5x6P06tXrxgyZEiMHj06dtlllwaZ59RTT40f//jH0bt37022ffvtt+Ppp5+OJUuWRGFhYWy33XYxdOjQ3Pc/a2r8+PFxzDHHROfOnTfZdvHixeXmq8s7ns19vs0xZkO58sorY9SoUbl3urJu1apVMXfu3HL7e++9926x35+vTps2beKll16KgQMH5rsUqLENGzbEBx98EIWFhdG9e/d8lwOZtWbNmvjNb34T9957bzz77LMxcuTIOP3002v0iU9obgT6FuDxxx+Po48+Ovbee+8YPnx47kZiy5Yti2nTpsXcuXPjkUceieHDh9d4zJdffrnS9fvss09MnDgxtttuu4iI2GOPPSq0WbVqVZxyyinx29/+NiIiCgoKokePHvH+++9Hu3bt4tprr41Ro0bVuJaaXNjffvvt8dOf/jT+8Y9/lFs/ZMiQuPnmm2Pw4MHm2wxj1tXKlSsrrEspRffu3ePpp5/OfdS+tn8MairKysrikksuiVtvvTXWrl0bEZ/9fBER2267bfz3f/93jBw5Mp8l5s2xxx5b6fpHHnkkDjvssNzN8R5++OHNWVaT8dJLL8UNN9xQ4Y+jRx99dFx44YWZPSaam8mTJ8dPf/rTeP7553M38OzUqVOMHDkyfvzjH8e2226b5wohuxYtWhSnn356zJw5M95///3o2rVrvkuCzUqgbwH23HPP+OpXvxpXXXVVpduvuOKKePjhh6sM6ZUpLCyMgoKCqOzls3F9QUFBpTcl+e53vxsLFiyIO++8M4qLi2Ps2LGx3XbbxeWXXx4TJkyIc889N/7nf/4nvv3tb5frV9UJ+qOPPoqSkpIoLPzsoQ3/flfnn/3sZ3HjjTfG2LFjo7i4OMaNGxff+ta3Yt99940HHnggfvvb38bMmTNjn332aVHzVacxxqyPqm6Cs/F1Vt3rLQsuueSSePTRR+O6666L4uLiuPrqq2PEiBFx1FFHxQMPPBDXXXddPProozFs2LB8l7rZFRYWxsEHH1zhfh/33XdfHHXUUdGlS5eIiLj33nvzUF1+TZkyJY455pj4yle+Eu3atYuHH344TjvttOjQoUP89re/jZRSPP3007mnJZAf999/f4waNSrOOuusKC4ujrvvvjtOOeWU6Nu3b0yYMCEWLFgQzzzzTOy44475LhUy5R//+EeMHz8+xo8fH6tXr46TTjop/uu//stXsWh5Nvdz8tj8iouL0+uvv17l9tdffz0VFxfXasw999wzjRgxIr322mvpb3/7W/rb3/6WFi1alFq3bp2mTZuWW1eZLbfcMr3wwgu55eXLl6fi4uK0atWqlFJKt956axo0aFCFfh07dkwjRoxI48ePz/137733platWqUf//jHuXX/rl+/fumxxx7LLb/xxhupW7duqbS0NKWU0nnnnZeGDh3a4uarTmOMWR9bb711GjFiRJoxY0Z66qmn0lNPPZWefPLJ1KpVq3Tvvffm1mXVVlttlWbNmpVb/sc//pE6duyY1qxZk1JK6aqrrkpDhgzJV3l59etf/zr16dMn3XPPPeXWt27dOi1YsCBPVTUNgwYNSnfccUdueerUqWnAgAEppZTWrVuXDj/88HTKKafkqzz+z4ABA9KECRNyy3PmzEl9+vRJZWVlKaWUjj/++HTMMcfkqzzIlLVr16YJEyakoUOHpuLi4nTMMcekSZMmpfXr1+e7NMgbgb4FGDBgQLrhhhuq3H7DDTek/6+9+45vqur/AP5JugelLRQoUGhZHayCDKEqU/oDoSAoIKuCzEfZS59HZIgIyiyIIILs8bBHGTLKkA1dQCm2bGULZZbVnt8fPERi09Dm3uTeJJ/365WX5t5+Tr4nJ0DPyR3BwcH5avPJkyeif//+IiwsTMTHx+u25+WXbG9vb/H777/rnj99+lQ4OjqKGzduCCGE+P333w0uMKSlpYmaNWuKLl26iPv37+f5Nd3d3cX58+d1z7Ozs4Wjo6O4cuWKEEKIxMRE4enpaXevZ4w52pTir7/+Eq1atRINGjQQf/zxh267rUzqChQoIM6ePat7npWVJRwdHcXVq1eFEEKcOnVKuLu7K1We4s6fPy8iIiJE69atxe3bt4UQtjP2Uri6uub4c+rk5KT7c7p3717h5+enUHX0kpubm944CfHi8/vnn38KIYQ4fPiw8Pb2VqAyIuvj6+srSpcuLb766iuRlpYm7t69a/BBZE+0Sh8hQOY3ZswYDB8+HFFRUYiJicGKFSuwYsUKxMTEoGXLlvjiiy/wzTff5KtNZ2dnTJ06FRMnTkRUVBS+/fZbZGdn5ylbs2ZNTJs2Tfd82rRp8PPz010g6MGDBwav1lyuXDkcOHAAxYoVQ3h4OPbv35+n16tQoQK2b9+uex4XFwdnZ2fdYaiurq4GLzpm669n6Tal8PX1xdq1a/Hhhx+iVq1aWLZsmcVe2xIqV66s16f//ve/8PT01L3f2dnZcHFxUao8xQUGBmLv3r2oVKkSqlatim3btvFCgQBKlCiBM2fO6J6fPXsW2dnZugtXlixZEg8ePFCqPPqfwMBAHDt2TPc8Pj4eWq1Wdz0bX19f3Xn1RGTcnTt3cOnSJXz99dcIDg6Gj4+P3sPb25tXvCe7w5NM7MCHH36IEiVKICYmBpMmTcpxlfvdu3ejTp06JrXdtGlTHDt2DF27dsWWLVvylBk/fjzeffddrF69Gs7Ozrh27RoWLFig23/gwAE0a9bMYNbR0RETJkxAZGQkOnTogI4dO772F/svvvgCnTp1wo4dO+Dq6oo1a9agX79+utzu3btRqVIlu3w9S7Yphz59+qBevXro0KEDNm7caPHXN5cxY8bgvffew4YNG+Dq6ooDBw7g+++/1+3funWr0fvt2gOtVovRo0fj3XffRZcuXaz2egly6tKlC7p3747//Oc/cHFxweTJkxEVFQVnZ2cAQGJiYo5rD5Dlffrpp+jevTuOHj0KV1dX/Pzzz+jcubPu2iCHDx9GhQoVFK6SyDrExcUpXQKR6vCieCSbmJgYxMXFYfr06ShZsqTRn7169So2bdqEJ0+eoGHDhibdNu+vv/5Cjx49EBcXh0OHDiE4ODjXn92yZQsWL16MJ0+eIDIyEj169NBrB8Brb8dm669niTbl8vTpU3z++eeIi4vDmjVrbGLSkpSUhP/+97+695u33sndgwcPcPbsWYSGhuomr/bo+fPn+M9//qP353TatGm62zgeOXIEjx8/xjvvvKNwpfTjjz/qjdOIESPg6uoKAEhLS0NWVpbubh1EZNzz58+xdOlSvTs3EdkzTuiJiIiIiMhquLu74/Tp0yhdurTSpRApjufQE06fPq27b7xc7ty5g4ULF1o8aw7/PLT38OHD2Lt372vPeTQ1909du3bFlStX8pWRksvNs2fPkJaWhrt378rWZl6tXr0ajx49svjrWtq5c+ewcOFCTJgwAd9//z1Wr16Ne/fuKV2W4jZv3ozu3btj2LBhOH36tN6+O3fuoGHDhgpVpk7z589X5M8pvd6lS5dw+PBhHD16VHekExHlX61atZCQkKB0GUTqoOw1+UgNEhMThVarVU2buWWfPn0qhg4dKsqWLStq1qwp5s6dq7f/2rVrsuauXLkiIiIihIODg3jnnXfE7du3xXvvvSc0Go3QaDSiQoUKuqtJy5FLSkoy+HBychJr167VPZcrZ8yECRPEo0ePhBBCPH/+XAwePFg4OzsLrVYrHB0dRdeuXcXTp0/z1aYUGo1GeHl5iR49eohDhw5Z7HUt5cGDB+KDDz7QfUa0Wq0oVqyYcHBwEJ6enmLGjBlKl6iYJUuWCAcHB/Hee++Jt956S7i6uorFixfr9uf259eeOTk5iZSUFKXLoFf88MMPolSpUkKr1eo9IiIi9G7jSkR5s2LFClGmTBkxffp0ceDAgRy/AxHZE14Uzw4MGjTI6P6bN2/mu83XfWt4//592bPffPMNFi5ciCFDhiAjIwODBg3C4cOHMXv2bN3PCANnkJiaGz58OIQQWLt2LZYsWYLmzZvDwcEBly9fRlZWFjp06IBvvvkGM2bMkCUXHh4OjUZjsJY2bdpACAGNRpPjm39Tc8Z88cUX+Pjjj+Hm5oYpU6Zg3rx5mDVrFmrXro2EhAQMGjQIU6ZMwbBhw/LcplRDhgzB2rVr8fPPPyMsLAzdu3dH586dFTuPX06DBg3C1atXkZycDFdXV3zxxRcoU6YMRo4cieXLl6Nv377w8fFBhw4dlC7V4r7//ntMnjwZ/fr1A/DiDgDdunXD48eP8cknnyhcnbJ8fX0Nbn/+/Dnq1KkDrfbFQXi3b9+2ZFn0DxMnTsSUKVPwxRdfwNXVFZMnT8ZHH32EmjVrYunSpXjnnXewZ88e1KhRQ+lSiaxG+/btAUD3bwMA3e9C+f2dh8ja8Rx6O+Dg4IDw8HB4eXkZ3P/gwQPEx8fn6y8/rVZr9Orrxv5CNTVbvnx5TJkyBc2bNwcApKeno2nTpnjrrbcwb9483LhxA8WLF5ctV7x4caxZswZvvvkmbt++jcKFC2P79u1o1KgRAGDXrl3o0aMHzp49K0suPDwcJUuWxMSJE+Hm5qZ7L8qXL48tW7agfPnyAJDjfDFTc8ZotVpcu3YNRYoUQfXq1dG7d2/07NlTt3/JkiX49ttvcfLkyTy3KcWr9Rw/fhxz587FsmXLkJmZiaioKPTo0cOqLyLn5+eHrVu34o033gDw4jDy4sWL46+//oK7uzt++OEH/Pzzz3Z5eKGnpydOnDihd+HDuLg4REVF4fvvv8f7779v8M+vPShQoADq1auHDz/8ULdNCIHu3btjzJgxKFGiBAAgOjpaqRIJQFBQEGbOnImmTZsCAH7//XfUrVsX165dg6OjI/r374/Tp0/j119/VbhSIutx8eJFo/t5bj3ZFcsfFECWVqFCBbFo0aJc9yckJOT7kFUvLy8xYcIEsXv3boOPOXPm5NqmqVk3Nzdx/vx5vW1//PGHqFChgujYsaP4888/Zc25urqKS5cu6Z57eHiItLQ03fOLFy8KNzc32XJPnjwR/fv3F2FhYSI+Pl633dHRUZw6dSrHz0vNGaPRaMSNGzeEEEIUKlRInDhxQm//uXPnhLu7u0ltm1rP9evX9bZlZmaKhQsXivr16wutVisCAwMtVo/cvL29xe+//657/vTpU+Ho6Kgbg99//124uroqVZ6i/P39xcGDB3Ns3717t/D09BT/+c9/7PaQ+7S0NFGzZk3RpUsXcf/+fd12KX/2SX7u7u56/wZlZ2cLR0dH3alXiYmJwtPTU6HqiIjI2vGieHagRo0aOH78eK77cztc25jq1asDAOrVq2fwUbNmzVzbNDVbrFixHN9qlyhRAnFxcTh69Cg+/vhjg69naq5IkSK4evWq7vlnn32md4jrnTt34OHhIVvO2dkZU6dOxcSJExEVFYVvv/0W2dnZBmuTI/c6c+bMQUxMDJydnXMcsnv//n24uLhIfo28MnREh6urKzp37oy4uDicOXPGqg9Hr1mzJqZNm6Z7Pm3aNPj5+cHPzw/Ai6NoPD09lSpPUbVq1cKWLVtybK9Xrx42btyIqVOnWr4olShXrhwOHDiAYsWKITw8HPv371e6JDKgQoUK2L59u+55XFwcnJ2dUaxYMQAv/i4zdtQaEeW0cuVKtG7dGpUqVUKlSpXQunVrrFq1SumyiBTBCb0dmDRpEgYMGJDr/qpVq+Z7AtihQwfdPXQNKVasGEaOHClrtmHDhli6dGmO7cWLF8euXbtw/vx5g+2ZmgsPD8fBgwd1z8ePH683Mf/tt99QpUoV2XIvNW3aFMeOHcO+fftQv379XH9OrpwhpUqVwpw5czBlyhS4uLggPj5eb39cXByCg4MlvUZ+vG7BqVy5cvjmm28sVI38xo8fj2XLlsHf3x+lS5fGf/7zH0yePFm3/8CBA2jWrJmCFSpn4MCBuf59Ub9+fWzcuBFdunSxcFXq4ejoiAkTJuCnn35Chw4d8O9//5uTQ5X54osv8Omnn6Jdu3aIjo5Gy5Yt0a9fP9047d69G5UqVVK4SiLrkJ2djXbt2qFdu3ZISUlBuXLlUK5cOZw6dQrt2rVD+/bt8/0lFZG14zn0ZDUuXryI1NRUREZGGtx/5coVbN++Pcf5oqbmXufIkSNwd3fP9y9i+cnFxMQgLi4O06dPR8mSJfP8Gqbm8urQoUNwcXFBtWrVZG/bkIsXL6JUqVI2PVG5evUqNm3ahCdPnqBhw4YICwtTuiSyMn/99Rd69OiBuLg4HDp0yKKLbmTcli1bsHjxYjx58gSRkZHo0aOHbt/L29fZwgU+icxtypQpGDt2LBYsWKC7NtJLGzZsQNeuXTFixAijX2QR2RpO6O3Q8ePHdfdyDgsL0x0CT0RkbZ4/f44rV66gVKlSSpdCRERmVqVKFQwYMADdunUzuH/u3LmYNm0akpOTLVwZkXI4obcjN27cQPv27bF79254e3sDADIyMtCgQQMsX75cd75ufu3ZswcTJ07UWyQYOnQo3n77bbNlz549i6lTp+rl+vfvj7Jly1osN2DAAJQpU8ZiOXP2zxx9MBcpnzdrYI4xtGVJSUmoXr26XV7l/nW42GEdOE5Eeefm5oYzZ87k+ufl4sWLCAkJQWZmpoUrI1IOz6G3I3379sX9+/dx6tQp3L59G7dv38bJkydx7949vft45sfixYvRuHFjuLu7o1+/fujXrx/c3NzQqFEjg+ety5Hdtm0bwsLCcOTIEVSpUgVVqlTB4cOHUbFiRb0LD5k7FxYWZtGcufpnjKl9MBcpnzdrYI4xJPt16tQpvdv9kTpxnIjyzs3NDRkZGbnuv3fvntHrNBHZJIWurk8K8PLyEkeOHMmx/fDhw6JgwYImtRkSEiImT56cY/ukSZNESEiIWbLh4eFi+PDhObYPHz5cVKtWjbl85owxR5tSSPm8WQO1vd9qUK1aNaOPkJAQu71t3eskJibyvbECHCeivGvWrJno3bt3rvt79eolmjZtasGKiJTHQ+7tSIECBbBv3z6Eh4frbU9ISEC9evVw7969fLfp4uKCU6dOoVy5cnrb09PTUalSJTx+/Fj2rKurK06cOIHy5cvrbf/9999RpUoV5vKZM8YcbUoh5fNmDdT2fquBq6sr2rdvn+s3mFevXsWcOXPs8pD7113/JDMzE7///rtdvjdqwnEiks+BAwdQv359tGrVCkOGDEFISAiEEDh9+jQmTZqE9evXIy4uDhEREUqXSmQxjkoXQJbTsGFD9O/fH8uWLUPx4sUBAH/++ScGDhyIRo0amdRmQEAAdu7cmWOCtWPHDgQEBJgl6+fnh8TExByTnsTERBQpUoS5fOaMMUebUkj5vFkDtb3falCpUiXUrl0bffr0Mbg/MTERc+bMsXBV6pCSkvLaxY7ff//dwlXRP3GciORTt25drFixAj179sTq1av19vn4+GDZsmWczJPd4YTejsyYMQNRUVEIDAzUTX4uX76MSpUqYfHixflqq1u3bpg2bRoGDx6Mfv36ITExEXXr1gUA7N+/H/Pnz8e0adNkzY4ZMwZDhgxBjx490LNnT5w7d04vN2HCBAwaNIi5POaMMUebUkj5vFkDtb3fahIREYEzZ87kur9AgQJ45513LFiRenCxwzpwnIjk9f777yMyMhLbtm1DWloaAKBChQpo0qQJ3N3dFa6OSAEKH/JPFpadnS1+/fVXERMTI2JiYsT27dtNaker1Yrr168LIYRYs2aNiIiIEL6+vsLX11dERESIdevWyZ59mcvOzhaTJ08WJUqUEBqNRmg0GlGiRAkxdepUkZ2dzVwec8aYo00ppHzerIHa3m+yDv369RP9+/fPdX96erqoX7++5QoigzhORERkTjyH3o4sXLgQ7dq1g4uLi972p0+fYvny5ejSpUue29Jqtbh27ZpJhwGbmjWUu3//PoAX39Ixl7+cMeZoUwopnzdroLb3m4iISK1u3bqFefPm4eDBg7h27RoAoFixYqhTpw66du1q8m2YiawVJ/R2xMHBAVevXs0xKfrrr79QpEiRfF2QR6vVIi0t7bV/aXp5ecmW1Wq1uH79er7/omYu/8zRphRSPm/WQG3vt1plZGRg7ty5OH36NACgYsWK6NatGwoWLKhwZUREZAlHjx5FZGQk3N3d0bhxYxQtWhQAcP36dezcuROPHj3Ctm3bUKNGDYUrJbIcTujtSG6ThqSkJDRo0AC3b9/OV1sajSbX/UIIaDQag4sEpma1Wi0KFixoNAsgRz+YM5wzxhxtSiHl82YN1PZ+q9GxY8cQGRkJNzc31KpVC8CLX+wyMzPx66+/vvZK4raOix3WgeNEJM2bb76JqlWrYtasWTn+zRRCoHfv3khOTsbBgwcVqpDI8nhRPDtQrVo1aDQaaDQaNGrUCI6Ofw97VlYWzp8/j//7v//Ld7urVq2Cr6+vSTWZmh09erRJv/gwl3/maFMKKZ83a6C291ttBg4ciKioKMyZM0f3d9jz58/RvXt3DBgwAHv37lW4QuUYWuyYPHkyvvnmGy52qAjHiUi6pKQkzJ8/3+ACuEajwcCBA1GtWjUFKiNSDr+htwOjR4/W/Xfw4MHw9PTU7XN2dkZgYCDatGkDZ2fnPLeplnPomTPP+eVqO2ddbfXIzdb7Jwc3NzckJCQgJCREb3tKSgpq1KiBR48eKVSZ8t5++22UK1fO4GLHuXPn7HqxQ004TkTSBQUFYfTo0ble92nhwoX46quvcOHCBcsWRqQgfkNvB0aOHAkACAwMRLt27eDq6qpwRaZ53eHIzMnHHG1S7vh+v56XlxcuXbqUY0J/+fJlu79w4LFjx/QmiQDg6OiIYcOG8TxSFeE4EUk3ZMgQ9OzZE8ePH0ejRo1ynEM/Z84cTJw4UeEqiSyLE3o7Eh0dDeDFLxUvz98LCwvDG2+8ke+2SpcuDQcHB5PqMDVr6sEkzKmjTSmkfN6sgdrebzV5eXeOdu3a4ZNPPsHEiRNRt25dAMD+/fsxdOhQfPTRRwpXqSwudlgHjhORdJ9++ikKFy6MKVOmYObMmbpr5zg4OOCNN97A/Pnz0bZtW4WrJLIsHnJvR/7880+0b98e+/fvh7e3N4AXF+ipW7culi9fjpIlS5rU7t27d/VuG5Kf84ClZJ88eQIAOW7Dx5xpOUu3aSopnxlroab3W2kv787h7e2NoUOHYtasWXj+/DkAwMnJCX369MH48ePt8r16udgxdOhQrF271uBiR5s2bTB16lRlC7VzHCci83j27Blu3boFAChcuDCcnJwUrohIIZa86T0pKzIyUtSuXVukpqbqtqWmpoo6deqIyMjIfLc3Z84cERoaKrRard4jNDRU/Pzzz2bJ/vrrr6Jp06bC29tbl/H29hZNmzYV27dvZy6fOWPM0aYUUj5v1kBt77daaDQacf36dd3zhw8fiuTkZJGcnCwePnyoYGXK02q14vr16+LJkyeiX79+wtnZWffZcXFxEQMGDBCPHz9Wuky7x3EiMp/Hjx/zzw/ZPX5Db0fc3Nxw4MCBHFf/PH78ON5+++18XVTq+++/x6hRo9CvXz9ERkbqncP066+/IiYmBqNGjcKQIUNkyy5YsADdu3fHBx98YDC3atUqzJ07F507d2YuDzljzNGmFFI+b9ZAbe+3muR2u03KeTHFR48e4ezZswCAsmXLwt3dXcny6H84TkTy2r59O6ZMmYKDBw/i3r17AF6c0lKnTh0MGjQIjRs3VrhCIgtTekWBLKd8+fLi8OHDObYfPnxYlC1bNl9tlSpVSqxYsSLX/cuXLxcBAQGyZsuXLy9mzJiRa+6HH34Q5cqVYy6POWPM0aYUUj5v1kBt77eaaDQaUblyZVGtWjWjD3uk0WjEjRs3lC6DXoPjRCSf+fPnC0dHR9G+fXvxyy+/iM2bN4vNmzeLX375RXz00UfCyclJLFy4UOkyiSyK39DbkfXr12PcuHH44YcfdFfUPXbsGPr27Yvhw4ejVatWeW7Lzc0N8fHxCA0NNbjf2K2kTM26uroiKSkJwcHBBnNnzpxBeHg4MjMzmctDzhhztCmFlM+bNVDb+60mWq02x+02DXl5Nw97otVqUalSJb2rphsSHx9voYrIEI4TkXwqVKiA/v3749NPPzW4f+bMmZgyZQrS0tIsXBmRcniVezvy8ccf49GjR6hdu7bePXAdHR3RrVs3dOvWTfezt2/fNtpWzZo1MX78eMydOzfHLylZWVmYMGECatasKWu2YsWKmDt3Lr777juD7c6bNw9hYWHM5TFnjDnalELK580aqO39VpuhQ4fqDlcmfZGRka9d7CDlcZyI5HHp0iWjh9Q3atQIgwcPtmBFRMrjN/R2ZMGCBXn+2Ze3uMtNcnIyIiMj8ezZM7zzzjt65/zu3bsXzs7O+PXXX1GpUiXZsrt370bz5s1RpkwZNG7cOMe9R8+dO4fY2Fi88847zOUhZ4w52pRCyufNGqjt/VaTl1e554Q+p3+em03qxHEiks8bb7yBRo0a5boAPnz4cOzYsQPHjx+3cGVEyuGEnkx2//59LF68GIcOHdK7jVidOnXQoUMHeHl5yZ69cOECfvzxR4O53r17IzAwkLl85IwxR5tSSPm8WQO1vd9qwclQ7rjYYR04TkTy4QI4UU6c0NuB5ORkg9sLFiyIUqVKQaPRWLgiIqK8uXjxIv+eygUXO6wDx4lIXlwAJ9LHCb0d0Gq10Gg0+OdQazQauLq6YsCAARgzZgwcHBzy3fa1a9dw+PBh3V+o/v7+qFWrFooVK2a27PPnz3Hq1Cm9XGhoKJycnJgzIWfpNqWQ8nmzBmp7v9UiJSUFM2bMwMGDB3P88vbZZ5/Z7fUFuNhhHThORERkVgpdXZ8s6MKFCwYfiYmJYu7cuaJ48eLi+++/z1ebDx48EB07dhQODg7C0dFRFClSRBQpUkQ4OjoKBwcH0alTJ/Hw4UNZs1lZWeI///mP8Pb2FhqNRu/h7e0tvvzyS5GVlcVcHnPGmKNNKaR83qyB2t5vNdm8ebNwdnYWb775phg5cqSYOXOmmDlzphg5cqSoW7eucHFxEVu3blW6TMWcOnVK9OnTR4SHh4tixYqJYsWKifDwcNGnTx9x6tQppcuj/+E4Ecnr2bNnIjExUWzdulVs3bpVJCUliadPnypdFpEiOKEnsXLlSlGpUqV8ZT755BNRvnx5sXXrVvH8+XPd9ufPn4tt27aJChUqiO7du8uaHTp0qPDz8xOzZs0S58+fF48ePRKPHj0S58+fF7NnzxZFihQRw4YNYy6POWPM0aYUUj5v1kBt77eaVKlSRYwYMSLX/SNHjhSVK1e2YEXqwcUO68BxIpIPF8CJcuKEnsS5c+eEh4dHvjLe3t5i//79ue7/7bffhLe3t6zZokWLGv2lZ+vWraJIkSLM5TFnjDnalELK580aqO39VhNXV1eRmpqa6/7U1FTh6upqwYrUg4sd1oHjRCQfLoAT5aRV+pB/Ut61a9fg5+eXr0x2djacnZ1z3e/s7Izs7GxZs/fv30fx4sVzzfn7++Phw4fM5TFnjDnalELK580aqO39VpPAwEDExsbmuj82NhalS5e2YEXq8fvvv6Njx4657v/oo4+QlpZmwYrIEI4TkXwWLlyIRYsWoVevXggMDISbmxvc3NwQGBiInj17YuHChZg/f77SZRJZFCf0du7mzZsYMWIEGjRokK9c8+bN0bNnTyQkJOTYl5CQgD59+qBFixayZuvXr48hQ4bg1q1bOfbdunULw4cPR/369ZnLY84Yc7QphZTPmzVQ2/utJmPGjMHw4cMRFRWFmJgYrFixAitWrEBMTAxatmyJL774At98843SZSqCix3WgeNEJB8ugBPlxKvc24Fq1aoZvLru3bt38ccffyA4OBi//vprvq4UfufOHXTo0AHbtm2Dj4+P7nY8N27cQEZGBiIjI7F06VJ4e3vLlr18+TKaNWuG1NRUVK5cWe/eoydOnEBYWBg2bdqEgIAA5vKQM8YcbUoh5fNmDdT2fqvNgQMHEBMTY/Aq9/3790edOnUUrlAZK1euRIcOHdC0aVOD92PeunUrli5dijZt2ihcqX3jOBHJ57333sPz58+xZMkSFC5cWG/frVu30LlzZzg4OGDTpk0KVUhkeZzQ24HRo0cb3O7l5YXg4GBERkaadMs6ADh9+rTB+4CGhISYJZudnY1t27YZzDVp0gRareGDTpjL/8E45mhTKimfN7VT4/tN6sfFDuvAcSKSBxfAiXLihN7GxcTEoGfPnnB1dcWlS5dQsmRJTgyIyCrdvXtXbzJUsGBBhSsiIiJL4wI4kT5O6G2co6Mjrly5giJFisDBwQFXr17VHa4s1dOnT7Fu3boc3zjUrVsXLVu2NHoRMynZI0eOGMzVrFnTaL3M5Z852jSVlM+MtVDT+60mP//8MyZPnowzZ84AAIQQ0Gg0CA4OxuDBg/HJJ58oXKHyuNhhHThOREQkN07obVypUqXwxRdfoFmzZggKCsKxY8dynHP06s/mVXp6OiIjI3HlyhXUrl1b75Cnw4cPo2TJktiyZQvKlSsnW/bGjRto06YN9u/fj1KlSunlLl26hIiICKxevTrHggVzhnPGmKNNKaR83qyB2t5vNfn+++8xatQo9OvXD5GRkXrvza+//oqYmBiMGjUKQ4YMUbhSZXCxwzpwnIjkxQVwolcocrM8spjZs2cLZ2dnodVqc31oNBqh1Wrz1W7jxo1Fy5Ytxd27d3Psu3v3rmjZsqVo0qSJrNk2bdqIOnXqGLwndWpqqqhbt6744IMPmMtjzhhztCmFlM+bNVDb+60mpUqVEitWrMh1//Lly0VAQIAFK1KP7777Tri7u4vPP/9cxMXFiZSUFJGSkiLi4uLEF198ITw8PMT333+vdJl2j+NEJJ/r16+Lt956S2g0GlG6dGlRq1YtUatWLVG6dGmh0WjEW2+9Ja5fv650mUQWxQm9Hbh37544ceKE0Gg0YufOnSIxMdHgIz/c3NzEiRMnct2fnJws3NzcZM16enqK+Pj4XHPHjh0Tnp6ezOUxZ4w52pRCyufNGqjt/VYTV1dXkZKSkuv+U6dOWfXYS8HFDuvAcSKSDxfAiXJyVPoIATK/AgUKoFKlSvjll18QEREBFxcXyW16e3vjwoULqFSpksH9Fy5cyPUWYqZmXVxccO/evVxrun//vsG+MWc4Z4w52pRCyufNGqjt/VaTmjVrYvz48Zg7dy4cHfX/ycrKysKECRPs9hDLGzduoHLlyrnur1y5Mm7dumXBisgQjhORfLZt24a9e/ciODg4x77g4GDExMSgfv36li+MSEG8DKQdadu2LbZt24aJEydi4sSJ2LBhAzIzM01qq3v37ujSpQumTJmC5ORkXL9+HdevX0dycjKmTJmCjz/+GD179pQ1265dO0RHR2Pt2rV6k5979+5h7dq16Nq1Kz766CPm8pgzxhxtSiHl82YN1PZ+q8mMGTPw66+/olixYmjdujX69OmDPn36oHXr1ihatCi2b9+OH374QekyFfFyseP58+c59tn7YoeacJyI5MMFcCIDlD5EgCxj/fr1ws/PT2g0Gr2Hn5+f2LBhg0ltjh8/Xvj7++vOwX95Pr6/v7+YMGGC7NnHjx+L3r17664J4OrqKlxdXYVWqxXOzs6iT58+4vHjx8zlMWeMOdqUSsrnTe3U+H6ryb1798TMmTNFly5dRJMmTUSTJk1Ely5dxI8//mjwugr2IikpSRQrVkwUKlRIvP/++6J3796id+/e4v333xeFChUS/v7+Rk9VIcvgOBHJ51//+pcoXbq0WLNmjd7f/3fv3hVr1qwRgYGB4rPPPlOwQiLL41Xu7cCBAwdQv359REVFYfDgwQgNDQUApKSkYNKkSdi0aRP27NmDN99806T2z507h+vXrwN4cZXRoKCgPGfPnz+vd4XSvGTv3buHY8eO6b3mG2+8AS8vr9fmjh8/rvd6ec3Z8uuZoxZzkvJ5UztzjCHZtvv372Px4sUG78fcoUMHfnZUguNEJI8nT55gwIABmDdvHp4/f667Ze3Tp0/h6OiITz75BFOmTOG39GRXOKG3A82aNUNAQABmz55tcH+vXr1w+fJlbN682cKVERHlzbVr13D48GHdZMjf3x+1atVCsWLFFK6MiIgsTY1fOBAphRN6O+Dr64s9e/bkelGe5ORk1KtXD3fu3MlXuykpKZgxY0aO+4DWqVMHn332GcLCwvLUzpUrVzB79mykp6fD398f3bt3R0hIiMGfvXXrFubNm2fw3qMff/wx/Pz8Xvt6Dx8+xH//+1/d63300UcoVKiQXb6eMXLUIie5Pm/WQK4xtAUPHz5Er169sHz5cmg0Gvj6+gIAbt++DSEEPvroI8yePRvu7u4KV6ocLnZYB44TERGZAyf0dsDNzQ2pqakoXbq0wf0XL15ESEhIvi6Qt2XLFrRq1QrVq1dHZGQkihYtCgC4fv06tm/fjuPHj2P9+vWIjIzMkXV3d8fFixfh5+eHlJQU1K1bF35+fqhWrRpOnDiBS5cu4eDBg6hSpYpe7ujRo4iMjIS7uzsaN26s95o7d+7Eo0ePsG3bNtSoUUMvFxYWht9++w2+vr64fPky3n77bWRkZKBChQo4e/YsHB0dcejQoRyHbtv66xljai3mIuXzZg3MMYa2onv37ti7dy+mT5+Oxo0bw8HBAcCLi4nt3LkTffv2xTvvvIM5c+YoXKnlcbHDOnCciOSlti8ciBSn0Ln7ZEGVK1cW8+bNy3X/3LlzReXKlfPVZpUqVcSIESNy3T9y5Mhc29RoNOL69etCCCFatmwpWrRoIZ49eyaEECIrK0u0b99eNG/ePEeudu3aomfPniI7OzvHvuzsbNGzZ0/x5ptvGn29jh07irp164qMjAwhhBD3798XjRs3Fh999JHdvZ4xptZiLlI+b9bAHGNoK7y9vcX+/ftz3f/bb78Jb29vC1akHp988okoX7682Lp1q3j+/Llu+/Pnz8W2bdtEhQoVRPfu3RWskITgOBHJ6ciRI8LHx0eUKFFCREdHi2HDholhw4aJ6OhoUbJkSeHr6yuOHj2qdJlEFsUJvR2YPHmy8PX1FbGxsTn2bdq0SRQqVEhMmjQpX226urqK1NTUXPenpqYKV1dXg/tenbwEBASIvXv36u2Pj48X/v7+Bl/z9OnTub7m6dOnDb7mq69XpkwZ8euvv+rt379/vwgICLC71zPG1FrMRcrnzRqYYwxthZeXl9Ffzo4cOSK8vLwsWJF6cLHDOnCciOSjti8ciNSA96G3A/3790fDhg3RvHlzhIaGonXr1nj//fcREhKCqKgo1KtXDwMGDMhXm4GBgYiNjc11f2xsbK6H+Gs0Gmg0GgCAVqtFwYIF9fZ7e3sbPJ+/WLFiOHLkSK6veeTIEd2h2IZeEwAeP34Mf39/vX0lSpTAzZs37e71jJFSizlI+bxZC7nH0FY0b94cPXv2REJCQo59CQkJ6NOnD1q0aKFAZcrLzs7WXeHZEGdnZ2RnZ1uwIjKE40Qkn6SkJAwcOFD3b+arNBoNBg4ciMTERMsXRqQgR6ULIPPTarVYuXIlVqxYgWXLliE1NRUAEBISglGjRqF9+/b5bnPMmDHo0KEDdu/ebfAc661bt2Lp0qUGs0IIVKhQARqNBg8ePEBycrLe+fLp6ekGLxI0ZMgQ9OzZE8ePH0ejRo1yvOacOXMwceJEg6/ZqFEjODo64t69ezhz5gwqVaqk23fx4kWDFxyz9dczRkot5iDl82Yt5B5DWzFjxgx06NABb7zxBnx8fFCkSBEAwI0bN5CRkYHIyEjMmDFD4SqV8XKxY+7cuahWrZrePntf7FATjhORfF5+4ZDbxZMt/YUDkRpwQm9H2rVrh3bt2snS1ocffogSJUogJiYGkyZNynHV8d27d6NOnToGs7/88ove83Llyuk9P3ToEN5///0cuU8//RSFCxfGlClTMHPmTGRlZQEAHBwc8MYbb2D+/Plo27ZtjtzIkSP1nnt6euo937hxI95++227ez1jTK3FXKR83qyBOcbQVvj4+GDLli04ffq0wXt45/ZLnT3gYod14DgRyUdtXzgQqQGvcm9nzp49i19++QXnzp3D1KlTUaRIEWzZsgWlSpVCxYoVlS4vz549e4Zbt24BAAoXLgwnJye+nh3UQkQ5paamGrydoz0vdqgRF6WI5LFixQpMmTIFx48fz/GFw6BBgyz6hQORGnBCb0f27NmDpk2bIiIiAnv37sXp06dRpkwZjB8/HseOHcOqVauULpEM2L17N2rXrg03NzeL5KzFkydP8Mcff6BkyZJwcXFRuhwyo6dPn2LdunUGb1HUsmVLo+cnExGRbeIXDkQv8KJ4duTzzz/H2LFjsX37dr1fgBs2bIhDhw7J+lovFwvkziYlJWHs2LGYOXOm7i/xl+7du4du3brJmvv5558RHR2tO01gxYoVCA0NRZkyZXIcJi1HzpAmTZrgwoUL+cpIyQEvDgV9VWJiIqKjoxEREYEPPvgAu3fvNqldU82fPx8HDx4E8OKicZ988gk8PDxQoUIFeHp6onfv3njy5IlFa5JT5cqV8fXXX+Py5ctKl6I66enpCA0NRXR0NBISEpCdnY3s7GwkJCSgS5cuqFixItLT05UuUxWEEIiLi8OcOXOwadMmPHv2TOmS6H+ePn2K//73vxg4cCA++ugjfPTRRxg4cCBWrlyJp0+fKl0ekVVycnKCv78//P39OZkn+6bkJfbJsjw8PMS5c+eEEEJ4enqKs2fPCiGEOH/+vHBxcZH1tRITE4VWq5U1u23bNuHs7CwqVqwoSpUqJQoVKiR27dql23/t2jVZc1OmTBEeHh6idevWwt/fX4wdO1YUKlRIjB07VowePVp4eXmJ2bNny5arVq2awYdGoxGhoaG653LljNFqtbrbqO3fv184OTmJevXqiaFDh4p3331XODo6ij179uSrTSmCgoLEoUOHhBBCDBkyRAQGBoo1a9aI06dPi3Xr1okKFSqIoUOHWqweuWk0GlGoUCHh4OAgIiMjxapVq8SzZ8+ULksVGjduLFq2bCnu3r2bY9/du3dFy5YtRZMmTRSoTHlNmzYVGRkZQggh/vrrL1G7dm2h0WiEn5+f0Gq1IiQkRNy4cUPhKiktLU2UKVNGuLq6inr16om2bduKtm3binr16glXV1dRrlw5kZaWpnSZRFYjMTFRfP311+KHH34QN2/e1Nt39+5d0bVrV4UqI1IGL4pnR7y9vXH16lUEBQXpbU9ISECJEiXy1dagQYOM7jd2iy1Ts6NGjcKQIUPwzTffQAiB77//HlFRUVi5ciX+7//+L9f2TM3Nnj0bP/30Ezp06ICEhATUqlULs2bNwieffALgxa3EfvzxR/Ts2VOW3IkTJ9C4cWO8+eabum1CCCQlJaFBgwa6Cyn9k6k5Y8QrZ+KMGjUKnTt3xty5c3XbBgwYgNGjR2Pnzp35btsUV65c0d3KbcOGDfjxxx91YxcSEgIfHx907twZ3333nUXqMYfk5GQcOXIE8+bNQ/v27eHj44MuXbrgk08+QWhoqNLlKWb//v04cuQIvLy8cuzz8vLC119/jdq1aytQmfK2bt2qOzLlyy+/xP3793H27FkEBQXhjz/+QKtWrfDVV1/hxx9/VLhS+9anTx9UrlwZCQkJOT7H9+7dQ5cuXfDpp59i27ZtClVIZD1+/fVXtGjRAuXLl8f9+/fx1VdfYeXKlWjQoAEAIDMzEwsWLMC8efMUrpTIghRdTiCLGjx4sHjrrbfE1atXRYECBURaWpr47bffRJkyZcSoUaPy1ZZWqxXVq1cX9evXN/ioUaNGrt/Qm5r18vIS6enpetuWLFkiPDw8xMaNG3P9pt3UnJubm7h48aLuuYuLizh58qTueVpamvD29pYt99tvv4myZcuKr776SmRlZem2Ozo6ilOnTuX4eak5YzQaje4ben9/f3Hw4EG9/SdPnhSFCxc2qW1TlC5dWndURYkSJcTRo0f19qekpAgPDw+L1SO3V99vIYS4cuWKGDdunChfvrzQarWiTp06Yu7cuQpWqBx/f3+xcePGXPdv2LBB+Pv7W7Ai9Xj1cxMcHCzWr1+vt3/Hjh0iKChIidLoFW5ubuLEiRO57k9OThZubm4WrIjIetWpU0f8+9//FkIIkZ2dLSZMmCA8PT3Fli1bhBC5H3VJZMs4obcjT548Ed27dxeOjo5Co9EIJycnodVqRadOncTz58/z1VaFChXEokWLct2fkJCQ61+opmb9/PzEsWPHcmxftmyZcHd3Fz/++KOsuUKFComUlBTd85IlS4oLFy7onqelpQlPT0/ZckIIkZGRIdq3by9q166tW4TIy8Tc1FxuNBqNSE9PF3fv3hVBQUEiPj5eb396erpwd3c3qW1T/Pvf/xZ16tQRd+7cEZ9//rlo0aKFuH//vhBCiIcPH4q2bdta9WHXr57i8E9xcXGiU6dOVr1gIcWIESOEj4+PmDx5skhKShLXrl0T165dE0lJSWLy5MnC19dXjBw5UukyFaHRaHSH1BcpUkRv4VAIIS5cuCD76VSUf1yUIpKPqV/SENkyHnJvR5ydnTFnzhyMGDECJ0+exIMHD1CtWjWUL18+323VqFEDx48fR6dOnQzu12g0eodty5ENDw9HXFwc3njjDb3t7du3hxAC0dHRBtszNRcSEoLk5GTd4c7/vGBZamoqAgMDZcsBQMGCBbFs2TL88ssveOuttzB69GhoNBqDPytHzpgKFSoAeHH4/bFjx1CtWjXdvlOnTqF48eKS2s+PkSNH4uTJkyhTpgxq1KiBffv2oWjRoihRogSuXLmCQoUKYfv27RarR265/VkBgPr166N+/fq4d++eBStSjzFjxsDDwwPff/89Bg8erPtcCyFQrFgxDB8+HMOGDVO4SuV8/PHHcHFxwbNnz3D+/Hm9249eu3YN3t7eyhVHAIDu3bujS5cuGDFihMH7Zo8dOxZ9+/ZVuEoi6+Di4oKMjAy9bR06dIBWq0W7du0wadIkZQojUhAn9HaoVKlSKFWqlKQ2Jk2aZPSq4lWrVkV2dras2T59+mDv3r0GMx999BGEEJgzZ45suQkTJsDDwyPXOi9duoRevXrJlntV165d8dZbb6Fjx454/vy50Z+VI/dPcXFxes9fnr/+0vnz53NcA8CcnJ2dsX79emzduhUbN26Eg4MDsrOz4e/vj4iICHTo0MHoe6520dHRr729oKFzyO3F8OHDMXz4cJw7dw7Xr18H8OK2df+8Hoi9eXUxsmXLlnj06JHe/tWrVyM8PNzCVdE/cVGKSD6mfklDZMt4H3o7IoTAqlWrEBcXhxs3buSYNK9ZsyZP7cTExKBnz55wdXXFpUuXEBAQkOdvg03N2msuOzsb9+/fh5eXl8F2TM2Zow/m8s96SpYsCa3Wdu64qbb3m2zHw4cP4eDgAFdXV6VLof85f/48rl27BoCLUkSmWLt2Lfbu3YspU6YY3L906VLMmTMnxxcTRLaME3o70r9/f8yePRsNGjRA0aJFc0waXt4z/XUcHR1x5coVFClSBA4ODrh69Wqer6RuapY5eXOWbtOW6pGbrfdPDikpKZgxYwYOHjyoNxmqU6cOPvvsM4SFhSlcIRERmRsXwIkM4yH3dmTRokVYs2YNmjVrJqmd4sWLY/Xq1WjWrBmEEPjjjz/w+PFjgz/7z0P7Tc0yJ2/OGHO0KYXa6pGbrfdPqi1btqBVq1aoXr06WrZsqXf+8fbt21G9enWsX78ekZGRCleqjKtXr2Lnzp3w9fVF48aN4ezsrNv38OFDTJo0CV999ZWCFdI/XblyBbNnz0Z6ejr8/f3RvXt3hISEKF0WkeoNGjQI7du3h6urK4KCgrgATvSShS6+RyoQGBgoTp8+Lbmd2bNnC2dnZ6HVanN9aDQag1cZNTXLnLw5c42vOaitHrnZev+kqlKlihgxYkSu+0eOHCkqV65swYrU48iRI8Lb21t4eXkJNzc3Ua5cOb0r3fNqz+rg5uamuxvBqVOnRMGCBUW5cuXEhx9+KEJCQoS7u7tISkpSuEoi9QsICBAzZ84UFy5cEBqNRhw/flxcvHjR4IPInvCQezuyYMECbN26FfPmzXvtBbhe5/79+7h48SKqVKmCHTt2oFChQgZ/rmrVqrJlmZM3Z4w52pRCbfXIzdb7J4WbmxsSExMRHBxscP+ZM2cQHh6OzMxMC1emvHfffRcBAQH4+eef8fDhQwwfPhz//e9/sX37dlSrVg3Xr19H8eLFkZWVpXSpdk2r1eLatWsoUqQIWrVqhezsbKxZswaOjo7Izs5Gx44d8eDBA2zcuFHpUolU7aeffkLfvn2NXvRXCAGNRsO/98iucEJvRzIzM/H+++9j//79CAwMhJOTk97++Pj4fLe5YMECtG/fHi4uLhbLMidvztJtSqG2euRm6/0zRWhoKHr06IFBgwYZ3D958mT89NNPSE1NtXBlyvP19cWhQ4d0t5gEgPHjx+O7777Dtm3bUKpUKU7oVeDVCX2pUqWwZMkSvP3227r9CQkJeO+993DlyhUFqySyDlwAJ8qJE3o70rZtW8TFxeGDDz4weFG8kSNH5rvNzMxMbN++Hb///juAF/cuf/fdd/N0BICpWebkzVm6TSnUVo/cbL1/pli5ciU6dOiApk2bonHjxjnu4b1161YsXboUbdq0UbhSy/P19cXu3btRpUoVve0TJ07EN998g3nz5uGDDz7ghF5hDg4OuHbtGvz8/BAYGIgNGzbojdn58+cRFhZml0eZEJmKC+BEr1DwcH+yMHd3d7Fv3z7Z2lu/fr3w8/MTGo1G7+Hn5yc2bNhglixz8uaMMUebUqitHrnZev+k2L9/v2jXrp0oVaqUcHZ2Fs7OzqJUqVKiXbt24sCBA0qXp5i3335b/Pjjjwb3TZgwQbi4uPAcehXQaDTC29tb+Pj4CCcnJ7Fo0SK9/b/++qsIDAxUqDoi6/To0SOxfv168f3334vvv/9erF+/Xjx69EjpsogUwQm9HQkODpbtwjv79+8XTk5Ook2bNuLAgQPizp074s6dO2L//v2idevWwtnZWRw8eFDWLHPy5owxR5tSqK0eudl6/8g85syZIzp16pTr/vHjx3OiqALz58/Xe/zzz/KYMWPEwIEDFaqOyPpwAZxIHw+5tyOxsbGYPn06Zs2ahcDAQEltNWvWDAEBAZg9e7bB/b169cLly5exefNm2bLMyZszxhxtSqG2euRm6/0jIiKSw4EDB1C/fn1ERUVh8ODBCA0NBQCkpKRg0qRJ2LRpE/bs2YM333xT4UqJLEjpFQWyHG9vb93tsTw9PYWPj4/eIz98fHxEcnJyrvuTkpKEt7e3rFnm5M0ZY442pVBbPXKz9f6ZU0pKiggKClK6DCIisoCmTZuKnj175rq/Z8+eomnTphasiEh5jkovKJDlTJ06Vba2MjMz4eXllev+ggUL4vHjx7JmmZM3Z4w52pRCbfXIzdb7Z05Pnz7FxYsXlS5DlU6fPo333nsP586dU7oUMoLjRJR3hw4dwoQJE3Ld/+mnn6JevXoWrIhIeZzQ25Ho6GjZ2ipfvjx27dqFrl27Gty/c+dOlC9fXtYsc/LmjDFHm1KorR652Xr/pMjtdnUv3bx500KVWB8udlgHjhNR3nEBnCgnTujtTFZWFtatW4fTp08DACpWrIioqCg4ODjkq52uXbtiyJAhKFq0KJo1a6a3LzY2FsOGDcO///1vWbPMyZszxhxtSqG2euRm6/2TYtq0aQgPD8/1F7gHDx5YuCL14GKHdeA4EcmHC+BEOfGieHYkPT0dzZo1w59//ong4GAAwJkzZxAQEIDY2FiULVs2z21lZ2ejXbt2WL16NYKDgxEaGgohBE6fPo20tDS0atUKK1euhFarlS3LnLw5c42vOaitHrnZev+kCA4OxogRI9CpUyeD+xMTE/HGG2/Y5b3WHRwcXrvYER8fb5fvjZpwnIjkM2XKFIwdOxaLFi0yuAAeHR2Nf//7369dSCOyJZzQ25FmzZpBCIElS5bA19cXAPDXX3+hU6dO0Gq1iI2NzXebK1aswLJly/D7778DACpUqID27dujffv2ZssyJ2/O0m1KobZ65Gbr/TNFx44dUaRIEUyZMsXg/qSkJFSrVg3Z2dkWrkx5XOywDhwnIvlwAZwoJ07o7YiHhwcOHTqEypUr621PSkpCRESEXR+6SkTqdO3aNTx58gSlS5dWuhTV4WKHdeA4EcmPC+BEf+PylR1xcXHB/fv3c2x/8OABnJ2dTW737Nmz+PLLL9GhQwfcuHEDALBlyxacOnXKbFnm5M1Zuk0p1FaP3Gy9f/kRExMDb29vlC5dGpcuXQLXn/VNmjQJAwYMyHV/1apVOUlUAY4TkfzatWuHdevWISUlBSkpKVi3bh0n82S3OKG3I82bN0fPnj1x+PBhCCEghMChQ4fQu3dvREVFmdTmnj17ULlyZRw+fBirV6/WfcuflJSEkSNHmiXLnLw5Y8zRphRqq0dutt6//Bo0aBDu3bsHAAgKCuLFw17BxQ7rwHEiMh8ugBP9j+VueU9Ku3PnjoiKihIajUY4OzsLZ2dnodVqRatWrURGRoZJbb755pti0qRJQgghPD09xdmzZ4UQQhw+fFiUKFHCLFnm5M0ZY442pVBbPXKz9f7lV0BAgJg5c6a4cOGC0Gg04vjx4+LixYsGH/bGwcFBXL9+XQghhFar1f0/qQvHicg8du/eLdzc3ETjxo2Fs7Oz7t/Lb7/9VrRp00bh6ogsi7etsyPe3t5Yv3490tPTdbetCw0NRbly5Uxu88SJE1i6dGmO7UWKFMGtW7fMkmVO3pwx5mhTCrXVIzdb719+ffnll+jbty8+++wzaDQa1KxZM8fPCCGg0Wjs7oJixYsXx+rVq3UXO/3jjz9yvfdyqVKlLFwdvcRxIjKPzz//HGPHjsWgQYNQoEAB3faGDRtixowZClZGZHmc0NuhcuXKSZrEv8rb2xtXr15FUFCQ3vaEhASUKFHCLFnm5M0ZY442pVBbPXKz9f7lV8+ePfHRRx/h4sWLqFKlCnbs2IFChQopXZYqcLHDOnCciMyDC+BEf+M59HakTZs2mDBhQo7t3333HT788EOT2mzfvj2GDx+Oa9euQaPRIDs7G/v378eQIUPQpUsXs2SZkzdnjDnalEJt9cjN1vtnigIFCqBSpUr45ZdfEBERgapVqxp82JuePXvi1q1bSEpKghAC27dvR3x8vN4jISEB8fHxSpdq1zhORObxcgH8n+x1AZzsnIKH+5OFFS5cWCQnJ+fYnpycLIoUKWJSm0+ePBHdu3cXjo6OQqPRCCcnJ6HVakWnTp3E8+fPzZJlTt6cMeZoUwq11SM3W++fFI8ePRLr168X33//vfj+++/F+vXrxaNHj5QuSxXmz58vHj9+rHQZ9BocJyL5DB48WLz11lvi6tWrokCBAiItLU389ttvokyZMmLUqFFKl0dkUbwPvR1xc3NDYmIigoOD9banpqaiWrVqyMzMNLntS5cu4eTJk3jw4AGqVauG8uXLmz3LnLw5S7dpS/XIzdb7l18bNmxA9+7dcxxGWbhwYcydOxctWrRQqDJ1yMzMxPbt2/Xux/zuu+/Czc1N4croVRwnIvk8ffoUn376KebPn4+srCw4OjoiKysLHTp0wPz58+Hg4KB0iUQWwwm9HalVqxaaN2+Or776Sm/7qFGjsHHjRhw/flyhyoiIDDtw4ADq16+PqKgoDB48GKGhoQCAlJQUTJo0CZs2bcKePXvw5ptvKlypMrjYYR04TkTmwQVwIk7o7crGjRvRunVrdOjQAQ0bNgQA7Ny5E8uWLcPKlSvRqlWrfLcphMCqVasQFxeHGzduIDs7W2//mjVrZM8yJ2/OGHO0KYXa6pGbrffPFM2aNUNAQABmz55tcH+vXr1w+fJlbN682cKVKY+LHdaB40RERObEq9zbkRYtWmDdunUYN24cVq1aBTc3N92Vo+vVq2dSmwMGDMDs2bPRoEEDFC1aFBqNxuxZ5uTNWbpNW6pHbrbeP1McOnTI4MU8X/r0009N/vvL2o0dOxZdu3bNsdhRt25d1K1bF7169cKYMWPscrFDTThORPLjAjjR3/gNPUni6+uLxYsXo1mzZhbLMidvztJtSqG2euRm6/0zhZubG1JTU1G6dGmD+y9evIiQkBBJ1wCxVr6+vtizZw8qV65scH9ycjLq1auHO3fuWLgyehXHiUh+/fv3N7oA/ssvvyhUGZHl8Rt6O/T06VODq5mlSpXKd1sFCxZEmTJlTKrD1Cxz8uYs3aYUaqtHbrbeP1OUL18eu3btQteuXQ3u37lzp92eM5mZmQkvL69c9xcsWBCPHz+2YEVkCMeJSH6LFi3CmjVruABOBN6H3q6kpaXh7bffhpubG0qXLo2goCAEBQUhMDAQQUFBJrU5atQojB492qRvx0zNMidvztJtSqG2euRm6/0zRdeuXTFkyBCDhyPHxsZi2LBh+Pjjjy1fmAq8XOzIjT0vdqgJx4lIflwAJ/obD7m3IxEREXB0dMTnn38Of3//HIcnVa1aNd9tZmZm4v3338f+/fsRGBgIJycnvf3x8fGyZ5mTN2eMOdqUQm31yM3W+2eK7OxstGvXDqtXr0ZwcDBCQ0MhhMDp06eRlpaGVq1aYeXKldBq7W99esqUKRg7diwWLVqU41uq2NhYREdH49///jcGDRqkUIUEcJyIzGHBggXYunUr5s2bx1s/kt3jIfd2JDExEcePH0dISIhsbUZHR+P48ePo1KlTvi/iZWqWOXlzlm7TluqRm633zxRarRYrV67EihUrsGzZMqSmpgIAQkJCMGrUKLRv317hCpXTv39/HDhwAM2bN891sWPAgAFKl2n3OE5E8mvbti2WLVuGIkWKcAGc7B6/obcjNWvWxJQpU/DWW2/J1qaHhwe2bdtmUpumZpmTN2fpNqVQWz1ys/X+kXm8XOz4/fffAQAVKlRA+/bt7XqxQ404TkTyadu2LeLi4vDBBx8YXAAfOXKkQpURWR6/obcjEyZMwLBhwzBu3DhUrlw5x2qmsYv25CYgIMCknJQsc/LmLN2mFGqrR2623j+pzp49i19++QXnzp3D1KlTUaRIEWzZsgWlSpVCxYoVlS5PMe3atUO7du2ULoNeg+NEJJ/Y2FgugBP9j/2ddGjHGjdujEOHDqFRo0YoUqQIfHx84OPjA29vb/j4+JjU5qRJkzBs2DBcuHDBYlnm5M1Zuk0p1FaP3Gy9f1K8vO3X4cOHsXr1ajx48AAAkJSUxG9i8GKx48svv0SHDh1w48YNAMCWLVtw6tQphSujV3GciOTBBXCiv/GQezuyZ88eo/vr1auX7zZ9fHzw6NEjPH/+HO7u7jm+9b99+7bsWebkzRljjjalUFs9crP1/klRp04dfPjhhxg0aBAKFCiApKQklClTBkeOHEHr1q3xxx9/KF2iYvbs2YOmTZsiIiICe/fuxenTp1GmTBmMHz8ex44dw6pVq5QukcBxIpJTbGwspk+fjlmzZiEwMFDpcogUxUPu7YgpE/bXmTp1qsWzzMmbs3SbUqitHrnZev+kOHHiBJYuXZpje5EiRXDr1i0FKlKPzz//HGPHjtUtdrzUsGFDzJgxQ8HK6FUcJyL5dOrUCY8ePULZsmW5AE52j9/Q24Hk5OQ8/VyVKlXMXAkRkWlKliyJ//73v6hbt67eN/Rr167FkCFDcPbsWaVLVIynpydOnDiBoKAgvffmwoULCAkJwePHj5UukcBxIpLTggULjO6Pjo62UCVEyuM39HYgPDwcGo0GxtZuNBoNsrKyTGo/KysL69atw+nTpwEAFStWRFRUFBwcHMyWZU7enKXblEJt9cjN1vtnqvbt22P48OFYuXIlNBoNsrOzsX//fgwZMgRdunRRujxFeXt74+rVqwgKCtLbnpCQgBIlSihUFf0Tx4lIPpywE/2N39DbgYsXL+bp50qXLp3vttPT09GsWTP8+eefCA4OBgCcOXMGAQEBiI2NRdmyZWXPMidvzhhztCmF2uqRm633T4qnT5/i008/xfz585GVlQVHR0dkZWWhQ4cOmD9/vl0veAwZMgSHDx/GypUrUaFCBcTHx+P69evo0qULunTpwosGqgTHiUheXAAneoETesrhX//6F8aMGYPChQu/9mebNWsGIQSWLFkCX19fAMBff/2FTp06QavVIjY2VvYsc/LmjDFHm1KorR652Xr/5HDp0iWcPHkSDx48QLVq1VC+fHmlS1IcFzusA8eJSD5cACf6Gyf0lIOXlxcSExNRpkyZ1/6sh4cHDh06hMqVK+ttT0pKQkREhO7WUnJmmZM3Z4w52pRCbfXIzdb7R+bFxQ7rwHEiko4L4ER/4zn0lEN+1nhcXFxw//79HNsfPHgAZ2dns2SZkzdnjDnalEJt9cjN1vsnhRACq1atQlxcHG7cuIHs7Gy9/WvWrFGoMvUoVaoUSpUqpXQZ9BocJyLp9uzZg0OHDukm8wBQqFAhjB8/HhEREQpWRmR5WqULIOvWvHlz9OzZE4cPH4YQAkIIHDp0CL1790ZUVJRZsszJmzPGHG1KobZ65Gbr/ZNiwIAB6Ny5M86fPw9PT08ULFhQ72HPhBBYuXIl/vWvf+GDDz5A69at9R6kDhwnIvlwAZzoFYLoHzw9PcXZs2fz9LN37twRUVFRQqPRCGdnZ+Hs7Cy0Wq1o1aqVyMjIMEuWOXlzxpijTSnUVo/cbL1/Uvj4+IjY2Fily1Clfv36CRcXF/F///d/Ijo6Wnz88cd6D1IHjhORfDp37iwqVqwoDh06JLKzs0V2drY4ePCgqFSpkoiOjla6PCKL4jn0lMOr98fNq/T0dN1VRkNDQ1GuXDmzZ5mTN2fpNm2pHrnZev9MERQUhC1btiAkJETpUlTH19cXixcvRrNmzZQuhYzgOBHJJyMjA9HR0di4cSOcnJwAAM+fP0dUVBTmz59v90dukX3hhJ5yMGVCT0RkTgsWLMDWrVsxb948uLm5KV2OqnCxwzpwnIjkxwVwIp5DTwZ06tQJXl5eefrZNm3aYMKECTm2f/fdd/jwww/NkmVO3pwx5mhTCrXVIzdb758Ubdu2xZ07d1CkSBFUrlwZ1atX13vYs1GjRmH06NHIzMxUuhQyguNEJL9y5cqhRYsWaNGiBSfzZLf4Db2NS05OzvPPVqlSJd/t+/n5YdeuXTlus3XixAk0btwY169flz3LnLw5Y8zRphRqq0dutt4/Kdq2bYu4uDh88MEHKFq0KDQajd7+kSNHKlSZ8jIzM/H+++9j//79CAwM1B1++lJ8fLxCldGrOE5E8mnTpg1q1aqF4cOH623/7rvvcPToUaxcuVKhyogsj7ets3Hh4eHQaDQQQuT4BfifsrKy8t1+blcTdXJywr1798ySZU7enDHmaFMKtdUjN1vvnxSxsbHYtm0b3nrrLaVLUZ3o6GgcP34cnTp1MrjYQerAcSKSz969ezFq1Kgc25s2bYpJkyZZviAiBfGQext3/vx5nDt3DufPn8fq1asRFBSEmTNnIiEhAQkJCZg5cybKli2L1atXm9R+5cqVsWLFihzbly9fjrCwMLNkmZM3Z4w52pRCbfXIzdb7J0VAQECeTwWyN7GxsVi7di1+/PFHjBo1CiNHjtR7kDpwnIjkwwVwor/xG3obV7p0ad3/f/jhh4iJidG7wm6VKlUQEBCAESNGoFWrVvluf8SIEWjdujXOnj2Lhg0bAgB27tyJZcuWvfZwJ1OzzMmbM8YcbUqhtnrkZuv9k2LSpEkYNmwYZs2ahcDAQKXLURUudlgHjhORfF4ugH/11Vd627kATnZJwVvmkYW5urqKlJSUHNtTUlKEq6urye1u2rRJ1K1bV7i7u4tChQqJBg0aiN27d5s1y5y8OUu3aUv1yM3W+2cqb29v4ezsLLRarfD09BQ+Pj56D3u2adMmERkZKc6fP690KWQEx4lIPhs2bBCOjo6iS5cuYv78+WL+/Pmic+fOwtHRUaxdu1bp8ogsihfFsyPVq1dHpUqV8PPPP+sOU3r69Cm6d++OkydP8oI8RKRaCxYsMLo/OjraQpWoj4+PDx49eoTnz5/D3d09x8XWbt++rVBl9CqOE5G8YmNjMW7cOCQmJsLNzQ1VqlTByJEjUa9ePaVLI7IoTujtyJEjR9CiRQsIIXRXtE9OToZGo8HGjRtRq1Ytk9t++vQpbty4gezsbL3tpUqVMluWOXlzlm5TCrXVIzdb7x/Ji4sd1oHjRERE5sAJvZ15+PAhlixZgtTUVABAaGgoOnToAA8PD5PaS0tLQ7du3XDgwAG97eJ/V9U3duV8U7PMyZszxhxtSqG2euRm6/2TKisrC+vWrcPp06cBABUrVkRUVBQcHBwUroyIiJTABXAiXhTP7nh4eKBnz56ytffxxx/D0dERmzZtgr+/f75uw2Nqljl5c5Zu05bqkZut90+K9PR0NGvWDH/++SeCg4MBAN9++y0CAgIQGxuLsmXLKlyhsrjYYR04TkTy4AI40d/4Db2N27BhQ55/NioqKt/te3h44Pjx4wgJCbFYljl5c5ZuUwq11SM3W++fFM2aNYMQAkuWLIGvry8A4K+//kKnTp2g1WoRGxurcIXKMbTYcebMGS52qAzHiUg+ERERcHR0xOeff25wAbxq1aoKVUZkefyG3sbl9VZ0pq5mhoWF4datW/nOSckyJ2/O0m1KobZ65Gbr/ZNiz549OHTokG4yDwCFChXC+PHjERERoWBlyuvXrx/Kli2r9/68XOzo16+fXS92qAnHiUg+iYmJXAAnesmSl9Qn27Nz505Rp04dERcXJ27duiXu3r2r9zBHljl5c8aYo00p1FaP3Gy9f1L4+PiI/fv359j+22+/2f1t69zd3UVycnKO7YmJicLDw0OBisgQjhORfGrUqCH27dundBlEqsBD7kkSrVYLADkOdRJ5OIfJ1Cxz8uaMMUebUqitHrnZev+k6NKlC+Lj4zF37lzdHTkOHz6MHj164I033sD8+fOVLVBBvr6+2LRpE+rWrau3ff/+/WjRogVvh6YSHCci+ezatQtffvklxo0bh8qVK+e4DaSXl5dClRFZHg+5tzN79uzBxIkTdRfkCQsLw9ChQ/H222+b1F5cXJzJtZiaZU7enKXblEJt9cjN1vsnRUxMDKKjo1GnTh3dL27Pnz9HVFQUpk2bpnB1ymrevDl69uyZY7Gjd+/eJl0bhcyD40Qkn8aNGwMAGjVqpLedC+Bkj/gNvR1ZvHgxunbtitatW+vOOd2/fz/Wrl2L+fPno0OHDgpXSERkXHp6um5BMjQ0FOXKlVO4IuVlZGQgOjoaGzduzLHYMX/+fBQsWFDhCgngOBHJac+ePUb316tXz0KVECmPE3o7Ehoaip49e2LgwIF62ydPnow5c+bofknOi+Tk5Dz9XJUqVWTLMidvzhhztCmF2uqRm633jyyDix3WgeNERERy4oTejri4uODUqVM5fnlIT09HpUqV8Pjx4zy3pdVqodFoYOzjk9shT6ZmmZM3Z4w52pRCbfXIzdb7J4c2bdqgVq1aGD58uN727777DkePHsXKlSsVqoyIiCyFC+BEOfEcejsSEBCAnTt35pjQ79ixAwEBAflq6/z58ybXYWqWOXlzlm5TCrXVIzdb758c9u7di1GjRuXY3rRpU0yaNMnyBakIFzusA8eJSLrw8HAugBP9k/kvpE9qMXPmTOHs7Cx69+4tFi5cKBYuXCh69eolXFxcxKxZs8z62n369BE3b960aJY5eXOWblMKtdUjN1vvnyGurq4iNTU1x/bTp08LV1dXBSpSj8KFCxu8HVpycrIoUqSIAhWRIRwnIukuXLiQpweRPdEqvaBAltOnTx8sX74cJ06cwIABAzBgwACcPHkSK1asQK9evcz62osXL8a9e/csmmVO3pyl25RCbfXIzdb7Z0jlypWxYsWKHNuXL1+OsLAwBSpSjwcPHsDZ2TnHdicnJ7v7nKgZx4lIutKlS+fp8dK//vUv3Lp1S8GKicyPh9zbmffffx/vv/++xV9XSLhUg6lZ5uTNWbpNKdRWj9xsvX+GjBgxAq1bt8bZs2fRsGFDAMDOnTuxbNkyuz9U+eVix1dffaW3nYsd6sJxIrK8xYsXY8iQIShcuLDSpRCZDSf0dujp06e4ceMGsrOz9baXKlVKoYqIiIxr0aIF1q1bh3HjxmHVqlVwc3NDlSpVsGPHDru/PREXO6wDx4nI8uxxAZzsDyf0diQtLQ3dunXDgQMH9LYLIXgBESJSvffeew/vvfee0mWoDhc7rAPHiYiIzIETejvy8ccfw9HREZs2bYK/vz80Go3SJRER5QuPMDKMix3WgeNERERy44TejiQmJuL48eMICQlRuhQionzhEUavx8UO68BxIiIiOXFCb0fCwsIUu9Jnp06d4OXlZdEsc/LmLN2mFGqrR2623j9DeIRR7rjYYR04TkREZA4awatF2LRXb4Vz7NgxfPnllxg3bhwqV64MJycnvZ/N6wQhOTk5z69fpUoVWbLMyZszxhxtSqG2euRm6/2Ti4eHB48wykVERAQcHR3x+eefG1zsqFq1qkKV0as4TkSW16dPH3z99de8yj3ZNE7obZxWq9X7peHlNwGvyu+3Ay/bNNTWP/2zTVOzzMmbM8YcbUqhtnrkZuv9k0vNmjUxZcoUvPXWW0qXojpc7LAOHCciabgATmQYD7m3cXFxcbK3ef78ed3/JyQkYMiQIRg6dCjq1KkDADh48CAmTZqE7777TrYsc/LmjDFHm1KorR652Xr/5DJhwgQMGzZM8hFGtkjJ06ko7zhORNKEh4dzAZzIEEEkQc2aNUVsbGyO7bGxsaJ69epmyTInb84Yc7QphdrqkZut908KjUYjNBqN0Gq1eo+X2+zZzp07RZ06dURcXJy4deuWuHv3rt6D1IHjRCTNhQsXdI+1a9eKsmXLilmzZomkpCSRlJQkZs2aJcqXLy/Wrl2rdKlEFsVv6O3Mvn37MHv2bJw7dw4rV65EiRIlsGjRIgQFBZl0KOuJEycQFBSUY3tQUBBSUlLMkmVO3pwx5mhTCrXVIzdb758U5jjayFY0btwYANCoUSO97YIXW1MVjhORNKVLl9b9/4cffoiYmBg0a9ZMt61KlSoICAjAiBEj0KpVKwUqJFIGz6G3I6tXr0bnzp3RsWNHLFq0CCkpKShTpgxmzJiBzZs3Y/Pmzflus3r16qhUqRJ+/vlnODs7A3hxS57u3bvj5MmTiI+Plz3LnLw5Y8zRphRqq0dutt4/Mo89e/YY3V+vXj0LVULGcJyI5OPm5ob4+HiEhobqbT99+jSqV6+OzMxMhSojsjxO6O1ItWrVMHDgQHTp0gUFChRAUlISypQpg4SEBDRt2hTXrl3Ld5tHjhxBixYtIITQXYAkOTkZGo0GGzduRK1atWTPMidvzhhztCmF2uqRm633zxR5vQgSL4BERGQ/uABO9DdO6O2Iu7s7UlJSEBgYqDehP3fuHMLCwvD48WOT2n348CGWLFmC1NRUAEBoaCg6dOgADw8Ps2WZkzdn6TalUFs9crP1/uXXq3cByI29Hq7MxQ7rwHEikh8XwIn+xgm9HSlTpgx++uknNG7cWG9Cv3DhQowfP97uz9ElIvW5ePFinn7u1XMr7QUXO6wDx4nIPLgATvQCL4pnR3r06IH+/ftj3rx50Gg0uHLlCg4ePIghQ4ZgxIgReW5nw4YNef7ZqKgoWbLMyZszxhxtSqG2euRm6/2TKr8T9X/9618YM2YMChcubKaK1OPVWx6SenGciMzDw8MDPXv2VLoMIsXxG3o7IoTAuHHj8O233+LRo0cAABcXFwwZMgRff/11ntvRarV5+jlD3ziYmmVO3pwx5mhTCrXVIzdb75+leXl5ITExEWXKlFG6FNWxp8UOa8ZxIjKMC+BEhnFCb4eePn2K9PR0PHjwAGFhYfD09FS6JCIiWbx6OhHp42KHdeA4ERnGBXAiw3jIvR1ydnZGWFgY7t27hx07diA4ODjHbT+IiMi2cP3eOnCciAzLzs5WugQiVcrbUhfZhLZt22LGjBkAgMzMTNSsWRNt27ZFlSpVsHr1apPb3bNnD1q0aIFy5cqhXLlyiIqKwr59+8yaZU7enKXbtKV65Gbr/SMiIiIi+XBCb0f27t2Lt99+GwCwdu1aZGdnIyMjAzExMRg7dqxJbS5evBiNGzeGu7s7+vXrh379+sHNzQ2NGjXC0qVLzZJlTt6cMeZoUwq11SM3W+8fERGRXLgATvQ/guyGq6uruHTpkhBCiM6dO4vhw4cLIYS4ePGi8PDwMKnNkJAQMXny5BzbJ02aJEJCQsySZU7enDHmaFMKtdUjN1vvnyV4enqKs2fPKl2GKvG9sQ4cJ6LXW7RokXB0dBRt27YV06ZNE9OmTRNt27YVTk5OYsmSJUqXR2RRnNDbkfLly4sVK1aIBw8eCD8/P7Fz504hhBCJiYmiUKFCJrXp7Ows0tLScmxPS0sTLi4uZskyJ2/OGHO0KYXa6pGbrffPEnr37i1u3rypdBmqxImideA4Eb0eF8CJ/sZD7u3IgAED0LFjR5QsWRLFixdH/fr1Abw4FL9y5comtRkQEICdO3fm2L5jxw4EBASYJcucvDljzNGmFGqrR2623r/8Sk5OzvPjpR9//JG3+8pFp06d4OXlpXQZ9BocJ6LXO3fuHFq0aJFje1RUFM6fP69ARUTK4VXu7ci//vUv1KpVC5cvX8a7776ru/1HmTJlTD6HfvDgwejXrx8SExNRt25dAMD+/fsxf/58TJs2zSxZ5uTNGWOONqVQWz1ys/X+5Vd4eDg0Gg2EENBoNEZ/1t5uUfTqIsbrVKlSBcCLxQ6yLI4TkXm8XAAvV66c3nZ7XQAnO6f0IQJk/dasWSMiIiKEr6+v8PX1FREREWLdunVmzTInb87SbdpSPXKz9f7lx4ULF3SPtWvXirJly4pZs2aJpKQkkZSUJGbNmiXKly8v1q5dq3SpFqfRaIRWq9X919iDlMNxIjKPmTNnCmdnZ9G7d2+xcOFCsXDhQtGrVy/h4uIiZs2apXR5RBalEYI3PLUX3bp1M7p/3rx5FqqEiCh/atWqhVGjRqFZs2Z62zdv3owRI0bg+PHjClWmjIsXL+r+PyEhAUOGDMHQoUNRp04dAMDBgwcxadIkfPfdd2jVqpVCVRLHich81q5di0mTJuH06dMAgNDQUAwdOhQtW7ZUuDIiy+KE3o68//77es+fPXuGkydPIiMjAw0bNsSaNWtMbvvp06e4ceMGsrOz9baXKlXKbFnm5M1Zuk0p1FaP3Gy9f6Zwc3NDfHw8QkND9bafPn0a1atXR2ZmpkKVKY+LHdaB40RERObAc+jtyNq1a3Nsy87ORp8+fVC2bFmT2kxLS0O3bt1w4MABve3if+e8Gjuv1dQsc/LmjDFHm1KorR652Xr/pAgNDcW3336Ln3/+Gc7OzgBeLHx8++23OSb59ubEiRMICgrKsT0oKAgpKSkKVESGcJyI5McFcCJO6O2eVqvFoEGDUL9+fQwbNizf+Y8//hiOjo7YtGkT/P39X3vhKjmyzMmbs3SbtlSP3Gy9f1LMmjULLVq0QMmSJXUXD0tOToZGo8HGjRsVrk5ZXOywDhwnIvlwAZzobzzknrB582ZER0fj5s2b+c56eHjg+PHjCAkJsViWOXlzlm5TCrXVIzdb759UDx8+xJIlS5CamgrgxQSpQ4cO8PDwULgyZR05cgQtWrSAEMLgYketWrUUrpAAjhORnCIiIuDo6IjPP//c4AJ41apVFaqMyPL4Db0dGTRokN5zIQSuXr2K2NhYREdHm9RmWFgYbt26ZdEsc/LmLN2mFGqrR2623j+pPDw80LNnT6XLUJ1atWrh3Llzeosd7dq142KHynCciOSTmJjIBXCi/+E39HakQYMGes+1Wi38/PzQsGFDdOvWDY6OeVvfuXfvnu7/jx07hi+//BLjxo1D5cqV4eTkpPezXl5esmSZkzdnjDnalEJt9cjN1vsnxYYNG/L8s1FRUWashIiI1KRmzZqYMmUK3nrrLaVLIVIcJ/SUb1qtVu/QppfnK70qt3OYTM0yJ2/OGHO0KYXa6pGbrfdPCq1Wm6efs8f3hosd1oHjRCQfLoATGcZD7u3QzZs3cebMGQBAcHAw/Pz88pWPi4sz+bVNzTInb87SbUqhtnrkZuv9k+KfVy2mv+X1nuX2uNihJhwnIvl4e3vnWABv1KiR3s/Y6wI42Td+Q29HHj58iL59+2LhwoW6X5QdHBzQpUsXTJ8+He7u7gpXSERERESU0549e/L8s/Xq1TNjJUTqkrfjGckmDBo0CHv27MHGjRuRkZGBjIwMrF+/Hnv27MHgwYNNbnffvn3o1KkT6tatiz///BMAsGjRIvz2229myzInb87SbUqhtnrkZuv9k2LPnj1o0aIFypUrh3LlyiEqKgr79u1TuiwiIrKAevXq5flBZE84obcjq1evxty5c9G0aVN4eXnBy8sLzZo1w5w5c7Bq1SqT24yMjISbmxvi4+Px5MkTAMDdu3cxbtw4s2SZkzdnjDnalEJt9cjN1vsnxeLFi9G4cWO4u7ujX79+6NevH9zc3NCoUSMsXbpU6fIUx8UO68BxIpIPF8CJ/keQ3XBzcxMpKSk5tp88eVK4u7ub1GZ4eLhYsGCBEEIIT09PcfbsWSGEEPHx8aJo0aJmyTInb84Yc7QphdrqkZut90+KkJAQMXny5BzbJ02aJEJCQhSoSD0WLVokHB0dRdu2bcW0adPEtGnTRNu2bYWTk5NYsmSJ0uXR/3CciOSzatUq4ebmJrp37y5cXFx0/15Onz5dNG3aVOHqiCyLE3o70rBhQ/Hhhx+KzMxM3bZHjx6JDz/8UDRq1MikNt3c3MT58+eFEPoTkLNnzwoXFxezZJmTN2eMOdqUQm31yM3W+yeFs7OzSEtLy7E9LS3N7t8bLnZYB44TkXy4AE70Nx5yb0emTZuG/fv3o2TJkmjUqBEaNWqEgIAAHDhwANOmTTOpzWLFiiE9PT3H9t9++w1lypQxS5Y5eXPGmKNNKdRWj9xsvX9SBAQEYOfOnTm279ixAwEBAQpUpB7nzp1DixYtcmyPiorC+fPnFaiIDOE4EcnnzJkzeOedd3JsL1iwIDIyMixfEJGCOKG3I5UqVUJaWhq+/fZbhIeHIzw8HOPHj0daWhoqVqxoUps9evRA//79cfjwYWg0Gly5cgVLlizBkCFD0KdPH7NkmZM3Z4w52pRCbfXIzdb7J8XgwYPRr18/9OnTB4sWLcKiRYvQu3dvDBgwAEOGDFG6PEVxscM6cJyI5MMFcKJXKH2IAFm37OxsMXbsWOHh4SE0Go3QaDTC1dVVfPnll2bLMidvztJtSqG2euRm6/2Tas2aNSIiIkL4+voKX19fERERIdatW6d0WYqbOXOmcHZ2Fr179xYLFy4UCxcuFL169RIuLi5i1qxZSpdH/8NxIpLPuHHjRFhYmDh06JAoUKCA2Ldvn1i8eLHw8/MTMTExSpdHZFG8D70d2LBhQ55+LioqyuTXePr0KdLT0/HgwQOEhYXB09PT7Fnm5M1Zuk1bqkdutt4/kt/atWsxadIknD59GgAQGhqKoUOHomXLlgpXRq/iOBHJQwiBcePG4dtvv8WjR48AAC4uLhgyZAi+/vprhasjsixO6O2AVqt/ZoVGo8E/h12j0SArK0vya927dw+7du1CcHAwQkNDLZJlTt6cpdu0pXrkZuv9M8XTp09x48YNZGdn620vVaqUQhUREZFSuABOBB5yb49evRqoVB9++KGYPn26EOLFFfMrVKggnJychKOjo1i1apVZsszJmzPGHG1KobZ65Gbr/ZPi999/F2+99ZbQarV6D41GI7RardLlqcKTJ0/E5cuXxcWLF/UepC4cJyL53b17V6xdu9bg7ZmJbB0n9HZIzgl90aJFRWJiohBCiCVLlohy5cqJhw8fipkzZ4rw8HCzZJmTN2eMOdqUQm31yM3W+ydF3bp1xTvvvCM2b94sEhISRGJiot7DnnGxwzpwnIjkwwVwor/xKvckyd27d+Hr6wsA2Lp1K9q0aQN3d3e89957SEtLM0uWOXlzxpijTSnUVo/cbL1/UiQmJmL27Nlo2rQpwsPDUbVqVb2HPfv444+h1WqxadMmHD9+HPHx8YiPj0dCQgLi4+OVLo/+h+NEJJ+9e/fi7bffBvDi2hTZ2dnIyMhATEwMxo4dq3B1RJblqHQBZN0CAgJw8OBB+Pr6YuvWrVi+fDkA4M6dO3B1dTVLljl5c8aYo00p1FaP3Gy9f1KEhYXh1q1bSpehSomJiTh+/DhCQkKULoWM4DgRycfYAvjQoUMVro7Isjiht0MajQYajUaWtgYMGICOHTvC09MTpUuXRv369QG8WDmtXLmyWbLMyZszxhxtSqG2euRm6/3Lr3v37un+f8KECRg2bBjGjRuHypUrw8nJSe9nvby8LF2eanCxwzpwnIjkwwVwor/xKvd2wMfHR28Cn5GRAS8vrxxXv799+7ZJ7R87dgyXL1/Gu+++q7u6aGxsLLy9vREREWGWLHPy5owxR5tSqK0eudl6//JDq9Xq/d0lhMixGPlymxx36bAmry52HDt2DF9++SUXO1SI40RkHjNnzkT//v11C+Dx8fHQarWYPn061qxZg7i4OKVLJLIYTujtwIIFC/L0c9HR0WauhIgo7/bs2ZPnn61Xr54ZK1EfLnZYB44TkflwAZzoBU7oKYdly5YhKioKHh4er/3Zbt26Gd0/b9482bPMyZszxhxtSqG2euRm6/0j+XCxwzpwnIiIyNx4Dj3l0KtXL9SuXRtlypR57c/euXNH7/mzZ89w8uRJZGRkoGHDhmbJMidvzhhztCmF2uqRm633T6p9+/Zh9uzZOHfuHFauXIkSJUpg0aJFCAoKwltvvaV0eRbFyZ914DgRmQcXwIn+xgk95ZCfgzbWrl2bY1t2djb69OmDsmXLmiXLnLw5Y8zRphRqq0dutt4/KVavXo3OnTujY8eOiI+Px5MnTwC8uNLxuHHjsHnzZoUrVBYXO6wDx4lIHlwAJ3qFpW98T+rn6ekpzp49K6mN1NRUUaxYMYtmmZM3Z+k2pVBbPXKz9f7lRXh4uFiwYIEQQv/vqPj4eFG0aFElS1PcqlWrhJubm+jevbtwcXHRvTfTp08XTZs2Vbg6eonjRGReWVlZomfPnmLChAlKl0JkUdrXT/mJ8u/s2bN4/vy5RbPMyZuzdJtSqK0eudl6//LizJkzeOedd3JsL1iwIDIyMixfkIqMHTsWs2bNwpw5c/SunB4REYH4+HgFK6NXcZyIzEur1WLQoEGYMmWK0qUQWRQPuSdJBg0apPdcCIGrV68iNjb2tVfNNzXLnLw5Y8zRphRqq0dutt4/KYoVK4b09HQEBgbqbf/tt9/ydL0PW8bFDuvAcSIyPy6Akz3ihJ4kSUhI0Huu1Wrh5+eHSZMmvfaCJaZmmZM3Z4w52pRCbfXIzdb7J0WPHj3Qv39/zJs3DxqNBleuXMHBgwcxZMgQjBgxQunyFMXFDuvAcSKSDxfAif7G29ZRDpUqVcKWLVsQEBCgdClERABe/LI2btw4fPvtt3j06BEAwMXFBUOGDMHXX3+tcHXK+vbbb7F48WLMmzcP7777LjZv3oyLFy9i4MCBGDFiBPr27at0iQSOE5GcGjRooPf85QJ4w4YN0a1bNzg68jtLsh+c0NuRMmXK4OjRoyhUqJDe9oyMDFSvXh3nzp0zue2bN2/izJkzAIDg4GD4+fmZPcucvDlLt2lL9cjN1vsnxdOnT5Geno4HDx4gLCwMnp6eSpekOC52WAeOExERmYWFL8JHCtJoNOL69es5tl+7dk04Ozub1OaDBw9E165dhYODg9BoNEKj0QhHR0fRrVs38fDhQ7NkmZM3Z4w52pRCbfXIzdb7J6e7d++KtWvXipSUFKVLUY0nT56IU6dOicOHD4v79+8rXQ7lguNEJJ8bN26Iffv2iX379okbN24oXQ6RIjihtwPr168X69evFxqNRixcuFD3fP369WLNmjXi008/FRUqVDCp7Z49e4oyZcqIzZs3i7t374q7d++K2NhYUbZsWdG7d2+zZJmTN2eMOdqUQm31yM3W+yfFhx9+KKZPny6EEOLRo0eiQoUKwsnJSTg6OopVq1YpXJ26cLHDOnCciEzHBXCiv3FCbwde/kWn1Wp1///y4ezsLCpUqCA2btxoUtuFChUScXFxObbv2rVLFC5c2CxZ5uTNGWOONqVQWz1ys/X+SVG0aFGRmJgohBBiyZIloly5cuLhw4di5syZIjw8XOHqlMXFDuvAcSKSDxfAif7G+9DbgezsbGRnZ6NUqVK4ceOG7nl2djaePHmCM2fOoHnz5ia1/ejRIxQtWjTH9iJFiujOEZQ7y5y8OWPM0aYUaqtHbrbePynu3r0LX19fAMDWrVvRpk0buLu747333kNaWprC1Slr7969ePvttwEAa9euRXZ2NjIyMhATE4OxY8cqXB29xHEiks/q1asxd+5cNG3aFF5eXvDy8kKzZs0wZ84crFq1SunyiCyKE3o7cv78eRQuXFjWNuvUqYORI0fi8ePHum2ZmZkYPXo06tSpY5Ysc/LmjDFHm1KorR652Xr/pAgICMDBgwfx8OFDbN26FU2aNAEA3LlzB66urgpXpywudlgHjhORfLgATvQ33tPBzuzcuRM7d+7UfVP/qnnz5uW7vWnTpiEyMhIlS5ZE1apVAQBJSUlwdXXFtm3bzJJlTt6cMeZoUwq11SM3W++fFAMGDEDHjh3h6emJ0qVLo379+gBefOtZuXJlZYtT2MvFDl9fX2zduhXLly8HwMUOteE4Ecnn5QL4woULdX9+uABO9oq3rbMjo0ePxpgxY1CjRg34+/tDo9Ho7V+7dq1J7T569AhLlixBamoqACA0NBQdO3aEm5ub2bLMyZuzdJtSqK0eudl6/6Q4duwYLl++jHfffVd3u7rY2Fh4e3sjIiJC4eqUM3PmTPTv31+32BEfHw+tVovp06djzZo1iIuLU7pEAseJSE4nT55EZGQknjx5YnABvGLFigpXSGQ5nNDbEX9/f3z33Xfo3Lmz0qUQEZGMuNhhHThORPLhAjjRC5zQ25FChQrhyJEjKFu2rOS2NmzYkKefi4qKki3LnLw5Y8zRphRqq0dutt4/OXTr1s3oflNOGSIiIiKydpzQ25Hhw4fD09MTI0aMkNyWVqt/PUWNRoN/fpQ0Gg2ysrJkyzInb84Yc7QphdrqkZut908O77//vt7zZ8+e4eTJk8jIyEDDhg2xZs0ahSpTHhc7rAPHiUg6LoAT5cSL4tmRx48f46effsKOHTtQpUoVODk56e2fPHlyntv65wX1ChQogKSkJJQpU8ZsWebkzVm6TSnUVo/cbL1/cjB0jY/s7Gz06dNHlqOOrNmdO3f0nv9zsYPUgeNEJF2rVq30nnMBnIgTeruSnJyM8PBwAC8uJvKqf14gj4hI7bRaLQYNGoT69etj2LBhSpejGC52WAeOE5F0XAAnyokTejvCK+gSka05e/Ysnj9/rnQZqsPFDuvAcSIiIqk4oSciItUbNGiQ3nMhBK5evYrY2FhER0crVJW6cbHDOnCciIhICk7o7UiDBg2MHlq/a9cuk9vWaDQmH7ZvapY5eXOWblMKtdUjN1vvnykSEhL0nmu1Wvj5+WHSpEmvvdiYreNih3XgOBERkTnwKvd2ZODAgXrPnz17hsTERJw8eRLR0dGYNm1antvy8fHRm3BkZGTAy8srx9W6b9++LVuWOXlzxpijTSnUVo/cbL1/ZF4NGjTQe/5ysaNhw4bo1q0bHB25dq8GHCci+Xl5eSEpKQlBQUFKl0KkGP7rYUemTJlicPuoUaPw4MGDfLU1depUk+swNcucvDlLtymF2uqRm633T043b97EmTNnAADBwcHw8/NTuCLl8foo1oHjRCTdPxfAHzx4gGrVqnEBnOwav6EnpKeno1atWmb9y2/ZsmWIioqCh4eHxbLMyZuzdJtSqK0eudl6/wx5+PAh+vbti4ULF+qucuzg4IAuXbpg+vTpcHd3V7hC5XGxwzpwnIhMt2DBgjz9HE9jIbsiyO4tXLhQ+Pv7m/U1ChQoIM6ePWvRLHPy5izdphRqq0dutt4/Q3r27CnKlCkjNm/eLO7evSvu3r0rYmNjRdmyZUXv3r2VLk9RDx48EF27dhUODg5Co9EIjUYjHB0dRbdu3cTDhw+VLo/+h+NEZHlLly4VDx48ULoMIrPiIfd2pHXr1nrPxf8uyHPs2DGMGDHCrK8tJBwIYmqWOXlzlm5TCrXVIzdb758hq1evxqpVq1C/fn3dtmbNmsHNzQ1t27bFjz/+qFxxChs0aBD27NmDjRs3IiIiAgDw22+/oV+/fhg8eLBdvzdqwnEisrxevXqhdu3avE892TRO6O1IwYIF9Z5rtVoEBwdjzJgxaNKkiUJVERG93qNHj1C0aNEc24sUKYJHjx4pUJF6cLHDOnCciCzPHhfAyf5wQm9HfvnlF6VLICIySZ06dTBy5EgsXLgQrq6uAIDMzEyMHj0aderUUbg6ZXGxwzpwnIiIyBw4obdDx48fx+nTpwEAFStWRLVq1RSuiIjIuGnTpiEyMhIlS5ZE1apVAQBJSUlwdXXFtm3bFK5OWVzssA4cJyIiMgdO6O3IjRs30L59e+zevRve3t4AXtzvukGDBli+fDmvtEtEqlWpUiWkpaVhyZIlSE1NBQB89NFH6NixI9zc3BSuTllc7LAOHCciIjIHTujtSN++fXH//n2cOnUKoaGhAICUlBRER0ejX79+WLZsmdleu3Tp0nBycrJoljl5c5ZuUwq11SM3W+9fbtzd3dGjRw+ly1AdLnZYB44TERGZA+9Db0cKFiyIHTt2oGbNmnrbjxw5giZNmiAjIyPfbZYpUwZHjx5FoUKF9LZnZGSgevXqOHfunOxZ5uTNGWOONqVQWz1ys/X+mWLDhg15+rmoqCgzV0JERNamUqVK2LJlCwICApQuhchs+A29HcnOzjb4rZ6TkxOys7NNavPChQvIysrKsf3Jkyf4888/zZJlTt6cMeZoUwq11SM3W++fKVq1aqX3XKPR5LhqsUajMfi+2ToudlgHjhOR/PK6AH7y5EklyiOyKE7o7UjDhg3Rv39/LFu2DMWLFwcA/Pnnnxg4cCAaNWqUr7Ze/QVl27ZterfEy8rKws6dOxEYGChrljl5c8aYo00p1FaP3Gy9f1L8c7GxQIECSEpK4j2FwcUOa8FxIpIfF8CJ/sZD7u3I5cuXERUVhVOnTukOPbp8+TIqVaqEDRs2oGTJknluS6vVAjD8i4mTkxMCAwMxadIkNG/eXLYsc/LmjDFHm1KorR652Xr/5MQJfe743lgHjhOR6V4ugLdq1QoLFiwwuAC+fft2nDlzRqkSiSyO39DbkYCAAMTHx2PHjh26C/KEhoaicePG+W7r5bdmQUFBOHr0KAoXLmz2LHPy5izdpi3VIzdb7x8REZEcXh7xotFoEB0drbfv1QVwInvCb+jtwK5du/DZZ5/h0KFD8PLy0tt39+5d1K1bF7NmzcLbb7+tUIVERHnDbzdzx/fGOnCciKTjAjjR3/gNvR2YOnUqevTokWMyD7y48n2vXr0wefJkkyf0O3fuxM6dO3Hjxo0c57vOmzfPLFnm5M0ZY442pVBbPXKz9f5JpdFooNFolC6DiIgUdP78eaVLIFINTujtQFJSEiZMmJDr/iZNmmDixIkmtT169GiMGTMGNWrUgL+/f75+0TY1y5y8OUu3aUv1yM3W+2cKHx8fvffhwYMHqFatmu66Ay/dvn3b0qWpDhc7rAPHiUgeXAAneoGH3NsBV1dXnDx5EuXKlTO4Pz09HZUrV0ZmZma+2/b398d3332Hzp07WyzLnLw5S7cphdrqkZut988UCxYsyNPP/fNcSnvwz8WOjIwMeHl5cbFDZThORPJ73QL42rVrFaqMyPL4Db0dKFGihNEJfXJyMvz9/U1q++nTp6hbt65Fs8zJm7N0m1KorR652Xr/TJHfifqyZcsQFRUFDw8PM1WkHlOnTlW6BMoDjhOR/GbNmoX58+dzAZwI/IbeLvTt2xe7d+/G0aNH4erqqrcvMzMTtWrVQoMGDRATE5PvtocPHw5PT0+MGDHCYlnm5M1Zuk0p1FaP3Gy9f5bg5eWFxMREXnDMAHta7LBmHCei1ytUqBCOHDmCsmXLKl0KkeL4Db0d+PLLL7FmzRpUqFABn332GYKDgwEAqamp+OGHH5CVlYX//Oc/JrX9+PFj/PTTT9ixYweqVKkCJycnvf2TJ0+WPcucvDljzNGmFGqrR2623j9L4Bp17nr16oXatWtzsUPlOE5Er9e9e3csXbqUC+BE4ITeLhQtWhQHDhxAnz598MUXX+h+4dVoNIiMjMQPP/yAokWLmtR2cnIywsPDAQAnT57U2/e6i/6YmmVO3pwx5mhTCrXVIzdb7x8pi4sd1oHjRPR6XAAn+hsPubczd+7cQXp6OoQQKF++PHx8fJQuiYhINrzHd+743lgHjhPR6zVo0CDXfRqNBrt27bJgNUTK4jf0dsbHxwc1a9ZUugwiIiIiIpPExcUpXQKRanBCT5I0aNDA6KHAxlZITc0yJ2/OGHO0KYXa6pGbrfePiIiIiOTFCT1J8vJ835eePXuGxMREnDx58rW3mzI1y5y8OWPM0aYUaqtHbrbeP0soXbp0jnMpiYjItnABnOhvnNCTJFOmTDG4fdSoUXjw4IFZsszJmzPGHG1KobZ65Gbr/ZOiTJkyOHr0KAoVKqS3PSMjA9WrV8e5c+cA5LyYIP2Nix3WgeNE9HpcACf6Gy+KR2aRnp6OWrVq4fbt2xbLMidvztJtSqG2euRm6/3LC61Wi2vXrqFIkSJ6269fv45SpUrhyZMnClWmvLwudpCyOE5E5vdyAXzixIlKl0JkMfyGnszi4MGDcHV1tWiWOXlzlm5TCrXVIzdb758xGzZs0P3/tm3bULBgQd3zrKws7Ny5E4GBgQpUph4XLlxAVlZWju1PnjzBn3/+qUBFZAjHicj8OnXqhFq1anFCT3aFE3qSpHXr1nrPhRC4evUqjh07hhEjRpgly5y8OWPM0aYUaqtHbrbeP1O0atUKwIvbEP3zMEonJycEBgZi0qRJClSmPC52WAeOE5Hl2PMCONkvHnJPknTt2lXvuVarhZ+fHxo2bIgmTZqYJcucvDljzNGmFGqrR2623j8pgoKCcPToURQuXFjpUlRDq9UCeLHY8c9/yl9d7GjevLkS5dH/cJyI5Pe6BfCRI0cqVBmR5XFCT0REZMW42GEdOE5E8uECONHfOKEnWRw/fhynT58GAFSsWBHVqlUze5Y5eXOWbtOW6pGbrffPVDt37sTOnTtx48YNZGdn6+2bN2+eQlURERERKYfn0JMkN27cQPv27bF79254e3sDeHHF3gYNGmD58uXw8/OTPcucvDljzNGmFGqrR2623j8pRo8ejTFjxqBGjRrw9/c3ev9he8TFDuvAcSKSFxfAiQCt0gWQdevbty/u37+PU6dO4fbt27h9+zZOnjyJe/fuoV+/fmbJMidvzhhztCmF2uqRm633T4pZs2Zh/vz5OHz4MNatW4e1a9fqPezZ6NGj0aRJE+zcuRO3bt3CnTt39B6kDhwnIvncuHEDDRs2RM2aNdGvXz/069cPb7zxBho1aoSbN28qXR6RZQkiCby8vMSRI0dybD98+LAoWLCgWbLMyZszxhxtSqG2euRm6/2TwtfXV6SnpytdhioVK1ZMLFy4UOky6DU4TkTyadu2rahRo4ZISUnRbTt16pSoUaOGaN++vYKVEVkev6EnSbKzs+Hk5JRju5OTU47DCeXKMidvzhhztCmF2uqRm633T4ru3btj6dKlSpehSk+fPkXdunWVLoNeg+NEJJ+tW7di5syZCA0N1W0LCwvDDz/8gC1btihYGZHlcUJPkjRs2BD9+/fHlStXdNv+/PNPDBw4EI0aNTJLljl5c8aYo00p1FaP3Gy9f1I8fvwYkydPRr169dC3b18MGjRI72HPuNhhHThORPLhAjjR33iVe5Lk8uXLiIqKwqlTpxAQEKDbVqlSJWzYsAElS5aUPcucvDljzNGmFGqrR2623j8pGjRokOs+jUaDXbt2WbAadenfvz8WLlyIKlWqoEqVKjl+yZ08ebJCldGrOE5E8mnZsiUyMjKwbNkyFC9eHMCLBfCOHTvCx8fH7q+tQvaFE3qSTAiBHTt2IDU1FQAQGhqKxo0bmzXLnLw5S7dpS/XIzdb7R/LjYod14DgRyYcL4ESvUOC8fbIBO3fuFKGhoeLu3bs59mVkZIiwsDCxd+9eWbPMyZszxhxtSqG2euRm6/0jIiKSW3Z2tvj1119FTEyMiImJEdu3b1e6JCJF8Bx6MsnUqVPRo0cPeHl55dhXsGBB9OrVK9fDB03NMidvzhhztCmF2uqRm633Tw4NGjRAw4YNc30QEZHt27VrF8LCwnDv3j1oNBq8++676Nu3L/r27YuaNWuiYsWK2Ldvn9JlElkUD7knk5QuXRpbt27Vu7roq1JTU9GkSRNcunRJtixz8uaMMUebUqitHrnZev/kMHDgQL3nz549Q2JiIk6ePIno6GhMmzZNocqU16BBA2g0mlz381BudeA4EUkXFRWFBg0a5Pg34aWYmBjExcXxHHqyK45KF0DW6fr16wavLvqSo6Mjbt68KWuWOXlzxpijTSnUVo/cbL1/cpgyZYrB7aNGjcKDBw8sXI26hIeH6z3/52IHqQPHiUi6pKQkTJgwIdf9TZo0wcSJEy1YEZHyOKEnk5QoUQInT55EuXLlDO5PTk6Gv7+/rFnm5M0ZY442pVBbPXKz9f6ZU6dOnVCrVi27/gWOix3WgeNEJB0XwIly4jn0ZJJmzZphxIgRePz4cY59mZmZGDlyJJo3by5rljl5c8aYo00p1FaP3Gy9f+Z08OBBuLq6Kl2GKnXq1Anz5s1Tugx6DY4TUd69XADPDRfAyR7xHHoyyfXr11G9enU4ODjgs88+Q3BwMIAX5/r+8MMPyMrKQnx8PIoWLSpbljl5c8aYo00p1FaP3Gy9f3Jo3bq13nMhBK5evYpjx45hxIgRGDlypEKVqdeiRYswfPhwXLlyRelSyAiOE1He9e3bF7t378bRo0dzLOZmZmaiVq1aaNCgAWJiYhSqkEgBil5jn6zahQsXRNOmTYVWqxUajUZoNBqh1WpF06ZNxblz58ySZU7enDHmaFMKtdUjN1vvn1Qff/yx3qNbt25i+PDhYtu2bUqXprj3339f79GqVStRu3Zt4eDgIEaNGqV0efQ/HCci6a5duyaKFy8uAgICxIQJE8S6devEunXrxPjx40VAQIAoXry4uHbtmtJlElkUv6Enye7cuYP09HQIIVC+fHn4+PiYPcucvDlLt2lL9cjN1vtH8uvatavec61WCz8/PzRs2BBNmjRRqCr6J44TkTwuXryIPn36YNu2bXg5jdFoNIiMjMQPP/yAoKAghSsksixO6ImIyGocP34cp0+fBgBUrFgR1apVU7giIiJSAhfAiV7ghJ6IiFTvxo0baN++PXbv3g1vb28AQEZGBho0aIDly5fDz89P2QJVgIsd1oHjREREcuKEnoiIVK9du3Y4d+4cFi5ciNDQUABASkoKoqOjUa5cOSxbtkzhCpXDxQ7rwHEiIiJz4G3riIhI9bZu3YqZM2fqJvMAEBYWhh9++AFbtmxRsDLl9e3bF/fv38epU6dw+/Zt3L59GydPnsS9e/fQr18/pcuj/+E4ERGROfAbeiIiUr0CBQpg3759CA8P19uekJCAevXq4d69e8oUpgIFCxbEjh07ULNmTb3tR44cQZMmTZCRkaFMYaSH40RERObAb+iJiEj1GjZsiP79++vdq/vPP//EwIED0ahRIwUrU152djacnJxybHdyckJ2drYCFZEhHCciIjIHTuiJiEj1ZsyYgXv37iEwMBBly5ZF2bJlERQUhHv37mH69OlKl6coLnZYB44TERGZAw+5JyIiqyCEwI4dO5CamgoACA0NRePGjRWuSnmXL19GVFQUTp06hYCAAN22SpUqYcOGDShZsqTCFRLAcSIiIvPghJ6IiFRr165d+Oyzz3Do0CF4eXnp7bt79y7q1q2LWbNm4e2331aoQnXgYod14DgREZHcOKEnIiLVioqKQoMGDTBw4ECD+2NiYhAXF4e1a9dauDLlcbHDOnCciIjInHgOPRERqVZSUhL+7//+L9f9TZo0wfHjxy1YkXpMnToVPXr0yDFJBF5cUb1Xr16YPHmyApXRqzhORERkTpzQExGRal2/ft3glcFfcnR0xM2bNy1YkXpwscM6cJyIiMicOKEnIiLVKlGiBE6ePJnr/uTkZPj7+1uwIvXgYod14DgREZE5cUJPRESq1axZM4wYMQKPHz/OsS8zMxMjR45E8+bNFahMeVzssA4cJyIiMideFI+IiFTr+vXrqF69OhwcHPDZZ58hODgYAJCamooffvgBWVlZiI+PR9GiRRWu1PL69u2L3bt34+jRo3B1ddXbl5mZiVq1aqFBgwaIiYlRqEICOE5ERGRenNATEZGqXbx4EX369MG2bdvw8p8sjUaDyMhI/PDDDwgKClK4QmVwscM6cJyIiMicOKEnIiKrcOfOHaSnp0MIgfLly8PHx0fpkhTHxQ7rwHEiIiJz4YSeiIjIynGxwzpwnIiISG6c0BMRERERERFZIV7lnoiIiIiIiMgKcUJPREREREREZIU4oSciIiIiIiKyQpzQExEREREREVkhTuiJiIiIiIiIrBAn9ERERERERERWiBN6IiIiIiIiIiv0/6edo7mropJsAAAAAElFTkSuQmCC", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "tags": [], - "needs_background": "light" - } + "metadata": {}, + "output_type": "display_data" } + ], + "source": [ + "#@title Enter state to plot { run: \"auto\" }\n", + "state_name = \"Washington\" #@param [\"Missouri\", \"Arkansas\", \"Arizona\", \"Ohio\", \"Connecticut\", \"Vermont\", \"Illinois\", \"South Dakota\", \"Iowa\", \"Oklahoma\", \"Kansas\", \"Washington\", \"Oregon\", \"Hawaii\", \"Minnesota\", \"Idaho\", \"Alaska\", \"Colorado\", \"Delaware\", \"Alabama\", \"North Dakota\", \"Michigan\", \"California\", \"Indiana\", \"Kentucky\", \"Nebraska\", \"Louisiana\", \"New Jersey\", \"Rhode Island\", \"Utah\", \"Nevada\", \"South Carolina\", \"Wisconsin\", \"New York\", \"North Carolina\", \"New Hampshire\", \"Georgia\", \"Pennsylvania\", \"West Virginia\", \"Maine\", \"Mississippi\", \"Montana\", \"Tennessee\", \"New Mexico\", \"Massachusetts\", \"Wyoming\", \"Maryland\", \"Florida\", \"Texas\", \"Virginia\"]\n", + "result = plot_income(data, state_name)\n", + "\n", + "# Show the plot\n", + "plt.show()" ] }, { "cell_type": "markdown", "metadata": { - "id": "EaE8M-orXDhB", - "colab_type": "text" + "id": "EaE8M-orXDhB" }, "source": [ "and we can display the raw table of values." @@ -685,57 +621,673 @@ }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "FYPs1S9hWL8B", - "colab_type": "code", "colab": { "base_uri": "https://localhost:8080/", - "height": 359 + "height": 1000 }, - "outputId": "09419ec8-0d36-466f-9523-7c4c71f9b116" + "id": "FYPs1S9hWL8B", + "outputId": "f1a4efa3-4ca2-4c41-b1bc-0b973a52869e" }, - "source": [ - "# Additionally print the table of income bracket sizes \n", - "result" - ], - "execution_count": 8, "outputs": [ { - "output_type": "execute_result", "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "repr_error": "0", + "type": "dataframe", + "variable_name": "result" + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
dateentityentity_namevariablevariable_namevaluefacetIdimportNamemeasurementMethodobservationPeriodprovenanceUrlunit
132023geoId/53WashingtonCount_Household_IncomeOf100000To124999USDollarHouseholds With an Income Between $100,000 and...3268471145703171CensusACS5YearSurveyCensusACS5yrSurveyNonehttps://www.census.gov/programs-surveys/acs/da...None
882023geoId/53WashingtonCount_Household_IncomeOf150000To199999USDollarHouseholds With an Income Between $150,000 and...3399471145703171CensusACS5YearSurveyCensusACS5yrSurveyNonehttps://www.census.gov/programs-surveys/acs/da...None
1352023geoId/53WashingtonCount_Household_IncomeOf20000To24999USDollarHouseholds With an Income Between $20,000 and ...764221145703171CensusACS5YearSurveyCensusACS5yrSurveyNonehttps://www.census.gov/programs-surveys/acs/da...None
1632023geoId/53WashingtonCount_Household_IncomeOf45000To49999USDollarCount of Household: 45,000 - 49,999 USD878121145703171CensusACS5YearSurveyCensusACS5yrSurveyNonehttps://www.census.gov/programs-surveys/acs/da...None
2542023geoId/53WashingtonCount_Household_IncomeOf50000To59999USDollarHouseholds With an Income Between $50,000 and ...1798191145703171CensusACS5YearSurveyCensusACS5yrSurveyNonehttps://www.census.gov/programs-surveys/acs/da...None
2672023geoId/53WashingtonCount_Household_IncomeOf40000To44999USDollarHouseholds With an Income Between $40,000 and ...869871145703171CensusACS5YearSurveyCensusACS5yrSurveyNonehttps://www.census.gov/programs-surveys/acs/da...None
3522023geoId/53WashingtonCount_Household_IncomeOf75000To99999USDollarHouseholds With an Income Between $75,000 and ...3815221145703171CensusACS5YearSurveyCensusACS5yrSurveyNonehttps://www.census.gov/programs-surveys/acs/da...None
3772023geoId/53WashingtonCount_Household_IncomeOf125000To149999USDollarHouseholds With an Income Between $125,000 and...2523581145703171CensusACS5YearSurveyCensusACS5yrSurveyNonehttps://www.census.gov/programs-surveys/acs/da...None
4272023geoId/53WashingtonCount_Household_IncomeOf60000To74999USDollarHouseholds With an Income Between $60,000 and ...2616011145703171CensusACS5YearSurveyCensusACS5yrSurveyNonehttps://www.census.gov/programs-surveys/acs/da...None
5052023geoId/53WashingtonCount_Household_IncomeOf200000OrMoreUSDollarHouseholds With an Income of $200,000 or More5187851145703171CensusACS5YearSurveyCensusACS5yrSurveyNonehttps://www.census.gov/programs-surveys/acs/da...None
5252023geoId/53WashingtonCount_Household_IncomeOfUpto10000USDollarHouseholds With an Income of $10,000 or Less1141371145703171CensusACS5YearSurveyCensusACS5yrSurveyNonehttps://www.census.gov/programs-surveys/acs/da...None
6162023geoId/53WashingtonCount_Household_IncomeOf10000To14999USDollarHouseholds With an Income Between $10,000 and ...811101145703171CensusACS5YearSurveyCensusACS5yrSurveyNonehttps://www.census.gov/programs-surveys/acs/da...None
6342023geoId/53WashingtonCount_Household_IncomeOf30000To34999USDollarCount of Household: 30,000 - 34,999 USD793241145703171CensusACS5YearSurveyCensusACS5yrSurveyNonehttps://www.census.gov/programs-surveys/acs/da...None
7112023geoId/53WashingtonCount_Household_IncomeOf15000To19999USDollarCount of Household: 15,000 - 19,999 USD703691145703171CensusACS5YearSurveyCensusACS5yrSurveyNonehttps://www.census.gov/programs-surveys/acs/da...None
7342023geoId/53WashingtonCount_Household_IncomeOf25000To29999USDollarCount of Household: 25,000 - 29,999 USD797191145703171CensusACS5YearSurveyCensusACS5yrSurveyNonehttps://www.census.gov/programs-surveys/acs/da...None
8172023geoId/53WashingtonCount_Household_IncomeOf35000To39999USDollarCount of Household: 35,000 - 39,999 USD837991145703171CensusACS5YearSurveyCensusACS5yrSurveyNonehttps://www.census.gov/programs-surveys/acs/da...None
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], "text/plain": [ - "name Idaho\n", - "Count_Household_IncomeOf25000To29999USDollar 31268\n", - "Count_Household_IncomeOf75000To99999USDollar 76641\n", - "Count_Household_IncomeOf40000To44999USDollar 31324\n", - "Count_Household_IncomeOf100000To124999USDollar 51057\n", - "Count_Household_IncomeOf125000To149999USDollar 28311\n", - "Count_Household_IncomeOfUpto10000USDollar 38492\n", - "Count_Household_IncomeOf15000To19999USDollar 29865\n", - "Count_Household_IncomeOf35000To39999USDollar 32391\n", - "Count_Household_IncomeOf200000OrMoreUSDollar 22323\n", - "Count_Household_IncomeOf30000To34999USDollar 34988\n", - "Count_Household_IncomeOf60000To74999USDollar 70028\n", - "Count_Household_IncomeOf150000To199999USDollar 25253\n", - "Count_Household_IncomeOf50000To59999USDollar 54943\n", - "Count_Household_IncomeOf10000To14999USDollar 29568\n", - "Count_Household_IncomeOf20000To24999USDollar 33635\n", - "Count_Household_IncomeOf45000To49999USDollar 28244\n", - "Name: geoId/16, dtype: object" + " date entity entity_name \\\n", + "13 2023 geoId/53 Washington \n", + "88 2023 geoId/53 Washington \n", + "135 2023 geoId/53 Washington \n", + "163 2023 geoId/53 Washington \n", + "254 2023 geoId/53 Washington \n", + "267 2023 geoId/53 Washington \n", + "352 2023 geoId/53 Washington \n", + "377 2023 geoId/53 Washington \n", + "427 2023 geoId/53 Washington \n", + "505 2023 geoId/53 Washington \n", + "525 2023 geoId/53 Washington \n", + "616 2023 geoId/53 Washington \n", + "634 2023 geoId/53 Washington \n", + "711 2023 geoId/53 Washington \n", + "734 2023 geoId/53 Washington \n", + "817 2023 geoId/53 Washington \n", + "\n", + " variable \\\n", + "13 Count_Household_IncomeOf100000To124999USDollar \n", + "88 Count_Household_IncomeOf150000To199999USDollar \n", + "135 Count_Household_IncomeOf20000To24999USDollar \n", + "163 Count_Household_IncomeOf45000To49999USDollar \n", + "254 Count_Household_IncomeOf50000To59999USDollar \n", + "267 Count_Household_IncomeOf40000To44999USDollar \n", + "352 Count_Household_IncomeOf75000To99999USDollar \n", + "377 Count_Household_IncomeOf125000To149999USDollar \n", + "427 Count_Household_IncomeOf60000To74999USDollar \n", + "505 Count_Household_IncomeOf200000OrMoreUSDollar \n", + "525 Count_Household_IncomeOfUpto10000USDollar \n", + "616 Count_Household_IncomeOf10000To14999USDollar \n", + "634 Count_Household_IncomeOf30000To34999USDollar \n", + "711 Count_Household_IncomeOf15000To19999USDollar \n", + "734 Count_Household_IncomeOf25000To29999USDollar \n", + "817 Count_Household_IncomeOf35000To39999USDollar \n", + "\n", + " variable_name value facetId \\\n", + "13 Households With an Income Between $100,000 and... 326847 1145703171 \n", + "88 Households With an Income Between $150,000 and... 339947 1145703171 \n", + "135 Households With an Income Between $20,000 and ... 76422 1145703171 \n", + "163 Count of Household: 45,000 - 49,999 USD 87812 1145703171 \n", + "254 Households With an Income Between $50,000 and ... 179819 1145703171 \n", + "267 Households With an Income Between $40,000 and ... 86987 1145703171 \n", + "352 Households With an Income Between $75,000 and ... 381522 1145703171 \n", + "377 Households With an Income Between $125,000 and... 252358 1145703171 \n", + "427 Households With an Income Between $60,000 and ... 261601 1145703171 \n", + "505 Households With an Income of $200,000 or More 518785 1145703171 \n", + "525 Households With an Income of $10,000 or Less 114137 1145703171 \n", + "616 Households With an Income Between $10,000 and ... 81110 1145703171 \n", + "634 Count of Household: 30,000 - 34,999 USD 79324 1145703171 \n", + "711 Count of Household: 15,000 - 19,999 USD 70369 1145703171 \n", + "734 Count of Household: 25,000 - 29,999 USD 79719 1145703171 \n", + "817 Count of Household: 35,000 - 39,999 USD 83799 1145703171 \n", + "\n", + " importName measurementMethod observationPeriod \\\n", + "13 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "88 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "135 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "163 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "254 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "267 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "352 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "377 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "427 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "505 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "525 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "616 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "634 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "711 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "734 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "817 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "\n", + " provenanceUrl unit \n", + "13 https://www.census.gov/programs-surveys/acs/da... None \n", + "88 https://www.census.gov/programs-surveys/acs/da... None \n", + "135 https://www.census.gov/programs-surveys/acs/da... None \n", + "163 https://www.census.gov/programs-surveys/acs/da... None \n", + "254 https://www.census.gov/programs-surveys/acs/da... None \n", + "267 https://www.census.gov/programs-surveys/acs/da... None \n", + "352 https://www.census.gov/programs-surveys/acs/da... None \n", + "377 https://www.census.gov/programs-surveys/acs/da... None \n", + "427 https://www.census.gov/programs-surveys/acs/da... None \n", + "505 https://www.census.gov/programs-surveys/acs/da... None \n", + "525 https://www.census.gov/programs-surveys/acs/da... None \n", + "616 https://www.census.gov/programs-surveys/acs/da... None \n", + "634 https://www.census.gov/programs-surveys/acs/da... None \n", + "711 https://www.census.gov/programs-surveys/acs/da... None \n", + "734 https://www.census.gov/programs-surveys/acs/da... None \n", + "817 https://www.census.gov/programs-surveys/acs/da... None " ] }, - "metadata": { - "tags": [] - }, - "execution_count": 8 + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" } + ], + "source": [ + "# Additionally print the table of income bracket sizes\n", + "result" ] }, { "cell_type": "markdown", "metadata": { - "id": "fD5uhrC_G0Jv", - "colab_type": "text" + "id": "fD5uhrC_G0Jv" }, "source": [ "This is only the beginning! What else can you analyze? For example, you could try computing a measure of income disparity in each state (see [Gini Coefficient](https://en.wikipedia.org/wiki/Gini_coefficient)).\n", @@ -744,5 +1296,19 @@ "\n" ] } - ] -} \ No newline at end of file + ], + "metadata": { + "colab": { + "include_colab_link": true, + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/notebooks/analyzing_obesity_prevalence.ipynb b/notebooks/analyzing_obesity_prevalence.ipynb index 8c6104d3..aaa272db 100644 --- a/notebooks/analyzing_obesity_prevalence.ipynb +++ b/notebooks/analyzing_obesity_prevalence.ipynb @@ -1,185 +1,186 @@ { - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "name": "Case Study: Prevalence of Obesity in 500 US Cities", - "provenance": [], - "collapsed_sections": [], - "include_colab_link": true - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - } - }, "cells": [ { "cell_type": "markdown", - "metadata": { - "id": "view-in-github", - "colab_type": "text" - }, + "metadata": {}, "source": [ - "\"Open" + "\"Open" ] }, { "cell_type": "markdown", "metadata": { - "id": "srAnaUPPbrH6", - "colab_type": "text" + "id": "srAnaUPPbrH6" }, "source": [ - "Copyright 2020 Google LLC.\n", + "Copyright 2025 Google LLC.\n", "SPDX-License-Identifier: Apache-2.0\n", "\n", - "**Notebook Version** - 1.0.1" + "**Notebook Version** - 2.0.0" ] }, { - "cell_type": "code", + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Case Study: Predicting Obesity Prevalence in US Counties\n", + "\n", + "**Objective:** This notebook demonstrates how to use Data Commons to build a linear regression model predicting the prevalence of obesity in US counties.\n", + "\n", + "**Background:** Obesity prevalence is known to correlate with various health and socio-economic factors [[1]](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3198075/)[[2]](https://www.ncbi.nlm.nih.gov/pubmed/26562758). Data for these factors often reside in separate datasets from different government agencies:\n", + "* The Centers for Disease Control (CDC) provides health condition prevalence data (e.g., obesity, high blood pressure).\n", + "* The US Bureau of Labor Statistics (BLS) provides unemployment rates.\n", + "* The US Census Bureau provides poverty rates and population counts.\n", + "\n", + "Data Commons aggregates these diverse datasets into a unified knowledge graph, simplifying data access and analysis.\n", + "\n", + "**Approach:** This notebook uses Data Commons to retrieve data for the following variables for US counties in 2021:\n", + "* [Percentage of Adult Population That Is Obese](https://datacommons.org/tools/statvar#sv=Percent_Person_Obesity) (CDC) - Target variable\n", + "* [Percentage of Adult Population With High Blood Pressure](https://datacommons.org/tools/statvar#sv=Percent_Person_WithHighBloodPressure) (CDC) - Predictor variable\n", + "* [Unemployment Rate of a Population](https://datacommons.org/tools/statvar#sv=UnemploymentRate_Person) (BLS) - Predictor variable\n", + "* [Population Below Poverty Level Status in Past Year](https://datacommons.org/tools/statvar#sv=Count_Person_BelowPovertyLevelInThePast12Months) (Census) - Used to calculate poverty rate\n", + "* [Total Population](https://datacommons.org/tools/statvar#sv=Count_Person) (Census) - Used to calculate poverty rate\n", + "\n", + "A linear regression model will be trained using high blood pressure prevalence, unemployment rate, and the calculated poverty rate to predict obesity prevalence.\n", + "\n", + "*Note:* The US Census also provides unemployment statistics. Using BLS data here is for demonstration purposes. Comparing results using Census unemployment data could be a potential extension." + ] + }, + { + "cell_type": "markdown", "metadata": { - "id": "7Et41jikt2yA", - "colab_type": "code", - "colab": {} + "id": "7SnIECsk7Csw" }, "source": [ - "from sklearn.linear_model import LinearRegression\n", - "from sklearn.model_selection import train_test_split\n", - "from google.colab import drive\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import pandas as pd\n", + "## 1. Set up environment\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pysygfoq43NF" + }, + "source": [ + "### 1.1. Install libraries\n", "\n", - "import json" + "Install the [datacommons-client](https://pypi.org/project/datacommons-client/) library." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "GQrede0Bdm-k", + "outputId": "cb8726c8-1bc4-4776-90c7-e1058c9e3b1e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/66.3 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m66.3/66.3 kB\u001b[0m \u001b[31m2.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h" + ] + } ], - "execution_count": 1, - "outputs": [] + "source": [ + "!pip install \"datacommons-client[Pandas]\" --upgrade --quiet" + ] }, { "cell_type": "markdown", "metadata": { - "id": "yjBCrzJfqHtM", - "colab_type": "text" + "id": "BtLVyFoN5AiI" }, "source": [ - "# Case Study: Prevalence of Obesity in 500 US Cities\n", - "\n", - "Obesity is well known to correlate with health factors such as high blood pressure, but is also known to correlate with economic factors such as low-income, unemployment, etc [[1]](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3198075/)[[2]](https://www.ncbi.nlm.nih.gov/pubmed/26562758). The Center for Disease Control (CDC) provides prevalence percentages on health conditions such as [obesity](https://browser.datacommons.org/kg?dcid=dc/p/8f94jymf10dh7), [high blood pressure](https://browser.datacommons.org/kg?dcid=dc/p/lddprn26my0wh), and [high cholesterol](https://browser.datacommons.org/kg?dcid=dc/p/ybn085073e7z6) for approximately 500 major cities in the US (e.g. [San Francisco](https://browser.datacommons.org/kg?dcid=geoId/0667000), [New York](https://browser.datacommons.org/kg?dcid=geoId/3651000), and [Austin](https://browser.datacommons.org/kg?dcid=geoId/4805000)). Meanwhile, the US Bureau of Labor Statistics provides [unemployment rates](https://browser.datacommons.org/kg?dcid=dc/p/820mxx8ejlrj7) while the US Census provides [poverty rates](https://browser.datacommons.org/kg?dcid=dc/p/mrbgbmbe5lvyh) for most cities across the United States. \n", + "### 1.2. Import dependencies\n", "\n", - "Even though these statistics come from different datasets across different government agencies with different storage formats, Data Commons surfaces each of these in a single, uniform knowledge graph. In fact, you can see this in the [browser](https://browser.datacommons.org/kg?dcid=dc/9xkkc71) by looking at the *provenance* column. Let's use the data in Data Commons to create a linear regression model that incorporates variables:\n", - "\n", - "- Prevalence of high blood pressure\n", - "- Unemployment rate\n", - "- Percent of population living with income below the poverty line\n", - "\n", - "to predict the prevalence of obesity in the 500 cities that the CDC provides data for. One thing you may note is that the US Census also provides employment statistics (you can see this by navigating to the \"employment\" and \"employmentStatus\" sections for [San Francisco](https://browser.datacommons.org/kg?dcid=geoId/0667000) and observing the different provenances). Our choice of using statistics from the Bureau of Labor Statistics is purely demonstrative, but it would be interesting to see if similar results can be reproduced using US Census employment statistics. " + "Import required libraries for data manipulation, modeling, and plotting.\n" ] }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "GQrede0Bdm-k", - "colab_type": "code", - "colab": {} + "id": "qb84-Bxp5FNO" }, + "outputs": [], "source": [ - "!pip install datacommons_pandas --upgrade --quiet\n", + "import datacommons_client\n", "\n", - "import datacommons_pandas as dc" - ], - "execution_count": 2, - "outputs": [] + "import matplotlib.pyplot as plt\n", + "from sklearn.linear_model import LinearRegression\n", + "from sklearn.model_selection import train_test_split\n", + "from google.colab import drive\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "import json" + ] }, { "cell_type": "markdown", "metadata": { - "id": "pNHUbzq_dnGc", - "colab_type": "text" + "id": "ZXzO6qSc5Xk0" }, "source": [ - "To get started, we'll need the cities that CDC provides data for. We can query Data Commons for Cities that are members of [CDC500_City](https://browser.datacommons.org/kg?dcid=CDC500_City). The default return limit is 100, so we'll explicitly set it to 500." + "### 1.3. Initialize Data Commons client\n", + "\n", + "Initialize the client using your Data Commons API key. Obtain a key from [apikeys.datacommons.org](https://apikeys.datacommons.org/) if you don't have one.\n" ] }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "4CoM0LD4kZSN", - "colab_type": "code", - "cellView": "both", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 112 - }, - "outputId": "2c2694ae-7a29-422d-e0d5-77a28d853fee" + "id": "cdPVl3dl5m6-" }, + "outputs": [], "source": [ - "city_dcids = dc.get_property_values([\"CDC500_City\"], \"member\", limit=500)[\"CDC500_City\"]\n", - "city_dcids[:5]" - ], - "execution_count": 3, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "['geoId/0107000',\n", - " 'geoId/0135896',\n", - " 'geoId/0137000',\n", - " 'geoId/0150000',\n", - " 'geoId/0151000']" - ] - }, - "metadata": { - "tags": [] - }, - "execution_count": 3 - } + "YOUR_API_KEY = \"Replace this string with your API key\"\n", + "\n", + "dc_client = datacommons_client.DataCommonsClient(api_key=YOUR_API_KEY)" ] }, { "cell_type": "markdown", "metadata": { - "id": "Ccy9-czCfVTn", - "colab_type": "text" + "id": "Ccy9-czCfVTn" }, "source": [ - "### Querying for all Statistics\n", - "With the list of cities, we can now initialize a `pandas.DataFrame` with possible correlate variables. If you have not already, take a look at the [docs](http://docs.datacommons.org/api/pandas/) for how to query Data Commons with [`build_multivariate_dataframe`](http://docs.datacommons.org/api/pandas/multivariate_dataframe.html). Note that all correlate variables below can be found in the [list of StatisticalVariables](http://docs.datacommons.org/statistical_variables.html)." + "## 2. Data acquisition\n", + "\n", + "Fetch statistical observations for the specified variables for all US counties for the year 2021 using the [Python Data Commons API](https://docs.datacommons.org/api/python/v2/)." ] }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "B51WFPL5TOn-", - "colab_type": "code", "colab": { "base_uri": "https://localhost:8080/", - "height": 262 + "height": 400 }, - "outputId": "ada3fd0b-5255-4d90-9edc-f410c9acd3b6" + "id": "B51WFPL5TOn-", + "outputId": "884bac05-17b2-4a2a-b493-c30620b0e80c" }, - "source": [ - "data = dc.build_multivariate_dataframe(city_dcids,\n", - " [\"Percent_Person_Obesity\", # Prevalence of obesity from CDC\n", - " \"Percent_Person_WithHighBloodPressure\", # Prevalence of high blood pressure from CDC\n", - " \"UnemploymentRate_Person\", # Unemployment rate from BLS\n", - " \"Count_Person_BelowPovertyLevelInThePast12Months\", # Persons living below the poverty line from Census\n", - " \"Count_Person\", # Total population from Census\n", - " ]\n", - " )\n", - "# Display the first five rows.\n", - "data.head(5)" - ], - "execution_count": 4, "outputs": [ { - "output_type": "execute_result", "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"us_county_observations_df\",\n \"rows\": 28363,\n \"fields\": [\n {\n \"column\": \"date\",\n \"properties\": {\n \"dtype\": \"object\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"2021\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"entity\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 3230,\n \"samples\": [\n \"geoId/38105\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"entity_name\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 1966,\n \"samples\": [\n \"Rappahannock County\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"variable\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 5,\n \"samples\": [\n \"Count_Person\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"variable_name\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 5,\n \"samples\": [\n \"Total Population\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"value\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 199254.5231709615,\n \"min\": 0.9,\n \"max\": 10019635.0,\n \"num_unique_values\": 9105,\n \"samples\": [\n 92581.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"facetId\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 7,\n \"samples\": [\n \"1145703171\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"importName\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 6,\n \"samples\": [\n \"CensusACS5YearSurvey\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"measurementMethod\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 7,\n \"samples\": [\n \"CensusACS5yrSurvey\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"observationPeriod\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"P1Y\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"provenanceUrl\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 6,\n \"samples\": [\n \"https://www.census.gov/programs-surveys/acs/data/data-via-ftp.html\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"unit\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"Percent\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe", + "variable_name": "us_county_observations_df" + }, "text/html": [ - "
\n", + "\n", + "
\n", + "
\n", "\n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" ], "text/plain": [ - " Percent_Person_Obesity ... Count_Person\n", - "place ... \n", - "geoId/0107000 42.0 ... 212021.0\n", - "geoId/0135896 28.4 ... 84480.0\n", - "geoId/0137000 36.2 ... 193663.0\n", - "geoId/0150000 38.2 ... 191485.0\n", - "geoId/0151000 39.0 ... 200156.0\n", - "\n", - "[5 rows x 5 columns]" + " date entity entity_name \\\n", + "0 2021 geoId/42077 Lehigh County \n", + "1 2021 geoId/01025 Clarke County \n", + "2 2021 geoId/12045 Gulf County \n", + "3 2021 geoId/27005 Becker County \n", + "4 2021 geoId/19121 Madison County \n", + "\n", + " variable \\\n", + "0 Count_Person_BelowPovertyLevelInThePast12Months \n", + "1 Count_Person_BelowPovertyLevelInThePast12Months \n", + "2 Count_Person_BelowPovertyLevelInThePast12Months \n", + "3 Count_Person_BelowPovertyLevelInThePast12Months \n", + "4 Count_Person_BelowPovertyLevelInThePast12Months \n", + "\n", + " variable_name value facetId \\\n", + "0 Population Below Poverty Level Status in Past ... 43982.0 1145703171 \n", + "1 Population Below Poverty Level Status in Past ... 5036.0 1145703171 \n", + "2 Population Below Poverty Level Status in Past ... 1214.0 1145703171 \n", + "3 Population Below Poverty Level Status in Past ... 3752.0 1145703171 \n", + "4 Population Below Poverty Level Status in Past ... 1083.0 1145703171 \n", + "\n", + " importName measurementMethod observationPeriod \\\n", + "0 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "1 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "2 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "3 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "4 CensusACS5YearSurvey CensusACS5yrSurvey None \n", + "\n", + " provenanceUrl unit \n", + "0 https://www.census.gov/programs-surveys/acs/da... None \n", + "1 https://www.census.gov/programs-surveys/acs/da... None \n", + "2 https://www.census.gov/programs-surveys/acs/da... None \n", + "3 https://www.census.gov/programs-surveys/acs/da... None \n", + "4 https://www.census.gov/programs-surveys/acs/da... None " ] }, - "metadata": { - "tags": [] - }, - "execution_count": 4 + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" } + ], + "source": [ + "us_county_observations_df = dc_client.observations_dataframe(variable_dcids=[\n", + " \"Percent_Person_Obesity\", # Obesity prevalence from CDC\n", + " \"Percent_Person_WithHighBloodPressure\", # High blood pressure prevalence from CDC\n", + " \"UnemploymentRate_Person\", # Unemployment rate from BLS\n", + " \"Count_Person_BelowPovertyLevelInThePast12Months\", # Persons living below the poverty line from Census\n", + " \"Count_Person\", # Total population from Census\n", + " ], date=\"2021\", parent_entity=\"country/USA\", entity_type=\"County\")\n", + "\n", + "# Display the first five rows.\n", + "us_county_observations_df.head(5)" ] }, { "cell_type": "markdown", "metadata": { - "id": "z191ImVmrdds", - "colab_type": "text" + "id": "z191ImVmrdds" }, "source": [ - "### Cleaning the Data\n", - "\n", - "Great! We have all the statistics we'll need for this case study queried from three different data sources without having to write additional code to perform the joins. However, we'll still need to perform some data cleanup tasks to prepare the data for analysis:\n", + "## 3. Data preparation\n", "\n", - "1. Remove any missing rows with missing values.\n", - "1. Normalize poverty into a rate.\n", - "1. Remove unnecessary columns.\n", + "Process the fetched data for modeling:\n", "\n", - "Let's generate the final dataframe." + "1. **Filter:** Keep only relevant observations based on their `measurementMethod`. For CDC data, this is typically `AgeAdjustedPrevalence`. For Census, `CensusACS5YearSurvey`, and for BLS, `BLSSeasonallyUnadjusted`.\n", + "1. **Select columns:** Keep only essential columns: `entity`, `entity_name`, `variable`, `value`.\n", + "1. **Pivot:** Reshape the dataframe so each variable becomes a column, indexed by county `entity` and `entity_name`.\n", + "1. **Calculate poverty rate:** Compute the poverty rate percentage using the population count and the count of people below the poverty level.\n", + "1. **Handle missing values:** Drop rows (counties) with any missing values for the selected variables.\n" ] }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "Wv6oIY765sf-", - "colab_type": "code", "colab": { "base_uri": "https://localhost:8080/", - "height": 451 + "height": 310 }, - "outputId": "dd20d7b1-936d-4dd2-bec1-a384c5ca52cb" + "id": "Wv6oIY765sf-", + "outputId": "8875c29b-cda2-43b2-e282-b870a336022f" }, - "source": [ - "# Drop rows with missing values\n", - "cleaned = data.dropna()\n", - "\n", - "# Compute the poverty rate\n", - "cleaned['PovertyRate'] = cleaned['Count_Person_BelowPovertyLevelInThePast12Months'] / cleaned['Count_Person'] * 100\n", - "\n", - "# Remove the unused columns\n", - "cleaned.drop(['Count_Person', 'Count_Person_BelowPovertyLevelInThePast12Months'], inplace=True, axis=1)\n", - "\n", - "# Display the table\n", - "cleaned.head(5)" - ], - "execution_count": 5, "outputs": [ { - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:5: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " \"\"\"\n", - "/usr/local/lib/python3.6/dist-packages/pandas/core/frame.py:3997: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame\n", - "\n", - "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " errors=errors,\n" - ], - "name": "stderr" - }, - { - "output_type": "execute_result", "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"pivoted_df\",\n \"rows\": 3067,\n \"fields\": [\n {\n \"column\": \"Count_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 327885.41578620876,\n \"min\": 83.0,\n \"max\": 10019635.0,\n \"num_unique_values\": 2996,\n \"samples\": [\n 14483.0,\n 10808.0,\n 13653.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person_BelowPovertyLevelInThePast12Months\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 43284.17721715056,\n \"min\": 1.0,\n \"max\": 1366544.0,\n \"num_unique_values\": 2704,\n \"samples\": [\n 744.0,\n 150.0,\n 17812.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_Obesity\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 4.531508938137115,\n \"min\": 17.4,\n \"max\": 52.5,\n \"num_unique_values\": 271,\n \"samples\": [\n 36.6,\n 31.8,\n 35.3\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithHighBloodPressure\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 4.74139808597901,\n \"min\": 20.9,\n \"max\": 52.7,\n \"num_unique_values\": 258,\n \"samples\": [\n 40.7,\n 41.2,\n 36.4\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"UnemploymentRate_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.732747038207391,\n \"min\": 0.9,\n \"max\": 19.4,\n \"num_unique_values\": 114,\n \"samples\": [\n 10.6,\n 2.3,\n 6.6\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"PovertyRate\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 5.858256487714936,\n \"min\": 1.2048192771084338,\n \"max\": 57.99236803052787,\n \"num_unique_values\": 3066,\n \"samples\": [\n 10.721531647378196,\n 16.491756335886876,\n 11.31127538936338\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe", + "variable_name": "pivoted_df" + }, "text/html": [ - "
\n", + "\n", + "
\n", + "
\n", "\n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" ], "text/plain": [ - " Percent_Person_Obesity ... PovertyRate\n", - "place ... \n", - "geoId/0107000 42.0 ... 26.288434\n", - "geoId/0135896 28.4 ... 6.690341\n", - "geoId/0137000 36.2 ... 16.983110\n", - "geoId/0150000 38.2 ... 21.209494\n", - "geoId/0151000 39.0 ... 21.220448\n", - "\n", - "[5 rows x 4 columns]" + "variable Count_Person \\\n", + "entity entity_name \n", + "geoId/01001 Autauga County 58239.0 \n", + "geoId/01003 Baldwin County 227131.0 \n", + "geoId/01005 Barbour County 25259.0 \n", + "geoId/01007 Bibb County 22412.0 \n", + "geoId/01009 Blount County 58884.0 \n", + "\n", + "variable Count_Person_BelowPovertyLevelInThePast12Months \\\n", + "entity entity_name \n", + "geoId/01001 Autauga County 7847.0 \n", + "geoId/01003 Baldwin County 20598.0 \n", + "geoId/01005 Barbour County 5890.0 \n", + "geoId/01007 Bibb County 3558.0 \n", + "geoId/01009 Blount County 7720.0 \n", + "\n", + "variable Percent_Person_Obesity \\\n", + "entity entity_name \n", + "geoId/01001 Autauga County 38.9 \n", + "geoId/01003 Baldwin County 37.2 \n", + "geoId/01005 Barbour County 43.4 \n", + "geoId/01007 Bibb County 39.6 \n", + "geoId/01009 Blount County 37.7 \n", + "\n", + "variable Percent_Person_WithHighBloodPressure \\\n", + "entity entity_name \n", + "geoId/01001 Autauga County 37.1 \n", + "geoId/01003 Baldwin County 32.4 \n", + "geoId/01005 Barbour County 44.1 \n", + "geoId/01007 Bibb County 39.1 \n", + "geoId/01009 Blount County 35.4 \n", + "\n", + "variable UnemploymentRate_Person PovertyRate \n", + "entity entity_name \n", + "geoId/01001 Autauga County 2.8 13.473789 \n", + "geoId/01003 Baldwin County 2.9 9.068775 \n", + "geoId/01005 Barbour County 5.5 23.318421 \n", + "geoId/01007 Bibb County 3.4 15.875424 \n", + "geoId/01009 Blount County 2.3 13.110522 " ] }, - "metadata": { - "tags": [] - }, - "execution_count": 5 + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" } + ], + "source": [ + "# Filter the dataframe to only include age adjusted values\n", + "valid_methods = ['AgeAdjustedPrevalence', 'CensusACS5yrSurvey', 'CensusACS5YearSurvey', 'BLSSeasonallyUnadjusted'] # Add all the methods you want to keep\n", + "\n", + "filtered_df = us_county_observations_df.loc[us_county_observations_df['measurementMethod'].isin(valid_methods), ['entity', 'entity_name', 'variable', 'value']]\n", + "\n", + "# Pivot the dataframe to show our two variables as column headers\n", + "pivoted_df = filtered_df.pivot_table(index=['entity', 'entity_name'], columns='variable', values='value')\n", + "\n", + "# Calculate poverty rate as the proportion of people below poverty level to total population\n", + "pivoted_df[\"PovertyRate\"] = (\n", + " pivoted_df[\"Count_Person_BelowPovertyLevelInThePast12Months\"] / pivoted_df[\"Count_Person\"]\n", + ") * 100\n", + "\n", + "# Drop any null values from the dataframe\n", + "pivoted_df.dropna(inplace=True)\n", + "\n", + "# Display the first five rows\n", + "pivoted_df.head(5)\n" ] }, { "cell_type": "markdown", "metadata": { - "id": "-ZGRFaJKdHIO", - "colab_type": "text" + "id": "-ZGRFaJKdHIO" }, "source": [ - "### Exploring the Data\n", + "## 4. Exploratory data analysis\n", "\n", - "Now's a good time to explore how each variable (high blood pressure prevalence, unemployment rate, and poverty rate) correlate with obesity prevalence. As stated before, previous research has shown that each of these variables tend to correlate positively with the prevalence of Obesity. Does our data show this?" + "Visualize the relationships between the target variable (Obesity Prevalence) and the predictor variables (High Blood Pressure Prevalence, Unemployment Rate, Poverty Rate) using scatter plots. This helps assess potential correlations.\n" ] }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "Y_g3fDt-dasl", - "colab_type": "code", "colab": { "base_uri": "https://localhost:8080/", - "height": 315 + "height": 564 }, - "outputId": "37a7c403-e59c-4dd5-98fb-35ac6b6b03c3" + "id": "Y_g3fDt-dasl", + "outputId": "5c5476f3-a9f1-4f62-adb2-bf2a7f9f47fa" }, - "source": [ - "# Plot Bphigh vs. Obesity\n", - "plt.figure(figsize=(6,4))\n", - "cleaned.plot.scatter(x='Percent_Person_WithHighBloodPressure', y='Percent_Person_Obesity')\n", - "plt.title('High Blood Pressure Prevalence v. Obesity Prevalence')\n", - "\n", - "# Show the plot\n", - "plt.show()" - ], - "execution_count": 6, "outputs": [ { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [] - } - }, - { - "output_type": "display_data", "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "tags": [], - "needs_background": "light" - } + "metadata": {}, + "output_type": "display_data" } + ], + "source": [ + "pivoted_df.plot(kind='scatter',\n", + " x='Percent_Person_Obesity',\n", + " y='Percent_Person_WithHighBloodPressure',\n", + " grid=True,\n", + " figsize=(10, 6),\n", + " title=\"Obesity vs. High Blood Pressure in US Counties\")\n", + "plt.xlabel(\"Obesity Prevalence (Age-Adjusted %)\")\n", + "plt.ylabel(\"High Blood Pressure Prevalence (Age-Adjusted %)\")\n", + "plt.show()\n" ] }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "Rf2yQkHBcuEk", - "colab_type": "code", "colab": { "base_uri": "https://localhost:8080/", - "height": 315 + "height": 564 }, - "outputId": "ed9ee58e-f30e-454b-ffb8-9473fb13cdc8" + "id": "Rf2yQkHBcuEk", + "outputId": "d680a7c1-9990-4e69-dc4e-b7610ab0c947" }, - "source": [ - "# Plot Unemployment with Obesity\n", - "plt.figure(figsize=(6,4))\n", - "cleaned.plot.scatter(x='UnemploymentRate_Person', y='Percent_Person_Obesity')\n", - "plt.title('Unemployment Rate v. Obesity Prevalence')\n", - "\n", - "# Show the plot\n", - "plt.show()" - ], - "execution_count": 7, "outputs": [ { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "tags": [] - } - }, - { - "output_type": "display_data", - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX8AAAEXCAYAAABF40RQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydeZwU5Zn4v09XTzfDjaAol9dIDLCCSkIMxg2Y3RhF467Xrldu1/1JNKuCJoZ4kGTjlRM3LjGHJhhFjBfqbkzATdCIAQUC6OqsUTm8QO5jZrr7+f1RVT3V1VXdVT3dMz0z7/fzGeiurnrrrequ533e53ne5xFVxWAwGAy9i0RXd8BgMBgMnY8R/gaDwdALMcLfYDAYeiFG+BsMBkMvxAh/g8Fg6IUY4W8wGAy9ECP8eyEi8rqIfKKr+2GIhoioiDRVuc07RWRONdvsaszvOh5G+FeJoAdURG4QkV91VZ96CiLyWRFZVmafp0Vkv4jsFpEtIvIbETkkYvsfF5GN1eltPERklIgsEJGtIrJHRJ4XkRm1Pq+qXqqqc50+dOj6nd95m3Pvt4vIsyJyQvV6a6gFRvgbehIzVbU/0AT0B27r4v6UREQOAJYBrcB4YBjwPeBeETm7K/tWAfc79/5A7Gv6jYiIfycRsTq9Z4ZAjPDvJFztSkSuEpF3ReQtEfmc5/O0iNwmIm+KyDvOtLzRd+xsz7FnisipIvKKiLwvIl/ztHWDiCwSkftFZJeIvCAiE0P6lRaR74vIZufv+yKSdj5bKyKne/ZtcLTqY0XkMGe28zkR2SAi20TkUhH5kIiscTTAeb5zfV5EXnL2/W8ROdTzmTrHv+oce4fYfBC4EzjB1SzL3WtV3Q48DEzytP8559y7ROQ1EfkXZ3s/4ElghNP+bhEZISIJEblWRP7P0coXOsI66B6+5NXWRSQpIu+JyHFluvpvwG7gC6r6tqruU9VfA98CbvcJz1Odfm8RkVtFJP/sht1X5/59z/nN7BSRv4jIBOezX4jIN0tc/14RGeo5x3HONTWUufdtwN3AwcBQ5zw/FpEnRGQPMM1p/0Gnvb+KyOXOOUaIyD7vfXZ+a1uc396RIrLE+T62iD1jGhzynYR+f57f7mfEft62iMh1nmMtEfmac+wuEVkpIqOdz44WkafEfub+V0TOLfMd1y+qav6q8Aco0OTbdgPwK+f1x4EMcBPQAJwK7AWGOJ9/D3gUOAAYADwG/Lvv2G84x34JeA+419l3PLAPONxz3jbgbGf/q4G/Ag3O568Dn3Be3wQ8BxyErbU9C8x1PpuNrdG51/Np4C/O68Oca74T6AP8PbAfW+geBIwE3gX+1nNsM/BBIAl8HXjWd/8WA4OBMc71neJ89llgWZn7/zTwRef1UOB3wCOez08DjgQE+Fvn3h/nub8bfe1d4dyXUUAa+E/g1yHn/gawwHeulyL8Zp4DbgzYfrhzPz7guTdLnd/GGOAVz7WG3lfgk8BK556Ks88hzme/AL5Z4vqfAP7V8/57wI9CruMG2n/naeBW4E3PeXYAU7GVzb5On74BpIAjgNeATzr7LwG+5Gn7VuBO53UT8HfOOQ4E/gB837Pv67T/rkO/P9p/uz8BGoGJQAvwQefzWcBfgA84920i9m+qH7AB+Jxzr48FtgDjulr+VCSzuroDPeWPaMJ/H5D0fP4u8BHnB7YHONLz2QnAX33HWs77Ac75pnj2Xwmc6Tnvc57PEsBbwMec996H5P+AUz37fhJ43Xk9AtgFDHTeLwJmO6/dB2ik59itwHme9w8CX3FeP4mt4Xr7tBc41HP/TvR8vhC41nn9WaIJ/73YgkaBVcCYEvs/DFzhub9+4fcScLLn/SHYA2oyoK0m5z71dd4vAL4R4TfTDFwasL2Pcw1TPffmFM/n/w/4fbn7CkzHHig+AiR85/gFpYX/ecAzzmsLeBv4cMh13IBtutqO/ZteAhzvOc89nn2n4AwMnm1fBX7uvP4isMR5LdjC9qSQ854JvOh5/zrtv+vQ74/23+4oz+fPA//kvP5f4NMB5zsP+KNv238C15f7ruvxz5h9qkcWW8v20oD9g3PZqqoZz/u92LbpA3E0IsfksR34L2e799is83qf8/87ns/3OW25bHBfqGoO2IgtzP2MAN7wvH/D3U9VNwPPAGc50+tPYQs2L/4+hPXpUOAHnut7H/vhHunZ/23P670UXk8ULlfVQcAxwBBsrQ8AEfmUiDznTNe3Y8+8hpVo61DgIU9/X8L+jof7d1TVZufz00WkL3AG9qysHFuwhZKfQzyfu2zwvM5/R5S4r6q6BJgH3AG8KyLzRWRghH4BPAKME5HDsbXtHar6fIn9F6rqYFU9SFWnq+rKkL4fim1i2u7p89dov68PYpv4DgFOAnLAHwFEZLiI3Ccim0RkJ/Arwr/DKN9f2O9tNLZSFNTmFF/fL8A2cXU7jPCvHm9iaxReDqdQsIaxBVtQjnceoMGqOkhtB1qljHZfOPbhUcDmgP02Y/+oXcb49rsbuBA4B/iTqm6qsD8bgH/xXN9gVW1U1WcjHBsr9ayq/gX4JuD6DdLYQuU2YLiqDsY2a7g29aD2NwCf8vW3T4nr/zXwz9hmmPXOgFCO3wH/6LXfO5zrnP8Vz7bRntfe76jkfVXVH6rq8cA4YCy2ScNP0fWr6n7s2deFwEXALyNcTxje9jdgz2i9/R2gqqc6590G/BZbyz4fuE8dFRv4ttPW36jqQKdvRU5lz3nifH/+Y48M2f4/vjb7q+q/Rmiz7jDCv3rcD3xd7NC9hNjxxqdjm0pK4mjmPwG+JyIHAYjISBH5ZAf6c7yI/KOIJIGvYNs0nwvY79dOvw8UkWHYtlhveOrDwHHYNtR7OtCfO4Gvish4ABEZJCLnRDz2HWCUiKRinO9ubC3vDGzbchrbj5ARkU9h+yi87Q8VkUG+/n7L4zw9UEQ+XeJ89zlt/ivRtH6w7eiDgJ+KyMEi0kdE/hm4DpjlEXoAs0RkiON4vAL79+b2M/C+iu18n+I4afdg+2RyAf0Iun6wv+/PYt/Djgh/L88Du0TkGhFpdJyrE0TkQ5597gUuxvZZee/lAGwH+Q4RGUnwQOYS9/vzchcwV0SOcpSHY8R2fi8GxorIRY4DusG5xx+M2G5dYYR/9bgJ21m6DNgG3AJcoKprIx5/DbYN+DlnSvs7bIdTpTyCrT1tw9bc/lHtSAw/3wRWAGuwnVwvONsAUNV92Frz4cBvKu2Mqj4E3Azc51zfWmwzUhSWAOuAt0VkS7mdnfO1Aj8A5qjqLuBybE12G7ZG+ahn35exB8HXnOn8COfYR4Hfisgu7IFzSonzvQX8Cfgo7YIZEVknIheEHLMVOBHbxr8e22dyJXCRqt7v2/0RbL/OKuBx4KdOG6Xu60BspWIb9gx0K7YD1d+PoOtHVZ/BHixeUNUoM9iyOKbLGdiRWH/FnvXehT0IujwKHAW8raqrPdtvxFZEdmDfg1K/x1jfn4/vYv9WfgvsxL7Xjc7v6O+Bf8Keeb2Nfe/TEdutK6RQuTD0BETkBmzn84VVau8bwNhqtWfoPojIEuBeVb2rq/tiqC7Jru6Aob5xYqO/gD17MPQiHFPMcdh+DEMPw5h9DKGIyJewnVxPquofuro/hs5DRO7GNj1+xTF3GHoYxuxjMBgMvRCj+RsMBkMvpNvY/IcNG6aHHXZYV3fDYDAYuhUrV67coqoH+rd3G+F/2GGHsWLFiq7uhsFgMHQrRCQwTLfmwl9EXsfOe5IFMqo62YkguR97RezrwLnOyj6DwWAwdAKdZfOfpqqTVHWy8/5a7MRURwG/d94bDAaDoZPoKofvp7GX3+P8f2YX9cNgMBh6JZ0h/BV7ifVKEbnE2TbcWQ4P9hLpokyJACJyiYisEJEV7733Xid01WAwGHoHneHwPVFVNzkJy54SkZe9H6qqikjgYgNVnQ/MB5g8ebJZkGAwGAxVouaav5tCVVXfBR4CPgy84+Trxvn/3Vr3w2DobWzd3cLqDdvZurulq7tiqENqqvmLXR80oaq7nNd/j5398lHgM8B3nP8fqWU/DIbexiOrNnHNg2toSCRoy+W45axjOGPSyPIHGnoNtTb7DMeupuOe615V/S8R+TOwUES+gJ1qtvsWQTYY6oytu1u45sE17G/Lsd9J3z/7wTVMbRrG0P7dMvuwoQbUVPir6mvYxY/927cCJ9fy3AZDb2Xjtn00JBJ5wQ/QkEiwcds+I/wNeUxuH4OhhzFqSCNtucKCXW25HKOGNHZRjwz1iBH+BkMPY2j/NLecdQx9GhIMSCfp05DglrOOMVq/oYBuk9vHYDBE54xJI5naNIyN2/Yxakhjtxf8W3e39JhrqReM8DcYeihD+6d7hKA0kUu1wZh9DAZD3eKNXNrVkmF/W47ZD64xaxeqgBH+BoOhbnEjl7y4kUuGjmGEv8FgqFtM5FLtMMLfYDDULSZyqXYYh6/BYKhrelrkUr1ghL/BYKh7ekrkUj1hzD4Gg8HQCzHC32AwGHohRvgbDAZDL8QIf4PBYOiFGOFv6FWY6lYGg42J9jH0GkyOGIOhHaP5G3oFJkeMwVCIEf6GXoHJEWMwFGKEv6FXYHLEGAyFGOFv6HI6wwlrcsQYDIV0isNXRCxgBbBJVWeIyC+AvwV2OLt8VlVXdUZfDPVFZzphTY4Yg6Gdzor2uQJ4CRjo2TZLVRd10vkNdYjXCbsf2yQz+8E1TG0aVjPBbHLEGOqNripRWXPhLyKjgNOAbwFX1vp8hu6D64R1BT+0O2GNgK4epv5t/dKV4cedYfP/PjAbyPm2f0tE1ojI90Qk8BcpIpeIyAoRWfHee+/VvKOGzsU4YWvPI6s2MfXmJVx413Km3ryER1dt6uouGRy6Ovy4psJfRGYA76rqSt9HXwWOBj4EHABcE3S8qs5X1cmqOvnAAw+sZVcNXYBxwtaWrhYuhtJ0dfhxrc0+U4EzRORUoA8wUER+paoXOp+3iMjPgatr3A9DnWKcsLXDmNXqm66e+dZU81fVr6rqKFU9DPgnYImqXigihwCIiABnAmtr2Q9DfTO0f5qJowcbgVRlulq4GErT1TPfrsrts0BEDgQEWAVc2kX9MPQwurNzs9p9d4XLbJ9Dsbvdl55MV858RVU77WQdYfLkybpixYqu7oahjunOidtq2ffuPCAaOo6IrFTVyf7tZoWvoUfQnZ2bte67MasZgjDC39Aj6OrIiY7Qnftu6L4Y4W/oEXRn52Z37ruh+2KEfy+gN1Sv6urIiY7Qnftu6L4Yh28P55FVm5i9aDWWJMhqjlvPnthlTtCOOB6jHtudnZvdue+G+iXM4WvKOPZgtu5u4aqFq8jkALIAXLlwVU0Tp4XRkWiWOMd258Rt3bnvhu6HMfv0YNZt3ukI/nYyOXt7Z9KRaJbuHMVjMNQzRvj3aMJMep1r6utINIuJhDEYaoMR/j2Y8SMG0WBJwbYGSxg/YlCn9qMj0SwmEsZgqA1G+PdwLp9+FOlkgr4pi3Qywe3nTKzIrhw1Yihov45Es5hIGIOhNphonx6K10nams0yc9pRnD9lDEDsiJKoDtdy+3VGtI/BYCjERPv0IoLKI97xdDMH9Esx9/H1sSJuopZajLJfR6JZTCSMwVBdIpt9ROR2ERlfy84YqkOQk9QS4cbF62NHzUR1uBrHrMHQvYhj838JmC8iy0XkUhHpXK+hITKBTtJsjpTf+RtBOI8a0si+tkzBtn1tmSKHq3HMGgzdi8jCX1XvUtWpwMXAYcAaEblXRKbVqnOGyghykl5/+ngyuUL/Tks2R7+UVbY9u+ZO+PuwcxrHbDG9IdWGoXsQy+YvIhZ27d2jgS3AauBKEfkXVf2nGvTPUCFBRSIG9Eky+8E1AOxvyyGqzJi3rKTtf+O2ffRJWrRl27X/VDLB0pffZdrRBxUId1OSsTTdud6AoecROdpHRL4HzACWAD9V1ec9n/2vqn6gNl20MdE+1aH5nV2c+sM/0ppt/977NCR45prpgcJ66+4Wpt68hP1thSadfimLrKoRYBEJuo+l7rvBUC2qUcxlDTBJVf/FK/gdPtyh3hk6jT2tWdLJQlNPKdu/15zTL91+3J7WrEm1EAPjEDfUG3GE/4Wquse7QUR+D6CqO6raK0PNqMQxe8akkTxzzXRuPH18kY/ACLBoGIe4od4oK/xFpI+IHAAME5EhInKA83cYYOb73Yw4jlmvc3Jo/zTTjj6IrM9MaARYNIxD3FBvRHH4/gvwFWAE8IJn+05gXpSTOI7iFcAmVZ0hIocD9wFDgZXARaraGqfjhsqJ4pgNc07ectYxzPZtNwIsGsYhbqgn4jh8v6yqP6roJCJXApOBgY7wXwj8RlXvE5E7gdWq+uNSbRiHb/UolyqhnHPSpFowGLoPFad3EJHpqroE2CQi/+j/XFV/U+b4UcBpwLeww0IFmA6c7+xyN3ADUFL4G6pDlHBD1znppmmAdtu+m2bBCP34mEHTUE9EMfv8LXZ45+kBnylQUvgD3wdmAwOc90OB7arqBo5vpJf7DmotFNz2+6WsSHl6KnFOGsFmE3YfTIy/od4oK/xV9Xrn/8/FbVxEZgDvqupKEfl4BcdfAlwCMGbMmLiHdwtqLRS87bdk7YVdXrwavYvrnIxq2+9Ogq2Wg1TYfYiaHM9g6Ewir/AVkSuAnwO7gJ8AxwHXqupvSxw2FThDRE4F+gADgR8Ag0Uk6Wj/o4BNQQer6nxgPtg2/6h97S7UWigEte8nTKP3OycBVm/YXiQ0u5Ngq+UgVeo+lDOjVRszCzNEIU56h8+r6g9E5JPYppuLgF8CocJfVb8KfBXA0fyvVtULROQB4GzsiJ/PAI9U1v3uiftw7tjXivry7WhOqyYUgoROn4YEuZySTlplNXrXtj//f/6PW377v6QtIasUCM2gc1gJKbgGvzCqpXAKa7vWg1QpAd+ZMf7daRZm6FriCH83m9epwD2quk6CMnxF4xrgPhH5JvAi8NMK2+l2FJhhMhlas4Wft2Q1UrK1KAQJHYAnLv8Ye1qzkYTv7EWrWbhiIwAZJyWEV2gGnWNPS5a1m3YwcfTgImF07uRRLFyxsarCyRX4azftCK1XUGvtu5SAj2tGq5TuNAszdD1xhP9KEfktcDjwVREZACG2hABU9Wngaef1a/TClBBRzDB9GhLs8Y8IFRImdJqGDyh/MHYeIFfwe0kIrNu8k0GNDYwa0sicGeO47qG1BfvMfXw9Uw4/oOh67/nTmwBVE07u4JJMCLtbsqFtjxrSSGu28L62ZnPs2NeWX8TWEcoJ+M6I8e9s85KhexNH+H8BmAS8pqp7RWQoENsJ3NvwmiGCHs4gqmEOcM87tWkYz1wzvSKhs2rD9sDt+9pyfOmeFaQsW8hd9vEm+qWsgkGrIZFg1YbtZa+3I8LJO5iWa3tZ8xa8FraEQDaX47IFL1RtBlJOwNc6RNakkDDEIY7wV2AcdmbPm4B+2E5cQwh+k8ec08YVPZzJBFiJRF6QVsMcUC2776TRgwO3WyK0ZHK0ZOxrmbe0Gfvn0U5bLsek0YMDzU7+/SoVTuUGU7dtd5Bo82Qyzan9t6vFjjiulnmkK9dAdJZ5ydAziCP8/wPbzDMdW/jvAh4EPlSDfnV7gkw8cx9fz5wZ45i7uNAuXU1zQNB5Zy2qTLCte2snCaFAY/7EBw9i+Wvv54UmQMpKcMlJR3DH081F5qVbzjqGWYvWYCWEbE4570PFNv8wx3A5wnwa3nTTAEtffpdkorR7qqeYR0wKCUNU4gj/Kap6nIi8CKCq20QkVaN+dXvC7K8TRgwKNMP4H9JKI2KCztuSyXHv8jf58slHRW7HHUS8gj9lCdeecjQz5i0r2Lctl+P8KWM4f8qYoj6r+68KoEw+9ACuOHls0X6VzFaCNN05M8YxYcQgRg1pZFnzFqbevARLpKwfpSeZR8wKbEMU4gj/NidBmwKIyIHEcPj2NspFf5R6ODtitrEdm8Vfy7ylr3L+lDGRhcLGbfuKtOV00rbrnzt5VN5xC3Du5FFFg1jzO7tY1vwe337iJSeiyRa+sx9cwzPXTGeix6TUkSiVME03zB/QL22RzWlg1JERmIbeRBzh/0PgIWC4iHwLO07/6zXpVQ+gUvtrR8P1hvZPM3NaE7c/9UrB9pRllYy997N204589IxLazbLhvf3cP+fCyOAFq7YyBUnj823842H/8I9z71JEEHmlY5GqQQNpkFt9ktZ3Hj6+Hz5yYs/chirNmxn0ujBkSOgDIaeQmThr6oLRGQlcLKz6UxVfak23eoZVGJ/rUa43vlTxvCjJa8UrCHwmjXKzSy27m5h7uPri9rNKcxe9Je8ozeof83v7AoV/P5+uNQiSiWozaxqXvCbxVCG3k6cSl4AfQHLOa5nGEhrzND+aSaOHhxZcFdDEC5r3oLSbrJJJsjPOrwzi10tmcBSjEElBwHassretmLbubd/YeGhaSsRWsCkFoVOSrW5dXcLsxeVvgcGQ08nTm6fbwDnYEf4CPBzEXlAVb9Zq871RjoarhcU1mglEkxtGgZEm1mERdH46ZuyyDlRNe6xYeGht587kROOHBp6HbWIUglrc87DpWcvBkNvII7N/wJgoqruBxCR7wCrACP8q0xHBGGQcE9Z7YItysxiaP80c04bx3UPF67a9ZJOCndeeBzjRwwq6F/T8AFcfMKYAofwxSeMYcbEEWX7XosoFX+bze/s4om17xTt15ptXxNgwiQNvYE4wn8z9qKu/c77NCHZOA0dp1JBGCTcW7K5fL6gqDOLCSMH0T9tFTl9+zZY5LC1/ZPGHhTYh5s+/TcFztQh/VKBGUG7gjCz1FnHjWRZ8xbjBzD0GqJU8voRdnjnDmCdiDzlvP874Pnadq930hHt0yvcAfa32Tn8Z8xblhdmpcIj3W2jhjSS8WUcTScT3HnR8YwfMbBsv5qGD6Bp+AAWPPcGNy5eT8oSMjntcoEaZpb6x2NHcuHPng+NsjIzAkNPI4rm7xbOXYkd6unydNV7082ohUCoRhTKGZNGMu6QgZz6wz8CdqZQslogzNz+bty2D7CdxLM9K3FvPfuYwBnCSWMPjNyPBc+9kTcdtToLgrs6y2SYWaohaYX6QsyMwNATiVLJ624AEekDNDmbm13bf2+lFqGCW3e3MOuB1bRmNVKMf6nBZ09rlnTSojXbnobBFWYAC5a/yR1Lm0lZCVqzOdqyuYLVvFc9sJrnvnpyaFK4KEXgb3xsXdF2f67/sPtQSy3bb5ZqGj6ArbtbAn0h5UpfmhmBobsSxeyTBL4NfB54AzvSZ7SI/By4TlXbatvF+qMaedODhMbXH15La7Z8mUUIHny8ppwwx+7aTTs49z+fpSVjn8cf9ZLfN6us27yDk8YeFOnc/oFv3ead5HLFxdfasloybLWaZqKtu1tYt3kHIEWmKtcs5RLmC9nTmjUzAkOPJIrZ51bs4uuHq+ouABEZCNzm/F1Ru+7VJx1diBUkPMcdMpAn175dtG9LJlskLIMGn6seWE1C7JW8bptBeW/mLl6fF/zlKU6GFmXge2TVJmY9sIag01z9d2ND71E1zUSPrNrE1Q+szoe8JhPw3XMnlYyiCvKFVDojMBjqnSjCfwYwVrW98req7hSRfwVephcK/44sxAoTntee8oHA/c85fnSReWHjtn1F5R9dIdeSaU9R/Mw10wvMNlHrCYAtLMePGJh/3/zOLlZt2E6fhmLbeALhT/+3hdEH9KNfyioQul7SSWHKEUND70ulZqKgtmYvKlzrkMnBlQtXYSWkYID0a+r+KKtKZgRG+AdjTGT1RRThr17B79mYFZEeV1Q9CpUsxGqv29sWKDSG9Q8ujfC5qYcVzRSu/MRY24lbAlcQ+VcXBy3eSicTnPehUdz3/JsICZQct50zCbCLti9Y/kZgRS+XvW1ZZv56FWlLyKEELAIGQERCB8iN2/bRYCWKqm0FmYnKCZGN2/ZhBaRwzuQgk9OCAbLS5HHN7+yiJRusABghV4xJp1F/RBH+60XkYlW9x7tRRC7E1vx7Ja5AWLd5J6CMHzEodF/vD781myMbMGs4+uABRbnzXfnlnync9tv/JZ1MhNrr3Tb9QtM/aLVms8ycdhTnTxnDsuYt3P/njU60T4IVr7/P7AfXkAD2hlTK8lNqQGrwpJgIYtSQRrLFOgbXnz6u4JgoQmTUkEayAf6G4j5VljzO7YM4/e3TYKfCuOWsY4wfIABTW7g+iSL8LwN+IyKfxw73BJiMndvnH2rVse5AlAc96IffYAnpZKF9fk9rln6pZEGRlH6pZGApxAYrEWhW8TLntEKhWaqso9tH72BSKjlbXAR48oqTSi728g5Mlght2RzXnz6eC6YcWnANUYRIWGZTP5UkjwtKFZ3LKU9c/jGG9Esx9eYlnS7k6n2mYWoL1ydRQj03AVNEZDow3tn8hKr+3rufiAxR1W016GNdEu50lYIcNkE//D5JizsuOJZBjamyjsWgUohZVc6fMopfPBssoPulLSaMbJ+JlNOW4/gCKsFKwPK/vs/cx9eXHCjLpbWII0TOnzKGeUtfDXVuJ8vMRMII6oNb52BPa+cLue5gTjG1heuTyFk9VXWJqv7I+ft9wC5F20Skj4g8LyKrRWSdiNzobP+FiPxVRFY5f5M6cA1dQlDmy7asMvPXL/KRf/89j66yM1+E/fDHjxhUYI/3Z6FMJxN87qOHsXnHPq78xFhSltC3IUHKEs445hB+/Xy4DT6ba7eTN7+zi1llMlj2S1m0ZEpXuvIyaVSwiashIaSSCdJWcRGYGxevj5RFs1QW1LhCZOa0o0gnE/nUFl68ye7iUKoPnS3komRorQdqkbXV0HHi5PYpR1CR1BZguqruFpEGYJmIPOl8NktVF1Xx/J1KqcyXbVktqJsb1Tnsar4Llr/JD373Cj/+n9f48f+8BoAl0JpV0skEC1cGp1Ty2p7dnPXuojEvXm3U1RwTCYGskrYESUhRpasrPzGWA/ql8rl6Pvqd3xdo1SlLuOszH2LEoD52mUfPOduyOUSKfx5xNeKo99KrDYNy5qRRPLJ6U0GeomTEKCK/SaVcHzqzgHp3MqeY2sL1RzWFfyuWRk0AACAASURBVFBEkAK7nbcNzl+PiBByhcDVi9bQGuB49dbNndo0jPkXTcZ1DJf74c9b8ip+k777PsjJ2zdlcctZf8PoA/oV2fH9gh8Ko1L89msV4fGZJ9I0fEBgrV2XW8+eGJr6wS8Ar/y7sXz7icLYgP1tuUCNvBzlhEiQOW7RCxvw6yZ7WrOs3byjoJyknzCTSqk+dKaQ627mlFpkbTVUTjWFfyBO3d+V2Kkh7lDV5c4agW85NQJ+D1yrqkVzVRG5BLgEYMyYMbXuamzcHDqf+sEfCAqImbf0VQ7olyqwdXsLjAc9CAuWvxkosEuRU+WEIwudimF2/AZLmDPDdgavDnAmp61Evth5qYfVHtCOJ2j1rF8Abty2j7QlBdFAaSu4qHoU52WpfgWntLa48CNj8rMol7mL13PK+IND01OUci6X6kNnCblKQo4N3YtaOvNrbfZBVbPAJBEZDDwkIhOArwJvAylgPnANcFPAsfOdz5k8eXJdzhiahg/g9nMn8W/3ryrS1pOJBDc+tq4gV891D62lX8oiq8WpC7bubuGOpa/G7sO5k0cBFETShJmlLBFuemw9A9JJpjYNY7/P1r8/YEWxH1cjTiaE1qxy/enjuGDKoYEmEhdxzEre9/7zRHVelnogwrThE44cyi+fe6PA9FPKRNJVJpW4D7sxp/Rcau3MjyX8HS1+uPc4VXVDTk4OPKh9v+0ishQ4RVVvcza3ODmCro7Tj3ojPwP44R8LQjD3Z7JkA2YErsbrDwPcuG0fKcvKL0LyYjmyMyi+/97lb3L/nzeSsgp/JN7QSfec+zPtkUlPXv4x/Ov3AtbzFRBkKrruobWs3rCNR1e/FfhDjaKhRg3jLPdAhJ1r/IhBRSmqS5lIytVFqAWVPuzdwZxS7+Go9UZnrI2IU8bxy8D1wDuQV4cUOAZAVd8POOZAoM0R/I3YNQBuFpFDVPUtsb2AZwLhJaO6CU3DB3D7ORM9C6hyZIIkv4co5RMtgfkXHc+wAX3ol7JYtWE71z+6rsBkYq9czeUHBdfZ7GqFj63exA2PvVTQbltWWdb8Ho0NhWsLGhuSrNu8k0GNDfRLWWzesR+vr2Ljtn0EjQ8LV9hO6LAfajXCOKM+EGHnimMi8Q4iEFwXoZpU82HvDEEb5xzdIRy13uiMmWcczf8K4AOqujXGMYcAdzszhgSwUFUXi8gSZ2AQ7FKQl8Zos27xCp0d+9q4bMELBYLVT1D5xHMnjyrINZ9ICJf9+sX8AzOkX4qvP1J6rHSdzedPGcPGbfv465a9gfsN69+naLDZ15bhS/esANUCG32DJdx+zkTGHTKw5Mri/P4BP9RSGmoU52WcByLoXN7vp1/Kjs3fursltE9R6iJUi2o97J0haOOcw6zurYzOcOZHjvMHNmBX84qMqq5R1WNV9RhVnaCqNznbp6vq3zjbLlTV3eXa6i64cerjRwwM1OLTyQT90hapZCLveAX7IfnDK+9y/583FBzTltWC+O1te1o57W8OLtuP7//uFT76nSVccNdz3P2nN4o+twROOHKob22BICK0ZHJFqRrc8NXNO/aTsgLdO4X7x/yhRokFHzWksSIfhf88r2/dw4x5y7jwruVMvXlJfk1GEG5dBC/eugjVohoPe1Dc/9WL1tD8zq6q9TPu2oKg9TC1uH89jc5YGxFH838NeFpEHseO3wdAVb9btd70IMJsz7v2Z7jxsXU0WAnmLrYdr4qdvychEroitSGR4OsPrw1M+xxEViGbyRE28XCjXApnK61ctuBF2rLBB9nJ0jS/JsDLuZNH8ejqzR2KOonivPT7JIJqBpQiribaWeGU1YjcCZo9tGZynPrDP3LbOROrMgOIO0PpbuGo9UStnflxhP+bzl/K+eu1RLV3+r88gKk3L6E1q/nslbMWrQakrCmlJZOJLPij8LuX3y0yeYwYFL5wDeyVw+NHDOKWs47hyoWrcLucTMCJTcO45pSjO/xDLRfG6fdRZJX8eoooxBVetQqnDPoNdfRhD4vwaq2iqSquMO/McNSe6FSupTM/svBXVTc1Q3/nfY8x1cQhrk3V++UFxdVbkggMkm1ICG05JZ0UVOH0Yw7hwRc3F+2XTIB/3LDE9hWUSv6WshKs27yDVRt25Ms5tuVy+ZW9miu2+d96tv3QTm0ahpVIkHGEQCbXXj8gbNGU+2C6tvZKhZs/5TPAvKXNTBw9mBGD+pRtuxJNNI5QjiKASv2GOvKwl1p4GDTAVSIsKxHmnRGOapzK8ZFyoX35He34/F8CBzibtgAXq2pxBY4aMHnyZF2xYkX5HWvI1t0t+ayNLn0aEjxzzfRIP+ig49NJwa/5p5MJfnLxZF56aye3P/UKKUtozWQJWBPFv//DBK5/dD2t2cLjPz/1MH72zOv5Gr2ZbK7AUtNgCYIWtdmnIcHimSc6WUaLo33AHsQuvGt5gQY+IJ3kV1+cEij83QfTHVC8aSjiPqA/+v2rgdk6GxLQliOwbb+Qe3TVpiLhVQ1BEUUAdfQ3FIXmd3Zx6g//WLBY0H+OjgrLetKyO+OedmdEZKWqTvZvj2P2mQ9cqapLnQY/DvwE+GhVetgN6GhERpjWBBSWWzxtHADffeoVWjO5fElD2+LezsUnjOG93a0Fgh/saJ+7n30DUC456QjOnzKGZ5q3FIShZnO5wFXJDQl7ha8rxL11bl3iaM9B6wLc15WYIuxsnc1FZjK3eX/bYWm3q62JRvUldEYIX9PwAdx2TnH6jbghs6Wop7UF3SnHUT0RR/j3cwU/gKo+LSL9atCnuqUazqswweNuW7tpB3MfX08iwA+gQCph27lnTmvi4o8exke/E5Rg1a6uBXDH082cP2VM5DDU1myOHfvaSoZAxpn6l0oXnRDJF4mPytD+aW492z53QoS9QdMh7Id/3eadZVM0VIuoAqizHKClBrieJiyNU7kyYkX7iMgcbNMPwIXYEUC9hmo5r4IEj/v+vPl/KtCS/bQ6H/1gSTM79reFrgh28T7U7l9Q7QCwTUHZXI7LFrwQaArwTvWjas+lsp/ubc3ypXtWcOvZ8SJR2quo7eBL96wIjJCyz6mdJuSiCqDOdICGDXA9TVh25j3tScSx+Q8BbgROdDb9Abixswq41IPN36Xa9k5vfd8gjbxUycYGq7RjN8z26bV7t2azfP7Ew/nZsr8WCFLvsR2xEbvn8juRw/oY5/762/ba/Kc2DetUW3AcX0JX28xr5ffoSrr6ntYrYTb/yMLf15iFbQbaWY3ORaGehH9H8f5IvTZp1xbvlfMpC248YwJff3htUeI4sCN7klaCpDMInDlpRFG8fRQBtHHbvlAn7qghjUVCNJVM8MSXTwz0CZQ614b39zB70V/yZinveSaOHlzRIFMqkqizhVytFINaCDQjLHsHHXb4isi92GkYssCfgYEi8gNVvbV63ez5BBVzz+Tac+I0WIIlmhf0WRXmPLKWpJUgG6D990lZXPSRQ/nZsr/SYCV4dPVm5pw2jgkjw9NGu/jNAmGmgLDFQ5/64R+5fLpdAL6c8HDPZRdqDz5PpY7IUvb7zs56WU1fQq3DFyvpqxkweg5x0juMczT9M4EngcOBi2rSqzpm6+4WVm/YXlGpvK27W5i9aHV+aXxLJlcUo5+yEvYKWodsTsnkgou4AGSyys+f+SutWWVPa5b9bTnmPr4+9sNZajl5mN2+Lavc/tQrfPQ7vy+ZIsHLsuYteBflemvp1ioVgJtyI+h+hH2fdrqN9/jDK+92SVnEzkjVEJdHVm1i6s1LIqXFMNQ/cRy+DU4pxjOBearaJiJ1mWO/VnRUE1uw/M3Q9A0u+9uygeYdF9spq6SSCVSVmdOamP+H1wqcvl6npl9TK6W5hRVoGdo/zbnHj+Ke54ILxrdkoq0gdQWa10fhraXb2Y7IsO/zkVWbuMqzgtlNateZNvHOSNUQB5OgrecRR/jfCbwOrAb+ICKHAp1m8+9qOvrjtwu1NBdtTybsnDkpy6I1myWb05KFLl3Bmc0pCREO6J8KFZgLnnsjn0coq8q5x49i4cqNgYNXqYFt6+4WFq4MLxgP5aNotu5uYenL75JMFC5nTlrC0pffZdrRB+VnH7MWrcaSBFmtbSqAoO9z3CEDmb1odcGMzE1qN7hvqqhqWS365fovap2qIQ49LTzUEFH4i0gCeEdVR3q2vQlMq1XH6o2O/vhtrb/4Yb7i5LH51MtuYrVSaaBd7EFAmbt4PXNOG1dQKvKWs47hwZUb+faTdt1cNyWCq7n7By+g5MBWKlY/358SGro7sHiLyrjsacly/aPr+Poja7nlrGOccU+cFW3tA0W1bc1h3+eqDdvtlBsU9rMlk+PSX64kR3EFtmrhH4DPnTyK+/68MVKqhlrT08JDDRGFv6rmRGQ2sNCzTYHyUqrOqFSIdOTHH1aeMZ1M5J2lpeLvS9GQSDBh5CCeuWZ6/rr+a+3becFfCneR1aDGVMmBLejakwkhIUo6mQytzOVqsP4Vvu61u4OhOyBc9cBqJ7Np+76zH1zDrv2ZwjrIHoc2UNXvc9LowUUOaRc3QmnWotUM7ttQkPKiowTNRBau2Mi9X/gw59+1vCBVQ1cIXRNL3/OIY/b5nYhcDdwP7HE3BlXwqlc6YrMf2r+40Mq5k0dF+vGHlWecOa2p4Ph2s8eaSAVToF0QeAeQGxevj3Ssu8jqGzPGl8yTH/bgh0XReO9zSyZb4MB2CQoxdmczXqyEFNdBfngt/dMW+9uyiAh9khat2RwzpzXlB9Nyg3zYNTUNH8CtZ08syFrqpyWjXPqrF8gF1GGulLCZSEPSKpmqoTMx9YJ7FnGE/3nO/5d5tilwRPW6UzuqYbNfuKLQ7r1wxUauOHls2eODtMx0Ujh/ypiifdX5Nyhbp590srjAgz3QSD4fUDlaMspNi9cV5cX3vw978P3XHnSfgzzYraW82h7askqDlSjK5tleiF3z9Qduf+oV5i19lfM+NJqFK4J9G1GuqX0F8U527mvjqgdWFTnq94bUYa6UUjPLiaMH143QraecPoaOETnUU1UPD/jrFoIfOl5RqCPHB4VR3nr2xFDB2ZLRAsHfJ1msOfdtsLj9nIkcOrRfQSjiqCGNRYXKwc4JFIYlCdINhdWq3Dz5/usIC5l0CbpPlZCyEvRpSHD96ePIxliI2JJR7vnTm5ErTfmvyQ39BDhp7IHMmDiCW8+eSJ+GBH0biou3V6sqValQ26B+GgwdJc4ir77AlcAYVb1ERI7Crum7uGa9qyIddVh19PgwLdO/ytY/9e+Xspj1yQ/w70++VKB9tmazXPXA6nwefle79ZozLCen/9V/N5bv/u4VCPEnZDVHkJl73tLmSAu4vJTK5RNEOpkgm83hj4BVlMUzP0bT8AEMSCft6wlwGEchqoM0zCzonQnYuYTar6+a9veeaFYxi8Lqlzhmn58DK2lP4bwJeADoFsK/ow6raji8/FNmv7CZM2NckeDMqnL6xBEc0C9VkIsnp3YEiiuIvOYHt/D4qg3bOWxoXxqSVj4iyBJxbOXQ2NDurH1j696iPPkpK35Uifc+JZCCNA4AaUtQEdKeQSvo3H2SVl7Qe4Xi2s07uOmx9ZF9IhBNQJczCw7tn+aksQfmM4rWyv7ek8wqpsBKfRNH+B+pqueJyD8DqOpeESlZyVtE+mAngEs751qkqteLyOHAfcBQ7AHlIlVtregKYtBRzaqamlmQsJm7eD1nTBxR4Ftwncrlau16tduw4ilnTBzBw6s205iyaMu25/of2j/NgueKi7xXqtWW0pQlITzuFIvxLjzz5+j3n9sVihNHD2b0kL5c+suVRQNL35RFTjVfjSyOgI4aytsTtfNaYBaF1T9xhH+riDTi+CRF5Eg8hdxDaAGmq+puZ3XwMhF5Ett89D1VvU9E7gS+APw4fvfj01HNqtzxUae5QcLGEuHhVYWlGl2nsnvMqCGNJU1QpYqnuIOK6wx2c/1v3d3C3MeLI4TmnDau4ntVSlP2J4Mb2j8dSaN27+2IQX3I+aKC0knhzguPy4dfXnHy2FgCOo5ZrxbaeU8zj5hFYfVPHOF/PfBfwGgRWQBMBT5b6gBnLYBb67fB+VNgOnC+s/1u4AY6SfjXkkdWbWK2Z3VqqTz1gcImmyOVTBRE6jQkEixY/ib/8XRzgWCcM2McNz62Pp/uYc6McazbvJPX3ttVtIo2DPdh3LGvlYRvEtcvbTFh5KB4NyCAqJpyuf2CFkD5tXtvUZi4AjquWa+awronmkfMorD6J04+/2HOyynY6y+fU9UtEY6zsE07TcAdwK3OsU3O56OBJ1V1QsCxlwCXAIwZM+b4N94oNk3UC1t3tzDl278riNJJJmD51z4RKhz86YZdu3xhjd8EoAXOXjslRIJkQmjL5jjz2BH85oVNZUND/fRpSDDntHHctHhdUShjR/Le1yKtcVBe/sU+81E1+tfRAuzVuraeUH+2J9YM6I5UnNJZRE4Hfoa9mjcLnKeqz0Q9sapmgUkiMhh4CDg6xrHzsWsHM3ny5LpOIrdu884i4ZvJ2dvHjxgYKFCCtN0BfZIFD8xlHy9O3JbJQSaXy9vcFq4Izq6YsoRWj83fry3PmTGOuYvXFwn+oPUDUQlyYk8YUT69dCnCTGTeWsOV9s8vkKKY9appy+7J5hHjH6lvoph9vgV8TFVfFpEpwC3A38Y9kapuF5GlwAnAYBFJqmoGGIUdOdTt8GqJYdnY/vR/W7jklyvy+fu9q1ChfZGUGyvuf2DAts3HpbEhwTWnfIBh/fswsDHJiEGN7GnNcvFHDstry0GCp2+DxZ0XHc9JYw+Mfc4gwXjdQ2vpl7LIdmA1bJAJYU9rlrWbd8QS/tUQ3NUW1j3dPNKTopd6GlGEf0ZVXwZQ1eUiEq10EyAiBwJtjuBvBP4OuBlYCpyNHfHzGeCR2D2PSK0caUUa7mnjikoqJhPws2depyXTLmzcVaiuPyBME/X21Ru3v6clWpx7Jqf8+5Mvk7Is9rVl8mkQ3HO4QtMveHIo40cMrOiehCWA2+NbDevuG/U7Gdo/zRkTDyma4cxdvJ5Txh9ctg1vmcyOCu5qC2uTM8fQVUQR/geJyJVh71X1uyWOPQS427H7J4CFqrpYRNYD94nIN4EXgZ9W0Pey1MqRFhim+fh6bjhjPDc9th4rYTth23PtFwoLN//9uEMGRtJE3dnA0pff5fpH10Va6JTJKgoec1F7GgTvOaopeMot8ApzXkcp0/jwi5uLtlsJKSu4gyqneYkruGshrI15xNAVRBH+PwEGlHgfiqquAY4N2P4a8OEobVRKLeOMw6b+E0YM4tlrp0cy2SREWNb8XmRNdGj/NNOOPoivP7I2Uh9LOUi85wgSPJXOlob2L05+56U1m+OOpa/SktFY38nGbfsC8/u0ZbWk4A76DTRYQjoJKcuqWHBXW1h3VZhnTwsvNcSjrPBX1RujNCQiX1XVf+94l6pDrRxpW3e3sGNfW2gWTL+NMyxL597WLN9+4iWUwhDLIE3U+5DectYxJTNORiFsARX4NeUsM6dFq9Hr9tOf/A7ssNFsTgOd11G+E7vub/Fwdv3ppdchBP0G+iQt7rjgWAY1pjok9Kply44zOzXhpYZqEifOvxznAHUj/GvhSPMWJWnzZaUMC5l1tcR7l7/Jj5a8WpDNsjULyYSSTiYKcvSUSgFx5SfGEi2Kv5AGq9DmHyQ8gjRl20fRzK1nlxcOYbmJbjx9PNOOtmPw/TOhKN9JQb4iscNbrz99PBdMOTT0GHuQbi2eLeRyVc3D3xHizE6rHV5qVt8aqin8K5FJNaPattmglbNeGhuSoRrs0P5pvnzyUUwcPbgoLUFjQ5I7LjiOQY0NRRpd0EMaVKSlb8riMx89lJ8/8zoJkXy6YZd+KYsfX3h84Dm8hDlsWzJ28fBxhwwsWp3rJWjAzarmSzQCsb8TV9ud2jSsoGBNVDt/Tm3HuzePUb0IuKizUxNeaqgF1RT+dReHX03b7MZt+7BKpDLyarBh0/PxIwYWpSWwNdHgurBRyicCZHM5vnjiEXzxxCNYt3mHk0+n/TxZ1Ui1Z0cNaaQ1G3yusOLh/mv1a+j+FBHteX924BaKD6MSbTdIUKaTCe644LiS92Dr7hbWbd4JaKfNDKLOTk14qaEW9FjN36Vattm1m3YERtm49mxXoywlsOLORqKmR5457ah8GyeNPYhbz57oyQBqLxTzEzRALWveUhQN46U1q1z9wOr8DCDsWnftz3Dj4vWkkgnmPr6eAX2SBUJ7WfOWsmkwKtV2gwRlMiG8u3N/6EDzyKpNXOXxozRYwu3nhKfmiEMpO33U34MJLzXUgjjpHab6V/Z6t4nI11T12zXoI2Cv8F2xYkWtmi+75N+/BB/ga586milHDC2IkomyVD+O485dIh8W459OJnj22uJUAFt3t7Bg+ZvcsfTVgsiWsLUFU5uGBV5jEKmkXWRl7uL1gSkXZsxbFnoPoqbBWL1hOxfetbygmP2AdJJffXFKfoFanO+qf9oikyteaLZ1dwsf/c7vA1c5B93XOESduURJN7F2046COsbVcNCaaJ/eQcXpHTz8CDgubFstBX+tKZeQLdCRmbaYcsTQghWmUafn7mzErRoVNeHZ2k07uP7RtQUa6q1nh2ts//F0My0ZzUfXXP3AakYM6hOoUc+/aHKRWatvQ4KWbA6/Jag1k7OTyvkSyAlw/4o3ixLLee9BqTQY3lXFYdru2k07OG/+n0qmZ/CantzZmlv20T97sM15CezMJd5r0Q7ZwOPMXMJmp7VIlRHlvIbeQZTcPidgF3A50LfYayBQXNeum7F1d4tnym8LgCsXrip4SEcNaWSvryhuS1u2aNpdbnrualr9UhZPrH2bO5Y2F1Xi8vfN1cwmjh7MxNGDOWXCwfnasgMbG0JNGUEDUWtW+ae7lhcJ5wTCXX/4vyKz1v5MjoCKkIA98LT5pPi+thw/+ePrRfsWmijCZpqF24NME97Ed36B6l7zqCGNBYvibnhsnafeb/FgbIeRFs929meUBcvfCEwfEUVj7qidPqzeQ09I+GaoD6Jo/imgv7OvN9RjJ3aKhm5NFE30v9a+XVSDPKiOTSlbqqvFAQUmiaBKXBBuMhjaP822va1lNcIwf0Emq2R8F7O3LcsfmrcW7Rsm+MHW/m84fTw3LQ6vquX6Q+bMGJfPXTR+xKCiNBgNljB+RHH6aL/DPkyghq0aDloUF7TG4dazJ/KV+1YVudUXrtjIJR87oiDCKaopp6N2ehORY6g1URZ5/Q/wPyLyC1Wt35zKFVNaE926u4UbH1tX9GkqGfwghq2YLRUmCoUPdimTARApeZo7EF39wOqCtQVgl1LMQdFahTioKqdMOJjRB/TlCz9/nraApmb9/QdosBLMXVxoq779nInMWrQmnwajlOnKb5rwC9Ryq4ajODbPmDSS9/e0csNjxQVtVm3Ynhf+cU05HXGqmogcQ62JY/NPi8h84DDvcao6vdqd6kzKaaKVpBbw2pPzbZQJ2fQ+2KW0Pvd1ueRpbuqGcYcM5NQfLaPVV0rxe05EkH9NQFTcdQ0b3t8bKPgB9rRk+OGS5oLEdrMWreHZa6cXpMGIKhCDBGrQquEEkp+5RQ33PbFpWOD2SRX4dFymNg1j/kXH44a0xk2VYSJyDLUkjvB/ALgTuAu/d6wbM7R/uqQmWklqgaCMn6VCNv3588tpff7UEl78wqhp+ABuCyiReMKRQ8mViPQS4Bwn/38Qbbkc/VJWYPlHlx/87lVafbajlkyOe5e/yZdPPqoiQRYl5fXetixfumdFflVyFMdm0/ABXHzCmIK8RBefMKbA5BNHG6/GilyT8M1QS+KEeq5U1eNr3J9QuirUc+vuFu5d/ibzlr5KMpFoTy3wkUMDj++XsopCHdPJBP/84dH84tliq9lZx47gXz/eVLRyNqwKUlCopJewKlBB1+c9x/5MllxOSSYSKDluO2cSZ0wayYq/buW/17/Nrn0ZHlq1qSBs9NCh/bjgrucKHKpRSFnCn756ctWE2aOrNjFr0eqqVCNrfmcXqzZsZ9LowYGrmaNUp+rJ1bkM3Y9qhHo+JiL/D7saV75wu6q+X4X+dTlB2qFXewPh0r89MjDJmXe/lmwO0WJt99fLNwSe94m1b/P42reLhEiY1rdx2z4aG5IF8e8uyQQlC5+XqyTmtu/ut+C5N7j+0XVkHO3dEpg57Yj8PVjw3BtFgj+ZkPz+YbRmNa/9VyPW/IxJIxnct4FLf/VCgRmrEgdp0/ABJVNYRNHGjbPW0B2II/w/4/w/y7NNgSOq1536Ici5d8fTzZw/ZUzZ/YJoCUmbsK8t3HEYNCCVWvVrJRJ5p7BL3LKF7usFz73BdQ8XRspkFeYtfZXzp4xh6+4WbghwhF/4kdH84tnglM5e5i19lQP6paq2cGn8iEFFZqzWbG0cpOXMSMZZa+gOJKLuqKqHB/z1SMEP7dqbF6/TtdR+fRoSpCyhbyr6Mgi3MEkpXC15zoxxpKziUNOUVdg/78C0qyXD/rYcsx9cw9bdLUXH+s8TFOEEkMvZi5/Wbd4RGC00+dChNAT0zU8ykeBGZ4VwnL6F4TpIvefO5nI807ylovY6gtuXPg0JBqST9GmovCZyVNwFg5XeP0PvI7LmLyJ9gSuBMap6iYgcBXxAVRfXrHddSFTtLUwTf+Lyj/Hy27uY+esXI52vXGESvwZ/9d9/gNueeqUgisffv0rND2ERTvY57CyhO/YFC/iBjQ3M+uQHuPnJl4vWRhReb45UMoF37Vy5vpUzEU1tGoZ3/Vom13WpijvTWWty8xsqIbLmD/wcaMVe7Qt20fVvVr1HdUJU7S1sv6bhAxh9QF/SEbRgKB09FKTBf/d3r3D96eNK9q9S80NYhBPYs5o9rVnGjxiI/9KSCVi8ZjPffqK04Ac489gRRb6BUn17ZNUmLFwqHQAAHTZJREFUpt68hAvvWs7Um5fw6KpNRfts3LaPlFU42wqarXUWQ/unmTh6cFnBX0prL6fRVzq7Mxji2PyPVNXzROSfAVR1rwQtc+1BRNXewvYbNaQRSQheSZhOCp+fejg/+eNr+YgdS+ykZWGUKhsZluPeayLyL7IqJ4zcAS2oApl7Xcuat5BICNlsuzN49iePDqw30NiQyPs2XB5d/VbkvkVdXNUdbe2ltPYoGr1xLhsqJY7wbxWRRpylryJyJJ6on55K1ORXQfuFLdSZ2jSMnz3z17zmm9XS5olSQq1clJK7zmDCyHgJwbwVyLxhrnNOGwfYq4y9Nv+klSCVDJ5IfnL8wfz32rfZlyk/eAWZduIkzOsuC6Pc+gGznQE2ykruqANeazbLjn2tbN3dUpfXbqgP4gj/64H/AkaLyAJgKvDZUgeIyGjgHmA49qAxX1V/ICI3AF8C3nN2/ZqqPhGv611HlBS87mdBs4LVG7aTsqzAWrZAUdtxhFqQlnzT4nU8e238uPqh/e0KZAf0SxXk539/T2uRME5ZCYb1TwW288Rf3ipKMRGkkYdpunE0+npeGOVPz5xAimZW3t+B+sximivONOr/bexry5BTuGzBi8b+byhJZOGvqk+JyAvAR7AXgF6hquVCKTLAVar6gogMAFaKyFPOZ99T1dsq6nUXUsk03a+dV5KuOKpQC9KSWzLtcfVx2bq7hbmPr6c1k8s7Z+ctbcafE6ktl+OEI4cVrZIFinMLJYVbzjqGZc1bPMXic2RzOTI5Ks7R49IVqYrLOaO99Z+DigK5uIPatj2ttPjuW0tW6RcQQdZeHW2nU8UtR1vW/rJMbV5DGJEdviLyD0BGVR93InwyInJmqWNU9S1VfcF5vQt4Cei2akgp51ocx1uQk3jOjPZ0xWHHR3Eg2qUYi4XLvKXNJZ2AYY7FoFDWlJVg5rSjAp3NV5w8lnSI+cfl81MPZ2rTsIL71ZLJFa1a9mrBZ0wayTPXTOdXX5zCM9dMrytttpwz2vvbCBP8fVNWwX3c05olnSx0qbnO9iCG9k8zqLGBlFU+PNlggJhmH1V9yH2jqttF5Hrg4SgHi8hhwLHAcmyT0UwRuRhYgT072BZwzCXAJQBjxozxf9ypbN3dwtKX3y0qeFIq4Vopx5tfk1+3eScJwoug+PsSVm92aP80M6cdxe1PvVJwjLsGoJRWGjTjCJulnD9lDOdPGRNon09ZidA0zwA/Xfa6nVAvRrI799qiaLCdWaEqijO6XGK/dFK488LjCr7LtZt2FKWrAEo6r7ujw9vQdcQR/kHqXKTjRaQ/8CDwFVXdKSI/BuZi2w7mArcDn/cfp6rzgflg5/aJ0deq4grHZKJ4yu59uOI+eK4wsyuJFUfW+I93SzP+4Hev5AOIgurNnj9lDPOWNhe0F9aXcsKrnMklzgpkl9Zsjn+7/0XwDaRuYj2XcyePCoxg6pey2NOaDRTunR3zHsUZHXZPvPWfTxp7UH67a2rzM+e08HBg6F4Ob0PXE0f4rxCR7wJ3OO8vA1aWO0hEGrAF/wJV/Q2Aqr7j+fwnQN0uFAvLxe/Nn+8+XJU8eG77fsHv2sXd40MHiKwya1Ghpjm0f5pbAzJ5VpqHJq4T9bKPNzHPqVLWms2RyeaK4v7bcmCJkk4m8vv5i8cvXLGRK04emx8gvcVw0pYgCSkQ7pUWfe8IUbTtIKFcKgIrrGzohJHFBW/81LPD21BfxBH+XwbmAPdja+xPYQ8AoTjrAH4KvKSq3/VsP0RV33Le/gOwNuj4eiDsQbzx9PFMO/qgokRp4w4ZWDIrZJT2+6Ys7rzwuLw2GDZAuLipIUolbQsTAlFCBaOaUQoT4SmXnGQngXumeQtXL1pTsBoZ7BDXhNr7TRw9mMsWvFCQsM5rUvMPwC1ZhawWCPeuiHmPqm3HEcpB30k2V3oFuL9PRugbyhHVbGMBi1V1Wsz2pwIXAX8RkVXOtq8B/ywik7AHkdeBf4nZbqcR9iD6BT9UZnIIaj+nWlDWsJzDLkwwRBECQ/unOXfyqIIInUyuPVTwXCenf7lr2rq7pShm3U2Ely8q88M/Fod8ZpU7nm5m8cwTQzXoUjZzr3AfNaSxqNbB/kxxreVqE1Wwx1kzYsw3hloTSfiralZEciIySFV3RG1cVZcBQauAu01Mf6kH0asRQ7RFOXHad+mXskJLQDZYUrIMopcgDb75nV3c93xhuulsTvMauDsolLqmrbtbuP23r4TGrA/tn7aLypwzMbCsZEPCjmIpdR/C/Ah+E4u/PkXUehUdpdratjHfGGpNHLPPbmwN/ilgj7tRVS+veq/qjKAH0a/lX/bxpopNDuUe9D2tWdKWFMR9NyTgutM+yOkTR0YSDEGzEsUuq+gXxqXwX1OYLwKKUyqHlZV0BfjE0YMD74N3gIRim783qsZf68AtN9kdhacx3xhqSRzh/xvnr1fifRCDHIvzlr6Kf5ITJ8yu1IMelCPIshKc2HRg3iRUSkgE9XfWotWAFNnhy+G9pnK+iJnTmor6FVZW0ivoy4XGhkX7dMdQx84MSzUYvMRZ4Xu3k9tnjKr+bw37VPcE2aBTlsUlJx3BHU83V91OG2QaOnfyKGbMWxbJvxC0hiCbg0yAKcUSSCSEPkkr1OYfJX69wRI+NeHgwP6UmumUEoblNOHuZis3qZgNXUmcGr6nA7cBKVU93HHY3qSqZ9Sygy61ruEbh1I1WqE4N081zxtWJzisRmwps4yflCU8cfnHGNIvVTbZmtsf/31wSVuCinD96eO4YMqhRZ8HUS1hGCf3Uldh6vwaOouwGr5x8vnfAHwY2A6gqqvooSUcyxGUnsHVMKOkYChHWKoFt+09rdmilAsJEdZt3lFwfPM7u0qaZfx8efpRNA0fUHQNYdc0tH86n+XTT0tWac3kuO6htSx4rrhwfdA1VysvfVh/o6RhqGY1rFLtRa0UZzDUijg2/zZV3eFL4R/PYNyD6Eg0RintM4r2G2Tb3tua5Uv3rOC8yaNZuNI207RksiQS0UoupJNSVJ84ChNGDqJ/2ioq5O7lxsfWccqEg0veo1rH6JdbAFZtE0y59urZP1EvsyNDbYmj+a8TkfMBS0SOEpEfAc/WqF/dgkq0/FLaZ1Tt1515+BOotWSUe557M398a1ZDQ0S9NFjwjRnjCxzaUTXgUUMaiypyFbcfrtG65+qXsmoiDN32123eGappV7saVpT2Ss0eu5IoFdMMPYO4K3yvwy7gci/w3/TgMo61oJz2GUf7PWPSSAb3TXHpL1eyty1c6/YjQMpJqbC3NYOIkHby9A/ok0QhlgbsCrFZi9ZgJezoIf9gkNXgRWh+7biUc7kSvO0HpY8otYisI7OOqO3VWyx/V6THMHQdZYW/iPQBLgWagL8AJ6hqpvRRhiDKCYW4poDxIwaSI94ipv7pJHdccBxAPve7a7KZtWgNoLRkNNbDr+6/KlgJ+MfjRvLwi5tpsBJF+Y9cggTNwhUbWTzzxNCkbXEIar/BEtJJOzKr3CKySmcdW3e3sGNfG63ZaO3VUyy/KQnZu4ii+d8NtAF/BD4FfBD4Si071VOxc+2HC4W4oYphIaCu9uwtkOI93/gRAwNTLycEcjnBW6gl6OEPWtlspx+2B5FHV7/FE5d/rKQQDxM0e1qzTBw9ONoNLUFQ+32SFndccCyDGlMVV0orhXemkc3laLDaQ2arZdKppT2+nv0QhuoTRfiPU9W/ARCRnwLP17ZLPZdlzVsKTA8NlhQJhSimAK8ACNr/ipPH5t8/07wlcsoEf5F1dx/vwx91ZXM5IV5rQRPWvr/+gUtHTTBBM42UBVf9/VhObBoWKclfOarplA4aRLrbOglDxygb5y8iL6jqcWHvO4t6ivOvhKC47nRSYtfWrUQAhGmLj67axOwSpQXTSeHWs+1aAW4BGddU5JKyEqjm8I4b7nqBcgLPPX+tFjnVun0vqzds58K7lheklgDo22CRQzt87mquCyj3GzLRPj2LsDj/KJr/RBHZ6bYDNDrvBVBVHVjFfvZYwlYFx7GnVuqQK5cyYenL73LDY+sKwjW9aaVdYRFUcNxvxgJ7hfCMecvKCrxaOzw706EaVrDFdcZHdZyGCd5q2eOj/IbqyQ9hqB1lQz1V1VLVgc7fAFVNel4bwR+Rapg5arEwaGj/NNOOPqgoQsdNK+0VFlGjiva35SKHS1ZjUVxXtu89jxu62TegyHqU76lUmGW1zGRmcZnBJU6cv6EDdDSu244iaS0qzu5PtBZnhaq7PxDatyBhEZUgoVLtVbT1hFtk/s4Ljysqvl5OUJdbG1CtdQHGqWtwiRPnb+gglZohvDbanEIyYacq9jrk4voCgvZ/5prpRX2LUpM3jHLO4q5OZFYL2/bQ/mlOGnsQt549MZbjtBblNMP6Z5y6BoiR2K2r6e4O30oJdhQn+MnFkxk/YmA+8VocZ2C5/f1CsZxj2D0+m1NUtWBg8tbXradEZp0xEMUZXDr7/hinbu+hIw5fQxcS7ChOMKixAbCjTHbsa4vlDCylZS5r3hIoFF2Nc+3mHcxdvD6/jmDmtCY+NeHgfEy/236tHJbVoLNWssZxnHa2Rm6cugYj/OucMBvt2k07OG/+n8qmLojTZr+UVVIous7TU8YfXFJrDNpWC1tzpdprPQ1EXuot3YOhZ2McvnVOkKNvzoxxzH18fd452JLJOTl6JJIzMMx5GJQqOshpWy6CJsipW+1EZh1JQFbPTs/Oik4yGGqq+YvIaOAeYDh2zoD5qvoDETkAuB84DHgdOFdVt9WyL90Zv0YYJ3VB1DZdW3+lQtHVwtdu2sHcx9cH2tKrpdl21GzjNbFYIrRlc8w5bZwRuIZeRa3NPhngKlV9QUQGACudAvCfBX6vqt8RkWuBa4FratyXbo3fRhsndUHUNiu1O9vVwlaTQNjnLAILEsrVcjJWw2xzxqSR7Nqf4cbF60l5sppWy+lrHKqGeqemwl9V3wLecl7vEpGXgJHAp4GPO7vdDTyNEf6R6YhzsJxQiqudb93dwlULVznJ44ojx8IcyXNmjGPCiEEVCcdqmG227m5h7uPrac3kaHUyMlTL6VtvIa0GQxCd5vAVkcOAY4HlwHBnYAB4G9ssZIhBJSaUIKEU1EacSJB1m3dSqkpkazbYkXzdQ2vpl7LyKZ/jCMdqRMbUyulrcuIbugudIvxFpD/wIPAVVd3pLQWpqioigYsNROQS4BKAMWPilxjs6cQR0kFC6aoHVpOQwvz28TXU0utEZk5ryjuSvYIWyK8ZqEQ4dtR/UCunb71GEhkMfmoe7SMiDdiCf4Gq/sbZ/I6IHOJ8fgjwbtCxqjpfVSer6uQDDzyw1l3tEPWetiAoTUNb1i7c0pHSheNHDKLBCq4T7NYFLrdKuNLcMh2JjKl29JFLPUcSGQxeah3tI8BPgZdU9buejx4FPgN8x/n/kVr2o9Z0BxtvlDQNlWqol08/inlLm1G1zTxpS5BEYa2CfHRNQtjTEp6fqDOpRVy9SZ9g6C7UNL2DiJyIXQHsL5CfB38N2+6/EBgDvIEd6vl+qbbqNb1DvaUtKIU3v31Qla+4/S6skZtl5rSjClb7+tuJEg4ah3qOqKnnvhl6F12S3kFVl2Hn/Q/i5Fqeu7OoZxuvXwD5Nd1SVb6itO33IdzxdDPnTxlD0/DwxWX5VcITSq8SLke9z7ZM+gRDvWPSO1SAV6jWq403TDh6hVJHzB4dHfQ6Ihy7U0SNmQEY6hUj/GMSJFTrzcYbRzhWKoQ7Muh1VCDW82zLS73PTgy9GyP8YxAmVJ+5ZnpgLvyuojOEY0dWA3dUINbrbMtLd5qdGHonRvjHoJRQradkXKWEYzXNEJWsBq6GQOwOETXdZXZi6L0Y4R+DqBpnZ9h5S53DFY6zFq3GkgRZtYVjWK7+juA1G5W77moKxHpPf9yVsxPjZzBEwQj/GETRODvDzhvlHHYAr9ixVirsaskwd/H6mpkhovSp2gKxniNqump2YvwMhqiYMo4VEKZZdUbMf5RzBO2TSiZoSBSWYRyQTnLH/2/v3oOtrMo4jn9/HsQLmkIQQ2jijTQViNBMsI6OkVlmN5lxjopa3sZIbXSwckawadK0aGwKVEQlbyleQHJSZyQlxhsgcrykKOEF6XDwlpShwtMfa2142e69z9777Nu79/OZOXP2fvd7WetdsM56n/fdz+oYzS47bNvrFMvF1jv5XYN6dk61Gh3XchSepu+cuNrxaRwrKN+IsxZx3mKOkXOdNvFhVga29z/8iNNnL6ZvW+864lLq3QjhmlqOjmt5deL3GVwpfCavCqpFnLeYY+RaZ+Mm45JjD9icy2a7PkISGz7a1KvcPsWWKames1W91PUeF85ZvnkWtN7Uu9Gk4Sko1zi886+gaiULK/UY+dbpOHQPFk0+kpt++EWuPXkM2/dp22rfvUmwVu16V8LcZas55qqFfJB1BVRuvRtNWtrBNQaP+VdBsXHe3sSDc22bvazQ/qsRH27kp0xy1Tej2eLijdwOrvY85l9DxcR5ext3zj5GoXQO+bav9NMojfz0Ta54OIQb4c02Om7kdnCNwzv/Oqj0tz/L3d/YfQZyzUljACt5/t+0yRUP79sm7ps0jn0G71ynUjlXPx7zr4NcE6v0Ju5czv7mLlvN2Msf4pybl3LGn5aw6KV1ZR07LXLFw688fqR3/K5l+ci/Dir9VEap+yvlSqGZ4seN8Jipc43CR/51UOmnMkrdX7FXCpmrgxNnPs7Yyx9i3rLVZZWvkdTzMVPnGomP/Ouk0qPQUvZXzJWCZ6V0rrn5yL+OKj0KLXZ/xVwpVPq+hHOusfjIv0X1dKXg3xZ1rrn5yL+FFbpSKPY+wpvrN/D0a+80RXoE51qJj/xdXj1dHXj6YOfSq6ojf0mzJK2V9Exi2RRJqyUtiz/HVLMMrnfyXR0kbwg3W4I051pBtcM+NwBH51g+zcxGxZ/7qlwGVwV+Q9i5dKtq529mjwBvVfMYrj78hrBz6VavG74/krQ8hoX651tJ0hmSFkta3N3dXcvyuR54+mDn0q3qKZ0lDQPmm9mB8f1gYB1hmtlfAEPM7LSe9pOmlM6tpJnSPzjXjBompbOZdWVeS7oWmF/rMrjK8fTBzqVTzcM+koYk3n4HeCbfus4556qjqiN/SbcC7cBASa8DlwDtkkYRwj6rgDOrWQbnnHMfV9XO38xOyLH4umoe0znnXM88vYNzzrUg7/ydc64FVf1Rz0qR1A28UqPDDSQ8jtpMvE7p4HVKhzTVaQ8zG5S9MDWdfy1JWpzrudg08zqlg9cpHZqhTh72cc65FuSdv3POtSDv/HO7pt4FqAKvUzp4ndIh9XXymL9zzrUgH/k751wL8s7fOedakHf+CZJWSeqM00umNn90nukzB0h6UNKK+DvvPAqNqNmmBJW0u6QFkp6T9Kykc+Py1LZTgTqluZ22l/SEpKdjnabG5XtKelzSS5L+LKlvvctaKo/5J0haBYwxs7R8eSMnSV8G1gOzE/Mo/Bp4y8wuk3QR0N/MJteznKXIU6cpwHozu7KeZStHzG47xMyWStoZWAJ8GziFlLZTgTpNIL3tJKCfma2XtC3wd+Bc4CfAXWZ2m6QZwNNmNr2eZS2Vj/ybUJ7pM48DboyvbyT8p0yNZpsS1MzWmNnS+Po94HlgKClupwJ1Si0L1se328YfA44E5sTlqWqnDO/8t2bAA5KWSDqj3oWpsMFmtia+/hcwuJ6FqaCipgRtZHG2u88Dj9Mk7ZRVJ0hxO0lqk7QMWAs8CLwMvGNmH8VVXieFf+S889/aODMbDXwdOCeGGpqOhVhfM8T7pgN7A6OANcBv6luc0knaCbgTOM/M/p38LK3tlKNOqW4nM9toZqOA3YBDgP3qXKSK8M4/wcxWx99rgbsJDd0sujKzqMXfa+tcnl4zs674H3MTcC0pa68YQ74TuNnM7oqLU91OueqU9nbKMLN3gAXAl4BdJWXmQ9kNWF23gpXJO/9IUr94kwpJ/YDxNNcUk/OAifH1RGBuHctSEWmeEjTeSLwOeN7Mfpv4KLXtlK9OKW+nQZJ2ja93AL5KuJexAPh+XC1V7ZThT/tEkvYijPYhzHB2i5n9so5FKlty+kygizB95j3A7cBnCKmxJ5hZam6g5qlTOyGUsHlK0ES8vKFJGgcsBDqBTXHxzwgx8lS2U4E6nUB622kE4YZuG2GwfLuZXRr7i9uAAcBTwIlmtqF+JS2dd/7OOdeCPOzjnHMtyDt/55xrQd75O+dcC/LO3znnWpB3/s4514K883fOuRbknb8rmaRhydTKcdkUSRfUoSztkubX+riFxDIdlnifTGn8nKQTitjHeZJ2LPP4f5P0QkxDvEjSZ8vZj2tu3vk7V3ntwGFZy6bF/DDHAVfHNAiFnAeU1flHHWY2kvAFpSuK2UCB9wktwhvaVVQcdV4eJ8B4UdLhcXmbpCskPRmzO54Zl7dLeljSXEkrJV0mqSNu3ylp77jeDZJmSFoc9/vNHMceIOmeuP/HJI2QtI3CxCiD4jrbxAk4BsV9To/rroxlmSXpeUk3JPY7XtKjkpZKuiMmLstM/jM1Lu+UtF/MZnkWcH4c6R+eLKOZrQD+C/SP+5ge65ScKOTHwKeBBZIWFCpDER4B9on7uDBx/jPHGhavEmYT0i7sHs/LM7FO58f1RsXztFzS3YqZOfO1t2t83vm7auhjZocQRq+XxGU/AN41s4OBg4HTJe0ZPxtJ6DD3B04ChsftZwKTEvsdRkgK9g1ghqTts447FXjKzEYQ0grMjsnEbgI64jpHESbe6I7v+xMSdZ1PyKszDTgAOCh2eAOBi4GjYsbXxYSJPDLWxeXTgQvMbBUwgzjSN7OFyQJKGg2siMkDAX5uZmOAEcBXJI0ws6uAN4AjzOyIIspQyLFAp6TxwL7x/I0CvqAtWWv3Bf5oZgcQ0mcMNbMDzewg4Pq4zmxgcjy3nWxpV8jd3q7B9el5Fec+Jl9OkMzyTIbKJYQOG0KivBGSMsmwdiF0Oh8AT2ZyvUh6GXggrtMJHJHY/+2xM18haSUfT607DvgegJk9JOmTkj4BzCIk3vodcBpbOjSAe83MJHUCXWbWGcvxbCz7bsDngEWSAPoCjya2T9b1u3nOC4QrgVOB4YQOOWOCwtwRfYAh8VjLs7Y9tIcy5HKzpPcJuXQmEWafGk/IQwOwE+H8vwq8YmaPxeUrgb0k/R74C2F+i12AXc3s4bjOjcAdiWPlam/X4Lzzd+V4kxi2SBgA/DO+ziS42siWf2MCJpnZ/cmNJLUn1oeQEGxD4nXy32j2H52iElOZ2WuSuiQdSRj5diQ+Th4ruxx9Yh0eNLN8N2lz1TWXaWZ2paRvAdfFcNYQ4ALgYDN7O4aasq9mIJy7QmXIpcPMNs9DrfBX41dmdvVWOw5hqv9k3sdyjAS+Rrgam0C4Kiqk2HPgGoiHfVzJ4rR2a2JniqQBwNGE+U3zuR84W/FGp6ThCqmzS3F8jNnvDewFvJD1+UJixx7/qKxLTJAykxD+ucPMNpZwzMeAsZIycfN+kob3sM17wM65PjCzeYSwzUTgE4SO911JgwmTCOXaRzllyHY/cFrifsVQSZ/KXimGmLYxszsJoabRZvYu8HYinn8S8HD2ti5d/K+0K9fJwB8kZfK2TzWzl2NYIpeZhJDA0jgK7ab0eU9fBZ4gdJpnmdn/so43BZglaTnhpurExGfzCOGeZMinR2bWLekU4FZJ28XFFwMvFtjsXmCOpOPY+p5FxqXALYR7HE8B/wBeAxYl1rkG+KukN2Lcv9QyZNfjAUn7A4/Gc7YeOJEwWk8aClyvLU/9/DT+nki4z7IjITR0arHHdo3JUzq7VIghkflmNqendfNsP4YQevGnUZzDR/6uBUi6CDibrWP9zrU0H/k7l1KS7gb2zFo8OfumunO5eOfvnHMtyJ/2cc65FuSdv3POtSDv/J1zrgV55++ccy3o/2El11dhBvzGAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } + "metadata": {}, + "output_type": "display_data" } + ], + "source": [ + "# Plot Unemployment with Obesity\n", + "pivoted_df.plot(kind='scatter',\n", + " x='UnemploymentRate_Person',\n", + " y='Percent_Person_Obesity',\n", + " grid=True,\n", + " figsize=(10, 6),\n", + " title=\"Unemployment Rate v. Obesity Prevalence in US Counties\")\n", + "plt.xlabel(\"Unemployment Rate\")\n", + "plt.ylabel(\"Obesity Prevalence (Age-Adjusted %)\")\n", + "plt.show()" ] }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "A6bczTzEcuOS", - "colab_type": "code", "colab": { "base_uri": "https://localhost:8080/", - "height": 314 + "height": 564 }, - "outputId": "5a5e12f4-c488-40c4-9a23-c38f7ebdfca0" + "id": "A6bczTzEcuOS", + "outputId": "0465fd0c-6a87-4a83-9e64-4d4abb5f6f38" }, - "source": [ - "# Plot PovertyRate with Obesity\n", - "plt.figure(figsize=(6,4))\n", - "cleaned.plot.scatter(x='PovertyRate', y='Percent_Person_Obesity')\n", - "plt.title('Poverty Rate v. Obesity Prevalence')\n", - "\n", - "# Show the plot\n", - "plt.show()" - ], - "execution_count": 8, "outputs": [ { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [] - } - }, - { - "output_type": "display_data", "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "tags": [], - "needs_background": "light" - } + "metadata": {}, + "output_type": "display_data" } + ], + "source": [ + "# Plot PovertyRate with Obesity\n", + "pivoted_df.plot(kind='scatter',\n", + " x='PovertyRate',\n", + " y='Percent_Person_Obesity',\n", + " grid=True,\n", + " figsize=(10, 6),\n", + " title=\"Poverty Rate v. Obesity Prevalence in US Counties\")\n", + "plt.xlabel(\"Poverty Rate\")\n", + "plt.ylabel(\"Obesity Prevalence (Age-Adjusted %)\")\n", + "plt.show()\n" ] }, { "cell_type": "markdown", "metadata": { - "id": "wNABZa_idvzD", - "colab_type": "text" + "id": "wNABZa_idvzD" }, "source": [ - "Looks like each of variable does correlate positively with obesity prevalence." + "*Observation:* The scatter plots suggest positive correlations between obesity prevalence and each of the predictor variables.\n" ] }, { "cell_type": "markdown", "metadata": { - "id": "Bp52dWJNfYSa", - "colab_type": "text" + "id": "Bp52dWJNfYSa" }, "source": [ - "### Modeling the Data\n", + "## 5. Model training\n", "\n", - "We'll be predicting the prevalence of obesity with the following linear model.\n", + "Train a linear regression model to predict obesity prevalence based on the selected predictors.\n", "\n", + "The model follows the form:\n", "
\n", "$$f_\\theta(x) = \\theta_0 + \\theta_1 (\\text{high blood pressure}) + \\theta_2 (\\text{unemployment}) + \\theta_3(\\text{poverty rate})$$\n", "
\n", "\n", + "### 5.1. Prepare features and target variable\n", + "Define the feature matrix `X` (predictors) and the target vector `Y` (obesity prevalence).\n", + "\n", "Let's start by creating our training and test sets. We'll then train a linear regression model using Scikit learn's [LinearRegression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html)" ] }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "CppTvF2tYz4U", - "colab_type": "code", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 55 - }, - "outputId": "1e6c3bed-7aa7-4de3-df9c-666d8b9065b7" + "id": "CppTvF2tYz4U" }, + "outputs": [], "source": [ - "X = cleaned[['Percent_Person_WithHighBloodPressure', 'UnemploymentRate_Person', 'PovertyRate']]\n", - "Y = cleaned[['Percent_Person_Obesity']]\n", - "x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.2)\n", + "X = pivoted_df[['Percent_Person_WithHighBloodPressure', 'UnemploymentRate_Person', 'PovertyRate']]\n", + "Y = pivoted_df[['Percent_Person_Obesity']]\n", "\n", - "model = LinearRegression(fit_intercept=True)\n", - "model.fit(x_train, y_train)\n", + "x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rmidaLTx_6C9" + }, + "source": [ + "### 5.2. Split data\n", "\n", - "print('Model Intercept: {}'.format(model.intercept_))\n", - "print('Model Coefficients: {}'.format(model.coef_))" - ], - "execution_count": 9, + "Split the data into training and testing sets (80% train, 20% test)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "AKSxAqb4_5vi", + "outputId": "d81908bf-1a1a-42ca-e941-b05016a8b7d5" + }, "outputs": [ { + "name": "stdout", "output_type": "stream", "text": [ - "Model Intercept: [1.22374975]\n", - "Model Coefficients: [[ 0.89181367 -0.18273296 0.26194405]]\n" - ], - "name": "stdout" + "Training set size: 2453 samples\n", + "Test set size: 614 samples\n" + ] } + ], + "source": [ + "x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, random_state=42) # Added random_state for reproducibility\n", + "\n", + "print(f\"Training set size: {x_train.shape[0]} samples\")\n", + "print(f\"Test set size: {x_test.shape[0]} samples\")" ] }, { "cell_type": "markdown", "metadata": { - "id": "dBmThySxaXKp", - "colab_type": "text" + "id": "hu2t8OAGAGFp" }, "source": [ - "### Analyzing the Model\n", + "### 5.3. Train linear regression model\n", "\n", - "We now have a trained model, but how well does it perform?" + "Instantiate and train the [LinearRegression](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html) model using the training data.\n", + "\n" ] }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "UvQhIin3awbU", - "colab_type": "code", "colab": { - "base_uri": "https://localhost:8080/", - "height": 55 + "base_uri": "https://localhost:8080/" }, - "outputId": "23b2c021-d193-4264-cd30-e197eea845dc" + "id": "zVOTtKvMARG2", + "outputId": "1a3b64bf-6fae-4923-8770-8bfb3bc5f8d5" }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model Intercept: [16.20330544]\n", + "Model Coefficients: [[ 0.66228006 -0.27859918 0.06449069]]\n" + ] + } + ], "source": [ - "def mse(y_pred, y_true):\n", - " \"\"\" Compute the mean squared error of 'y_pred' and 'y_true'. \"\"\"\n", - " return float(np.sum((y_pred - y_true) ** 2)) / len(y_pred)\n", "\n", - "train_pred = model.predict(x_train)\n", - "test_pred = model.predict(x_test)\n", + "model = LinearRegression(fit_intercept=True)\n", + "model.fit(x_train, y_train)\n", "\n", - "print('Training Error: {}'.format(mse(train_pred, y_train)))\n", - "print('Test Error: {}'.format(mse(test_pred, y_test)))" - ], - "execution_count": 10, + "print('Model Intercept: {}'.format(model.intercept_))\n", + "print('Model Coefficients: {}'.format(model.coef_))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dBmThySxaXKp" + }, + "source": [ + "## 6. Model evaluation\n", + "\n", + "Assess the performance of the trained model using the Mean Squared Error (MSE) metric and residual analysis.\n", + "\n", + "### 6.1. Calculate Mean Squared Error (MSE)\n", + "\n", + "Define a function for MSE and calculate it for both the training and test sets. Lower MSE indicates better fit.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "UvQhIin3awbU", + "outputId": "87a7f9ff-cca7-43d7-c93a-62f1740872cc" + }, "outputs": [ { + "name": "stdout", "output_type": "stream", "text": [ - "Training Error: 8.797589893072455\n", - "Test Error: 8.633974278766338\n" - ], - "name": "stdout" + "Training MSE: 9.1628\n", + "Test MSE: 9.9832\n" + ] } + ], + "source": [ + "def mse(y_true, y_pred):\n", + " \"\"\" Computes the Mean Squared Error. \"\"\"\n", + " return np.mean((y_pred - y_true) ** 2)\n", + "\n", + "# Make predictions\n", + "train_pred = model.predict(x_train)\n", + "test_pred = model.predict(x_test)\n", + "\n", + "# Calculate MSE\n", + "train_mse = mse(y_train, train_pred)\n", + "test_mse = mse(y_test, test_pred)\n", + "\n", + "print(f'Training MSE: {train_mse:.4f}')\n", + "print(f'Test MSE: {test_mse:.4f}')" ] }, { "cell_type": "markdown", "metadata": { - "id": "VsGLliuzawPE", - "colab_type": "text" + "id": "VsGLliuzawPE" }, "source": [ - "We can also display a plot of the residuals" + "### 6.2. Analyze residuals\n", + "\n", + "Calculate and plot the residuals (difference between predicted and actual values) for the test set. Residuals ideally should be randomly scattered around zero." ] }, { "cell_type": "code", + "execution_count": null, "metadata": { - "id": "MLwX-CH3bDKg", - "colab_type": "code", "colab": { "base_uri": "https://localhost:8080/", - "height": 295 + "height": 472 }, - "outputId": "d5ee8232-c67e-4193-cf7c-eedbee3196b2" + "id": "MLwX-CH3bDKg", + "outputId": "3960b8a4-bf31-41a3-ebe1-f2688655054a" }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "y_res = (test_pred - y_test) / y_test\n", "y_res.reset_index(inplace=True)\n", @@ -725,54 +1301,57 @@ "plt.xlabel(\"Test Data Row Index\")\n", "plt.ylabel(\"resid. / actual obesity prevalence\")\n", "plt.scatter(y_res.index, y_res['Percent_Person_Obesity'])\n", - "plt.show()" - ], - "execution_count": 11, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEWCAYAAAB42tAoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3debgcVbnv8e+PECAyGJWIJIBBzQFBkOAWUVARQUBk0iOgeASPwuE6gBOXoBxA1GO4OIIjIogTc8QIHCMCakRREoJEEAQZJAlDFIIMERJ47x9VDZ1Nd3Xt7qru6u7f53n2s7uG3fXW7up6q9ZatZYiAjMzs2ZW63UAZmZWbU4UZmaWyYnCzMwyOVGYmVkmJwozM8vkRGFmZpmcKKyyJB0k6ecZy38p6X0FbGcnSYs6fZ8qkPQJSaf3Oo4aSXdI2qXXcVhnnCisEOkJYbmkhyXdI+m7ktbp5D0j4ocR8aaiYmyXpJD0SLpviyV9UdK4CsT1jAQXEf8TER0nzzHG0fH/Z5CS9SByorAi7RUR6wDbANOBY3ocT5Fenu7bG4F3AoeOXkHS6t0Kppvbyqnl/8f6lxOFFS4i7gHmkCQMACRtL+m3kpZJ+qOkneqWHSLpNkkPSbpd0kF1839Tt96ukm6S9KCkrwKqW3aCpB/UTU9Nr3RXT6ffI+nP6TZuk/Rfbe7bTcBc4GV123ivpL8BV0haTdKxku6UdJ+k70l69qiYDpO0RNLdkj5eF/Oakr6cLluSvl4zXbaTpEWSjpZ0D3A28L/A5PRK/mFJkxv8H/aWdEP6f/+lpJfWLbtD0sclXZ/+T8+VtFa6bH1JF6d/d7+kuZJani/q/z+jlzXbP0lrN9qXdj4fK4cThRVO0kbAHsCt6fQU4BLgM8BzgY8DF0qalJ4kTgH2iIh1gdcA1zV4z/WBWcCxwPrAX4EdxhDWfcBbgPWA9wBfkrRtG/u2BfBaYEHd7NcDLwV2Aw5Jf94AvAhYB/jqqLd5AzANeBNwdF0Z/ieB7UkS7MuB7Uj2t+YFJP+/FwLvJvkfL4mIddKfJaNi/TeShPJhYBJwKfBTSWvUrbY/sDuwKbB1GjvAx4BF6d9tAHwCaNnfT5P/T03D/YuIR1rti/WWE4UV6SJJDwF3kZyYj0/nvwu4NCIujYgnI+IyYB7w5nT5kyRX6BMi4u6IuKHBe78ZuCEiLoiIFcCXgXvyBhYRl0TEXyPxK+DnJCe0vK6V9ADwU+B04My6ZSdExCMRsRw4CPhiRNwWEQ+TFL8dOKqo6FPp+gvT93lHOv8g4MSIuC8ilgKfAv6j7u+eBI6PiMfSbbVyAHBJRFyW/s8+D0wgScY1p0TEkoi4P9232l3gCmBD4IURsSIi5kZ2x3BZ/5+aVvtnFeVEYUXaN70r2AnYnOTKH5Ir4LenxRjLJC0DdgQ2TK8mDwAOB+6WdImkzRu892SSBARAetK6q8F6DUnaQ9LVaTHKMpLEs36rv6uzbUQ8JyJeHBHHRsSTdcvq45gM3Fk3fSewOslVeaP170z/ptnf1hfBLI2If40h5lXeL435LmBK3Tr1yfZRkjsggJNJ7gh/nhbVzWixraz/T8N4eOb+WUU5UVjh0iv275JcwUJycvp+REys+1k7Imam68+JiF1JrmBvAr7d4G3vBjauTUhS/TTwCPCsuukX1K27JnBhGs8GETGRpBhGFKP+SnsJSWKs2QRYCdxbN2/jUctrxSyN/ra+CGb0FX2roqBV3q/uf7a4xd8REQ9FxMci4kXA3sBHJb2x1d+NJR5W3T93Y11hThRWli8Du0p6OfADYC9Ju0kaJ2mttHJ2I0kbSNonrat4DHiYpIhltEuALSW9NS3GOYK6ZEBSr/E6SZuklcf1La7WANYElgIrJe1BUj9QhrOBj0jaVEnz4P8Bzo2IlXXr/LekZ0nakqS+5Ny6vz02rbtZHziO5H/XzL3A82qV5Q2cB+wp6Y2SxpPUOzwG/LbVTkh6i6SXpMnlQeAJGn8uY5G1f632xXrIicJKkZZBfw84LiLuAvYhqRBdSnKHcRTJ8bca8FGSK8v7SSqG/0+D9/s78HZgJvAPksrgq+qWX0Zywr0emA9cXLfsIZLEch7wAEnzzdlF7m+dM4DvA78Gbgf+BXxo1Dq/IinWuRz4fETUHir8DEndzfXAQuDadF5DaQujs4Hb0iK9yaOW30xSP3Qq8HdgL5ImzI/n2I9pwC9IEvfvgK9HxJU5/i5L0/1rtS/WW/LARWbdIWkqSfIYP+oOw6zSfEdhZmaZnCjMzCyTi57MzCyT7yjMzCxT1ToW69j6668fU6dO7XUYZmZ9Zf78+X+PiEmNlg1copg6dSrz5s3rdRhmZn1F0p3NlrnoyczMMjlRmJlZJicKMzPL5ERhZmaZepooJO0u6WZJt2Z1YyzpbenIYCPdjM/MzHrY6knJ4OtfA3YlGUnrGkmzI+LGUeutCxwJ/L77UVq/u2jBYk6eczNLli1n8sQJHLXbZuw7fUrrPzSzp/TyjmI74NZ0JLDHgXNIehgd7dPASSS9cJrldtGCxRwzayGLly0ngMXLlnPMrIVctKDlcAxmVqeXiWIKq470tYhVR94iHdN444i4JOuN0sHq50mat3Tp0uIjtb508pybWb7iiVXmLV/xBCfPublHEZn1p8pWZktaDfgiyWArmSLitIgYiYiRSZMaPlhoQ2jJssbDSjebb2aN9TJRLGbVISE3YtUhGtcFXgb8UtIdwPbAbFdoW16TJ04Y03wza6yXieIaYFo6ZOQawIHUjToWEQ9GxPoRMTUipgJXA3tHhPvnsFyO2m0zJowft8q8CePHcdRum/UoIrP+1LNWTxGxUtIHgTnAOOCMiLhB0onAvIgoa6hKGxK11k1u9WTWmYEbj2JkZCTcKaCZ2dhImh8RDYv2K1uZbWZm1eBEYWZmmZwozMwskxOFmZllcqIwM7NMThRmZpbJicLMzDI5UZiZWSYnCjMzy+REYWZmmZwozMwskxOFmZllcqIwM7NMuboZl7QjMC0izpQ0CVgnIm4vNzSzarpowWJ3XW5DpWWikHQ8MAJsBpwJjAd+AOxQbmhm1XPRgsUcM2vhU2NxL162nGNmLQRwsrCBlafoaT9gb+ARgIhYQjJMqdnQOXnOzU8liZrlK57g5Dk39ygis/LlSRSPRzK6UQBIWrvckMyqa8my5WOabzYI8iSK8yR9C5go6VDgF8C3yw3LrJomT5wwpvlmg6BlooiIzwMXABeS1FMcFxGnlh2YWRUdtdtmTBg/bpV5E8aP46jdNutRRGbly1OZvSkwNyIuS6cnSJoaEXeUHZxZ1dQqrN3qyYZJnuax5wOvqZt+Ip33ylIiMqu4fadPcWKwoZKnjmL1iHi8NpG+XqO8kMzMrEryJIqlkvauTUjaB/h7ERuXtLukmyXdKmlGg+WHS1oo6TpJv5G0RRHbNTOz/PIUPR0O/FDSVwEBdwHv7nTDksYBXwN2BRYB10iaHRE31q32o4j4Zrr+3sAXgd073baZmeXXMlFExF+B7SWtk04/XNC2twNujYjbACSdA+wDPJUoIuKfdeuvTfosh5mZdU+eVk9rAm8DpgKrSwIgIk7scNtTSO5OahYBr2qw/Q8AHyWpF9m5w22amdkY5amj+AnJlf5Kkm48aj9dERFfi4gXA0cDxzZaR9JhkuZJmrd06dJuhWZmNhTy1FFsFBFl1AssBjau3046r5lzgG80WhARpwGnAYyMjLh4ysysQHnuKH4raasStn0NME3SppLWAA4EZtevIGla3eSewC0lxGFmZhny3FHsCBwi6XbgMZKWTxERW3ey4YhYKemDwBxgHHBGRNwg6URgXkTMBj4oaRdgBfAAcHAn2zQzs7HLkyj2KGvjEXEpcOmoecfVvT6yrG2bmVk+eToFvJOkLmHn9PWjef7OzMwGQ8sTfjrC3dHAMems2gh3ZmY2BDzCnZmZZfIId2Zmlskj3JmZWaY8fT19XtKuwD95eoS7y0qPzMzMKiFP81jSxODkYGY2hJomCkkP0bi31toDd+uVFpWZmVVG00QREW7ZZGZm+YqeACQ9H1irNh0RfyslIjMzq5Q841HsDXwBmAzcB7wQ+DOwZbmhWTdctGAxJ8+5mSXLljN54gSO2m0z9p0+pddhmVmF5Gke+2lge+AvEbEp8Ebg6lKjsq64aMFijpm1kMXLlhPA4mXLOWbWQi5akNXbu5kNmzyJYkVE/ANYTdJqEXElMFJyXNYFJ8+5meUrnlhl3vIVT3DynJt7FJGZVVGeOopl6XjZvwZ+KOk+ujjCnZVnybLlY5pvZsMpzx3FPiQ9xn4E+BnwV2CvMoOy7pg8ccKY5pvZcMqTKP4L2DAiVkbEWRFxSloUZX3uqN02Y8L4cavMmzB+HEfttlmPIjKzKspT9LQu8HNJ9wPnAudHxL3lhmXdUGvd5FZPZpZFScewOVaUtgYOAN4GLIqIXcoMrF0jIyMxb968XodhZtZXJM2PiIYNlXI/cEfyDMU9wD+A5xcRmJkNJz+/01/yPHD3fmB/YBJwPnBoRNxYdmBmNphqz+/UmmbXnt8BnCwqKs8dxcbAhyPiurKDMbPBl/X8jhNFNeUZj+IYSTtKek9EnClpErBORNzehfjM+paLVxrz8zuNVfl4yVP0dDzJk9ibAWcC44EfADuUG5pZ/3LxSnOTJ05gcYOkMMzP71T9eMnzHMV+wN6kT2NHxBKSJrMdk7S7pJsl3SppRoPlH5V0o6TrJV0u6YVFbNesbO4epTk/v/NMVT9e8iSKxyNpQxsAktYuYsOSxgFfA/YAtgDeIWmLUastAEYiYmvgAuD/FbFts7K5eKW5fadP4XNv3YopEycgYMrECXzurVtV4sq5V6p+vOSpzD5P0reAiZIOBf4T+HYB294OuDUibgOQdA5JdyFPtahKOyCsuRp4VwHbNSudi1ey7Tt9SkeJocrl+e2o+vGSeUchSSRPY18AXEhST3FcRJxawLanAHfVTS9K5zXzXuB/m8R5mKR5kuYtXbq0gNDMOuPilfIMYvf4VT9eMu8oIiIkXRoRWwGXdSmmZ5D0LpIK9dc3Wh4RpwGnQfJkdhdDM2vI3aOUZxCb11b9eMlT9HStpFdGxDUFb3sxyTMaNRul81YhaRfgk8DrI+KxgmOwChqUYoVOi1essaqX57erysdLnkTxKuBdku4gafkkkpuNrTvc9jXANEmbkiSIA4F31q8gaTrwLWD3iLivw+1ZH6h6M0HrvaqX5w+iPK2edgNeBOxMMg7FWyhgPIqIWAl8EJhDMgb3eRFxg6QT03G6AU4G1gHOl3SdpNmdbteqrerNBK33ql6eP4jyPJl9p6RtgR1JmsheFRHXFrHxiLgUuHTUvOPqXleyh1orz6AWK1hxql6eP4jyPJl9HPB2YFY660xJ50fEZ0qNzIaSixUsjyqX5w+iPHUUBwEvj4h/AUiaCVwHOFE0MCgVsb1y1G6brVJHAS5WMOu1PIliCbAW8K90ek0atE4yV8QWwcUKZtWTJ1E8CNwg6TKSOopdgT9IOgUgIo4oMb6+Mojtu3shT7GC79zMuidPovhx+lPzy3JC6X+uiO0O37l1jxOyQb5WT2d1I5BB4IrY7vCdW3c4IVtNnucoLCe37+4O37l1h59psZo8RU+Wkytiu2OQ7tyqXLTjhGw1eZ6j2CoiFnYjmEHg9t3lG5QmtFUv2hmkhGydyVP09HVJf5D0fknPLj0isxYGZeCbqhftuCjVavJUZr9W0jSSAYvmS/oDcGZE9KzbcbNBuHOretGOi1KtJlcdRUTcIulYYB5wCjA9HdToExExK/uv+0OVy4qh+vHZ2PVD0c4gJGTrXMuiJ0lbS/oSSQ+vOwN7RcRL09dfKjm+rqj6iFlVj8/a46KdxEULFrPDzCvYdMYl7DDzCh/XFZSnjuJU4FqS/p4+UOs5NiKWAMeWGVy3dFpWXPaB3iy+D597nb9YfWxQ6lo64Yug/pDryeyI+H79DElHRsRXRs/vV52UFXej5UpWHFVrKWNjM+xFO354srUqFDvnuaN4d4N5hxQcR081KxPOU1bcjZYrreKoUksZs7GoeoV+K2WXJlTljqtpopD0Dkk/BTaVNLvu50rg/u6FWL5Oyoq7caA3iq/M7eXlsmXrVCcXab3WjZN4VZpQZxU9/Ra4G1gf+ELd/IeA68sMqts6aQbYjZYr9fE12lbR28uj6g+LWX/o54cnu1FsVpU7rqaJIiLuBO4EXt29cHqn3bLibh3otfhGn6DL2l4rLlu2IvTzsxrdOIlXpQl100Qh6TcRsaOkh0jGoXhqERARsV7p0fWBbh/oVfliVeVKx/pfv1bod+MkXpU7rqw7ih3T3+t2L5z+0cuWCFX4YlXlSsesV7pxEq/KhWGeTgFfDCyKiMck7QRsDXwvIpaVHVxVDXP5fC1BLl62PLm1rFvWL2XLZkXo1km8CheGiojsFaTrgBFgKnAp8BNgy4h4c8cbl3YHvgKMA06PiJmjlr8O+DJJcjowIi5o9Z4jIyMxb968TkPLtMPMKxpeTU+ZOIGrZuxc6rZ7qVH9SC1ZTKlQ2XIV2p2b9RtJ8yNipNGyPA/cPRkRKyXtB5waEadKWlBAUOOAr5GMwb0IuEbS7Ii4sW61v5E8s/HxTrdXpGEtn29UgV1LElVJkMN8t2dWljwP3K2Q9A7gYODidN74Ara9HXBrRNwWEY8D5wD71K8QEXdExPXAkwVsrzD93Pa7E/2QIKvS7txskORJFO8haSL72Yi4XdKmQBFdd0wB7qqbXpTOGzNJh0maJ2ne0qVLCwgt27B25tYPCbIfklkefpjRqqRlokiLgo4m6RiQiLg9Ik4qO7CxiIjTImIkIkYmTZpU+vaq2plb2SeXfkiQ/ZDMWqlKtw1mNXlaPe0FfB5Yg6Q7j22AEyNi7w63vRjYuG56o3ReX6hCS4R63Sibr0pTvSxVaXfeCT/MaFWTpzL7BJL6hF8CRMR1kl5UwLavAaalRVmLgQOBdxbwvkOpWyeXqiXI0fohmbUyKMVnNjjyJIoVEfFgMqDdUzquXE5bUn0QmEPSPPaMiLhB0onAvIiYLemVwI+B5wB7SfpURGzZ6barrN2mnT65PK3qyawVP8xoVZMnUdwg6Z3AuHTs7CNIOgzsWERcSvJsRv284+peX0NSJDUUOik+8sllcAxC8dkwGuTnd/K0evoQsCXwGHA28E/gw2UGNaw6adrZDxXN4NY8eVS1scQgKup4HPQGCC3vKCLiUeCTkk5KJuOh8sMaTp0UH/VD2bwfhsuvG8Vng3wFnEeRx+OgN0DI0+rplcAZwLrp9IPAf0bE/JJjGzqdFh9VvWx+0L9M/cRJu9jjsdnF3OJly9lh5hV9n4TzFD19B3h/REyNiKnAB4AzS41qSPVL8VG7XOFeHcP8BHutuKnZIGDtHI9ZF3ODUAyVJ1E8ERFzaxMR8RtgZXkhDa9BL5sehIfhBsWwJu36uoRm2jkeWw1X3O9JOGvgom3Tl7+S9C2SiuwADiB9psKKV/Xio064NU91DGsruUZ3UvVEe8VFeYYr7ucknFVH8YVR08fXvc7um9ysgX6ocB8W3Uravawwb7TtrJN1/fgq7dTZ1C7ymhVr9XMSbjkeRb/pxngU/WDYW7RYa0UeI43eC2iYjLpRnNpsbPm1xq/GA4+ueMb64ySeaHAubKcL/WbbrnoxctZ4FHkGLno2yd3E69JZvyLp6+nBQqMsiBNF/x6o1l9ajXbY7KTc7vglY0lsza7qJ04Yz2Mrn3zGd6NZcZSA22fuWWqsVdHpwEVnAH8C9k+n/4Ok1dNbiwmvf/TLh+9mqFa20Rcjoy83l694ounJt52y+rE25222jQeXr+BLB2zzjO9xs7qFdouLBq2uMU+ieHFEvK1u+lPp8KhDpZ/anQ9rixbrnlaVwlnaOfmO9eInq7K+2UncDS2ay9M8drmkHWsTknYAhu6M00/tzt0MdTh1s3uUPBcdEyeML+y5oLFe/Iz1maRBb5reqTx3FIcD30vrKgAeIBkWdai0c5Xeq6IqN0MdPt2+4212xV4zYfw4Ttg76ei5iO/AWJvzttPCbtCKi4qUp6+nPwIvl7ReOv3P0qOqoLEeqL0sqnIz1OFTZL1UngucRhcjtQrtKaP+pojjrp2Ln0E88ffq4jPPHQUwvAmiZqwHaq8rlAfxS2LNFVUvlfcCp9sXI7746e3FZ+5EMezGeqC6Qtm6qagnrcdygdPti5Fhv/jp5cWnE8UYjOVAHdYuEqw3su54x1JcUaULnH5pjt4tvfxssvp6ynxOIiJmFR/O4HCFsnVTszteYEzFFVW5wGm3mKXqyaWT+Hr52WTdUeyVsSwAJ4oMLlO1bmt0x7vDzCvGVFxRlQucdopZqv6s01jia5RQevnZNE0UEfGe0rc+4Ia9THVYVPkqdqzFFVW5wGmnmKXXDUhayRtfs4TyubduxefeulV1Wz1J2pNk3Oy1avMi4sSygjLrF924iu12cUWnFzhFJM524q5S/UojeePLSihXzdi5J0mv5ZPZkr5JMgbFh0iaSr8deGHJcZn1hbKf2K8faCcY+2hp3R41sdN4a9qJu+o9EuSNr4oJL08XHq+JiHcDD0TEp4BXA/9WxMYl7S7pZkm3SprRYPmaks5Nl/9e0tQitmuDpZtdV4xW9pe600TU7a4pikqc7cRdZlIs4hjLG18VE16eoqfaEf+opMnAP4ANO92wpHHA14BdgUXANZJmR8SNdau9lyRBvUTSgcBJJHc3NoTyjHnQ7QrMZkUkAWMeJa2RIhJRN+vKikycY427rPqVoooX88ZXlQYF9fIkioslTQROBq4l+Q6cXsC2twNujYjbACSdA+wD1CeKfYAT0tcXAF+VpBi00Za6oP4k++wJ45Fg2aMrKlf52kyzL+ta41crtAJzrOXrjb7UNUUkrao0V82r1/GWkRSLrCTPE19VGhTUy9PX06fTlxdKuhhYq6BBi6YAd9VNLwJe1WydiFgp6UHgecDf61eSdBhwGMAmm2xSQGjVUFRrmtEn2WXLnx5MpmpNCJtp9mXt5ZgH9fObjWfQaaubKl5dZum3ePPoRZ1B1VpM5qnMfnfth6TYZ5/0dWVExGkRMRIRI5MmTep1OIUoqlIQWo8dUNXu0uuN9UtZ9JgHWfadPoWrZuyMmizv5ITSb91f91u8eVSxzqDb8hQ9vbLu9VrAG0mKoL7X4bYXAxvXTW+Uzmu0ziJJqwPPJqkjGXhF3u7mOVFVpQlhM82KNJoNbdmNMQ/yxtjpCaVqV5et9Fu8rQziXdJYtbyjiIgP1f0cCmwLrFPAtq8BpknaVNIawIHA7FHrzObpsS/+HbhiWOonirzdzXOiqvrVUbMWIyfsvWVhV7CdXjl2uymqdccg3iWNVTudAj4CbNrphtM6hw8Cc4BxwBkRcYOkE4F5ETEb+A7wfUm3AveTJJOhUOTVaVaFK/THyaxVBV+vxjwYS4zdVOWnxfvRoN0ljZVaXaBL+ilPj52+GrAFcH5EHF1ybG0ZGRmJefPm9TqMMcnT7BOSk1a7VzL93uqpW7pxgi17G6Mr5aGzY8eGg6T5ETHScFmORPH6usmVwJ0RsajA+ArVb4ki60sN3b067eVV6LBcAXfjJL7DzCsa3o1OmTiBq2bsXMg2hkGRrQ4bvU/VjvmsRJGn6OnNo+8eJJ1U1TuKflOVfl162fNm1Xv9LFKnjRTynFyq2AVEvynqmGz2PvPuvJ8L5y/um2M+TxceuzaYt0fRgQyrqnypy+6zqKrb7rZOPu+8TabdnPOZxtoFR1HHZLP3Ofv3d/XVMd80UUj6P5IWAptLur7u53ZgYfdCHGxV+VL3MmFVJVl2Qyefd96Tl1tfraqdZ5KKOiabrf9EkyL/qh7zWXcUPyIZvOgn6e/azysi4qAuxDYUqvKl7mXCqkqy7IZOPu+8Jy8351xVO3cHRR2TzdYfp8aPZ1b1mM8auOhB4EFJXwHuj4iHACStJ+lVEfH7bgU5KLLKl3tdqdXLh4qG6YGmrM+7Vf3DWJpMN2vOWbUK1G5o5+6gqGOy2fu87RVTVqmjaPf9uyVPq6cFwLa1B90krUbynMO2XYhvzIpu9VRWf0tQvSaLzZrQdqM57TCewOrlOT46PYb64RgsQ7utwNzqqW5ZjkRxXURsM2re9RGxdYExFqbIRFHkF6vZwQrJAdvrg6Reo/2u182TS9W+TGXJezLr5P8xrM1mhzVBjlWnzWNvk3QE8I10+v3AbUUFV2Xd6m+pak3j8nYi6GazxRlL/UO7+z5MjQbqVaV4t5/lSRSHA6cAx5I8oX05aZfeg67o/paa3VFAtQaBr0ongkUm6qrrxjgOWdsY9Du3Ye+Co1N5OgW8LyIOjIjnR8QGEfHOiLivG8H1WpGtcRq1dhmtKld2VelEcJCugFu14+9G67dm23jD5pMK69LeBlOe8SjWkvQBSV+XdEbtpxvB9VqRX976JovNVKVpXKuk1q3WGUU3m+3V2Np52vG326R1LPvUbBtX3rS0rx7+su7LU5l9PnAT8E7gROAg4M8RcWT54Y1dVVs9jX7PqleuVaETwSL/T738n5dViVzUPm064xIanQUE3D5zz7bjs/7SaWX2SyLi7ZL2iYizJP0ImFtsiNVVRtlmP1SuVaFMt8j/Uy/rO8oqQitqn3o9zrVVX55EURtgeZmklwH3AM8vL6ThUIUTcT8o6v/Uy/qOsk7ERe3TMD3waO3J0yngaZKeQ9LqaTZwI3BSqVGZFayX3YSUVVFd1D65yw9rpeUdRUScnr78NfCicsOxQVSFppe9vGouq6ixyH3yHa5laWcoVLPcqvLQXK/rhYa1rqsbqnAhMuhatnrqN/02wt2gaPZl7YduI3yi6V+9aM02qMdLW62eJE2OiCXlhWWDIuuuoeoPzVXljsfa0+3WbMN6vGRVZp8u6WpJMyXtJMnFVNZQ1pe16mNNDNPoeoOo2xciVTpeuvkAadNEERFvBnYCfgnsB1wtaZakwyRtUlpE1neyvqxVGZipmarf8Vi2bl+IVOV4aWfUvk5kNo+NiH9FxM8i4si07OpjJMVVX5X0h3Y3KrJLZfIAAA3+SURBVOm5ki6TdEv6+zlN1vuZpGWSLm53W1a+rC9r1ZteZsXeqy4/LL9uX4hU5Q6523c2eZ6jeEpE3B4RX4+IvYEdO9juDODyiJhG0hvtjCbrnQz8RwfbsS5o9WXdd/oUrpqxM7fP3JOrZuxcmSQB7iivasaanLt9IVKVO+Ru39m0Xe8QEY93sN19SIq1AM4iKd46usE2Lpe00+j5Vi393EyzWezD1MV5VbRbUdzNZ0Cqcqx3u9uVnjSPlbQsIiamrwU8UJtusO5OwMcj4i153tvNY60I7iivsTKbhvZDU+qqKKNZcKedAra70V8AL2iw6JP1ExERkjrKVpIOIx1MaZNNXM9unXNHec9UdtPQqlQU94Nu39m0lSgknRARJ2StExG7ZPz9vZI2jIi7JW0IdDQQUkScBpwGyR1FJ+9lBu4or5Gyi+OcnMemm0VuY6rMrjO/w+3OBg5OXx8M/KTD9zMrVNVba/VC2Vf8Vakotmdq644iIn7a4XZnAudJei9wJ7A/gKQR4PCIeF86PRfYHFhH0iLgvRExp8Ntm+XijvJWVfYVf1Uqiu2ZmlZmSzoVGtbnARARR5QVVCeGrTJ7UPudserph5EZrX3tVmbXzrY7AFsA56bTbycZk8J6bFj7nbHe8BX/8MozZvbVwI4RsTKdHg/MjYjtuxDfmA3THYWbE5pZUTptHvscYD3g/nR6nXSe9ZibE7bPRXY2SMo+nvMkipnAAklXkjxv9DrghMIisLa5OWF7XGRng6Qbx3PL5rERcSbwKuDHwCzg1RFxViFbt464OWF7qtRVtFmnunE8Zw1ctHlE3CRp23TWXenvyemgRtcWFoW1pcqVi1Uu2nGRXW9U+ZjoZ904nrOKnj5K0i3GFxosC8C1pRVQxbb+VS/acZFd91X9mOhn3TieswYuOiz9/YYGP04S1lTVi3ZcZNd9VT8m+lk3jueWldmS3g78LCIeknQssC3w6YhYUFgUNlDy3gr3qiiiykV2g8rFfeXpxvGcp9XTf0fE+ZJ2BHYhGUzomyQV3GbPkOdWuNdFEVUsshtkLu4rV9nHc55OAWv3i3sCp0XEJcAapUVkfS/PrbCLIoaLi/v6W547isWSvgXsCpwkaU3a73XWhkCeW2EXRQwXF/f1tzyJYn9gd+DzEbEsHT/iqHLDsn7X6lbYRRHDx8V9/SvPA3ePkgwstGM6ayVwS5lB2eBzUYRZ/8jT6ul4YATYDDgTGA/8gKRXWbO2uCjCrH/kKXraD5gOXAsQEUskrVtqVDYUXBRh1h/yVEo/Hklf5AEgae1yQzIzsyrJkyjOS1s9TZR0KPAL4NvlhmVmZlWRWfQkSSQj220O/JOknuK4iLisC7GZmVkFZCaKiAhJl0bEVoCTg5nZEMpT9HStpFeWHomZmVVSnlZPrwIOknQn8AjJKHcREVuXGpmZmVVCnkSxW+lRmJlZZbVMFBFxZ9EblfRckkryqcAdwP4R8cCodbYBvgGsR9Ix4Wcj4tyiYzEzs2y96txvBnB5REwDLk+nR3sUeHdEbEnS19SXJU3sYoxmZkbvEsU+wFnp67OAfUevEBF/iYhb0tdLSPqbmtS1CM3MDOhdotggIu5OX98DbJC1sqTtSMbA+GuT5YdJmidp3tKlS4uN1MxsyOWpzG6LpF8AL2iw6JP1E+mzGpHxPhsC3wcOjognG60TEacBpwGMjIw0fS8zMxu70hJFROzSbJmkeyVtGBF3p4ngvibrrQdcAnwyIq4uKdRn6NVYzmZmVdSroqfZwMHp64OBn4xeQdIawI+B70XEBd0KrDaW8+JlywmeHsv5ogWLuxWCmVml9CpRzAR2lXQLsEs6jaQRSaen6+wPvA44RNJ16c82ZQfmsZzNzFZVWtFTloj4B/DGBvPnAe9LX/+AZICkrvJYzmZmq+rVHUVlNRuz2WM5m9mwcqIYxWM5m5mtqidFT1XmsZytEbeEs2HmRNGAx3K2erWWcLVGDrWWcICPExsKLnoya8Et4WzYOVGYteCWcDbsnCjMWnBLOBt2ThRmLbglnA07V2abteCWcDbsnCjMcnBLOBtmLnoyM7NMThRmZpbJicLMzDI5UZiZWSYnCjMzy6SIwRpiWtJS4M4O3mJ94O8FhdNPvN/Dxfs9XPLs9wsjYlKjBQOXKDolaV5EjPQ6jm7zfg8X7/dw6XS/XfRkZmaZnCjMzCyTE8UzndbrAHrE+z1cvN/DpaP9dh2FmZll8h2FmZllcqIwM7NMThQpSbtLulnSrZJm9DqeskjaWNKVkm6UdIOkI9P5z5V0maRb0t/P6XWsZZA0TtICSRen05tK+n36uZ8raY1ex1g0SRMlXSDpJkl/lvTqIfq8P5Ie53+SdLaktQbxM5d0hqT7JP2pbl7Dz1iJU9L9v17Stq3e34mC5OQBfA3YA9gCeIekLXobVWlWAh+LiC2A7YEPpPs6A7g8IqYBl6fTg+hI4M910ycBX4qIlwAPAO/tSVTl+grws4jYHHg5yf4P/OctaQpwBDASES8DxgEHMpif+XeB3UfNa/YZ7wFMS38OA77R6s2dKBLbAbdGxG0R8ThwDrBPj2MqRUTcHRHXpq8fIjlpTCHZ37PS1c4C9u1NhOWRtBGwJ3B6Oi1gZ+CCdJWB229JzwZeB3wHICIej4hlDMHnnVodmCBpdeBZwN0M4GceEb8G7h81u9lnvA/wvUhcDUyUtGHW+ztRJKYAd9VNL0rnDTRJU4HpwO+BDSLi7nTRPcAGPQqrTF8G/i/wZDr9PGBZRKxMpwfxc98UWAqcmRa5nS5pbYbg846IxcDngb+RJIgHgfkM/mde0+wzHvP5zoliSElaB7gQ+HBE/LN+WSRtpgeq3bSktwD3RcT8XsfSZasD2wLfiIjpwCOMKmYaxM8bIC2T34ckWU4G1uaZxTNDodPP2IkisRjYuG56o3TeQJI0niRJ/DAiZqWz763dfqa/7+tVfCXZAdhb0h0kRYs7k5TdT0yLJWAwP/dFwKKI+H06fQFJ4hj0zxtgF+D2iFgaESuAWSTHwaB/5jXNPuMxn++cKBLXANPS1hBrkFR4ze5xTKVIy+W/A/w5Ir5Yt2g2cHD6+mDgJ92OrUwRcUxEbBQRU0k+3ysi4iDgSuDf09UGcb/vAe6StFk6643AjQz45536G7C9pGelx31t3wf6M6/T7DOeDbw7bf20PfBgXRFVQ34yOyXpzSRl2OOAMyLisz0OqRSSdgTmAgt5uqz+EyT1FOcBm5B0075/RIyuHBsIknYCPh4Rb5H0IpI7jOcCC4B3RcRjvYyvaJK2IanAXwO4DXgPyUXiwH/ekj4FHEDS2m8B8D6S8viB+swlnQ3sRNKd+L3A8cBFNPiM06T5VZJiuEeB90TEvMz3d6IwM7MsLnoyM7NMThRmZpbJicLMzDI5UZiZWSYnCjMzy+REYZUn6XmSrkt/7pG0uG66Zc+fknaS9Jomyw6RtDTt3uIWSXOarTvq7/Yda8eRddu6Lu3J9SNj+fsc7/9LSSNj/JuHi4zBBpMThVVeRPwjIraJiG2Ab5L0/LlN+vN4jrfYCcg6+Z8bEdPTXjZnArMkvbTFe+5L0tPwWJ2b7scOwCclbdzqD8x6zYnC+pKkV0j6laT56V1ArauCI5SMtXG9pHPSjg8PBz6SXsm/Nut9I+JKkvGFD0vf71BJ10j6o6QL06d8XwPsDZycvueLG63XYjv/AG4FanF/VMmYCX+S9OF03lGSjkhff0nSFenrnSX9sMX/52FJn03juVrSBun8TSX9TtJCSZ8Z9TdHpftwffqgGpL2k3R5+hTvhpL+IukFWdu2weNEYf1IwKnAv0fEK4AzgNqT9DOA6RGxNXB4RNzBqnchc3O8/7XA5unrWRHxyoiojePw3oj4LUk3CEel7/nXRutl7oC0CbAWcL2kV5A8Lf0qkjFCDpU0neQJ+lpiGwHWSfvpei3w6xb7sDZwdRrPr4FD0/lfIekgcCuSHlVr8byJZHyC7YBtgFdIel1E/Dhd7wPAt4Hj025BbIg4UVg/WhN4GXCZpOuAY0k6NgO4HvihpHeRdNvQDtW9fpmkuZIWAgcBWzb5m7zrHSDpepK7ia9HxL+AHYEfR8QjEfEwSed1ryXpEvsVktYDHgN+R5IwXkuSRLI8Dlycvp4PTE1f7wCcnb7+ft36b0p/FvB0opyWLvsQcAzwWEScjQ2d1VuvYlY5Am6IiFc3WLYnyUA9e5HUAWzVxvtP5+lR8L4L7BsRf5R0CEl9RyN51zs3Ij6YVjr/XFLTzicjYoWk24FDgN+SJME3AC9h1VH6GlkRT/fP8wSrftcb9dsj4HMR8a0GyzYi6RdsA0mrRcSTDdaxAeY7CutHjwGTJL0akm7TJW0paTVg47Se4Wjg2cA6wEPAunneWNLrSeonvp3OWhe4Oy3yOahu1dHv2Wy9htJO2L5PMjTrXGDftP5jbWA/nr5jmAt8nKT4aC5JfcuCuiQwVleR9J7LqDjnAP+pZJwSJE2R9Hwl3XGfAbyDJDl9tM3tWh9zorB+9CRJN9EnSfojcB1Jq6ZxwA/S4p8FwCnpsJ8/BfbLqMw+IF32F5KedN8WEbUr9v8m6Vn3KuCmur85BzgqbVb74oz1spxEUjdxC8kdyR/S9zg9Ihak68wlqfD+XUTcC/yL1sVOWY4kGSd9IXWjmkXEz4EfAb9Ll11Akvw+AcyNiN+QJIn35WgRZgPGvceamVkm31GYmVkmJwozM8vkRGFmZpmcKMzMLJMThZmZZXKiMDOzTE4UZmaW6f8DK005vJaw8vQAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - } + "plt.show()\n" ] }, { "cell_type": "markdown", "metadata": { - "id": "8VE-arrmbLNL", - "colab_type": "text" + "id": "8VE-arrmbLNL" }, "source": [ + "*Evaluation summary:* The model achieves a test MSE of approximately 10%. The residual plots provide insights into the model's error distribution.\n", + "\n", "How well does your model perform? We were able to achieve an MSE for the test set of approximately 10% points from the observed obesity prevalence. Our model was also able to fit the data with the residuals clustered between -20% and 30%, which for a simple model considering only three explanatory variables isn't so bad." ] }, { "cell_type": "markdown", "metadata": { - "id": "qapl33x8fy_A", - "colab_type": "text" + "id": "qapl33x8fy_A" }, "source": [ - "## Conclusion\n", + "## 7. Conclusion and next steps\n", + "This notebook demonstrated the use of Data Commons to efficiently acquire data from multiple sources (CDC, BLS, Census) and build a simple linear regression model to predict obesity prevalence in US counties. Data Commons significantly streamlines the data gathering and integration process.\n", "\n", - "Congratulations! Rather than spending a couple of hours just searching for and joining datasets from the CDC, Bureau of Labor Statistics, and US Census Bureau, you've spent one lab session querying Data Commons for the same data and, on top of that, used it to build a basic model to predict the prevalence of obesity in approximately 500 cities using intuition from a long line of research. Hopefully Data Commons has made the time-to-analysis much shorter!\n", + "The resulting model, using high blood pressure prevalence, unemployment rate, and poverty rate, provides a baseline prediction.\n", "\n", - "The model you've created only uses three explanatory variables, so even though it's not the most accurate at predicting obesity prevalence, it's possible that it can be improved by adding more variables. Obesity is also known to correlate with factors such as [high cholesterol](https://browser.datacommons.org/kg?dcid=dc/p/ybn085073e7z6) and [diabetes](https://browser.datacommons.org/kg?dcid=dc%2Fp%2Fkk03bc7vvm3s3), but with the accessibility of Data Commons, we can even consider asking if obesity correlates with less obvious factors such as\n", + "**Potential improvements & further exploration:**\n", "\n", - "- How many [universities recognized](https://browser.datacommons.org/kg?dcid=ipedsId/148487) by [College Scorecard](https://collegescorecard.ed.gov/data/) dataset are contained in a given city\n", - "- The [incidence rate of arsony](https://browser.datacommons.org/kg?dcid=dc/p/m3m7t6w2snwgh)\n", - "- The average snowfall in inches\n", - "\n", - "Does adding these variables into your model improve accuracy? Can you think of other variables that correlate with obesity? " + "* Add More Variables: Incorporate other variables known or hypothesized to correlate with obesity, such as:\n", + " * `Percent_Person_WithHighCholesterol`\n", + " * `Percent_Person_WithDiabetes`\n", + " * Educational attainment levels\n", + " * Access to healthy food outlets\n", + " * Physical inactivity rates\n", + "* **Feature engineering:** Create new features from existing ones.\n", + "* **Model selection:** Experiment with different regression models (e.g., Ridge, Lasso, tree-based models).\n", + "* **Geographic analysis:** Explore spatial patterns in obesity prevalence and model errors.\n", + "* **Alternative data sources:** Compare model performance using Census unemployment data instead of BLS data.\n", + "Data Commons provides access to a wide range of variables, enabling exploration of correlations with factors like university counts, crime rates (e.g., arson), or environmental factors (e.g., snowfall), potentially leading to more comprehensive models." ] } - ] -} \ No newline at end of file + ], + "metadata": { + "colab": { + "include_colab_link": true, + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/notebooks/intro_data_science/Classification_and_Model_Evaluation.ipynb b/notebooks/intro_data_science/Classification_and_Model_Evaluation.ipynb new file mode 100644 index 00000000..b3369019 --- /dev/null +++ b/notebooks/intro_data_science/Classification_and_Model_Evaluation.ipynb @@ -0,0 +1,3071 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "view-in-github" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vTbNks0XH5xW" + }, + "source": [ + "Copyright 2025 Google LLC.\n", + "SPDX-License-Identifier: Apache-2.0" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "go4bM4R_LeId" + }, + "source": [ + "# Classification and Model Evaluation\n", + "\n", + "So you've built a machine learning model, or perhaps multiple models... now what? How do you know if those models are any good? And if you have multiple candidate models, how should you choose which one to utimately deploy?\n", + "\n", + "The answer: model evaluation. Understanding how to evaluate your models is an essential skill not just to check how well your models perform, but also to diagnose issues and find areas for improvement. Most importantly, we need to understand whether or not we can trust our model's predictions.\n", + "\n", + "## Learning objectives\n", + "In this lesson, we'll be covering:\n", + "\n", + "* Model selection\n", + "* Generalization and overfitting\n", + "* Train/test splits\n", + "* Cross validation\n", + "* Statistical evaluation metrics:\n", + "* How do we know a model is \"good\"?\n", + "* Tradeoffs between evaluation metrics\n", + "\n", + "---\n", + "**Need extra help?**\n", + "\n", + "If you're new to Google Colab, take a look at this getting started [tutorial](https://colab.research.google.com/notebooks/intro.ipynb).\n", + "\n", + "To build more familiarity with the Data Commons API, check out these [Data Commons tutorials](https://docs.datacommons.org/api/python/v2/tutorials/).\n", + "\n", + "And for help with Pandas and manipulating data frames, take a look at the [Pandas documentation](https://pandas.pydata.org/docs/reference/index.html).\n", + "\n", + "We'll be using the scikit-learn library for implementing our models today. You can find documentation [here](https://scikit-learn.org/stable/modules/classes.html).\n", + "\n", + "As usual, if you have any other questions, please reach out to your course staff!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "umu23IaLzlMJ" + }, + "source": [ + "## 0) Introduction and setup\n", + "\n", + "The [obesity epidemic in the United States](https://en.wikipedia.org/wiki/Obesity_in_the_United_States) is a major public health issue. Obesity rates vary across the nation by geographic location. In this Colab, we'll be exploring how obesity rates vary with different health or societal factors across US cities.\n", + "\n", + "**Our data science question:** Can we predict which cities have high (>30%) or low (<30%) obesity rates based on other health or lifestyle factors?\n", + "\n", + "### Install Data Commons API\n", + "\n", + "We need to install the Data Commons API, since it doesn't ship natively with most Python installations.\n", + "\n", + "In Colab, we'll be installing the Data Commons Python and Pandas APIs through pip." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "UpW0UwpG0ytY", + "outputId": "b9f7aaa6-f704-4926-bebb-929b49b89f29" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/66.3 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━\u001b[0m \u001b[32m61.4/66.3 kB\u001b[0m \u001b[31m3.6 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m66.3/66.3 kB\u001b[0m \u001b[31m1.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h" + ] + } + ], + "source": [ + "!pip install \"datacommons-client[Pandas]\" --upgrade --quiet" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "udVhgaJehgPp" + }, + "source": [ + "Let's load all the libraries we need for this assignment and create a Data Commons client, using the trial key. If you plan to continue to use the Data Commons API, you should [obtain your own key](https://docs.datacommons.org/api/#obtain-an-api-key)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "vdh_OcdOIYGD" + }, + "outputs": [], + "source": [ + "# Data Commons Python API using trial key\n", + "from datacommons_client.client import DataCommonsClient\n", + "client = DataCommonsClient(api_key=\"AIzaSyCTI4Xz-UW_G2Q2RfknhcfdAnTHq5X5XuI\")\n", + "\n", + "# For manipulating data\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "# For implementing models and evaluation methods\n", + "from sklearn import linear_model, svm, tree\n", + "from sklearn.metrics import mean_squared_error\n", + "from sklearn.model_selection import train_test_split, cross_val_score\n", + "from sklearn.preprocessing import StandardScaler\n", + "\n", + "# For plotting\n", + "from matplotlib import pyplot as plt\n", + "from mlxtend.plotting import plot_decision_regions, category_scatter" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JYLCmVag2YxO" + }, + "source": [ + "### Load the data\n", + "\n", + "We'll query data using the Data Commons API, storing it in a Pandas DataFrame. To demonstrate the concepts with a more reasonably sized dataset, we'll first analyze the 500 largest cities by population. To do that:\n", + "* We use the statistical variable `Count_Person`.\n", + "* We use the [`observation.fetch_observations_by_entity_type()`](https://docs.datacommons.org/api/python/v2/observation.html#fetch_observations_by_entity_type) method to query cities with the parent USA.\n", + "* We use the `filter_facet_ids` parameter of the method to restrict results to a single data source." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ahmaNIig4Vzv" + }, + "outputs": [], + "source": [ + "# Fetch the population of the US cities\n", + "city_pop = client.observation.fetch_observations_by_entity_type(\n", + " date=\"latest\",\n", + " parent_entity=\"country/USA\",\n", + " entity_type=\"City\",\n", + " variable_dcids=\"Count_Person\",\n", + " filter_facet_ids=\"2176550201\" # USCensusPEP_Annual_Population\n", + ").byVariable[\"Count_Person\"].byEntity\n", + "city_pop_dict = {\n", + " city: data[\"orderedFacets\"][0].observations[0].value\n", + " for city, data in city_pop.items()\n", + " }\n", + "\n", + "# Filter to the top 500 cities\n", + "cities = [\n", + " item[0]\n", + " for item in sorted(\n", + " city_pop_dict.items(),\n", + " key=lambda item: item[1],\n", + " reverse=True)[:500]\n", + " ]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qrxyqf_WCvYB" + }, + "source": [ + "Now we'll compile a list of some Data Commons statistical variables related to obesity, that we'll use as features, and we'll use the [`observations_dataframe()`](https://docs.datacommons.org/api/python/v2/pandas.html) method to query for the latest data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 704 + }, + "collapsed": true, + "id": "iiudLKaxEEen", + "outputId": "87b1b429-82b4-4db6-c7d1-e97b852a31c5" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"raw_features_df\",\n \"rows\": 18198,\n \"fields\": [\n {\n \"column\": \"date\",\n \"properties\": {\n \"dtype\": \"object\",\n \"num_unique_values\": 18,\n \"samples\": [\n \"2023\",\n \"2020\",\n \"2000\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"entity\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 500,\n \"samples\": [\n \"geoId/2509000\",\n \"geoId/0629000\",\n \"geoId/0809280\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"entity_name\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 476,\n \"samples\": [\n \"Wilmington\",\n \"Stockton\",\n \"Oxnard\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"variable\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 10,\n \"samples\": [\n \"Percent_Person_WithMentalHealthNotGood\",\n \"Median_Income_Person\",\n \"Percent_Person_PhysicalInactivity\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"variable_name\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 10,\n \"samples\": [\n \"Percentage of Adult Population With Poor Mental Health\",\n \"Median Income of a Population\",\n \"Percentage of Adult Population Who Are Physically Inactive\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"value\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1255622.6881860355,\n \"min\": 8.8,\n \"max\": 136531190.0,\n \"num_unique_values\": 5697,\n \"samples\": [\n 109419.0,\n 101860.0,\n 107584.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"facetId\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 19,\n \"samples\": [\n \"2176550201\",\n \"1226172227\",\n \"1704193675\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"importName\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 14,\n \"samples\": [\n \"CensusACS5YearSurvey_SubjectTables_S0701\",\n \"CensusACS5YearSurvey_HealthInsurance_StatVarAgg\",\n \"USCensusPEP_Annual_Population\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"measurementMethod\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 8,\n \"samples\": [\n \"CensusACS5yrSurvey\",\n \"CensusACS1yrSurvey\",\n \"CensusPEPSurvey\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"observationPeriod\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"P1Y\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"provenanceUrl\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 13,\n \"samples\": [\n \"https://data.census.gov/cedsci/table?q=S2702&tid=ACSST5Y2019.S2702\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"unit\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"USDollar\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe", + "variable_name": "raw_features_df" + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
dateentityentity_namevariablevariable_namevaluefacetIdimportNamemeasurementMethodobservationPeriodprovenanceUrlunit
02023geoId/0454050PeoriaCount_PersonTotal Population198750.02176550201USCensusPEP_Annual_PopulationCensusPEPSurveyP1Yhttps://www2.census.gov/programs-surveys/popes...None
12023geoId/0454050PeoriaCount_PersonTotal Population194338.01145703171CensusACS5YearSurveyCensusACS5yrSurveyNonehttps://www.census.gov/programs-surveys/acs/da...None
22020geoId/0454050PeoriaCount_PersonTotal Population190985.01541763368USDecennialCensus_RedistrictingReleaseUSDecennialCensusNonehttps://www.census.gov/programs-surveys/decenn...None
32023geoId/0454050PeoriaCount_PersonTotal Population198750.01794369807UNDataUNDataNonehttps://data.un.org/Data.aspx?q=city+populatio...None
42021geoId/0454050PeoriaCount_PersonTotal Population187733.01964317807CensusACS5YearSurvey_SubjectTables_S0101CensusACS5yrSurveySubjectTableNonehttps://data.census.gov/table?q=S0101:+Age+and...None
.......................................
181932017geoId/3268400SparksPercent_Person_WithHighCholesterolPercent of Adult Population With High Cholesterol33.21237405506CDC500CrudePrevalenceP1Yhttps://www.cdc.gov/places/index.htmlNone
181942021geoId/2836000JacksonPercent_Person_WithHighCholesterolPercent of Adult Population With High Cholesterol30.6276985032CDC500AgeAdjustedPrevalenceP1Yhttps://www.cdc.gov/places/index.htmlPercent
181952017geoId/2836000JacksonPercent_Person_WithHighCholesterolPercent of Adult Population With High Cholesterol32.92329020768CDC500AgeAdjustedPrevalenceP1Yhttps://www.cdc.gov/places/index.htmlNone
181962021geoId/2836000JacksonPercent_Person_WithHighCholesterolPercent of Adult Population With High Cholesterol34.02219109638CDC500CrudePrevalenceP1Yhttps://www.cdc.gov/places/index.htmlPercent
181972017geoId/2836000JacksonPercent_Person_WithHighCholesterolPercent of Adult Population With High Cholesterol34.21237405506CDC500CrudePrevalenceP1Yhttps://www.cdc.gov/places/index.htmlNone
\n", + "

18198 rows × 12 columns

\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + " date entity entity_name variable \\\n", + "0 2023 geoId/0454050 Peoria Count_Person \n", + "1 2023 geoId/0454050 Peoria Count_Person \n", + "2 2020 geoId/0454050 Peoria Count_Person \n", + "3 2023 geoId/0454050 Peoria Count_Person \n", + "4 2021 geoId/0454050 Peoria Count_Person \n", + "... ... ... ... ... \n", + "18193 2017 geoId/3268400 Sparks Percent_Person_WithHighCholesterol \n", + "18194 2021 geoId/2836000 Jackson Percent_Person_WithHighCholesterol \n", + "18195 2017 geoId/2836000 Jackson Percent_Person_WithHighCholesterol \n", + "18196 2021 geoId/2836000 Jackson Percent_Person_WithHighCholesterol \n", + "18197 2017 geoId/2836000 Jackson Percent_Person_WithHighCholesterol \n", + "\n", + " variable_name value \\\n", + "0 Total Population 198750.0 \n", + "1 Total Population 194338.0 \n", + "2 Total Population 190985.0 \n", + "3 Total Population 198750.0 \n", + "4 Total Population 187733.0 \n", + "... ... ... \n", + "18193 Percent of Adult Population With High Cholesterol 33.2 \n", + "18194 Percent of Adult Population With High Cholesterol 30.6 \n", + "18195 Percent of Adult Population With High Cholesterol 32.9 \n", + "18196 Percent of Adult Population With High Cholesterol 34.0 \n", + "18197 Percent of Adult Population With High Cholesterol 34.2 \n", + "\n", + " facetId importName \\\n", + "0 2176550201 USCensusPEP_Annual_Population \n", + "1 1145703171 CensusACS5YearSurvey \n", + "2 1541763368 USDecennialCensus_RedistrictingRelease \n", + "3 1794369807 UNData \n", + "4 1964317807 CensusACS5YearSurvey_SubjectTables_S0101 \n", + "... ... ... \n", + "18193 1237405506 CDC500 \n", + "18194 276985032 CDC500 \n", + "18195 2329020768 CDC500 \n", + "18196 2219109638 CDC500 \n", + "18197 1237405506 CDC500 \n", + "\n", + " measurementMethod observationPeriod \\\n", + "0 CensusPEPSurvey P1Y \n", + "1 CensusACS5yrSurvey None \n", + "2 USDecennialCensus None \n", + "3 UNData None \n", + "4 CensusACS5yrSurveySubjectTable None \n", + "... ... ... \n", + "18193 CrudePrevalence P1Y \n", + "18194 AgeAdjustedPrevalence P1Y \n", + "18195 AgeAdjustedPrevalence P1Y \n", + "18196 CrudePrevalence P1Y \n", + "18197 CrudePrevalence P1Y \n", + "\n", + " provenanceUrl unit \n", + "0 https://www2.census.gov/programs-surveys/popes... None \n", + "1 https://www.census.gov/programs-surveys/acs/da... None \n", + "2 https://www.census.gov/programs-surveys/decenn... None \n", + "3 https://data.un.org/Data.aspx?q=city+populatio... None \n", + "4 https://data.census.gov/table?q=S0101:+Age+and... None \n", + "... ... ... \n", + "18193 https://www.cdc.gov/places/index.html None \n", + "18194 https://www.cdc.gov/places/index.html Percent \n", + "18195 https://www.cdc.gov/places/index.html None \n", + "18196 https://www.cdc.gov/places/index.html Percent \n", + "18197 https://www.cdc.gov/places/index.html None \n", + "\n", + "[18198 rows x 12 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "stat_vars_to_query = [\n", + " \"Count_Person\",\n", + " \"Median_Income_Person\",\n", + " \"Count_Person_NoHealthInsurance\",\n", + " \"Percent_Person_PhysicalInactivity\",\n", + " \"Percent_Person_SleepLessThan7Hours\",\n", + " \"dc/e9gftzl2hm8h9\", # Commute Time, this has a weird DCID\n", + " \"Percent_Person_WithHighBloodPressure\",\n", + " \"Percent_Person_WithMentalHealthNotGood\",\n", + " \"Percent_Person_WithHighCholesterol\",\n", + " \"Percent_Person_Obesity\"\n", + "\n", + "]\n", + "\n", + "# Query Data Commons for the data and display the data\n", + "raw_features_df = client.observations_dataframe(\n", + " variable_dcids=stat_vars_to_query,\n", + " date=\"latest\",\n", + " entity_dcids=cities)\n", + "display(raw_features_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bKzqKCCcEuFO" + }, + "source": [ + "We've succesfully loaded our data, but there are still a couple preprocessing steps to go through first. Specifically, we're going to:\n", + "\n", + "1. Filter rows to the highest ranked facet for each city and variable.\n", + "\n", + "2. Select required columns and pivot by variable.\n", + "\n", + "3. Change the row labels from DCIDs to names for readability.\n", + "\n", + "4. Change the column name \"`dc/e9gftzl2hm8h9`\" to the more human readable \"`Commute_Time`\"\n", + "\n", + "5. The raw commute time values from Data Commons show the total amount of minutes spent for everyone in the city. Let's instead look at the average commute time for a single person, which we'll get by dividing the raw commute time (`Commute_Time`) by population size (`Count_Person`)\n", + "\n", + "6. Similarly, we'll get a `Percent_NoHealthInsurance` by dividing the the count of people without health insurance (`Count_Person_NoHealthInsurance`) by population size.\n", + "\n", + "7. To perform classification, we need to convert our obesity rate data into labels. In this lesson, we'll look at binary classification, and will split our cities into \"Low obesity rate\" (label 0, obesity% < 30%) and \"High obesity rate\" (label 1, obesity% >= 30%) categories.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 475 + }, + "collapsed": true, + "id": "GxXQ3Kw3FB6H", + "outputId": "d3035c3f-e895-4a97-8e89-847c798bd6ef" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"df\",\n \"rows\": 497,\n \"fields\": [\n {\n \"column\": \"City\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 474,\n \"samples\": [\n \"Tyler\",\n \"West Jordan\",\n \"Avondale\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"DCID\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 497,\n \"samples\": [\n \"geoId/5353545\",\n \"geoId/0639892\",\n \"geoId/1714351\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 472102.4945555199,\n \"min\": 76212.0,\n \"max\": 8258035.0,\n \"num_unique_values\": 497,\n \"samples\": [\n 80038.0,\n 78135.0,\n 81004.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person_NoHealthInsurance\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 47525.88545625916,\n \"min\": 1271.0,\n \"max\": 547513.0,\n \"num_unique_values\": 484,\n \"samples\": [\n 17301.0,\n 11710.0,\n 10310.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Median_Income_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 12090.230240671903,\n \"min\": 16408.0,\n \"max\": 99872.0,\n \"num_unique_values\": 486,\n \"samples\": [\n 57306.0,\n 33684.0,\n 56045.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_Obesity\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 6.366575765664315,\n \"min\": 14.1,\n \"max\": 48.9,\n \"num_unique_values\": 220,\n \"samples\": [\n 33.4,\n 41.6,\n 23.2\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_PhysicalInactivity\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 5.796178720119461,\n \"min\": 11.2,\n \"max\": 41.8,\n \"num_unique_values\": 209,\n \"samples\": [\n 25.0,\n 39.5,\n 18.4\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_SleepLessThan7Hours\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 4.331395564726455,\n \"min\": 24.9,\n \"max\": 49.5,\n \"num_unique_values\": 166,\n \"samples\": [\n 42.5,\n 25.6,\n 28.4\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithHighBloodPressure\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 4.555496704057517,\n \"min\": 21.3,\n \"max\": 45.7,\n \"num_unique_values\": 169,\n \"samples\": [\n 40.3,\n 25.6,\n 41.2\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithHighCholesterol\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2.088786698728499,\n \"min\": 24.6,\n \"max\": 35.6,\n \"num_unique_values\": 95,\n \"samples\": [\n 25.9,\n 34.1,\n 27.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithMentalHealthNotGood\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2.103505046709983,\n \"min\": 11.5,\n \"max\": 23.3,\n \"num_unique_values\": 103,\n \"samples\": [\n 15.8,\n 16.3,\n 12.7\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Commute_Time\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2.167510478400184,\n \"min\": 5.878913346975463,\n \"max\": 17.91734986677598,\n \"num_unique_values\": 497,\n \"samples\": [\n 8.914265723781204,\n 13.057720611761695,\n 13.66080687373463\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_NoHealthInsurance\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.04826228073064541,\n \"min\": 0.014375388791494656,\n \"max\": 0.2985449570948887,\n \"num_unique_values\": 497,\n \"samples\": [\n 0.11825632824408407,\n 0.05055352914826902,\n 0.19500271591526344\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Label\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 0,\n \"max\": 1,\n \"num_unique_values\": 2,\n \"samples\": [\n 0,\n 1\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe", + "variable_name": "df" + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
variableDCIDCount_PersonCount_Person_NoHealthInsuranceMedian_Income_PersonPercent_Person_ObesityPercent_Person_PhysicalInactivityPercent_Person_SleepLessThan7HoursPercent_Person_WithHighBloodPressurePercent_Person_WithHighCholesterolPercent_Person_WithMentalHealthNotGoodCommute_TimePercent_NoHealthInsuranceLabel
City
AuburngeoId/010307682025.05150.029495.033.023.636.034.330.617.87.5978670.0627861
BirminghamgeoId/0107000196644.024564.028054.044.932.942.945.031.619.78.9065520.1249161
HoovergeoId/013589692448.04536.053074.032.519.733.632.631.015.411.1124630.0490651
HuntsvillegeoId/0137000225564.020180.038349.037.524.040.036.531.618.08.0028280.0894651
MobilegeoId/0150000182595.019147.031028.044.228.743.439.832.519.99.4071030.1048601
..........................................
Green BaygeoId/5531000105744.08922.036818.038.926.733.128.130.717.98.7492430.0843741
KenoshageoId/553922598211.06628.038433.043.723.836.629.930.018.611.0234090.0674871
MadisongeoId/5548000280305.011798.044398.032.118.729.926.628.515.68.9799860.0420901
MilwaukeegeoId/5553000561385.051731.032247.043.428.840.036.730.119.09.2078700.0921491
RacinegeoId/556600076602.06180.034600.042.928.239.232.332.018.49.5068010.0806771
\n", + "

497 rows × 13 columns

\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + "variable DCID Count_Person Count_Person_NoHealthInsurance \\\n", + "City \n", + "Auburn geoId/0103076 82025.0 5150.0 \n", + "Birmingham geoId/0107000 196644.0 24564.0 \n", + "Hoover geoId/0135896 92448.0 4536.0 \n", + "Huntsville geoId/0137000 225564.0 20180.0 \n", + "Mobile geoId/0150000 182595.0 19147.0 \n", + "... ... ... ... \n", + "Green Bay geoId/5531000 105744.0 8922.0 \n", + "Kenosha geoId/5539225 98211.0 6628.0 \n", + "Madison geoId/5548000 280305.0 11798.0 \n", + "Milwaukee geoId/5553000 561385.0 51731.0 \n", + "Racine geoId/5566000 76602.0 6180.0 \n", + "\n", + "variable Median_Income_Person Percent_Person_Obesity \\\n", + "City \n", + "Auburn 29495.0 33.0 \n", + "Birmingham 28054.0 44.9 \n", + "Hoover 53074.0 32.5 \n", + "Huntsville 38349.0 37.5 \n", + "Mobile 31028.0 44.2 \n", + "... ... ... \n", + "Green Bay 36818.0 38.9 \n", + "Kenosha 38433.0 43.7 \n", + "Madison 44398.0 32.1 \n", + "Milwaukee 32247.0 43.4 \n", + "Racine 34600.0 42.9 \n", + "\n", + "variable Percent_Person_PhysicalInactivity \\\n", + "City \n", + "Auburn 23.6 \n", + "Birmingham 32.9 \n", + "Hoover 19.7 \n", + "Huntsville 24.0 \n", + "Mobile 28.7 \n", + "... ... \n", + "Green Bay 26.7 \n", + "Kenosha 23.8 \n", + "Madison 18.7 \n", + "Milwaukee 28.8 \n", + "Racine 28.2 \n", + "\n", + "variable Percent_Person_SleepLessThan7Hours \\\n", + "City \n", + "Auburn 36.0 \n", + "Birmingham 42.9 \n", + "Hoover 33.6 \n", + "Huntsville 40.0 \n", + "Mobile 43.4 \n", + "... ... \n", + "Green Bay 33.1 \n", + "Kenosha 36.6 \n", + "Madison 29.9 \n", + "Milwaukee 40.0 \n", + "Racine 39.2 \n", + "\n", + "variable Percent_Person_WithHighBloodPressure \\\n", + "City \n", + "Auburn 34.3 \n", + "Birmingham 45.0 \n", + "Hoover 32.6 \n", + "Huntsville 36.5 \n", + "Mobile 39.8 \n", + "... ... \n", + "Green Bay 28.1 \n", + "Kenosha 29.9 \n", + "Madison 26.6 \n", + "Milwaukee 36.7 \n", + "Racine 32.3 \n", + "\n", + "variable Percent_Person_WithHighCholesterol \\\n", + "City \n", + "Auburn 30.6 \n", + "Birmingham 31.6 \n", + "Hoover 31.0 \n", + "Huntsville 31.6 \n", + "Mobile 32.5 \n", + "... ... \n", + "Green Bay 30.7 \n", + "Kenosha 30.0 \n", + "Madison 28.5 \n", + "Milwaukee 30.1 \n", + "Racine 32.0 \n", + "\n", + "variable Percent_Person_WithMentalHealthNotGood Commute_Time \\\n", + "City \n", + "Auburn 17.8 7.597867 \n", + "Birmingham 19.7 8.906552 \n", + "Hoover 15.4 11.112463 \n", + "Huntsville 18.0 8.002828 \n", + "Mobile 19.9 9.407103 \n", + "... ... ... \n", + "Green Bay 17.9 8.749243 \n", + "Kenosha 18.6 11.023409 \n", + "Madison 15.6 8.979986 \n", + "Milwaukee 19.0 9.207870 \n", + "Racine 18.4 9.506801 \n", + "\n", + "variable Percent_NoHealthInsurance Label \n", + "City \n", + "Auburn 0.062786 1 \n", + "Birmingham 0.124916 1 \n", + "Hoover 0.049065 1 \n", + "Huntsville 0.089465 1 \n", + "Mobile 0.104860 1 \n", + "... ... ... \n", + "Green Bay 0.084374 1 \n", + "Kenosha 0.067487 1 \n", + "Madison 0.042090 1 \n", + "Milwaukee 0.092149 1 \n", + "Racine 0.080677 1 \n", + "\n", + "[497 rows x 13 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Filter to highest ranked facet for each entity and variable\n", + "df = raw_features_df.copy(deep=True)\n", + "df = df.groupby([\"entity\", \"entity_name\", \"variable\"]).first().reset_index()\n", + "\n", + "# Select required columns and pivot by variable\n", + "df = df[[\"entity\", \"entity_name\", \"variable\", \"value\"]]\n", + "df = df.pivot(index=[\"entity\", \"entity_name\"], columns=\"variable\", values=\"value\")\n", + "df = df.dropna()\n", + "\n", + "# Make row names more readable\n", + "df = df.reset_index()\n", + "df.rename(columns={\"entity\":\"DCID\", \"entity_name\": \"City\"}, inplace=True)\n", + "df.set_index(\"City\", inplace=True)\n", + "\n", + "# Rename variable \"dc/e9gftzl2hm8h9\" to \"Commute_Time\"\n", + "df.rename(columns={\"dc/e9gftzl2hm8h9\":\"Commute_Time\"}, inplace=True)\n", + "\n", + "# Convert Commute_Time value\n", + "avg_commute_time = df[\"Commute_Time\"]/df[\"Count_Person\"]\n", + "df[\"Commute_Time\"] = avg_commute_time\n", + "\n", + "# Convert Count of No Health Insurance to Percentage\n", + "percent_noHealthInsurance = df[\"Count_Person_NoHealthInsurance\"]/df[\"Count_Person\"]\n", + "df[\"Percent_NoHealthInsurance\"] = percent_noHealthInsurance\n", + "\n", + "# Create labels based on the obesity rate of each city\n", + "# --- Percent_Person_Obesity < 30 will be Label 0\n", + "# --- Percent_Person_Obesity >= 30 will be label 1\n", + "df[\"Label\"] = df['Percent_Person_Obesity'] >= 30.0\n", + "df[\"Label\"] = df[\"Label\"].astype(int)\n", + "\n", + "# Display results\n", + "display(df)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Un0pOqmC2l01" + }, + "source": [ + "Now that we have our features and labels set, it's time to start modeling!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "K38HUB5uz2Mg" + }, + "source": [ + "## 1) Model selection\n", + "\n", + "The results of our models are only good if our models are correct in the first place. \"Good\" here can mean different things depending on your application -- we'll talk more about that later in this assignment.\n", + "\n", + "What's important to know for now is that the conclusions we draw are subject to the assumptions and limitations of our underlying model. Thus, making sure we choose the right models to analyze is important! But how does one choose the right model?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_IDNDln0961H" + }, + "source": [ + "### 1.1) Building Intuition -- Which model do you think is best?\n", + "To build some intuition, let's start off with a simple example. We'll use a subset of our data. For ease of visualization, we'll start with just two features, and just 10 cities.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 631 + }, + "collapsed": true, + "id": "R_53hMUL_HS3", + "outputId": "2697f0e7-12e7-4740-b5f5-00e8d993dfd2" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":31: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " ax.scatter(X[\"Percent_Person_PhysicalInactivity\"][i],\n", + ":32: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " X[\"Percent_Person_SleepLessThan7Hours\"][i],\n", + ":33: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " c=colors[Y['Label'][i]],\n", + ":34: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " marker=markers[Y['Label'][i]],\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# For ease of visualization, we'll focus on just a few cities\n", + "subset_city_dcids = [\"geoId/0667000\", # San Francisco, CA\n", + " \"geoId/3651000\", # NYC, NY\n", + " \"geoId/1304000\", # Atlanta, GA\n", + " \"geoId/2404000\", # Baltimore, MD\n", + " \"geoId/3050200\", # Missoula, MT\n", + " \"geoId/4835000\", # Houston, TX\n", + " \"geoId/2622000\", # Detroit, MI\n", + " \"geoId/5363000\", # Seattle, WA\n", + " \"geoId/2938000\", # Kansas City, MO\n", + " \"geoId/4752006\" # Nashville, TN\n", + " ]\n", + "\n", + "# Create a subset dataframe with just those cities\n", + "subset_df = df.loc[df['DCID'].isin(subset_city_dcids)]\n", + "\n", + "# We'll just use 2 features for ease of visualization\n", + "X = subset_df[[\"Percent_Person_PhysicalInactivity\",\n", + " \"Percent_Person_SleepLessThan7Hours\"]]\n", + "Y = subset_df[['Label']]\n", + "\n", + "# Visualize the data\n", + "colors = ['#1f77b4', '#ff7f0e']\n", + "markers = ['s', '^']\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.set_title('Original Data')\n", + "ax.set_ylabel('Percent_Person_SleepLessThan7Hours')\n", + "ax.set_xlabel('Percent_Person_PhysicalInactivity')\n", + "for i in range(X.shape[0]):\n", + " ax.scatter(X[\"Percent_Person_PhysicalInactivity\"][i],\n", + " X[\"Percent_Person_SleepLessThan7Hours\"][i],\n", + " c=colors[Y['Label'][i]],\n", + " marker=markers[Y['Label'][i]],\n", + " )\n", + "ax.legend([0, 1])\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "J-_ZAW1XJV5h" + }, + "source": [ + "\n", + "The following blocks of code will generate 2 candidate classifiers, for labeling the datapoints as either label 0 (high obesity rate), or label 1 (high obesity rate).\n", + "\n", + "The code will also output an accuracy score, which for this section is defined as:\n", + "\n", + "$\\text{Accuracy} = \\frac{\\text{# correctly labeled}}{\\text{# total datapoints}}$\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 544 + }, + "collapsed": true, + "id": "q4IrknfmLJfb", + "outputId": "045e15b8-7499-4106-e8af-e2007f914bd7" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.11/dist-packages/sklearn/utils/validation.py:2739: UserWarning: X does not have valid feature names, but SVC was fitted with feature names\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy of this classifier is: 0.9\n" + ] + } + ], + "source": [ + "# Classifier 1\n", + "classifier1 = svm.SVC()\n", + "classifier1.fit(X, Y[\"Label\"])\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.set_title('Classifier 1')\n", + "ax.set_ylabel('Percent_Person_SleepLessThan7Hours')\n", + "ax.set_xlabel('Percent_Person_PhysicalInactivity')\n", + "plot_decision_regions(X.to_numpy(),\n", + " Y[\"Label\"].to_numpy(),\n", + " clf=classifier1,\n", + " legend=2)\n", + "plt.show()\n", + "\n", + "print('Accuracy of this classifier is:', classifier1.score(X,Y[\"Label\"]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 544 + }, + "collapsed": true, + "id": "fN7LCX0YLL3n", + "outputId": "241eb46e-710a-461a-a7f1-cf4f22c1483a" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.11/dist-packages/sklearn/utils/validation.py:2739: UserWarning: X does not have valid feature names, but DecisionTreeClassifier was fitted with feature names\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy of this classifier is: 1.0\n" + ] + } + ], + "source": [ + "# Classifier 2\n", + "classifier2 = tree.DecisionTreeClassifier(random_state=0)\n", + "classifier2.fit(X, Y[\"Label\"])\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.set_title('Classifier 2')\n", + "ax.set_ylabel('Percent_Person_SleepLessThan7Hours')\n", + "ax.set_xlabel('Percent_Person_PhysicalInactivity')\n", + "plot_decision_regions(X.to_numpy(),\n", + " Y[\"Label\"].to_numpy(),\n", + " clf=classifier2,\n", + " legend=2)\n", + "plt.show()\n", + "\n", + "print('Accuracy of this classifier is:', classifier2.score(X,Y[\"Label\"]))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bFJOOjyOVje8" + }, + "source": [ + "**1.1A)** Which model do you think is better, Classifier 1 or Classifier 2? Explain your reasoning.\n", + "\n", + "**1.1B)** Classifier 2 has a higher accuracy than Classifier 1, but has a more complicated decision boundary. Which do you think would generalize best to new data?\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BrWpvHTNU9YT" + }, + "source": [ + "\n", + "### 1.2) The importance of generalizability\n", + "\n", + "So, how did we do? Let's see what happens when we add back the rest of the cities (we'll keep using just the 2 features for ease of visualization)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 631 + }, + "collapsed": true, + "id": "dJ9ZFhPqgkmJ", + "outputId": "67fc0fd2-51ba-4689-de5d-6baacd14baaa" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":15: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " ax.scatter(X_full[\"Percent_Person_PhysicalInactivity\"][i],\n", + ":16: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " X_full[\"Percent_Person_SleepLessThan7Hours\"][i],\n", + ":17: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " c=cCycle[Y_full['Label'][i]],\n", + ":18: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " marker=mCycle[Y_full['Label'][i]],\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Original data\n", + "X_full = df[[\"Percent_Person_PhysicalInactivity\",\n", + " \"Percent_Person_SleepLessThan7Hours\"]]\n", + "Y_full = df[['Label']]\n", + "\n", + "# Visualize the data\n", + "cCycle = ['#1f77b4', '#ff7f0e']\n", + "mCycle = ['s', '^']\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.set_title('Original Data')\n", + "ax.set_ylabel('Percent_Person_SleepLessThan7Hours')\n", + "ax.set_xlabel('Percent_Person_PhysicalInactivity')\n", + "for i in range(X_full.shape[0]):\n", + " ax.scatter(X_full[\"Percent_Person_PhysicalInactivity\"][i],\n", + " X_full[\"Percent_Person_SleepLessThan7Hours\"][i],\n", + " c=cCycle[Y_full['Label'][i]],\n", + " marker=mCycle[Y_full['Label'][i]],\n", + " )\n", + "ax.legend([0, 1])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 544 + }, + "collapsed": true, + "id": "zEz4hyJfg_F8", + "outputId": "e945c3e7-fa4c-4b12-852e-c4eedf94e4e2" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.11/dist-packages/sklearn/utils/validation.py:2739: UserWarning: X does not have valid feature names, but SVC was fitted with feature names\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy of this classifier is: 0.82\n" + ] + } + ], + "source": [ + "# Classifier 1\n", + "fig, ax = plt.subplots()\n", + "ax.set_title('Classifier 1')\n", + "ax.set_ylabel('Percent_Person_SleepLessThan7Hours')\n", + "ax.set_xlabel('Percent_Person_PhysicalInactivity')\n", + "plot_decision_regions(X_full.to_numpy(),\n", + " Y_full[\"Label\"].to_numpy(),\n", + " clf=classifier1,\n", + " legend=2)\n", + "plt.show()\n", + "\n", + "print('Accuracy of this classifier is: %.2f' % classifier1.score(X_full,Y_full[\"Label\"]))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 544 + }, + "collapsed": true, + "id": "NkAC1ii9hZ62", + "outputId": "e2338498-4e78-421c-aa03-0cb7923c264d" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.11/dist-packages/sklearn/utils/validation.py:2739: UserWarning: X does not have valid feature names, but DecisionTreeClassifier was fitted with feature names\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy of this classifier is: 0.73\n" + ] + } + ], + "source": [ + "# Classifier 2\n", + "fig, ax = plt.subplots()\n", + "ax.set_title('Classifier 2')\n", + "ax.set_ylabel('Percent_Person_SleepLessThan7Hours')\n", + "ax.set_xlabel('Percent_Person_PhysicalInactivity')\n", + "plot_decision_regions(X_full.to_numpy(),\n", + " Y_full[\"Label\"].to_numpy(),\n", + " clf=classifier2,\n", + " legend=2)\n", + "plt.show()\n", + "\n", + "print('Accuracy of this classifier is: %.2f' % classifier2.score(X_full,Y_full[\"Label\"]))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "51H3zw11xMnF" + }, + "source": [ + "**1.2A)** In light of all the new data points, now which classifier do you think is better, Classifer 1 or Classifier 2? Explain your reasoning.\n", + "\n", + "**1.2B)** In question 1, Classifier 1 had a *lower* accuracy than Classifier 2. After adding more data points, we now see the reverse, with Classifier 1 having a *higher* accuracy than Classifier 2. What happened? Give an explanation (or at least your best guess) for why this is." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DnGbwAsQs-A9" + }, + "source": [ + "## 2) Evaluation metrics\n", + "\n", + "In question 1, we were able to visualize how well our models performed by plotting our data and decision boundaries. However, this was only possible because we limited ourselves to just 2 features. Unfortunately for us, humans are only good at visualizing up to 3 dimensions. As you increase the number of features and/or complexity of your models, creating meaningful visualizations quickly becomes intractable.\n", + "\n", + "Thus, we'll need other methods to measure how well our models perform. In this section, we'll cover some common strategies for evaluating models.\n", + "\n", + "To start, let's finally fit a model to all of our available data (e.g. 500 cities and 8 features). Because the features have different scales, we'll also take care to standardize their values." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 79 + }, + "collapsed": true, + "id": "_OEKYfmWClw5", + "outputId": "2eb85c0e-4cdc-4010-957b-83acfbfdee4a" + }, + "outputs": [ + { + "data": { + "text/html": [ + "
Perceptron()
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "Perceptron()" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Use all features that aren't obesity\n", + "X_large = df.dropna()[[\n", + " \"Median_Income_Person\",\n", + " \"Percent_NoHealthInsurance\",\n", + " \"Percent_Person_PhysicalInactivity\",\n", + " \"Percent_Person_SleepLessThan7Hours\",\n", + " \"Percent_Person_WithHighBloodPressure\",\n", + " \"Percent_Person_WithMentalHealthNotGood\",\n", + " \"Percent_Person_WithHighCholesterol\",\n", + " \"Commute_Time\"\n", + " ]]\n", + "Y_large = df.dropna()[\"Label\"]\n", + "\n", + "# Standardize the data\n", + "scaler = StandardScaler().fit(X_large)\n", + "X_large = scaler.transform(X_large)\n", + "\n", + "# Create a model\n", + "large_model = linear_model.Perceptron()\n", + "large_model.fit(X_large, Y_large)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TsxEsROd2o7z" + }, + "source": [ + "### 2.1) Accuracy\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TaRWM46b9zmX" + }, + "source": [ + "#### 2.1.1) Classification accuracy\n", + "We've seen an example of an evaluation metric already -- accuracy! The accuracy score used in question 1 is more commonly known as _classification accuracy_, and is the most common metric used in classification problems.\n", + "\n", + "As a refresher, the classification accuracy is the ratio of number of correct predictions to the total number of data points.\n", + "\n", + "**Classification accuracy:**\n", + "$Accuracy = \\frac{\\text{# correctly labeled}}{\\text{# total datapoints}}$\n", + "\n", + "Note that sometimes the classification accuracy can be misleading! Consider the following scenario:\n", + "\n", + "> There are two classes, A and B. We have 100 data points in our dataset. Of these 100 data points, 99 points are labeled class A, while only 1 of the data points is labeled class B.\n", + "\n", + "**2.1.1A)** Consider a model that always predicts class A. What is the accuracy of this always-A model?\n", + "\n", + "**2.1.1B)** How well do you expect the always-A model to perform on new, previously unseen data? Assume the new data follows the same distribution as the original 100 data points.\n", + "\n", + "**2.1.1C)** Run the following code block to calculate the classification accuracy of our large model. Is the accuracy higher or lower than you expected?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "WLdGp_nUFhPZ", + "outputId": "ace47caf-511c-465f-fb47-37181dd88313" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy of the large model is: 0.81\n" + ] + } + ], + "source": [ + "print('Accuracy of the large model is: %.2f' % large_model.score(X_large,Y_large))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YDiuNmdDYZ6L" + }, + "source": [ + "### 2.2) Train/test splits\n", + "The ability of a model to perform well on new, previously unseen data (drawn from the same distribution as the data used the create the model) is called _**generalization**_. For most applications, we prefer models that generalize well over those that don't.\n", + "\n", + "One way to check the generalizability of a model is to perform an analysis similar to what we did in question 1. We'll take our data, and randomly split it into two subsets, a _**training set**_ that we'll use to build our model, and a _**test set**_, which we'll hold out until the model is complete and use it to evaluate how well our model can generalize to simulate new, previously unseen data.\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "N6edxvroQl_G" + }, + "source": [ + "#### 2.2.1) Choosing split sizes\n", + "But what percentage of our data points should go into our training and test sets respectively? There are no hard and fast rules for this; the right split often depends on the application and how much data we have. The next few questions explore the key tradeoffs:\n", + "\n", + "**2.2A)** Consider a scenario with 5 data points in the training set and 95 data points in the test set. How accurate of a model do you think we're likely to train?\n", + "\n", + "**2.2B)** Does your answer to 2.2A change if we have 500 training and 9500 test points instead?\n", + "\n", + "**2.2C)** Consider a scenario with 95 data points in the training set and 5 data points in the test set. Is the test accuracy still a good measure of generalizability?\n", + "\n", + "**2.2D)** Does your answer to 2.2C change if we have 9500 training and 500 test points instead?\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7IKTxtfK7VE0" + }, + "source": [ + "#### 2.2.2) Try for yourself!\n", + "**2.2E)** Play around with a couple values of `test_size` in the code box below. Find a split ratio that seems to work well, and report what that ratio is." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "x0Pf04BU9e_i", + "outputId": "d0377093-d01c-45a4-e201-d37014f8b8cd" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "75.0% Training, 25.0% Test Split\n", + "The TRAINING accuracy is: 0.87\n", + "The TEST accuracy is: 0.87\n" + ] + } + ], + "source": [ + "'''\n", + "Try a variety of different splits by changing the test_size variable, which\n", + "represents the ratio of points to use in the test set.\n", + "\n", + "For example, for a 75% training, 25% test split, use test_size=0.25\n", + "'''\n", + "\n", + "\n", + "test_size = 0.25 # Change me! Enter a value between 0 and 1\n", + "\n", + "\n", + "\n", + "print(f'{np.round((1-test_size)*100)}% Training, {(test_size)*100}% Test Split' )\n", + "\n", + "# Randomly split data into train and test Sets\n", + "x_train, x_test, y_train, y_test = train_test_split(X_large, Y_large, test_size=test_size)\n", + "\n", + "# Fit a model on the training set\n", + "large_model.fit(x_train, y_train)\n", + "print('The TRAINING accuracy is: %.2f' % large_model.score(x_train, y_train))\n", + "\n", + "# Evaluate on the test Set\n", + "print('The TEST accuracy is: %.2f' % large_model.score(x_test, y_test))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "h-wTIQ0OAWzd" + }, + "source": [ + "#### 2.2.3) Training vs. test accuracy\n", + "\n", + "As you may have noticed from 2.2.2, we can calculate two different accuracies after performing a train/test split: a _**training accuracy**_ based on how well the model performs on the data it was trained on, and a _**test accuracy**_ based on how well the model performs on held out data. Typically, we select models based on _test_ accuracy. After all, a model's performance on new data after being deployed is usually more important than how well that model performed on the training data.\n", + "\n", + "So why measure training accuracy at all? It turns out training accuracy is often useful for diagnosing some common issues with models.\n", + "\n", + "For example, consider the following scenario:\n", + "\n", + ">After performing a train/test split, a model is found to have 100% training accuracy, but only 33% test accuracy.\n", + "\n", + "**2.2F)** What's going on with the model in the scenario? Come up with a hypothetical setup that could result in these train and test accuracies.\n", + "\n", + "_Hint: This situation is called **overfitting**. If you're stuck, feel free to look it up!_\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rFlqkyen9iAX" + }, + "source": [ + "### 2.3) Cross-validation\n", + "\n", + "If you haven't already, run the code box in 2.2.2 multiple times without changing the `test_size` variable. Notice how the accuracies can be different between runs?\n", + "\n", + "The problem is that each time we randomly select a train/test split, sometimes we'll get luckier or unlucky with a particular distribution of training or test data. To borrow a term from statistics, a sample size of $n=1$ is too small! We can do better.\n", + "\n", + "To get a better estimate of test accuracy, a common strategy is to use _**k-fold cross-validation**_. The general proceedure is:\n", + "\n", + "1. Split the data into $k$ groups.\n", + "2. Then for each group (called a fold):\n", + " 1. Hold that group out as the test set, and use the remaining groups as a training set.\n", + " 2. Fit a new model on the training set and record the resulting accuracy on the test set.\n", + "3. Take the average of all test accuracies.\n", + "\n", + "#### A note on choosing k\n", + "The number of folds to use depends on your data. Setting the number of folds implicitly also sets your train/test split ratio. For example, using 10 folds implies 10 (90% train, 10% test) splits. Common choices are $k=10$ or $k=5$.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "MN5BAsFc9hfn", + "outputId": "274f89d1-cc7c-4f49-b615-d742302a07da" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test accuracies for 5 splits:\n", + "\tFold 1: 0.81\n", + "\tFold 2: 0.89\n", + "\tFold 3: 0.84\n", + "\tFold 4: 0.93\n", + "\tFold 5: 0.87\n", + "Average score across all folds: 0.87\n" + ] + } + ], + "source": [ + "'''\n", + "Set the number of folds by changing k.\n", + "'''\n", + "k = 5 # Enter an integer >=2. Number of folds.\n", + "\n", + "print(f'Test accuracies for {k} splits:')\n", + "scores = cross_val_score(large_model, X_large, Y_large, cv=k)\n", + "for i in range(k):\n", + " print('\\tFold %d: %.2f' % (i+1, scores[i]))\n", + "print('Average score across all folds: %.2f' % np.mean(scores))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2iOF5tOUJByn" + }, + "source": [ + "**2.3A)** Play around with the code box above to find a good value of $k$. What happens if $k$ is very large or very small?\n", + "\n", + "**2.2B)** How does the average score across all folds change with $k$?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Tg0bLVujHOQb" + }, + "source": [ + "### 2.4) Other metrics worth knowing\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Sw8y60E1N7AV" + }, + "source": [ + "#### 2.4.1) What about regression? -- mean squared error\n", + "Different models and different problems often use different accuracy metrics. You may have noticed that classification accuracy doesn't make much sense for regression problems, where instead of predicting a label, the model predicts a numeric value. In regression, a common accuracy metric is the mean squared error, or MSE.\n", + "\n", + "$ MSE = \\frac{1}{\\text{# total data points}}\\sum_{\\text{all data points}}(\\text{predicted value} - \\text{actual value})^2$\n", + "\n", + "It is a measure of the average difference between the predicted value and the actual value. The square ($^2$) can seem counterintuitive at first, but offers some nice mathematical properties." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NxSp1xeIMTg8" + }, + "source": [ + "#### 2.4.2) More classification metrics\n", + "Accuracy alone never tells the full story.There are a number of other metrics borrowed from statistics that are commonly used on classification models.\n", + "\n", + "It's possible for a model to have a high accuracy, but score very low on some of the following metrics:\n", + "\n", + "* **True positives:** The cases where we predicted positively, and the actual label was positive.\n", + "\n", + "* **True negatives:** The cases where we predicted negatively, and the actual label was negative.\n", + "\n", + "* **False p:** The cases where we predicted positively, but the actual label was negative.\n", + "\n", + "* **False negatives:** The cases where we predicted negatively, but the actual label was positive.\n", + "\n", + "* **False positive rate:** Corresponds to the proportion of negative data points incorrectly considered positive relative to all negative points.\n", + ">$FPR = \\frac{FP}{TN + FP}$\n", + "\n", + "* **Sensitivity:** _(Also known as True Positive Rate)_ corresponds to the proportion of positive datapoints correctly considered as positive relative to all positive points.\n", + ">$TPR = \\frac{TP}{TP + FN}$\n", + "\n", + "\n", + "* **Specificity:** _(Also known as True Negative Rate)_ corresponds to the proportion of negative datapoints correctly considered negative relative to all negative points.\n", + ">$TNR = \\frac{TN}{TN + FP}$\n", + "\n", + "* **Precision:** Proportion of correctly labeled positive points relative to the number of positive predictions\n", + ">$Precision = \\frac{TP}{TP+FP}$\n", + "\n", + "* **Recall:** Proportion of correctly labeled positive points relative to all points that were actually positive.\n", + ">$Recall = \\frac{TP}{TP+FN}$\n", + "\n", + "* **F1 score:** Measure of a balance between precision and recall.\n", + ">$F1 = 2 \\cdot \\frac{1}{\\frac{1}{precision} + \\frac{1}{recall}}$" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EZ8DZPlhIl0L" + }, + "source": [ + "#### 2.4.3) Tradeoffs between metrics\n", + "\n", + "Often, our definition of a \"good\" model varies by situation or application case. In some cases, we might prefer a different tradeoff between accuracy, false positive rate, and false negative rate.\n", + "\n", + "**2.4)** Read through the following scenarios. For each case, state which metrics you would prioritize, and why.\n", + "\n", + "Scenario 1:\n", + "\n", + ">Doctors have identified a new extremely rare, but also very deadly disease. Fortunately, they also discover a simple medication, that if taken early enough, can prevent the disease. The doctors plan to use a machine learning model to predict which of their patients are at high-risk for getting the disease. A positively labeled patient is high-risk, while a negatively labeled patient is low-risk.\n", + "\n", + "Scenario 2:\n", + ">Data Is Cool Inc. is a company that attracts many highly (and equally) qualified applicants to its job posting. They are overwhelmed with the number of applications received, so the company implements a machine learning model to sort all the incoming resumes. A positively labeled resume gets passed to a recruiter for a very thorough, but time-costly review. Negatively labeled resumes are held for future job openings." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1xJQfVP2_xWc" + }, + "source": [ + "## 3) Tying it all together: choosing a model to deploy\n", + "\n", + "Now that we've seen many different evaluation metrics, let's put what we've learned into practice!\n", + "\n", + "One of the most common problems you'll encounter as a data scientist is to decide between a set of candidate models.\n", + "\n", + "Each of the following code boxes below generates a candidate classifier for predicting high vs low obesity rates in cities. The models can differ in different ways: number of features, learning algorithm used, number of datapoints, etc.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "f-pp0Hf9aYp8", + "outputId": "896a8a1c-48b8-4afa-b947-50c31976cd42" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Classifier A\n", + "-------------\n", + "Number of Data Points: 497\n", + "Number of Features: 2\n", + "Classification Accuracy: 0.32\n", + "5-Fold Cross Validation Accuracy: 0.69\n" + ] + } + ], + "source": [ + "# Classifier A\n", + "x_A = df[[\"Count_Person\",\n", + " \"Median_Income_Person\"]]\n", + "y_A = df[\"Label\"]\n", + "\n", + "classifierA = linear_model.Perceptron()\n", + "classifierA.fit(x_A, y_A)\n", + "scores = cross_val_score(classifierA, x_A, y_A, cv=5)\n", + "\n", + "print('Classifier A')\n", + "print('-------------')\n", + "print('Number of Data Points:', x_A.shape[0])\n", + "print('Number of Features:', x_A.shape[1])\n", + "print('Classification Accuracy: %.2f' % classifierA.score(x_A, y_A))\n", + "print('5-Fold Cross Validation Accuracy: %.2f' % np.mean(scores))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "FuJ-EzxZdKVl", + "outputId": "2de70e3c-d8ce-47c8-b8b5-269a00126259" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Classifier A\n", + "-------------\n", + "Number of Data Points: 497\n", + "Number of Features: 2\n", + "Training Classification Accuracy: 0.79\n", + "5-Fold Cross Validation Accuracy: 0.80\n" + ] + } + ], + "source": [ + "# Classifier A\n", + "x_A = df[[\"Percent_Person_PhysicalInactivity\",\n", + " \"Median_Income_Person\"]]\n", + "y_A = df[\"Label\"]\n", + "\n", + "classifierA = svm.SVC()\n", + "classifierA.fit(x_A, y_A)\n", + "scores = cross_val_score(classifierA, x_A, y_A, cv=5)\n", + "\n", + "print('Classifier A')\n", + "print('-------------')\n", + "print('Number of Data Points:', x_A.shape[0])\n", + "print('Number of Features:', x_A.shape[1])\n", + "print('Training Classification Accuracy: %.2f' % classifierA.score(x_A, y_A))\n", + "print('5-Fold Cross Validation Accuracy: %.2f' % np.mean(scores))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "e04m-KpZeOcp", + "outputId": "e3988ac5-e37b-419b-eccb-0ea1f4b07e3d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Classifier B\n", + "-------------\n", + "Number of Data Points: 497\n", + "Number of Features: 6\n", + "Training Classification Accuracy: 1.00\n", + "5-Fold Cross Validation Accuracy: 0.80\n" + ] + } + ], + "source": [ + "# Classifier B\n", + "x_B = df.dropna()[[\n", + " \"Percent_NoHealthInsurance\",\n", + " \"Percent_Person_PhysicalInactivity\",\n", + " \"Percent_Person_SleepLessThan7Hours\",\n", + " \"Percent_Person_WithHighBloodPressure\",\n", + " \"Percent_Person_WithMentalHealthNotGood\",\n", + " \"Percent_Person_WithHighCholesterol\"\n", + "]]\n", + "y_B = df.dropna()[\"Label\"]\n", + "\n", + "classifierB = tree.DecisionTreeClassifier()\n", + "classifierB.fit(x_B, y_B)\n", + "scores = cross_val_score(classifierB, x_B, y_B, cv=5)\n", + "\n", + "print('Classifier B')\n", + "print('-------------')\n", + "print('Number of Data Points:', x_B.shape[0])\n", + "print('Number of Features:', x_B.shape[1])\n", + "print('Training Classification Accuracy: %.2f' % classifierB.score(x_B, y_B))\n", + "print('5-Fold Cross Validation Accuracy: %.2f' % np.mean(scores))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "U1AtT499foLS", + "outputId": "631db8f5-42eb-440f-8946-6c4fe279208d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Classifier C\n", + "-------------\n", + "Number of Data Points: 497\n", + "Number of Features: 6\n", + "Training Classification Accuracy: 0.84\n", + "5-Fold Cross Validation Accuracy: 0.80\n" + ] + } + ], + "source": [ + "# Classifier C\n", + "x_C = df.dropna()[[\n", + " \"Percent_NoHealthInsurance\",\n", + " \"Percent_Person_PhysicalInactivity\",\n", + " \"Percent_Person_SleepLessThan7Hours\",\n", + " \"Percent_Person_WithHighBloodPressure\",\n", + " \"Percent_Person_WithMentalHealthNotGood\",\n", + " \"Percent_Person_WithHighCholesterol\"\n", + "]]\n", + "y_C = df.dropna()[\"Label\"]\n", + "\n", + "classifierC = linear_model.Perceptron()\n", + "classifierC.fit(x_C, y_C)\n", + "scores = cross_val_score(classifierC, x_C, y_C, cv=5)\n", + "\n", + "print('Classifier C')\n", + "print('-------------')\n", + "print('Number of Data Points:', x_C.shape[0])\n", + "print('Number of Features:', x_C.shape[1])\n", + "print('Training Classification Accuracy: %.2f' % classifierC.score(x_C, y_C))\n", + "print('5-Fold Cross Validation Accuracy: %.2f' % np.mean(scores))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8u7xbAicaZR4" + }, + "source": [ + "**3A)** Run the code boxes above and select which model you would choose to deploy. Justify your answer.\n", + "\n", + "**3B)** Consider a new classifier D. Its results look like this:\n", + ">Number of data points: 5,000 \\\n", + ">Number of features: 10,000 \\\n", + ">Training classification accuracy: 98% \\\n", + ">5-Fold cross validation accuracy: 95%.\n", + "\n", + "Would you deploy classifier D? Name one advantage and one disadvantage of such a model." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vxkyeNejly6y" + }, + "source": [ + "## 4) Extension: what about YOUR city?\n", + "\n", + "Now that we've got a model trained up, let's play with it!\n", + "\n", + "1. Use the [Data Commons search feature](https://datacommons.org/) to find the DCID of a town or city local to you.\n", + "\n", + "2. Use the code box below to add your local town or city's data, and run the model on that data.\n", + "\n", + "**Note: Data may not be available for all locations. If you encounter errors, please try a different location!**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "uB697BnhOiWN", + "outputId": "ffe9f9c9-ac4d-4c98-eb3b-ba3557bb3de6" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Prediction for Mountain View:\n", + "\tThe predicted label was 0\n", + "\tThe actual label was 0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + ":45: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + " print(f'\\tThe actual label was {y_local[0]}')\n" + ] + } + ], + "source": [ + "your_local_dcid = \"geoId/0649670\" # Replace with your own!\n", + "\n", + "# Get your local data from Data Commons\n", + "local_data = client.observations_dataframe(\n", + " variable_dcids=stat_vars_to_query,\n", + " date=\"latest\",\n", + " entity_dcids=your_local_dcid)\n", + "\n", + "# Cleaning and preprocessing\n", + "local_data = local_data.groupby([\"entity\", \"entity_name\", \"variable\"]).first().reset_index()\n", + "local_data = local_data[[\"entity\", \"entity_name\", \"variable\", \"value\"]]\n", + "local_data = local_data.pivot(index=[\"entity\", \"entity_name\"], columns=\"variable\", values=\"value\")\n", + "local_data = local_data.reset_index()\n", + "local_data.rename(columns={\"entity\":\"DCID\", \"entity_name\": \"City\"}, inplace=True)\n", + "local_data.set_index(\"City\", inplace=True)\n", + "local_data.rename(columns={\"dc/e9gftzl2hm8h9\":\"Commute_Time\"}, inplace=True)\n", + "avg_commute_time = local_data[\"Commute_Time\"]/local_data[\"Count_Person\"]\n", + "local_data[\"Commute_Time\"] = avg_commute_time\n", + "percent_noHealthInsurance = local_data[\"Count_Person_NoHealthInsurance\"]/local_data[\"Count_Person\"]\n", + "local_data[\"Percent_NoHealthInsurance\"] = percent_noHealthInsurance\n", + "local_data[\"Label\"] = local_data['Percent_Person_Obesity'] >= 30.0\n", + "local_data[\"Label\"] = local_data[\"Label\"].astype(int)\n", + "\n", + "# Build data to feed into model\n", + "x_local = local_data[[\n", + " \"Median_Income_Person\",\n", + " \"Percent_NoHealthInsurance\",\n", + " \"Percent_Person_PhysicalInactivity\",\n", + " \"Percent_Person_SleepLessThan7Hours\",\n", + " \"Percent_Person_WithHighBloodPressure\",\n", + " \"Percent_Person_WithMentalHealthNotGood\",\n", + " \"Percent_Person_WithHighCholesterol\",\n", + " \"Commute_Time\"\n", + "]]\n", + "x_local = scaler.transform(x_local)\n", + "y_local = local_data[\"Label\"]\n", + "\n", + "\n", + "# Make prediction\n", + "prediction = large_model.predict(x_local)\n", + "\n", + "# Report results\n", + "print(f'Prediction for {local_data.index[0]}:')\n", + "print(f'\\tThe predicted label was {prediction[0]}')\n", + "print(f'\\tThe actual label was {y_local[0]}')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "71cqwFb8PFZv" + }, + "source": [ + "**4A)** How well did the model do? Was it able to classify your city or town correctly?\n", + "\n", + "**4B)** Can you find a city or town that the model predicts incorrectly? Why do you think the model predicts it incorrectly?\n", + "\n" + ] + } + ], + "metadata": { + "colab": { + "include_colab_link": true, + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/notebooks/intro_data_science/Data_Commons_For_Data_Science_Tutorial.ipynb b/notebooks/intro_data_science/Data_Commons_For_Data_Science_Tutorial.ipynb new file mode 100644 index 00000000..b5c39620 --- /dev/null +++ b/notebooks/intro_data_science/Data_Commons_For_Data_Science_Tutorial.ipynb @@ -0,0 +1,1904 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zINqyQ-9HymG" + }, + "source": [ + "Copyright 2025 Google LLC.\n", + "SPDX-License-Identifier: Apache-2.0" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xHtx1UaU5anm" + }, + "source": [ + "# Tutorial: Data Science with the Data Commons API\n", + "\n", + "Welcome! This tutorial will introduce the core ideas and workflow you need to get started using Data Commons for data science applications. In particular, we will focus on introducing the Python and Pandas Data Commons APIs.\n", + "\n", + "This tutorial will cover:\n", + "* The power of Data Commons\n", + "* Key terminology\n", + "* The standard workflow\n", + "* Some examples to get you started" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HCqxWaPr5lI_" + }, + "source": [ + "## Why use Data Commons?\n", + "\n", + "There is a substantial amount of publicly available data, but this data can be difficult to use. Although the data is open, using it to answer specific questions often involves tedious \"foraging\" — finding the data, cleaning the data, reconciling different formats and schemas, figuring out how to merge data about the same entity from different sources, etc. This error-prone and tedious process is repeated, once (or more) by each organization.\n", + "\n", + "Data Commons is an attempt to ameliorate some of this tedium by doing this once, on a large scale, and providing cloud-accessible APIs to the cleaned, normalized and joined data. Using the API, we can easily explore and analyze data across different datasets without the need for data cleaning or joining.\n", + "\n", + "**The Knowledge Graph**\n", + "\n", + "Data Commons provides an open knowledge repository that combines data from public datasets into one large knowledge graph. For example, here are some statements contained in the graph:\n", + "\n", + "* [Santa Clara County](https://browser.datacommons.org/kg?dcid=geoId/06085) is contained in the [State of California](https://browser.datacommons.org/kg?dcid=geoId/06)\n", + "* The latitude of [Berkeley, CA](https://browser.datacommons.org/kg?dcid=geoId/0606000) is 37.8703\n", + "* [The population of Maryland](https://browser.datacommons.org/kg?dcid=dc/p/psjx4xy30nws1) was [6,003,435 in 2018](https://browser.datacommons.org/kg?dcid=dc%2Fo%2Fx1tlfg4ll9yr9).\n", + "\n", + "In the graph, [*entities*](https://en.wikipedia.org/wiki/Entity) like [Santa Clara County](https://browser.datacommons.org/kg?dcid=geoId/06085) are represented by nodes. Every node has a type corresponding to what the node represents. For example, [California](https://browser.datacommons.org/kg?dcid=geoId/06) is a [State](https://schema.org/State). *Relations* between entities are represented by edges between these nodes. For example, the statement \"Santa Clara County is contained in the State of California\" is represented in the graph as two nodes: \"Santa Clara County\" and \"California\", with an edge labeled \"[containedInPlace](https://schema.org/containedInPlace)\" pointing from Santa Clara to California. Data Commons closely follows the [Schema.org data model](https://schema.org/docs/datamodel.html) and leverages the Schema.org schema to provide a common set of types and properties.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XFFrbKYjCaUJ" + }, + "source": [ + "## Useful links\n", + "\n", + "Some useful references for Data Commons:\n", + "\n", + "* [Main API documentation](https://docs.datacommons.org/api/python/v2)\n", + "\n", + "* [API tutorials](https://docs.datacommons.org/tutorials/v2)\n", + "\n", + "* [Graph Browswer](https://datacommons.org/browser/) Tool for manually stepping through the knowledge graph\n", + "\n", + "And some nice visualization tools:\n", + "\n", + "* [Timelines Explorer](https://datacommons.org/tools/timeline) Explore how statistical variables change across time.\n", + "\n", + "* [Scatter Plot Explorer](https://datacommons.org/tools/scatter) Plot any two statistical variables against each other.\n", + "\n", + "* [Map Explorer](https://datacommons.org/tools/map) Explore how statistics vary across geographic regions (e.g. states or counties)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "X9udZsx36QBv" + }, + "source": [ + "## Installing the Data Commons API\n", + "\n", + "The Data Commons API does not ship natively with most Python installations. Thus, we need to install the APIs manually. Install the Data Commons Python and Pandas APIs using [`pip`](https://pip.pypa.io/en/stable/). In this colab, you can do this by running the following lines of code:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "dThSMUJ96vK2" + }, + "outputs": [], + "source": [ + "!pip install \"datacommons-client[Pandas]\" --upgrade --quiet" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Fpv4QKvV6xiw" + }, + "source": [ + "If you want to run the Data Commons API locally on your own machine, first [make sure you have Python installed](https://wiki.python.org/moin/BeginnersGuide/Download). Then, copy/paste and run the following lines in your terminal or command-line.\n", + "\n", + "```\n", + "pip install \"datacommons-client[Pandas]\" --upgrade\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "grdHeoqRerXN" + }, + "source": [ + "## Importing the Data Commons client\n", + "\n", + "After installation, you can import the Data Commons client and create a client instance using the lines of code below:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "hQdpQ9Xcey72" + }, + "outputs": [], + "source": [ + "from datacommons_client import DataCommonsClient\n", + "\n", + "# Create a client using the Data Commons Trial API key.\n", + "dc_client = DataCommonsClient(api_key=\"AIzaSyCTI4Xz-UW_G2Q2RfknhcfdAnTHq5X5XuI\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4dZ655iRH2sW" + }, + "source": [ + "The trial key is capped with a limited quota for requests. If you are planning on using the APIs more rigorously (e.g. for personal or school projects, developing applications, etc.) please request an official key without any quota limits; see [Obtain an API key](https://docs.datacommons.org/api/index.html#get-key) for information." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "anVcVbI56PPy" + }, + "source": [ + "## Terms you should know\n", + "\n", + "### DCIDs\n", + "\n", + "The **DCID** (Data Commons identifier) is a unique identifier assigned to each entity in the knowledge graph. With this identifier, you will be able to search for and query information on the given entity in ways that we will discuss later.\n", + "\n", + "### Statistical Variables (StatVars)\n", + "\n", + "A **statistical variable** is any type of metric, statistic, or measure that can be measured at a place and time. Examples include median income of persons older than 16, number of female high school graduates aged 18 to 24, unemployment rate, or percentage of persons with diabetes. Statistial variables are also represented as nodes in the knowledge graph, and have their own entries in the graph browser.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Eqyi2wHO-0PZ" + }, + "source": [ + "## General workflow for data science applications" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "L_3FV74h-6sp" + }, + "source": [ + "### 1) Get DCIDs of interest\n", + "\n", + "The first thing we need is to set the scope of our analysis, by combining a list of DCIDs of all the entities we wish to analyze. There are a number of ways to do this.\n", + "\n", + "**Method A: Look for the DCIDs in the Graph Browser**\n", + "\n", + "The first method is just to look up the entities you are interested in, using the [graph browser](https://datacommons.org/browser/), and manually compile a list of DCIDs. For example, if I were interested in looking at data available for the cities of [San Francisco](https://datacommons.org/browser/geoId/0667000), [Oakland](https://datacommons.org/browser/geoId/0653000), and [Los Angeles](https://datacommons.org/browser/geoId/0644000), I would look up their pages in the graph browser to find their DCIDs, end up with a list that looks something like this:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "xAqxWxzK5Ss8" + }, + "outputs": [], + "source": [ + "dcids = [\"geoId/0667000\", # San Francisco\n", + " \"geoId/065300\", # Oakland\n", + " \"geoId/0644000\"] # Los Angeles" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BOyYQa-7L9It" + }, + "source": [ + "**Method B: Use `node.fetch()` to find places contained in CA**\n", + "\n", + "Often, we want to analyze a large cohort of places (e.g. \"all cities in California\", or \"all states in the US\"). Instead of finding the DCID for each location manually, we can use the `node.fetch()` method to query for DCIDs all at once.\n", + "\n", + "For more details on how the method works, take a look at [the documentation page for `node.fetch()`](https://docs.datacommons.org/api/python/v2/node#fetch).\n", + "\n", + "For example, if I wanted the DCIDs for all counties in California, I would use the following lines of code:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "wSHXif8XOXuh", + "outputId": "5f09e9ec-68a3-4be0-fc73-b3f63ccd67c6" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['geoId/06001', 'geoId/06003', 'geoId/06005', 'geoId/06007', 'geoId/06009', 'geoId/06011', 'geoId/06013', 'geoId/06015', 'geoId/06017', 'geoId/06019', 'geoId/06021', 'geoId/06023', 'geoId/06025', 'geoId/06027', 'geoId/06029', 'geoId/06031', 'geoId/06033', 'geoId/06035', 'geoId/06037', 'geoId/06039', 'geoId/06041', 'geoId/06043', 'geoId/06045', 'geoId/06047', 'geoId/06049', 'geoId/06051', 'geoId/06053', 'geoId/06055', 'geoId/06057', 'geoId/06059', 'geoId/06061', 'geoId/06063', 'geoId/06065', 'geoId/06067', 'geoId/06069', 'geoId/06071', 'geoId/06073', 'geoId/06075', 'geoId/06077', 'geoId/06079', 'geoId/06081', 'geoId/06083', 'geoId/06085', 'geoId/06087', 'geoId/06089', 'geoId/06091', 'geoId/06093', 'geoId/06095', 'geoId/06097', 'geoId/06099', 'geoId/06101', 'geoId/06103', 'geoId/06105', 'geoId/06107', 'geoId/06109', 'geoId/06111', 'geoId/06113', 'geoId/06115']\n" + ] + } + ], + "source": [ + "def get_node_dcids(node_response, parent_dcid, property_name):\n", + " return [\n", + " node['dcid']\n", + " for node in node_response.to_dict()['data'][parent_dcid]['arcs'][property_name]['nodes']\n", + " if 'dcid' in node\n", + " ]\n", + "\n", + "dcid_of_california = \"geoId/06\"\n", + "node_resp = dc_client.node.fetch(node_dcids=[dcid_of_california], expression=\"<-containedInPlace+{typeOf:County}\")\n", + "dcids_of_california_counties = get_node_dcids(node_resp, dcid_of_california, \"containedInPlace+\")\n", + "print(dcids_of_california_counties)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lwS4I5kZ_AgU" + }, + "source": [ + "### 2) Get statvars of interest\n", + "Similar to collecting a list of DCIDs, we also need a list of all the statistical variables we are interested in.\n", + "\n", + "You can find a complete list of statistical variables in the [Statistical Variable Explorer](https://datacommons.org/tools/statvar).\n", + "\n", + "However, note that data for statistical variables may not be available for all places/entities. There are a number of different ways to check if a statistical variable is available for an entity.\n", + "\n", + "**Method A: Look up entities in the Graph Browser**\n", + "\n", + "The first method is just to look up the entities you are interested in, using the [graph browser](https://datacommons.org/browser/), and scroll down to see the list of statistical variables available for that entity. For example, if I were interested in looking at statistical variables available for the city of [San Francisco](https://datacommons.org/browser/geoId/0667000), I would look up its page in the graph browser and scroll down to see the list of statistical variables available for the city -- as well as way of browsing by category and filtering.\n", + "\n", + "**Method B: Use `observation.fetch_available_statistical_variables()` to look up statvars associated with a DCID**\n", + "\n", + "Again, rather than having to look up each entity or place one by one in the browser, you can use the `observation.fetch_available_statistical_variables()` method to find the variables for multiple entities at a time.\n", + "\n", + "For more details on how the method works, take a look at [the documentation page for `observation.fetch_available_statistical_variables()`](https://docs.datacommons.org/api/python/v2/observation#fetch_available_statistical_variables).\n", + "\n", + "For example, if I wanted to find the statvars available for some of the California counties I obtained above, I could write this code:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "8vGy9dJZK2uN", + "outputId": "20703268-7b4a-410d-cd4d-0838a127baca" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "geoId/06005: ['Count_Student_ParentHighSchoolGraduateIncludesEquivalency_SchoolGrade3_Mathematics', 'MarginOfError_Count_Household_Householder3To4OwnChildren_MarriedCoupleFamilyHousehold_BelowPovertyLevelInThePast12Months', 'Percentile90AcrossModels_DifferenceRelativeToBaseDate2015To2020_Temperature_SSP245', 'dc/3r78p8w1m08d2', 'dc/pbz9yj5h82fy6']\n", + "geoId/06007: ['Count_Student_ParentHighSchoolGraduateIncludesEquivalency_SchoolGrade3_Mathematics', 'MarginOfError_Count_Household_Householder3To4OwnChildren_MarriedCoupleFamilyHousehold_BelowPovertyLevelInThePast12Months', 'MarginOfError_Count_Person_EnrolledInCollegeOrGraduateSchool_ForeignBorn_PlaceOfBirthCentralAmericaExceptMexico', 'Percentile90AcrossModels_DifferenceRelativeToBaseDate2015To2020_Temperature_SSP245', 'dc/3r78p8w1m08d2']\n", + "geoId/06001: ['Count_Student_ParentHighSchoolGraduateIncludesEquivalency_SchoolGrade3_Mathematics', 'MarginOfError_Count_Household_Householder3To4OwnChildren_MarriedCoupleFamilyHousehold_BelowPovertyLevelInThePast12Months', 'MarginOfError_Count_Person_EnrolledInCollegeOrGraduateSchool_ForeignBorn_PlaceOfBirthCentralAmericaExceptMexico', 'dc/gjz50kkskghm3', 'dc/tbw0cr73ep6l8']\n", + "geoId/06003: ['Count_Student_ParentHighSchoolGraduateIncludesEquivalency_SchoolGrade3_Mathematics', 'MarginOfError_Count_Household_Householder3To4OwnChildren_MarriedCoupleFamilyHousehold_BelowPovertyLevelInThePast12Months', 'Percentile90AcrossModels_DifferenceRelativeToBaseDate2015To2020_Temperature_SSP245', 'Count_Person_50To54Years_Female_NotHispanicOrLatino_WhiteAloneOrInCombinationWithOneOrMoreOtherRaces', 'dc/56md3ndhrmvm7']\n" + ] + } + ], + "source": [ + "stat_vars = dc_client.observation.fetch_available_statistical_variables(entity_dcids=['geoId/06001', 'geoId/06003', 'geoId/06005', 'geoId/06007'])\n", + "\n", + "for dcid, vars in stat_vars.items():\n", + " print(dcid + ':', vars[:5])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BRz43ETvSN1F" + }, + "source": [ + "Let's select some statvars of interest.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "1b-Z3IEY_DpE" + }, + "outputs": [], + "source": [ + "stat_vars_to_query = [\"Count_MortalityEvent_COVID19\",\n", + " \"Count_Person\",\n", + " \"Median_Income_Person\",\n", + " \"Percent_Person_Obesity\",\n", + " \"Amount_Emissions_CarbonDioxide_PerCapita\"\n", + " ]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bA9bMtel_D1f" + }, + "source": [ + "### 3) Build DataFrame" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Q9VsI0veBNuQ" + }, + "source": [ + "**Method A: Use `observations_dataframe()` with CA as `parent_entity`**\n", + "\n", + "Data Commons provides a `observations_dataframe()` method that returns data as a Pandas DataFrame.\n", + "\n", + "For more on how the method works, take a look at the [`observations_dataframe()` documentation page](https://docs.datacommons.org/api/python/v2/observation)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "Qvmu77TI_Kia", + "outputId": "7a306d7c-912c-4f48-8f9b-cdd125a4846d" + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
dateentityentity_namevariablevariable_namevaluefacetIdimportNamemeasurementMethodobservationPeriodprovenanceUrlunit
02020geoId/06095Solano CountyCount_MortalityEvent_COVID19Count of Mortality Event: COVID-19171.02825511676CDC_Mortality_UnderlyingCauseNoneNonehttps://wonder.cdc.gov/ucd-icd10.htmlNone
12020geoId/06115Yuba CountyCount_MortalityEvent_COVID19Count of Mortality Event: COVID-1929.02825511676CDC_Mortality_UnderlyingCauseNoneNonehttps://wonder.cdc.gov/ucd-icd10.htmlNone
22020geoId/06061Placer CountyCount_MortalityEvent_COVID19Count of Mortality Event: COVID-19157.02825511676CDC_Mortality_UnderlyingCauseNoneNonehttps://wonder.cdc.gov/ucd-icd10.htmlNone
32020geoId/06099Stanislaus CountyCount_MortalityEvent_COVID19Count of Mortality Event: COVID-19634.02825511676CDC_Mortality_UnderlyingCauseNoneNonehttps://wonder.cdc.gov/ucd-icd10.htmlNone
42020geoId/06079San Luis Obispo CountyCount_MortalityEvent_COVID19Count of Mortality Event: COVID-19116.02825511676CDC_Mortality_UnderlyingCauseNoneNonehttps://wonder.cdc.gov/ucd-icd10.htmlNone
.......................................
8382022geoId/06031Kings CountyPercent_Person_ObesityPercentage of Adult Population That Is Obese31.62219109638CDC500CrudePrevalenceP1Yhttps://www.cdc.gov/places/index.htmlPercent
8392018geoId/06041Marin CountyPercent_Person_ObesityPercentage of Adult Population That Is Obese21.02329020768CDC500AgeAdjustedPrevalenceP1Yhttps://www.cdc.gov/places/index.htmlNone
8402022geoId/06041Marin CountyPercent_Person_ObesityPercentage of Adult Population That Is Obese23.5276985032CDC500AgeAdjustedPrevalenceP1Yhttps://www.cdc.gov/places/index.htmlPercent
8412018geoId/06041Marin CountyPercent_Person_ObesityPercentage of Adult Population That Is Obese21.41237405506CDC500CrudePrevalenceP1Yhttps://www.cdc.gov/places/index.htmlNone
8422022geoId/06041Marin CountyPercent_Person_ObesityPercentage of Adult Population That Is Obese23.52219109638CDC500CrudePrevalenceP1Yhttps://www.cdc.gov/places/index.htmlPercent
\n", + "

843 rows × 12 columns

\n", + "
" + ], + "text/plain": [ + " date entity entity_name variable \\\n", + "0 2020 geoId/06095 Solano County Count_MortalityEvent_COVID19 \n", + "1 2020 geoId/06115 Yuba County Count_MortalityEvent_COVID19 \n", + "2 2020 geoId/06061 Placer County Count_MortalityEvent_COVID19 \n", + "3 2020 geoId/06099 Stanislaus County Count_MortalityEvent_COVID19 \n", + "4 2020 geoId/06079 San Luis Obispo County Count_MortalityEvent_COVID19 \n", + ".. ... ... ... ... \n", + "838 2022 geoId/06031 Kings County Percent_Person_Obesity \n", + "839 2018 geoId/06041 Marin County Percent_Person_Obesity \n", + "840 2022 geoId/06041 Marin County Percent_Person_Obesity \n", + "841 2018 geoId/06041 Marin County Percent_Person_Obesity \n", + "842 2022 geoId/06041 Marin County Percent_Person_Obesity \n", + "\n", + " variable_name value facetId \\\n", + "0 Count of Mortality Event: COVID-19 171.0 2825511676 \n", + "1 Count of Mortality Event: COVID-19 29.0 2825511676 \n", + "2 Count of Mortality Event: COVID-19 157.0 2825511676 \n", + "3 Count of Mortality Event: COVID-19 634.0 2825511676 \n", + "4 Count of Mortality Event: COVID-19 116.0 2825511676 \n", + ".. ... ... ... \n", + "838 Percentage of Adult Population That Is Obese 31.6 2219109638 \n", + "839 Percentage of Adult Population That Is Obese 21.0 2329020768 \n", + "840 Percentage of Adult Population That Is Obese 23.5 276985032 \n", + "841 Percentage of Adult Population That Is Obese 21.4 1237405506 \n", + "842 Percentage of Adult Population That Is Obese 23.5 2219109638 \n", + "\n", + " importName measurementMethod observationPeriod \\\n", + "0 CDC_Mortality_UnderlyingCause None None \n", + "1 CDC_Mortality_UnderlyingCause None None \n", + "2 CDC_Mortality_UnderlyingCause None None \n", + "3 CDC_Mortality_UnderlyingCause None None \n", + "4 CDC_Mortality_UnderlyingCause None None \n", + ".. ... ... ... \n", + "838 CDC500 CrudePrevalence P1Y \n", + "839 CDC500 AgeAdjustedPrevalence P1Y \n", + "840 CDC500 AgeAdjustedPrevalence P1Y \n", + "841 CDC500 CrudePrevalence P1Y \n", + "842 CDC500 CrudePrevalence P1Y \n", + "\n", + " provenanceUrl unit \n", + "0 https://wonder.cdc.gov/ucd-icd10.html None \n", + "1 https://wonder.cdc.gov/ucd-icd10.html None \n", + "2 https://wonder.cdc.gov/ucd-icd10.html None \n", + "3 https://wonder.cdc.gov/ucd-icd10.html None \n", + "4 https://wonder.cdc.gov/ucd-icd10.html None \n", + ".. ... ... \n", + "838 https://www.cdc.gov/places/index.html Percent \n", + "839 https://www.cdc.gov/places/index.html None \n", + "840 https://www.cdc.gov/places/index.html Percent \n", + "841 https://www.cdc.gov/places/index.html None \n", + "842 https://www.cdc.gov/places/index.html Percent \n", + "\n", + "[843 rows x 12 columns]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = dc_client.observations_dataframe(stat_vars_to_query, entity_type=\"County\", parent_entity=dcid_of_california, date=\"latest\")\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xza-1c15RZ-R" + }, + "source": [ + "**Method B: Use `observations_dataframe()` with a list of DCIDs**\n", + "\n", + "This is the same method as above, but using a precomputed `dcids` list.\n", + "\n", + "Either way is viable! One might be more suited than the other based on the data / DCIDs you already have access to." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "id": "YRUm5ibvH2sY", + "outputId": "9eb2934c-b284-4996-88c6-527870375090" + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
dateentityentity_namevariablevariable_namevaluefacetIdimportNamemeasurementMethodobservationPeriodprovenanceUrlunit
02020geoId/06053Monterey CountyCount_MortalityEvent_COVID19Count of Mortality Event: COVID-19256.02825511676CDC_Mortality_UnderlyingCauseNoneNonehttps://wonder.cdc.gov/ucd-icd10.htmlNone
12020geoId/06031Kings CountyCount_MortalityEvent_COVID19Count of Mortality Event: COVID-19113.02825511676CDC_Mortality_UnderlyingCauseNoneNonehttps://wonder.cdc.gov/ucd-icd10.htmlNone
22020geoId/06013Contra Costa CountyCount_MortalityEvent_COVID19Count of Mortality Event: COVID-19422.02825511676CDC_Mortality_UnderlyingCauseNoneNonehttps://wonder.cdc.gov/ucd-icd10.htmlNone
32020geoId/06035Lassen CountyCount_MortalityEvent_COVID19Count of Mortality Event: COVID-1916.02825511676CDC_Mortality_UnderlyingCauseNoneNonehttps://wonder.cdc.gov/ucd-icd10.htmlNone
42020geoId/06061Placer CountyCount_MortalityEvent_COVID19Count of Mortality Event: COVID-19157.02825511676CDC_Mortality_UnderlyingCauseNoneNonehttps://wonder.cdc.gov/ucd-icd10.htmlNone
.......................................
8382018geoId/06019Fresno CountyPercent_Person_ObesityPercentage of Adult Population That Is Obese33.51237405506CDC500CrudePrevalenceP1Yhttps://www.cdc.gov/places/index.htmlNone
8392022geoId/06063Plumas CountyPercent_Person_ObesityPercentage of Adult Population That Is Obese29.1276985032CDC500AgeAdjustedPrevalenceP1Yhttps://www.cdc.gov/places/index.htmlPercent
8402018geoId/06063Plumas CountyPercent_Person_ObesityPercentage of Adult Population That Is Obese25.62329020768CDC500AgeAdjustedPrevalenceP1Yhttps://www.cdc.gov/places/index.htmlNone
8412022geoId/06063Plumas CountyPercent_Person_ObesityPercentage of Adult Population That Is Obese29.12219109638CDC500CrudePrevalenceP1Yhttps://www.cdc.gov/places/index.htmlPercent
8422018geoId/06063Plumas CountyPercent_Person_ObesityPercentage of Adult Population That Is Obese25.81237405506CDC500CrudePrevalenceP1Yhttps://www.cdc.gov/places/index.htmlNone
\n", + "

843 rows × 12 columns

\n", + "
" + ], + "text/plain": [ + " date entity entity_name variable \\\n", + "0 2020 geoId/06053 Monterey County Count_MortalityEvent_COVID19 \n", + "1 2020 geoId/06031 Kings County Count_MortalityEvent_COVID19 \n", + "2 2020 geoId/06013 Contra Costa County Count_MortalityEvent_COVID19 \n", + "3 2020 geoId/06035 Lassen County Count_MortalityEvent_COVID19 \n", + "4 2020 geoId/06061 Placer County Count_MortalityEvent_COVID19 \n", + ".. ... ... ... ... \n", + "838 2018 geoId/06019 Fresno County Percent_Person_Obesity \n", + "839 2022 geoId/06063 Plumas County Percent_Person_Obesity \n", + "840 2018 geoId/06063 Plumas County Percent_Person_Obesity \n", + "841 2022 geoId/06063 Plumas County Percent_Person_Obesity \n", + "842 2018 geoId/06063 Plumas County Percent_Person_Obesity \n", + "\n", + " variable_name value facetId \\\n", + "0 Count of Mortality Event: COVID-19 256.0 2825511676 \n", + "1 Count of Mortality Event: COVID-19 113.0 2825511676 \n", + "2 Count of Mortality Event: COVID-19 422.0 2825511676 \n", + "3 Count of Mortality Event: COVID-19 16.0 2825511676 \n", + "4 Count of Mortality Event: COVID-19 157.0 2825511676 \n", + ".. ... ... ... \n", + "838 Percentage of Adult Population That Is Obese 33.5 1237405506 \n", + "839 Percentage of Adult Population That Is Obese 29.1 276985032 \n", + "840 Percentage of Adult Population That Is Obese 25.6 2329020768 \n", + "841 Percentage of Adult Population That Is Obese 29.1 2219109638 \n", + "842 Percentage of Adult Population That Is Obese 25.8 1237405506 \n", + "\n", + " importName measurementMethod observationPeriod \\\n", + "0 CDC_Mortality_UnderlyingCause None None \n", + "1 CDC_Mortality_UnderlyingCause None None \n", + "2 CDC_Mortality_UnderlyingCause None None \n", + "3 CDC_Mortality_UnderlyingCause None None \n", + "4 CDC_Mortality_UnderlyingCause None None \n", + ".. ... ... ... \n", + "838 CDC500 CrudePrevalence P1Y \n", + "839 CDC500 AgeAdjustedPrevalence P1Y \n", + "840 CDC500 AgeAdjustedPrevalence P1Y \n", + "841 CDC500 CrudePrevalence P1Y \n", + "842 CDC500 CrudePrevalence P1Y \n", + "\n", + " provenanceUrl unit \n", + "0 https://wonder.cdc.gov/ucd-icd10.html None \n", + "1 https://wonder.cdc.gov/ucd-icd10.html None \n", + "2 https://wonder.cdc.gov/ucd-icd10.html None \n", + "3 https://wonder.cdc.gov/ucd-icd10.html None \n", + "4 https://wonder.cdc.gov/ucd-icd10.html None \n", + ".. ... ... \n", + "838 https://www.cdc.gov/places/index.html None \n", + "839 https://www.cdc.gov/places/index.html Percent \n", + "840 https://www.cdc.gov/places/index.html None \n", + "841 https://www.cdc.gov/places/index.html Percent \n", + "842 https://www.cdc.gov/places/index.html None \n", + "\n", + "[843 rows x 12 columns]" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Get DCID list of counties in CA\n", + "dcid_of_california = \"geoId/06\"\n", + "node_resp = dc_client.node.fetch(node_dcids=[dcid_of_california], expression=\"<-containedInPlace+{typeOf:County}\")\n", + "dcids = get_node_dcids(node_resp, dcid_of_california, \"containedInPlace+\")\n", + "\n", + "# Fetch StatVars for the list of dcids\n", + "df2 = dc_client.observations_dataframe(date=\"latest\", variable_dcids=stat_vars_to_query, entity_dcids=dcids)\n", + "df2" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dMlo_e0YH2sY" + }, + "source": [ + "Because the Data Commons API returns a Pandas Dataframe, you are free to use any functions found in [Pandas' documentation](https://pandas.pydata.org/docs/reference/frame.html) to edit your dataframe." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ALSTltgy_mzM" + }, + "source": [ + "#### Pivot and filter resulting dataframe\n", + "\n", + "We're interested in just the statistical values, so we'll select a single data point for each place-statvar pair:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "SioY7DRTAxi6", + "outputId": "85c8cc7d-ff6f-4470-d60e-64f7b43c923f" + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Count of Mortality Event: COVID-19Median Income of a PopulationPercentage of Adult Population That Is ObeseTotal Population
Alameda County635.056575.023.41622188.0
Alpine CountyNaN35598.029.51141.0
Amador County19.041581.029.141811.0
Butte County132.033600.031.6207172.0
Calaveras County17.037043.026.646565.0
Colusa County15.036820.030.522037.0
Contra Costa County422.054178.023.11155025.0
Del Norte CountyNaN31929.031.726589.0
El Dorado County72.048876.026.6192215.0
Fresno County937.033875.033.51017162.0
Glenn County22.035120.030.628129.0
Humboldt County23.031657.026.2133985.0
Imperial County529.024717.036.4179057.0
Inyo County28.041594.027.318527.0
Kern County678.030912.033.6913820.0
Kings County113.034210.034.1152682.0
Lake County39.031565.030.067878.0
Lassen County16.034293.028.728861.0
Los Angeles County11176.038111.026.59663345.0
Madera County170.030316.032.8162858.0
Marin County114.065068.021.4254407.0
Mariposa CountyNaN36299.026.316919.0
Mendocino County35.034707.028.589108.0
Merced County260.031343.036.3291920.0
Modoc CountyNaN31521.029.98500.0
Mono CountyNaN46048.027.713066.0
Monterey County256.037063.028.1430723.0
Napa County38.047432.025.2133216.0
Nevada County63.040174.022.1102037.0
Orange County2459.046430.021.63135755.0
Placer County157.053071.021.8423561.0
Plumas CountyNaN39230.025.819131.0
Riverside County2657.037929.028.82492442.0
Sacramento County948.042351.028.31584288.0
San Benito County32.044611.028.368175.0
San Bernardino County2747.036178.034.72195611.0
San Diego County1748.045463.024.13269973.0
San Francisco County222.069260.016.8808988.0
San Joaquin County793.038674.033.3800965.0
San Luis Obispo County116.040720.027.1281639.0
San Mateo County248.063325.021.5726353.0
Santa Barbara County177.038787.025.3441257.0
Santa Clara County852.062532.019.11877592.0
Santa Cruz County122.043988.020.9261547.0
Shasta County102.035503.026.6180366.0
Sierra CountyNaN31696.028.03200.0
Siskiyou County14.031315.028.442905.0
Solano County171.045137.027.1449218.0
Sonoma County196.048308.025.3481812.0
Stanislaus County634.036126.032.9551430.0
Sutter County62.034285.027.597948.0
Tehama County44.033015.034.264896.0
Trinity CountyNaN30470.030.115670.0
Tulare County451.031326.035.0479468.0
Tuolumne County33.037688.026.954204.0
Ventura County376.042693.023.9829590.0
Yolo County110.040567.024.5220544.0
Yuba County29.035459.028.185722.0
\n", + "
" + ], + "text/plain": [ + " Count of Mortality Event: COVID-19 \\\n", + "Alameda County 635.0 \n", + "Alpine County NaN \n", + "Amador County 19.0 \n", + "Butte County 132.0 \n", + "Calaveras County 17.0 \n", + "Colusa County 15.0 \n", + "Contra Costa County 422.0 \n", + "Del Norte County NaN \n", + "El Dorado County 72.0 \n", + "Fresno County 937.0 \n", + "Glenn County 22.0 \n", + "Humboldt County 23.0 \n", + "Imperial County 529.0 \n", + "Inyo County 28.0 \n", + "Kern County 678.0 \n", + "Kings County 113.0 \n", + "Lake County 39.0 \n", + "Lassen County 16.0 \n", + "Los Angeles County 11176.0 \n", + "Madera County 170.0 \n", + "Marin County 114.0 \n", + "Mariposa County NaN \n", + "Mendocino County 35.0 \n", + "Merced County 260.0 \n", + "Modoc County NaN \n", + "Mono County NaN \n", + "Monterey County 256.0 \n", + "Napa County 38.0 \n", + "Nevada County 63.0 \n", + "Orange County 2459.0 \n", + "Placer County 157.0 \n", + "Plumas County NaN \n", + "Riverside County 2657.0 \n", + "Sacramento County 948.0 \n", + "San Benito County 32.0 \n", + "San Bernardino County 2747.0 \n", + "San Diego County 1748.0 \n", + "San Francisco County 222.0 \n", + "San Joaquin County 793.0 \n", + "San Luis Obispo County 116.0 \n", + "San Mateo County 248.0 \n", + "Santa Barbara County 177.0 \n", + "Santa Clara County 852.0 \n", + "Santa Cruz County 122.0 \n", + "Shasta County 102.0 \n", + "Sierra County NaN \n", + "Siskiyou County 14.0 \n", + "Solano County 171.0 \n", + "Sonoma County 196.0 \n", + "Stanislaus County 634.0 \n", + "Sutter County 62.0 \n", + "Tehama County 44.0 \n", + "Trinity County NaN \n", + "Tulare County 451.0 \n", + "Tuolumne County 33.0 \n", + "Ventura County 376.0 \n", + "Yolo County 110.0 \n", + "Yuba County 29.0 \n", + "\n", + " Median Income of a Population \\\n", + "Alameda County 56575.0 \n", + "Alpine County 35598.0 \n", + "Amador County 41581.0 \n", + "Butte County 33600.0 \n", + "Calaveras County 37043.0 \n", + "Colusa County 36820.0 \n", + "Contra Costa County 54178.0 \n", + "Del Norte County 31929.0 \n", + "El Dorado County 48876.0 \n", + "Fresno County 33875.0 \n", + "Glenn County 35120.0 \n", + "Humboldt County 31657.0 \n", + "Imperial County 24717.0 \n", + "Inyo County 41594.0 \n", + "Kern County 30912.0 \n", + "Kings County 34210.0 \n", + "Lake County 31565.0 \n", + "Lassen County 34293.0 \n", + "Los Angeles County 38111.0 \n", + "Madera County 30316.0 \n", + "Marin County 65068.0 \n", + "Mariposa County 36299.0 \n", + "Mendocino County 34707.0 \n", + "Merced County 31343.0 \n", + "Modoc County 31521.0 \n", + "Mono County 46048.0 \n", + "Monterey County 37063.0 \n", + "Napa County 47432.0 \n", + "Nevada County 40174.0 \n", + "Orange County 46430.0 \n", + "Placer County 53071.0 \n", + "Plumas County 39230.0 \n", + "Riverside County 37929.0 \n", + "Sacramento County 42351.0 \n", + "San Benito County 44611.0 \n", + "San Bernardino County 36178.0 \n", + "San Diego County 45463.0 \n", + "San Francisco County 69260.0 \n", + "San Joaquin County 38674.0 \n", + "San Luis Obispo County 40720.0 \n", + "San Mateo County 63325.0 \n", + "Santa Barbara County 38787.0 \n", + "Santa Clara County 62532.0 \n", + "Santa Cruz County 43988.0 \n", + "Shasta County 35503.0 \n", + "Sierra County 31696.0 \n", + "Siskiyou County 31315.0 \n", + "Solano County 45137.0 \n", + "Sonoma County 48308.0 \n", + "Stanislaus County 36126.0 \n", + "Sutter County 34285.0 \n", + "Tehama County 33015.0 \n", + "Trinity County 30470.0 \n", + "Tulare County 31326.0 \n", + "Tuolumne County 37688.0 \n", + "Ventura County 42693.0 \n", + "Yolo County 40567.0 \n", + "Yuba County 35459.0 \n", + "\n", + " Percentage of Adult Population That Is Obese \\\n", + "Alameda County 23.4 \n", + "Alpine County 29.5 \n", + "Amador County 29.1 \n", + "Butte County 31.6 \n", + "Calaveras County 26.6 \n", + "Colusa County 30.5 \n", + "Contra Costa County 23.1 \n", + "Del Norte County 31.7 \n", + "El Dorado County 26.6 \n", + "Fresno County 33.5 \n", + "Glenn County 30.6 \n", + "Humboldt County 26.2 \n", + "Imperial County 36.4 \n", + "Inyo County 27.3 \n", + "Kern County 33.6 \n", + "Kings County 34.1 \n", + "Lake County 30.0 \n", + "Lassen County 28.7 \n", + "Los Angeles County 26.5 \n", + "Madera County 32.8 \n", + "Marin County 21.4 \n", + "Mariposa County 26.3 \n", + "Mendocino County 28.5 \n", + "Merced County 36.3 \n", + "Modoc County 29.9 \n", + "Mono County 27.7 \n", + "Monterey County 28.1 \n", + "Napa County 25.2 \n", + "Nevada County 22.1 \n", + "Orange County 21.6 \n", + "Placer County 21.8 \n", + "Plumas County 25.8 \n", + "Riverside County 28.8 \n", + "Sacramento County 28.3 \n", + "San Benito County 28.3 \n", + "San Bernardino County 34.7 \n", + "San Diego County 24.1 \n", + "San Francisco County 16.8 \n", + "San Joaquin County 33.3 \n", + "San Luis Obispo County 27.1 \n", + "San Mateo County 21.5 \n", + "Santa Barbara County 25.3 \n", + "Santa Clara County 19.1 \n", + "Santa Cruz County 20.9 \n", + "Shasta County 26.6 \n", + "Sierra County 28.0 \n", + "Siskiyou County 28.4 \n", + "Solano County 27.1 \n", + "Sonoma County 25.3 \n", + "Stanislaus County 32.9 \n", + "Sutter County 27.5 \n", + "Tehama County 34.2 \n", + "Trinity County 30.1 \n", + "Tulare County 35.0 \n", + "Tuolumne County 26.9 \n", + "Ventura County 23.9 \n", + "Yolo County 24.5 \n", + "Yuba County 28.1 \n", + "\n", + " Total Population \n", + "Alameda County 1622188.0 \n", + "Alpine County 1141.0 \n", + "Amador County 41811.0 \n", + "Butte County 207172.0 \n", + "Calaveras County 46565.0 \n", + "Colusa County 22037.0 \n", + "Contra Costa County 1155025.0 \n", + "Del Norte County 26589.0 \n", + "El Dorado County 192215.0 \n", + "Fresno County 1017162.0 \n", + "Glenn County 28129.0 \n", + "Humboldt County 133985.0 \n", + "Imperial County 179057.0 \n", + "Inyo County 18527.0 \n", + "Kern County 913820.0 \n", + "Kings County 152682.0 \n", + "Lake County 67878.0 \n", + "Lassen County 28861.0 \n", + "Los Angeles County 9663345.0 \n", + "Madera County 162858.0 \n", + "Marin County 254407.0 \n", + "Mariposa County 16919.0 \n", + "Mendocino County 89108.0 \n", + "Merced County 291920.0 \n", + "Modoc County 8500.0 \n", + "Mono County 13066.0 \n", + "Monterey County 430723.0 \n", + "Napa County 133216.0 \n", + "Nevada County 102037.0 \n", + "Orange County 3135755.0 \n", + "Placer County 423561.0 \n", + "Plumas County 19131.0 \n", + "Riverside County 2492442.0 \n", + "Sacramento County 1584288.0 \n", + "San Benito County 68175.0 \n", + "San Bernardino County 2195611.0 \n", + "San Diego County 3269973.0 \n", + "San Francisco County 808988.0 \n", + "San Joaquin County 800965.0 \n", + "San Luis Obispo County 281639.0 \n", + "San Mateo County 726353.0 \n", + "Santa Barbara County 441257.0 \n", + "Santa Clara County 1877592.0 \n", + "Santa Cruz County 261547.0 \n", + "Shasta County 180366.0 \n", + "Sierra County 3200.0 \n", + "Siskiyou County 42905.0 \n", + "Solano County 449218.0 \n", + "Sonoma County 481812.0 \n", + "Stanislaus County 551430.0 \n", + "Sutter County 97948.0 \n", + "Tehama County 64896.0 \n", + "Trinity County 15670.0 \n", + "Tulare County 479468.0 \n", + "Tuolumne County 54204.0 \n", + "Ventura County 829590.0 \n", + "Yolo County 220544.0 \n", + "Yuba County 85722.0 " + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def filter_to_stats_only(df, keep_stat_var_dcid=False):\n", + " df = df[df['measurementMethod'] != 'AgeAdjustedPrevalence']\n", + " columns = 'variable' if keep_stat_var_dcid else 'variable_name'\n", + " df = df.pivot_table(index='entity_name', columns=columns, values='value', aggfunc='first')\n", + " df = df.rename_axis(None, axis=1)\n", + " df.index.name = None\n", + " return df\n", + "\n", + "df = filter_to_stats_only(df)\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DT-o7kBc_Zvg" + }, + "source": [ + "#### (Optional) Saving DataFrames to CSVs\n", + "If you'd like, you can save your generated DataFrame to a CSV to save and reload later.\n", + "\n", + "To do this, use [Pandas' `DataFrame.to_csv()` method](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_csv.html).\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ZD79ZSap_ZDk" + }, + "outputs": [], + "source": [ + "df.to_csv(\"path/to/save/location.csv\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zhG59DwqFr5R" + }, + "source": [ + "There are also premade CSVs available for full download from the Data Commons website, which you can find using the [Data Download tool](https://datacommons.org/tools/download)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "K59a7Knm_LGx" + }, + "source": [ + "### 4) Analyze DataFrame\n", + "\n", + "Now that you have a DataFrame, you are free to use your preferred data science libraries for analysis. The sky is the limit!\n", + "\n", + "To give you some ideas, we've provided some examples below of some analyses using data from Data Commons." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "usXzzWkaCCaf" + }, + "source": [ + "#### Example 1: Correlation plots\n", + "Let's analyze how different statistical variables correlate with one another.\n", + "\n", + "In particular, using the counties in California, let's look at the relationship between median income, physical inactivity, sleep, blood pressure, mental health, cholesterol, and obesity." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ppPamf-KZrXx" + }, + "outputs": [], + "source": [ + "# libraries we'll use for the visualizations\n", + "import matplotlib.pyplot as plt\n", + "\n", + "!pip install heatmapz --upgrade --quiet\n", + "from heatmap import heatmap, corrplot" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 883 + }, + "id": "U0u-9rvdCFe_", + "outputId": "12d986ac-906c-437c-b815-7e7ba81b900f" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dcid_of_california = \"geoId/06\"\n", + "# List of StatVars\n", + "stat_vars_to_query = [\n", + " \"Median_Income_Person\",\n", + " \"Percent_Person_PhysicalInactivity\",\n", + " \"Percent_Person_SleepLessThan7Hours\",\n", + " \"Percent_Person_WithHighBloodPressure\",\n", + " \"Percent_Person_WithMentalHealthNotGood\",\n", + " \"Percent_Person_WithHighCholesterol\",\n", + " \"Percent_Person_Obesity\"\n", + "\n", + "]\n", + "\n", + "# Build Data Frame\n", + "df = dc_client.observations_dataframe(stat_vars_to_query, entity_type=\"County\", parent_entity=dcid_of_california, date=\"latest\")\n", + "df = filter_to_stats_only(df)\n", + "\n", + "# Generate a correlation matrix plot\n", + "# We'll use the heatmapz package to draw a nice one.\n", + "plt.figure(figsize=(8, 8))\n", + "corrplot(df.corr(), size_scale=300)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "prnF7AHpCGCz" + }, + "source": [ + "#### Example 2: Regression analysis\n", + "\n", + "Keeping the scope of our analysis to counties in California, let's analyze the relationship between population and Covid-19 case numbers." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "id": "xvpeIPjAbLxV" + }, + "outputs": [], + "source": [ + "# libraries we'll use for models and the visualizations\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 523 + }, + "id": "rTD7eN7zCIl_", + "outputId": "1b54bb85-d6bf-43d6-c5c6-9b109de02630" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dcid_of_california = \"geoId/06\"\n", + "# List of StatVars\n", + "stat_vars_to_query = [\n", + " \"Count_MortalityEvent_COVID19\",\n", + " \"Count_Person\",\n", + "\n", + "]\n", + "\n", + "# Build Data Frame\n", + "df = dc_client.observations_dataframe(stat_vars_to_query, entity_type=\"County\", parent_entity=dcid_of_california, date=\"latest\")\n", + "df = filter_to_stats_only(df, keep_stat_var_dcid=True)\n", + "\n", + "sns.lmplot(x=\"Count_Person\",\n", + " y=\"Count_MortalityEvent_COVID19\",\n", + " data=df)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_BfCeN5EHyKm" + }, + "source": [ + "For more examples of using the Data Commons Python API, take a look at [the tutorials page](https://docs.datacommons.org/api/python/v2/tutorials).\n" + ] + } + ], + "metadata": { + "colab": { + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "display_name": ".venv", + "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.12.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/notebooks/intro_data_science/Feature_Engineering.ipynb b/notebooks/intro_data_science/Feature_Engineering.ipynb new file mode 100644 index 00000000..5bf4fd51 --- /dev/null +++ b/notebooks/intro_data_science/Feature_Engineering.ipynb @@ -0,0 +1,5875 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "view-in-github" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0ARQO5dmH3Em" + }, + "source": [ + "Copyright 2025 Google LLC.\n", + "SPDX-License-Identifier: Apache-2.0" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YRw6WuNZEyeH" + }, + "source": [ + "# Exploring Feature Engineering\n", + "\n", + "Welcome! In this lesson, we'll be exploring various techniques for feature engineering. We'll be walking through the steps you take to set up your data for your machine learning models, starting with acquiring and exploring the data, working through different transformations and feature representation choices, and analyzing how those design decisions affect our model's results.\n", + "\n", + "## Learning objectives:\n", + "In this lesson, we'll be covering\n", + "* Tools for data exploration and visualization\n", + "* Useful feature representations\n", + "* Useful feature transformations\n", + "* Why is feature engineering important?\n", + "\n", + "### Need extra help?\n", + "\n", + "If you're new to Google Colab, take a look at [this getting started tutorial](https://colab.research.google.com/notebooks/intro.ipynb).\n", + "\n", + "To build more familiarity with the Data Commons API, check out these [Data Commons tutorials](https://docs.datacommons.org/api/python/v2/tutorials.html).\n", + "\n", + "And for help with Pandas and manipulating dataframes, take a look at the [Pandas documentation](https://pandas.pydata.org/docs/reference/index.html).\n", + "\n", + "We'll be using the scikit-learn library for implementing our models today. Documentation can be found [here](https://scikit-learn.org/stable/modules/classes.html).\n", + "\n", + "As usual, if you have any other questions, please reach out to your course staff!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ha6_UkviFoVW" + }, + "source": [ + "## 0) Introduction and setup\n", + "\n", + "As a result of the COVID-19 pandemic, we have very detailed statistics on the number of COVID-19 cases across the United States. Many studies have been done on the medical bases of the disease, but it is widely known that societal factors, like public policy, can greatly affect case numbers. Today, we'll take advantage of Data Commons, an open-source project that allows us to easily combine data from multiple different sources, to analyze the impact of social factors on COVID-19 cases. While public policy is hard to quantify into a data point, perhaps we can find other social factors that correlate with the number of COVID-19 cases.\n", + "\n", + "**Our data science question:** How do various social factors (median income, household size, etc.) affect the cummulative number of COVID-19 cases?\n", + "\n", + "Run the following code to install and load the packages required." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "gUETYfc0EuGg" + }, + "outputs": [], + "source": [ + "# We need to install the Data Commons API, since it doesn't ship natively with\n", + "# most Python installations.\n", + "\n", + "# In Colab, we'll install the Data Commons Python APIs through pip.\n", + "\n", + "!pip install \"datacommons-client[Pandas]\" --upgrade --quiet\n", + "\n", + "# We'll also install some nice libraries for some pretty plots\n", + "# Import the two methods from heatmap library to make pretty correlation plots\n", + "!pip install heatmapz --upgrade --quiet" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "PX-TZz1iGmm-" + }, + "outputs": [], + "source": [ + "# Imports\n", + "\n", + "# Data Commons Python APIs\n", + "import datacommons_client as dc\n", + "\n", + "# For manipulating data\n", + "import pandas as pd\n", + "\n", + "# For creating a model\n", + "from sklearn import linear_model\n", + "from sklearn.metrics import mean_squared_error as mse\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "# For visualizations\n", + "import matplotlib.pyplot as plt\n", + "from heatmap import heatmap, corrplot" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "oHM0XwHZehic" + }, + "outputs": [], + "source": [ + "# Create a Data Commons client\n", + "YOUR_API_KEY = \"your API key here\"\n", + "dc_client = dc.DataCommonsClient(api_key=YOUR_API_KEY)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To get your own API key, see [Obtain an API key](https://docs.datacommons.org/api/index.html#get-key) for information." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4AQwbayf79nY" + }, + "source": [ + "## 1) Acquiring data" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lEmUwQrMysIV" + }, + "source": [ + "\n", + "### 1.1) Setting the scope\n", + "As a starting point, we'll keep the scope of our analysis to the United States. Your job will be to select a state of interest and query for data at the county level, across all counties for your state of choice.\n", + "\n", + "In Data Commons, every concept has a unique identifier, called a DCID, that's needed when querying for data. First, let's grab the DCIDs of all counties for your state of choice. We can use the `node` endpoint [`fetch_place_children()`](https://docs.datacommons.org/api/python/v2/node.html#fetch_place_children) method to list the DCIDs for all counties in your state of choice easily!\n", + "\n", + "**1.1)** Choose a US state to analyze. Use the [Data Commons Graph Browser](https://datacommons.org/browser/) to find the DCID for your state of choice, then fill in the code box below with the DCID.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "uBkIIdJIsuTJ", + "outputId": "a3e88c1e-9ad6-4849-b4b7-056c40f9cf0f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['geoId/06001', 'geoId/06003', 'geoId/06005', 'geoId/06007', 'geoId/06009', 'geoId/06011', 'geoId/06013', 'geoId/06015', 'geoId/06017', 'geoId/06019', 'geoId/06021', 'geoId/06023', 'geoId/06025', 'geoId/06027', 'geoId/06029', 'geoId/06031', 'geoId/06033', 'geoId/06035', 'geoId/06037', 'geoId/06039', 'geoId/06041', 'geoId/06043', 'geoId/06045', 'geoId/06047', 'geoId/06049', 'geoId/06051', 'geoId/06053', 'geoId/06055', 'geoId/06057', 'geoId/06059', 'geoId/06061', 'geoId/06063', 'geoId/06065', 'geoId/06067', 'geoId/06069', 'geoId/06071', 'geoId/06073', 'geoId/06075', 'geoId/06077', 'geoId/06079', 'geoId/06081', 'geoId/06083', 'geoId/06085', 'geoId/06087', 'geoId/06089', 'geoId/06091', 'geoId/06093', 'geoId/06095', 'geoId/06097', 'geoId/06099', 'geoId/06101', 'geoId/06103', 'geoId/06105', 'geoId/06107', 'geoId/06109', 'geoId/06111', 'geoId/06113', 'geoId/06115']\n" + ] + } + ], + "source": [ + "# Choose your state:\n", + "your_state_dcid = \"geoId/06\" # Using California as an example # YOUR DCID HERE\n", + "\n", + "# Get a list of all DCIDs for counties in that state.\n", + "counties = dc_client.node.fetch_place_children(place_dcids=[your_state_dcid], children_type=\"County\")[your_state_dcid]\n", + "\n", + "# Extract just the DCIDs\n", + "county_dcids = [county[\"dcid\"] for county in counties]\n", + "print(county_dcids)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "olXRa5im8lat" + }, + "source": [ + "### 1.2) Finding features" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "44s3x-SHcyqQ" + }, + "source": [ + "#### 1.2.1) Find candidate features\n", + "Now that we have the DCIDs of all counties for your state of interest, let's figure out what features to use!\n", + "\n", + "First, let's query Data Commons for data we're interested in using the [`observations_dataframe()`](https://docs.datacommons.org/api/python/v2/pandas.html) method.\n", + "\n", + "We'll start out with the following features:\n", + "\n", + "* Population\n", + "* Median income\n", + "* Number of households with 4 or more people\n", + "\n", + "And of course, since we're analyzing COVID-19 cases, we'll query for that too.\n", + "\n", + "At this stage, we're just loading in data that is potentially interesting to include in our analysis.\n", + "\n", + "**1.2A)** Take a look at the [Statistical Variable Explorer](https://datacommons.org/tools/statvar). Find at least 3 more variables to add to your analysis.\n", + "\n", + "_Note: not all variables are available for all locations. If you notice the dataframe has some missing columns, try a different variable!_" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 704 + }, + "id": "-KPyhkIADWyV", + "outputId": "7e982af6-0f4e-4c66-b341-e62b08d9a8a8" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"raw_df\",\n \"rows\": 851,\n \"fields\": [\n {\n \"column\": \"date\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 8,\n \"samples\": [\n \"2022-05-13\",\n \"2021\",\n \"2023\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"entity\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 58,\n \"samples\": [\n \"geoId/06003\",\n \"geoId/06005\",\n \"geoId/06081\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"entity_name\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 58,\n \"samples\": [\n \"Alpine County\",\n \"Amador County\",\n \"San Mateo County\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"variable\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 5,\n \"samples\": [\n \"CumulativeCount_MedicalConditionIncident_COVID_19_ConfirmedOrProbableCase\",\n \"Median_Income_Person\",\n \"Count_Person\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"variable_name\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 5,\n \"samples\": [\n \"Cumulative Count of COVID-19 Cases\",\n \"Median Income of a Population\",\n \"Total Population\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"value\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1130812.0818661533,\n \"min\": 103.0,\n \"max\": 10039107.0,\n \"num_unique_values\": 811,\n \"samples\": [\n 257332.0,\n 3463469.0,\n 1552058.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"facetId\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 13,\n \"samples\": [\n \"1305418269\",\n \"3870053105\",\n \"1145703171\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"importName\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 11,\n \"samples\": [\n \"CensusACS5YearSurvey_SubjectTables_S0101\",\n \"CensusACS5YearSurvey\",\n \"CensusACS5YearSurvey_SubjectTables_S0701\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"measurementMethod\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 6,\n \"samples\": [\n \"CensusACS5yrSurvey\",\n \"NYT_COVID19_GitHub\",\n \"CensusACS1yrSurvey\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"observationPeriod\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"P1Y\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"provenanceUrl\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 10,\n \"samples\": [\n \"https://data.census.gov/cedsci/table?q=S0701&tid=ACSST5Y2019.S0701\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"unit\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"USDollar\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe", + "variable_name": "raw_df" + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
dateentityentity_namevariablevariable_namevaluefacetIdimportNamemeasurementMethodobservationPeriodprovenanceUrlunit
02023geoId/06003Alpine CountyCount_Household_With4OrMorePersonCount of Household: 4 Person or More103.01145703171CensusACS5YearSurveyCensusACS5yrSurveyNonehttps://www.census.gov/programs-surveys/acs/da...None
12023geoId/06009Calaveras CountyCount_Household_With4OrMorePersonCount of Household: 4 Person or More3075.01145703171CensusACS5YearSurveyCensusACS5yrSurveyNonehttps://www.census.gov/programs-surveys/acs/da...None
22023geoId/06113Yolo CountyCount_Household_With4OrMorePersonCount of Household: 4 Person or More21166.01145703171CensusACS5YearSurveyCensusACS5yrSurveyNonehttps://www.census.gov/programs-surveys/acs/da...None
32023geoId/06051Mono CountyCount_Household_With4OrMorePersonCount of Household: 4 Person or More1105.01145703171CensusACS5YearSurveyCensusACS5yrSurveyNonehttps://www.census.gov/programs-surveys/acs/da...None
42023geoId/06091Sierra CountyCount_Household_With4OrMorePersonCount of Household: 4 Person or More114.01145703171CensusACS5YearSurveyCensusACS5yrSurveyNonehttps://www.census.gov/programs-surveys/acs/da...None
.......................................
8462021geoId/06019Fresno CountyMedian_Income_PersonMedian Income of a Population28697.03214767095CensusACS5YearSurvey_SubjectTables_S0701CensusACS5yrSurveySubjectTableNonehttps://data.census.gov/cedsci/table?q=S0701&t...USDollar
8472023geoId/06027Inyo CountyMedian_Income_PersonMedian Income of a Population41594.01305418269CensusACS5YearSurveyCensusACS5yrSurveyNonehttps://www.census.gov/programs-surveys/acs/da...USDollar
8482021geoId/06027Inyo CountyMedian_Income_PersonMedian Income of a Population33551.03214767095CensusACS5YearSurvey_SubjectTables_S0701CensusACS5yrSurveySubjectTableNonehttps://data.census.gov/cedsci/table?q=S0701&t...USDollar
8492023geoId/06093Siskiyou CountyMedian_Income_PersonMedian Income of a Population31315.01305418269CensusACS5YearSurveyCensusACS5yrSurveyNonehttps://www.census.gov/programs-surveys/acs/da...USDollar
8502021geoId/06093Siskiyou CountyMedian_Income_PersonMedian Income of a Population26928.03214767095CensusACS5YearSurvey_SubjectTables_S0701CensusACS5yrSurveySubjectTableNonehttps://data.census.gov/cedsci/table?q=S0701&t...USDollar
\n", + "

851 rows × 12 columns

\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + " date entity entity_name variable \\\n", + "0 2023 geoId/06003 Alpine County Count_Household_With4OrMorePerson \n", + "1 2023 geoId/06009 Calaveras County Count_Household_With4OrMorePerson \n", + "2 2023 geoId/06113 Yolo County Count_Household_With4OrMorePerson \n", + "3 2023 geoId/06051 Mono County Count_Household_With4OrMorePerson \n", + "4 2023 geoId/06091 Sierra County Count_Household_With4OrMorePerson \n", + ".. ... ... ... ... \n", + "846 2021 geoId/06019 Fresno County Median_Income_Person \n", + "847 2023 geoId/06027 Inyo County Median_Income_Person \n", + "848 2021 geoId/06027 Inyo County Median_Income_Person \n", + "849 2023 geoId/06093 Siskiyou County Median_Income_Person \n", + "850 2021 geoId/06093 Siskiyou County Median_Income_Person \n", + "\n", + " variable_name value facetId \\\n", + "0 Count of Household: 4 Person or More 103.0 1145703171 \n", + "1 Count of Household: 4 Person or More 3075.0 1145703171 \n", + "2 Count of Household: 4 Person or More 21166.0 1145703171 \n", + "3 Count of Household: 4 Person or More 1105.0 1145703171 \n", + "4 Count of Household: 4 Person or More 114.0 1145703171 \n", + ".. ... ... ... \n", + "846 Median Income of a Population 28697.0 3214767095 \n", + "847 Median Income of a Population 41594.0 1305418269 \n", + "848 Median Income of a Population 33551.0 3214767095 \n", + "849 Median Income of a Population 31315.0 1305418269 \n", + "850 Median Income of a Population 26928.0 3214767095 \n", + "\n", + " importName measurementMethod \\\n", + "0 CensusACS5YearSurvey CensusACS5yrSurvey \n", + "1 CensusACS5YearSurvey CensusACS5yrSurvey \n", + "2 CensusACS5YearSurvey CensusACS5yrSurvey \n", + "3 CensusACS5YearSurvey CensusACS5yrSurvey \n", + "4 CensusACS5YearSurvey CensusACS5yrSurvey \n", + ".. ... ... \n", + "846 CensusACS5YearSurvey_SubjectTables_S0701 CensusACS5yrSurveySubjectTable \n", + "847 CensusACS5YearSurvey CensusACS5yrSurvey \n", + "848 CensusACS5YearSurvey_SubjectTables_S0701 CensusACS5yrSurveySubjectTable \n", + "849 CensusACS5YearSurvey CensusACS5yrSurvey \n", + "850 CensusACS5YearSurvey_SubjectTables_S0701 CensusACS5yrSurveySubjectTable \n", + "\n", + " observationPeriod provenanceUrl \\\n", + "0 None https://www.census.gov/programs-surveys/acs/da... \n", + "1 None https://www.census.gov/programs-surveys/acs/da... \n", + "2 None https://www.census.gov/programs-surveys/acs/da... \n", + "3 None https://www.census.gov/programs-surveys/acs/da... \n", + "4 None https://www.census.gov/programs-surveys/acs/da... \n", + ".. ... ... \n", + "846 None https://data.census.gov/cedsci/table?q=S0701&t... \n", + "847 None https://www.census.gov/programs-surveys/acs/da... \n", + "848 None https://data.census.gov/cedsci/table?q=S0701&t... \n", + "849 None https://www.census.gov/programs-surveys/acs/da... \n", + "850 None https://data.census.gov/cedsci/table?q=S0701&t... \n", + "\n", + " unit \n", + "0 None \n", + "1 None \n", + "2 None \n", + "3 None \n", + "4 None \n", + ".. ... \n", + "846 USDollar \n", + "847 USDollar \n", + "848 USDollar \n", + "849 USDollar \n", + "850 USDollar \n", + "\n", + "[851 rows x 12 columns]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create a Pandas dataframe containing data for each of the features\n", + "# listed above. Each row will represent a single county - feature pair\n", + "\n", + "stat_vars_to_query = [\n", + " \"CumulativeCount_MedicalConditionIncident_COVID_19_ConfirmedOrProbableCase\",\n", + " \"Count_Person\",\n", + " \"Count_Person_MarriedAndNotSeparated\",\n", + " \"Median_Income_Person\",\n", + " \"Count_Household_With4OrMorePerson\"\n", + "]\n", + "\n", + "# Use the \"latest\" value for the date\n", + "raw_df = dc_client.observations_dataframe(variable_dcids=stat_vars_to_query, date=\"latest\", entity_dcids=county_dcids)\n", + "raw_df" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "uFjYXk4T1jKF" + }, + "source": [ + "Before we can proceed further, we need to remove the additional columns that aren't relevant, and pivot the table so that the matrix only consists of numerical observations. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "KCzNTzQ318vS", + "outputId": "1a53e309-e449-4314-d969-91472b691e90" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"df\",\n \"rows\": 58,\n \"fields\": [\n {\n \"column\": \"CumulativeCount_MedicalConditionIncident_COVID_19_ConfirmedOrProbableCase\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 406565.9999807545,\n \"min\": 126.0,\n \"max\": 2908425.0,\n \"num_unique_values\": 58,\n \"samples\": [\n 284054.0,\n 4549.0,\n 13636.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1437255.7987916414,\n \"min\": 1099.0,\n \"max\": 9757179.0,\n \"num_unique_values\": 58,\n \"samples\": [\n 1649060.0,\n 22074.0,\n 69159.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person_MarriedAndNotSeparated\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 525224.8977358631,\n \"min\": 706.0,\n \"max\": 3463469.0,\n \"num_unique_values\": 58,\n \"samples\": [\n 677916.0,\n 8772.0,\n 26497.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Median_Income_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 9434.683907047034,\n \"min\": 24717.0,\n \"max\": 69260.0,\n \"num_unique_values\": 58,\n \"samples\": [\n 56575.0,\n 36820.0,\n 44611.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Household_With4OrMorePerson\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 142918.55616768374,\n \"min\": 103.0,\n \"max\": 967873.0,\n \"num_unique_values\": 58,\n \"samples\": [\n 155852.0,\n 2203.0,\n 7695.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe", + "variable_name": "df" + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CumulativeCount_MedicalConditionIncident_COVID_19_ConfirmedOrProbableCaseCount_PersonCount_Person_MarriedAndNotSeparatedMedian_Income_PersonCount_Household_With4OrMorePerson
Alameda County284054.01649060.0677916.056575.0155852.0
Alpine County126.01099.0706.035598.0103.0
Amador County9242.042026.018828.041581.02923.0
Butte County40181.0208334.073463.033600.016410.0
Calaveras County7754.046505.022308.037043.03075.0
Colusa County4549.022074.08772.036820.02203.0
Contra Costa County209958.01172607.0493526.054178.0118442.0
Del Norte County6381.027009.010455.031929.02309.0
El Dorado County30508.0192823.092581.048876.016166.0
Fresno County257611.01024125.0341599.033875.0107943.0
Glenn County6631.028304.011278.035120.02500.0
Humboldt County20952.0132380.045314.031657.09713.0
Imperial County66715.0181724.059722.024717.018112.0
Inyo County4636.018485.07493.041594.01043.0
Kern County244681.0922529.0310288.030912.097654.0
Kings County55429.0154913.052479.034210.016052.0
Lake County11699.067764.023231.031565.05140.0
Lassen County10751.028340.010726.034293.01615.0
Los Angeles County2908425.09757179.03463469.038111.0967873.0
Madera County43685.0165432.055566.030316.016535.0
Marin County38685.0256400.0111744.065068.020703.0
Mariposa County3145.017048.07707.036299.01233.0
Mendocino County16568.089175.031433.034707.06681.0
Merced County72959.0296774.094168.031343.030146.0
Modoc County1000.08491.03649.031521.0465.0
Mono County3144.012991.06096.046048.01105.0
Monterey County95140.0436251.0158299.037063.048002.0
Napa County27765.0132727.057521.047432.012018.0
Nevada County17503.0102195.047214.040174.06898.0
Orange County600384.03170435.01309331.046430.0321300.0
Placer County71527.0433822.0193241.053071.037963.0
Plumas County3379.018834.08369.039230.0999.0
Riverside County626695.02529933.0954331.037929.0268129.0
Sacramento County314407.01611231.0588558.042351.0154446.0
San Benito County13636.069159.026497.044611.07695.0
San Bernardino County597377.02214281.0786363.036178.0242009.0
San Diego County824586.03298799.01300502.045463.0298453.0
San Francisco County143959.0827526.0301144.069260.058854.0
San Joaquin County178501.0816108.0292240.038674.088055.0
San Luis Obispo County57556.0281843.0114590.040720.021754.0
San Mateo County137238.0742893.0324408.063325.068046.0
Santa Barbara County92683.0444500.0158537.038787.043491.0
Santa Clara County342015.01926325.0815675.062532.0185999.0
Santa Cruz County52532.0262406.0102154.043988.023759.0
Shasta County36988.0181121.070343.035503.014201.0
Sierra County324.03113.01423.031696.0114.0
Siskiyou County7478.042498.017822.031315.03024.0
Solano County89419.0455101.0176011.045137.042824.0
Sonoma County90191.0485375.0198744.048308.042270.0
Stanislaus County136645.0556972.0201688.036126.059134.0
Sutter County23045.098545.038857.034285.010428.0
Tehama County14753.064451.026142.033015.05817.0
Trinity County1485.015642.04715.030470.0604.0
Tulare County136125.0483546.0166592.031326.056914.0
Tuolumne County13758.053893.022067.037688.03488.0
Ventura County186062.0835427.0337666.042693.082532.0
Yolo County41061.0225251.078658.040567.021166.0
Yuba County17944.087469.030233.035459.08439.0
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + " CumulativeCount_MedicalConditionIncident_COVID_19_ConfirmedOrProbableCase \\\n", + "Alameda County 284054.0 \n", + "Alpine County 126.0 \n", + "Amador County 9242.0 \n", + "Butte County 40181.0 \n", + "Calaveras County 7754.0 \n", + "Colusa County 4549.0 \n", + "Contra Costa County 209958.0 \n", + "Del Norte County 6381.0 \n", + "El Dorado County 30508.0 \n", + "Fresno County 257611.0 \n", + "Glenn County 6631.0 \n", + "Humboldt County 20952.0 \n", + "Imperial County 66715.0 \n", + "Inyo County 4636.0 \n", + "Kern County 244681.0 \n", + "Kings County 55429.0 \n", + "Lake County 11699.0 \n", + "Lassen County 10751.0 \n", + "Los Angeles County 2908425.0 \n", + "Madera County 43685.0 \n", + "Marin County 38685.0 \n", + "Mariposa County 3145.0 \n", + "Mendocino County 16568.0 \n", + "Merced County 72959.0 \n", + "Modoc County 1000.0 \n", + "Mono County 3144.0 \n", + "Monterey County 95140.0 \n", + "Napa County 27765.0 \n", + "Nevada County 17503.0 \n", + "Orange County 600384.0 \n", + "Placer County 71527.0 \n", + "Plumas County 3379.0 \n", + "Riverside County 626695.0 \n", + "Sacramento County 314407.0 \n", + "San Benito County 13636.0 \n", + "San Bernardino County 597377.0 \n", + "San Diego County 824586.0 \n", + "San Francisco County 143959.0 \n", + "San Joaquin County 178501.0 \n", + "San Luis Obispo County 57556.0 \n", + "San Mateo County 137238.0 \n", + "Santa Barbara County 92683.0 \n", + "Santa Clara County 342015.0 \n", + "Santa Cruz County 52532.0 \n", + "Shasta County 36988.0 \n", + "Sierra County 324.0 \n", + "Siskiyou County 7478.0 \n", + "Solano County 89419.0 \n", + "Sonoma County 90191.0 \n", + "Stanislaus County 136645.0 \n", + "Sutter County 23045.0 \n", + "Tehama County 14753.0 \n", + "Trinity County 1485.0 \n", + "Tulare County 136125.0 \n", + "Tuolumne County 13758.0 \n", + "Ventura County 186062.0 \n", + "Yolo County 41061.0 \n", + "Yuba County 17944.0 \n", + "\n", + " Count_Person Count_Person_MarriedAndNotSeparated \\\n", + "Alameda County 1649060.0 677916.0 \n", + "Alpine County 1099.0 706.0 \n", + "Amador County 42026.0 18828.0 \n", + "Butte County 208334.0 73463.0 \n", + "Calaveras County 46505.0 22308.0 \n", + "Colusa County 22074.0 8772.0 \n", + "Contra Costa County 1172607.0 493526.0 \n", + "Del Norte County 27009.0 10455.0 \n", + "El Dorado County 192823.0 92581.0 \n", + "Fresno County 1024125.0 341599.0 \n", + "Glenn County 28304.0 11278.0 \n", + "Humboldt County 132380.0 45314.0 \n", + "Imperial County 181724.0 59722.0 \n", + "Inyo County 18485.0 7493.0 \n", + "Kern County 922529.0 310288.0 \n", + "Kings County 154913.0 52479.0 \n", + "Lake County 67764.0 23231.0 \n", + "Lassen County 28340.0 10726.0 \n", + "Los Angeles County 9757179.0 3463469.0 \n", + "Madera County 165432.0 55566.0 \n", + "Marin County 256400.0 111744.0 \n", + "Mariposa County 17048.0 7707.0 \n", + "Mendocino County 89175.0 31433.0 \n", + "Merced County 296774.0 94168.0 \n", + "Modoc County 8491.0 3649.0 \n", + "Mono County 12991.0 6096.0 \n", + "Monterey County 436251.0 158299.0 \n", + "Napa County 132727.0 57521.0 \n", + "Nevada County 102195.0 47214.0 \n", + "Orange County 3170435.0 1309331.0 \n", + "Placer County 433822.0 193241.0 \n", + "Plumas County 18834.0 8369.0 \n", + "Riverside County 2529933.0 954331.0 \n", + "Sacramento County 1611231.0 588558.0 \n", + "San Benito County 69159.0 26497.0 \n", + "San Bernardino County 2214281.0 786363.0 \n", + "San Diego County 3298799.0 1300502.0 \n", + "San Francisco County 827526.0 301144.0 \n", + "San Joaquin County 816108.0 292240.0 \n", + "San Luis Obispo County 281843.0 114590.0 \n", + "San Mateo County 742893.0 324408.0 \n", + "Santa Barbara County 444500.0 158537.0 \n", + "Santa Clara County 1926325.0 815675.0 \n", + "Santa Cruz County 262406.0 102154.0 \n", + "Shasta County 181121.0 70343.0 \n", + "Sierra County 3113.0 1423.0 \n", + "Siskiyou County 42498.0 17822.0 \n", + "Solano County 455101.0 176011.0 \n", + "Sonoma County 485375.0 198744.0 \n", + "Stanislaus County 556972.0 201688.0 \n", + "Sutter County 98545.0 38857.0 \n", + "Tehama County 64451.0 26142.0 \n", + "Trinity County 15642.0 4715.0 \n", + "Tulare County 483546.0 166592.0 \n", + "Tuolumne County 53893.0 22067.0 \n", + "Ventura County 835427.0 337666.0 \n", + "Yolo County 225251.0 78658.0 \n", + "Yuba County 87469.0 30233.0 \n", + "\n", + " Median_Income_Person \\\n", + "Alameda County 56575.0 \n", + "Alpine County 35598.0 \n", + "Amador County 41581.0 \n", + "Butte County 33600.0 \n", + "Calaveras County 37043.0 \n", + "Colusa County 36820.0 \n", + "Contra Costa County 54178.0 \n", + "Del Norte County 31929.0 \n", + "El Dorado County 48876.0 \n", + "Fresno County 33875.0 \n", + "Glenn County 35120.0 \n", + "Humboldt County 31657.0 \n", + "Imperial County 24717.0 \n", + "Inyo County 41594.0 \n", + "Kern County 30912.0 \n", + "Kings County 34210.0 \n", + "Lake County 31565.0 \n", + "Lassen County 34293.0 \n", + "Los Angeles County 38111.0 \n", + "Madera County 30316.0 \n", + "Marin County 65068.0 \n", + "Mariposa County 36299.0 \n", + "Mendocino County 34707.0 \n", + "Merced County 31343.0 \n", + "Modoc County 31521.0 \n", + "Mono County 46048.0 \n", + "Monterey County 37063.0 \n", + "Napa County 47432.0 \n", + "Nevada County 40174.0 \n", + "Orange County 46430.0 \n", + "Placer County 53071.0 \n", + "Plumas County 39230.0 \n", + "Riverside County 37929.0 \n", + "Sacramento County 42351.0 \n", + "San Benito County 44611.0 \n", + "San Bernardino County 36178.0 \n", + "San Diego County 45463.0 \n", + "San Francisco County 69260.0 \n", + "San Joaquin County 38674.0 \n", + "San Luis Obispo County 40720.0 \n", + "San Mateo County 63325.0 \n", + "Santa Barbara County 38787.0 \n", + "Santa Clara County 62532.0 \n", + "Santa Cruz County 43988.0 \n", + "Shasta County 35503.0 \n", + "Sierra County 31696.0 \n", + "Siskiyou County 31315.0 \n", + "Solano County 45137.0 \n", + "Sonoma County 48308.0 \n", + "Stanislaus County 36126.0 \n", + "Sutter County 34285.0 \n", + "Tehama County 33015.0 \n", + "Trinity County 30470.0 \n", + "Tulare County 31326.0 \n", + "Tuolumne County 37688.0 \n", + "Ventura County 42693.0 \n", + "Yolo County 40567.0 \n", + "Yuba County 35459.0 \n", + "\n", + " Count_Household_With4OrMorePerson \n", + "Alameda County 155852.0 \n", + "Alpine County 103.0 \n", + "Amador County 2923.0 \n", + "Butte County 16410.0 \n", + "Calaveras County 3075.0 \n", + "Colusa County 2203.0 \n", + "Contra Costa County 118442.0 \n", + "Del Norte County 2309.0 \n", + "El Dorado County 16166.0 \n", + "Fresno County 107943.0 \n", + "Glenn County 2500.0 \n", + "Humboldt County 9713.0 \n", + "Imperial County 18112.0 \n", + "Inyo County 1043.0 \n", + "Kern County 97654.0 \n", + "Kings County 16052.0 \n", + "Lake County 5140.0 \n", + "Lassen County 1615.0 \n", + "Los Angeles County 967873.0 \n", + "Madera County 16535.0 \n", + "Marin County 20703.0 \n", + "Mariposa County 1233.0 \n", + "Mendocino County 6681.0 \n", + "Merced County 30146.0 \n", + "Modoc County 465.0 \n", + "Mono County 1105.0 \n", + "Monterey County 48002.0 \n", + "Napa County 12018.0 \n", + "Nevada County 6898.0 \n", + "Orange County 321300.0 \n", + "Placer County 37963.0 \n", + "Plumas County 999.0 \n", + "Riverside County 268129.0 \n", + "Sacramento County 154446.0 \n", + "San Benito County 7695.0 \n", + "San Bernardino County 242009.0 \n", + "San Diego County 298453.0 \n", + "San Francisco County 58854.0 \n", + "San Joaquin County 88055.0 \n", + "San Luis Obispo County 21754.0 \n", + "San Mateo County 68046.0 \n", + "Santa Barbara County 43491.0 \n", + "Santa Clara County 185999.0 \n", + "Santa Cruz County 23759.0 \n", + "Shasta County 14201.0 \n", + "Sierra County 114.0 \n", + "Siskiyou County 3024.0 \n", + "Solano County 42824.0 \n", + "Sonoma County 42270.0 \n", + "Stanislaus County 59134.0 \n", + "Sutter County 10428.0 \n", + "Tehama County 5817.0 \n", + "Trinity County 604.0 \n", + "Tulare County 56914.0 \n", + "Tuolumne County 3488.0 \n", + "Ventura County 82532.0 \n", + "Yolo County 21166.0 \n", + "Yuba County 8439.0 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def filter_to_stats_only(df, statvars):\n", + " columns = 'variable'\n", + " # Extract the entity name and discard the DCIDs\n", + " df = df.pivot_table(index='entity_name', columns=columns, values='value', aggfunc='first')\n", + " df = df.rename_axis(None, axis=1)\n", + " df.index.name = None\n", + " # Reorder columns to replicate the original order of stat vars\n", + " order = statvars\n", + " df = df[order]\n", + " return df\n", + "\n", + "df = filter_to_stats_only(raw_df, stat_vars_to_query)\n", + "display(df)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "I6fbGHEC71PR" + }, + "source": [ + "#### 1.2.2) Curate features\n", + "Now that we've got a list of candidate features, we'll need to narrow it down to the features that will be most useful for our analysis.\n", + "\n", + "How do you know which features are useful? One helpful tool is to use a **correlation matrix**. You can think of a correlation as a table of values with each features in the rows and columns. The further away from zero the value in any particular cell is, the more highly correlated the feature corresponding to its row and column are.\n", + "\n", + "Run the following code block to generate a correlation matrix of the features you've chosen. A larger size/darker color denotes stronger correlation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 799 + }, + "id": "0O20_YeL95nn", + "outputId": "edb29198-3d0b-42a4-b3c2-6a4401f992f1" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Generate a correlation matrix plot\n", + "# We'll use the heatmapz package to draw a nice one.\n", + "plt.figure(figsize=(8, 8))\n", + "corrplot(df.corr(), size_scale=300);" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OhYqqeGp97QE" + }, + "source": [ + "**1.2B)** Why does the diagonal from top left to bottom right have such strong correlations?\n", + "\n", + "**1.2C)** Which features correlate the most? Which features correlate the least?\n", + "\n", + "**1.2D)** Which features do you think will be most useful for predicting life expectancy? Why?\n", + "\n", + "**1.2E)** Do any features (life expectancy is not counted as a feature) correlate strongly with each other?\n", + "\n", + "**1.2F)** If two features correlate very strongly with each other, would you want to include them both in your analysis? Why or why not?\n", + "\n", + "**1.2G)** Using your answers for 1.2C - 1.2F, fill in the code box below with a filtered list of statistical variables that you think are best to use for our model. The code box will generate a new dataframe containing only our selected useful features." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "ivZK29Ho_PYN", + "outputId": "04be128e-4f43-4b4d-ed72-53e57cdf7227" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"filtered_df\",\n \"rows\": 58,\n \"fields\": [\n {\n \"column\": \"Count_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1437255.7987916414,\n \"min\": 1099.0,\n \"max\": 9757179.0,\n \"num_unique_values\": 58,\n \"samples\": [\n 1649060.0,\n 22074.0,\n 69159.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person_MarriedAndNotSeparated\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 525224.8977358631,\n \"min\": 706.0,\n \"max\": 3463469.0,\n \"num_unique_values\": 58,\n \"samples\": [\n 677916.0,\n 8772.0,\n 26497.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Median_Income_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 9434.683907047034,\n \"min\": 24717.0,\n \"max\": 69260.0,\n \"num_unique_values\": 58,\n \"samples\": [\n 56575.0,\n 36820.0,\n 44611.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Household_With4OrMorePerson\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 142918.55616768374,\n \"min\": 103.0,\n \"max\": 967873.0,\n \"num_unique_values\": 58,\n \"samples\": [\n 155852.0,\n 2203.0,\n 7695.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe", + "variable_name": "filtered_df" + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Count_PersonCount_Person_MarriedAndNotSeparatedMedian_Income_PersonCount_Household_With4OrMorePerson
Alameda County1649060.0677916.056575.0155852.0
Alpine County1099.0706.035598.0103.0
Amador County42026.018828.041581.02923.0
Butte County208334.073463.033600.016410.0
Calaveras County46505.022308.037043.03075.0
Colusa County22074.08772.036820.02203.0
Contra Costa County1172607.0493526.054178.0118442.0
Del Norte County27009.010455.031929.02309.0
El Dorado County192823.092581.048876.016166.0
Fresno County1024125.0341599.033875.0107943.0
Glenn County28304.011278.035120.02500.0
Humboldt County132380.045314.031657.09713.0
Imperial County181724.059722.024717.018112.0
Inyo County18485.07493.041594.01043.0
Kern County922529.0310288.030912.097654.0
Kings County154913.052479.034210.016052.0
Lake County67764.023231.031565.05140.0
Lassen County28340.010726.034293.01615.0
Los Angeles County9757179.03463469.038111.0967873.0
Madera County165432.055566.030316.016535.0
Marin County256400.0111744.065068.020703.0
Mariposa County17048.07707.036299.01233.0
Mendocino County89175.031433.034707.06681.0
Merced County296774.094168.031343.030146.0
Modoc County8491.03649.031521.0465.0
Mono County12991.06096.046048.01105.0
Monterey County436251.0158299.037063.048002.0
Napa County132727.057521.047432.012018.0
Nevada County102195.047214.040174.06898.0
Orange County3170435.01309331.046430.0321300.0
Placer County433822.0193241.053071.037963.0
Plumas County18834.08369.039230.0999.0
Riverside County2529933.0954331.037929.0268129.0
Sacramento County1611231.0588558.042351.0154446.0
San Benito County69159.026497.044611.07695.0
San Bernardino County2214281.0786363.036178.0242009.0
San Diego County3298799.01300502.045463.0298453.0
San Francisco County827526.0301144.069260.058854.0
San Joaquin County816108.0292240.038674.088055.0
San Luis Obispo County281843.0114590.040720.021754.0
San Mateo County742893.0324408.063325.068046.0
Santa Barbara County444500.0158537.038787.043491.0
Santa Clara County1926325.0815675.062532.0185999.0
Santa Cruz County262406.0102154.043988.023759.0
Shasta County181121.070343.035503.014201.0
Sierra County3113.01423.031696.0114.0
Siskiyou County42498.017822.031315.03024.0
Solano County455101.0176011.045137.042824.0
Sonoma County485375.0198744.048308.042270.0
Stanislaus County556972.0201688.036126.059134.0
Sutter County98545.038857.034285.010428.0
Tehama County64451.026142.033015.05817.0
Trinity County15642.04715.030470.0604.0
Tulare County483546.0166592.031326.056914.0
Tuolumne County53893.022067.037688.03488.0
Ventura County835427.0337666.042693.082532.0
Yolo County225251.078658.040567.021166.0
Yuba County87469.030233.035459.08439.0
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + " Count_Person Count_Person_MarriedAndNotSeparated \\\n", + "Alameda County 1649060.0 677916.0 \n", + "Alpine County 1099.0 706.0 \n", + "Amador County 42026.0 18828.0 \n", + "Butte County 208334.0 73463.0 \n", + "Calaveras County 46505.0 22308.0 \n", + "Colusa County 22074.0 8772.0 \n", + "Contra Costa County 1172607.0 493526.0 \n", + "Del Norte County 27009.0 10455.0 \n", + "El Dorado County 192823.0 92581.0 \n", + "Fresno County 1024125.0 341599.0 \n", + "Glenn County 28304.0 11278.0 \n", + "Humboldt County 132380.0 45314.0 \n", + "Imperial County 181724.0 59722.0 \n", + "Inyo County 18485.0 7493.0 \n", + "Kern County 922529.0 310288.0 \n", + "Kings County 154913.0 52479.0 \n", + "Lake County 67764.0 23231.0 \n", + "Lassen County 28340.0 10726.0 \n", + "Los Angeles County 9757179.0 3463469.0 \n", + "Madera County 165432.0 55566.0 \n", + "Marin County 256400.0 111744.0 \n", + "Mariposa County 17048.0 7707.0 \n", + "Mendocino County 89175.0 31433.0 \n", + "Merced County 296774.0 94168.0 \n", + "Modoc County 8491.0 3649.0 \n", + "Mono County 12991.0 6096.0 \n", + "Monterey County 436251.0 158299.0 \n", + "Napa County 132727.0 57521.0 \n", + "Nevada County 102195.0 47214.0 \n", + "Orange County 3170435.0 1309331.0 \n", + "Placer County 433822.0 193241.0 \n", + "Plumas County 18834.0 8369.0 \n", + "Riverside County 2529933.0 954331.0 \n", + "Sacramento County 1611231.0 588558.0 \n", + "San Benito County 69159.0 26497.0 \n", + "San Bernardino County 2214281.0 786363.0 \n", + "San Diego County 3298799.0 1300502.0 \n", + "San Francisco County 827526.0 301144.0 \n", + "San Joaquin County 816108.0 292240.0 \n", + "San Luis Obispo County 281843.0 114590.0 \n", + "San Mateo County 742893.0 324408.0 \n", + "Santa Barbara County 444500.0 158537.0 \n", + "Santa Clara County 1926325.0 815675.0 \n", + "Santa Cruz County 262406.0 102154.0 \n", + "Shasta County 181121.0 70343.0 \n", + "Sierra County 3113.0 1423.0 \n", + "Siskiyou County 42498.0 17822.0 \n", + "Solano County 455101.0 176011.0 \n", + "Sonoma County 485375.0 198744.0 \n", + "Stanislaus County 556972.0 201688.0 \n", + "Sutter County 98545.0 38857.0 \n", + "Tehama County 64451.0 26142.0 \n", + "Trinity County 15642.0 4715.0 \n", + "Tulare County 483546.0 166592.0 \n", + "Tuolumne County 53893.0 22067.0 \n", + "Ventura County 835427.0 337666.0 \n", + "Yolo County 225251.0 78658.0 \n", + "Yuba County 87469.0 30233.0 \n", + "\n", + " Median_Income_Person \\\n", + "Alameda County 56575.0 \n", + "Alpine County 35598.0 \n", + "Amador County 41581.0 \n", + "Butte County 33600.0 \n", + "Calaveras County 37043.0 \n", + "Colusa County 36820.0 \n", + "Contra Costa County 54178.0 \n", + "Del Norte County 31929.0 \n", + "El Dorado County 48876.0 \n", + "Fresno County 33875.0 \n", + "Glenn County 35120.0 \n", + "Humboldt County 31657.0 \n", + "Imperial County 24717.0 \n", + "Inyo County 41594.0 \n", + "Kern County 30912.0 \n", + "Kings County 34210.0 \n", + "Lake County 31565.0 \n", + "Lassen County 34293.0 \n", + "Los Angeles County 38111.0 \n", + "Madera County 30316.0 \n", + "Marin County 65068.0 \n", + "Mariposa County 36299.0 \n", + "Mendocino County 34707.0 \n", + "Merced County 31343.0 \n", + "Modoc County 31521.0 \n", + "Mono County 46048.0 \n", + "Monterey County 37063.0 \n", + "Napa County 47432.0 \n", + "Nevada County 40174.0 \n", + "Orange County 46430.0 \n", + "Placer County 53071.0 \n", + "Plumas County 39230.0 \n", + "Riverside County 37929.0 \n", + "Sacramento County 42351.0 \n", + "San Benito County 44611.0 \n", + "San Bernardino County 36178.0 \n", + "San Diego County 45463.0 \n", + "San Francisco County 69260.0 \n", + "San Joaquin County 38674.0 \n", + "San Luis Obispo County 40720.0 \n", + "San Mateo County 63325.0 \n", + "Santa Barbara County 38787.0 \n", + "Santa Clara County 62532.0 \n", + "Santa Cruz County 43988.0 \n", + "Shasta County 35503.0 \n", + "Sierra County 31696.0 \n", + "Siskiyou County 31315.0 \n", + "Solano County 45137.0 \n", + "Sonoma County 48308.0 \n", + "Stanislaus County 36126.0 \n", + "Sutter County 34285.0 \n", + "Tehama County 33015.0 \n", + "Trinity County 30470.0 \n", + "Tulare County 31326.0 \n", + "Tuolumne County 37688.0 \n", + "Ventura County 42693.0 \n", + "Yolo County 40567.0 \n", + "Yuba County 35459.0 \n", + "\n", + " Count_Household_With4OrMorePerson \n", + "Alameda County 155852.0 \n", + "Alpine County 103.0 \n", + "Amador County 2923.0 \n", + "Butte County 16410.0 \n", + "Calaveras County 3075.0 \n", + "Colusa County 2203.0 \n", + "Contra Costa County 118442.0 \n", + "Del Norte County 2309.0 \n", + "El Dorado County 16166.0 \n", + "Fresno County 107943.0 \n", + "Glenn County 2500.0 \n", + "Humboldt County 9713.0 \n", + "Imperial County 18112.0 \n", + "Inyo County 1043.0 \n", + "Kern County 97654.0 \n", + "Kings County 16052.0 \n", + "Lake County 5140.0 \n", + "Lassen County 1615.0 \n", + "Los Angeles County 967873.0 \n", + "Madera County 16535.0 \n", + "Marin County 20703.0 \n", + "Mariposa County 1233.0 \n", + "Mendocino County 6681.0 \n", + "Merced County 30146.0 \n", + "Modoc County 465.0 \n", + "Mono County 1105.0 \n", + "Monterey County 48002.0 \n", + "Napa County 12018.0 \n", + "Nevada County 6898.0 \n", + "Orange County 321300.0 \n", + "Placer County 37963.0 \n", + "Plumas County 999.0 \n", + "Riverside County 268129.0 \n", + "Sacramento County 154446.0 \n", + "San Benito County 7695.0 \n", + "San Bernardino County 242009.0 \n", + "San Diego County 298453.0 \n", + "San Francisco County 58854.0 \n", + "San Joaquin County 88055.0 \n", + "San Luis Obispo County 21754.0 \n", + "San Mateo County 68046.0 \n", + "Santa Barbara County 43491.0 \n", + "Santa Clara County 185999.0 \n", + "Santa Cruz County 23759.0 \n", + "Shasta County 14201.0 \n", + "Sierra County 114.0 \n", + "Siskiyou County 3024.0 \n", + "Solano County 42824.0 \n", + "Sonoma County 42270.0 \n", + "Stanislaus County 59134.0 \n", + "Sutter County 10428.0 \n", + "Tehama County 5817.0 \n", + "Trinity County 604.0 \n", + "Tulare County 56914.0 \n", + "Tuolumne County 3488.0 \n", + "Ventura County 82532.0 \n", + "Yolo County 21166.0 \n", + "Yuba County 8439.0 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "filtered_stat_vars_to_query = [\n", + " \"Count_Person\",\n", + " \"Count_Person_MarriedAndNotSeparated\",\n", + " \"Median_Income_Person\",\n", + " \"Count_Household_With4OrMorePerson\"\n", + "\n", + "]\n", + "\n", + "# Get data from Data Commons\n", + "filtered_df = dc_client.observations_dataframe(variable_dcids=filtered_stat_vars_to_query, date=\"latest\", entity_dcids=county_dcids)\n", + "\n", + "filtered_df = filter_to_stats_only(filtered_df, filtered_stat_vars_to_query)\n", + "display(filtered_df)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dAOdWfrQY3L9" + }, + "source": [ + "### 1.3) Data visualization\n", + "\n", + "Now that we have our features, it's time to explore the data more in depth! This step is extremely important. The more familiar we are with our data, the better models we can build, and the better equiped we will be to troubleshoot when something goes wrong.\n", + "\n", + "**1.3) For each feature, generate a plot or otherwise write code to answer each of the following:**\n", + " - What is the maximum value of the feature?\n", + " - What is the minimum value of the feature?\n", + " - What is the distribution of values for this feature?\n", + " - Is the data complete? Are there any NaN or empty values?\n", + " - Are there any strange outliers?\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 300 + }, + "id": "_EbvFd0EY7wS", + "outputId": "7e2c1963-2dc1-4678-aa15-951186151a1a" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"display(filtered_df\",\n \"rows\": 8,\n \"fields\": [\n {\n \"column\": \"Count_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 3332714.499068039,\n \"min\": 58.0,\n \"max\": 9757179.0,\n \"num_unique_values\": 8,\n \"samples\": [\n 679849.3620689656,\n 187273.5,\n 58.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person_MarriedAndNotSeparated\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1180728.2119731812,\n \"min\": 58.0,\n \"max\": 3463469.0,\n \"num_unique_values\": 8,\n \"samples\": [\n 257662.9655172414,\n 71903.0,\n 58.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Median_Income_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 21459.53064249957,\n \"min\": 58.0,\n \"max\": 69260.0,\n \"num_unique_values\": 8,\n \"samples\": [\n 40144.1724137931,\n 37375.5,\n 58.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Household_With4OrMorePerson\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 331261.5845253443,\n \"min\": 58.0,\n \"max\": 967873.0,\n \"num_unique_values\": 8,\n \"samples\": [\n 66565.87931034483,\n 16472.5,\n 58.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe" + }, + "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", + "
Count_PersonCount_Person_MarriedAndNotSeparatedMedian_Income_PersonCount_Household_With4OrMorePerson
count5.800000e+015.800000e+0158.00000058.000000
mean6.798494e+052.576630e+0540144.17241466565.879310
std1.437256e+065.252249e+059434.683907142918.556168
min1.099000e+037.060000e+0224717.000000103.000000
25%4.835200e+042.212725e+0433958.7500003178.250000
50%1.872735e+057.190300e+0437375.50000016472.500000
75%6.964128e+052.696020e+0544455.25000059064.000000
max9.757179e+063.463469e+0669260.000000967873.000000
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + " Count_Person Count_Person_MarriedAndNotSeparated \\\n", + "count 5.800000e+01 5.800000e+01 \n", + "mean 6.798494e+05 2.576630e+05 \n", + "std 1.437256e+06 5.252249e+05 \n", + "min 1.099000e+03 7.060000e+02 \n", + "25% 4.835200e+04 2.212725e+04 \n", + "50% 1.872735e+05 7.190300e+04 \n", + "75% 6.964128e+05 2.696020e+05 \n", + "max 9.757179e+06 3.463469e+06 \n", + "\n", + " Median_Income_Person Count_Household_With4OrMorePerson \n", + "count 58.000000 58.000000 \n", + "mean 40144.172414 66565.879310 \n", + "std 9434.683907 142918.556168 \n", + "min 24717.000000 103.000000 \n", + "25% 33958.750000 3178.250000 \n", + "50% 37375.500000 16472.500000 \n", + "75% 44455.250000 59064.000000 \n", + "max 69260.000000 967873.000000 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Use this space to create scatter plots, histograms, etc.\n", + "# to answer the questions above.\n", + "\n", + "# YOUR CODE HERE\n", + "\n", + "# Example Solution:\n", + "\n", + "# Get some basic statistics\n", + "display(filtered_df.describe())\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 447 + }, + "id": "GBJ4rOt73pI1", + "outputId": "461055dc-c936-4151-e696-e0cb18d9bb34" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj4AAAGdCAYAAAASUnlxAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAALGlJREFUeJzt3Xl0VGWe//FPQZIKURJQyAKEpWXftwYLF7CJBsxxiM5xGBo7iMi03XE6NIptHEdGme7QMoB0iyytEB0ao7igoyzGYKCVKAaIEHSiCJKASbAbSJGMBEw9vz/8UW2ZBKGopFI879c59xzuc5977/fWpZLPeeq5KYcxxggAAMACrYJdAAAAQHMh+AAAAGsQfAAAgDUIPgAAwBoEHwAAYA2CDwAAsAbBBwAAWIPgAwAArBEW7AKam8fj0Zdffqm2bdvK4XAEuxwAAHAejDE6efKkOnXqpFat/B+3sS74fPnll0pMTAx2GQAAwA9lZWXq0qWL3/tbF3zatm0r6dsXLjo6OsjVAACA8+F2u5WYmOj9Pe4v64LP2Y+3oqOjCT4AAISYi52mwuRmAABgDYIPAACwBsEHAABYg+ADAACsQfABAADWIPgAAABrEHwAAIA1CD4AAMAaBB8AAGANgg8AALBGiwk+8+fPl8Ph0KxZs87Zb926derbt68iIyM1aNAgbdiwoXkKBAAAIa9FBJ8PP/xQK1as0ODBg8/Zb/v27ZoyZYpmzJih3bt3KzU1VampqSouLm6mSgEAQCgLevCprq7W1KlT9ac//Unt27c/Z98lS5ZowoQJmjNnjvr166d58+Zp+PDhevLJJ5upWgAAEMqCHnzS09OVkpKipKSkH+xbUFBQr19ycrIKCgoa3ae2tlZut9tnAQAAdgoL5slzcnK0a9cuffjhh+fVv6KiQnFxcT5tcXFxqqioaHSfrKwsPfrooxdVJ/zT/cE367V9MT8lCJUAAPCtoI34lJWVKSMjQ3/+858VGRnZZOfJzMxUVVWVdykrK2uycwEAgJYtaCM+O3fu1NGjRzV8+HBvW11dnbZt26Ynn3xStbW1at26tc8+8fHxqqys9GmrrKxUfHx8o+dxOp1yOp2BLR4AAISkoI34jB8/Xnv37lVRUZF3GTlypKZOnaqioqJ6oUeSXC6X8vLyfNpyc3Plcrmaq2wAABDCgjbi07ZtWw0cONCn7bLLLtOVV17pbU9LS1Pnzp2VlZUlScrIyNDYsWO1cOFCpaSkKCcnR4WFhVq5cmWz1w8AAEJP0J/qOpfS0lKVl5d718eMGaO1a9dq5cqVGjJkiF566SWtX7++XoACAABoiMMYY4JdRHNyu92KiYlRVVWVoqOjg13OJY2nugAAgRKo398tesQHAAAgkAg+AADAGgQfAABgDYIPAACwBsEHAABYg+ADAACsQfABAADWIPgAAABrEHwAAIA1CD4AAMAaBB8AAGANgg8AALAGwQcAAFiD4AMAAKxB8AEAANYg+AAAAGsQfAAAgDUIPgAAwBoEHwAAYA2CDwAAsAbBBwAAWIPgAwAArEHwAQAA1iD4AAAAaxB8AACANQg+AADAGgQfAABgDYIPAACwBsEHAABYg+ADAACsQfABAADWIPgAAABrEHwAAIA1ghp8li1bpsGDBys6OlrR0dFyuVzauHFjo/2zs7PlcDh8lsjIyGasGAAAhLKwYJ68S5cumj9/vnr16iVjjJ599llNmjRJu3fv1oABAxrcJzo6WiUlJd51h8PRXOUCAIAQF9Tgc8stt/is//a3v9WyZcv0/vvvNxp8HA6H4uPjm6M8AABwiWkxc3zq6uqUk5OjmpoauVyuRvtVV1erW7duSkxM1KRJk7Rv375zHre2tlZut9tnAQAAdgp68Nm7d68uv/xyOZ1O3XPPPXr11VfVv3//Bvv26dNHq1at0muvvaY1a9bI4/FozJgxOnz4cKPHz8rKUkxMjHdJTExsqksBAAAtnMMYY4JZwOnTp1VaWqqqqiq99NJLevrpp7V169ZGw893nTlzRv369dOUKVM0b968BvvU1taqtrbWu+52u5WYmKiqqipFR0cH7DpQX/cH36zX9sX8lCBUAgAIdW63WzExMRf9+zuoc3wkKSIiQj179pQkjRgxQh9++KGWLFmiFStW/OC+4eHhGjZsmPbv399oH6fTKafTGbB6AQBA6Ar6R13f5/F4fEZozqWurk579+5VQkJCE1cFAAAuBUEd8cnMzNTEiRPVtWtXnTx5UmvXrlV+fr42b94sSUpLS1Pnzp2VlZUlSXrsscd09dVXq2fPnjpx4oQWLFigQ4cO6e677w7mZQAAgBAR1OBz9OhRpaWlqby8XDExMRo8eLA2b96sG2+8UZJUWlqqVq3+Pih1/PhxzZw5UxUVFWrfvr1GjBih7du3n9d8IAAAgKBPbm5ugZochR/G5GYAQKAE6vd3i5vjAwAA0FQIPgAAwBoEHwAAYA2CDwAAsAbBBwAAWIPgAwAArEHwAQAA1iD4AAAAaxB8AACANQg+AADAGgQfAABgDYIPAACwBsEHAABYg+ADAACsQfABAADWIPgAAABrEHwAAIA1CD4AAMAaBB8AAGANgg8AALAGwQcAAFiD4AMAAKxB8AEAANYg+AAAAGsQfAAAgDUIPgAAwBoEHwAAYA2CDwAAsAbBBwAAWIPgAwAArEHwAQAA1iD4AAAAaxB8AACANYIafJYtW6bBgwcrOjpa0dHRcrlc2rhx4zn3Wbdunfr27avIyEgNGjRIGzZsaKZqAQBAqAtq8OnSpYvmz5+vnTt3qrCwUD/5yU80adIk7du3r8H+27dv15QpUzRjxgzt3r1bqampSk1NVXFxcTNXDgAAQpHDGGOCXcR3XXHFFVqwYIFmzJhRb9vkyZNVU1OjN954w9t29dVXa+jQoVq+fPl5Hd/tdismJkZVVVWKjo4OWN2or/uDb9Zr+2J+ShAqAQCEukD9/m4xc3zq6uqUk5OjmpoauVyuBvsUFBQoKSnJpy05OVkFBQWNHre2tlZut9tnAQAAdgoLdgF79+6Vy+XSqVOndPnll+vVV19V//79G+xbUVGhuLg4n7a4uDhVVFQ0evysrCw9+uijAa0ZDWtohCeY5z+f0SV/R6X8ORcAIPiCPuLTp08fFRUV6YMPPtAvfvELTZs2TR9//HHAjp+ZmamqqirvUlZWFrBjAwCA0BL0EZ+IiAj17NlTkjRixAh9+OGHWrJkiVasWFGvb3x8vCorK33aKisrFR8f3+jxnU6nnE5nYIsGAAAhKegjPt/n8XhUW1vb4DaXy6W8vDyfttzc3EbnBAEAAHxXUEd8MjMzNXHiRHXt2lUnT57U2rVrlZ+fr82bN0uS0tLS1LlzZ2VlZUmSMjIyNHbsWC1cuFApKSnKyclRYWGhVq5cGczLAAAAISKowefo0aNKS0tTeXm5YmJiNHjwYG3evFk33nijJKm0tFStWv19UGrMmDFau3atHn74YT300EPq1auX1q9fr4EDBwbrEgAAQAgJavB55plnzrk9Pz+/Xtvtt9+u22+/vYkqAgAAl7IWN8cHAACgqRB8AACANQg+AADAGgQfAABgDYIPAACwBsEHAABYg+ADAACsQfABAADWIPgAAABrEHwAAIA1CD4AAMAaBB8AAGANgg8AALAGwQcAAFiD4AMAAKxB8AEAANYg+AAAAGsQfAAAgDUIPgAAwBoEHwAAYA2CDwAAsAbBBwAAWIPgAwAArEHwAQAA1iD4AAAAaxB8AACANQg+AADAGgQfAABgDYIPAACwBsEHAABYg+ADAACsQfABAADWIPgAAABrBDX4ZGVl6cc//rHatm2r2NhYpaamqqSk5Jz7ZGdny+Fw+CyRkZHNVDEAAAhlQQ0+W7duVXp6ut5//33l5ubqzJkzuummm1RTU3PO/aKjo1VeXu5dDh061EwVAwCAUBYWzJNv2rTJZz07O1uxsbHauXOnrr/++kb3czgcio+Pb+ryAADAJaZFzfGpqqqSJF1xxRXn7FddXa1u3bopMTFRkyZN0r59+xrtW1tbK7fb7bMAAAA7tZjg4/F4NGvWLF1zzTUaOHBgo/369OmjVatW6bXXXtOaNWvk8Xg0ZswYHT58uMH+WVlZiomJ8S6JiYlNdQkAAKCFazHBJz09XcXFxcrJyTlnP5fLpbS0NA0dOlRjx47VK6+8oo4dO2rFihUN9s/MzFRVVZV3KSsra4ryAQBACAjqHJ+z7r33Xr3xxhvatm2bunTpckH7hoeHa9iwYdq/f3+D251Op5xOZyDKBAAAIc6vEZ8DBw4E5OTGGN1777169dVXtWXLFvXo0eOCj1FXV6e9e/cqISEhIDUBAIBLl1/Bp2fPnrrhhhu0Zs0anTp1yu+Tp6ena82aNVq7dq3atm2riooKVVRU6Ouvv/b2SUtLU2Zmpnf9scce01tvvaUDBw5o165duuOOO3To0CHdfffdftcBAADs4Ffw2bVrlwYPHqzZs2crPj5eP//5z7Vjx44LPs6yZctUVVWlcePGKSEhwbu88MIL3j6lpaUqLy/3rh8/flwzZ85Uv379dPPNN8vtdmv79u3q37+/P5cCAAAs4tccn6FDh2rJkiVauHChXn/9dWVnZ+vaa69V7969ddddd+lnP/uZOnbs+IPHMcb8YJ/8/Hyf9cWLF2vx4sX+lA0AACx3UU91hYWF6bbbbtO6dev0+9//Xvv379f999+vxMREpaWl+YzUAAAABNtFBZ/CwkL98pe/VEJCghYtWqT7779fn3/+uXJzc/Xll19q0qRJgaoTAADgovn1UdeiRYu0evVqlZSU6Oabb9Zzzz2nm2++Wa1afZujevTooezsbHXv3j2QtQIAAFwUv4LPsmXLdNddd+nOO+9s9DHy2NhYPfPMMxdVHAAAQCD5FXw+++yzH+wTERGhadOm+XN4AACAJuHXHJ/Vq1dr3bp19drXrVunZ5999qKLAgAAaAp+BZ+srCx16NChXntsbKx+97vfXXRRAAAATcGv4FNaWtrg10t069ZNpaWlF10UAABAU/Ar+MTGxmrPnj312j/66CNdeeWVF10UAABAU/Ar+EyZMkW/+tWv9M4776iurk51dXXasmWLMjIy9M///M+BrhEAACAg/Hqqa968efriiy80fvx4hYV9ewiPx6O0tDTm+AAAgBbLr+ATERGhF154QfPmzdNHH32kNm3aaNCgQerWrVug6wMAAAgYv4LPWb1791bv3r0DVQsAAECT8iv41NXVKTs7W3l5eTp69Kg8Ho/P9i1btgSkOAAAgEDyK/hkZGQoOztbKSkpGjhwoBwOR6DrAgAACDi/gk9OTo5efPFF3XzzzYGuBwAAoMn49Th7RESEevbsGehaAAAAmpRfwee+++7TkiVLZIwJdD0AAABNxq+Put59912988472rhxowYMGKDw8HCf7a+88kpAigMAAAgkv4JPu3btdOuttwa6FgAAgCblV/BZvXp1oOsAAABocn7N8ZGkb775Rm+//bZWrFihkydPSpK+/PJLVVdXB6w4AACAQPJrxOfQoUOaMGGCSktLVVtbqxtvvFFt27bV73//e9XW1mr58uWBrhMAAOCi+TXik5GRoZEjR+r48eNq06aNt/3WW29VXl5ewIoDAAAIJL9GfP7yl79o+/btioiI8Gnv3r27jhw5EpDCAAAAAs2vER+Px6O6urp67YcPH1bbtm0vuigAAICm4Ffwuemmm/TEE0941x0Oh6qrqzV37ly+xgIAALRYfn3UtXDhQiUnJ6t///46deqUfvrTn+qzzz5Thw4d9Pzzzwe6RgAAgIDwK/h06dJFH330kXJycrRnzx5VV1drxowZmjp1qs9kZwAAgJbEr+AjSWFhYbrjjjsCWQsAAECT8iv4PPfcc+fcnpaW5lcxAAAATcmv4JORkeGzfubMGf3f//2fIiIiFBUVRfABAAAtkl9PdR0/ftxnqa6uVklJia699lomNwMAgBbL7+/q+r5evXpp/vz59UaDziUrK0s//vGP1bZtW8XGxio1NVUlJSU/uN+6devUt29fRUZGatCgQdqwYcPFlA4AACwRsOAjfTvh+csvvzzv/lu3blV6erref/995ebm6syZM7rppptUU1PT6D7bt2/XlClTNGPGDO3evVupqalKTU1VcXFxIC4BAABcwvya4/P666/7rBtjVF5erieffFLXXHPNeR9n06ZNPuvZ2dmKjY3Vzp07df311ze4z5IlSzRhwgTNmTNHkjRv3jzl5ubqySef5MtRAQDAOfkVfFJTU33WHQ6HOnbsqJ/85CdauHCh38VUVVVJkq644opG+xQUFGj27Nk+bcnJyVq/fn2D/Wtra1VbW+tdd7vdftcHAABCm1/Bx+PxBLoOeTwezZo1S9dcc40GDhzYaL+KigrFxcX5tMXFxamioqLB/llZWXr00UcDWquNuj/4ps/6F/NTglRJ0wvUtZ7PcULxXAAQygI6x+dipKenq7i4WDk5OQE9bmZmpqqqqrxLWVlZQI8PAABCh18jPt//qOlcFi1a9IN97r33Xr3xxhvatm2bunTpcs6+8fHxqqys9GmrrKxUfHx8g/2dTqecTud51wsAAC5dfgWf3bt3a/fu3Tpz5oz69OkjSfr000/VunVrDR8+3NvP4XCc8zjGGP3rv/6rXn31VeXn56tHjx4/eG6Xy6W8vDzNmjXL25abmyuXy+XPpQAAAIv4FXxuueUWtW3bVs8++6zat28v6ds/ajh9+nRdd911uu+++87rOOnp6Vq7dq1ee+01tW3b1jtPJyYmxvtlp2lpaercubOysrIkfftXo8eOHauFCxcqJSVFOTk5Kiws1MqVK/25FAAAYBG/5vgsXLhQWVlZ3tAjSe3bt9d//ud/XtBTXcuWLVNVVZXGjRunhIQE7/LCCy94+5SWlqq8vNy7PmbMGK1du1YrV67UkCFD9NJLL2n9+vXnnBANAAAg+Tni43a79dVXX9Vr/+qrr3Ty5MnzPo4x5gf75Ofn12u7/fbbdfvtt5/3eQAAACQ/R3xuvfVWTZ8+Xa+88ooOHz6sw4cP6+WXX9aMGTN02223BbpGAACAgPBrxGf58uW6//779dOf/lRnzpz59kBhYZoxY4YWLFgQ0AIBAAACxa/gExUVpaeeekoLFizQ559/Lkm66qqrdNlllwW0OAAAgEC6qD9gWF5ervLycvXq1UuXXXbZec3ZAQAACBa/gs/f/vY3jR8/Xr1799bNN9/sfepqxowZ5/0oOwAAQHPzK/j8+te/Vnh4uEpLSxUVFeVtnzx5cr1vXAcAAGgp/Jrj89Zbb2nz5s31vl6iV69eOnToUEAKAwAACDS/Rnxqamp8RnrOOnbsGN+LBQAAWiy/gs91112n5557zrvucDjk8Xj0+OOP64YbbghYcQAAAIHk10ddjz/+uMaPH6/CwkKdPn1aDzzwgPbt26djx47pvffeC3SNAAAAAeHXiM/AgQP16aef6tprr9WkSZNUU1Oj2267Tbt379ZVV10V6BoBAAAC4oJHfM6cOaMJEyZo+fLl+rd/+7emqAkAAKBJXPCIT3h4uPbs2dMUtQAAADQpvz7quuOOO/TMM88EuhYAAIAm5dfk5m+++UarVq3S22+/rREjRtT7jq5FixYFpDgAAIBAuqDgc+DAAXXv3l3FxcUaPny4JOnTTz/16eNwOAJXHQAAQABdUPDp1auXysvL9c4770j69isq/vCHPyguLq5JigMAAAikC5rj8/1vX9+4caNqamoCWhAAAEBT8Wty81nfD0IAAAAt2QUFH4fDUW8OD3N6AABAqLigOT7GGN15553eLyI9deqU7rnnnnpPdb3yyiuBqxAAACBALij4TJs2zWf9jjvuCGgxAAAATemCgs/q1aubqg4AAIAmd1GTmwEAAEIJwQcAAFiD4AMAAKxB8AEAANYg+AAAAGsQfAAAgDUIPgAAwBoEHwAAYA2CDwAAsAbBBwAAWCOowWfbtm265ZZb1KlTJzkcDq1fv/6c/fPz873fEP/dpaKionkKBgAAIS2owaempkZDhgzR0qVLL2i/kpISlZeXe5fY2NgmqhAAAFxKLuhLSgNt4sSJmjhx4gXvFxsbq3bt2gW+IAAAcEkLyTk+Q4cOVUJCgm688Ua999575+xbW1srt9vtswAAADuFVPBJSEjQ8uXL9fLLL+vll19WYmKixo0bp127djW6T1ZWlmJiYrxLYmJiM1YMAABakqB+1HWh+vTpoz59+njXx4wZo88//1yLFy/Wf//3fze4T2ZmpmbPnu1dd7vdhB8AACwVUsGnIaNGjdK7777b6Han0ymn09mMFQEAgJYqpD7qakhRUZESEhKCXQYAAAgBQR3xqa6u1v79+73rBw8eVFFRka644gp17dpVmZmZOnLkiJ577jlJ0hNPPKEePXpowIABOnXqlJ5++mlt2bJFb731VrAuAQAAhJCgBp/CwkLdcMMN3vWzc3GmTZum7OxslZeXq7S01Lv99OnTuu+++3TkyBFFRUVp8ODBevvtt32OAQAA0JigBp9x48bJGNPo9uzsbJ/1Bx54QA888EATVwUAAC5VIT/HBwAA4HwRfAAAgDUIPgAAwBoEHwAAYA2CDwAAsAbBBwAAWIPgAwAArEHwAQAA1iD4AAAAaxB8AACANQg+AADAGgQfAABgDYIPAACwBsEHAABYg+ADAACsQfABAADWIPgAAABrEHwAAIA1CD4AAMAaBB8AAGANgg8AALAGwQcAAFiD4AMAAKxB8AEAANYg+AAAAGsQfAAAgDUIPgAAwBoEHwAAYA2CDwAAsAbBBwAAWIPgAwAArEHwAQAA1iD4AAAAawQ1+Gzbtk233HKLOnXqJIfDofXr1//gPvn5+Ro+fLicTqd69uyp7OzsJq8TAABcGoIafGpqajRkyBAtXbr0vPofPHhQKSkpuuGGG1RUVKRZs2bp7rvv1ubNm5u4UgAAcCkIC+bJJ06cqIkTJ553/+XLl6tHjx5auHChJKlfv3569913tXjxYiUnJzdVmQAA4BIRUnN8CgoKlJSU5NOWnJysgoKCRvepra2V2+32WQAAgJ2COuJzoSoqKhQXF+fTFhcXJ7fbra+//lpt2rSpt09WVpYeffTR5ipR3R9802f9i/kpzXbu5vT96/R3v4ZeH3+PfSkcp6E+33+NAlXP+Z7/+87n/3RT1vh95/P6NFWfYPPn501TXpctP/8k/36W+ft6tPTXNRTeK98VUiM+/sjMzFRVVZV3KSsrC3ZJAAAgSEJqxCc+Pl6VlZU+bZWVlYqOjm5wtEeSnE6nnE5nc5QHAABauJAa8XG5XMrLy/Npy83NlcvlClJFAAAglAQ1+FRXV6uoqEhFRUWSvn1cvaioSKWlpZK+/ZgqLS3N2/+ee+7RgQMH9MADD+h///d/9dRTT+nFF1/Ur3/962CUDwAAQkxQg09hYaGGDRumYcOGSZJmz56tYcOG6ZFHHpEklZeXe0OQJPXo0UNvvvmmcnNzNWTIEC1cuFBPP/00j7IDAIDzEtQ5PuPGjZMxptHtDf1V5nHjxmn37t1NWBUAALhUhdQcHwAAgItB8AEAANYg+AAAAGsQfAAAgDUIPgAAwBoEHwAAYA2CDwAAsAbBBwAAWIPgAwAArEHwAQAA1iD4AAAAaxB8AACANQg+AADAGgQfAABgDYIPAACwBsEHAABYg+ADAACsQfABAADWIPgAAABrEHwAAIA1CD4AAMAaBB8AAGANgg8AALAGwQcAAFiD4AMAAKxB8AEAANYg+AAAAGsQfAAAgDUIPgAAwBoEHwAAYA2CDwAAsAbBBwAAWIPgAwAArNEigs/SpUvVvXt3RUZGavTo0dqxY0ejfbOzs+VwOHyWyMjIZqwWAACEqqAHnxdeeEGzZ8/W3LlztWvXLg0ZMkTJyck6evRoo/tER0ervLzcuxw6dKgZKwYAAKEq6MFn0aJFmjlzpqZPn67+/ftr+fLlioqK0qpVqxrdx+FwKD4+3rvExcU1Y8UAACBUBTX4nD59Wjt37lRSUpK3rVWrVkpKSlJBQUGj+1VXV6tbt25KTEzUpEmTtG/fvkb71tbWyu12+ywAAMBOQQ0+f/3rX1VXV1dvxCYuLk4VFRUN7tOnTx+tWrVKr732mtasWSOPx6MxY8bo8OHDDfbPyspSTEyMd0lMTAz4dQAAgNAQ9I+6LpTL5VJaWpqGDh2qsWPH6pVXXlHHjh21YsWKBvtnZmaqqqrKu5SVlTVzxQAAoKUIC+bJO3TooNatW6uystKnvbKyUvHx8ed1jPDwcA0bNkz79+9vcLvT6ZTT6bzoWgEAQOgL6ohPRESERowYoby8PG+bx+NRXl6eXC7XeR2jrq5Oe/fuVUJCQlOVCQAALhFBHfGRpNmzZ2vatGkaOXKkRo0apSeeeEI1NTWaPn26JCktLU2dO3dWVlaWJOmxxx7T1VdfrZ49e+rEiRNasGCBDh06pLvvvjuYlwEAAEJA0IPP5MmT9dVXX+mRRx5RRUWFhg4dqk2bNnknPJeWlqpVq78PTB0/flwzZ85URUWF2rdvrxEjRmj79u3q379/sC4BAACEiKAHH0m69957de+99za4LT8/32d98eLFWrx4cTNUBQAALjUh91QXAACAvwg+AADAGgQfAABgDYIPAACwBsEHAABYg+ADAACsQfABAADWIPgAAABrEHwAAIA1CD4AAMAaBB8AAGANgg8AALAGwQcAAFiD4AMAAKxB8AEAANYg+AAAAGsQfAAAgDUIPgAAwBoEHwAAYA2CDwAAsAbBBwAAWIPgAwAArEHwAQAA1iD4AAAAaxB8AACANQg+AADAGgQfAABgDYIPAACwBsEHAABYg+ADAACsQfABAADWIPgAAABrEHwAAIA1WkTwWbp0qbp3767IyEiNHj1aO3bsOGf/devWqW/fvoqMjNSgQYO0YcOGZqoUAACEsqAHnxdeeEGzZ8/W3LlztWvXLg0ZMkTJyck6evRog/23b9+uKVOmaMaMGdq9e7dSU1OVmpqq4uLiZq4cAACEmqAHn0WLFmnmzJmaPn26+vfvr+XLlysqKkqrVq1qsP+SJUs0YcIEzZkzR/369dO8efM0fPhwPfnkk81cOQAACDVhwTz56dOntXPnTmVmZnrbWrVqpaSkJBUUFDS4T0FBgWbPnu3TlpycrPXr1zfYv7a2VrW1td71qqoqSZLb7b7I6hvmqf0/n/WmOk9z+/51BUpDr09TnaspNeV1fP/Y53Pc86nH35rP5/90c97D83l9mqpPsPnz86Ypr+tS/fnXEH/eT/6+Hi39dW2u98rZYxpjLu5AJoiOHDliJJnt27f7tM+ZM8eMGjWqwX3Cw8PN2rVrfdqWLl1qYmNjG+w/d+5cI4mFhYWFhYXlEljKysouKnsEdcSnOWRmZvqMEHk8Hh07dkxXXnmlHA5HECsLDW63W4mJiSorK1N0dHSwy8H/x31pebgnLQ/3pOW5mHtijNHJkyfVqVOni6ohqMGnQ4cOat26tSorK33aKysrFR8f3+A+8fHxF9Tf6XTK6XT6tLVr187/oi0VHR3ND44WiPvS8nBPWh7uScvj7z2JiYm56HMHdXJzRESERowYoby8PG+bx+NRXl6eXC5Xg/u4XC6f/pKUm5vbaH8AAICzgv5R1+zZszVt2jSNHDlSo0aN0hNPPKGamhpNnz5dkpSWlqbOnTsrKytLkpSRkaGxY8dq4cKFSklJUU5OjgoLC7Vy5cpgXgYAAAgBQQ8+kydP1ldffaVHHnlEFRUVGjp0qDZt2qS4uDhJUmlpqVq1+vvA1JgxY7R27Vo9/PDDeuihh9SrVy+tX79eAwcODNYlXNKcTqfmzp1b7+NCBBf3peXhnrQ83JOWpyXcE4cxF/tcGAAAQGgI+h8wBAAAaC4EHwAAYA2CDwAAsAbBBwAAWIPgc4lZtmyZBg8e7P3jUC6XSxs3bvRuP3XqlNLT03XllVfq8ssv1z/+4z/W+4OQpaWlSklJUVRUlGJjYzVnzhx98803Pn3y8/M1fPhwOZ1O9ezZU9nZ2fVqWbp0qbp3767IyEiNHj1aO3bsaJJrDjXz58+Xw+HQrFmzvG3cl+b3H//xH3I4HD5L3759vdu5J8Fx5MgR3XHHHbryyivVpk0bDRo0SIWFhd7txhg98sgjSkhIUJs2bZSUlKTPPvvM5xjHjh3T1KlTFR0drXbt2mnGjBmqrq726bNnzx5dd911ioyMVGJioh5//PF6taxbt059+/ZVZGSkBg0apA0bNjTNRbdg3bt3r/c+cTgcSk9PlxSi75OL+sILtDivv/66efPNN82nn35qSkpKzEMPPWTCw8NNcXGxMcaYe+65xyQmJpq8vDxTWFhorr76ajNmzBjv/t98840ZOHCgSUpKMrt37zYbNmwwHTp0MJmZmd4+Bw4cMFFRUWb27Nnm448/Nn/84x9N69atzaZNm7x9cnJyTEREhFm1apXZt2+fmTlzpmnXrp2prKxsvhejBdqxY4fp3r27GTx4sMnIyPC2c1+a39y5c82AAQNMeXm5d/nqq6+827knze/YsWOmW7du5s477zQffPCBOXDggNm8ebPZv3+/t8/8+fNNTEyMWb9+vfnoo4/MP/zDP5gePXqYr7/+2ttnwoQJZsiQIeb99983f/nLX0zPnj3NlClTvNurqqpMXFycmTp1qikuLjbPP/+8adOmjVmxYoW3z3vvvWdat25tHn/8cfPxxx+bhx9+2ISHh5u9e/c2z4vRQhw9etTnPZKbm2skmXfeeccYE5rvE4KPBdq3b2+efvppc+LECRMeHm7WrVvn3fbJJ58YSaagoMAYY8yGDRtMq1atTEVFhbfPsmXLTHR0tKmtrTXGGPPAAw+YAQMG+Jxj8uTJJjk52bs+atQok56e7l2vq6sznTp1MllZWU1yjaHg5MmTplevXiY3N9eMHTvWG3y4L8Exd+5cM2TIkAa3cU+C4ze/+Y259tprG93u8XhMfHy8WbBggbftxIkTxul0mueff94YY8zHH39sJJkPP/zQ22fjxo3G4XCYI0eOGGOMeeqpp0z79u299+nsufv06eNd/6d/+ieTkpLic/7Ro0ebn//85xd3kSEuIyPDXHXVVcbj8YTs+4SPui5hdXV1ysnJUU1NjVwul3bu3KkzZ84oKSnJ26dv377q2rWrCgoKJEkFBQUaNGiQ9w9ISlJycrLcbrf27dvn7fPdY5ztc/YYp0+f1s6dO336tGrVSklJSd4+NkpPT1dKSkq91477EjyfffaZOnXqpB/96EeaOnWqSktLJXFPguX111/XyJEjdfvttys2NlbDhg3Tn/70J+/2gwcPqqKiwuf1iomJ0ejRo33uS7t27TRy5Ehvn6SkJLVq1UoffPCBt8/111+viIgIb5/k5GSVlJTo+PHj3j7nunc2On36tNasWaO77rpLDocjZN8nBJ9L0N69e3X55ZfL6XTqnnvu0auvvqr+/furoqJCERER9b6kNS4uThUVFZKkiooKn/+gZ7ef3XauPm63W19//bX++te/qq6ursE+Z49hm5ycHO3atcv71SvfxX0JjtGjRys7O1ubNm3SsmXLdPDgQV133XU6efIk9yRIDhw4oGXLlqlXr17avHmzfvGLX+hXv/qVnn32WUl/f13P9XpVVFQoNjbWZ3tYWJiuuOKKgNw7G+/LWevXr9eJEyd05513Sgrdn11B/8oKBF6fPn1UVFSkqqoqvfTSS5o2bZq2bt0a7LKsVVZWpoyMDOXm5ioyMjLY5eD/mzhxovffgwcP1ujRo9WtWze9+OKLatOmTRArs5fH49HIkSP1u9/9TpI0bNgwFRcXa/ny5Zo2bVqQq8MzzzyjiRMnqlOnTsEu5aIw4nMJioiIUM+ePTVixAhlZWVpyJAhWrJkieLj43X69GmdOHHCp39lZaXi4+MlSfHx8fVm5J9d/6E+0dHRatOmjTp06KDWrVs32OfsMWyyc+dOHT16VMOHD1dYWJjCwsK0detW/eEPf1BYWJji4uK4Ly1Au3bt1Lt3b+3fv5/3SpAkJCSof//+Pm39+vXzfgR59jU51+sVHx+vo0eP+mz/5ptvdOzYsYDcOxvviyQdOnRIb7/9tu6++25vW6i+Twg+FvB4PKqtrdWIESMUHh6uvLw877aSkhKVlpbK5XJJklwul/bu3evzgyM3N1fR0dHeH0gul8vnGGf7nD1GRESERowY4dPH4/EoLy/P28cm48eP1969e1VUVORdRo4cqalTp3r/zX0Jvurqan3++edKSEjgvRIk11xzjUpKSnzaPv30U3Xr1k2S1KNHD8XHx/u8Xm63Wx988IHPfTlx4oR27tzp7bNlyxZ5PB6NHj3a22fbtm06c+aMt09ubq769Omj9u3be/uc697ZZvXq1YqNjVVKSoq3LWTfJxc8HRot2oMPPmi2bt1qDh48aPbs2WMefPBB43A4zFtvvWWM+fbRw65du5otW7aYwsJC43K5jMvl8u5/9tHDm266yRQVFZlNmzaZjh07Nvjo4Zw5c8wnn3xili5d2uCjh06n02RnZ5uPP/7Y/Mu//Itp166dz8x+m333qS5juC/BcN9995n8/Hxz8OBB895775mkpCTToUMHc/ToUWMM9yQYduzYYcLCwsxvf/tb89lnn5k///nPJioqyqxZs8bbZ/78+aZdu3bmtddeM3v27DGTJk1q8HH2YcOGmQ8++MC8++67plevXj6Ps584ccLExcWZn/3sZ6a4uNjk5OSYqKioeo+zh4WFmf/6r/8yn3zyiZk7d66Vj7Mb8+0TVF27djW/+c1v6m0LxfcJwecSc9ddd5lu3bqZiIgI07FjRzN+/Hhv6DHGmK+//tr88pe/NO3btzdRUVHm1ltvNeXl5T7H+OKLL8zEiRNNmzZtTIcOHcx9991nzpw549PnnXfeMUOHDjURERHmRz/6kVm9enW9Wv74xz+arl27moiICDNq1Cjz/vvvN8k1h6LvBx/uS/ObPHmySUhIMBEREaZz585m8uTJPn8vhnsSHP/zP/9jBg4caJxOp+nbt69ZuXKlz3aPx2P+/d//3cTFxRmn02nGjx9vSkpKfPr87W9/M1OmTDGXX365iY6ONtOnTzcnT5706fPRRx+Za6+91jidTtO5c2czf/78erW8+OKLpnfv3iYiIsIMGDDAvPnmm4G/4BCwefNmI6ne62xMaL5PHMYYc+HjRAAAAKGHOT4AAMAaBB8AAGANgg8AALAGwQcAAFiD4AMAAKxB8AEAANYg+AAAAGsQfAAAgDUIPgAAwBoEHwAAYA2CDwAAsAbBBwAAWOP/Aejhd2LlZhJJAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot histograms to get an idea of data spread\n", + "display(filtered_df[\"Median_Income_Person\"].plot.hist(bins=100))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 465 + }, + "id": "3j9THBI03tQA", + "outputId": "205793de-86cc-48f5-d7cf-5fe6b5f05e0a" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "display(filtered_df[\"Count_Household_With4OrMorePerson\"].plot.hist(bins=100))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5rgu5l92ex-a" + }, + "source": [ + "### 1.4) Data cleaning\n", + "Before proceeding with our model, we first need to clean our data. Sometimes our data comes to us incomplete, with missing values, or in a different unit than we were expecting. It's always best practice to look through your data to make sure there are no corrupt, inaccurate, or missing records. If we do find such entries, we need to replace, modify, or remove that data. The process of correcting or removing bad data is known as **data cleaning**.\n", + "\n", + "Some common things to look out for:\n", + "* Data can be missing (e.g. an empty cell in a column). Depending on your application and context, sometimes there's a clear \"default\" value that can be filled in.\n", + "* Duplicate rows or columns. You will need to delete the extras.\n", + "* The format of the data you're provided is incorrect. This can include strange naming conventions, typos, strange capitalization, or inconsistencies (e.g. having both \"N/A\" and \"Not Applicable\" appear).\n", + "\n", + "**1.4A)** Why bother replacing/modifying/removing \"dirty\" data in the first place? What do you think would happen if we found \"dirty\" data, but trained a model on such data without data cleaning first?\n", + "\n", + "**1.4B)** How would you approach handling any NaN or empty values in a dataframe? Should we remove that row? Remove the feature? Or should we replace NaNs with a particular value (and if so, how do you decide what value that should be)?\n", + "\n", + "**1.4C)** Take a look at the dataframe outputted by the code box above from section 1.2. Are there any values that need to be cleaned? If so, write code to implement the answers to the above questions using the code box below.\n", + "\n", + "_Hint: If you're strugging, check out the [Pandas documentation](https://pandas.pydata.org/docs/reference/index.html) for methods you can use to manipulate the data in the dataframe._" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "p7X8LerYMM7H" + }, + "outputs": [], + "source": [ + "# Use this code box to implement any imputation and data cleaning.\n", + "\n", + "# YOUR CODE HERE" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "x1SJKVzgZbLw" + }, + "source": [ + "## 2) Building features\n", + "\n", + "Now that we've selected and explored some features, we need to decide how exactly to encode our data into a feature vector to feed into our model." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mtxeD4H2ba6q" + }, + "source": [ + "### 2.1) Feature transformations\n", + "\n", + "Sometimes transforming the data can reveal interesting combinations, or better scale our data. Here are some things to look out for:\n", + "\n", + "* If your data has a skewed distribution or large changes in magnitude, it may be helpful to take the $log()$ of your data to bring it closer to normal.\n", + "* Other times it may be helpful to bin close values together (for example, create groupings by age 0-10, 11-20, 21-30, etc.)\n", + "* When working with population or demographic data, it's often also prudent to consider whether the features you are using should be scaled by population.\n", + "\n", + "**2.1) Choose a feature transformation to implement, and use it to transform at least one of your features.**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "cEoh-lfRd09G", + "outputId": "c37c382a-973a-4c9b-97ac-b7eb3da7ca49" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"features_df_new\",\n \"rows\": 58,\n \"fields\": [\n {\n \"column\": \"County\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 58,\n \"samples\": [\n \"Alameda County\",\n \"Colusa County\",\n \"San Benito County\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Household4orMore_percapita\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.0182969544012553,\n \"min\": 0.03662062319306136,\n \"max\": 0.11770131486973318,\n \"num_unique_values\": 58,\n \"samples\": [\n 0.09450959940814767,\n 0.09980067047204856,\n 0.11126534507439378\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"CumulativeCount_MedicalConditionIncident_COVID_19_ConfirmedOrProbableCase\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 406565.9999807545,\n \"min\": 126.0,\n \"max\": 2908425.0,\n \"num_unique_values\": 58,\n \"samples\": [\n 284054.0,\n 4549.0,\n 13636.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1437255.7987916414,\n \"min\": 1099.0,\n \"max\": 9757179.0,\n \"num_unique_values\": 58,\n \"samples\": [\n 1649060.0,\n 22074.0,\n 69159.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person_MarriedAndNotSeparated\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 525224.8977358631,\n \"min\": 706.0,\n \"max\": 3463469.0,\n \"num_unique_values\": 58,\n \"samples\": [\n 677916.0,\n 8772.0,\n 26497.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Median_Income_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 9434.683907047034,\n \"min\": 24717.0,\n \"max\": 69260.0,\n \"num_unique_values\": 58,\n \"samples\": [\n 56575.0,\n 36820.0,\n 44611.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Household_With4OrMorePerson\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 142918.55616768374,\n \"min\": 103.0,\n \"max\": 967873.0,\n \"num_unique_values\": 58,\n \"samples\": [\n 155852.0,\n 2203.0,\n 7695.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe", + "variable_name": "features_df_new" + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Household4orMore_percapitaCumulativeCount_MedicalConditionIncident_COVID_19_ConfirmedOrProbableCaseCount_PersonCount_Person_MarriedAndNotSeparatedMedian_Income_PersonCount_Household_With4OrMorePerson
County
Alameda County0.094510284054.01649060.0677916.056575.0155852.0
Alpine County0.093722126.01099.0706.035598.0103.0
Amador County0.0695529242.042026.018828.041581.02923.0
Butte County0.07876840181.0208334.073463.033600.016410.0
Calaveras County0.0661227754.046505.022308.037043.03075.0
Colusa County0.0998014549.022074.08772.036820.02203.0
Contra Costa County0.101007209958.01172607.0493526.054178.0118442.0
Del Norte County0.0854906381.027009.010455.031929.02309.0
El Dorado County0.08383930508.0192823.092581.048876.016166.0
Fresno County0.105400257611.01024125.0341599.033875.0107943.0
Glenn County0.0883276631.028304.011278.035120.02500.0
Humboldt County0.07337220952.0132380.045314.031657.09713.0
Imperial County0.09966866715.0181724.059722.024717.018112.0
Inyo County0.0564244636.018485.07493.041594.01043.0
Kern County0.105855244681.0922529.0310288.030912.097654.0
Kings County0.10361955429.0154913.052479.034210.016052.0
Lake County0.07585111699.067764.023231.031565.05140.0
Lassen County0.05698710751.028340.010726.034293.01615.0
Los Angeles County0.0991962908425.09757179.03463469.038111.0967873.0
Madera County0.09995043685.0165432.055566.030316.016535.0
Marin County0.08074538685.0256400.0111744.065068.020703.0
Mariposa County0.0723253145.017048.07707.036299.01233.0
Mendocino County0.07492016568.089175.031433.034707.06681.0
Merced County0.10157972959.0296774.094168.031343.030146.0
Modoc County0.0547641000.08491.03649.031521.0465.0
Mono County0.0850593144.012991.06096.046048.01105.0
Monterey County0.11003395140.0436251.0158299.037063.048002.0
Napa County0.09054727765.0132727.057521.047432.012018.0
Nevada County0.06749817503.0102195.047214.040174.06898.0
Orange County0.101343600384.03170435.01309331.046430.0321300.0
Placer County0.08750871527.0433822.0193241.053071.037963.0
Plumas County0.0530423379.018834.08369.039230.0999.0
Riverside County0.105983626695.02529933.0954331.037929.0268129.0
Sacramento County0.095856314407.01611231.0588558.042351.0154446.0
San Benito County0.11126513636.069159.026497.044611.07695.0
San Bernardino County0.109295597377.02214281.0786363.036178.0242009.0
San Diego County0.090473824586.03298799.01300502.045463.0298453.0
San Francisco County0.071120143959.0827526.0301144.069260.058854.0
San Joaquin County0.107896178501.0816108.0292240.038674.088055.0
San Luis Obispo County0.07718557556.0281843.0114590.040720.021754.0
San Mateo County0.091596137238.0742893.0324408.063325.068046.0
Santa Barbara County0.09784392683.0444500.0158537.038787.043491.0
Santa Clara County0.096556342015.01926325.0815675.062532.0185999.0
Santa Cruz County0.09054352532.0262406.0102154.043988.023759.0
Shasta County0.07840636988.0181121.070343.035503.014201.0
Sierra County0.036621324.03113.01423.031696.0114.0
Siskiyou County0.0711567478.042498.017822.031315.03024.0
Solano County0.09409889419.0455101.0176011.045137.042824.0
Sonoma County0.08708790191.0485375.0198744.048308.042270.0
Stanislaus County0.106171136645.0556972.0201688.036126.059134.0
Sutter County0.10582023045.098545.038857.034285.010428.0
Tehama County0.09025514753.064451.026142.033015.05817.0
Trinity County0.0386141485.015642.04715.030470.0604.0
Tulare County0.117701136125.0483546.0166592.031326.056914.0
Tuolumne County0.06472113758.053893.022067.037688.03488.0
Ventura County0.098790186062.0835427.0337666.042693.082532.0
Yolo County0.09396641061.0225251.078658.040567.021166.0
Yuba County0.09648017944.087469.030233.035459.08439.0
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + " Household4orMore_percapita \\\n", + "County \n", + "Alameda County 0.094510 \n", + "Alpine County 0.093722 \n", + "Amador County 0.069552 \n", + "Butte County 0.078768 \n", + "Calaveras County 0.066122 \n", + "Colusa County 0.099801 \n", + "Contra Costa County 0.101007 \n", + "Del Norte County 0.085490 \n", + "El Dorado County 0.083839 \n", + "Fresno County 0.105400 \n", + "Glenn County 0.088327 \n", + "Humboldt County 0.073372 \n", + "Imperial County 0.099668 \n", + "Inyo County 0.056424 \n", + "Kern County 0.105855 \n", + "Kings County 0.103619 \n", + "Lake County 0.075851 \n", + "Lassen County 0.056987 \n", + "Los Angeles County 0.099196 \n", + "Madera County 0.099950 \n", + "Marin County 0.080745 \n", + "Mariposa County 0.072325 \n", + "Mendocino County 0.074920 \n", + "Merced County 0.101579 \n", + "Modoc County 0.054764 \n", + "Mono County 0.085059 \n", + "Monterey County 0.110033 \n", + "Napa County 0.090547 \n", + "Nevada County 0.067498 \n", + "Orange County 0.101343 \n", + "Placer County 0.087508 \n", + "Plumas County 0.053042 \n", + "Riverside County 0.105983 \n", + "Sacramento County 0.095856 \n", + "San Benito County 0.111265 \n", + "San Bernardino County 0.109295 \n", + "San Diego County 0.090473 \n", + "San Francisco County 0.071120 \n", + "San Joaquin County 0.107896 \n", + "San Luis Obispo County 0.077185 \n", + "San Mateo County 0.091596 \n", + "Santa Barbara County 0.097843 \n", + "Santa Clara County 0.096556 \n", + "Santa Cruz County 0.090543 \n", + "Shasta County 0.078406 \n", + "Sierra County 0.036621 \n", + "Siskiyou County 0.071156 \n", + "Solano County 0.094098 \n", + "Sonoma County 0.087087 \n", + "Stanislaus County 0.106171 \n", + "Sutter County 0.105820 \n", + "Tehama County 0.090255 \n", + "Trinity County 0.038614 \n", + "Tulare County 0.117701 \n", + "Tuolumne County 0.064721 \n", + "Ventura County 0.098790 \n", + "Yolo County 0.093966 \n", + "Yuba County 0.096480 \n", + "\n", + " CumulativeCount_MedicalConditionIncident_COVID_19_ConfirmedOrProbableCase \\\n", + "County \n", + "Alameda County 284054.0 \n", + "Alpine County 126.0 \n", + "Amador County 9242.0 \n", + "Butte County 40181.0 \n", + "Calaveras County 7754.0 \n", + "Colusa County 4549.0 \n", + "Contra Costa County 209958.0 \n", + "Del Norte County 6381.0 \n", + "El Dorado County 30508.0 \n", + "Fresno County 257611.0 \n", + "Glenn County 6631.0 \n", + "Humboldt County 20952.0 \n", + "Imperial County 66715.0 \n", + "Inyo County 4636.0 \n", + "Kern County 244681.0 \n", + "Kings County 55429.0 \n", + "Lake County 11699.0 \n", + "Lassen County 10751.0 \n", + "Los Angeles County 2908425.0 \n", + "Madera County 43685.0 \n", + "Marin County 38685.0 \n", + "Mariposa County 3145.0 \n", + "Mendocino County 16568.0 \n", + "Merced County 72959.0 \n", + "Modoc County 1000.0 \n", + "Mono County 3144.0 \n", + "Monterey County 95140.0 \n", + "Napa County 27765.0 \n", + "Nevada County 17503.0 \n", + "Orange County 600384.0 \n", + "Placer County 71527.0 \n", + "Plumas County 3379.0 \n", + "Riverside County 626695.0 \n", + "Sacramento County 314407.0 \n", + "San Benito County 13636.0 \n", + "San Bernardino County 597377.0 \n", + "San Diego County 824586.0 \n", + "San Francisco County 143959.0 \n", + "San Joaquin County 178501.0 \n", + "San Luis Obispo County 57556.0 \n", + "San Mateo County 137238.0 \n", + "Santa Barbara County 92683.0 \n", + "Santa Clara County 342015.0 \n", + "Santa Cruz County 52532.0 \n", + "Shasta County 36988.0 \n", + "Sierra County 324.0 \n", + "Siskiyou County 7478.0 \n", + "Solano County 89419.0 \n", + "Sonoma County 90191.0 \n", + "Stanislaus County 136645.0 \n", + "Sutter County 23045.0 \n", + "Tehama County 14753.0 \n", + "Trinity County 1485.0 \n", + "Tulare County 136125.0 \n", + "Tuolumne County 13758.0 \n", + "Ventura County 186062.0 \n", + "Yolo County 41061.0 \n", + "Yuba County 17944.0 \n", + "\n", + " Count_Person Count_Person_MarriedAndNotSeparated \\\n", + "County \n", + "Alameda County 1649060.0 677916.0 \n", + "Alpine County 1099.0 706.0 \n", + "Amador County 42026.0 18828.0 \n", + "Butte County 208334.0 73463.0 \n", + "Calaveras County 46505.0 22308.0 \n", + "Colusa County 22074.0 8772.0 \n", + "Contra Costa County 1172607.0 493526.0 \n", + "Del Norte County 27009.0 10455.0 \n", + "El Dorado County 192823.0 92581.0 \n", + "Fresno County 1024125.0 341599.0 \n", + "Glenn County 28304.0 11278.0 \n", + "Humboldt County 132380.0 45314.0 \n", + "Imperial County 181724.0 59722.0 \n", + "Inyo County 18485.0 7493.0 \n", + "Kern County 922529.0 310288.0 \n", + "Kings County 154913.0 52479.0 \n", + "Lake County 67764.0 23231.0 \n", + "Lassen County 28340.0 10726.0 \n", + "Los Angeles County 9757179.0 3463469.0 \n", + "Madera County 165432.0 55566.0 \n", + "Marin County 256400.0 111744.0 \n", + "Mariposa County 17048.0 7707.0 \n", + "Mendocino County 89175.0 31433.0 \n", + "Merced County 296774.0 94168.0 \n", + "Modoc County 8491.0 3649.0 \n", + "Mono County 12991.0 6096.0 \n", + "Monterey County 436251.0 158299.0 \n", + "Napa County 132727.0 57521.0 \n", + "Nevada County 102195.0 47214.0 \n", + "Orange County 3170435.0 1309331.0 \n", + "Placer County 433822.0 193241.0 \n", + "Plumas County 18834.0 8369.0 \n", + "Riverside County 2529933.0 954331.0 \n", + "Sacramento County 1611231.0 588558.0 \n", + "San Benito County 69159.0 26497.0 \n", + "San Bernardino County 2214281.0 786363.0 \n", + "San Diego County 3298799.0 1300502.0 \n", + "San Francisco County 827526.0 301144.0 \n", + "San Joaquin County 816108.0 292240.0 \n", + "San Luis Obispo County 281843.0 114590.0 \n", + "San Mateo County 742893.0 324408.0 \n", + "Santa Barbara County 444500.0 158537.0 \n", + "Santa Clara County 1926325.0 815675.0 \n", + "Santa Cruz County 262406.0 102154.0 \n", + "Shasta County 181121.0 70343.0 \n", + "Sierra County 3113.0 1423.0 \n", + "Siskiyou County 42498.0 17822.0 \n", + "Solano County 455101.0 176011.0 \n", + "Sonoma County 485375.0 198744.0 \n", + "Stanislaus County 556972.0 201688.0 \n", + "Sutter County 98545.0 38857.0 \n", + "Tehama County 64451.0 26142.0 \n", + "Trinity County 15642.0 4715.0 \n", + "Tulare County 483546.0 166592.0 \n", + "Tuolumne County 53893.0 22067.0 \n", + "Ventura County 835427.0 337666.0 \n", + "Yolo County 225251.0 78658.0 \n", + "Yuba County 87469.0 30233.0 \n", + "\n", + " Median_Income_Person \\\n", + "County \n", + "Alameda County 56575.0 \n", + "Alpine County 35598.0 \n", + "Amador County 41581.0 \n", + "Butte County 33600.0 \n", + "Calaveras County 37043.0 \n", + "Colusa County 36820.0 \n", + "Contra Costa County 54178.0 \n", + "Del Norte County 31929.0 \n", + "El Dorado County 48876.0 \n", + "Fresno County 33875.0 \n", + "Glenn County 35120.0 \n", + "Humboldt County 31657.0 \n", + "Imperial County 24717.0 \n", + "Inyo County 41594.0 \n", + "Kern County 30912.0 \n", + "Kings County 34210.0 \n", + "Lake County 31565.0 \n", + "Lassen County 34293.0 \n", + "Los Angeles County 38111.0 \n", + "Madera County 30316.0 \n", + "Marin County 65068.0 \n", + "Mariposa County 36299.0 \n", + "Mendocino County 34707.0 \n", + "Merced County 31343.0 \n", + "Modoc County 31521.0 \n", + "Mono County 46048.0 \n", + "Monterey County 37063.0 \n", + "Napa County 47432.0 \n", + "Nevada County 40174.0 \n", + "Orange County 46430.0 \n", + "Placer County 53071.0 \n", + "Plumas County 39230.0 \n", + "Riverside County 37929.0 \n", + "Sacramento County 42351.0 \n", + "San Benito County 44611.0 \n", + "San Bernardino County 36178.0 \n", + "San Diego County 45463.0 \n", + "San Francisco County 69260.0 \n", + "San Joaquin County 38674.0 \n", + "San Luis Obispo County 40720.0 \n", + "San Mateo County 63325.0 \n", + "Santa Barbara County 38787.0 \n", + "Santa Clara County 62532.0 \n", + "Santa Cruz County 43988.0 \n", + "Shasta County 35503.0 \n", + "Sierra County 31696.0 \n", + "Siskiyou County 31315.0 \n", + "Solano County 45137.0 \n", + "Sonoma County 48308.0 \n", + "Stanislaus County 36126.0 \n", + "Sutter County 34285.0 \n", + "Tehama County 33015.0 \n", + "Trinity County 30470.0 \n", + "Tulare County 31326.0 \n", + "Tuolumne County 37688.0 \n", + "Ventura County 42693.0 \n", + "Yolo County 40567.0 \n", + "Yuba County 35459.0 \n", + "\n", + " Count_Household_With4OrMorePerson \n", + "County \n", + "Alameda County 155852.0 \n", + "Alpine County 103.0 \n", + "Amador County 2923.0 \n", + "Butte County 16410.0 \n", + "Calaveras County 3075.0 \n", + "Colusa County 2203.0 \n", + "Contra Costa County 118442.0 \n", + "Del Norte County 2309.0 \n", + "El Dorado County 16166.0 \n", + "Fresno County 107943.0 \n", + "Glenn County 2500.0 \n", + "Humboldt County 9713.0 \n", + "Imperial County 18112.0 \n", + "Inyo County 1043.0 \n", + "Kern County 97654.0 \n", + "Kings County 16052.0 \n", + "Lake County 5140.0 \n", + "Lassen County 1615.0 \n", + "Los Angeles County 967873.0 \n", + "Madera County 16535.0 \n", + "Marin County 20703.0 \n", + "Mariposa County 1233.0 \n", + "Mendocino County 6681.0 \n", + "Merced County 30146.0 \n", + "Modoc County 465.0 \n", + "Mono County 1105.0 \n", + "Monterey County 48002.0 \n", + "Napa County 12018.0 \n", + "Nevada County 6898.0 \n", + "Orange County 321300.0 \n", + "Placer County 37963.0 \n", + "Plumas County 999.0 \n", + "Riverside County 268129.0 \n", + "Sacramento County 154446.0 \n", + "San Benito County 7695.0 \n", + "San Bernardino County 242009.0 \n", + "San Diego County 298453.0 \n", + "San Francisco County 58854.0 \n", + "San Joaquin County 88055.0 \n", + "San Luis Obispo County 21754.0 \n", + "San Mateo County 68046.0 \n", + "Santa Barbara County 43491.0 \n", + "Santa Clara County 185999.0 \n", + "Santa Cruz County 23759.0 \n", + "Shasta County 14201.0 \n", + "Sierra County 114.0 \n", + "Siskiyou County 3024.0 \n", + "Solano County 42824.0 \n", + "Sonoma County 42270.0 \n", + "Stanislaus County 59134.0 \n", + "Sutter County 10428.0 \n", + "Tehama County 5817.0 \n", + "Trinity County 604.0 \n", + "Tulare County 56914.0 \n", + "Tuolumne County 3488.0 \n", + "Ventura County 82532.0 \n", + "Yolo County 21166.0 \n", + "Yuba County 8439.0 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Try different transformations on your features like taking the log, binning, etc.\n", + "\n", + "# YOUR CODE HERE\n", + "\n", + "# Example solution:\n", + "# Data Commons often contains data already in \"per capita\" form, but as an exercise\n", + "# it'll be good for students to realize they should compare features like household counts\n", + "# normalized by population and do this themselves.\n", + "\n", + "# Normalizing Count_HouseholdWith4OrMorePerson by population count\n", + "household_count_percapita = df['Count_Household_With4OrMorePerson']/df['Count_Person']\n", + "household_df = household_count_percapita.to_frame()\n", + "household_df.index.name = 'County'\n", + "household_df = household_df.rename({0:'Household4orMore_percapita'}, axis=1)\n", + "features_df_new = pd.concat([household_df,df], axis=1)\n", + "display(features_df_new)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YdKhNbbUpUi6" + }, + "source": [ + "### 2.2) Feature representations\n", + "If any of your data is discrete, getting a good encoding of discrete features is particularly important. You want to create “opportunities” for your model to find the underlying regularities.\n", + "\n", + "**2.2A) For each of the following encodings, name an example of data the encoding would work well on, as well as an example of data it would not work as well for. Explain your answers.**\n", + "\n", + "* *Numeric* Assign each of these values a number, say 1.0/k, 2.0/k, . . . , 1.0.\n", + "\n", + "* *Thermometer code* Use a vector of length k binary variables, where we convert discrete input value $0 < j < k$ into a vector in which the first j values are 1.0 and the rest are 0.0.\n", + "\n", + "* *Factored code* If your discrete values can sensibly be decomposed into two parts, then it’s best to treat those as two separate features (choosing a separate encoding scheme for each).\n", + "\n", + "* *One-hot code* Use a vector of length k, where we convert discrete input value $0 < j < k$ into a vector in which all values are 0.0, except for the $j$-th, which is 1.0.\n", + "\n", + "**2.2B) Write a function that creates a one-hot encoding.**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "LBw6m5FDYtRK" + }, + "outputs": [], + "source": [ + "# Write a function that implements one-hot encoding.\n", + "\n", + "# YOUR CODE HERE\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BTW-V4deppyI" + }, + "source": [ + "### 2.3) Standardization\n", + "It is typically useful to scale numeric data, so that it tends to be in the range [−1, +1]. Without performing this transformation, if you have\n", + "one feature with much larger values than another, it will take the learning algorithm a lot of work to find parameters that can put them on an equal basis.\n", + "\n", + "Typically, we use the transformation\n", + "$$ \\phi(x) = \\frac{\\bar{x} − x}{\\sigma} $$\n", + "\n", + "where $\\bar{x}$ is the average of the $x_i$, and $\\sigma$ is the standard\n", + "deviation of the $x_i$.\n", + "\n", + "The resulting feature values will have mean 0 and standard deviation 1. This transformation is sometimes called *standardizing* a variable.\n", + "\n", + "**2.3) Write code to standardize each of the features in your dataframe.**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "kd1jAmAwpr-j", + "outputId": "d0e93c2b-f4f2-4ac2-944b-0c846e91c244" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"standardized_df\",\n \"rows\": 58,\n \"fields\": [\n {\n \"column\": \"County\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 58,\n \"samples\": [\n \"Alameda County\",\n \"Colusa County\",\n \"San Benito County\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Household4orMore_percapita\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.9999999999999999,\n \"min\": -2.7499609154882445,\n \"max\": 1.6814154709069205,\n \"num_unique_values\": 58,\n \"samples\": [\n 0.4138976669605766,\n 0.7030753600272374,\n 1.3296645918153793\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"CumulativeCount_MedicalConditionIncident_COVID_19_ConfirmedOrProbableCase\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.9999999999999999,\n \"min\": -0.3962677646621369,\n \"max\": 6.7570578949790265,\n \"num_unique_values\": 58,\n \"samples\": [\n 0.3020887137778709,\n -0.3853888421742521,\n -0.3630382275128438\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.0,\n \"min\": -0.4722543910691599,\n \"max\": 6.3157370076799895,\n \"num_unique_values\": 58,\n \"samples\": [\n 0.6743480448963147,\n -0.45766060754250126,\n -0.4249002596353394\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person_MarriedAndNotSeparated\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.0000000000000002,\n \"min\": -0.4892322634074093,\n \"max\": 6.103682533524841,\n \"num_unique_values\": 58,\n \"samples\": [\n 0.8001392094974615,\n -0.4738750325625448,\n -0.4401275844190755\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Median_Income_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.9999999999999999,\n \"min\": -1.6351551960601571,\n \"max\": 3.0860416600135863,\n \"num_unique_values\": 58,\n \"samples\": [\n 1.7415345069413768,\n -0.35233532427198566,\n 0.473447508174651\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Household_With4OrMorePerson\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.9999999999999997,\n \"min\": -0.4650402375487557,\n \"max\": 6.306438749858121,\n \"num_unique_values\": 58,\n \"samples\": [\n 0.6247342758269779,\n -0.45034655426289805,\n -0.4119190739743599\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe", + "variable_name": "standardized_df" + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Household4orMore_percapitaCumulativeCount_MedicalConditionIncident_COVID_19_ConfirmedOrProbableCaseCount_PersonCount_Person_MarriedAndNotSeparatedMedian_Income_PersonCount_Household_With4OrMorePerson
County
Alameda County0.4138980.3020890.6743480.8001391.7415350.624734
Alpine County0.370829-0.396268-0.472254-0.489232-0.481857-0.465040
Amador County-0.950123-0.373846-0.443779-0.4547290.152292-0.445309
Butte County-0.446456-0.297747-0.328066-0.350707-0.693629-0.350940
Calaveras County-1.137600-0.377506-0.440662-0.448103-0.328699-0.444245
Colusa County0.703075-0.385389-0.457661-0.473875-0.352335-0.450347
Contra Costa County0.7690290.1198400.3428460.4490711.4874720.362977
Del Norte County-0.079057-0.380883-0.454227-0.470671-0.870742-0.449605
El Dorado County-0.169317-0.321539-0.338859-0.3143070.925503-0.352648
Fresno County1.0091130.2370490.2395370.159810-0.6644810.289515
Glenn County0.075980-0.380268-0.453326-0.469104-0.532522-0.448268
Humboldt County-0.741349-0.345044-0.380913-0.404301-0.899571-0.397799
Imperial County0.695804-0.232484-0.346581-0.376869-1.635155-0.339031
Inyo County-1.667622-0.385175-0.460158-0.4763100.153670-0.458463
Kern County1.0339500.2052460.1688490.100195-0.9785350.217523
Kings County0.911787-0.260243-0.365235-0.390659-0.628974-0.353445
Lake County-0.605841-0.367803-0.425871-0.446346-0.909323-0.429796
Lassen County-1.636881-0.370134-0.453301-0.470155-0.620177-0.454461
Los Angeles County0.6700276.7570586.3157376.103683-0.2155006.306439
Madera County0.711260-0.289129-0.357916-0.384782-1.041707-0.350066
Marin County-0.338395-0.301427-0.294624-0.2778222.641724-0.320902
Mariposa County-0.798566-0.388842-0.461158-0.475903-0.407557-0.457134
Mendocino County-0.656745-0.355827-0.410974-0.430730-0.576296-0.419014
Merced County0.800267-0.217126-0.266532-0.311286-0.932853-0.254830
Modoc County-1.758362-0.394118-0.467111-0.483629-0.913986-0.462507
Mono County-0.102621-0.388845-0.463980-0.4789700.625758-0.458029
Monterey County1.262311-0.162569-0.169489-0.189184-0.326579-0.129891
Napa County0.197313-0.328286-0.380672-0.3810600.772451-0.381671
Nevada County-1.062369-0.353527-0.401915-0.4006840.003161-0.417496
Orange County0.7873461.0801421.7328762.0023190.6662471.782373
Placer County0.031246-0.220648-0.171179-0.1226561.370139-0.200134
Plumas County-1.852448-0.388267-0.459915-0.474642-0.096895-0.458771
Riverside County1.0409451.1448571.2872331.326419-0.2347901.410336
Sacramento County0.4874780.3767460.6480280.6300060.2339060.614897
San Benito County1.329665-0.363038-0.424900-0.4401280.473448-0.411919
San Bernardino County1.2219571.0727461.0676121.006616-0.4203821.227574
San Diego County0.1932941.6315951.8221881.9855100.5637531.622512
San Francisco County-0.864412-0.0424920.1027490.0827863.086042-0.053960
San Joaquin County1.1455310.0424680.0948050.065833-0.1558260.150359
San Luis Obispo County-0.532969-0.255011-0.276921-0.2724030.061033-0.313548
San Mateo County0.254656-0.0590240.0438640.1270792.4569800.010356
Santa Barbara County0.596055-0.168612-0.163749-0.188731-0.143849-0.161455
Santa Clara County0.5257630.4446510.8672611.0624252.3729280.835673
Santa Cruz County0.197102-0.267369-0.290445-0.2960810.407415-0.299519
Shasta County-0.466219-0.305601-0.347000-0.356647-0.491927-0.366397
Sierra County-2.749961-0.395781-0.470853-0.487867-0.895438-0.464963
Siskiyou County-0.862452-0.378185-0.443450-0.456644-0.935821-0.444602
Solano County0.391391-0.176640-0.156373-0.1554610.529199-0.166122
Sonoma County0.008240-0.174742-0.135309-0.1121790.865300-0.169998
Stanislaus County1.051212-0.060482-0.085494-0.106573-0.425894-0.052001
Sutter County1.032038-0.339896-0.404454-0.416595-0.621025-0.392796
Tehama County0.181346-0.360291-0.428176-0.440803-0.755634-0.425059
Trinity County-2.641016-0.392925-0.462136-0.481599-1.025384-0.461535
Tulare County1.681415-0.061761-0.136582-0.173394-0.934655-0.067534
Tuolumne County-1.214175-0.362738-0.435522-0.448562-0.260334-0.441355
Ventura County0.6478490.0610650.1082460.1523210.2701550.111715
Yolo County0.384203-0.295583-0.316296-0.3408160.044816-0.317663
Yuba County0.521582-0.352442-0.412161-0.433014-0.496590-0.406713
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + " Household4orMore_percapita \\\n", + "County \n", + "Alameda County 0.413898 \n", + "Alpine County 0.370829 \n", + "Amador County -0.950123 \n", + "Butte County -0.446456 \n", + "Calaveras County -1.137600 \n", + "Colusa County 0.703075 \n", + "Contra Costa County 0.769029 \n", + "Del Norte County -0.079057 \n", + "El Dorado County -0.169317 \n", + "Fresno County 1.009113 \n", + "Glenn County 0.075980 \n", + "Humboldt County -0.741349 \n", + "Imperial County 0.695804 \n", + "Inyo County -1.667622 \n", + "Kern County 1.033950 \n", + "Kings County 0.911787 \n", + "Lake County -0.605841 \n", + "Lassen County -1.636881 \n", + "Los Angeles County 0.670027 \n", + "Madera County 0.711260 \n", + "Marin County -0.338395 \n", + "Mariposa County -0.798566 \n", + "Mendocino County -0.656745 \n", + "Merced County 0.800267 \n", + "Modoc County -1.758362 \n", + "Mono County -0.102621 \n", + "Monterey County 1.262311 \n", + "Napa County 0.197313 \n", + "Nevada County -1.062369 \n", + "Orange County 0.787346 \n", + "Placer County 0.031246 \n", + "Plumas County -1.852448 \n", + "Riverside County 1.040945 \n", + "Sacramento County 0.487478 \n", + "San Benito County 1.329665 \n", + "San Bernardino County 1.221957 \n", + "San Diego County 0.193294 \n", + "San Francisco County -0.864412 \n", + "San Joaquin County 1.145531 \n", + "San Luis Obispo County -0.532969 \n", + "San Mateo County 0.254656 \n", + "Santa Barbara County 0.596055 \n", + "Santa Clara County 0.525763 \n", + "Santa Cruz County 0.197102 \n", + "Shasta County -0.466219 \n", + "Sierra County -2.749961 \n", + "Siskiyou County -0.862452 \n", + "Solano County 0.391391 \n", + "Sonoma County 0.008240 \n", + "Stanislaus County 1.051212 \n", + "Sutter County 1.032038 \n", + "Tehama County 0.181346 \n", + "Trinity County -2.641016 \n", + "Tulare County 1.681415 \n", + "Tuolumne County -1.214175 \n", + "Ventura County 0.647849 \n", + "Yolo County 0.384203 \n", + "Yuba County 0.521582 \n", + "\n", + " CumulativeCount_MedicalConditionIncident_COVID_19_ConfirmedOrProbableCase \\\n", + "County \n", + "Alameda County 0.302089 \n", + "Alpine County -0.396268 \n", + "Amador County -0.373846 \n", + "Butte County -0.297747 \n", + "Calaveras County -0.377506 \n", + "Colusa County -0.385389 \n", + "Contra Costa County 0.119840 \n", + "Del Norte County -0.380883 \n", + "El Dorado County -0.321539 \n", + "Fresno County 0.237049 \n", + "Glenn County -0.380268 \n", + "Humboldt County -0.345044 \n", + "Imperial County -0.232484 \n", + "Inyo County -0.385175 \n", + "Kern County 0.205246 \n", + "Kings County -0.260243 \n", + "Lake County -0.367803 \n", + "Lassen County -0.370134 \n", + "Los Angeles County 6.757058 \n", + "Madera County -0.289129 \n", + "Marin County -0.301427 \n", + "Mariposa County -0.388842 \n", + "Mendocino County -0.355827 \n", + "Merced County -0.217126 \n", + "Modoc County -0.394118 \n", + "Mono County -0.388845 \n", + "Monterey County -0.162569 \n", + "Napa County -0.328286 \n", + "Nevada County -0.353527 \n", + "Orange County 1.080142 \n", + "Placer County -0.220648 \n", + "Plumas County -0.388267 \n", + "Riverside County 1.144857 \n", + "Sacramento County 0.376746 \n", + "San Benito County -0.363038 \n", + "San Bernardino County 1.072746 \n", + "San Diego County 1.631595 \n", + "San Francisco County -0.042492 \n", + "San Joaquin County 0.042468 \n", + "San Luis Obispo County -0.255011 \n", + "San Mateo County -0.059024 \n", + "Santa Barbara County -0.168612 \n", + "Santa Clara County 0.444651 \n", + "Santa Cruz County -0.267369 \n", + "Shasta County -0.305601 \n", + "Sierra County -0.395781 \n", + "Siskiyou County -0.378185 \n", + "Solano County -0.176640 \n", + "Sonoma County -0.174742 \n", + "Stanislaus County -0.060482 \n", + "Sutter County -0.339896 \n", + "Tehama County -0.360291 \n", + "Trinity County -0.392925 \n", + "Tulare County -0.061761 \n", + "Tuolumne County -0.362738 \n", + "Ventura County 0.061065 \n", + "Yolo County -0.295583 \n", + "Yuba County -0.352442 \n", + "\n", + " Count_Person Count_Person_MarriedAndNotSeparated \\\n", + "County \n", + "Alameda County 0.674348 0.800139 \n", + "Alpine County -0.472254 -0.489232 \n", + "Amador County -0.443779 -0.454729 \n", + "Butte County -0.328066 -0.350707 \n", + "Calaveras County -0.440662 -0.448103 \n", + "Colusa County -0.457661 -0.473875 \n", + "Contra Costa County 0.342846 0.449071 \n", + "Del Norte County -0.454227 -0.470671 \n", + "El Dorado County -0.338859 -0.314307 \n", + "Fresno County 0.239537 0.159810 \n", + "Glenn County -0.453326 -0.469104 \n", + "Humboldt County -0.380913 -0.404301 \n", + "Imperial County -0.346581 -0.376869 \n", + "Inyo County -0.460158 -0.476310 \n", + "Kern County 0.168849 0.100195 \n", + "Kings County -0.365235 -0.390659 \n", + "Lake County -0.425871 -0.446346 \n", + "Lassen County -0.453301 -0.470155 \n", + "Los Angeles County 6.315737 6.103683 \n", + "Madera County -0.357916 -0.384782 \n", + "Marin County -0.294624 -0.277822 \n", + "Mariposa County -0.461158 -0.475903 \n", + "Mendocino County -0.410974 -0.430730 \n", + "Merced County -0.266532 -0.311286 \n", + "Modoc County -0.467111 -0.483629 \n", + "Mono County -0.463980 -0.478970 \n", + "Monterey County -0.169489 -0.189184 \n", + "Napa County -0.380672 -0.381060 \n", + "Nevada County -0.401915 -0.400684 \n", + "Orange County 1.732876 2.002319 \n", + "Placer County -0.171179 -0.122656 \n", + "Plumas County -0.459915 -0.474642 \n", + "Riverside County 1.287233 1.326419 \n", + "Sacramento County 0.648028 0.630006 \n", + "San Benito County -0.424900 -0.440128 \n", + "San Bernardino County 1.067612 1.006616 \n", + "San Diego County 1.822188 1.985510 \n", + "San Francisco County 0.102749 0.082786 \n", + "San Joaquin County 0.094805 0.065833 \n", + "San Luis Obispo County -0.276921 -0.272403 \n", + "San Mateo County 0.043864 0.127079 \n", + "Santa Barbara County -0.163749 -0.188731 \n", + "Santa Clara County 0.867261 1.062425 \n", + "Santa Cruz County -0.290445 -0.296081 \n", + "Shasta County -0.347000 -0.356647 \n", + "Sierra County -0.470853 -0.487867 \n", + "Siskiyou County -0.443450 -0.456644 \n", + "Solano County -0.156373 -0.155461 \n", + "Sonoma County -0.135309 -0.112179 \n", + "Stanislaus County -0.085494 -0.106573 \n", + "Sutter County -0.404454 -0.416595 \n", + "Tehama County -0.428176 -0.440803 \n", + "Trinity County -0.462136 -0.481599 \n", + "Tulare County -0.136582 -0.173394 \n", + "Tuolumne County -0.435522 -0.448562 \n", + "Ventura County 0.108246 0.152321 \n", + "Yolo County -0.316296 -0.340816 \n", + "Yuba County -0.412161 -0.433014 \n", + "\n", + " Median_Income_Person \\\n", + "County \n", + "Alameda County 1.741535 \n", + "Alpine County -0.481857 \n", + "Amador County 0.152292 \n", + "Butte County -0.693629 \n", + "Calaveras County -0.328699 \n", + "Colusa County -0.352335 \n", + "Contra Costa County 1.487472 \n", + "Del Norte County -0.870742 \n", + "El Dorado County 0.925503 \n", + "Fresno County -0.664481 \n", + "Glenn County -0.532522 \n", + "Humboldt County -0.899571 \n", + "Imperial County -1.635155 \n", + "Inyo County 0.153670 \n", + "Kern County -0.978535 \n", + "Kings County -0.628974 \n", + "Lake County -0.909323 \n", + "Lassen County -0.620177 \n", + "Los Angeles County -0.215500 \n", + "Madera County -1.041707 \n", + "Marin County 2.641724 \n", + "Mariposa County -0.407557 \n", + "Mendocino County -0.576296 \n", + "Merced County -0.932853 \n", + "Modoc County -0.913986 \n", + "Mono County 0.625758 \n", + "Monterey County -0.326579 \n", + "Napa County 0.772451 \n", + "Nevada County 0.003161 \n", + "Orange County 0.666247 \n", + "Placer County 1.370139 \n", + "Plumas County -0.096895 \n", + "Riverside County -0.234790 \n", + "Sacramento County 0.233906 \n", + "San Benito County 0.473448 \n", + "San Bernardino County -0.420382 \n", + "San Diego County 0.563753 \n", + "San Francisco County 3.086042 \n", + "San Joaquin County -0.155826 \n", + "San Luis Obispo County 0.061033 \n", + "San Mateo County 2.456980 \n", + "Santa Barbara County -0.143849 \n", + "Santa Clara County 2.372928 \n", + "Santa Cruz County 0.407415 \n", + "Shasta County -0.491927 \n", + "Sierra County -0.895438 \n", + "Siskiyou County -0.935821 \n", + "Solano County 0.529199 \n", + "Sonoma County 0.865300 \n", + "Stanislaus County -0.425894 \n", + "Sutter County -0.621025 \n", + "Tehama County -0.755634 \n", + "Trinity County -1.025384 \n", + "Tulare County -0.934655 \n", + "Tuolumne County -0.260334 \n", + "Ventura County 0.270155 \n", + "Yolo County 0.044816 \n", + "Yuba County -0.496590 \n", + "\n", + " Count_Household_With4OrMorePerson \n", + "County \n", + "Alameda County 0.624734 \n", + "Alpine County -0.465040 \n", + "Amador County -0.445309 \n", + "Butte County -0.350940 \n", + "Calaveras County -0.444245 \n", + "Colusa County -0.450347 \n", + "Contra Costa County 0.362977 \n", + "Del Norte County -0.449605 \n", + "El Dorado County -0.352648 \n", + "Fresno County 0.289515 \n", + "Glenn County -0.448268 \n", + "Humboldt County -0.397799 \n", + "Imperial County -0.339031 \n", + "Inyo County -0.458463 \n", + "Kern County 0.217523 \n", + "Kings County -0.353445 \n", + "Lake County -0.429796 \n", + "Lassen County -0.454461 \n", + "Los Angeles County 6.306439 \n", + "Madera County -0.350066 \n", + "Marin County -0.320902 \n", + "Mariposa County -0.457134 \n", + "Mendocino County -0.419014 \n", + "Merced County -0.254830 \n", + "Modoc County -0.462507 \n", + "Mono County -0.458029 \n", + "Monterey County -0.129891 \n", + "Napa County -0.381671 \n", + "Nevada County -0.417496 \n", + "Orange County 1.782373 \n", + "Placer County -0.200134 \n", + "Plumas County -0.458771 \n", + "Riverside County 1.410336 \n", + "Sacramento County 0.614897 \n", + "San Benito County -0.411919 \n", + "San Bernardino County 1.227574 \n", + "San Diego County 1.622512 \n", + "San Francisco County -0.053960 \n", + "San Joaquin County 0.150359 \n", + "San Luis Obispo County -0.313548 \n", + "San Mateo County 0.010356 \n", + "Santa Barbara County -0.161455 \n", + "Santa Clara County 0.835673 \n", + "Santa Cruz County -0.299519 \n", + "Shasta County -0.366397 \n", + "Sierra County -0.464963 \n", + "Siskiyou County -0.444602 \n", + "Solano County -0.166122 \n", + "Sonoma County -0.169998 \n", + "Stanislaus County -0.052001 \n", + "Sutter County -0.392796 \n", + "Tehama County -0.425059 \n", + "Trinity County -0.461535 \n", + "Tulare County -0.067534 \n", + "Tuolumne County -0.441355 \n", + "Ventura County 0.111715 \n", + "Yolo County -0.317663 \n", + "Yuba County -0.406713 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create a new dataframe with each of the features standardized.\n", + "\n", + "# YOUR CODE HERE\n", + "\n", + "# Solution:\n", + "standardized_df = (features_df_new - features_df_new.mean())/features_df_new.std()\n", + "display(standardized_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HrrQcDDyHvnR" + }, + "source": [ + "## 3) Testing your features\n", + "\n", + "Now, let's see how well a simple [linear regression model](https://scikit-learn.org/stable/modules/linear_model.html#ordinary-least-squares) can learn to predict the cummulative number of COVID-19 cases, given our features." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "WnFICa70a2TQ", + "outputId": "8f17e863-28b8-4355-bd31-7da9233deb79" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model Intercept: [-0.08223537]\n", + "Model Coefficients: [[0.18810523 0.07292689]]\n" + ] + } + ], + "source": [ + "# Run me!\n", + "\n", + "# Convert dataframes into data and labels for the model\n", + "target_df = standardized_df\n", + "X = target_df[['Household4orMore_percapita','Median_Income_Person']]\n", + "Y = target_df[['CumulativeCount_MedicalConditionIncident_COVID_19_ConfirmedOrProbableCase']]\n", + "\n", + "# Split into training and test sets\n", + "x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.2)\n", + "\n", + "# Fit an OLS linear regression model\n", + "model = linear_model.LinearRegression(fit_intercept=True)\n", + "model.fit(x_train, y_train)\n", + "print('Model Intercept: {}'.format(model.intercept_))\n", + "print('Model Coefficients: {}'.format(model.coef_))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3hJVFRHiJqaE" + }, + "source": [ + "Let's now see how accurate our model was on our test set." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "1fI_htJPKjqS", + "outputId": "8561a90c-c9e5-4e3f-a2a6-73865e7c388d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training Error: 0.17290626819814806\n", + "Test Error: 3.8106112457909185\n" + ] + } + ], + "source": [ + "train_pred = model.predict(x_train)\n", + "test_pred = model.predict(x_test)\n", + "\n", + "print('Training Error: {}'.format(mse(train_pred, y_train)))\n", + "print('Test Error: {}'.format(mse(test_pred, y_test)))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "e7XFek4Aa6Tu" + }, + "source": [ + "\n", + "**3) Answer the following questions.**\n", + "\n", + "1. Which feature was most important (had the most weight) for your model?\n", + "\n", + "2. How accurate was your model? Were any of the results surprising?\n", + "\n", + "3. Rerun the code in part 2, this time choosing different feature representations. List which feature representations you try here.\n", + "\n", + "4. How do the different representations affect the resulting predictions? Which seem to work best? Which were worse?\n", + "\n", + "5. Can you think of any other factors that might affect the number of covid-19 cases that we were not able to include in the model?\n" + ] + } + ], + "metadata": { + "colab": { + "include_colab_link": true, + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/notebooks/intro_data_science/Introduction_to_Clustering.ipynb b/notebooks/intro_data_science/Introduction_to_Clustering.ipynb new file mode 100644 index 00000000..25f35e81 --- /dev/null +++ b/notebooks/intro_data_science/Introduction_to_Clustering.ipynb @@ -0,0 +1,3173 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "9uqlvgsuICzJ" + }, + "source": [ + "Copyright 2025 Google LLC.\n", + "SPDX-License-Identifier: Apache-2.0" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "i-oJ51dbG_H6" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hZmCyCI8CvFc" + }, + "source": [ + "# Introduction to Clustering\n", + "\n", + "We have previously looked at training models when we have labels, categories, or some other classification from which to extract relationships in our data. When we classify data with known labels, this is known as _supervised learning_. But what if we have data without matching labels and aim to identify inherent patterns in the data without knowing the relationships in advance? This is when we utilize _unsupervised learning_.\n", + "\n", + "One common technique in unsupervised learning is **clustering**, also known as cluster analysis. The goal of clustering is to divide your data points into groups (clusters), such that data points in each group are more similar to each other than to data points in other clusters. Clustering is used in many fields for data exploration.\n", + "\n", + "In this assignment, we will build some intuition for clustering by applying the technique to case studies.\n", + "\n", + "## Learning goals\n", + "* Understand what clustering is and does\n", + "* See how clustering can be used to find patterns\n", + "* Build intuition into how clustering works\n", + "* Gain hands-on experience clustering real-world data" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-x0FnQc-DELQ" + }, + "source": [ + "## 0) A brief primer on k-means\n", + "\n", + "There are many different algorithms for clustering data. For this assignment, we'll be using the **k-means** algorithm, one of the most popular and easiest to understand clustering algorithms.\n", + "\n", + "In k-means, you need to specify how many clusters the algorithm should divide your data into, so the number of clusters you select is a tunable hyperparameter. The k-means algorithm subsequently attempts to create that many clusters by minimizing the Euclidean distance between points in the same cluster.\n", + "\n", + "Don't worry too much about implementation details right now, the goal of this assignment is to build intuition about clustering. We'll look more into the mechanics of how things work in part 2. If you're interested in the details, you can take a look at the [Wikipedia entry on k-means](https://en.wikipedia.org/wiki/K-means_clustering) in the meantime." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5WY193l0OSiA" + }, + "source": [ + "Run the following code boxes to load the Python libraries and data we'll be using today." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "UKw3L8d2CrUb", + "outputId": "9516133a-306b-469c-a152-aa59b4707cca" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/70.0 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K \u001b[91m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[90m╺\u001b[0m\u001b[90m━━━━\u001b[0m \u001b[32m61.4/70.0 kB\u001b[0m \u001b[31m17.0 MB/s\u001b[0m eta \u001b[36m0:00:01\u001b[0m\r\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m70.0/70.0 kB\u001b[0m \u001b[31m1.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h" + ] + } + ], + "source": [ + "!pip install \"datacommons-client[Pandas]\" --upgrade --quiet" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1DVlSq9fDdTs" + }, + "source": [ + "## 1) Images: building intuition with FashionMNIST\n", + "\n", + "We'll start exploring clustering with a simple, intuitive case: clustering the [FashionMNIST dataset](https://github.com/zalandoresearch/fashion-mnist).\n", + "\n", + "The FashionMNIST dataset is a collection of over 60,000 (28x28) greyscale images of various clothing items (e.g. shoes, shirts, bags) that's often used as a nice toy dataset in computer vision circles. While this particular dataset already has labels for each image, we'll be working with the images only. That is, we'll see what patterns in FashionMNIST we can recover without using any labels.\n", + "\n", + "Let's start by loading the dataset and viewing some sample images.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 670 + }, + "id": "-SnJqDECF0Il", + "outputId": "e41affef-b2a1-444f-cb88-a29285afa83d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded 2000 images. The first 25 are:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# load dataset\n", + "from keras.datasets import fashion_mnist\n", + "(fashion_mnist, labels), _ = fashion_mnist.load_data()\n", + "\n", + "# limit to first 2000 images so runtimes are reasonable\n", + "fashion_mnist = fashion_mnist[:2000, :, :]\n", + "\n", + "# Show the first 25 images as a sample\n", + "print(f\"Loaded {fashion_mnist.shape[0]} images. The first 25 are:\")\n", + "sns.set(rc={'figure.figsize':(11,8)})\n", + "for i in range(25):\n", + " # define subplot\n", + " plt.subplot(5, 5, i+1)\n", + " # plot raw pixel data\n", + " plt.imshow(fashion_mnist[i], cmap=plt.get_cmap('gray'))\n", + " plt.axis(\"off\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2RjjZVcxGHdT" + }, + "source": [ + "To cluster the images, we'll need to convert the images into a format we can pass into our KMeans model, which expects 1D feature vectors. For this assignment, we'll just flatten our image. This is akin to cutting each image up into rows, and concatenating the rows end-to-end to form one long, skinny image.\n", + "\n", + "Note that this is a rather naive way to vectorize images, and there exist better ways to represent images for clustering. We will continue with this approach in the interest of simplicity." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "9jSk-CgsGNTM" + }, + "outputs": [], + "source": [ + "# squash images into 1D\n", + "fashion_data = fashion_mnist.reshape((-1, 28*28))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9qgeMJvrGJtN" + }, + "source": [ + "Now run the code box below using different numbers of clusters, and note how the clustering results change." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 708 + }, + "id": "rSTIeeK8GRqh", + "outputId": "4b25f157-2f3f-4360-df96-cfe8568f02ce" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cluster 0 contains 919 images. The first 25 are:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cluster 1 contains 1081 images. The first 25 are:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# set number of clusters\n", + "k = 2 # Change me! Try 2, 8, 10, 15\n", + "\n", + "# cluster the images\n", + "kmeans = KMeans(n_clusters=k).fit(fashion_data)\n", + "\n", + "# create a dictionary of clusters to images\n", + "clusters = {n:[] for n in range(k)}\n", + "for i in range(fashion_data.shape[0]):\n", + " key = kmeans.labels_[i]\n", + " value = fashion_data[i,:].reshape(1, 28, 28).squeeze()\n", + " clusters[key].append(value)\n", + "\n", + "# display images from each cluster\n", + "sns.set(rc={'figure.figsize':(6,4)})\n", + "for cluster_num, images in clusters.items():\n", + " print(f'Cluster {cluster_num} contains {len(images)} images. The first 25 are:')\n", + " for i in range(min(25, len(images))):\n", + " # define subplot\n", + " plt.subplot(5, 5, i+1)\n", + " # plot pixel data\n", + " plt.imshow(images[i], cmap=plt.get_cmap('gray'))\n", + " plt.axis(\"off\")\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "paaKJosjIi6R" + }, + "source": [ + "### 1.1) Effect of number of clusters\n", + "**Q1: Try each of the settings `k=2`, `k=10`, and `k=15`. What value of k results in clusters that are most meaningful?**\n", + "\n", + "A1: Because FashionMNIST was created with 10 original categories, we should expect k=10 to work best of the settings suggested. You might rightfully observe that the \"best\" k can depend on what you're looking for (e.g. if k=2 is just shoes vs non-shoes, this might be the right level of nuance for your application!)\n", + "\n", + "**Q2: What happens if k is too small? What happens if k is too large?**\n", + "\n", + "A2: Too small and the clusters will still look heterogenous. Too large and we'll have clusters that seem to represent the same object (e.g. multiple clusters of shirts)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hnOBOvrcEzeC" + }, + "source": [ + "### 1.2) What features are used for clustering?\n", + "**Q3: Let's go back to `k=2`. What features of the images does KMeans seem to be using to split the data into two groups? Why do you think this was the feaure used?**\n", + "\n", + "A3: k=2 tends to cluster based on image intensity (e.g. dark vs light images). Because k-means uses euclidean distance between pixel values, high on average and low on average pixel values would be the most distinguishing feature at the k=2 level.\n", + "\n", + "**Q4: Now compare `k=10` with `k=8`. Which items or traits group together in `k=8` compared to `k=10`?**\n", + "\n", + "A4: You may notice that items that look similar (e.g. bag with similar area and shading to shirts) will group first with those items that are most similar." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bxeXgGNv9SY5" + }, + "source": [ + "### 1.3) Extension question\n", + "\n", + "**Q5 (Extension): Imagine you have a set of 1 million unlabeled images that look just like these fashion MNIST images, and you want to generate categorical labels for each of the images. However, labeling each of those 1 million images is too time intensive and costly.**\n", + "\n", + "**Devise a strategy for how you could use clustering to help you label each of the images.**\n", + "\n", + "*A5: Cluster the 1 million images. Label each of the clusters, and assign every image the label corresponding to its cluster*\n", + "\n", + "*This is semi-supervised learning!*" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MAqGyhgrlfPY" + }, + "source": [ + "## 2) Real-world data\n", + "\n", + "Now that we've built up some intuition on what k-means does, let's try clustering on some more complex, real world data. We've provided a list of the DCIDs for 100 countries around the world, along with a starting list of DCIDs of statistical variables.\n", + "\n", + "In case the DCID names are unclear, we will examine the following statistics for each country:\n", + "* CO2 emissions per capita\n", + "* Life expectancy\n", + "* Number of internet users per capita\n", + "* Population growth rate\n", + "* Percentage of population that is overweight\n", + "* [Gini index](https://www.investopedia.com/terms/g/gini-index.asp) (A measure of economic inequality)\n", + "* Percentage of population with mobile phone subscriptions\n", + "* [Gross domestic product](https://en.wikipedia.org/wiki/Gross_domestic_product) per captia\n", + "* [Fertility rate](https://data.oecd.org/pop/fertility-rates.htm)\n", + "* Number of deaths per year, normalized by population\n", + "\n", + "Run the following code boxes to load and cluster the data associated with each country." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 704 + }, + "id": "6LwJykBsuUPg", + "outputId": "eaa977ce-ca03-4eea-d610-88f78a2387dc" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"df\",\n \"rows\": 1047,\n \"fields\": [\n {\n \"column\": \"date\",\n \"properties\": {\n \"dtype\": \"object\",\n \"num_unique_values\": 25,\n \"samples\": [\n \"2017\",\n \"2015\",\n \"2023\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"entity\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 100,\n \"samples\": [\n \"country/PER\",\n \"country/MAR\",\n \"country/MLI\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"entity_name\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 100,\n \"samples\": [\n \"Peru\",\n \"Morocco\",\n \"Mali\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"variable\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 10,\n \"samples\": [\n \"FertilityRate_Person_Female\",\n \"Amount_EconomicActivity_GrossDomesticProduction_Nominal_PerCapita\",\n \"Count_Person_Upto4Years_Overweight_AsFractionOf_Count_Person_Upto4Years\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"variable_name\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 10,\n \"samples\": [\n \"Fertility Rate\",\n \"Nominal GDP Per Capita\",\n \"Percent of Children Younger Than 4 Years who are Overweight\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"value\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 4586.645121412181,\n \"min\": -8.4230077743,\n \"max\": 82769.4122114216,\n \"num_unique_values\": 971,\n \"samples\": [\n 7459.9981513284,\n 2.694,\n 2.9535809305\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"facetId\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 19,\n \"samples\": [\n \"3981252704\",\n \"3496587042\",\n \"3614729857\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"importName\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 11,\n \"samples\": [\n \"Kenya_Census\",\n \"WorldDevelopmentIndicators\",\n \"EurostatData_Fertility\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"measurementMethod\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 4,\n \"samples\": [\n \"WorldBankWeightedAverage\",\n \"WorldBankEstimate\",\n \"EurostatRegionalStatistics\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"observationPeriod\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 2,\n \"samples\": [\n \"Annual\",\n \"P1Y\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"provenanceUrl\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 11,\n \"samples\": [\n \"https://kenya.opendataforafrica.org/\",\n \"https://datacatalog.worldbank.org/dataset/world-development-indicators/\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"unit\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 5,\n \"samples\": [\n \"USDollar\",\n \"MetricTon\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe", + "variable_name": "df" + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
dateentityentity_namevariablevariable_namevaluefacetIdimportNamemeasurementMethodobservationPeriodprovenanceUrlunit
02023country/ARGArgentinaGrowthRate_Count_PersonRate of Population Growth0.2869763981252704WorldDevelopmentIndicatorsNoneP1Yhttps://datacatalog.worldbank.org/dataset/worl...None
12023country/UGAUgandaGrowthRate_Count_PersonRate of Population Growth2.8008323981252704WorldDevelopmentIndicatorsNoneP1Yhttps://datacatalog.worldbank.org/dataset/worl...None
22002country/UGAUgandaGrowthRate_Count_PersonRate of Population Growth3.2000001312347814Uganda_CensusNoneNonehttps://uganda.opendataforafrica.org/Percent
32023country/BOLBoliviaGrowthRate_Count_PersonRate of Population Growth1.3733443981252704WorldDevelopmentIndicatorsNoneP1Yhttps://datacatalog.worldbank.org/dataset/worl...None
42023country/MDGMadagascarGrowthRate_Count_PersonRate of Population Growth2.4620153981252704WorldDevelopmentIndicatorsNoneP1Yhttps://datacatalog.worldbank.org/dataset/worl...None
.......................................
10422023country/COGCongo [Republic]Amount_Emissions_CarbonDioxide_PerCapitaCO2 Emissions Per Capita1.1727214225050521WorldDevelopmentIndicatorsNoneP1Yhttps://datacatalog.worldbank.org/dataset/worl...MetricTon
10432023country/MRTMauritaniaAmount_Emissions_CarbonDioxide_PerCapitaCO2 Emissions Per Capita0.9259044225050521WorldDevelopmentIndicatorsNoneP1Yhttps://datacatalog.worldbank.org/dataset/worl...MetricTon
10442023country/TURTurkeyAmount_Emissions_CarbonDioxide_PerCapitaCO2 Emissions Per Capita5.1369554225050521WorldDevelopmentIndicatorsNoneP1Yhttps://datacatalog.worldbank.org/dataset/worl...MetricTon
10452023country/SWZEswatiniAmount_Emissions_CarbonDioxide_PerCapitaCO2 Emissions Per Capita1.1297794225050521WorldDevelopmentIndicatorsNoneP1Yhttps://datacatalog.worldbank.org/dataset/worl...MetricTon
10462023country/TZATanzaniaAmount_Emissions_CarbonDioxide_PerCapitaCO2 Emissions Per Capita0.2908174225050521WorldDevelopmentIndicatorsNoneP1Yhttps://datacatalog.worldbank.org/dataset/worl...MetricTon
\n", + "

1047 rows × 12 columns

\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + " date entity entity_name \\\n", + "0 2023 country/ARG Argentina \n", + "1 2023 country/UGA Uganda \n", + "2 2002 country/UGA Uganda \n", + "3 2023 country/BOL Bolivia \n", + "4 2023 country/MDG Madagascar \n", + "... ... ... ... \n", + "1042 2023 country/COG Congo [Republic] \n", + "1043 2023 country/MRT Mauritania \n", + "1044 2023 country/TUR Turkey \n", + "1045 2023 country/SWZ Eswatini \n", + "1046 2023 country/TZA Tanzania \n", + "\n", + " variable variable_name \\\n", + "0 GrowthRate_Count_Person Rate of Population Growth \n", + "1 GrowthRate_Count_Person Rate of Population Growth \n", + "2 GrowthRate_Count_Person Rate of Population Growth \n", + "3 GrowthRate_Count_Person Rate of Population Growth \n", + "4 GrowthRate_Count_Person Rate of Population Growth \n", + "... ... ... \n", + "1042 Amount_Emissions_CarbonDioxide_PerCapita CO2 Emissions Per Capita \n", + "1043 Amount_Emissions_CarbonDioxide_PerCapita CO2 Emissions Per Capita \n", + "1044 Amount_Emissions_CarbonDioxide_PerCapita CO2 Emissions Per Capita \n", + "1045 Amount_Emissions_CarbonDioxide_PerCapita CO2 Emissions Per Capita \n", + "1046 Amount_Emissions_CarbonDioxide_PerCapita CO2 Emissions Per Capita \n", + "\n", + " value facetId importName measurementMethod \\\n", + "0 0.286976 3981252704 WorldDevelopmentIndicators None \n", + "1 2.800832 3981252704 WorldDevelopmentIndicators None \n", + "2 3.200000 1312347814 Uganda_Census None \n", + "3 1.373344 3981252704 WorldDevelopmentIndicators None \n", + "4 2.462015 3981252704 WorldDevelopmentIndicators None \n", + "... ... ... ... ... \n", + "1042 1.172721 4225050521 WorldDevelopmentIndicators None \n", + "1043 0.925904 4225050521 WorldDevelopmentIndicators None \n", + "1044 5.136955 4225050521 WorldDevelopmentIndicators None \n", + "1045 1.129779 4225050521 WorldDevelopmentIndicators None \n", + "1046 0.290817 4225050521 WorldDevelopmentIndicators None \n", + "\n", + " observationPeriod provenanceUrl \\\n", + "0 P1Y https://datacatalog.worldbank.org/dataset/worl... \n", + "1 P1Y https://datacatalog.worldbank.org/dataset/worl... \n", + "2 None https://uganda.opendataforafrica.org/ \n", + "3 P1Y https://datacatalog.worldbank.org/dataset/worl... \n", + "4 P1Y https://datacatalog.worldbank.org/dataset/worl... \n", + "... ... ... \n", + "1042 P1Y https://datacatalog.worldbank.org/dataset/worl... \n", + "1043 P1Y https://datacatalog.worldbank.org/dataset/worl... \n", + "1044 P1Y https://datacatalog.worldbank.org/dataset/worl... \n", + "1045 P1Y https://datacatalog.worldbank.org/dataset/worl... \n", + "1046 P1Y https://datacatalog.worldbank.org/dataset/worl... \n", + "\n", + " unit \n", + "0 None \n", + "1 None \n", + "2 Percent \n", + "3 None \n", + "4 None \n", + "... ... \n", + "1042 MetricTon \n", + "1043 MetricTon \n", + "1044 MetricTon \n", + "1045 MetricTon \n", + "1046 MetricTon \n", + "\n", + "[1047 rows x 12 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "countries = [\n", + " 'country/AGO', 'country/ALB', 'country/ARG', 'country/ARM', 'country/AUS',\n", + " 'country/AZE', 'country/BDI', 'country/BGD', 'country/BGR', 'country/BIH',\n", + " 'country/BLZ', 'country/BOL', 'country/BRA', 'country/BTN', 'country/BWA',\n", + " 'country/CAN', 'country/CHL', 'country/CHN', 'country/CMR', 'country/COD',\n", + " 'country/COG', 'country/COL', 'country/CRI', 'country/CZE', 'country/DOM',\n", + " 'country/DZA', 'country/ECU', 'country/EGY', 'country/ETH', 'country/FJI',\n", + " 'country/GAB', 'country/GEO', 'country/GHA', 'country/GTM', 'country/GUY',\n", + " 'country/HND', 'country/IDN', 'country/IND', 'country/IRN', 'country/JAM',\n", + " 'country/JOR', 'country/JPN', 'country/KAZ', 'country/KEN', 'country/KGZ',\n", + " 'country/KIR', 'country/KOR', 'country/LAO', 'country/LBN', 'country/LCA',\n", + " 'country/LSO', 'country/MAR', 'country/MDA', 'country/MDG', 'country/MEX',\n", + " 'country/MLI', 'country/MMR', 'country/MNE', 'country/MNG', 'country/MOZ',\n", + " 'country/MRT', 'country/MWI', 'country/MYS', 'country/NAM', 'country/NER',\n", + " 'country/NGA', 'country/NIC', 'country/NPL', 'country/PAK', 'country/PAN',\n", + " 'country/PER', 'country/PHL', 'country/PNG', 'country/PRY', 'country/ROU',\n", + " 'country/RWA', 'country/SDN', 'country/SLV', 'country/SRB', 'country/SWZ',\n", + " 'country/SYR', 'country/THA', 'country/TJK', 'country/TKM', 'country/TLS',\n", + " 'country/TON', 'country/TTO', 'country/TUN', 'country/TUR', 'country/TZA',\n", + " 'country/UGA', 'country/UKR', 'country/USA', 'country/UZB', 'country/VNM',\n", + " 'country/VUT', 'country/YEM', 'country/ZAF', 'country/ZMB', 'country/ZWE'\n", + "]\n", + "\n", + "stat_vars_to_query = [\n", + " \"Amount_Emissions_CarbonDioxide_PerCapita\",\n", + " \"LifeExpectancy_Person\",\n", + " \"Count_Person_IsInternetUser_PerCapita\",\n", + " \"GrowthRate_Count_Person\",\n", + " \"Count_Person_Upto4Years_Overweight_AsFractionOf_Count_Person_Upto4Years\",\n", + " \"GiniIndex_EconomicActivity\",\n", + " \"Count_Product_MobileCellularSubscription_AsFractionOf_Count_Person\",\n", + " \"Amount_EconomicActivity_GrossDomesticProduction_Nominal_PerCapita\",\n", + " \"FertilityRate_Person_Female\",\n", + " \"Count_Death_AsAFractionOfCount_Person\"\n", + "]\n", + "df = client.observations_dataframe(entity_dcids=countries, variable_dcids=stat_vars_to_query, date='latest')\n", + "display(df)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9u9WRGFE2DFa" + }, + "source": [ + "### 2.1) Flattening data per countrry\n", + "\n", + "Each row in the DataFrame reflects a single statistical observation. Before applying statistical normalization, we will rearrange our data to reflect the observations per country as columns.\n", + "\n", + "To accomplish this, we can group by `(entity, entity_name, variable)` and then apply a pivot on the subset of columns we wish to retain. In our Data Commons query we requested the `latest` observation for each statistical variable; however, if we had selected a range this would be the time to also collapse the observations to a single desired value.\n", + "\n", + "Finally we will rename our index to be the name of the country.\n", + "\n", + "Run the code below to rearrange and flatten our data rows in the DataFrame." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 475 + }, + "id": "ALtH6kJd2Dgn", + "outputId": "c3dc6a18-8b0d-46df-9458-12c5c518045c" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"df\",\n \"rows\": 98,\n \"fields\": [\n {\n \"column\": \"Country\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 98,\n \"samples\": [\n \"Myanmar [Burma]\",\n \"Indonesia\",\n \"Vietnam\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Amount_EconomicActivity_GrossDomesticProduction_Nominal_PerCapita\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 12660.430210284881,\n \"min\": 193.0071455648,\n \"max\": 82769.4122114216,\n \"num_unique_values\": 98,\n \"samples\": [\n 1233.1966620927,\n 4876.3143270319,\n 4282.0885172451\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Amount_Emissions_CarbonDioxide_PerCapita\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 3.6873466431894943,\n \"min\": 0.0359155843,\n \"max\": 19.9020116855,\n \"num_unique_values\": 98,\n \"samples\": [\n 0.616406039,\n 2.3988610522,\n 3.7163961501\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Death_AsAFractionOfCount_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2.310270042156018,\n \"min\": 3.049,\n \"max\": 15.7,\n \"num_unique_values\": 98,\n \"samples\": [\n 9.153,\n 7.531,\n 6.577\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person_IsInternetUser_PerCapita\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 24.87160871033679,\n \"min\": 11.1,\n \"max\": 97.7,\n \"num_unique_values\": 91,\n \"samples\": [\n 69.2,\n 38.4,\n 37.4\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person_Upto4Years_Overweight_AsFractionOf_Count_Person_Upto4Years\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.04767323046541555,\n \"min\": 0.008,\n \"max\": 0.265,\n \"num_unique_values\": 71,\n \"samples\": [\n 0.059,\n 0.164,\n 0.032\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Product_MobileCellularSubscription_AsFractionOf_Count_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.32194958849055555,\n \"min\": 0.4207158261,\n \"max\": 1.816273204,\n \"num_unique_values\": 98,\n \"samples\": [\n 1.066964737,\n 1.149005566,\n 1.399496874\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"FertilityRate_Person_Female\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.199634729992407,\n \"min\": 0.721,\n \"max\": 6.061,\n \"num_unique_values\": 94,\n \"samples\": [\n 1.358,\n 1.33,\n 1.731\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"GiniIndex_EconomicActivity\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 8.211422885899049,\n \"min\": 25.6,\n \"max\": 63.0,\n \"num_unique_values\": 83,\n \"samples\": [\n 54.6,\n 29.4,\n 48.9\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"GrowthRate_Count_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.5614737725156045,\n \"min\": -8.4230077743,\n \"max\": 4.9186152682,\n \"num_unique_values\": 98,\n \"samples\": [\n 0.6988793963,\n 0.8426661373,\n 0.6714292507\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"LifeExpectancy_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 5.897314294540096,\n \"min\": 54.462,\n \"max\": 84.0412195122,\n \"num_unique_values\": 98,\n \"samples\": [\n 66.889,\n 71.146,\n 74.588\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe", + "variable_name": "df" + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
variableAmount_EconomicActivity_GrossDomesticProduction_Nominal_PerCapitaAmount_Emissions_CarbonDioxide_PerCapitaCount_Death_AsAFractionOfCount_PersonCount_Person_IsInternetUser_PerCapitaCount_Person_Upto4Years_Overweight_AsFractionOf_Count_Person_Upto4YearsCount_Product_MobileCellularSubscription_AsFractionOf_Count_PersonFertilityRate_Person_FemaleGiniIndex_EconomicActivityGrowthRate_Count_PersonLifeExpectancy_Person
Country
Albania8575.1711341.6721958.33283.10.1640.9788571.34829.4-1.14841879.602000
Algeria5364.0279503.9068704.64176.90.1281.0916542.76627.61.49897676.261000
Angola2308.1597670.7681636.92544.80.0340.6737355.12451.33.08065564.617000
Argentina14187.4827254.0356807.66889.20.1241.3235781.50040.70.28697677.395000
Armenia8053.0106632.5828688.20080.00.1371.3525401.90027.90.72817977.465854
.................................
Vanuatu3515.2363360.8966665.08345.70.0490.7819953.59632.32.32481671.477000
Vietnam4282.0885173.7163966.57778.10.0941.3994971.91336.10.67142974.588000
Yemen477.4090290.2766844.79213.80.0150.4601954.59036.73.00980869.295000
Zambia1330.7278060.3888735.20733.00.0520.9910244.10151.52.79406866.349000
Zimbabwe2156.0340040.7186977.61438.40.0430.8762453.72450.31.67709662.775000
\n", + "

98 rows × 10 columns

\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + "variable Amount_EconomicActivity_GrossDomesticProduction_Nominal_PerCapita \\\n", + "Country \n", + "Albania 8575.171134 \n", + "Algeria 5364.027950 \n", + "Angola 2308.159767 \n", + "Argentina 14187.482725 \n", + "Armenia 8053.010663 \n", + "... ... \n", + "Vanuatu 3515.236336 \n", + "Vietnam 4282.088517 \n", + "Yemen 477.409029 \n", + "Zambia 1330.727806 \n", + "Zimbabwe 2156.034004 \n", + "\n", + "variable Amount_Emissions_CarbonDioxide_PerCapita \\\n", + "Country \n", + "Albania 1.672195 \n", + "Algeria 3.906870 \n", + "Angola 0.768163 \n", + "Argentina 4.035680 \n", + "Armenia 2.582868 \n", + "... ... \n", + "Vanuatu 0.896666 \n", + "Vietnam 3.716396 \n", + "Yemen 0.276684 \n", + "Zambia 0.388873 \n", + "Zimbabwe 0.718697 \n", + "\n", + "variable Count_Death_AsAFractionOfCount_Person \\\n", + "Country \n", + "Albania 8.332 \n", + "Algeria 4.641 \n", + "Angola 6.925 \n", + "Argentina 7.668 \n", + "Armenia 8.200 \n", + "... ... \n", + "Vanuatu 5.083 \n", + "Vietnam 6.577 \n", + "Yemen 4.792 \n", + "Zambia 5.207 \n", + "Zimbabwe 7.614 \n", + "\n", + "variable Count_Person_IsInternetUser_PerCapita \\\n", + "Country \n", + "Albania 83.1 \n", + "Algeria 76.9 \n", + "Angola 44.8 \n", + "Argentina 89.2 \n", + "Armenia 80.0 \n", + "... ... \n", + "Vanuatu 45.7 \n", + "Vietnam 78.1 \n", + "Yemen 13.8 \n", + "Zambia 33.0 \n", + "Zimbabwe 38.4 \n", + "\n", + "variable Count_Person_Upto4Years_Overweight_AsFractionOf_Count_Person_Upto4Years \\\n", + "Country \n", + "Albania 0.164 \n", + "Algeria 0.128 \n", + "Angola 0.034 \n", + "Argentina 0.124 \n", + "Armenia 0.137 \n", + "... ... \n", + "Vanuatu 0.049 \n", + "Vietnam 0.094 \n", + "Yemen 0.015 \n", + "Zambia 0.052 \n", + "Zimbabwe 0.043 \n", + "\n", + "variable Count_Product_MobileCellularSubscription_AsFractionOf_Count_Person \\\n", + "Country \n", + "Albania 0.978857 \n", + "Algeria 1.091654 \n", + "Angola 0.673735 \n", + "Argentina 1.323578 \n", + "Armenia 1.352540 \n", + "... ... \n", + "Vanuatu 0.781995 \n", + "Vietnam 1.399497 \n", + "Yemen 0.460195 \n", + "Zambia 0.991024 \n", + "Zimbabwe 0.876245 \n", + "\n", + "variable FertilityRate_Person_Female GiniIndex_EconomicActivity \\\n", + "Country \n", + "Albania 1.348 29.4 \n", + "Algeria 2.766 27.6 \n", + "Angola 5.124 51.3 \n", + "Argentina 1.500 40.7 \n", + "Armenia 1.900 27.9 \n", + "... ... ... \n", + "Vanuatu 3.596 32.3 \n", + "Vietnam 1.913 36.1 \n", + "Yemen 4.590 36.7 \n", + "Zambia 4.101 51.5 \n", + "Zimbabwe 3.724 50.3 \n", + "\n", + "variable GrowthRate_Count_Person LifeExpectancy_Person \n", + "Country \n", + "Albania -1.148418 79.602000 \n", + "Algeria 1.498976 76.261000 \n", + "Angola 3.080655 64.617000 \n", + "Argentina 0.286976 77.395000 \n", + "Armenia 0.728179 77.465854 \n", + "... ... ... \n", + "Vanuatu 2.324816 71.477000 \n", + "Vietnam 0.671429 74.588000 \n", + "Yemen 3.009808 69.295000 \n", + "Zambia 2.794068 66.349000 \n", + "Zimbabwe 1.677096 62.775000 \n", + "\n", + "[98 rows x 10 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# group on (entity_name, variable) and pivot on (variable, value)\n", + "df = df.groupby([\"entity_name\", \"variable\"]).first().reset_index()\n", + "df = df[[\"entity_name\", \"variable\", \"value\"]]\n", + "df = df.pivot(index=[\"entity_name\"], columns=\"variable\", values=\"value\")\n", + "df = df.dropna()\n", + "\n", + "# index on countryCode and rename `entity_name` > `Country Name`\n", + "df = df.reset_index()\n", + "df.rename(columns={\"entity_name\": \"Country\"}, inplace=True)\n", + "df.set_index(\"Country\", inplace=True)\n", + "df = df.reindex(sorted(df.columns), axis=1)\n", + "\n", + "display(df)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "z1eNSt7fvnjY" + }, + "source": [ + "### 2.2) The importance of normalization\n", + "Scroll through the Dataframe generated by the codebox above, and take note of the scales of each of the features. They can vary drastically in magnitude! Let's normalize our data before clustering.\n", + "\n", + "**Q1: What do you think would happen if we didn't normalize our data before clustering?**\n", + "\n", + "*A1:Generally the features with higher magnitudes will end up dominating the clustering.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 475 + }, + "id": "QhOQzx81v1I2", + "outputId": "d6390efd-163a-4188-d5dd-7534723c6669" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"normalized_df\",\n \"rows\": 98,\n \"fields\": [\n {\n \"column\": \"Country\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 98,\n \"samples\": [\n \"Myanmar [Burma]\",\n \"Indonesia\",\n \"Vietnam\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Amount_EconomicActivity_GrossDomesticProduction_Nominal_PerCapita\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.9999999999999997,\n \"min\": -0.6461685611085157,\n \"max\": 5.876232628605771,\n \"num_unique_values\": 98,\n \"samples\": [\n -0.5640078841606749,\n -0.2762516543621282,\n -0.3231873271565702\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Amount_Emissions_CarbonDioxide_PerCapita\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.0000000000000002,\n \"min\": -0.8349407771344035,\n \"max\": 4.552699177436332,\n \"num_unique_values\": 98,\n \"samples\": [\n -0.6775130897288372,\n -0.19411535534653201,\n 0.16319715833684487\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Death_AsAFractionOfCount_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.9999999999999998,\n \"min\": -1.750060456622983,\n \"max\": 3.7259227700796766,\n \"num_unique_values\": 98,\n \"samples\": [\n 0.8920549189040932,\n 0.18997249113461104,\n -0.22296624874953533\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person_IsInternetUser_PerCapita\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.0000000000000002,\n \"min\": -2.150062379433337,\n \"max\": 1.331819352004828,\n \"num_unique_values\": 91,\n \"samples\": [\n 0.18593448657771836,\n -1.0524252978136845,\n -1.092631784319899\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person_Upto4Years_Overweight_AsFractionOf_Count_Person_Upto4Years\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.0000000000000002,\n \"min\": -1.2921725717961488,\n \"max\": 4.098693486388017,\n \"num_unique_values\": 71,\n \"samples\": [\n -0.22238981316816273,\n 1.9801041016541618,\n -0.7887453912653318\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Product_MobileCellularSubscription_AsFractionOf_Count_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.0,\n \"min\": -2.0118377829915386,\n \"max\": 2.3228699718560466,\n \"num_unique_values\": 98,\n \"samples\": [\n -0.004539330057011171,\n 0.2502857479455556,\n 1.0283308735020624\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"FertilityRate_Person_Female\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.9999999999999998,\n \"min\": -1.595711061295617,\n \"max\": 2.8556438940863424,\n \"num_unique_values\": 94,\n \"samples\": [\n -1.0647160975169074,\n -1.0880565354852023,\n -0.7537881202964073\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"GiniIndex_EconomicActivity\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.0000000000000002,\n \"min\": -1.5673785581506015,\n \"max\": 2.987252292030629,\n \"num_unique_values\": 83,\n \"samples\": [\n 1.964287074342866,\n -1.1046085787204234,\n 1.270132105197598\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"GrowthRate_Count_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.0,\n \"min\": -6.164400048092786,\n \"max\": 2.3798504397050624,\n \"num_unique_values\": 98,\n \"samples\": [\n -0.32255541953765554,\n -0.23047142585753555,\n -0.3401350587753844\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"LifeExpectancy_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.0,\n \"min\": -2.9236629543326154,\n \"max\": 2.092047254564559,\n \"num_unique_values\": 98,\n \"samples\": [\n -0.8164325475175557,\n -0.09457853272623643,\n 0.48907698029037455\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe", + "variable_name": "normalized_df" + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
variableAmount_EconomicActivity_GrossDomesticProduction_Nominal_PerCapitaAmount_Emissions_CarbonDioxide_PerCapitaCount_Death_AsAFractionOfCount_PersonCount_Person_IsInternetUser_PerCapitaCount_Person_Upto4Years_Overweight_AsFractionOf_Count_Person_Upto4YearsCount_Product_MobileCellularSubscription_AsFractionOf_Count_PersonFertilityRate_Person_FemaleGiniIndex_EconomicActivityGrowthRate_Count_PersonLifeExpectancy_Person
Country
Albania0.015907-0.3911860.5366850.7448051.980104-0.278208-1.073052-1.104609-1.5056031.339295
Algeria-0.2377290.214853-1.0609640.4955241.2249630.0721460.108974-1.3238150.1898430.772765
Angola-0.479101-0.636357-0.072335-0.795104-0.746793-1.2259422.0745731.5624081.202783-1.201693
Argentina0.4592030.2497860.2492730.9900641.1410590.792521-0.9463470.271523-0.5863470.965056
Armenia-0.025336-0.1442130.4795490.6201651.4137490.882479-0.612912-1.287281-0.3037910.977071
.................................
Vanuatu-0.383758-0.601507-0.869644-0.758918-0.432151-0.8896780.800852-0.7514420.718728-0.038451
Vietnam-0.3231870.163197-0.2229660.5437720.5117751.028331-0.602075-0.288672-0.3401350.489077
Yemen-0.623705-0.769645-0.995603-2.041505-1.145340-1.8892111.629437-0.2156031.157411-0.408450
Zambia-0.556304-0.739219-0.815971-1.269540-0.369223-0.2404161.2218131.5867641.019246-0.908000
Zimbabwe-0.491116-0.6497720.225899-1.052425-0.558008-0.5969290.9075511.4406260.303915-1.514038
\n", + "

98 rows × 10 columns

\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + "variable Amount_EconomicActivity_GrossDomesticProduction_Nominal_PerCapita \\\n", + "Country \n", + "Albania 0.015907 \n", + "Algeria -0.237729 \n", + "Angola -0.479101 \n", + "Argentina 0.459203 \n", + "Armenia -0.025336 \n", + "... ... \n", + "Vanuatu -0.383758 \n", + "Vietnam -0.323187 \n", + "Yemen -0.623705 \n", + "Zambia -0.556304 \n", + "Zimbabwe -0.491116 \n", + "\n", + "variable Amount_Emissions_CarbonDioxide_PerCapita \\\n", + "Country \n", + "Albania -0.391186 \n", + "Algeria 0.214853 \n", + "Angola -0.636357 \n", + "Argentina 0.249786 \n", + "Armenia -0.144213 \n", + "... ... \n", + "Vanuatu -0.601507 \n", + "Vietnam 0.163197 \n", + "Yemen -0.769645 \n", + "Zambia -0.739219 \n", + "Zimbabwe -0.649772 \n", + "\n", + "variable Count_Death_AsAFractionOfCount_Person \\\n", + "Country \n", + "Albania 0.536685 \n", + "Algeria -1.060964 \n", + "Angola -0.072335 \n", + "Argentina 0.249273 \n", + "Armenia 0.479549 \n", + "... ... \n", + "Vanuatu -0.869644 \n", + "Vietnam -0.222966 \n", + "Yemen -0.995603 \n", + "Zambia -0.815971 \n", + "Zimbabwe 0.225899 \n", + "\n", + "variable Count_Person_IsInternetUser_PerCapita \\\n", + "Country \n", + "Albania 0.744805 \n", + "Algeria 0.495524 \n", + "Angola -0.795104 \n", + "Argentina 0.990064 \n", + "Armenia 0.620165 \n", + "... ... \n", + "Vanuatu -0.758918 \n", + "Vietnam 0.543772 \n", + "Yemen -2.041505 \n", + "Zambia -1.269540 \n", + "Zimbabwe -1.052425 \n", + "\n", + "variable Count_Person_Upto4Years_Overweight_AsFractionOf_Count_Person_Upto4Years \\\n", + "Country \n", + "Albania 1.980104 \n", + "Algeria 1.224963 \n", + "Angola -0.746793 \n", + "Argentina 1.141059 \n", + "Armenia 1.413749 \n", + "... ... \n", + "Vanuatu -0.432151 \n", + "Vietnam 0.511775 \n", + "Yemen -1.145340 \n", + "Zambia -0.369223 \n", + "Zimbabwe -0.558008 \n", + "\n", + "variable Count_Product_MobileCellularSubscription_AsFractionOf_Count_Person \\\n", + "Country \n", + "Albania -0.278208 \n", + "Algeria 0.072146 \n", + "Angola -1.225942 \n", + "Argentina 0.792521 \n", + "Armenia 0.882479 \n", + "... ... \n", + "Vanuatu -0.889678 \n", + "Vietnam 1.028331 \n", + "Yemen -1.889211 \n", + "Zambia -0.240416 \n", + "Zimbabwe -0.596929 \n", + "\n", + "variable FertilityRate_Person_Female GiniIndex_EconomicActivity \\\n", + "Country \n", + "Albania -1.073052 -1.104609 \n", + "Algeria 0.108974 -1.323815 \n", + "Angola 2.074573 1.562408 \n", + "Argentina -0.946347 0.271523 \n", + "Armenia -0.612912 -1.287281 \n", + "... ... ... \n", + "Vanuatu 0.800852 -0.751442 \n", + "Vietnam -0.602075 -0.288672 \n", + "Yemen 1.629437 -0.215603 \n", + "Zambia 1.221813 1.586764 \n", + "Zimbabwe 0.907551 1.440626 \n", + "\n", + "variable GrowthRate_Count_Person LifeExpectancy_Person \n", + "Country \n", + "Albania -1.505603 1.339295 \n", + "Algeria 0.189843 0.772765 \n", + "Angola 1.202783 -1.201693 \n", + "Argentina -0.586347 0.965056 \n", + "Armenia -0.303791 0.977071 \n", + "... ... ... \n", + "Vanuatu 0.718728 -0.038451 \n", + "Vietnam -0.340135 0.489077 \n", + "Yemen 1.157411 -0.408450 \n", + "Zambia 1.019246 -0.908000 \n", + "Zimbabwe 0.303915 -1.514038 \n", + "\n", + "[98 rows x 10 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# normalize the values\n", + "mean_df = df.mean(numeric_only=True)\n", + "std_df = df.std(numeric_only=True)\n", + "\n", + "normalized_df = ((df-mean_df)/std_df)\n", + "display(normalized_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9ePjPC65wDwx" + }, + "source": [ + "### 2.3) Interpreting clusters\n", + "Now let's cluster our data! Once again, play around with $k$ to see how the results change." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0IrIOjDlwJdn", + "outputId": "0f7a59bc-808c-490d-e03d-5cf286c15ab0" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Countries in Cluster 0:\n", + "['Albania', 'Algeria', 'Argentina', 'Armenia', 'Azerbaijan', 'Bangladesh', 'Belize', 'Bhutan', 'Bolivia', 'Botswana', 'Brazil', 'Chile', 'Colombia', 'Costa Rica', 'Dominican Republic', 'Ecuador', 'Egypt', 'El Salvador', 'Fiji', 'Gabon', 'Guatemala', 'Guyana', 'India', 'Indonesia', 'Iran', 'Jamaica', 'Jordan', 'Kazakhstan', 'Kyrgyzstan', 'Lebanon', 'Malaysia', 'Mexico', 'Mongolia', 'Morocco', 'Nepal', 'Nicaragua', 'Panama', 'Paraguay', 'Peru', 'Philippines', 'Saint Lucia', 'South Africa', 'Tajikistan', 'Thailand', 'Tonga', 'Tunisia', 'Turkey', 'Uzbekistan', 'Vietnam']\n", + "49\n", + "Countries in Cluster 1:\n", + "['Angola', 'Burundi', 'Cameroon', 'Congo [DRC]', 'Congo [Republic]', 'East Timor', 'Eswatini', 'Ethiopia', 'Ghana', 'Honduras', 'Kenya', 'Kiribati', 'Laos', 'Lesotho', 'Madagascar', 'Malawi', 'Mali', 'Mauritania', 'Mozambique', 'Myanmar [Burma]', 'Namibia', 'Niger', 'Nigeria', 'Pakistan', 'Papua New Guinea', 'Rwanda', 'Sudan', 'Syria', 'Tanzania', 'Turkmenistan', 'Uganda', 'Vanuatu', 'Yemen', 'Zambia', 'Zimbabwe']\n", + "35\n", + "Countries in Cluster 2:\n", + "['Australia', 'Bosnia and Herzegovina', 'Bulgaria', 'Canada', 'China', 'Czech Republic', 'Georgia', 'Japan', 'Moldova', 'Romania', 'South Korea', 'Trinidad and Tobago', 'Ukraine', 'United States of America']\n", + "14\n" + ] + } + ], + "source": [ + "# Clustering using K-means\n", + "n_clusters = 3\n", + "kmeans_model = KMeans(n_clusters).fit(normalized_df)\n", + "labels_df = pd.DataFrame(data=np.transpose(kmeans_model.labels_), index=normalized_df.index, columns=['cluster'])\n", + "\n", + "# list countries in each cluster:\n", + "for i in range(n_clusters):\n", + " print(f'Countries in Cluster {i}:')\n", + " print(labels_df.index[labels_df['cluster']==i].tolist())\n", + " print(len(labels_df.index[labels_df['cluster']==i].tolist()))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sfINZFcGwcjY" + }, + "source": [ + "#### Analyzing centroids\n", + "\n", + "What characterizes each of the clusters?\n", + "\n", + "It can be a little hard to tell what characteristics each cluster has latched on to from cluster membership alone. One way to characterize clusters is to look at the **centroids**, which are the average values of each cluster. One can think of the centroids as describing the average group member.\n", + "\n", + "Run the following code box to display the values of the centroids of each cluster. *Note: We're displaying the non-normalized values for better interpretability. The clustering was still performed on normalized values.*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "LV-U4hpZw7ei", + "outputId": "fbbb65de-aefe-499c-e8d0-e35c69e347c7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Cluster 0:\n" + ] + }, + { + "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", + "
0
variable
Amount_EconomicActivity_GrossDomesticProduction_Nominal_PerCapita7354.195071
Amount_Emissions_CarbonDioxide_PerCapita3.030033
Count_Death_AsAFractionOfCount_Person6.247837
Count_Person_IsInternetUser_PerCapita77.895918
Count_Person_Upto4Years_Overweight_AsFractionOf_Count_Person_Upto4Years0.079265
Count_Product_MobileCellularSubscription_AsFractionOf_Count_Person1.190733
FertilityRate_Person_Female2.112551
GiniIndex_EconomicActivity38.606122
GrowthRate_Count_Person0.922780
LifeExpectancy_Person74.153838
\n", + "

" + ], + "text/plain": [ + "variable\n", + "Amount_EconomicActivity_GrossDomesticProduction_Nominal_PerCapita 7354.195071\n", + "Amount_Emissions_CarbonDioxide_PerCapita 3.030033\n", + "Count_Death_AsAFractionOfCount_Person 6.247837\n", + "Count_Person_IsInternetUser_PerCapita 77.895918\n", + "Count_Person_Upto4Years_Overweight_AsFractionOf_Count_Person_Upto4Years 0.079265\n", + "Count_Product_MobileCellularSubscription_AsFractionOf_Count_Person 1.190733\n", + "FertilityRate_Person_Female 2.112551\n", + "GiniIndex_EconomicActivity 38.606122\n", + "GrowthRate_Count_Person 0.922780\n", + "LifeExpectancy_Person 74.153838\n", + "dtype: float64" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Cluster 1:\n" + ] + }, + { + "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", + "
0
variable
Amount_EconomicActivity_GrossDomesticProduction_Nominal_PerCapita1860.935259
Amount_Emissions_CarbonDioxide_PerCapita0.863238
Count_Death_AsAFractionOfCount_Person6.817514
Count_Person_IsInternetUser_PerCapita37.062857
Count_Person_Upto4Years_Overweight_AsFractionOf_Count_Person_Upto4Years0.042771
Count_Product_MobileCellularSubscription_AsFractionOf_Count_Person0.815895
FertilityRate_Person_Female3.855400
GiniIndex_EconomicActivity40.357143
GrowthRate_Count_Person2.289117
LifeExpectancy_Person65.779286
\n", + "

" + ], + "text/plain": [ + "variable\n", + "Amount_EconomicActivity_GrossDomesticProduction_Nominal_PerCapita 1860.935259\n", + "Amount_Emissions_CarbonDioxide_PerCapita 0.863238\n", + "Count_Death_AsAFractionOfCount_Person 6.817514\n", + "Count_Person_IsInternetUser_PerCapita 37.062857\n", + "Count_Person_Upto4Years_Overweight_AsFractionOf_Count_Person_Upto4Years 0.042771\n", + "Count_Product_MobileCellularSubscription_AsFractionOf_Count_Person 0.815895\n", + "FertilityRate_Person_Female 3.855400\n", + "GiniIndex_EconomicActivity 40.357143\n", + "GrowthRate_Count_Person 2.289117\n", + "LifeExpectancy_Person 65.779286\n", + "dtype: float64" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Cluster 2:\n" + ] + }, + { + "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", + "
0
variable
Amount_EconomicActivity_GrossDomesticProduction_Nominal_PerCapita28224.432925
Amount_Emissions_CarbonDioxide_PerCapita9.039210
Count_Death_AsAFractionOfCount_Person10.733571
Count_Person_IsInternetUser_PerCapita86.735714
Count_Person_Upto4Years_Overweight_AsFractionOf_Count_Person_Upto4Years0.102857
Count_Product_MobileCellularSubscription_AsFractionOf_Count_Person1.271680
FertilityRate_Person_Female1.414464
GiniIndex_EconomicActivity33.278571
GrowthRate_Count_Person-0.534735
LifeExpectancy_Person77.939667
\n", + "

" + ], + "text/plain": [ + "variable\n", + "Amount_EconomicActivity_GrossDomesticProduction_Nominal_PerCapita 28224.432925\n", + "Amount_Emissions_CarbonDioxide_PerCapita 9.039210\n", + "Count_Death_AsAFractionOfCount_Person 10.733571\n", + "Count_Person_IsInternetUser_PerCapita 86.735714\n", + "Count_Person_Upto4Years_Overweight_AsFractionOf_Count_Person_Upto4Years 0.102857\n", + "Count_Product_MobileCellularSubscription_AsFractionOf_Count_Person 1.271680\n", + "FertilityRate_Person_Female 1.414464\n", + "GiniIndex_EconomicActivity 33.278571\n", + "GrowthRate_Count_Person -0.534735\n", + "LifeExpectancy_Person 77.939667\n", + "dtype: float64" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Get centroids of each cluster.\n", + "for i in range(n_clusters):\n", + " print(f'\\nCluster {i}:')\n", + " # display non-normalized mean values\n", + " mean_to_display = df[labels_df['cluster']==i].mean()\n", + " display(mean_to_display)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1Hqw46XLxJWA" + }, + "source": [ + "#### Visualizing centroids\n", + "These values can be difficult to compare on their own. One good way to visualize cluster centroids is by using a color-coded heat map of normalized values. Use the code box below to generate such a heat map." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "D_BDDdvtyxlz", + "outputId": "662212e2-9ffd-46c0-e259-ccc5599bc077" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# get normalized values\n", + "normalized_means = []\n", + "for i in range(n_clusters):\n", + " # calculate normalized values for the next part\n", + " mean_normalized = normalized_df[labels_df['cluster']==i].mean()\n", + " normalized_means.append(mean_normalized.to_frame().transpose())\n", + "normalized_means_df = pd.concat(normalized_means)\n", + "\n", + "# For better visualization, we'll multiply the following features by -1\n", + "# so that a higher value is associated with more development.\n", + "\n", + "features_to_flip = [\n", + " \"GiniIndex_EconomicActivity\",\n", + " \"GrowthRate_Count_Person\",\n", + " \"FertilityRate_Person_Female\"\n", + "]\n", + "\n", + "for column in features_to_flip:\n", + " normalized_means_df[column] *= -1\n", + "\n", + "# Plot heatmap\n", + "sns.set(rc={'figure.figsize':(11.7,8.27)})\n", + "sns.set(font_scale = 1.5)\n", + "ax = sns.heatmap(normalized_means_df.to_numpy(), linewidth=0.5, xticklabels=normalized_means_df.columns, center=0)\n", + "ax.set_ylabel(\"Cluster\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TO9J4Jkv1oO1" + }, + "source": [ + "*For Q2-Q4, please answer using `k=3`.*\n", + "\n", + "**Q2: What does each cluster seem to represent?**\n", + "\n", + "Now, here's a list of 3 held-out countries (i.e., countries that weren't part of the original countries we used to create the clusters).\n", + "\n", + "- Germany\n", + "- Haiti\n", + "- Iraq\n", + "\n", + "**Q3: For each of the countries listed above, make a prediction for which cluster the country would be a member of.**\n", + "\n", + "Run the code box below to get feature values for each country that can help you answer Q3." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 195 + }, + "id": "1JwYn1PQ_C3K", + "outputId": "0d89a6be-203d-457f-afa2-c25a1c796572" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"normalized_df_holdout\",\n \"rows\": 3,\n \"fields\": [\n {\n \"column\": \"Country\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"Germany\",\n \"Haiti\",\n \"Iraq\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Amount_EconomicActivity_GrossDomesticProduction_Nominal_PerCapita\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2.317430967715527,\n \"min\": -0.5266803696465243,\n \"max\": 3.63095460639185,\n \"num_unique_values\": 3,\n \"samples\": [\n 3.63095460639185,\n -0.5266803696465243,\n -0.22184496296231038\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Amount_Emissions_CarbonDioxide_PerCapita\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.913276908425939,\n \"min\": -0.7622664675749948,\n \"max\": 1.0536724229189223,\n \"num_unique_values\": 3,\n \"samples\": [\n 1.0536724229189223,\n -0.7622664675749948,\n 0.3159927127880693\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Death_AsAFractionOfCount_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.7705686803209777,\n \"min\": -1.2812840883897223,\n \"max\": 2.2542333407231805,\n \"num_unique_values\": 3,\n \"samples\": [\n 2.2542333407231805,\n 0.3137675431334225,\n -1.2812840883897223\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person_IsInternetUser_PerCapita\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.146018879212192,\n \"min\": -1.0162394599580915,\n \"max\": 1.1629521086787276,\n \"num_unique_values\": 3,\n \"samples\": [\n 1.1629521086787276,\n -1.0162394599580915,\n 0.688515567905398\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person_Upto4Years_Overweight_AsFractionOf_Count_Person_Upto4Years\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.34339408896615464,\n \"min\": -0.851673788831684,\n \"max\": -0.18043754812392793,\n \"num_unique_values\": 3,\n \"samples\": [\n -0.851673788831684,\n -0.6419124636105101,\n -0.18043754812392793\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Product_MobileCellularSubscription_AsFractionOf_Count_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.9540515319486078,\n \"min\": -1.3327442269939864,\n \"max\": 0.5709750940138721,\n \"num_unique_values\": 3,\n \"samples\": [\n 0.5709750940138721,\n -1.3327442269939864,\n -0.2689357524879005\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"FertilityRate_Person_Female\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.7915629461647973,\n \"min\": -1.0380413112674278,\n \"max\": 0.5115970524132958,\n \"num_unique_values\": 3,\n \"samples\": [\n -1.0380413112674278,\n 0.017279919727621256,\n 0.5115970524132958\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"GiniIndex_EconomicActivity\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.7351748268644707,\n \"min\": -1.0924304213669975,\n \"max\": 0.32023583163038977,\n \"num_unique_values\": 3,\n \"samples\": [\n -0.7392638581176508,\n 0.32023583163038977,\n -1.0924304213669975\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"GrowthRate_Count_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.9280824363508461,\n \"min\": -1.1672274045016677,\n \"max\": 0.6717677253837453,\n \"num_unique_values\": 3,\n \"samples\": [\n -1.1672274045016677,\n -0.02959293258981379,\n 0.6717677253837453\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"LifeExpectancy_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.323722025125944,\n \"min\": -1.1476002456353467,\n \"max\": 1.4985981143618445,\n \"num_unique_values\": 3,\n \"samples\": [\n 1.4985981143618445,\n -1.1476002456353467,\n 0.10517341217020969\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe", + "variable_name": "normalized_df_holdout" + }, + "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", + "
variableAmount_EconomicActivity_GrossDomesticProduction_Nominal_PerCapitaAmount_Emissions_CarbonDioxide_PerCapitaCount_Death_AsAFractionOfCount_PersonCount_Person_IsInternetUser_PerCapitaCount_Person_Upto4Years_Overweight_AsFractionOf_Count_Person_Upto4YearsCount_Product_MobileCellularSubscription_AsFractionOf_Count_PersonFertilityRate_Person_FemaleGiniIndex_EconomicActivityGrowthRate_Count_PersonLifeExpectancy_Person
Country
Germany3.6309551.0536722.2542331.162952-0.8516740.570975-1.038041-0.739264-1.1672271.498598
Haiti-0.526680-0.7622660.313768-1.016239-0.641912-1.3327440.0172800.320236-0.029593-1.147600
Iraq-0.2218450.315993-1.2812840.688516-0.180438-0.2689360.511597-1.0924300.6717680.105173
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + "variable Amount_EconomicActivity_GrossDomesticProduction_Nominal_PerCapita \\\n", + "Country \n", + "Germany 3.630955 \n", + "Haiti -0.526680 \n", + "Iraq -0.221845 \n", + "\n", + "variable Amount_Emissions_CarbonDioxide_PerCapita \\\n", + "Country \n", + "Germany 1.053672 \n", + "Haiti -0.762266 \n", + "Iraq 0.315993 \n", + "\n", + "variable Count_Death_AsAFractionOfCount_Person \\\n", + "Country \n", + "Germany 2.254233 \n", + "Haiti 0.313768 \n", + "Iraq -1.281284 \n", + "\n", + "variable Count_Person_IsInternetUser_PerCapita \\\n", + "Country \n", + "Germany 1.162952 \n", + "Haiti -1.016239 \n", + "Iraq 0.688516 \n", + "\n", + "variable Count_Person_Upto4Years_Overweight_AsFractionOf_Count_Person_Upto4Years \\\n", + "Country \n", + "Germany -0.851674 \n", + "Haiti -0.641912 \n", + "Iraq -0.180438 \n", + "\n", + "variable Count_Product_MobileCellularSubscription_AsFractionOf_Count_Person \\\n", + "Country \n", + "Germany 0.570975 \n", + "Haiti -1.332744 \n", + "Iraq -0.268936 \n", + "\n", + "variable FertilityRate_Person_Female GiniIndex_EconomicActivity \\\n", + "Country \n", + "Germany -1.038041 -0.739264 \n", + "Haiti 0.017280 0.320236 \n", + "Iraq 0.511597 -1.092430 \n", + "\n", + "variable GrowthRate_Count_Person LifeExpectancy_Person \n", + "Country \n", + "Germany -1.167227 1.498598 \n", + "Haiti -0.029593 -1.147600 \n", + "Iraq 0.671768 0.105173 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "dcids_holdout = ['country/HTI','country/DEU', 'country/IRQ']\n", + "\n", + "# get values for each holdout\n", + "df_holdout = client.observations_dataframe(entity_dcids=dcids_holdout, variable_dcids=stat_vars_to_query, date='latest')\n", + "\n", + "# pivot the holdout data and name the axis Country\n", + "df_holdout = df_holdout.groupby([\"entity_name\", \"variable\"]).first().reset_index()\n", + "df_holdout = df_holdout[[\"entity_name\", \"variable\", \"value\"]]\n", + "df_holdout = df_holdout.pivot(index=[\"entity_name\"], columns=\"variable\", values=\"value\")\n", + "df_holdout.rename_axis(\"Country\", inplace=True)\n", + "\n", + "# ensure columns are in exactly the same order as those used previously for clustering\n", + "df_holdout = df_holdout[normalized_df.columns]\n", + "df_holdout = df_holdout.dropna()\n", + "\n", + "# normalize values for clustering\n", + "normalized_df_holdout = ((df_holdout-mean_df)/std_df)\n", + "display(normalized_df_holdout)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_13YpIqD7ctI" + }, + "source": [ + "Now, let's see where these countries would actually have clustered." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "s2pTEsnO2_ky", + "outputId": "4adb854a-a365-48fa-bceb-98c8ac7c24c6" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Germany belongs to cluster 2\n", + "Haiti belongs to cluster 1\n", + "Iraq belongs to cluster 0\n" + ] + } + ], + "source": [ + "# find which cluster centroid is closest\n", + "for country in df_holdout.index:\n", + " country_data = normalized_df_holdout.loc[country].to_numpy()\n", + " country_data = country_data[np.newaxis, :]\n", + " difference = normalized_means_df.to_numpy() - country_data\n", + " distance = np.linalg.norm(difference,axis=1)\n", + " cluster_membership = np.argmin(distance, axis=0)\n", + " print(f\"{country} belongs to cluster {cluster_membership}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eo2tsDP57xC0" + }, + "source": [ + "**Q4: Did these countries cluster in the way that you expected? If not, why not?**\n", + "\n", + "**Q5: Now run this section again for a larger value of K. Are you able to find a setting with more nuance? What traits do the clusters highlight?**" + ] + } + ], + "metadata": { + "colab": { + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/notebooks/intro_data_science/Regression_Basics_and_Prediction.ipynb b/notebooks/intro_data_science/Regression_Basics_and_Prediction.ipynb new file mode 100644 index 00000000..fdb5aa23 --- /dev/null +++ b/notebooks/intro_data_science/Regression_Basics_and_Prediction.ipynb @@ -0,0 +1,3979 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "view-in-github" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GOTE_b4GH96U" + }, + "source": [ + "Copyright 2025 Google LLC.\n", + "SPDX-License-Identifier: Apache-2.0" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hzDMRXIQ5kea" + }, + "source": [ + "\n", + "# Regression: Basics and Prediction\n", + "\n", + "[Regression analysis](https://en.wikipedia.org/wiki/Regression_analysis) is a powerful process for finding statistical relationships between variables. It's one of the most commonly used tools seen in the data science world, often used for prediction and forecasting.\n", + "\n", + "In this assignment, we'll be focusing on [linear regression](https://en.wikipedia.org/wiki/Linear_regression), which forms the basis for most regression models. In particular, we'll explore linear regression as a tool for _prediction_. We'll cover _interpreting_ regression models, in part 2.\n", + "\n", + "### Learning objectives:\n", + "* Linear regression for prediction\n", + "* Mean-qquared error\n", + "* In-sample vs out-of-sample prediction\n", + "* Single variate vs. multivariate regression\n", + "* The effect of increasing variables\n", + "\n", + "---\n", + "**Need extra help?**\n", + "\n", + "If you're new to Google Colab, take a look at [this getting started tutorial](https://colab.research.google.com/notebooks/intro.ipynb).\n", + "\n", + "To build more familiarity with the Data Commons API, check out these [Data Commons tutorials](https://docs.datacommons.org/api/python/v2/tutorials.html).\n", + "\n", + "And for help with Pandas and manipulating data frames, take a look at the [Pandas documentation](https://pandas.pydata.org/docs/reference/index.html).\n", + "\n", + "We'll be using the scikit-learn library for implementing our models today. Documentation can be found [here](https://scikit-learn.org/stable/modules/classes.html).\n", + "\n", + "As usual, if you have any other questions, please reach out to your course staff!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gnoowEYUIQS-" + }, + "source": [ + "## 0) Introduction and setup\n", + "\n", + "### Introduction\n", + "\n", + "In this assignment, we'll be returning to the scenario we started analyzing in the [model evaluation assignment](https://colab.research.google.com/github/datacommonsorg/api-python/blob/master/notebooks/v2/intro_data_science/Classification_and_Model_Evaluation.ipynb) -- analyzing the [obesity epidemic in the United States](https://en.wikipedia.org/wiki/Obesity_in_the_United_States). Obesity rates vary across the nation by geographic location. In this Colab, we'll be exploring how obesity rates vary with different health or societal factors across US cities.\n", + "\n", + "In the model evaluation assignment, we limited our analysis to high (<30%) and low (>30%) categories. Today we'll go one step further and predict the obesity rates themselves.\n", + "\n", + "Our data science question: **Can we predict the obesity rates of various US cities based on other health or lifestyle factors?**\n", + "\n", + "### Load the libraries and data\n", + "\n", + "Run the following code boxes to load the Python libraries and data we'll be using today." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "YkuB0EIS59qX" + }, + "outputs": [], + "source": [ + "# Setup/imports\n", + "!pip install \"datacommons-client[Pandas]\" --upgrade --quiet" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "u2oFQ7-v8sxY" + }, + "outputs": [], + "source": [ + "# Import the Data Commons library\n", + "import datacommons_client\n", + "YOUR_API_KEY = \"Replace this string with your API key\"\n", + "dc_client = datacommons_client.DataCommonsClient(api_key=YOUR_API_KEY)\n", + "\n", + "# Import other libraries\n", + "\n", + "# For manipulating data\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "# For implementing models and evaluation methods\n", + "from sklearn import linear_model\n", + "from sklearn.metrics import r2_score, mean_squared_error\n", + "\n", + "# For plotting/printing\n", + "from matplotlib import pyplot as plt\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OjBcDnD4gnY_" + }, + "source": [ + "Run the following code box to load the data. We've done some basic data cleaning and manipulation for you, but look through the code to make sure you understand what's going on." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 309 + }, + "id": "VuA3xgSQXhK6", + "outputId": "5e2c94ec-c0dc-4746-b2df-f6fcc7d50925" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"df\",\n \"rows\": 58,\n \"fields\": [\n {\n \"column\": \"Count_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1456810.3562811632,\n \"min\": 1296.7142857142858,\n \"max\": 9949647.375,\n \"num_unique_values\": 58,\n \"samples\": [\n 1665662.375,\n 21797.714285714286,\n 64909.857142857145\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_Obesity\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 4.162926936370126,\n \"min\": 17.225,\n \"max\": 37.475,\n \"num_unique_values\": 56,\n \"samples\": [\n 21.4,\n 31.375,\n 28.675\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_PhysicalInactivity\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 3.7666018118476385,\n \"min\": 14.375,\n \"max\": 31.4,\n \"num_unique_values\": 53,\n \"samples\": [\n 14.375,\n 19.5,\n 26.825\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_SleepLessThan7Hours\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2.2201207657374313,\n \"min\": 28.625,\n \"max\": 38.225,\n \"num_unique_values\": 50,\n \"samples\": [\n 36.45,\n 31.35,\n 38.225\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithHighBloodPressure\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2.349714235241347,\n \"min\": 24.65,\n \"max\": 35.025,\n \"num_unique_values\": 55,\n \"samples\": [\n 32.125,\n 30.05,\n 29.025\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithHighCholesterol\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.467178731486741,\n \"min\": 28.675,\n \"max\": 35.15,\n \"num_unique_values\": 53,\n \"samples\": [\n 31.0,\n 34.525,\n 33.45\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithMentalHealthNotGood\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.5978652032646534,\n \"min\": 11.5,\n \"max\": 18.0,\n \"num_unique_values\": 50,\n \"samples\": [\n 14.775,\n 16.425,\n 15.674999999999999\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe", + "variable_name": "df" + }, + "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", + "
variableCount_PersonPercent_Person_ObesityPercent_Person_PhysicalInactivityPercent_Person_SleepLessThan7HoursPercent_Person_WithHighBloodPressurePercent_Person_WithHighCholesterolPercent_Person_WithMentalHealthNotGood
entityentity_name
geoId/06001Alameda County1.665662e+0621.40018.77534.10026.07529.40012.550
geoId/06003Alpine County1.296714e+0329.52520.55033.82531.47532.92515.850
geoId/06005Amador County4.052386e+0428.20020.32533.00031.55033.15014.750
geoId/06007Butte County2.140051e+0531.55022.30033.95029.65031.75016.625
geoId/06009Calaveras County4.581786e+0428.00020.70032.77531.92533.97515.500
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + "variable Count_Person Percent_Person_Obesity \\\n", + "entity entity_name \n", + "geoId/06001 Alameda County 1.665662e+06 21.400 \n", + "geoId/06003 Alpine County 1.296714e+03 29.525 \n", + "geoId/06005 Amador County 4.052386e+04 28.200 \n", + "geoId/06007 Butte County 2.140051e+05 31.550 \n", + "geoId/06009 Calaveras County 4.581786e+04 28.000 \n", + "\n", + "variable Percent_Person_PhysicalInactivity \\\n", + "entity entity_name \n", + "geoId/06001 Alameda County 18.775 \n", + "geoId/06003 Alpine County 20.550 \n", + "geoId/06005 Amador County 20.325 \n", + "geoId/06007 Butte County 22.300 \n", + "geoId/06009 Calaveras County 20.700 \n", + "\n", + "variable Percent_Person_SleepLessThan7Hours \\\n", + "entity entity_name \n", + "geoId/06001 Alameda County 34.100 \n", + "geoId/06003 Alpine County 33.825 \n", + "geoId/06005 Amador County 33.000 \n", + "geoId/06007 Butte County 33.950 \n", + "geoId/06009 Calaveras County 32.775 \n", + "\n", + "variable Percent_Person_WithHighBloodPressure \\\n", + "entity entity_name \n", + "geoId/06001 Alameda County 26.075 \n", + "geoId/06003 Alpine County 31.475 \n", + "geoId/06005 Amador County 31.550 \n", + "geoId/06007 Butte County 29.650 \n", + "geoId/06009 Calaveras County 31.925 \n", + "\n", + "variable Percent_Person_WithHighCholesterol \\\n", + "entity entity_name \n", + "geoId/06001 Alameda County 29.400 \n", + "geoId/06003 Alpine County 32.925 \n", + "geoId/06005 Amador County 33.150 \n", + "geoId/06007 Butte County 31.750 \n", + "geoId/06009 Calaveras County 33.975 \n", + "\n", + "variable Percent_Person_WithMentalHealthNotGood \n", + "entity entity_name \n", + "geoId/06001 Alameda County 12.550 \n", + "geoId/06003 Alpine County 15.850 \n", + "geoId/06005 Amador County 14.750 \n", + "geoId/06007 Butte County 16.625 \n", + "geoId/06009 Calaveras County 15.500 " + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Load the data we'll be using\n", + "stat_vars_to_query = [\n", + " \"Count_Person\",\n", + " \"Percent_Person_PhysicalInactivity\",\n", + " \"Percent_Person_SleepLessThan7Hours\",\n", + " \"Percent_Person_WithHighBloodPressure\",\n", + " \"Percent_Person_WithMentalHealthNotGood\",\n", + " \"Percent_Person_WithHighCholesterol\",\n", + " \"Percent_Person_Obesity\"\n", + "]\n", + "\n", + "# Query Data Commons for the data and remove any NaN values\n", + "dcid_of_california = \"geoId/06\"\n", + "raw_features_df = dc_client.observations_dataframe(variable_dcids=stat_vars_to_query, date=\"latest\", parent_entity=dcid_of_california, entity_type=\"County\")\n", + "df = raw_features_df.pivot_table(index=['entity', 'entity_name'], columns='variable', values='value')\n", + "df.dropna(inplace=True)\n", + "\n", + "# Order columns alphabetically\n", + "df = df.reindex(sorted(df.columns), axis=1)\n", + "\n", + "# Display results\n", + "df.head(5)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "itTEvuAljfdl" + }, + "source": [ + "**0A)** Look through the dataframe and make sure you understand what each variable is describing.\n", + "\n", + "**0B)** What are the units for each variable?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "N5L1nY525qCj" + }, + "source": [ + "## 1) Single linear regression\n", + "\n", + "To help us build some intuition for how regression works, we'll start by using a single variable. We'll create two models, Model A and Model B. Model A will use `Count_Person` variable to predict obesity rates, while Model B will use the `Percent_Person_PhysicalInactivity` variable.\n", + "\n", + "Model | Independent Variable | Dependent Variable\n", + "--- | --- | ---\n", + "Model A | `Count_Person` | `Percent_Person_Obesity`\n", + "Model B | `Percent_Person_PhysicalInactivity` | `Percent_Person_Obesity`\n", + "\n", + "**1A)** Just using your intuition, which model do you think will be better at predicting obesity rates? Why?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rfsRHnPNPXjQ" + }, + "source": [ + "### 1.1) Fit a model\n", + "Let's now check your intuition by fitting linear regression models to our data.\n", + "\n", + "Run the following code box to fit Model A and Model B." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "h4m5ovk76JHl", + "outputId": "c1c4d244-f965-431b-a1a3-3e6aec0934e2" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model A:\n", + "---------\n", + "Weights: [[-5.5338791e-07]]\n", + "Intercept: [29.43390488]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model B:\n", + "---------\n", + "Weights: [[0.96832964]]\n", + "Intercept: [7.31082796]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "var1 = \"Count_Person\"\n", + "var2 = \"Percent_Person_PhysicalInactivity\"\n", + "dep_var = \"Percent_Person_Obesity\"\n", + "\n", + "df_single_vars = df[[var1, var2, dep_var]].copy()\n", + "x_a = df_single_vars[var1].to_numpy().reshape(-1, 1)\n", + "x_b = df_single_vars[var2].to_numpy().reshape(-1,1)\n", + "y = df_single_vars[dep_var].to_numpy().reshape(-1, 1)\n", + "\n", + "# Fit models\n", + "model_a = linear_model.LinearRegression().fit(x_a,y)\n", + "model_b = linear_model.LinearRegression().fit(x_b,y)\n", + "\n", + "# Make Predictions\n", + "predictions_a = model_a.predict(x_a)\n", + "predictions_b = model_b.predict(x_b)\n", + "df_single_vars[\"Prediction_A\"] = predictions_a\n", + "df_single_vars[\"Prediction_B\"] = predictions_b\n", + "\n", + "# Plot Model A\n", + "print(\"Model A:\")\n", + "print(\"---------\")\n", + "print(\"Weights:\", model_a.coef_)\n", + "print(\"Intercept:\", model_a.intercept_)\n", + "fig, ax = plt.subplots()\n", + "p1 = sns.scatterplot(data=df_single_vars, x=var1, y=dep_var, ax=ax, color=\"orange\")\n", + "p2 = sns.lineplot(data=df_single_vars, x=var1, y=\"Prediction_A\", ax=ax, color=\"blue\")\n", + "plt.show()\n", + "\n", + "# Plot Model B\n", + "print(\"Model B:\")\n", + "print(\"---------\")\n", + "print(\"Weights:\", model_b.coef_)\n", + "print(\"Intercept:\", model_b.intercept_)\n", + "fig, ax = plt.subplots()\n", + "p1 = sns.scatterplot(data=df_single_vars, x=var2, y=dep_var, ax=ax, color=\"orange\")\n", + "p2 = sns.lineplot(data=df_single_vars, x=var2, y=\"Prediction_B\", ax=ax, color=\"blue\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "g9wIlkKcVDAW" + }, + "source": [ + "**1.1B**) For each model, what are the units of the weights? Intercepts?\n", + "\n", + "**1.1C**) Mathematically, what does the weight represent?\n", + "\n", + "**1.1D**) Mathematically, what does the intercept represent?\n", + "\n", + "**1.1E**) Looking visually at the plots of the regression models, which model do you think will be better at predicting obesity rates for new, unseen data points (cities)? Why?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TSq5skVv3cnx" + }, + "source": [ + "### 1.2) Prediction error: MSE and RMSE\n", + "\n", + "To quantify predictive accuracy, we find the prediction error, a metric of how far off our model predictions are from the true value. One of the most common metrics used is [mean squared error](https://en.wikipedia.org/wiki/Mean_squared_error):\n", + "\n", + "\n", + "$$ MSE = \\frac{1}{\\text{# total data points}}\\sum_{\\text{all data points}}(\\text{predicted value} - \\text{actual value})^2$$\n", + "\n", + "MSE is a measure of the average difference between the predicted value and the actual value. The square ($^2$) can seem counterintuitive at first, but offers some nice mathematical properties.\n", + "\n", + "There's also [root mean squared error](https://en.wikipedia.org/wiki/Root-mean-square_deviation), the square root of the MSE, which scales the error metric to match the scale of the data points:\n", + "\n", + "$$ RMSE = \\sqrt{MSE} = \\sqrt{\\frac{1}{\\text{# total data points}}\\sum_{\\text{all data points}}(\\text{predicted value} - \\text{actual value})^2}$$\n", + "\n", + "\n", + "Prediction error can actually refer to one of two things: _in-sample prediction error_ or _out-of-sample prediction error_. We'll explore both in the sections below.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "s8-W4Ghuks7H" + }, + "source": [ + "#### 1.2.1) In-sample prediction\n", + "\n", + "In-sample prediction refers to forecasting or predicting for a data point that was used to fit the model. This is akin to applying your model to the training set, in machine learning parlance. In-sample prediction error measures how well our model is able to reproduce the data we currently have.\n", + "\n", + "Run the following code block to calculate the in-sample prediction RMSE for both models." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "jcKllCVTrxAo", + "outputId": "8f66071c-d5ff-4b05-f6cf-f3629540ea76" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model A RMSE: 16.392445721682485\n", + "Model B RMSE: 3.957642295731405\n" + ] + } + ], + "source": [ + "print(\"Model A RMSE:\", mean_squared_error(y, predictions_a))\n", + "print(\"Model B RMSE:\", mean_squared_error(y, predictions_b))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9XmMfD0uA7jh" + }, + "source": [ + "**1F)** What are the units of the RMSE for each model?\n", + "\n", + "**1G)** Which model had better RMSE?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vdLmnscqaoNs" + }, + "source": [ + "#### 1.2.2) Out-of-sample prediction\n", + "In contrast to in-sample prediction, we can also perform _out-of-sample_ prediction, by using our model to make predictions on new, previously unseen data. This is akin to applying our model on a test set, in machine learning parlance. Out-of-sample prediction error measures how well our model can generalize to new data.\n", + "\n", + "**1H)** In general, would you expect in-sample prediction error or out-of-sample prediction error to be higher?\n", + "\n", + "Let's see how well our models perform on some US cities.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "zgN1iQ4G6CVK", + "outputId": "a8076af6-e91b-411d-f52c-9b6b09c80e7d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model A:\n", + "--------\n" + ] + }, + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"print(\\\"\\\")\",\n \"rows\": 5,\n \"fields\": [\n {\n \"column\": \"Model A Prediction\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.2344679203547182,\n \"min\": 26.5601970930957,\n \"max\": 29.43377659115775,\n \"num_unique_values\": 5,\n \"samples\": [\n 29.4074124664549,\n 29.387185664015124,\n 26.5601970930957\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_Obesity\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 4.467955348926399,\n \"min\": 31.424999999999997,\n \"max\": 41.075,\n \"num_unique_values\": 5,\n \"samples\": [\n 40.0,\n 41.075,\n 31.424999999999997\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe" + }, + "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", + "
variableModel A PredictionPercent_Person_Obesity
entityentity_name
geoId/12057Hillsborough County28.61173431.925
geoId/12063Jackson County29.40741240.000
geoId/17031Cook County26.56019731.425
geoId/48269King County29.43377736.975
geoId/48361Orange County29.38718641.075
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + "variable Model A Prediction Percent_Person_Obesity\n", + "entity entity_name \n", + "geoId/12057 Hillsborough County 28.611734 31.925\n", + "geoId/12063 Jackson County 29.407412 40.000\n", + "geoId/17031 Cook County 26.560197 31.425\n", + "geoId/48269 King County 29.433777 36.975\n", + "geoId/48361 Orange County 29.387186 41.075" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RMSE: 68.0644006512601\n", + "\n", + "Model B:\n", + "--------\n" + ] + }, + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"print(\\\"\\\")\",\n \"rows\": 5,\n \"fields\": [\n {\n \"column\": \"Model B Prediction\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 3.8614762363530413,\n \"min\": 29.388743708198877,\n \"max\": 39.02362360739547,\n \"num_unique_values\": 5,\n \"samples\": [\n 39.02362360739547,\n 35.077680332096364,\n 29.388743708198877\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_Obesity\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 4.467955348926399,\n \"min\": 31.424999999999997,\n \"max\": 41.075,\n \"num_unique_values\": 5,\n \"samples\": [\n 40.0,\n 41.075,\n 31.424999999999997\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe" + }, + "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", + "
variableModel B PredictionPercent_Person_Obesity
entityentity_name
geoId/12057Hillsborough County31.78536031.925
geoId/12063Jackson County39.02362440.000
geoId/17031Cook County29.38874431.425
geoId/48269King County36.82067436.975
geoId/48361Orange County35.07768041.075
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + "variable Model B Prediction Percent_Person_Obesity\n", + "entity entity_name \n", + "geoId/12057 Hillsborough County 31.785360 31.925\n", + "geoId/12063 Jackson County 39.023624 40.000\n", + "geoId/17031 Cook County 29.388744 31.425\n", + "geoId/48269 King County 36.820674 36.975\n", + "geoId/48361 Orange County 35.077680 41.075" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RMSE: 8.22216196191367\n", + "\n" + ] + } + ], + "source": [ + "# Make a prediction\n", + "new_dcids = [\n", + " \"geoId/48361\", # Orange, Texas\n", + " \"geoId/48269\", # King County, Texas\n", + " \"geoId/17031\", # Cook County, Illinois\n", + " \"geoId/12063\", # Jackson County, Florida\n", + " \"geoId/12057\", # Hillsborough County, Florida\n", + "]\n", + "\n", + "new_df = dc_client.observations_dataframe(variable_dcids=stat_vars_to_query, entity_dcids=new_dcids, date=\"latest\")\n", + "new_df = new_df.pivot_table(index=['entity', 'entity_name'], columns='variable', values='value')\n", + "\n", + "x_a_new = new_df[var1].to_numpy().reshape(-1,1)\n", + "x_b_new = new_df[var2].to_numpy().reshape(-1,1)\n", + "y_new = new_df[dep_var].to_numpy().reshape(-1, 1)\n", + "\n", + "predicted_a_new = model_a.predict(x_a_new)\n", + "predicted_b_new = model_b.predict(x_b_new)\n", + "new_df[\"Model A Prediction\"] = predicted_a_new\n", + "new_df[\"Model B Prediction\"] = predicted_b_new\n", + "\n", + "print(\"Model A:\")\n", + "print(\"--------\")\n", + "display(new_df[[\"Model A Prediction\", dep_var]])\n", + "fig, ax = plt.subplots()\n", + "p0 = sns.scatterplot(data=df_single_vars, x=var1, y=dep_var, ax=ax, color=\"orange\")\n", + "p1 = sns.scatterplot(data=new_df, x=var1, y=dep_var, ax=ax, color=\"red\")\n", + "p2 = sns.lineplot(data=df_single_vars, x=var1, y=\"Prediction_A\", ax=ax, color=\"blue\")\n", + "plt.show()\n", + "print(\"RMSE:\", mean_squared_error(y_new, predicted_a_new))\n", + "print(\"\")\n", + "\n", + "print(\"Model B:\")\n", + "print(\"--------\")\n", + "display(new_df[[\"Model B Prediction\", dep_var]])\n", + "fig, ax = plt.subplots()\n", + "p0 = sns.scatterplot(data=df_single_vars, x=var2, y=dep_var, ax=ax, color=\"orange\")\n", + "p1 = sns.scatterplot(data=new_df, x=var2, y=dep_var, ax=ax, color=\"red\")\n", + "p2 = sns.lineplot(data=df_single_vars, x=var2, y=\"Prediction_B\", ax=ax, color=\"blue\")\n", + "plt.show()\n", + "print(\"RMSE:\", mean_squared_error(y_new, predicted_b_new))\n", + "print(\"\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UnArHe8Y2gZt" + }, + "source": [ + "**1I)** How well did these model predict the obesity rates? Which model had better accuracy?\n", + "\n", + "**1J)** For the model you selected in the question above, how much would you trust this model? What are its limitations?\n", + "\n", + "**1K)** Can you think of any ways to create an even better model?\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fF64l1126Oo3" + }, + "source": [ + "## 2) Multiple linear regression\n", + "\n", + "Let's now see what happens if we increase the number of independent variables used to make our prediction. Using multiple independent variables is referred to as _multiple linear regression_.\n", + "\n", + "Now let's use all the data we loaded at the beginning of the assignment. The following code box will display our dataframe in its entirety again, so you can refamiliarize yourself with the data we have available." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 309 + }, + "id": "jYOfmvQoKfyQ", + "outputId": "0a5cdb2d-d1f4-4fb7-b3b0-924219dc1370" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"df\",\n \"rows\": 58,\n \"fields\": [\n {\n \"column\": \"Count_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1456810.3562811632,\n \"min\": 1296.7142857142858,\n \"max\": 9949647.375,\n \"num_unique_values\": 58,\n \"samples\": [\n 1665662.375,\n 21797.714285714286,\n 64909.857142857145\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_Obesity\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 4.162926936370126,\n \"min\": 17.225,\n \"max\": 37.475,\n \"num_unique_values\": 56,\n \"samples\": [\n 21.4,\n 31.375,\n 28.675\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_PhysicalInactivity\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 3.7666018118476385,\n \"min\": 14.375,\n \"max\": 31.4,\n \"num_unique_values\": 53,\n \"samples\": [\n 14.375,\n 19.5,\n 26.825\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_SleepLessThan7Hours\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2.2201207657374313,\n \"min\": 28.625,\n \"max\": 38.225,\n \"num_unique_values\": 50,\n \"samples\": [\n 36.45,\n 31.35,\n 38.225\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithHighBloodPressure\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2.349714235241347,\n \"min\": 24.65,\n \"max\": 35.025,\n \"num_unique_values\": 55,\n \"samples\": [\n 32.125,\n 30.05,\n 29.025\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithHighCholesterol\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.467178731486741,\n \"min\": 28.675,\n \"max\": 35.15,\n \"num_unique_values\": 53,\n \"samples\": [\n 31.0,\n 34.525,\n 33.45\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithMentalHealthNotGood\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.5978652032646534,\n \"min\": 11.5,\n \"max\": 18.0,\n \"num_unique_values\": 50,\n \"samples\": [\n 14.775,\n 16.425,\n 15.674999999999999\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe", + "variable_name": "df" + }, + "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", + "
variableCount_PersonPercent_Person_ObesityPercent_Person_PhysicalInactivityPercent_Person_SleepLessThan7HoursPercent_Person_WithHighBloodPressurePercent_Person_WithHighCholesterolPercent_Person_WithMentalHealthNotGood
entityentity_name
geoId/06001Alameda County1.665662e+0621.40018.77534.10026.07529.40012.550
geoId/06003Alpine County1.296714e+0329.52520.55033.82531.47532.92515.850
geoId/06005Amador County4.052386e+0428.20020.32533.00031.55033.15014.750
geoId/06007Butte County2.140051e+0531.55022.30033.95029.65031.75016.625
geoId/06009Calaveras County4.581786e+0428.00020.70032.77531.92533.97515.500
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + "variable Count_Person Percent_Person_Obesity \\\n", + "entity entity_name \n", + "geoId/06001 Alameda County 1.665662e+06 21.400 \n", + "geoId/06003 Alpine County 1.296714e+03 29.525 \n", + "geoId/06005 Amador County 4.052386e+04 28.200 \n", + "geoId/06007 Butte County 2.140051e+05 31.550 \n", + "geoId/06009 Calaveras County 4.581786e+04 28.000 \n", + "\n", + "variable Percent_Person_PhysicalInactivity \\\n", + "entity entity_name \n", + "geoId/06001 Alameda County 18.775 \n", + "geoId/06003 Alpine County 20.550 \n", + "geoId/06005 Amador County 20.325 \n", + "geoId/06007 Butte County 22.300 \n", + "geoId/06009 Calaveras County 20.700 \n", + "\n", + "variable Percent_Person_SleepLessThan7Hours \\\n", + "entity entity_name \n", + "geoId/06001 Alameda County 34.100 \n", + "geoId/06003 Alpine County 33.825 \n", + "geoId/06005 Amador County 33.000 \n", + "geoId/06007 Butte County 33.950 \n", + "geoId/06009 Calaveras County 32.775 \n", + "\n", + "variable Percent_Person_WithHighBloodPressure \\\n", + "entity entity_name \n", + "geoId/06001 Alameda County 26.075 \n", + "geoId/06003 Alpine County 31.475 \n", + "geoId/06005 Amador County 31.550 \n", + "geoId/06007 Butte County 29.650 \n", + "geoId/06009 Calaveras County 31.925 \n", + "\n", + "variable Percent_Person_WithHighCholesterol \\\n", + "entity entity_name \n", + "geoId/06001 Alameda County 29.400 \n", + "geoId/06003 Alpine County 32.925 \n", + "geoId/06005 Amador County 33.150 \n", + "geoId/06007 Butte County 31.750 \n", + "geoId/06009 Calaveras County 33.975 \n", + "\n", + "variable Percent_Person_WithMentalHealthNotGood \n", + "entity entity_name \n", + "geoId/06001 Alameda County 12.550 \n", + "geoId/06003 Alpine County 15.850 \n", + "geoId/06005 Amador County 14.750 \n", + "geoId/06007 Butte County 16.625 \n", + "geoId/06009 Calaveras County 15.500 " + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.head(5)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CqgRWWv9wEJN" + }, + "source": [ + "### 2.1) Fit a model\n", + "\n", + "Now let's fit a linear regression model using all of the features in our dataframe." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "huqaDyKEK39D", + "outputId": "ea242386-7747-4e06-bd36-cb824981b44a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Features in Order:\n", + "\n", + "\t Index(['Count_Person', 'Percent_Person_PhysicalInactivity',\n", + " 'Percent_Person_SleepLessThan7Hours',\n", + " 'Percent_Person_WithHighBloodPressure',\n", + " 'Percent_Person_WithHighCholesterol',\n", + " 'Percent_Person_WithMentalHealthNotGood'],\n", + " dtype='object', name='variable')\n", + "\n", + "Weights:\n", + "\n", + "\t [[-2.19445858e-08 5.92398556e-01 8.58111992e-02 6.36513779e-01\n", + " -6.55756125e-01 6.39071221e-01]]\n", + "\n", + "Intercept:\n", + "\n", + "\t [5.219999]\n" + ] + } + ], + "source": [ + "# Fit a regression model\n", + "dep_var = \"Percent_Person_Obesity\"\n", + "\n", + "y = df[dep_var].to_numpy().reshape(-1, 1)\n", + "x = df.loc[:, ~df.columns.isin([dep_var])]\n", + "\n", + "model = linear_model.LinearRegression().fit(x,y)\n", + "predictions = model.predict(x)\n", + "df[\"Predicted\"] = predictions\n", + "\n", + "print(\"Features in Order:\\n\\n\\t\", x.columns)\n", + "print(\"\\nWeights:\\n\\n\\t\", model.coef_)\n", + "print(\"\\nIntercept:\\n\\n\\t\", model.intercept_)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mojSn3Ru-P6z" + }, + "source": [ + "**2A)** Look at the coefficients for each of the features. Which features contribute most to the prediction?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fpOfdZGF8imR" + }, + "source": [ + "### 2.2) Prediction error\n", + "Let's now analyze the in-sample and out-of-sample prediction errors for our multiple linear regression model." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NoFGyDVY4G9O", + "outputId": "6a041813-5d4e-4968-9f84-389e877e1c2d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "In-sample Prediction RMSE: 2.2871127732728005\n" + ] + } + ], + "source": [ + "# Analyze in-sample MSE\n", + "print(\"In-sample Prediction RMSE:\", mean_squared_error(y, predictions))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "C1_FK9S58vSb" + }, + "source": [ + "**2B)** How does the in-sample prediction RMSE compare with that of the single variable models A and B?\n", + "\n", + "We'll also take a look at out-of-sample prediction error." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 237 + }, + "id": "oUB2MyONLAJp", + "outputId": "cdfe6b4c-16bf-44e9-8627-a55fec5dd58c" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"display(new_df[[\\\"Prediction\\\", dep_var]])\",\n \"rows\": 5,\n \"fields\": [\n {\n \"column\": \"Prediction\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 5.008113713219048,\n \"min\": 30.410179762235938,\n \"max\": 43.7495528396845,\n \"num_unique_values\": 5,\n \"samples\": [\n 43.7495528396845,\n 35.57469734748693,\n 30.410179762235938\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_Obesity\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 4.467955348926399,\n \"min\": 31.424999999999997,\n \"max\": 41.075,\n \"num_unique_values\": 5,\n \"samples\": [\n 40.0,\n 41.075,\n 31.424999999999997\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe" + }, + "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", + "
variablePredictionPercent_Person_Obesity
entityentity_name
geoId/12057Hillsborough County33.22867331.925
geoId/12063Jackson County43.74955340.000
geoId/17031Cook County30.41018031.425
geoId/48269King County37.07812736.975
geoId/48361Orange County35.57469741.075
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + "variable Prediction Percent_Person_Obesity\n", + "entity entity_name \n", + "geoId/12057 Hillsborough County 33.228673 31.925\n", + "geoId/12063 Jackson County 43.749553 40.000\n", + "geoId/17031 Cook County 30.410180 31.425\n", + "geoId/48269 King County 37.078127 36.975\n", + "geoId/48361 Orange County 35.574697 41.075" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Apply model to some out-of-sample data points\n", + "new_dcids = [\n", + " \"geoId/48361\", # Orange, Texas\n", + " \"geoId/48269\", # King County, Texas\n", + " \"geoId/17031\", # Cook County, Illinois\n", + " \"geoId/12063\", # Jackson County, Florida\n", + " \"geoId/12057\", # Hillsborough County, Florida\n", + "]\n", + "\n", + "new_df = dc_client.observations_dataframe(variable_dcids=stat_vars_to_query, entity_dcids=new_dcids, date=\"latest\")\n", + "new_df = new_df.pivot_table(index=['entity', 'entity_name'], columns='variable', values='value')\n", + "\n", + "new_y = new_df[dep_var].to_numpy().reshape(-1, 1)\n", + "new_x = new_df.loc[:, ~new_df.columns.isin([dep_var])]\n", + "\n", + "predicted = model.predict(new_x)\n", + "new_df[\"Prediction\"] = predicted\n", + "display(new_df[[\"Prediction\", dep_var]])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "XgJJC7vyEh5r", + "outputId": "a61a68f5-152e-4f8a-fcc1-cd6abff56039" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Out-of-sample RMSE: 9.41050687483534\n" + ] + } + ], + "source": [ + "print(\"Out-of-sample RMSE:\", mean_squared_error(new_y, predicted))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mtPbEzqvAWSe" + }, + "source": [ + "**2C)** How does the out-of-sample RMSE compare with that of the single variable models A and B?\n", + "\n", + "**2D)** In general, how would you expect adding more variables to affect the resulting prediction error: increase, decrease, or no substantial change?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jzo439GEiP1P" + }, + "source": [ + "### 2.3) Variables: The more, the merrier?\n", + "\n", + "As we've seen in the sections above, adding more variables to our regression model tends to increase model accuracy. But is adding more and more variables always a good thing?\n", + "\n", + "Let's explore what happens when we add even more variables. We've compiled a new list of statistical variables to predict obesity rates with. Run the code boxes below to load some more data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 309 + }, + "id": "yEVHjMAYiUsY", + "outputId": "d0211099-1773-42b3-aa71-f1018fb7c3ad" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"large_df\",\n \"rows\": 58,\n \"fields\": [\n {\n \"column\": \"Count_Household\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 492056.31637068733,\n \"min\": 463.5,\n \"max\": 3372450.6,\n \"num_unique_values\": 58,\n \"samples\": [\n 590160.2,\n 7457.5,\n 20104.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_HousingUnit\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 526113.2835297179,\n \"min\": 1581.3333333333333,\n \"max\": 3605208.6666666665,\n \"num_unique_values\": 58,\n \"samples\": [\n 625180.0,\n 8121.0,\n 20595.666666666668\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1456810.3562811632,\n \"min\": 1296.7142857142858,\n \"max\": 9949647.375,\n \"num_unique_values\": 58,\n \"samples\": [\n 1665662.375,\n 21797.714285714286,\n 64909.857142857145\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person_1OrMoreYears_DifferentHouse1YearAgo\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 143983.4542521967,\n \"min\": 228.0,\n \"max\": 916157.0,\n \"num_unique_values\": 58,\n \"samples\": [\n 202142.0,\n 1293.0,\n 6516.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person_BelowPovertyLevelInThePast12Months\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 184772.74779004575,\n \"min\": 209.0,\n \"max\": 1322476.0,\n \"num_unique_values\": 58,\n \"samples\": [\n 149752.0,\n 2332.0,\n 5118.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person_EducationalAttainmentRegularHighSchoolDiploma\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 182795.23612951263,\n \"min\": 186.0,\n \"max\": 1261045.0,\n \"num_unique_values\": 58,\n \"samples\": [\n 169001.0,\n 3758.0,\n 9730.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person_Employed\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 703327.5627291262,\n \"min\": 470.5,\n \"max\": 4790075.5,\n \"num_unique_values\": 58,\n \"samples\": [\n 832939.0,\n 9797.0,\n 32381.5\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"GenderIncomeInequality_Person_15OrMoreYears_WithIncome\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.0575139440334322,\n \"min\": 0.01742014,\n \"max\": 0.40503931,\n \"num_unique_values\": 58,\n \"samples\": [\n 0.17523127,\n 0.26723913,\n 0.25735199\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Median_Age_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 6.118901027820581,\n \"min\": 31.55,\n \"max\": 54.349999999999994,\n \"num_unique_values\": 55,\n \"samples\": [\n 51.95,\n 35.650000000000006,\n 36.35\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Median_Income_Household\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 25546.764494177973,\n \"min\": 53498.0,\n \"max\": 159674.0,\n \"num_unique_values\": 58,\n \"samples\": [\n 126240.0,\n 75149.0,\n 108289.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Median_Income_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 8966.589708185242,\n \"min\": 22461.5,\n \"max\": 64138.5,\n \"num_unique_values\": 58,\n \"samples\": [\n 53077.5,\n 33142.0,\n 41092.5\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_Obesity\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 4.162926936370126,\n \"min\": 17.225,\n \"max\": 37.475,\n \"num_unique_values\": 56,\n \"samples\": [\n 21.4,\n 31.375,\n 28.675\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_PhysicalInactivity\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 3.7666018118476385,\n \"min\": 14.375,\n \"max\": 31.4,\n \"num_unique_values\": 53,\n \"samples\": [\n 14.375,\n 19.5,\n 26.825\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_SleepLessThan7Hours\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2.2201207657374313,\n \"min\": 28.625,\n \"max\": 38.225,\n \"num_unique_values\": 50,\n \"samples\": [\n 36.45,\n 31.35,\n 38.225\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithHighBloodPressure\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2.349714235241347,\n \"min\": 24.65,\n \"max\": 35.025,\n \"num_unique_values\": 55,\n \"samples\": [\n 32.125,\n 30.05,\n 29.025\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithHighCholesterol\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.467178731486741,\n \"min\": 28.675,\n \"max\": 35.15,\n \"num_unique_values\": 53,\n \"samples\": [\n 31.0,\n 34.525,\n 33.45\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithMentalHealthNotGood\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.5978652032646534,\n \"min\": 11.5,\n \"max\": 18.0,\n \"num_unique_values\": 50,\n \"samples\": [\n 14.775,\n 16.425,\n 15.674999999999999\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"UnemploymentRate_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2.2325240894350755,\n \"min\": 3.3666666666666667,\n \"max\": 16.0,\n \"num_unique_values\": 53,\n \"samples\": [\n 9.033333333333333,\n 5.833333333333333,\n 6.7\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe", + "variable_name": "large_df" + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
variableCount_HouseholdCount_HousingUnitCount_PersonCount_Person_1OrMoreYears_DifferentHouse1YearAgoCount_Person_BelowPovertyLevelInThePast12MonthsCount_Person_EducationalAttainmentRegularHighSchoolDiplomaCount_Person_EmployedGenderIncomeInequality_Person_15OrMoreYears_WithIncomeMedian_Age_PersonMedian_Income_HouseholdMedian_Income_PersonPercent_Person_ObesityPercent_Person_PhysicalInactivityPercent_Person_SleepLessThan7HoursPercent_Person_WithHighBloodPressurePercent_Person_WithHighCholesterolPercent_Person_WithMentalHealthNotGoodUnemploymentRate_Person
entityentity_name
geoId/06001Alameda County590160.20625180.0000001.665662e+06202142.0149752.0169001.0832939.00.17523138.35126240.053077.521.40018.77534.10026.07529.40012.5504.566667
geoId/06003Alpine County463.501581.3333331.296714e+03228.0209.0186.0470.50.01742044.65110781.034263.529.52520.55033.82531.47532.92515.8506.300000
geoId/06005Amador County15985.7518845.6666674.052386e+045017.02931.06911.014300.00.21208549.8081526.038295.528.20020.32533.00031.55033.15014.7505.800000
geoId/06007Butte County81601.0091459.3333332.140051e+0538854.037531.025356.087422.50.15430236.4568574.031121.031.55022.30033.95029.65031.75016.6256.366667
geoId/06009Calaveras County17722.2527507.3333334.581786e+043949.06083.09705.016705.50.19957852.1579877.033742.528.00020.70032.77531.92533.97515.5006.166667
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + "variable Count_Household Count_HousingUnit \\\n", + "entity entity_name \n", + "geoId/06001 Alameda County 590160.20 625180.000000 \n", + "geoId/06003 Alpine County 463.50 1581.333333 \n", + "geoId/06005 Amador County 15985.75 18845.666667 \n", + "geoId/06007 Butte County 81601.00 91459.333333 \n", + "geoId/06009 Calaveras County 17722.25 27507.333333 \n", + "\n", + "variable Count_Person \\\n", + "entity entity_name \n", + "geoId/06001 Alameda County 1.665662e+06 \n", + "geoId/06003 Alpine County 1.296714e+03 \n", + "geoId/06005 Amador County 4.052386e+04 \n", + "geoId/06007 Butte County 2.140051e+05 \n", + "geoId/06009 Calaveras County 4.581786e+04 \n", + "\n", + "variable Count_Person_1OrMoreYears_DifferentHouse1YearAgo \\\n", + "entity entity_name \n", + "geoId/06001 Alameda County 202142.0 \n", + "geoId/06003 Alpine County 228.0 \n", + "geoId/06005 Amador County 5017.0 \n", + "geoId/06007 Butte County 38854.0 \n", + "geoId/06009 Calaveras County 3949.0 \n", + "\n", + "variable Count_Person_BelowPovertyLevelInThePast12Months \\\n", + "entity entity_name \n", + "geoId/06001 Alameda County 149752.0 \n", + "geoId/06003 Alpine County 209.0 \n", + "geoId/06005 Amador County 2931.0 \n", + "geoId/06007 Butte County 37531.0 \n", + "geoId/06009 Calaveras County 6083.0 \n", + "\n", + "variable Count_Person_EducationalAttainmentRegularHighSchoolDiploma \\\n", + "entity entity_name \n", + "geoId/06001 Alameda County 169001.0 \n", + "geoId/06003 Alpine County 186.0 \n", + "geoId/06005 Amador County 6911.0 \n", + "geoId/06007 Butte County 25356.0 \n", + "geoId/06009 Calaveras County 9705.0 \n", + "\n", + "variable Count_Person_Employed \\\n", + "entity entity_name \n", + "geoId/06001 Alameda County 832939.0 \n", + "geoId/06003 Alpine County 470.5 \n", + "geoId/06005 Amador County 14300.0 \n", + "geoId/06007 Butte County 87422.5 \n", + "geoId/06009 Calaveras County 16705.5 \n", + "\n", + "variable GenderIncomeInequality_Person_15OrMoreYears_WithIncome \\\n", + "entity entity_name \n", + "geoId/06001 Alameda County 0.175231 \n", + "geoId/06003 Alpine County 0.017420 \n", + "geoId/06005 Amador County 0.212085 \n", + "geoId/06007 Butte County 0.154302 \n", + "geoId/06009 Calaveras County 0.199578 \n", + "\n", + "variable Median_Age_Person Median_Income_Household \\\n", + "entity entity_name \n", + "geoId/06001 Alameda County 38.35 126240.0 \n", + "geoId/06003 Alpine County 44.65 110781.0 \n", + "geoId/06005 Amador County 49.80 81526.0 \n", + "geoId/06007 Butte County 36.45 68574.0 \n", + "geoId/06009 Calaveras County 52.15 79877.0 \n", + "\n", + "variable Median_Income_Person Percent_Person_Obesity \\\n", + "entity entity_name \n", + "geoId/06001 Alameda County 53077.5 21.400 \n", + "geoId/06003 Alpine County 34263.5 29.525 \n", + "geoId/06005 Amador County 38295.5 28.200 \n", + "geoId/06007 Butte County 31121.0 31.550 \n", + "geoId/06009 Calaveras County 33742.5 28.000 \n", + "\n", + "variable Percent_Person_PhysicalInactivity \\\n", + "entity entity_name \n", + "geoId/06001 Alameda County 18.775 \n", + "geoId/06003 Alpine County 20.550 \n", + "geoId/06005 Amador County 20.325 \n", + "geoId/06007 Butte County 22.300 \n", + "geoId/06009 Calaveras County 20.700 \n", + "\n", + "variable Percent_Person_SleepLessThan7Hours \\\n", + "entity entity_name \n", + "geoId/06001 Alameda County 34.100 \n", + "geoId/06003 Alpine County 33.825 \n", + "geoId/06005 Amador County 33.000 \n", + "geoId/06007 Butte County 33.950 \n", + "geoId/06009 Calaveras County 32.775 \n", + "\n", + "variable Percent_Person_WithHighBloodPressure \\\n", + "entity entity_name \n", + "geoId/06001 Alameda County 26.075 \n", + "geoId/06003 Alpine County 31.475 \n", + "geoId/06005 Amador County 31.550 \n", + "geoId/06007 Butte County 29.650 \n", + "geoId/06009 Calaveras County 31.925 \n", + "\n", + "variable Percent_Person_WithHighCholesterol \\\n", + "entity entity_name \n", + "geoId/06001 Alameda County 29.400 \n", + "geoId/06003 Alpine County 32.925 \n", + "geoId/06005 Amador County 33.150 \n", + "geoId/06007 Butte County 31.750 \n", + "geoId/06009 Calaveras County 33.975 \n", + "\n", + "variable Percent_Person_WithMentalHealthNotGood \\\n", + "entity entity_name \n", + "geoId/06001 Alameda County 12.550 \n", + "geoId/06003 Alpine County 15.850 \n", + "geoId/06005 Amador County 14.750 \n", + "geoId/06007 Butte County 16.625 \n", + "geoId/06009 Calaveras County 15.500 \n", + "\n", + "variable UnemploymentRate_Person \n", + "entity entity_name \n", + "geoId/06001 Alameda County 4.566667 \n", + "geoId/06003 Alpine County 6.300000 \n", + "geoId/06005 Amador County 5.800000 \n", + "geoId/06007 Butte County 6.366667 \n", + "geoId/06009 Calaveras County 6.166667 " + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Load new data\n", + "new_stat_vars = [\n", + " 'Percent_Person_Obesity',\n", + " 'Count_Household',\n", + " 'Count_HousingUnit',\n", + " 'Count_Person',\n", + " 'Count_Person_1OrMoreYears_DifferentHouse1YearAgo',\n", + " 'Count_Person_BelowPovertyLevelInThePast12Months',\n", + " 'Count_Person_EducationalAttainmentRegularHighSchoolDiploma',\n", + " 'Count_Person_Employed',\n", + " 'GenderIncomeInequality_Person_15OrMoreYears_WithIncome',\n", + " 'Median_Age_Person',\n", + " 'Median_Income_Household',\n", + " 'Median_Income_Person',\n", + " 'Percent_Person_PhysicalInactivity',\n", + " 'Percent_Person_SleepLessThan7Hours',\n", + " 'Percent_Person_WithHighBloodPressure',\n", + " 'Percent_Person_WithHighCholesterol',\n", + " 'Percent_Person_WithMentalHealthNotGood',\n", + " 'UnemploymentRate_Person'\n", + "]\n", + "\n", + "# Query Data Commons for the data and remove any NaN values\n", + "dcid_of_california = \"geoId/06\"\n", + "large_features_df = dc_client.observations_dataframe(variable_dcids=new_stat_vars, date=\"latest\", parent_entity=dcid_of_california, entity_type=\"County\")\n", + "large_features_df = large_features_df.pivot_table(index=['entity', 'entity_name'], columns='variable', values='value')\n", + "\n", + "large_features_df.dropna(axis='index', inplace=True)\n", + "\n", + "# order columns alphabetically\n", + "large_df = large_features_df.reindex(sorted(large_features_df.columns), axis=1)\n", + "\n", + "# Display results\n", + "large_df.head(5)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rhfPjm71Bhfa" + }, + "source": [ + "**2E)** Take a look at the list of variables we'll be using this time. Do you think all of them will be useful/predictive?\n", + "\n", + "**2F)** Based on your intuition, do you think adding all these models will help or hinder predictive accuracy?\n", + "\n", + "Let's now build a model and see what happens." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4_UAGmnEBd4r", + "outputId": "08e4c1cc-0c07-4536-bd37-f4606e1e392e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Features in Order:\n", + "\n", + "\t Index(['Count_Household', 'Count_HousingUnit', 'Count_Person',\n", + " 'Count_Person_1OrMoreYears_DifferentHouse1YearAgo',\n", + " 'Count_Person_BelowPovertyLevelInThePast12Months',\n", + " 'Count_Person_EducationalAttainmentRegularHighSchoolDiploma',\n", + " 'Count_Person_Employed',\n", + " 'GenderIncomeInequality_Person_15OrMoreYears_WithIncome',\n", + " 'Median_Age_Person', 'Median_Income_Household', 'Median_Income_Person',\n", + " 'Percent_Person_PhysicalInactivity',\n", + " 'Percent_Person_SleepLessThan7Hours',\n", + " 'Percent_Person_WithHighBloodPressure',\n", + " 'Percent_Person_WithHighCholesterol',\n", + " 'Percent_Person_WithMentalHealthNotGood', 'UnemploymentRate_Person'],\n", + " dtype='object', name='variable')\n", + "\n", + "Weights:\n", + "\n", + "\t [[-2.19445858e-08 5.92398556e-01 8.58111992e-02 6.36513779e-01\n", + " -6.55756125e-01 6.39071221e-01]]\n", + "\n", + "Intercept:\n", + "\n", + "\t [5.219999]\n" + ] + } + ], + "source": [ + "# Build a new model\n", + "dep_var = \"Percent_Person_Obesity\"\n", + "\n", + "y = large_df[dep_var].to_numpy().reshape(-1, 1)\n", + "x = large_df.loc[:, ~large_df.columns.isin([dep_var])]\n", + "\n", + "large_model = linear_model.LinearRegression().fit(x,y)\n", + "predictions = large_model.predict(x)\n", + "large_df[\"Predicted\"] = predictions\n", + "\n", + "# Get out-of-sample RMSE\n", + "\n", + "print(\"Features in Order:\\n\\n\\t\", x.columns)\n", + "print(\"\\nWeights:\\n\\n\\t\", model.coef_)\n", + "print(\"\\nIntercept:\\n\\n\\t\", model.intercept_)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BB9f8L9ycISb" + }, + "source": [ + "Let's also look at prediction error:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 565 + }, + "id": "NJffjobqcKxz", + "outputId": "7a0e105e-e726-41e8-b6e0-c7757ddbfc4b" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"new_df\",\n \"rows\": 5,\n \"fields\": [\n {\n \"column\": \"Count_Household\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 885650.2474016213,\n \"min\": 87.5,\n \"max\": 2061119.0,\n \"num_unique_values\": 5,\n \"samples\": [\n 16998.5,\n 31745.6,\n 2061119.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_HousingUnit\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 972865.909403489,\n \"min\": 154.33333333333334,\n \"max\": 2265544.6666666665,\n \"num_unique_values\": 5,\n \"samples\": [\n 19988.333333333332,\n 37472.0,\n 2265544.6666666665\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2230746.097346493,\n \"min\": 231.83333333333334,\n \"max\": 5192935.625,\n \"num_unique_values\": 5,\n \"samples\": [\n 47873.142857142855,\n 84424.0,\n 5192935.625\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person_1OrMoreYears_DifferentHouse1YearAgo\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 264682.09020540095,\n \"min\": 49.0,\n \"max\": 610109.0,\n \"num_unique_values\": 5,\n \"samples\": [\n 5228.0,\n 9634.0,\n 610109.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person_BelowPovertyLevelInThePast12Months\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 292170.7199974015,\n \"min\": 29.0,\n \"max\": 680528.0,\n \"num_unique_values\": 5,\n \"samples\": [\n 7647.0,\n 10663.0,\n 680528.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person_EducationalAttainmentRegularHighSchoolDiploma\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 297946.63191534823,\n \"min\": 39.0,\n \"max\": 696119.0,\n \"num_unique_values\": 5,\n \"samples\": [\n 10606.0,\n 18148.0,\n 696119.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person_Employed\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1130675.0906171056,\n \"min\": 157.0,\n \"max\": 2627782.0,\n \"num_unique_values\": 5,\n \"samples\": [\n 17580.0,\n 40344.0,\n 2627782.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"GenderIncomeInequality_Person_15OrMoreYears_WithIncome\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.09155086976837996,\n \"min\": 0.09788463,\n \"max\": 0.33380116,\n \"num_unique_values\": 5,\n \"samples\": [\n 0.09788463,\n 0.33380116,\n 0.15334302\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Median_Age_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2.5895462923068178,\n \"min\": 37.55,\n \"max\": 42.599999999999994,\n \"num_unique_values\": 5,\n \"samples\": [\n 42.599999999999994,\n 37.95,\n 37.55\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Median_Income_Household\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 13121.476544200352,\n \"min\": 47327.0,\n \"max\": 81797.0,\n \"num_unique_values\": 5,\n \"samples\": [\n 47327.0,\n 73372.0,\n 81797.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Median_Income_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 5391.692551972896,\n \"min\": 26371.0,\n \"max\": 40571.5,\n \"num_unique_values\": 5,\n \"samples\": [\n 26371.0,\n 35955.5,\n 40571.5\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_Obesity\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 4.467955348926399,\n \"min\": 31.424999999999997,\n \"max\": 41.075,\n \"num_unique_values\": 5,\n \"samples\": [\n 40.0,\n 41.075,\n 31.424999999999997\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_PhysicalInactivity\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 3.9877703670096145,\n \"min\": 22.8,\n \"max\": 32.75,\n \"num_unique_values\": 5,\n \"samples\": [\n 32.75,\n 28.675,\n 22.8\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_SleepLessThan7Hours\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.8604938860420899,\n \"min\": 35.875,\n \"max\": 40.3,\n \"num_unique_values\": 5,\n \"samples\": [\n 40.3,\n 39.875,\n 35.875\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithHighBloodPressure\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 4.077184997029201,\n \"min\": 30.175,\n \"max\": 40.1,\n \"num_unique_values\": 5,\n \"samples\": [\n 40.1,\n 34.65,\n 30.175\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithHighCholesterol\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 3.037854917536387,\n \"min\": 29.15,\n \"max\": 36.575,\n \"num_unique_values\": 5,\n \"samples\": [\n 33.225,\n 35.25,\n 29.15\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithMentalHealthNotGood\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.949070291190136,\n \"min\": 13.5,\n \"max\": 18.675,\n \"num_unique_values\": 5,\n \"samples\": [\n 18.675,\n 17.225,\n 13.5\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"UnemploymentRate_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 1.1139020503517254,\n \"min\": 3.1333333333333333,\n \"max\": 6.066666666666666,\n \"num_unique_values\": 5,\n \"samples\": [\n 4.166666666666667,\n 4.933333333333334,\n 6.066666666666666\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe", + "variable_name": "new_df" + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
variableCount_HouseholdCount_HousingUnitCount_PersonCount_Person_1OrMoreYears_DifferentHouse1YearAgoCount_Person_BelowPovertyLevelInThePast12MonthsCount_Person_EducationalAttainmentRegularHighSchoolDiplomaCount_Person_EmployedGenderIncomeInequality_Person_15OrMoreYears_WithIncomeMedian_Age_PersonMedian_Income_HouseholdMedian_Income_PersonPercent_Person_ObesityPercent_Person_PhysicalInactivityPercent_Person_SleepLessThan7HoursPercent_Person_WithHighBloodPressurePercent_Person_WithHighCholesterolPercent_Person_WithMentalHealthNotGoodUnemploymentRate_Person
entityentity_name
geoId/12057Hillsborough County562309.66.091467e+051.485704e+06239440.0193025.0223649.0783239.50.15222937.7075011.036136.031.92525.27538.05031.75030.95015.4753.900000
geoId/12063Jackson County16998.51.998833e+044.787314e+045228.07647.010606.017580.00.09788542.6047327.026371.040.00032.75040.30040.10033.22518.6754.166667
geoId/17031Cook County2061119.02.265545e+065.192936e+06610109.0680528.0696119.02627782.00.15334337.5581797.040571.531.42522.80035.87530.17529.15013.5006.066667
geoId/48269King County87.51.543333e+022.318333e+0249.029.039.0157.00.13793142.3070192.038077.036.97530.47537.10037.57536.57516.7253.133333
geoId/48361Orange County31745.63.747200e+048.442400e+049634.010663.018148.040344.00.33380137.9573372.035955.541.07528.67539.87534.65035.25017.2254.933333
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + "variable Count_Household Count_HousingUnit \\\n", + "entity entity_name \n", + "geoId/12057 Hillsborough County 562309.6 6.091467e+05 \n", + "geoId/12063 Jackson County 16998.5 1.998833e+04 \n", + "geoId/17031 Cook County 2061119.0 2.265545e+06 \n", + "geoId/48269 King County 87.5 1.543333e+02 \n", + "geoId/48361 Orange County 31745.6 3.747200e+04 \n", + "\n", + "variable Count_Person \\\n", + "entity entity_name \n", + "geoId/12057 Hillsborough County 1.485704e+06 \n", + "geoId/12063 Jackson County 4.787314e+04 \n", + "geoId/17031 Cook County 5.192936e+06 \n", + "geoId/48269 King County 2.318333e+02 \n", + "geoId/48361 Orange County 8.442400e+04 \n", + "\n", + "variable Count_Person_1OrMoreYears_DifferentHouse1YearAgo \\\n", + "entity entity_name \n", + "geoId/12057 Hillsborough County 239440.0 \n", + "geoId/12063 Jackson County 5228.0 \n", + "geoId/17031 Cook County 610109.0 \n", + "geoId/48269 King County 49.0 \n", + "geoId/48361 Orange County 9634.0 \n", + "\n", + "variable Count_Person_BelowPovertyLevelInThePast12Months \\\n", + "entity entity_name \n", + "geoId/12057 Hillsborough County 193025.0 \n", + "geoId/12063 Jackson County 7647.0 \n", + "geoId/17031 Cook County 680528.0 \n", + "geoId/48269 King County 29.0 \n", + "geoId/48361 Orange County 10663.0 \n", + "\n", + "variable Count_Person_EducationalAttainmentRegularHighSchoolDiploma \\\n", + "entity entity_name \n", + "geoId/12057 Hillsborough County 223649.0 \n", + "geoId/12063 Jackson County 10606.0 \n", + "geoId/17031 Cook County 696119.0 \n", + "geoId/48269 King County 39.0 \n", + "geoId/48361 Orange County 18148.0 \n", + "\n", + "variable Count_Person_Employed \\\n", + "entity entity_name \n", + "geoId/12057 Hillsborough County 783239.5 \n", + "geoId/12063 Jackson County 17580.0 \n", + "geoId/17031 Cook County 2627782.0 \n", + "geoId/48269 King County 157.0 \n", + "geoId/48361 Orange County 40344.0 \n", + "\n", + "variable GenderIncomeInequality_Person_15OrMoreYears_WithIncome \\\n", + "entity entity_name \n", + "geoId/12057 Hillsborough County 0.152229 \n", + "geoId/12063 Jackson County 0.097885 \n", + "geoId/17031 Cook County 0.153343 \n", + "geoId/48269 King County 0.137931 \n", + "geoId/48361 Orange County 0.333801 \n", + "\n", + "variable Median_Age_Person Median_Income_Household \\\n", + "entity entity_name \n", + "geoId/12057 Hillsborough County 37.70 75011.0 \n", + "geoId/12063 Jackson County 42.60 47327.0 \n", + "geoId/17031 Cook County 37.55 81797.0 \n", + "geoId/48269 King County 42.30 70192.0 \n", + "geoId/48361 Orange County 37.95 73372.0 \n", + "\n", + "variable Median_Income_Person Percent_Person_Obesity \\\n", + "entity entity_name \n", + "geoId/12057 Hillsborough County 36136.0 31.925 \n", + "geoId/12063 Jackson County 26371.0 40.000 \n", + "geoId/17031 Cook County 40571.5 31.425 \n", + "geoId/48269 King County 38077.0 36.975 \n", + "geoId/48361 Orange County 35955.5 41.075 \n", + "\n", + "variable Percent_Person_PhysicalInactivity \\\n", + "entity entity_name \n", + "geoId/12057 Hillsborough County 25.275 \n", + "geoId/12063 Jackson County 32.750 \n", + "geoId/17031 Cook County 22.800 \n", + "geoId/48269 King County 30.475 \n", + "geoId/48361 Orange County 28.675 \n", + "\n", + "variable Percent_Person_SleepLessThan7Hours \\\n", + "entity entity_name \n", + "geoId/12057 Hillsborough County 38.050 \n", + "geoId/12063 Jackson County 40.300 \n", + "geoId/17031 Cook County 35.875 \n", + "geoId/48269 King County 37.100 \n", + "geoId/48361 Orange County 39.875 \n", + "\n", + "variable Percent_Person_WithHighBloodPressure \\\n", + "entity entity_name \n", + "geoId/12057 Hillsborough County 31.750 \n", + "geoId/12063 Jackson County 40.100 \n", + "geoId/17031 Cook County 30.175 \n", + "geoId/48269 King County 37.575 \n", + "geoId/48361 Orange County 34.650 \n", + "\n", + "variable Percent_Person_WithHighCholesterol \\\n", + "entity entity_name \n", + "geoId/12057 Hillsborough County 30.950 \n", + "geoId/12063 Jackson County 33.225 \n", + "geoId/17031 Cook County 29.150 \n", + "geoId/48269 King County 36.575 \n", + "geoId/48361 Orange County 35.250 \n", + "\n", + "variable Percent_Person_WithMentalHealthNotGood \\\n", + "entity entity_name \n", + "geoId/12057 Hillsborough County 15.475 \n", + "geoId/12063 Jackson County 18.675 \n", + "geoId/17031 Cook County 13.500 \n", + "geoId/48269 King County 16.725 \n", + "geoId/48361 Orange County 17.225 \n", + "\n", + "variable UnemploymentRate_Person \n", + "entity entity_name \n", + "geoId/12057 Hillsborough County 3.900000 \n", + "geoId/12063 Jackson County 4.166667 \n", + "geoId/17031 Cook County 6.066667 \n", + "geoId/48269 King County 3.133333 \n", + "geoId/48361 Orange County 4.933333 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"print(\\\"Out-of-sample RMSE:\\\", mean_squared_error(new_y, new_predicted))\",\n \"rows\": 5,\n \"fields\": [\n {\n \"column\": \"Prediction\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 7.596590621467286,\n \"min\": 17.37404363962777,\n \"max\": 36.883062016616456,\n \"num_unique_values\": 5,\n \"samples\": [\n 36.883062016616456,\n 32.50827326532303,\n 17.37404363962777\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_Obesity\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 4.467955348926399,\n \"min\": 31.424999999999997,\n \"max\": 41.075,\n \"num_unique_values\": 5,\n \"samples\": [\n 40.0,\n 41.075,\n 31.424999999999997\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe" + }, + "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", + "
variablePredictionPercent_Person_Obesity
entityentity_name
geoId/12057Hillsborough County28.27921031.925
geoId/12063Jackson County36.88306240.000
geoId/17031Cook County17.37404431.425
geoId/48269King County33.87582136.975
geoId/48361Orange County32.50827341.075
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + "variable Prediction Percent_Person_Obesity\n", + "entity entity_name \n", + "geoId/12057 Hillsborough County 28.279210 31.925\n", + "geoId/12063 Jackson County 36.883062 40.000\n", + "geoId/17031 Cook County 17.374044 31.425\n", + "geoId/48269 King County 33.875821 36.975\n", + "geoId/48361 Orange County 32.508273 41.075" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "In-sample Prediction RMSE: 0.8337317180392496\n", + "Out-of-sample RMSE: 60.68603623938627\n" + ] + } + ], + "source": [ + "# Apply model to some out-of-sample datapoints\n", + "new_dcids = [\n", + " \"geoId/48361\", # Orange, Texas\n", + " \"geoId/48269\", # King County, Texas\n", + " \"geoId/17031\", # Cook County, Illinois\n", + " \"geoId/12063\", # Jackson County, Florida\n", + " \"geoId/12057\", # Hillsborough County, Florida\n", + "]\n", + "\n", + "new_df = dc_client.observations_dataframe(variable_dcids=new_stat_vars, entity_dcids=new_dcids, date=\"latest\")\n", + "new_df = new_df.pivot_table(index=['entity', 'entity_name'], columns='variable', values='value')\n", + "new_df.dropna()\n", + "\n", + "# sort columns alphabetically\n", + "new_df = new_df.reindex(sorted(new_df.columns), axis=1)\n", + "\n", + "display(new_df)\n", + "\n", + "new_y = new_df[dep_var].to_numpy().reshape(-1, 1)\n", + "new_x = new_df.loc[:, ~new_df.columns.isin([dep_var])]\n", + "\n", + "new_predicted = large_model.predict(new_x)\n", + "new_df[\"Prediction\"] = new_predicted\n", + "display(new_df[[\"Prediction\", dep_var]])\n", + "\n", + "print(\"In-sample Prediction RMSE:\", mean_squared_error(y, predictions))\n", + "print(\"Out-of-sample RMSE:\", mean_squared_error(new_y, new_predicted))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qinowt_kB4oM" + }, + "source": [ + "**2G)** How does the in-sample and out-of-sample RMSE compare with the smaller model from question 2A?\n", + "\n", + "**2H)** Analyze the coefficients of the new larger regression model. Which variables seem to affect the prediction most?\n", + "\n", + "**2I)** Is it easy to tell? In other words, how interpretable is this model?" + ] + } + ], + "metadata": { + "colab": { + "include_colab_link": true, + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/notebooks/intro_data_science/Regression_Evaluation_and_Interpretation.ipynb b/notebooks/intro_data_science/Regression_Evaluation_and_Interpretation.ipynb new file mode 100644 index 00000000..b549c8aa --- /dev/null +++ b/notebooks/intro_data_science/Regression_Evaluation_and_Interpretation.ipynb @@ -0,0 +1,3211 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "view-in-github" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "myiDKzkSIAUs" + }, + "source": [ + "Copyright 2025 Google LLC.\n", + "SPDX-License-Identifier: Apache-2.0" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sbPgBMt01mSB" + }, + "source": [ + "# Regression: Evaluation and Interpretation\n", + "In the [previous notebook](https://github.com/datacommonsorg/api-python/blob/master/notebooks/v2/intro_data_science/Regression_Basics_and_Prediction.ipynb), we saw how powerful regression can be as a tool for prediction. In this Colab, we'll take that exploration one step further: what can regression models tell us about the statistical relationships between variables?\n", + "\n", + "In particular, this colab will take a more rigorous statistical approach to regressions. We'll look at how to evaluate and interpret our regression models using statistical methods.\n", + "\n", + "## Learning objectives:\n", + "* Hypothesis testing with regression\n", + "* Regression tables\n", + "* Pearson correlation coefficient, $r$\n", + "* $R^2$ and adjusted $R^2$\n", + "* Interpreting weights and intercepts\n", + "* How correlated variables affect models\n", + "---\n", + "**Need extra help?**\n", + "\n", + "If you're new to Google Colab, take a look at [this getting started tutorial](https://colab.research.google.com/notebooks/intro.ipynb).\n", + "\n", + "To build more familiarity with the Data Commons API, check out these [Data Commons tutorials](https://docs.datacommons.org/api/python/v2/tutorials.md).\n", + "\n", + "And for help with Pandas and manipulating data frames, take a look at the [Pandas documentation](https://pandas.pydata.org/docs/reference/index.html).\n", + "\n", + "We'll be using the scikit-learn library for implementing our models today. Documentation can be found [here](https://scikit-learn.org/stable/modules/classes.html).\n", + "\n", + "As usual, if you have any other questions, please reach out to your course staff!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gnoowEYUIQS-" + }, + "source": [ + "## Getting set up\n", + "\n", + "\n", + "Run the following code boxes to load the Python libraries and data we'll be using today." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "YkuB0EIS59qX" + }, + "outputs": [], + "source": [ + "# Setup/Imports\n", + "!pip install \"datacommons-client[Pandas]\" --upgrade --quiet" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "u2oFQ7-v8sxY" + }, + "outputs": [], + "source": [ + "# Data Commons Python and Pandas APIs\n", + "from datacommons_client.client import DataCommonsClient\n", + "client = DataCommonsClient(api_key=\"your API key\")\n", + "\n", + "# For manipulating data\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "# For implementing models and evaluation methods\n", + "from sklearn import linear_model\n", + "from sklearn.metrics import r2_score, mean_squared_error\n", + "from statsmodels import api as sm\n", + "\n", + "\n", + "# For plotting/printing\n", + "from matplotlib import pyplot as plt\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WQlAj-wYjI9L" + }, + "source": [ + "### The data\n", + "\n", + "In this assignment, we'll be returning to the scenario we started in the previous notebook. As a refresher, we'll be exploring how obesity rates vary with different health or societal factors across US cities.\n", + "\n", + "Our data science question: **What can we learn about the relationship of those health and lifestyle factors to obesity rates?**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 492 + }, + "id": "VuA3xgSQXhK6", + "outputId": "6c43f4e1-6424-4058-f681-6cf31b6fb05a" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"df\",\n \"rows\": 498,\n \"fields\": [\n {\n \"column\": \"place\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 498,\n \"samples\": [\n \"geoId/5363000\",\n \"geoId/0639892\",\n \"geoId/1714351\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"City Name\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 475,\n \"samples\": [\n \"Memphis\",\n \"Plano\",\n \"Avondale\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 471628.1194557695,\n \"min\": 76212.0,\n \"max\": 8258035.0,\n \"num_unique_values\": 498,\n \"samples\": [\n 755078.0,\n 78135.0,\n 81004.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_Obesity\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 6.3675302626575006,\n \"min\": 14.1,\n \"max\": 48.9,\n \"num_unique_values\": 220,\n \"samples\": [\n 33.4,\n 41.6,\n 23.2\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_PhysicalInactivity\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 5.79401923130349,\n \"min\": 11.2,\n \"max\": 41.8,\n \"num_unique_values\": 209,\n \"samples\": [\n 25.0,\n 39.5,\n 18.4\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_SleepLessThan7Hours\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 4.3313227959895455,\n \"min\": 24.9,\n \"max\": 49.5,\n \"num_unique_values\": 166,\n \"samples\": [\n 42.5,\n 25.6,\n 28.4\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithHighBloodPressure\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 4.56550336745893,\n \"min\": 21.3,\n \"max\": 45.7,\n \"num_unique_values\": 170,\n \"samples\": [\n 40.3,\n 25.6,\n 41.2\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithHighCholesterol\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2.089525781869934,\n \"min\": 24.6,\n \"max\": 35.6,\n \"num_unique_values\": 95,\n \"samples\": [\n 25.9,\n 34.1,\n 27.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithMentalHealthNotGood\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2.1019573952670365,\n \"min\": 11.5,\n \"max\": 23.3,\n \"num_unique_values\": 103,\n \"samples\": [\n 15.8,\n 16.3,\n 12.7\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe", + "variable_name": "df" + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
variableCity NameCount_PersonPercent_Person_ObesityPercent_Person_PhysicalInactivityPercent_Person_SleepLessThan7HoursPercent_Person_WithHighBloodPressurePercent_Person_WithHighCholesterolPercent_Person_WithMentalHealthNotGood
place
geoId/0103076Auburn82025.033.023.636.034.330.617.8
geoId/0107000Birmingham196644.044.932.942.945.031.619.7
geoId/0135896Hoover92448.032.519.733.632.631.015.4
geoId/0137000Huntsville225564.037.524.040.036.531.618.0
geoId/0150000Mobile182595.044.228.743.439.832.519.9
...........................
geoId/5531000Green Bay105744.038.926.733.128.130.717.9
geoId/5539225Kenosha98211.043.723.836.629.930.018.6
geoId/5548000Madison280305.032.118.729.926.628.515.6
geoId/5553000Milwaukee561385.043.428.840.036.730.119.0
geoId/5566000Racine76602.042.928.239.232.332.018.4
\n", + "

498 rows × 8 columns

\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + "variable City Name Count_Person Percent_Person_Obesity \\\n", + "place \n", + "geoId/0103076 Auburn 82025.0 33.0 \n", + "geoId/0107000 Birmingham 196644.0 44.9 \n", + "geoId/0135896 Hoover 92448.0 32.5 \n", + "geoId/0137000 Huntsville 225564.0 37.5 \n", + "geoId/0150000 Mobile 182595.0 44.2 \n", + "... ... ... ... \n", + "geoId/5531000 Green Bay 105744.0 38.9 \n", + "geoId/5539225 Kenosha 98211.0 43.7 \n", + "geoId/5548000 Madison 280305.0 32.1 \n", + "geoId/5553000 Milwaukee 561385.0 43.4 \n", + "geoId/5566000 Racine 76602.0 42.9 \n", + "\n", + "variable Percent_Person_PhysicalInactivity \\\n", + "place \n", + "geoId/0103076 23.6 \n", + "geoId/0107000 32.9 \n", + "geoId/0135896 19.7 \n", + "geoId/0137000 24.0 \n", + "geoId/0150000 28.7 \n", + "... ... \n", + "geoId/5531000 26.7 \n", + "geoId/5539225 23.8 \n", + "geoId/5548000 18.7 \n", + "geoId/5553000 28.8 \n", + "geoId/5566000 28.2 \n", + "\n", + "variable Percent_Person_SleepLessThan7Hours \\\n", + "place \n", + "geoId/0103076 36.0 \n", + "geoId/0107000 42.9 \n", + "geoId/0135896 33.6 \n", + "geoId/0137000 40.0 \n", + "geoId/0150000 43.4 \n", + "... ... \n", + "geoId/5531000 33.1 \n", + "geoId/5539225 36.6 \n", + "geoId/5548000 29.9 \n", + "geoId/5553000 40.0 \n", + "geoId/5566000 39.2 \n", + "\n", + "variable Percent_Person_WithHighBloodPressure \\\n", + "place \n", + "geoId/0103076 34.3 \n", + "geoId/0107000 45.0 \n", + "geoId/0135896 32.6 \n", + "geoId/0137000 36.5 \n", + "geoId/0150000 39.8 \n", + "... ... \n", + "geoId/5531000 28.1 \n", + "geoId/5539225 29.9 \n", + "geoId/5548000 26.6 \n", + "geoId/5553000 36.7 \n", + "geoId/5566000 32.3 \n", + "\n", + "variable Percent_Person_WithHighCholesterol \\\n", + "place \n", + "geoId/0103076 30.6 \n", + "geoId/0107000 31.6 \n", + "geoId/0135896 31.0 \n", + "geoId/0137000 31.6 \n", + "geoId/0150000 32.5 \n", + "... ... \n", + "geoId/5531000 30.7 \n", + "geoId/5539225 30.0 \n", + "geoId/5548000 28.5 \n", + "geoId/5553000 30.1 \n", + "geoId/5566000 32.0 \n", + "\n", + "variable Percent_Person_WithMentalHealthNotGood \n", + "place \n", + "geoId/0103076 17.8 \n", + "geoId/0107000 19.7 \n", + "geoId/0135896 15.4 \n", + "geoId/0137000 18.0 \n", + "geoId/0150000 19.9 \n", + "... ... \n", + "geoId/5531000 17.9 \n", + "geoId/5539225 18.6 \n", + "geoId/5548000 15.6 \n", + "geoId/5553000 19.0 \n", + "geoId/5566000 18.4 \n", + "\n", + "[498 rows x 8 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Load the data we'll be using\n", + "\n", + "# Fetch the population of the US cities\n", + "city_pop = client.observation.fetch_observations_by_entity_type(\n", + " date=\"latest\",\n", + " parent_entity=\"country/USA\",\n", + " entity_type=\"City\",\n", + " variable_dcids=\"Count_Person\",\n", + " filter_facet_ids=\"2176550201\" # USCensusPEP_Annual_Population\n", + ").byVariable[\"Count_Person\"].byEntity\n", + "city_pop_dict = {\n", + " city: data[\"orderedFacets\"][0].observations[0].value\n", + " for city, data in city_pop.items()\n", + " }\n", + "\n", + "# Filter to the top 500 cities\n", + "cities = [\n", + " item[0]\n", + " for item in sorted(\n", + " city_pop_dict.items(),\n", + " key=lambda item: item[1],\n", + " reverse=True)[:500]\n", + " ]\n", + "\n", + "# We've compiled a list of some nice Data Commons Statistical Variables\n", + "# to use as features for you\n", + "stat_vars_to_query = [\n", + " \"Count_Person\",\n", + " \"Percent_Person_PhysicalInactivity\",\n", + " \"Percent_Person_SleepLessThan7Hours\",\n", + " \"Percent_Person_WithHighBloodPressure\",\n", + " \"Percent_Person_WithMentalHealthNotGood\",\n", + " \"Percent_Person_WithHighCholesterol\",\n", + " \"Percent_Person_Obesity\"\n", + "\n", + "]\n", + "\n", + "# Query Data Commons for the data\n", + "raw_features_df = client.observations_dataframe(\n", + " variable_dcids=stat_vars_to_query,\n", + " date=\"latest\",\n", + " entity_dcids=cities)\n", + "\n", + "# Filter to highest ranked facet for each entity and variable\n", + "df = raw_features_df.copy(deep=True)\n", + "df = df.groupby([\"entity\", \"entity_name\", \"variable\"]).first().reset_index()\n", + "\n", + "# Select required columns and pivot by variable\n", + "df = df[[\"entity\", \"entity_name\", \"variable\", \"value\"]]\n", + "df = df.pivot(index=[\"entity\", \"entity_name\"], columns=\"variable\", values=\"value\")\n", + "df = df.dropna()\n", + "\n", + "# Rename columns and order alphabetically\n", + "df = df.reset_index()\n", + "df.rename(columns={\"entity\":\"place\", \"entity_name\": \"City Name\"}, inplace=True)\n", + "df.set_index(\"place\", inplace=True)\n", + "df = df.reindex(sorted(df.columns), axis=1)\n", + "\n", + "# Display results\n", + "display(df)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TbvPpqYDiGmY" + }, + "source": [ + "### The model\n", + "\n", + "Run the following code box to fit an [ordinary least squares](https://en.wikipedia.org/wiki/Ordinary_least_squares) regression model to our data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "V9x5v10LwYZG" + }, + "outputs": [], + "source": [ + "# Fit a regression model\n", + "dep_var = \"Percent_Person_Obesity\"\n", + "y = df[dep_var].to_numpy().reshape(-1, 1)\n", + "x = df.loc[:, ~df.columns.isin([dep_var, \"City Name\"])]\n", + "x = sm.add_constant(x)\n", + "\n", + "\n", + "model = sm.OLS(y, x)\n", + "results = model.fit()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_h32-nQChkE6" + }, + "source": [ + "## 0) Regression tables\n", + "\n", + "When performing regression analyses, statistical packages will usually provide a _**regression table**_, which summarizes the results of the analysis.\n", + "\n", + "Run the following codebox to display the regression table for our original model. In this Colab, we'll go over some of the statistics included in the table.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "KvCfUveghpcJ", + "outputId": "be61942c-174a-405d-b317-43439e1363b0" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: y R-squared: 0.758\n", + "Model: OLS Adj. R-squared: 0.755\n", + "Method: Least Squares F-statistic: 256.0\n", + "Date: Thu, 22 May 2025 Prob (F-statistic): 1.18e-147\n", + "Time: 16:02:06 Log-Likelihood: -1275.0\n", + "No. Observations: 498 AIC: 2564.\n", + "Df Residuals: 491 BIC: 2593.\n", + "Df Model: 6 \n", + "Covariance Type: nonrobust \n", + "==========================================================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "----------------------------------------------------------------------------------------------------------\n", + "const -0.1937 2.656 -0.073 0.942 -5.412 5.024\n", + "Count_Person -7.183e-07 3.02e-07 -2.381 0.018 -1.31e-06 -1.25e-07\n", + "Percent_Person_PhysicalInactivity 0.3053 0.046 6.577 0.000 0.214 0.396\n", + "Percent_Person_SleepLessThan7Hours -0.1246 0.057 -2.192 0.029 -0.236 -0.013\n", + "Percent_Person_WithHighBloodPressure 0.7572 0.054 14.062 0.000 0.651 0.863\n", + "Percent_Person_WithHighCholesterol -0.1352 0.077 -1.756 0.080 -0.286 0.016\n", + "Percent_Person_WithMentalHealthNotGood 0.6901 0.103 6.704 0.000 0.488 0.892\n", + "==============================================================================\n", + "Omnibus: 2.835 Durbin-Watson: 1.396\n", + "Prob(Omnibus): 0.242 Jarque-Bera (JB): 2.651\n", + "Skew: 0.133 Prob(JB): 0.266\n", + "Kurtosis: 3.239 Cond. No. 9.89e+06\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "[2] The condition number is large, 9.89e+06. This might indicate that there are\n", + "strong multicollinearity or other numerical problems.\n" + ] + } + ], + "source": [ + "print(results.summary())" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aFi0LWX0OlwA" + }, + "source": [ + "## 1) Hypothesis testing\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DrYP7lZ9cyHL" + }, + "source": [ + "### 1.1) Null hypotheses\n", + "\n", + "When performing statistical analyses, one usually starts with a statement of the null hypothesis. Typically for regression models, these take the form of the coefficient for a variable equaling zero.\n", + "\n", + "**1.1)** Write out the null hypotheses for each of our independent variables." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "wAOpaTGXeiQb" + }, + "source": [ + "### 1.2) T-test\n", + "\n", + "So how do we test our null hypotheses? We use the [T-test](https://en.wikipedia.org/wiki/Student%27s_t-test#Slope_of_a_regression_line).\n", + "\n", + "Take a look at the regression table above to answer the following questions\n", + "\n", + "**Q1.2A)** According to the t-test, which variables are statistically significant?\n", + "\n", + "**Q1.2B)** For variables that are not statistically significant, should we keep them in our model? Why or why not?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "exV8u07Bek4z" + }, + "source": [ + "### 1.3) F-test\n", + "\n", + "Beyond testing the significance of our individual variables independently, we can also test the significance of our model overall using the [F-test](https://en.wikipedia.org/wiki/F-test#Regression_problems). In particular, the F-test compares our model to one without predictors (aka, just an intercept). In other words, can our model do statistically better than just predicting the mean?\n", + "\n", + "Again use the regression table above to answer the following questions:\n", + "\n", + "**1.3A)** What is the null hypothesis for the F-test?\n", + "\n", + "**1.3B)** Can we reject the null hypothesis for our model?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gpk0RO17VJXz" + }, + "source": [ + "## 2) Statistical measures" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "RS-U1bdrl-c2" + }, + "source": [ + "### 2.1) Correlation coefficient $r$\n", + "\n", + "We can quantify predictiveness of variables using a _correlation coefficient_, a number that represents the degree to which two variables have a statistical relationship. The most common correlation coefficient used is the [Pearson correlation coefficient](https://en.wikipedia.org/wiki/Pearson_correlation_coefficient), also known as _Pearson's r_, which measures the strength of linear relationships between variables.\n", + "\n", + "Mathematically, the correlation coefficient is defined as:\n", + "$$ r = \\frac{\\sum_i (x_i - \\bar{x})(y_i - \\bar{y})}{\\sqrt{\\sum_i (x_i - \\bar{x})^2}\\sqrt{\\sum_i (y_i - \\bar{y})^2}}\n", + "$$\n", + "\n", + "where $x$ and $y$ are the two variables.\n", + "\n", + "Those of you with a statistics background might recognize this as the ratio of covariance to the product of their standard deviations.\n", + "\n", + "**2.1A)** Either using the mathematical definition or by exploring with code, explain what the correlation coefficient would be in the following cases:\n", + "\n", + "A) $x = y$\n", + "\n", + "B) $x = -y$\n", + "\n", + "C) $x$ and $y$ are both normally distributed variables with mean 0 and variance 1, randomly sampled independently from each other." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "FwEnQEWjMQv5", + "outputId": "9803eadf-dc00-4c69-b337-ef0b5ed92fad" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'\\nOptional cell for 2.1A\\n'" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"\n", + "Optional cell for 2.1A\n", + "\"\"\"\n", + "\n", + "# Hint: Try writing code to generate values for x and y, then either write or import\n", + "# a function to calculate the correlation coefficient\n", + "\n", + "# Your code here" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mPxYc8tNMq52" + }, + "source": [ + "Now run the following code box to use the Pandas `.corr()` function to calculate the correlation coefficient between our variables. Note that pandas outputs the results as a matrix." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 320 + }, + "id": "TKrIjyt657ir", + "outputId": "80ea1cfc-18ec-49bd-8c21-5a0e33502bdf" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"df[stat_vars_to_query]\",\n \"rows\": 7,\n \"fields\": [\n {\n \"column\": \"variable\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 7,\n \"samples\": [\n \"Count_Person\",\n \"Percent_Person_PhysicalInactivity\",\n \"Percent_Person_WithHighCholesterol\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.3692768160533883,\n \"min\": -0.032606435112257866,\n \"max\": 1.0,\n \"num_unique_values\": 7,\n \"samples\": [\n 1.0,\n 0.05966842357472978,\n 0.04809963828980299\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_PhysicalInactivity\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.3039891315555219,\n \"min\": 0.05966842357472978,\n \"max\": 1.0,\n \"num_unique_values\": 7,\n \"samples\": [\n 0.05966842357472978,\n 1.0,\n 0.4366429779497951\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_SleepLessThan7Hours\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.3018122804213848,\n \"min\": 0.07380691021769277,\n \"max\": 1.0,\n \"num_unique_values\": 7,\n \"samples\": [\n 0.07380691021769277,\n 0.7788343765257514,\n 0.3694331027620301\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithHighBloodPressure\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.32460607938114927,\n \"min\": 0.025619158392611367,\n \"max\": 1.0,\n \"num_unique_values\": 7,\n \"samples\": [\n 0.025619158392611367,\n 0.7446432625492557,\n 0.381625664582876\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithMentalHealthNotGood\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.34286073197902867,\n \"min\": -0.006579247299365092,\n \"max\": 1.0,\n \"num_unique_values\": 7,\n \"samples\": [\n -0.006579247299365092,\n 0.7007758800234068,\n 0.21400402260098858\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithHighCholesterol\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.29745289241877604,\n \"min\": 0.04809963828980299,\n \"max\": 1.0,\n \"num_unique_values\": 7,\n \"samples\": [\n 0.04809963828980299,\n 0.4366429779497951,\n 1.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_Obesity\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.3527430213065325,\n \"min\": -0.032606435112257866,\n \"max\": 1.0,\n \"num_unique_values\": 7,\n \"samples\": [\n -0.032606435112257866,\n 0.7531559280354309,\n 0.29900147207085953\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe" + }, + "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", + "
variableCount_PersonPercent_Person_PhysicalInactivityPercent_Person_SleepLessThan7HoursPercent_Person_WithHighBloodPressurePercent_Person_WithMentalHealthNotGoodPercent_Person_WithHighCholesterolPercent_Person_Obesity
variable
Count_Person1.0000000.0596680.0738070.025619-0.0065790.048100-0.032606
Percent_Person_PhysicalInactivity0.0596681.0000000.7788340.7446430.7007760.4366430.753156
Percent_Person_SleepLessThan7Hours0.0738070.7788341.0000000.7454740.6193430.3694330.657111
Percent_Person_WithHighBloodPressure0.0256190.7446430.7454741.0000000.6902940.3816260.825544
Percent_Person_WithMentalHealthNotGood-0.0065790.7007760.6193430.6902941.0000000.2140040.735612
Percent_Person_WithHighCholesterol0.0481000.4366430.3694330.3816260.2140041.0000000.299001
Percent_Person_Obesity-0.0326060.7531560.6571110.8255440.7356120.2990011.000000
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + "variable Count_Person \\\n", + "variable \n", + "Count_Person 1.000000 \n", + "Percent_Person_PhysicalInactivity 0.059668 \n", + "Percent_Person_SleepLessThan7Hours 0.073807 \n", + "Percent_Person_WithHighBloodPressure 0.025619 \n", + "Percent_Person_WithMentalHealthNotGood -0.006579 \n", + "Percent_Person_WithHighCholesterol 0.048100 \n", + "Percent_Person_Obesity -0.032606 \n", + "\n", + "variable Percent_Person_PhysicalInactivity \\\n", + "variable \n", + "Count_Person 0.059668 \n", + "Percent_Person_PhysicalInactivity 1.000000 \n", + "Percent_Person_SleepLessThan7Hours 0.778834 \n", + "Percent_Person_WithHighBloodPressure 0.744643 \n", + "Percent_Person_WithMentalHealthNotGood 0.700776 \n", + "Percent_Person_WithHighCholesterol 0.436643 \n", + "Percent_Person_Obesity 0.753156 \n", + "\n", + "variable Percent_Person_SleepLessThan7Hours \\\n", + "variable \n", + "Count_Person 0.073807 \n", + "Percent_Person_PhysicalInactivity 0.778834 \n", + "Percent_Person_SleepLessThan7Hours 1.000000 \n", + "Percent_Person_WithHighBloodPressure 0.745474 \n", + "Percent_Person_WithMentalHealthNotGood 0.619343 \n", + "Percent_Person_WithHighCholesterol 0.369433 \n", + "Percent_Person_Obesity 0.657111 \n", + "\n", + "variable Percent_Person_WithHighBloodPressure \\\n", + "variable \n", + "Count_Person 0.025619 \n", + "Percent_Person_PhysicalInactivity 0.744643 \n", + "Percent_Person_SleepLessThan7Hours 0.745474 \n", + "Percent_Person_WithHighBloodPressure 1.000000 \n", + "Percent_Person_WithMentalHealthNotGood 0.690294 \n", + "Percent_Person_WithHighCholesterol 0.381626 \n", + "Percent_Person_Obesity 0.825544 \n", + "\n", + "variable Percent_Person_WithMentalHealthNotGood \\\n", + "variable \n", + "Count_Person -0.006579 \n", + "Percent_Person_PhysicalInactivity 0.700776 \n", + "Percent_Person_SleepLessThan7Hours 0.619343 \n", + "Percent_Person_WithHighBloodPressure 0.690294 \n", + "Percent_Person_WithMentalHealthNotGood 1.000000 \n", + "Percent_Person_WithHighCholesterol 0.214004 \n", + "Percent_Person_Obesity 0.735612 \n", + "\n", + "variable Percent_Person_WithHighCholesterol \\\n", + "variable \n", + "Count_Person 0.048100 \n", + "Percent_Person_PhysicalInactivity 0.436643 \n", + "Percent_Person_SleepLessThan7Hours 0.369433 \n", + "Percent_Person_WithHighBloodPressure 0.381626 \n", + "Percent_Person_WithMentalHealthNotGood 0.214004 \n", + "Percent_Person_WithHighCholesterol 1.000000 \n", + "Percent_Person_Obesity 0.299001 \n", + "\n", + "variable Percent_Person_Obesity \n", + "variable \n", + "Count_Person -0.032606 \n", + "Percent_Person_PhysicalInactivity 0.753156 \n", + "Percent_Person_SleepLessThan7Hours 0.657111 \n", + "Percent_Person_WithHighBloodPressure 0.825544 \n", + "Percent_Person_WithMentalHealthNotGood 0.735612 \n", + "Percent_Person_WithHighCholesterol 0.299001 \n", + "Percent_Person_Obesity 1.000000 " + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# calculate correlation\n", + "df[stat_vars_to_query].corr()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XHsUlBdXNC1X" + }, + "source": [ + "\n", + "**2.1B)** Explain why the diagonals of the matrix have the value 1.\n", + "\n", + "**2.1C)** What is the correlation coefficient between `Count_Person` and `Percent_Person_Obesity`? What does the correlation coefficient imply about the relationship between population and obesity rate?\n", + "\n", + "**2.1D)** What is the correlation coefficient between `Percent_Person_PhysicalInactivity` and `Percent_Person_Obesity`? What does the correlation coefficient imply about the relationship between physical inactivity and obesity rate?\n", + "\n", + "**2.1E)** In general, would you prefer to include features that correlate strongly with the dependent variable, or features with no correlation in a regression model?\n", + "\n", + "**2.1F)** You find a new feature with correlation coefficient $r=-0.97$ between it and obesity rates. Would it be a good idea to add this new feature to your model?\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HXG9__t8YAqy" + }, + "source": [ + "### 2.2) $R^2$ score\n", + "\n", + "To quantify how predictive a linear regression model is overall, we can use the [coefficient of determination](https://en.wikipedia.org/wiki/Coefficient_of_determination), $R^2$ (pronounced \"R squared\").\n", + "\n", + "Mathematically, the $R^2$ score is defined as:\n", + "\n", + "$$S_{residuals} = \\sum_i{(y_i - f_i)^2} \\\\\n", + "S_{total} = \\sum_i{(y_i - \\bar{y})^2}\\\\\n", + "R^2 = 1 - \\frac{S_{residuals}}{S_{total}}$$\n", + "\n", + "where $y_i$s are the actual dependent variable values, $f_i$ are the predicted dependent variable values, and $\\bar{y}$ is the average of the $y_i$'s.\n", + "\n", + "Conceptually, the $R^2$ score is a measure of explained variance. If $R^2=0.75$, that means that 75% of the variance in the dependent variable has been accounted for by our model, while 25% of the remaining variability has not.\n", + "\n", + "**2.2A)** Based on the mathematic definition, what is the range of values possible for R^2?\n", + "\n", + "**2.2B)** Come up with a situation (e.g. what would the data look like) where:\n", + "\n", + "A) $R^2 = 1.0$\n", + "\n", + "B) $R^2 = 0.0$\n", + "\n", + "Let's now analyze what the $R^2$ value is for our model." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-rnvtExD5_U1", + "outputId": "51ee0f86-162f-4542-eeb6-809deb556b88" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model R^2 = 0.7577718062114178\n" + ] + } + ], + "source": [ + "# calculate R^2\n", + "print(\"Model R^2 =\", results.rsquared)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "k_L-1iVbXKtc" + }, + "source": [ + "**2.2C)** Is the model's $R^2$ a \"good\" score?\n", + "\n", + "**2.2D)** Can you think of any ways we can change our model that would improve the $R^2$ score?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "t_Eieuedizkv" + }, + "source": [ + "### 2.3) Adjusted $R^2$\n", + "\n", + "There's an issue with $R^2$ scores that one needs to be aware of when working with multiple independent variables: namely, that the number of independent variables used can affect the $R^2$ score.\n", + "\n", + "Let's see this in practice. Let's create a new dataframe with an extra 100 dummy variables (randomly sampled from a 0-mean 1-variance normal distribution) tacked on." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 510 + }, + "id": "iF9B9dPJ1P8G", + "outputId": "66d7dae3-11cb-4b46-a15e-846812c9f5b7" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "variable_name": "df_padded" + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
City NameCount_PersonPercent_Person_ObesityPercent_Person_PhysicalInactivityPercent_Person_SleepLessThan7HoursPercent_Person_WithHighBloodPressurePercent_Person_WithHighCholesterolPercent_Person_WithMentalHealthNotGoodRandom Variable 0Random Variable 1...Random Variable 90Random Variable 91Random Variable 92Random Variable 93Random Variable 94Random Variable 95Random Variable 96Random Variable 97Random Variable 98Random Variable 99
place
geoId/0103076Auburn82025.033.023.636.034.330.617.8-1.5643120.288515...0.7625210.251051-0.697129-1.6971950.399706-0.5571550.4447601.7876420.3404101.535658
geoId/0107000Birmingham196644.044.932.942.945.031.619.7-0.5801590.849181...0.2158431.553184-1.7661151.1529410.7124260.9366600.576485-0.127241-0.5438451.536037
geoId/0135896Hoover92448.032.519.733.632.631.015.4-0.322616-1.748737...2.0361160.993741-1.786077-0.264808-1.922278-1.227397-1.7237620.847944-0.446194-0.320127
geoId/0137000Huntsville225564.037.524.040.036.531.618.00.768514-0.534476...0.9500640.7303440.0074713.5141800.145648-1.2544480.275048-1.241024-0.1635770.376057
geoId/0150000Mobile182595.044.228.743.439.832.519.90.2072171.028760...-0.7755071.338210-0.395432-0.830337-0.558512-0.367606-1.049303-3.161325-0.5866680.934307
..................................................................
geoId/5531000Green Bay105744.038.926.733.128.130.717.9-0.104983-0.856795...-0.945322-0.219595-2.1131650.6143790.110795-0.2500100.926896-0.526254-0.359181-1.424956
geoId/5539225Kenosha98211.043.723.836.629.930.018.6-0.3553490.348573...-0.7895750.590118-0.1935870.5021880.124404-0.376209-0.3313310.6971651.029427-1.143744
geoId/5548000Madison280305.032.118.729.926.628.515.6-0.6481190.025662...-0.1519650.835380-1.3812860.3031140.540398-0.3599880.0079040.010788-0.2760710.979319
geoId/5553000Milwaukee561385.043.428.840.036.730.119.0-0.154089-0.339432...2.2554581.3578280.6927940.9240340.951688-0.0710960.0975820.952135-1.019633-0.778193
geoId/5566000Racine76602.042.928.239.232.332.018.41.638922-0.543906...0.370553-0.6062731.0666600.0221320.0391351.102639-0.438601-1.7446471.2452142.216294
\n", + "

498 rows × 108 columns

\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + " City Name Count_Person Percent_Person_Obesity \\\n", + "place \n", + "geoId/0103076 Auburn 82025.0 33.0 \n", + "geoId/0107000 Birmingham 196644.0 44.9 \n", + "geoId/0135896 Hoover 92448.0 32.5 \n", + "geoId/0137000 Huntsville 225564.0 37.5 \n", + "geoId/0150000 Mobile 182595.0 44.2 \n", + "... ... ... ... \n", + "geoId/5531000 Green Bay 105744.0 38.9 \n", + "geoId/5539225 Kenosha 98211.0 43.7 \n", + "geoId/5548000 Madison 280305.0 32.1 \n", + "geoId/5553000 Milwaukee 561385.0 43.4 \n", + "geoId/5566000 Racine 76602.0 42.9 \n", + "\n", + " Percent_Person_PhysicalInactivity \\\n", + "place \n", + "geoId/0103076 23.6 \n", + "geoId/0107000 32.9 \n", + "geoId/0135896 19.7 \n", + "geoId/0137000 24.0 \n", + "geoId/0150000 28.7 \n", + "... ... \n", + "geoId/5531000 26.7 \n", + "geoId/5539225 23.8 \n", + "geoId/5548000 18.7 \n", + "geoId/5553000 28.8 \n", + "geoId/5566000 28.2 \n", + "\n", + " Percent_Person_SleepLessThan7Hours \\\n", + "place \n", + "geoId/0103076 36.0 \n", + "geoId/0107000 42.9 \n", + "geoId/0135896 33.6 \n", + "geoId/0137000 40.0 \n", + "geoId/0150000 43.4 \n", + "... ... \n", + "geoId/5531000 33.1 \n", + "geoId/5539225 36.6 \n", + "geoId/5548000 29.9 \n", + "geoId/5553000 40.0 \n", + "geoId/5566000 39.2 \n", + "\n", + " Percent_Person_WithHighBloodPressure \\\n", + "place \n", + "geoId/0103076 34.3 \n", + "geoId/0107000 45.0 \n", + "geoId/0135896 32.6 \n", + "geoId/0137000 36.5 \n", + "geoId/0150000 39.8 \n", + "... ... \n", + "geoId/5531000 28.1 \n", + "geoId/5539225 29.9 \n", + "geoId/5548000 26.6 \n", + "geoId/5553000 36.7 \n", + "geoId/5566000 32.3 \n", + "\n", + " Percent_Person_WithHighCholesterol \\\n", + "place \n", + "geoId/0103076 30.6 \n", + "geoId/0107000 31.6 \n", + "geoId/0135896 31.0 \n", + "geoId/0137000 31.6 \n", + "geoId/0150000 32.5 \n", + "... ... \n", + "geoId/5531000 30.7 \n", + "geoId/5539225 30.0 \n", + "geoId/5548000 28.5 \n", + "geoId/5553000 30.1 \n", + "geoId/5566000 32.0 \n", + "\n", + " Percent_Person_WithMentalHealthNotGood Random Variable 0 \\\n", + "place \n", + "geoId/0103076 17.8 -1.564312 \n", + "geoId/0107000 19.7 -0.580159 \n", + "geoId/0135896 15.4 -0.322616 \n", + "geoId/0137000 18.0 0.768514 \n", + "geoId/0150000 19.9 0.207217 \n", + "... ... ... \n", + "geoId/5531000 17.9 -0.104983 \n", + "geoId/5539225 18.6 -0.355349 \n", + "geoId/5548000 15.6 -0.648119 \n", + "geoId/5553000 19.0 -0.154089 \n", + "geoId/5566000 18.4 1.638922 \n", + "\n", + " Random Variable 1 ... Random Variable 90 Random Variable 91 \\\n", + "place ... \n", + "geoId/0103076 0.288515 ... 0.762521 0.251051 \n", + "geoId/0107000 0.849181 ... 0.215843 1.553184 \n", + "geoId/0135896 -1.748737 ... 2.036116 0.993741 \n", + "geoId/0137000 -0.534476 ... 0.950064 0.730344 \n", + "geoId/0150000 1.028760 ... -0.775507 1.338210 \n", + "... ... ... ... ... \n", + "geoId/5531000 -0.856795 ... -0.945322 -0.219595 \n", + "geoId/5539225 0.348573 ... -0.789575 0.590118 \n", + "geoId/5548000 0.025662 ... -0.151965 0.835380 \n", + "geoId/5553000 -0.339432 ... 2.255458 1.357828 \n", + "geoId/5566000 -0.543906 ... 0.370553 -0.606273 \n", + "\n", + " Random Variable 92 Random Variable 93 Random Variable 94 \\\n", + "place \n", + "geoId/0103076 -0.697129 -1.697195 0.399706 \n", + "geoId/0107000 -1.766115 1.152941 0.712426 \n", + "geoId/0135896 -1.786077 -0.264808 -1.922278 \n", + "geoId/0137000 0.007471 3.514180 0.145648 \n", + "geoId/0150000 -0.395432 -0.830337 -0.558512 \n", + "... ... ... ... \n", + "geoId/5531000 -2.113165 0.614379 0.110795 \n", + "geoId/5539225 -0.193587 0.502188 0.124404 \n", + "geoId/5548000 -1.381286 0.303114 0.540398 \n", + "geoId/5553000 0.692794 0.924034 0.951688 \n", + "geoId/5566000 1.066660 0.022132 0.039135 \n", + "\n", + " Random Variable 95 Random Variable 96 Random Variable 97 \\\n", + "place \n", + "geoId/0103076 -0.557155 0.444760 1.787642 \n", + "geoId/0107000 0.936660 0.576485 -0.127241 \n", + "geoId/0135896 -1.227397 -1.723762 0.847944 \n", + "geoId/0137000 -1.254448 0.275048 -1.241024 \n", + "geoId/0150000 -0.367606 -1.049303 -3.161325 \n", + "... ... ... ... \n", + "geoId/5531000 -0.250010 0.926896 -0.526254 \n", + "geoId/5539225 -0.376209 -0.331331 0.697165 \n", + "geoId/5548000 -0.359988 0.007904 0.010788 \n", + "geoId/5553000 -0.071096 0.097582 0.952135 \n", + "geoId/5566000 1.102639 -0.438601 -1.744647 \n", + "\n", + " Random Variable 98 Random Variable 99 \n", + "place \n", + "geoId/0103076 0.340410 1.535658 \n", + "geoId/0107000 -0.543845 1.536037 \n", + "geoId/0135896 -0.446194 -0.320127 \n", + "geoId/0137000 -0.163577 0.376057 \n", + "geoId/0150000 -0.586668 0.934307 \n", + "... ... ... \n", + "geoId/5531000 -0.359181 -1.424956 \n", + "geoId/5539225 1.029427 -1.143744 \n", + "geoId/5548000 -0.276071 0.979319 \n", + "geoId/5553000 -1.019633 -0.778193 \n", + "geoId/5566000 1.245214 2.216294 \n", + "\n", + "[498 rows x 108 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Pad our dataframe with more random variables\n", + "num_rows = len(df.index)\n", + "num_new_columns = 100\n", + "random_data = np.random.normal(loc=0, scale=1, size=(num_rows, num_new_columns))\n", + "new_column_names = [f\"Random Variable {i}\" for i in range(num_new_columns)]\n", + "random_data_df = pd.DataFrame(\n", + " random_data,\n", + " columns=new_column_names,\n", + " index=df.index\n", + ")\n", + "df_padded = pd.concat([df, random_data_df], axis=1)\n", + "display(df_padded)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Q5f22xUmvoN_" + }, + "source": [ + "Now let's fit a new model to the data and compare R^2 scores." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "rn57oEF82dju", + "outputId": "27dd8be5-fae5-45b4-a31f-5858a087d3d5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original Model R^2 = 0.7577718062114178\n", + "Padded Model R^2 = 0.7988444670439291\n" + ] + } + ], + "source": [ + "# New R^2\n", + "y_padded = df_padded[dep_var].to_numpy().reshape(-1, 1)\n", + "x_padded = df_padded.loc[:, ~df_padded.columns.isin([dep_var, \"City Name\"])]\n", + "x_padded = sm.add_constant(x_padded)\n", + "\n", + "padded_model = sm.OLS(y_padded, x_padded)\n", + "padded_results = padded_model.fit()\n", + "\n", + "print(\"Original Model R^2 = \", results.rsquared)\n", + "print(\"Padded Model R^2 =\", padded_results.rsquared)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "j-j4IbOtwFj8" + }, + "source": [ + "**2.3A)** Which model had a better $R^2$ score?\n", + "\n", + "**2.3B)** Think about the variables used in each model. Should one model be much more predictive than another?\n", + "\n", + "**2.3B)** In general, how would you expect $R^2$ to change as we increase the number of independent variables?\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2Ipg_orhxOF_" + }, + "source": [ + "So how do we fix this? We can adjust our $R^2$ metric to account for the number of variables. The most popular way to defined the _**adjusted $R^2$**_ score is as follows:\n", + "\n", + "$$R^{2}_{adj}=1-(1-R^{2}){n-1 \\over n-p-1}$$\n", + "\n", + "where $n$ is the number of data points and $p$ is the number of independent variables.\n", + "\n", + "Now let's compare the adjusted $R^2$ of our models." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7pZ9_NmZisGi", + "outputId": "bfa5cddd-dddf-45c9-8082-ab58dbe5c286" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original Model Adjusted R^2 = 0.7548117875500502\n", + "Padded Model Adjusted R^2 = 0.7443112535059662\n" + ] + } + ], + "source": [ + "# Adjusted R^2\n", + "print(\"Original Model Adjusted R^2 = \", results.rsquared_adj)\n", + "print(\"Padded Model Adjusted R^2 =\", padded_results.rsquared_adj)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qU9VwLsNHcKD" + }, + "source": [ + "**2.3D)** Which model had a better adjusted $R^2$ score?\n", + "\n", + "**2.3E)** When would you prefer to use adjusted R^2 over R^2 to evaluate model fit?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1tiopX7PWHiu" + }, + "source": [ + "## 3) Interpreting regression models\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qC7aC0y-O3_D" + }, + "source": [ + "### 3.1) Analyzing weights and intercepts\n", + "The parameters of the regression model itself can also yield important insights.\n", + "\n", + "Run the following code box to display the weights and intercept of our original model." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 304 + }, + "id": "_y0xeWysPIm6", + "outputId": "6ede53a7-bbc0-474e-bc4a-4567735c8d75" + }, + "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", + "
0
const-0.19367
Count_Person-0.00000
Percent_Person_PhysicalInactivity0.30528
Percent_Person_SleepLessThan7Hours-0.12455
Percent_Person_WithHighBloodPressure0.75717
Percent_Person_WithHighCholesterol-0.13520
Percent_Person_WithMentalHealthNotGood0.69012
\n", + "

" + ], + "text/plain": [ + "const -0.19367\n", + "Count_Person -0.00000\n", + "Percent_Person_PhysicalInactivity 0.30528\n", + "Percent_Person_SleepLessThan7Hours -0.12455\n", + "Percent_Person_WithHighBloodPressure 0.75717\n", + "Percent_Person_WithHighCholesterol -0.13520\n", + "Percent_Person_WithMentalHealthNotGood 0.69012\n", + "dtype: float64" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Display weights/coefficients\n", + "display(results.params.round(5))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dvpGBohWPymA" + }, + "source": [ + "**3.1A)** What is the intercept of our model? What are its units?\n", + "\n", + "**3.1B)** What are the units on each of the model weights (aka coefficients)?\n", + "\n", + "**3.1C)** Which variables matter most to our model?\n", + "\n", + "**3.1D)** In words, describe what a weight/coefficient in a linear regression means.\n", + "\n", + "**3.1E)** Our model is used to generate a predicted obesity rate for a fictional city named Dataopolis. If we increased `Percent_Person_WithMentalHealthNotGood` for Dataopolis by 1 unit, _while keeping the values for all remaining variables constant_, by how much would we expect our predicted obesity rate to change?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2ZoaATgWh-fR" + }, + "source": [ + "### 3.2) The effect of correlated variables\n", + "\n", + "When interpreting weights, one thing to look out for is if we have independent variables that are highly correlated with each other.\n", + "\n", + "Let's illustrate why this might be a problem, by adding a variable that is correlated with one of the existing variables" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 845 + }, + "id": "uP4XtXkfLB1U", + "outputId": "f55a1573-1c38-49ad-ea26-9675b434e7aa" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "New dataframe to fit:\n" + ] + }, + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "summary": "{\n \"name\": \"correlated_df\",\n \"rows\": 498,\n \"fields\": [\n {\n \"column\": \"place\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 498,\n \"samples\": [\n \"geoId/5363000\",\n \"geoId/0639892\",\n \"geoId/1714351\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"City Name\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 475,\n \"samples\": [\n \"Memphis\",\n \"Plano\",\n \"Avondale\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Count_Person\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 471628.1194557695,\n \"min\": 76212.0,\n \"max\": 8258035.0,\n \"num_unique_values\": 498,\n \"samples\": [\n 755078.0,\n 78135.0,\n 81004.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_Obesity\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 6.3675302626575006,\n \"min\": 14.1,\n \"max\": 48.9,\n \"num_unique_values\": 220,\n \"samples\": [\n 33.4,\n 41.6,\n 23.2\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_PhysicalInactivity\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 5.79401923130349,\n \"min\": 11.2,\n \"max\": 41.8,\n \"num_unique_values\": 209,\n \"samples\": [\n 25.0,\n 39.5,\n 18.4\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_SleepLessThan7Hours\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 4.3313227959895455,\n \"min\": 24.9,\n \"max\": 49.5,\n \"num_unique_values\": 166,\n \"samples\": [\n 42.5,\n 25.6,\n 28.4\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithHighBloodPressure\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 4.56550336745893,\n \"min\": 21.3,\n \"max\": 45.7,\n \"num_unique_values\": 170,\n \"samples\": [\n 40.3,\n 25.6,\n 41.2\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithHighCholesterol\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2.089525781869934,\n \"min\": 24.6,\n \"max\": 35.6,\n \"num_unique_values\": 95,\n \"samples\": [\n 25.9,\n 34.1,\n 27.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Percent_Person_WithMentalHealthNotGood\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2.1019573952670365,\n \"min\": 11.5,\n \"max\": 23.3,\n \"num_unique_values\": 103,\n \"samples\": [\n 15.8,\n 16.3,\n 12.7\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Correlated Variable\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2.2936580170071315,\n \"min\": 9.748686615105605,\n \"max\": 23.243226154344537,\n \"num_unique_values\": 498,\n \"samples\": [\n 16.440967097355323,\n 17.12077873386613,\n 17.01999484946955\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}", + "type": "dataframe", + "variable_name": "correlated_df" + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
variableCity NameCount_PersonPercent_Person_ObesityPercent_Person_PhysicalInactivityPercent_Person_SleepLessThan7HoursPercent_Person_WithHighBloodPressurePercent_Person_WithHighCholesterolPercent_Person_WithMentalHealthNotGoodCorrelated Variable
place
geoId/0103076Auburn82025.033.023.636.034.330.617.818.761300
geoId/0107000Birmingham196644.044.932.942.945.031.619.717.655787
geoId/0135896Hoover92448.032.519.733.632.631.015.414.736255
geoId/0137000Huntsville225564.037.524.040.036.531.618.016.549451
geoId/0150000Mobile182595.044.228.743.439.832.519.920.277958
..............................
geoId/5531000Green Bay105744.038.926.733.128.130.717.918.645080
geoId/5539225Kenosha98211.043.723.836.629.930.018.617.067335
geoId/5548000Madison280305.032.118.729.926.628.515.615.665917
geoId/5553000Milwaukee561385.043.428.840.036.730.119.019.073143
geoId/5566000Racine76602.042.928.239.232.332.018.417.106196
\n", + "

498 rows × 9 columns

\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + " \n", + " \n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "text/plain": [ + "variable City Name Count_Person Percent_Person_Obesity \\\n", + "place \n", + "geoId/0103076 Auburn 82025.0 33.0 \n", + "geoId/0107000 Birmingham 196644.0 44.9 \n", + "geoId/0135896 Hoover 92448.0 32.5 \n", + "geoId/0137000 Huntsville 225564.0 37.5 \n", + "geoId/0150000 Mobile 182595.0 44.2 \n", + "... ... ... ... \n", + "geoId/5531000 Green Bay 105744.0 38.9 \n", + "geoId/5539225 Kenosha 98211.0 43.7 \n", + "geoId/5548000 Madison 280305.0 32.1 \n", + "geoId/5553000 Milwaukee 561385.0 43.4 \n", + "geoId/5566000 Racine 76602.0 42.9 \n", + "\n", + "variable Percent_Person_PhysicalInactivity \\\n", + "place \n", + "geoId/0103076 23.6 \n", + "geoId/0107000 32.9 \n", + "geoId/0135896 19.7 \n", + "geoId/0137000 24.0 \n", + "geoId/0150000 28.7 \n", + "... ... \n", + "geoId/5531000 26.7 \n", + "geoId/5539225 23.8 \n", + "geoId/5548000 18.7 \n", + "geoId/5553000 28.8 \n", + "geoId/5566000 28.2 \n", + "\n", + "variable Percent_Person_SleepLessThan7Hours \\\n", + "place \n", + "geoId/0103076 36.0 \n", + "geoId/0107000 42.9 \n", + "geoId/0135896 33.6 \n", + "geoId/0137000 40.0 \n", + "geoId/0150000 43.4 \n", + "... ... \n", + "geoId/5531000 33.1 \n", + "geoId/5539225 36.6 \n", + "geoId/5548000 29.9 \n", + "geoId/5553000 40.0 \n", + "geoId/5566000 39.2 \n", + "\n", + "variable Percent_Person_WithHighBloodPressure \\\n", + "place \n", + "geoId/0103076 34.3 \n", + "geoId/0107000 45.0 \n", + "geoId/0135896 32.6 \n", + "geoId/0137000 36.5 \n", + "geoId/0150000 39.8 \n", + "... ... \n", + "geoId/5531000 28.1 \n", + "geoId/5539225 29.9 \n", + "geoId/5548000 26.6 \n", + "geoId/5553000 36.7 \n", + "geoId/5566000 32.3 \n", + "\n", + "variable Percent_Person_WithHighCholesterol \\\n", + "place \n", + "geoId/0103076 30.6 \n", + "geoId/0107000 31.6 \n", + "geoId/0135896 31.0 \n", + "geoId/0137000 31.6 \n", + "geoId/0150000 32.5 \n", + "... ... \n", + "geoId/5531000 30.7 \n", + "geoId/5539225 30.0 \n", + "geoId/5548000 28.5 \n", + "geoId/5553000 30.1 \n", + "geoId/5566000 32.0 \n", + "\n", + "variable Percent_Person_WithMentalHealthNotGood Correlated Variable \n", + "place \n", + "geoId/0103076 17.8 18.761300 \n", + "geoId/0107000 19.7 17.655787 \n", + "geoId/0135896 15.4 14.736255 \n", + "geoId/0137000 18.0 16.549451 \n", + "geoId/0150000 19.9 20.277958 \n", + "... ... ... \n", + "geoId/5531000 17.9 18.645080 \n", + "geoId/5539225 18.6 17.067335 \n", + "geoId/5548000 15.6 15.665917 \n", + "geoId/5553000 19.0 19.073143 \n", + "geoId/5566000 18.4 17.106196 \n", + "\n", + "[498 rows x 9 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Correlated Model Weights and Intercept:\n" + ] + }, + { + "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", + "
0
const-0.28192
Count_Person-0.00000
Percent_Person_PhysicalInactivity0.30604
Percent_Person_SleepLessThan7Hours-0.12529
Percent_Person_WithHighBloodPressure0.75756
Percent_Person_WithHighCholesterol-0.13345
Percent_Person_WithMentalHealthNotGood0.55372
Correlated Variable0.13921
\n", + "

" + ], + "text/plain": [ + "const -0.28192\n", + "Count_Person -0.00000\n", + "Percent_Person_PhysicalInactivity 0.30604\n", + "Percent_Person_SleepLessThan7Hours -0.12529\n", + "Percent_Person_WithHighBloodPressure 0.75756\n", + "Percent_Person_WithHighCholesterol -0.13345\n", + "Percent_Person_WithMentalHealthNotGood 0.55372\n", + "Correlated Variable 0.13921\n", + "dtype: float64" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# New variable correlated with Percent_Person_WithMentalHealthNotGood\n", + "correlated_df = df.copy()\n", + "target_var = \"Percent_Person_WithMentalHealthNotGood\"\n", + "noise = np.random.normal(size=(len(correlated_df.index),))\n", + "correlated_df[\"Correlated Variable\"] = correlated_df[target_var] + noise\n", + "\n", + "# show new data frame\n", + "print(\"New dataframe to fit:\")\n", + "display(correlated_df)\n", + "\n", + "# Create a new model\n", + "y_corr = correlated_df[dep_var].to_numpy().reshape(-1, 1)\n", + "x_corr = correlated_df.loc[:, ~correlated_df.columns.isin([dep_var, \"City Name\"])]\n", + "x_corr = sm.add_constant(x_corr)\n", + "\n", + "correlated_model = sm.OLS(y_corr, x_corr)\n", + "correlated_results = correlated_model.fit()\n", + "\n", + "print(\"Correlated Model Weights and Intercept:\")\n", + "display(correlated_results.params.round(5))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HEHJWPxibiY3" + }, + "source": [ + "**3.2A)** Compare the new weights of the correlated model with the weights of our original model. What happened to the weights corresponding to `Percent_Person_WithMentalHealthNotGood`?\n", + "\n", + "**3.2B)** Thinking back to your answers for Q3.1C-E, how might correlated variables affect the interpretation of model weights?" + ] + } + ], + "metadata": { + "colab": { + "include_colab_link": true, + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 00000000..df85079d --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,109 @@ +[project] +name = "datacommons-client" +dynamic = ["version"] +description = "A library to access Data Commons Python API." +readme = "datacommons_client/README.md" +authors = [ + { name = "datacommons.org", email = "support@datacommons.org" }, + { name = "one.org", email= "data@one.org"} +] +maintainers = [ + { name = "datacommons.org", email = "support@datacommons.org" } +] +license = { file = "LICENSE" } +dependencies = [ +"requests>=2.32", +"typing_extensions", +"pydantic>=2.11" +] +requires-python = ">=3.10" +keywords = ["data commons", "api", "data", "development"] +classifiers = [ + "Intended Audience :: Developers", + "License :: OSI Approved :: Apache Software License", + "Programming Language :: Python", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: Implementation :: CPython", + "Topic :: Software Development" +] +urls = { "Homepage" = "https://github.com/datacommonsorg/api-python" } + +[project.optional-dependencies] +pandas = ["pandas"] +dev = [ + "pytest", + "isort", + "yapf", + "mock", + "hatch" +] + +[tool.hatch.version] +path = "datacommons_client/__init__.py" + + +[tool.hatch.build.targets.sdist] +include = [ + "datacommons_client", + "README.md", + "LICENSE", + "CHANGELOG.md" +] + +[tool.hatch.build.targets.wheel] +include = [ + "datacommons_client" +] + +[tool.hatch.envs.default] +dependencies = [ + "pytest", + "isort", + "yapf", + "hatch", +] + +[tool.hatch.envs.test] +dependencies = [ + "pytest", + "mock", + "pandas", + "isort", + "yapf" +] + + +[tool.hatch.envs.test.scripts] +setup = "./run_test.sh -s" +all = "./run_test.sh -a" +python = "./run_test.sh -p" +lint = "./run_test.sh -l" + +[tool.hatch.envs.lint] +dependencies = [ + "isort", + "yapf" +] + +[tool.hatch.envs.lint.scripts] +check = "./run_test.sh -l" +format = "./run_test.sh -f" + +[tool.hatch.envs.release] +dependencies = [ + "twine" +] + +[tool.hatch.envs.release.scripts] +localtest = "hatch build && twine check dist/*" +testpypi = "hatch build && twine upload --repository testpypi dist/*" +pypi = "hatch build && twine upload dist/*" +tag = "git commit -am 'Bump version to {version}' && git tag v{version}" + + +[build-system] +requires = ["hatchling"] +build-backend = "hatchling.build" diff --git a/requirements.txt b/requirements.txt index 35bbdfec..f92a6667 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,8 @@ -six -pytest +isort==5.13.2 mock -pandas \ No newline at end of file +pandas +pytest +requests==2.32.0 +typing_extensions==4.12.2 +yapf==0.40.2 +pydantic>=2.11 \ No newline at end of file diff --git a/run_test.sh b/run_test.sh new file mode 100755 index 00000000..b473b38a --- /dev/null +++ b/run_test.sh @@ -0,0 +1,109 @@ +#!/bin/bash +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +set -e # Immediately exit with failure if any command fails. + +YAPF_STYLE='{based_on_style: google, indent_width: 2}' +FORMAT_INCLUDE_PATHS="datacommons/ datacommons_client/ datacommons_pandas/" +FORMAT_EXCLUDE_PATH="**/.env/**" + +function setup_python { + python3 -m pip install --upgrade pip hatch + # here temporarily while there is an incompatibility with hatch and the newest click version + # see https://github.com/pypa/hatch/pull/2051 for status updates from Hatch + python3 -m pip uninstall uninstall click -y + python3 -m pip install click==8.2.1 + hatch env create +} + +function run_py_test { + pytest -vv +} + +function run_yapf { + EXTRA_ARGS=$@ + yapf $EXTRA_ARGS --recursive --parallel --style="$YAPF_STYLE" \ + --exclude="$FORMAT_EXCLUDE_PATH" $FORMAT_INCLUDE_PATHS +} + +function run_isort { + EXTRA_ARGS=$@ + isort $EXTRA_ARGS --profile=google --skip-glob="$FORMAT_EXCLUDE_PATH" \ + $FORMAT_INCLUDE_PATHS +} + +function run_lint_test { + if ! run_yapf --diff; then + echo "Fix lint errors by running: ./run_test.sh -f" + exit 1 + fi + if ! run_isort --check-only; then + echo "Fix Python import sort orders by running ./run_test.sh -f" + exit 1 + fi + echo "Python style checks passed." +} + +function run_lint_fix { + run_yapf --in-place + run_isort +} + +function run_all_tests { + run_py_test + run_lint_test +} + +function help { + echo "Usage: $0 -asplf" + echo "-a Run all tests" + echo "-s Set up python environment" + echo "-p Run python tests" + echo "-l Run lint tests" + echo "-f Fix lint" + exit 1 +} + +while getopts asplf OPTION; do + case $OPTION in + a) + echo -e "### Running all tests" + run_all_tests + ;; + s) + echo -e "### Setting up python environment" + setup_python + ;; + p) + echo -e "### Running python tests" + run_py_test + ;; + l) + echo -e "### Running lint tests" + run_lint_test + ;; + f) + echo -e "### Fix lint errors" + run_lint_fix + ;; + *) + help + esac +done + +if [ $OPTIND -eq 1 ] +then + help +fi diff --git a/run_tests_local.sh b/run_tests_local.sh deleted file mode 100755 index 9cf899ad..00000000 --- a/run_tests_local.sh +++ /dev/null @@ -1,33 +0,0 @@ -#!/bin/bash -# Copyright 2020 Google LLC -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - - -python3 -m venv .env -source .env/bin/activate - -pip3 install -r requirements.txt -python3 -m pytest - -deactivate - - -python2 -m venv .env -source .env/bin/activate - -pip2 install -r requirements.txt -python2 -m pytest - -deactivate - diff --git a/setup_datacommons.py b/setup_datacommons.py deleted file mode 100644 index f986ab51..00000000 --- a/setup_datacommons.py +++ /dev/null @@ -1,62 +0,0 @@ -# Copyright 2017 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -"""Build and distribute the datacommons package to PyPI.""" -from setuptools import setup - -with open('README.md', 'r') as fh: - long_description = fh.read() - -# Package metadata. -NAME = 'datacommons' -DESCRIPTION = 'A library to access Data Commons Python API.' -URL = 'https://github.com/datacommonsorg/api-python' -EMAIL = 'support@datacommons.org' -AUTHOR = 'datacommons.org' -REQUIRES_PYTHON = '>=2.7' -VERSION = '1.4.3' - -REQUIRED = [ - 'six', -] - -PACKAGES = ['datacommons'] -PACKAGE_DIR = {'datacommons': 'datacommons'} - -setup( - name=NAME, - version=VERSION, - description=DESCRIPTION, - long_description=long_description, - long_description_content_type='text/markdown', - author=AUTHOR, - author_email=EMAIL, - maintainer=AUTHOR, - maintainer_email=EMAIL, - python_requires=REQUIRES_PYTHON, - url=URL, - packages=PACKAGES, - package_dir=PACKAGE_DIR, - install_requires=REQUIRED, - include_package_data=True, - license='Apache 2.0', - classifiers=[ - 'Intended Audience :: Developers', - 'License :: OSI Approved :: Apache Software License', - 'Programming Language :: Python', - 'Programming Language :: Python :: 2.7', - 'Programming Language :: Python :: 3.6', - 'Programming Language :: Python :: Implementation :: CPython', - 'Topic :: Software Development', - ], -) diff --git a/setup_datacommons_pandas.py b/setup_datacommons_pandas.py deleted file mode 100644 index 584d39fb..00000000 --- a/setup_datacommons_pandas.py +++ /dev/null @@ -1,62 +0,0 @@ -# Copyright 2020 Google Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -"""Build and distribute the datacommons_pandas package to PyPI.""" -from setuptools import setup - -with open('datacommons_pandas/README.md', 'r') as fh: - long_description = fh.read() - -# Package metadata. -NAME = 'datacommons_pandas' -DESCRIPTION = 'A library to create pandas objects using the Data Commons Python API.' -URL = 'https://github.com/datacommonsorg/api-python' -EMAIL = 'support@datacommons.org' -AUTHOR = 'datacommons.org' -REQUIRES_PYTHON = '>=2.7' -VERSION = '0.0.3' - -REQUIRED = [ - 'six', - 'pandas', -] - -PACKAGES = ['datacommons_pandas'] -PACKAGE_DIR = {'datacommons_pandas': 'datacommons_pandas'} -setup( - name=NAME, - version=VERSION, - description=DESCRIPTION, - long_description=long_description, - long_description_content_type='text/markdown', - author=AUTHOR, - author_email=EMAIL, - maintainer=AUTHOR, - maintainer_email=EMAIL, - python_requires=REQUIRES_PYTHON, - url=URL, - packages=PACKAGES, - package_dir=PACKAGE_DIR, - install_requires=REQUIRED, - include_package_data=True, - license='Apache 2.0', - classifiers=[ - 'Intended Audience :: Developers', - 'License :: OSI Approved :: Apache Software License', - 'Programming Language :: Python', - 'Programming Language :: Python :: 2.7', - 'Programming Language :: Python :: 3.6', - 'Programming Language :: Python :: Implementation :: CPython', - 'Topic :: Software Development', - ], -)