diff --git a/Add Audio.ipynb b/Add Audio.ipynb new file mode 100644 index 000000000..f61681028 --- /dev/null +++ b/Add Audio.ipynb @@ -0,0 +1,68 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Generate a sound\n", + "import numpy as np\n", + "import IPython.display as ipd\n", + "from IPython.display import Audio\n", + "framerate = 44100\n", + "t = np.linspace(0,5,framerate*5)\n", + "data = np.sin(2*np.pi*220*t) + np.sin(2*np.pi*224*t)\n", + "Audio(data,rate=framerate)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "celltoolbar": "Raw Cell Format", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/01.03-Magic-Commands.ipynb b/notebooks/01.03-Magic-Commands.ipynb index 4a47b373a..b2dd79cd4 100644 --- a/notebooks/01.03-Magic-Commands.ipynb +++ b/notebooks/01.03-Magic-Commands.ipynb @@ -30,7 +30,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The previous two sections showed how IPython lets you use and explore Python efficiently and interactively.\n", + "This is a test for the special character ñ in markdown cell. The previous two sections showed how IPython lets you use and explore Python efficiently and interactively.\n", "Here we'll begin discussing some of the enhancements that IPython adds on top of the normal Python syntax.\n", "These are known in IPython as *magic commands*, and are prefixed by the ``%`` character.\n", "These magic commands are designed to succinctly solve various common problems in standard data analysis.\n", diff --git a/notebooks/02.00-Introduction-to-NumPy.ipynb b/notebooks/02.00-Introduction-to-NumPy.ipynb index 813b85ab4..d2f4e92c9 100644 --- a/notebooks/02.00-Introduction-to-NumPy.ipynb +++ b/notebooks/02.00-Introduction-to-NumPy.ipynb @@ -157,7 +157,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.6.8" } }, "nbformat": 4, diff --git a/notebooks/04.14-Visualization-With-Seaborn.ipynb b/notebooks/04.14-Visualization-With-Seaborn.ipynb index 652627b2a..d10e5a99d 100644 --- a/notebooks/04.14-Visualization-With-Seaborn.ipynb +++ b/notebooks/04.14-Visualization-With-Seaborn.ipynb @@ -6,7 +6,18 @@ "source": [ "\n", "\n", - "*This notebook contains an excerpt from the [Python Data Science Handbook](http://shop.oreilly.com/product/0636920034919.do) by Jake VanderPlas; the content is available [on GitHub](https://github.com/jakevdp/PythonDataScienceHandbook).*\n", + "*This notebook contains an excerpt from the [Python Data Science Handbook] (random addition) (http://shop.oreilly.com/product/0636920034919.do) by Jake VanderPlas; the content is available [on GitHub](https://github.com/jakevdp/PythonDataScienceHandbook).*\n", + "\n", + "**Changing Header and first row completely**\n", + "\n", + "| Change | header and | 1st | row | completely | for testing |\n", + "|----------|-------------|------|----------|-------------|------|\n", + "| the | colons | after | the header | row are | removed |\n", + "| col 2 is | centered | 12 | to fix | all the changes | in the table properly |\n", + "| col 3 is | right aligned | 1 | hence, we are testing | the table changes | here |\n", + "| col 1 is | left aligned | 1600 | It's weird | to write random | text\n", + "| col 2 is | centered | 12 | but it's 2020 | and I got | to do this | \n", + "| col 3 is | right aligned | 1 | Let's make | world a better place | peace\n", "\n", "*The text is released under the [CC-BY-NC-ND license](https://creativecommons.org/licenses/by-nc-nd/3.0/us/legalcode), and code is released under the [MIT license](https://opensource.org/licenses/MIT). If you find this content useful, please consider supporting the work by [buying the book](http://shop.oreilly.com/product/0636920034919.do)!*" ] @@ -16,7 +27,18 @@ "metadata": {}, "source": [ "\n", - "< [Geographic Data with Basemap](04.13-Geographic-Data-With-Basemap.ipynb) | [Contents](Index.ipynb) | [Further Resources](04.15-Further-Resources.ipynb) >" + "< [Geographic Data with Basemap](04.13-Geographic-Data-With-Basemap.ipynb) | [Contents](Index.ipynb) | [Further Resources](04.15-Further-Resources.ipynb) >\n", + "\n", + "**Additional Column in the middle**\n", + "\n", + "| Tables | Are | Cool | NEW COLUMN | Let us | test them | properly, shall we? |\n", + "|:----------:|:-------------:|:-------------:|:------:|:----------:|:-------------:|:------:|\n", + "| col 1 is | left aligned | 1600 | ADDING A | Still some | work to | be done |\n", + "| col 2 is | centered | 12 | COLUMN | to fix | all the changes | in the table properly |\n", + "| col 3 is | right aligned | 1 | FOR THE | hence, we are testing | the table changes | here |\n", + "| col 1 is | left aligned | 1600 | TESTING | It's weird | to write random | text\n", + "| col 2 is | centered | 12 | PURPOSE | but it's 2020 | and I got | to do this | \n", + "| col 3 is | right aligned | 1 | HERE ON OUT | Let's make | world a better place | peace" ] }, { @@ -33,6 +55,17 @@ "Matplotlib has proven to be an incredibly useful and popular visualization tool, but even avid users will admit it often leaves much to be desired.\n", "There are several valid complaints about Matplotlib that often come up:\n", "\n", + "**Small changes at multiple places**\n", + "\n", + "| Tables | Are | Cool | Let us | test them | properly, shall we? |\n", + "|:----------:|:-------------:|:------:|:----------:|:-------------:|:------:|\n", + "| col 1 is | right aligned | 1800 | Still some | work got to | be done |\n", + "| col 2 is | centered | 12 | to fix | all the changes | in the table properly |\n", + "| col 3 is | right aligned | 1 | hence, we are testing | the table changes | here |\n", + "| col 1 is | left aligned | 1600 | It's weird | to write random | text\n", + "| row 2 is | centered | 12 | but it is 2220 | and I got | to do this | \n", + "| col 3 is | right aligned | 1 | Let's make | world A better place | apple pie\n", + "\n", "- Prior to version 2.0, Matplotlib's defaults are not exactly the best choices. It was based off of MATLAB circa 1999, and this often shows.\n", "- Matplotlib's API is relatively low level. Doing sophisticated statistical visualization is possible, but often requires a *lot* of boilerplate code.\n", "- Matplotlib predated Pandas by more than a decade, and thus is not designed for use with Pandas ``DataFrame``s. In order to visualize data from a Pandas ``DataFrame``, you must extract each ``Series`` and often concatenate them together into the right format. It would be nicer to have a plotting library that can intelligently use the ``DataFrame`` labels in a plot.\n", @@ -51,7 +84,18 @@ "## Seaborn Versus Matplotlib\n", "\n", "Here is an example of a simple random-walk plot in Matplotlib, using its classic plot formatting and colors.\n", - "We start with the typical imports:" + "We start with the typical imports:\n", + "\n", + "**Remove 1st Column**\n", + "\n", + "Are | Cool | Let us | test them | properly, shall we? |\n", + "-------------:|:------:|:----------:|:-------------:|:------:|\n", + " left aligned | 1600 | Still some | work to | be done |\n", + " centered | 12 | to fix | all the changes | in the table properly |\n", + " right aligned | 1 | hence, we are testing | the table changes | here |\n", + " left aligned | 1600 | It's weird | to write random | text\n", + " centered | 12 | but it's 2020 | and I got | to do this | \n", + " right aligned | 1 | Let's make | world a better place | peace" ] }, { @@ -71,7 +115,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now we create some random walk data:" + "**First and last row removed**\n", + "\n", + "| Tables | Are | Cool | Let us | test them | properly, shall we? |\n", + "|:----------:|:-------------:|:------:|:----------:|:-------------:|:------:|\n", + "| col 2 is | centered | 12 | to fix | all the changes | in the table properly |\n", + "| col 3 is | right aligned | 1 | hence, we are testing | the table changes | here |\n", + "| col 1 is | left aligned | 1600 | It's weird | to write random | text\n", + "| col 2 is | centered | 12 | but it's 2020 | and I got | to do this | " ] }, { @@ -121,6 +172,18 @@ "source": [ "Although the result contains all the information we'd like it to convey, it does so in a way that is not all that aesthetically pleasing, and even looks a bit old-fashioned in the context of 21st-century data visualization.\n", "\n", + "**ADD ROW IN MIDDLE**\n", + "\n", + "| Tables | Are | Cool | Let us | test them | properly, shall we? |\n", + "|:----------:|:-------------:|:------:|:----------:|:-------------:|:------:|\n", + "| col 1 is | left aligned | 1600 | Still some | work to | be done |\n", + "| col 2 is | centered | 12 | to fix | all the changes | in the table properly |\n", + "| col 3 is | right aligned | 1 | hence, we are testing | the table changes | here |\n", + "| COL NEW | NEWLY ADDED | COLUMN | 2200 | TO THIS TABLE | IN THE MIDDLE |\n", + "| col 1 is | left aligned | 1600 | It's weird | to write random | text\n", + "| col 2 is | centered | 12 | but it's 2020 | and I got | to do this | \n", + "| col 3 is | right aligned | 1 | Let's make | world a better place | peace\n", + "\n", "Now let's take a look at how it works with Seaborn.\n", "As we will see, Seaborn has many of its own high-level plotting routines, but it can also overwrite Matplotlib's default parameters and in turn get even simple Matplotlib scripts to produce vastly superior output.\n", "We can set the style by calling Seaborn's ``set()`` method.\n", @@ -173,6 +236,18 @@ "Ah, much better!" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**DELETE TOP 2 AND BOTTOM 2 ROWS**\n", + "\n", + "| Tables | Are | Cool | Let us | test them | properly, shall we? |\n", + "|:----------:|:-------------:|:------:|:----------:|:-------------:|:------:|\n", + "| col 3 is | right aligned | 1 | hence, we are testing | the table changes | here |\n", + "| col 1 is | left aligned | 1600 | It's weird | to write random | text" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -181,6 +256,17 @@ "\n", "The main idea of Seaborn is that it provides high-level commands to create a variety of plot types useful for statistical data exploration, and even some statistical model fitting.\n", "\n", + "**DELETE FIRST 2 AND LAST 2 COLUMNS**\n", + "\n", + "| Cool | Let us |\n", + "|:------:|:----------:|\n", + "| 1600 | Still some |\n", + "| 12 | to fix |\n", + "| 1 | hence, we are testing |\n", + "| 1600 | It's weird |\n", + "| 12 | but it's 2020 |\n", + "| 1 | Let's make |\n", + "\n", "Let's take a look at a few of the datasets and plot types available in Seaborn. Note that all of the following *could* be done using raw Matplotlib commands (this is, in fact, what Seaborn does under the hood) but the Seaborn API is much more convenient." ] }, @@ -191,7 +277,14 @@ "### Histograms, KDE, and densities\n", "\n", "Often in statistical data visualization, all you want is to plot histograms and joint distributions of variables.\n", - "We have seen that this is relatively straightforward in Matplotlib:" + "We have seen that this is relatively straightforward in Matplotlib:\n", + "\n", + "**REPLACE ENTIRE TABLE**\n", + "\n", + "Markdown | Less | Pretty\n", + "--- | --- | ---\n", + "*Still* | `renders` | **nicely**\n", + "1 | 2 | 3" ] }, { @@ -251,7 +344,19 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Histograms and KDE can be combined using ``distplot``:" + "Histograms and KDE can be combined using ``distplot``:\n", + "\n", + "**NEW ROW AT END**\n", + "\n", + "| Tables | Are | Cool | Let us | test them | properly, shall we? |\n", + "|:----------:|:-------------:|:------:|:----------:|:-------------:|:------:|\n", + "| col 1 is | left aligned | 1600 | Still some | work to | be done |\n", + "| col 2 is | centered | 12 | to fix | all the changes | in the table properly |\n", + "| col 3 is | right aligned | 1 | hence, we are testing | the table changes | here |\n", + "| col 1 is | left aligned | 1600 | It's weird | to write random | text\n", + "| col 2 is | centered | 12 | but it's 2020 | and I got | to do this | \n", + "| col 3 is | right aligned | 1 | Let's make | world a better place | peace\n", + "| NEWLY | ADDED | ROW | AT THE | END OF THE | TABLE" ] }, { @@ -279,6 +384,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ + "**REMOVE LAST COLUMN**\n", + "\n", + "| Tables | Are | Cool | Let us | test them |\n", + "|:----------:|:-------------:|:------:|:----------:|:-------------:|\n", + "| col 1 is | left aligned | 1600 | Still some | work to |\n", + "| col 2 is | centered | 12 | to fix | all the changes |\n", + "| col 3 is | right aligned | 1 | hence, we are testing | the table changes |\n", + "| col 1 is | left aligned | 1600 | It's weird | to write random |\n", + "| col 2 is | centered | 12 | but it's 2020 | and I got |\n", + "| col 3 is | right aligned | 1 | Let's make | world a better place |\n", + "\n", + "\n", "If we pass the full two-dimensional dataset to ``kdeplot``, we will get a two-dimensional visualization of the data:" ] }, @@ -307,7 +424,16 @@ "metadata": {}, "source": [ "We can see the joint distribution and the marginal distributions together using ``sns.jointplot``.\n", - "For this plot, we'll set the style to a white background:" + "For this plot, we'll set the style to a white background:\n", + "\n", + "| Tables | Are | Cool | Let us | test them | properly, shall we? |\n", + "|:----------:|:-------------:|:------:|:----------:|:-------------:|:------:|\n", + "| col 1 is | left aligned | 1600 | Still some | work to | be done |\n", + "| col 2 is | centered | 12 | to fix | all the changes | in the table properly |\n", + "| col 3 is | right aligned | 1 | hence, we are testing | the table changes | here |\n", + "| col 1 is | left aligned | 1600 | It's weird | to write random | text\n", + "| col 2 is | centered | 12 | but it's 2020 | and I got | to do this | \n", + "| col 3 is | right aligned | 1 | Let's make | world a better place | peace" ] }, { @@ -335,7 +461,16 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "There are other parameters that can be passed to ``jointplot``—for example, we can use a hexagonally based histogram instead:" + "There are other parameters that can be passed to ``jointplot``—for example, we can use a hexagonally based histogram instead:\n", + "\n", + "| Tables | Are | Cool | Let us | test them | properly, shall we? |\n", + "|:----------:|:-------------:|:------:|:----------:|:-------------:|:------:|\n", + "| col 1 is | left aligned | 1600 | Still some | work to | be done |\n", + "| col 2 is | centered | 12 | to fix | all the changes | in the table properly |\n", + "| col 3 is | right aligned | 1 | hence, we are testing | the table changes | here |\n", + "| col 1 is | left aligned | 1600 | It's weird | to write random | text\n", + "| col 2 is | centered | 12 | but it's 2020 | and I got | to do this | \n", + "| col 3 is | right aligned | 1 | Let's make | world a better place | peace" ] }, { @@ -374,7 +509,16 @@ { "cell_type": "markdown", "metadata": {}, - "source": [] + "source": [ + "| Tables | Are | Cool | Let us | test them | properly, shall we? |\n", + "|:----------:|:-------------:|:------:|:----------:|:-------------:|:------:|\n", + "| col 1 is | left aligned | 1600 | Still some | work to | be done |\n", + "| col 2 is | centered | 12 | to fix | all the changes | in the table properly |\n", + "| col 3 is | right aligned | 1 | hence, we are testing | the table changes | here |\n", + "| col 1 is | left aligned | 1600 | It's weird | to write random | text\n", + "| col 2 is | centered | 12 | but it's 2020 | and I got | to do this | \n", + "| col 3 is | right aligned | 1 | Let's make | world a better place | peace" + ] }, { "cell_type": "code", @@ -389,6 +533,15 @@ "source": [ "### Faceted histograms\n", "\n", + "| Tables | Are | Cool | Let us | test them | properly, shall we? |\n", + "|:----------:|:-------------:|:------:|:----------:|:-------------:|:------:|\n", + "| col 1 is | left aligned | 1600 | Still some | work to | be done |\n", + "| col 2 is | centered | 12 | to fix | all the changes | in the table properly |\n", + "| col 3 is | right aligned | 1 | hence, we are testing | the table changes | here |\n", + "| col 1 is | left aligned | 1600 | It's weird | to write random | text\n", + "| col 2 is | centered | 12 | but it's 2020 | and I got | to do this | \n", + "| col 3 is | right aligned | 1 | Let's make | world a better place | peace\n", + "\n", "Emptied above cells Sometimes the best way to view data is via histograms of subsets. Seaborn's ``FacetGrid`` makes this extremely simple.\n", "We'll take a look at some data that shows the amount that restaurant staff receive in tips based on various indicator data:" ] @@ -518,7 +671,16 @@ "source": [ "### Factor plots\n", "\n", - "Factor plots can be useful for this kind of visualization as well. This allows you to view the distribution of a parameter within bins defined by any other parameter:" + "Factor plots can be useful for this kind of visualization as well. This allows you to view the distribution of a parameter within bins defined by any other parameter:\n", + "\n", + "| Tables | Are | Cool | Let us | test them | properly, shall we? |\n", + "|:----------:|:-------------:|:------:|:----------:|:-------------:|:------:|\n", + "| col 1 is | left aligned | 1600 | Still some | work to | be done |\n", + "| col 2 is | centered | 12 | to fix | all the changes | in the table properly |\n", + "| col 3 is | right aligned | 1 | hence, we are testing | the table changes | here |\n", + "| col 1 is | left aligned | 1600 | It's weird | to write random | text\n", + "| col 2 is | centered | 12 | but it's 2020 | and I got | to do this | \n", + "| col 3 is | right aligned | 1 | Let's make | world a better place | peace" ] }, { @@ -549,6 +711,15 @@ "source": [ "### Joint distributions\n", "\n", + "| Tables | Are | Cool | Let us | test them | properly, shall we? |\n", + "|:----------:|:-------------:|:------:|:----------:|:-------------:|:------:|\n", + "| col 1 is | left aligned | 1600 | Still some | work to | be done |\n", + "| col 2 is | centered | 12 | to fix | all the changes | in the table properly |\n", + "| col 3 is | right aligned | 1 | hence, we are testing | the table changes | here |\n", + "| col 1 is | left aligned | 1600 | It's weird | to write random | text\n", + "| col 2 is | centered | 12 | but it's 2020 | and I got | to do this | \n", + "| col 3 is | right aligned | 1 | Let's make | world a better place | peace\n", + "\n", "Similar to the pairplot we saw earlier, we can use ``sns.jointplot`` to show the joint distribution between different datasets, along with the associated marginal distributions:" ] }, @@ -606,7 +777,16 @@ "source": [ "### Bar plots\n", "\n", - "Time series can be plotted using ``sns.factorplot``. In the following example, we'll use the Planets data that we first saw in [Aggregation and Grouping](03.08-Aggregation-and-Grouping.ipynb):" + "Time series can be plotted using ``sns.factorplot``. In the following example, we'll use the Planets data that we first saw in [Aggregation and Grouping](03.08-Aggregation-and-Grouping.ipynb):\n", + "\n", + "| Tables | Are | Cool | Let us | test them | properly, shall we? |\n", + "|:----------:|:-------------:|:------:|:----------:|:-------------:|:------:|\n", + "| col 1 is | left aligned | 1600 | Still some | work to | be done |\n", + "| col 2 is | centered | 12 | to fix | all the changes | in the table properly |\n", + "| col 3 is | right aligned | 1 | hence, we are testing | the table changes | here |\n", + "| col 1 is | left aligned | 1600 | It's weird | to write random | text\n", + "| col 2 is | centered | 12 | but it's 2020 | and I got | to do this | \n", + "| col 3 is | right aligned | 1 | Let's make | world a better place | peace" ] }, { @@ -1611,7 +1791,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.6.8" } }, "nbformat": 4, diff --git a/notebooks/Lime - basic usage, two class case.ipynb b/notebooks/Lime - basic usage, two class case.ipynb new file mode 100644 index 000000000..04e2e635e --- /dev/null +++ b/notebooks/Lime - basic usage, two class case.ipynb @@ -0,0 +1,74665 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import print_function\n", + "import lime\n", + "import sklearn\n", + "import numpy as np\n", + "import sklearn\n", + "import sklearn.ensemble\n", + "import sklearn.metrics" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fetching data, training a classifier" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For this tutorial, we'll be using the [20 newsgroups dataset](http://scikit-learn.org/stable/datasets/#the-20-newsgroups-text-dataset). In particular, for simplicity, we'll use a 2-class subset: atheism and christianity." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Downloading 20news dataset. This may take a few minutes.\n", + "Downloading dataset from https://ndownloader.figshare.com/files/5975967 (14 MB)\n" + ] + } + ], + "source": [ + "from sklearn.datasets import fetch_20newsgroups\n", + "categories = ['alt.atheism', 'soc.religion.christian']\n", + "newsgroups_train = fetch_20newsgroups(subset='train', categories=categories)\n", + "newsgroups_test = fetch_20newsgroups(subset='test', categories=categories)\n", + "class_names = ['atheism', 'christian']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's use the tfidf vectorizer, commonly used for text." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "vectorizer = sklearn.feature_extraction.text.TfidfVectorizer(lowercase=False)\n", + "train_vectors = vectorizer.fit_transform(newsgroups_train.data)\n", + "test_vectors = vectorizer.transform(newsgroups_test.data)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, let's say we want to use random forests for classification. It's usually hard to understand what random forests are doing, especially with many trees." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "RandomForestClassifier(bootstrap=True, ccp_alpha=0.0, class_weight=None,\n", + " criterion='gini', max_depth=None, max_features='auto',\n", + " max_leaf_nodes=None, max_samples=None,\n", + " min_impurity_decrease=0.0, min_impurity_split=None,\n", + " min_samples_leaf=1, min_samples_split=2,\n", + " min_weight_fraction_leaf=0.0, n_estimators=500,\n", + " n_jobs=None, oob_score=False, random_state=None,\n", + " verbose=0, warm_start=False)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rf = sklearn.ensemble.RandomForestClassifier(n_estimators=500)\n", + "rf.fit(train_vectors, newsgroups_train.target)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.9241540256709451" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pred = rf.predict(test_vectors)\n", + "sklearn.metrics.f1_score(newsgroups_test.target, pred, average='binary')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that this classifier achieves a very high F score. [The sklearn guide to 20 newsgroups](http://scikit-learn.org/stable/datasets/#filtering-text-for-more-realistic-training) indicates that Multinomial Naive Bayes overfits this dataset by learning irrelevant stuff, such as headers. Let's see if random forests do the same." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Explaining predictions using lime" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lime explainers assume that classifiers act on raw text, but sklearn classifiers act on vectorized representation of texts. For this purpose, we use sklearn's pipeline, and implements predict_proba on raw_text lists." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from lime import lime_text\n", + "from sklearn.pipeline import make_pipeline\n", + "c = make_pipeline(vectorizer, rf)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0.252 0.748]]\n" + ] + } + ], + "source": [ + "print(c.predict_proba([newsgroups_test.data[0]]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we create an explainer object. We pass the class_names as an argument for prettier display." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "from lime.lime_text import LimeTextExplainer\n", + "explainer = LimeTextExplainer(class_names=class_names)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We then generate an explanation with at most 6 features for an arbitrary document in the test set." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/amitrathi/.virtualenvs/loaded2/lib/python3.6/site-packages/lime/lime_text.py:116: FutureWarning: split() requires a non-empty pattern match.\n", + " self.as_list = [s for s in splitter.split(self.raw) if s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Document id: 83\n", + "Probability(christian) = 0.492\n", + "True class: atheism\n" + ] + } + ], + "source": [ + "idx = 83\n", + "exp = explainer.explain_instance(newsgroups_test.data[idx], c.predict_proba, num_features=6)\n", + "print('Document id: %d' % idx)\n", + "print('Probability(christian) =', c.predict_proba([newsgroups_test.data[idx]])[0,1])\n", + "print('True class: %s' % class_names[newsgroups_test.target[idx]])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The classifier got this example right (it predicted atheism). \n", + "The explanation is presented below as a list of weighted features. " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[('Host', -0.13158254377478837),\n", + " ('Posting', -0.12755833682065656),\n", + " ('NNTP', -0.1091239484180258),\n", + " ('edu', -0.02540690605359643),\n", + " ('post', -0.0130522416154676),\n", + " ('Thanks', 0.009196448838747762)]" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "exp.as_list()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "These weighted features are a linear model, which approximates the behaviour of the random forest classifier in the vicinity of the test example. Roughly, if we remove 'Posting' and 'Host' from the document , the prediction should move towards the opposite class (Christianity) by about 0.27 (the sum of the weights for both features). Let's see if this is the case." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original prediction: 0.492\n", + "Prediction removing some features: 0.734\n", + "Difference: 0.242\n" + ] + } + ], + "source": [ + "print('Original prediction:', rf.predict_proba(test_vectors[idx])[0,1])\n", + "tmp = test_vectors[idx].copy()\n", + "tmp[0,vectorizer.vocabulary_['Posting']] = 0\n", + "tmp[0,vectorizer.vocabulary_['Host']] = 0\n", + "print('Prediction removing some features:', rf.predict_proba(tmp)[0,1])\n", + "print('Difference:', rf.predict_proba(tmp)[0,1] - rf.predict_proba(test_vectors[idx])[0,1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Pretty close! \n", + "The words that explain the model around this document seem very arbitrary - not much to do with either Christianity or Atheism. \n", + "In fact, these are words that appear in the email headers (you will see this clearly soon), which make distinguishing between the classes much easier." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualizing explanations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The explanations can be returned as a matplotlib barplot:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "fig = exp.as_pyplot_figure()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The explanations can also be exported as an html page (which we can render here in this notebook), using D3.js to render graphs. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "exp.show_in_notebook(text=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Alternatively, we can save the fully contained html page to a file:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "exp.save_to_file('/tmp/oi.html')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we can also include a visualization of the original document, with the words in the explanations highlighted. Notice how the words that affect the classifier the most are all in the email header." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "exp.show_in_notebook(text=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That's it for this tutorial. Random forests were just an example, this explainer works for any classifier you may want to use, as long as it implements predict_proba." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/notebooks/Shap Trial.ipynb b/notebooks/Shap Trial.ipynb new file mode 100644 index 000000000..2d681f0ca --- /dev/null +++ b/notebooks/Shap Trial.ipynb @@ -0,0 +1,274 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "
\n", + " Visualization omitted, Javascript library not loaded!
\n", + " Have you run `initjs()` in this notebook? If this notebook was from another\n", + " user you must also trust this notebook (File -> Trust notebook). If you are viewing\n", + " this notebook on github the Javascript has been stripped for security. If you are using\n", + " JupyterLab this error is because a JupyterLab extension has not yet been written.\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import xgboost\n", + "import shap\n", + "\n", + "# load JS visualization code to notebook\n", + "shap.initjs()\n", + "\n", + "# train XGBoost model\n", + "X,y = shap.datasets.boston()\n", + "model = xgboost.train({\"learning_rate\": 0.02}, xgboost.DMatrix(X, label=y), 90)\n", + "\n", + "# explain the model's predictions using SHAP\n", + "# (same syntax works for LightGBM, CatBoost, scikit-learn and spark models)\n", + "explainer = shap.TreeExplainer(model)\n", + "shap_values = explainer.shap_values(X)\n", + "\n", + "# visualize the first prediction's explanation (use matplotlib=True to avoid Javascript)\n", + "shap.force_plot(explainer.expected_value, shap_values[0,:], X.iloc[0,:])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a\n" + ] + } + ], + "source": [ + "print('a')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + "
\n", + " Visualization omitted, Javascript library not loaded!
\n", + " Have you run `initjs()` in this notebook? If this notebook was from another\n", + " user you must also trust this notebook (File -> Trust notebook). If you are viewing\n", + " this notebook on github the Javascript has been stripped for security. If you are using\n", + " JupyterLab this error is because a JupyterLab extension has not yet been written.\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# visualize the training set predictions\n", + "shap.force_plot(explainer.expected_value, shap_values, X)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAd4AAAFACAYAAAAS8h3wAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzdd3hUVfrA8e+Zkk5vAenSiyBcmoKiWMHeGyrqYlt13XV/u66uvevaK1YUe3ddxI6CSDnSBQQE6R0C6VPu+f1xJ8kkpEzCJJPMvJ/nmSczt74DybxzujLGIIQQQoi64Yp1AEIIIUQikcQrhBBC1CFJvEIIIUQdksQrhBBC1CFJvEIIIUQdksQrhBBC1CFPrAOIleuuu8489dRTsQ5DCCEaGhX9K55Relyr+Sj696hHErbEm5WVFesQhBBCJKCELfEKIYSoL+K6gLsfSbxCCCFiTBKvEEIIUYck8QohhBB1KLESb8J2rhJCCCFiQUq8QgghYiyxSrySeIUQQsSYJF4hhBCiDiVW4pU2XiFEXPh8eYDHZvjYkGXHOpSI/bIxyKMzfMzbECy1/cc1AR6f6eO3HQ3nvRwYVeYR36TEK4Ro8J6f7ePqTwoBePhHH0tvTKd5WmQf4B+tsJn6u82oDopLDnHXZpil6I1BDn8uD18QPC6YcVUawzu6+Xx5gFNez8cYuP3rQhbekE6X5vFeRor/ZBsu3v83hRAJ4MuVJSXGLdmGJVuDlRxd4sf1Nmd9FODlRTaXfh7kwxV1V8KcviaILxRmwIbvfg8A8OXKACY0c/G+Qvh5fWTvpWFLrBKvJF4hRIM3umtJSbVVuqJvm4o/2vL8hi05TmZbst0QPjv/4u11l3hHdnbjCYXpUnBEF+c9HBn2XlK9MKR93ZXCY8WgSj3inVQ1CyEavBtGJtG2sWL1LptzD/HSMr38xDtro8249wJkFcDF/V3cMcpNixlBduVDuhfO6Fl3ZZHhHd38cGUa360OcGRXNyM7Ox/HZ/X38vmlivmbgpzUy0P3llI+ijfKGFP1UXFo/Pjx5o033oh1GEKIOjT2XT9f/F7ymbfoCg8tUxWzNxkOzVR0aRr/pa0oiPo/klEXl0pEyrxe6T2UUi2AN4CDAR+wCrgSaAa8ALQFAsA84BpjTH4515gOdAT2hTY9YYx59YDeSITkq5QQImE0Tyn5PHcraJKsaNdIcUYvlyTdGKpBVbMBHjLG9DTG9Ad+Bx7AScJ/Ncb0Ag4B0oCbKrnO9caYgaFHnSRdkKpmIUQD9e6yID9tNIzr5uL4ruWXIV7/1earPwwDWkLnVJtrD3Wxt0CxPttw0zA3nZqU/pDfkWPz6bIALpdi/jbDnI02nZoq2jRz8+oy6NIEPj3NTbdmznnGGCYvDLI523DxAA/tm0SWvG3b4HKpKrcljuq9b2PMbmB62KbZwNXGmD+AP0LH2EqpuUDvqIQYRXGTeC3LOgm4m5JucXdqrT+KbVRCiNrw0Qqb8z5xevs+84vNz5d4GNqudPL9cq3NJV84naXeBNjnIzlgc+TOvfQ3Nj0GtADSi4/PKTSMeC6P33cZSHKDcpKB3mzAZSDdw7JdcMtMm3dPdjo83fZdgAen+2jiC/DKHC+Lb0glLaniJBIMGp54bidzf8mjS6ckbv5raxo3dvPp1L28+2EWjRu5+dt1reh+cHL0/rHinFLKBVwNfFZmeypwGXBzJac/rJS6H1gE/MMYs6nWAg0TF1XNlmUpnPr+8VrrgcB4YLJlWXHx/oQQpemtJb2PbQMLtu7fV2XZrjIb3C4KbdiQlITfb5j89p5Su5dus52k61LFSbdYWF+Y8D0/rvRz3ObdHL0ti37LdzJvpa/yuOfnMUfnYQys+cPH51/uI2tvkLffzyIYhD1ZQd54Z0+l14hPpYcTKaUmKqV02GNiJSc/BeQATxdfTSkP8A7wnTHmswrOG2+M6Q0MBFYA70bjnUQinhKTDTQJPW8KbNFaJ8q0L0IklFO7u0gOjbJpmgLHdtn/o+zUboqWqaEXtqFo0GxTvzNeNiWl9DndW7hI9YaOLdPp9NjubtK90L8l3Duq5LxBLh/pQedjJtk2bFyRV2ncbk/phO5xK1yu0nneHf+jh/ZTto3XGDPJGGOFPSaVd55S6hGgO3CuMcYObXPjVHLsAa6v8J7GbAj9DAJPAMNDpedaFxdVzVprY1nWOcCnlmXlAo2AsWWPsyxrIjARIDMzs26DFEJEzbCDXCy43Mv8rTYjO7j2a6sF6NpUseRSN/O3GbZn2cxe5+EgV5DdPxu8Xi8TJ7QodXyLdMXJA5N5b1HAyYRuxd9HuLlysJuDK5g5asLhydz7c8nrL7a76bbFMKxt+dXNgwemctQR6Xwxr5CkdBdtOiXTuJGbyy9u7lQ1N3Yz4aLmNf+HabCq37atlLoPGAyMM8YUhra5gNeAIHC5qWDYTqhE3MIYsy206XxgSVHyrm1xMZzIsiwPMA24XWv9k2VZhwNvA3201jnlnSPDiYRo2HbnGc6ako/eGGTQQS6ePS2FPm1qXlycvyXI8Ff9+HGqmkd3Unx/gbd4/+z1QXIKDUcf7C7VCeqb6dm88U0ec/xJ/NaqEY2S4Pcr3LSqYMrKlz7LZvJU52PJ64Ept7eiXSunDBS0DW8vClAYMFw40EuK98A6W23eZ7Mz19CvjSuaHbei3gMsoC4vlYg85uWqhhP1BZYCK4GioUJrgZeAz0P7iqb8+skYc61Sqh0w1RgzUCmVDvwAJOG8n03ADcaY36L0lioVFyVenDr6dlrrnwBCyTcXpzfbvJhGJoSoFQ/+4OP7Nc5n6w9rbQY9mce869Lon1n95Lsr13D8S/n4c0Of/xle0pJLku493xby76+d9tuz+3t478LU4n3HjG7EwzvT+O0P59xsH6zfB63Syr/Xhm2B4uf+AGzZFSxOvFd8WMBrvzj7310c4KvLK7hIBD791c85bxXgC8LpfT18eFEKqmzbdb1R7V7Nv1ZyUrnbjTGbcXIFxphcwKrWTaMoXtp4NwLtLcvqCWBZVm+gDc7YLiFEHPIHS9fWFQbh29U1m9d4weYgO3PDOlD5bS7pW/L5/bL2Fz9/f0mAnMLS9760r6KoQDkkE/q1rPhe4w5PI8llSA0E6dpS0bdrUvG+qb+VxP/1quB+77E6Hp3pxxeEFj4/S+fmMGNJYY2vVdsSbcrIuEi8WuutON3JP7AsaxFOb7bLtNa7YxuZEKK2/N+RSRzcouRD2qVgWIeaVTX3y3TRrKQQyz8Oc3NOr5KPx/C5nzs1VaQnUcr5vV0svNjN1DNc/HCum2RPxcmjbycv3ZNtmgWCFGwsZJ7OLd43slNJ/MM6uPC6a56EOjZVtCn0c9TubA7NzuPFp7ezeYu/6hNjIrEWSYiXqma01m8SGq4nhIh/mY1crP57BtN+8/PjWptju7sZ0almiTezkYufrk7j3UUBerZycf5Ab6n9r5+Tyt3fFpJdCP8cnVRulW3/Vor+rapOGmvXFbJnT0nJdt78fEYdlgHAlPNSeH62n4KA4erhSRVdIiJPnpzCn3/LIRAaneTzGVasLKBdW2/lJ8ZAIpRyw8VN4hVCJKYTeno5oeeBX6d3azd3HFt+4m6epnjs5JQDvwlwUDsvqamK/HynGrlbWFVzqldx46gDS7hFmqUp/npKOg897gxx8nqgW72dmEMSrxBCiFrSrKmHO27OZObPubTN9HD0ERm1dq/BA9P4102tWfV7IQP7p9KxfXSSerRJiVcIIUSt6twxic4d6yYJDuiXyoB+qVUfKOqMJF4hhBAxJSVeIYQQok5J4hVCCCHqjJR4hRBCiDoliVcIIYSoM4lW4o2LmauEEEKIhkISrxBCCFGHpKpZCCFETCVaVbMkXiGEEDEmiVcIIYSoM1LiFUIIIepQoiVe6VwlhBBC1CEp8QohhIipRCvxSuIVQggRY5J4hRBCiDojJV4hhBCiDiVa4pXOVUIIIWJMlXlUcbRSLZRSU5VSvymlliilPlJKtQrtG66UWqSUWqmU+kop1bqCa6Qppd5VSq1WSq1QSp0UzXdUGUm8QgghYsqUeUR4ykPGmJ7GmP7A78ADSikXMAW41hjTA/gReKCCa9wE7DPGdANOBl5SSmUcyPuIlCReIYQQMWVQpR5VHm/MbmPM9LBNs4FOwGCgwBgzM7T9eeCcCi5zLvBC6HqrAA2cWLN3UD2SeIUQQsRY6apmpdREpZQOe0ys8EynlHs18BnQEVhXtM8YsxNwKaWal3NqqWOB9UCHA38vVZPOVUIIIWKqbCnXGDMJmBTh6U8BOcDTwOnRjax2SIlXCCFETFW3qrmIUuoRoDtwrjHGxim1dgrb3xKwjTG7yzm91LE4JeANNYm/uiTxCiGEaHCUUvfhtOmeZowpDG3+BUhVSo0Mvb4KeL+CS7wPXBm6VndgCDCt9iIuIVXNQgghGhSlVF/gZmAlMEspBbDWGHO6Umo88IJSKgX4A7go7LyFwFhjzGbgYeA1pdRqIAhMNMZk10X8kniFEELEVHUn0DDG/EoFA36NMbOA/hXsGxj2PBc4u1o3jhJJvEIIIWIq0WauksQrhBAixiTxCiGEEHUmwtmq4oYkXiGEEDElVc1CCCFEHZLEK4QQQtQpSbxCCCFEnZESbwNlWVYK8BhwDFAA/Ky1rnBibSGEEPVDonWuiqcpIx/CSbg9tNb9gX/HOB4hhBARqOlczQ1VXJR4LcvKAC4G2mutDYDWeltsoxJCCBGZ+E+24eIi8QIHA7uA2y3LOgpniahbtdYzKz9NCCFErCVCKTdcvFQ1u4GuwAKttQX8A/jIsqzG4QdZljXRsixtWZbes2dPLOIUQghRhinziHfxknjXAwHgbQCt9RxgJ9Aj/CCt9SSttaW1tpo1a1b3UQohhNhPorXxxkXi1VrvBL4HjgWwLKsH0BpYHcu4hBBCVC3REm+8tPGCs+DxK5Zl/QfwA+O11lkxjkkIIYQoJW4Sr9Z6DTA61nEIIYSorvgv5YaLm8QrhBCiYUqEDlXhJPEKIYSIqURo1w0niVcIIURMSeIVQggh6pAkXiGEEKIOSRuvEEIIUacSq8QbFxNoCCGEaLhqMoGGUuoRpdRapZRRSvULbeuslFoY9vhDKbW7gvPvUEptDzv2mSi+pUpJiVcIIURM1bCN9xPgCWBG8XWM+QMYWPRaKfU4lee5140xN9Xk5gdCEq8QQoiYqkkbrzFmJoBS5SdtpVQScCFwfM0jqx1S1SyEECKmylY1K6UmKqV02GNiDS57CrDJGDO/kmPOU0otVkp9pZQaUcPwq01KvEIIIWKqbFWzMWYSMOkAL3sZ8Eol+58H7jXG+JVSxwKfKqV6G2N2HeB9qyQlXiGEEDEV7fV4lVIHAUcCb1Z4T2O2GmP8oedfAxuAflG4fZUk8QohhIipWlgW8BLgf5WVXkPJuej5QKAz8Fs0bl4VSbxCCCFiqobDiZ5USm0E2gPfKKV+Ddt9KeVUMyulpiqlrNDL+5RSS5VSi4AXgfHGmK0H9EYiJG28QgghYqqGvZqvB66vYF+PCraPDXt+SQ1uGxWSeIUQQsRUos3VLFXNQgghRB2SEq8QQoiYSrQSb5WJ17IsD7AAGKK1Lqj9kIQQQiSSRFudqMqqZq11AGhK4v3bCCGEqAO1MJyoXou0jfcJ4N5Q6VcIIYSIIlXmEd8iTaRX4gwuvtqyrC2AXbRDa11ut20hhBAiEolQyg0XaeK9p1ajEEIIkbASrR0zosSrtZ5c24EIIYRITFLirYBlWUNwVnvogDOZ9Cta63m1FZgQQojEkGgl3og6V1mWdRrwI9AEZ2hRY+AHy7JOr8XYhBBCJAAbVeoR7yIt8d4OnKm1nlq0wbKsE4EHgI9rIzAhhBCJIdGqmiMdTtQZmFZm25dAp6hGI4QQIuFEez3e+i7SxLsOOKbMtjHA+uiGI4QQItEk2gQakVY13w18alnWB8BanBLwmTiLDQshhBA1lgjJNlxEJV6t9Yc4Jdw8wALygWO11h/UYmxCCCESQKJVNVdY4rUs60Ot9Zmh5xO01q8Cs+osMiGEEAlBSrwlxoQ9f6K2AxFCCJGYpI23xK+WZb0NLAGSLMv6V3kHaa3vq5XIhBBCiDhUWeK9CPgncBTgBo4t5xgDSOIVQghRY4nQrhuuwsSrtV6LsyoRlmUt1FofVWdRCSGESBiJUL0cLtJezQNrO5BosSzrdsuyjGVZ/WIdixBCiKrVpFezUuoRpdRapZRRSvUL2/6HUmqFUmph6HF8BeenKaXeVUqtDh1/0oG/k8jE1cL2lmUNAobjTPghhBCiAahhifcTnI6/M8rZd5YxZmkV598E7DPGdFNKdQdmKKW6GWNyahJMdUQ6c1W9Z1lWMvAMcHWsYxFCREdOoWH59iC+QKK1AiaWmvRqNsbMNMZsOIDbngu8ELrWKkADJx7A9SIWN4kXuAuYorX+I9aBCCEiM1n7aXNPNp0fyOGXjYFS+37bYdPt4Vz6PJrHiOfyyCmU5Buv7DKPKHhTKbVYKfWsUqppBcd0pHTt6HqcZW9rXVxUNVuWNQJnRq1/VnHcRGAiQGZmZh1EJoSoyO48w4QPCkJteoZhz+ZzSK9U/jHUxWHtFM/P9rEtx9k7f5PNf5cHOH+gN5Yhi1piXKVLuUqp4s/qkEnGmEkRXm6UMWaDUioZeBx4GmeUTr0RUeK1LMsN3IwzN3NrrXUTy7KOB7porZ+vzQAjdCTQG1hrWRZAe+DL0IxbXxUdpLWeBEwCGD9+vHx9FiKGsgtNqY40QRsWbDGc96Ef3IpTO5Y+vl3jxOr5mkhMmf/aUJKNNNGWPXdD6GehUupZ4LMKDl2Ps8LejtDrjsD3NblndUVa1Xw3cArwD0o6na0kNNwo1rTWD2it22mtO2utOwMbgePDk64Qon7p1MxF3zYlH0FNg0E6b8tGFQYhP8j3WxU3HO7l8E5uHj8pmSO7OuWEp78r4JJXc/hmQUGsQhdRZlyq1KOmlFLpSqkmoecKOA9YWMHh7xPKYaHOVUPYf/nbWhFpVfMFwAit9RbLsl4KbfsDZ5UiIYSo0rYcg8+GDmEl16U3pvPKz4U8+c5eGhUGAVDA2kappCh4/OSUUtf459RCHlzmATx8ODXA9DQfVs+kOnwXojaYGvQ2Uko9CZwBZALfKKV2AScDHyql3DgTPy0Drgk7ZyEw1hizGXgYeE0ptRoIAhONMdkH+FYiEmniTQO2l9mWBNTLr5yhUq8Qoh5Yscsw7v0Aa3Y7lWV/HebiP2NKPnqGZypeDSVdgNSA8/yho937XevTP0qe5yZ7mL5aEm88MO7ql3KNMdcD15ez69BKzhkY9jwXOLvaN46CSL9nzAcmlNl2ATA3uuEIIeLNlV8Hi5MuwKNzbHbnl/Rd7d7BS7+uTqcplwuOH5HKjMuSuGTA/uWCw9qXfGR5gzbH95ekGw9slyr1iHeRlnhvAqZblnUekGZZ1n9xehHLNJJCiEpl+3Dqj8N6Uv26xaaN7ad9Oy9paS6euLEFS9f4aNXUTYc2FX8sPT/OQ5v0IL9uDXL9UDf9O8bFwIyEV5Oq5oYsot9arfVSy7J6AxcDK3DGPl2htd5Wm8EJIRq+B45wcdIHBr/fybxtkmymPLGdrL1Bmjdzc/etmbRs4WFQz+RS532zKsD49wooDBiePz2Fcw7x4nUr7hvjtPGK+HEgHaoaooh/e7XWO4D/1GIsQog4dFxnFzl/gZeWGLblQeet+Uxb4rTj7t4TZNacXE4Z22S/8/70UQFbs51kfdkHBZzVz4MrwT6gE0XZ4UTxLtJxvOWuxQuyHq8QompJHhfXhLq8zJ7nKTVmo3UrKb0mOinxlq/sWrztgC7ATGQ9XiFENQwfks7484IsWZZP/z6pDB+SXu5xL56RUqqqWUq7Il5E2sa7Xycqy7L+DLSKekRCiLh30gmNOemExpUec0x3D1tuyaijiEQs2Qn2nepA+pI9B1wVrUCEEEIkpmjNXNVQHEjjygCo2SKKQgghRBHpXFUOy7K+ptQoPNKBQcCjtRGUEEKIxGFUw8q8SqkUoBmwxxhT7RkcIy3xzizzOhv4l9b6h+reUAghhAjXUNp4lVJDcYbVDsdpqrWVUrOBm4wxcyK9TqSdq+6sUZRCCCFEFRpCu65SqhvwHfAzcDXOKngdgHOB75RShxpjVkZyrQoTr2VZ7SK5gNZ6cyTHCSGEEOVpIG28NwFvGmPKLof7olLqOeBvRLhUbmUl3o2Ubtctq2j21f2XEBFCCCEi1EDaeI8ATq1g33+AzyO9UGWJt0t1IiqPZVlrqjpGa931QO8jhBCi4WogbbxtjTGrytthjFmtlMqM9EIVJl6t9bqaRFZGZ5yFiF8FtkbhekIIIeJMAynxVjXvRcRvIuJxvJZl9QJG48xWVXwDrfVdlZw2HPgTcAswHXgRmKa1rqwKWwghRAJpIG28SUqp86k4wXojvVCk43jPB14DFgOHhH4OAH6s7Dyt9VxgrmVZNwLnA3cBz1mW9TLwpNZ6b6SBCiEaoOx8WLIOerSDlpVPESkSl90wSrzbqHxtgoiXyY10yshbgPFa6yFAXujnVcD8SE7WWudorV/EKQG/BtwODI40SCFEA7Q9Cwb8FQ7/F/S6DlZsjHVEop4yqvSjPjLGdDbGdKnsEem1Ik28HYH3y2x7HRgfycmWZXW2LOseYB3OSkdXAD9FGqQQogH6dB6sDRUCdmXDGzLfjiifUarUo6FRSvVVSj0Z6fGRtvFmAU1CP7dZltUb2IUzdWSFLMs6C6eN91DgTeB4rfWvkQYnhGjAurap/LUQIQ002SbjTJ5xJTACmBXpuZEm3m+A03F6J78Xeu0HvqjivPdwejU/DxQAp1qWVWoclNZa1vMVIh6NOQReuAr+q2FED7hsTKwjEvVUfa1eLo9Sqg9Osr0ISMOpOT7BGPNVpNeIdMrIy8Je3g6sABoDk6s49UecSTZGVbDfUHljtRCiIZt4nPMoY1uOYZ/P8Ms26NxEMbyd4o6vC/l6dYDBB7npkOmlR3PFqd0OZOVSEc+UUo8AZ+IMW+1vjFmqlGoBvAEcDPiAVcCVxpgd5Zz/GnAMsDO06X1jzL2V3G88MBE4HKeD8R04Nbm/AgurE3ukvZo7aq3XA4SGAr0VyXla69GVXFMRYRuxECJ+XDPVz3M6CG4Fyc7Ed6d3svn4Fx8As9bZkAGkeHhmDAwO5PPex3vJyHBx2UXNWLi0AAUcd3QjUlIkMceDGs7V/AnwBDAj/FLAQ8aY6QBKqYeBB4DLK7jGA8aYpyO832ScJtZxxpji2l5Vg2rySKua11iW9T3wMvCx1row0htYltUVGAj8VtS+a1nWyTgl3bY4nbSEEAngmzVBnpsTcF4EjTMiMsnNl+vKDO23nddfrw4y68ud+EOn3PngdnJzbQCWLCvglpuk3Tge1KSN1xgzE0onPmPMbpw5I4rMxlnQIBr+jdMx+BOl1FTgFeB/NblQpF8Xu+M0HN8PbLEs61nLsqyqTgp1rloBfAAstixrgmVZr+N8c3iXKExLKYSoX5ZsDXLFBwX8a1oheb7SCfX9ZcHSBwec/RkuQ7cWzgeoy6MgxSkTjGxLcdIFyAslXYAVKyP+/i/qOeNSpR7RoJRy4STdzyo57K9KqSVKqU+UUr0rjdGphu4KnIZTsv4Q2AQ0BSJaVKhIpG28a3Hadm+3LGsMcAnwvWVZa7TWAyo59Rbg7zgzVl0DPANMBQ7WWu+pTqBCiPov12cY82I+O3KdhLo12+aVs1OL97dKdwFhydcYyPXzwDg35w1I5489NkYp/rsGujeDM3q4eHtrYz75fB8pKYpOHZL4bZWTcA89JBVRTXe+C2/+CId2gZevhYx68m9YpsSrlJqI055aZJIxZlI1r/oUkANUVJV8C7DFGGMrpS4GpimluhpjghUcjzHG4HQq/kIp1RanBHwZME8p9bEx5pxIAot4ysgw03E6VnXAWa2hMp2Bp7TWtmVZTxKqa5cZq4SIT9uyTXHSBVi6raSEmuMzPDLXBq8LbEOqsmmbbHPBQC8TrCQAerd22nz7tCq55vlnNeOUE5uQlKRQCmb+nItScPjwSkczirK+XwJ3vOs8X7XFmU3s7gtiG1NI2VJuKMlWN9EWC3W86g6cbIyxyzvGGLMp7PnrSqnHgPY4801UHbMxW4C7lVL3ACcQYd8nqN5czYcAE4ALgEKcttk/VXGaW2ttA2itfZZl7ZOkK0T86tRMMbqrm+lrnELDpYNLpq/1BaEwCLgUuBQ927hZcHlk09ump5e0io0elRHVmBPG3rzKX8dQNMfxKqXuw5kZcZwxpsL2CKXUQUXJVyl1PE5VzKaKjg8dV9RnaaUxZmlo80k4zbAVlpTLirRX8wKgJ05d+cXA10UJtQpJlmX9K+x1cpnXMo5XiDjidim+vCyVb1YHaZ2hsNqXLNfdPFVx5yg3t88IkpEEDxwlS3nXqbGD4PiB8OVC6Nwabjw51hEVM6r6vdNDM0WdAWQC3yildgHnADcDK4FZoY5Xa40xp4fOWQiMNcZsBiYrpdoANrAPOMUYE9j/TsX3OwunVOsBjFLqCuAonMT7KE4P64hEWuJ9EXhLa50V6YVDZuNMEVlkbpnXMo5XiIbk49mgf4dTh8LQ7uUekuRRjO1V8tGyZIdh6hrDoDZw2yg3fx3mIskNSe4GNGtCPEjywrTbnOk7m6aBu/588alJhypjzPXA9eXsqvBixpiBYc+PqeYtK+yzZIypVp8l5bQVJ57x48ebN954I9ZhCNFwvDsTznvUeZ7shQX/gd7tS/bvyobXp/N+RmfmdOvDyd1cHJQBA18Pkut3Dvn4VBendZextw1c1L8xPTX4y1KJ6Lpfjq9338qUUnuAFqHOWElAXuh1tZtP5S9ACBGZn1aUPC/0w/zfS177A3DErbz/2nLO2dub//xiOOb9IO/9ZhcnXYBv1yfmF31RBVXmUT+5izpqGWN8wL6aJF2oWa9mIUQiGjsInpkGtg1N02FkybDHwj92kbxsA3NOGl28LWCD2wXpXoqT75iO9fdTVcROA1kkIUkpVarPUpnXGGMiajqVxCuEiHlhZ5IAACAASURBVMwJg2DWfbBgLRw7ADq1BuDBz3N54nsPvS64mXWZrVG+IMbrommK4pweLsZ1galrnTbeYzpJJZvYX7QmzahlUeuzVGXitSyrG9AfWKS1XlONIIUQ8WZYD+cRsnx7kJtnBjHeJLZ06EU6hlY5hexqlEyyrXhKw6PHeOjXqkF8sIoYaQglXmPM6Ghdq9LEa1nWGThTO7oBn2VZZ2itp0br5tFiWVa5K1JorfdbkUIIET2b9xlMWKNcmi9AisdF0Ci25cJjc23y8n08f3JSDKMU9V1DSLzRVFW9z63Av4BGOFNG/qvyw2PGAA9prXtqrfsDv+PMkiWEqEWjOrvJUM6QfrcxtC30Y5f5EH1hjp8f11Q4PFIIjFKlHvGuqsTbBfiP1joXZ4Bwt9oPqfq01ru11tPDNs0GOsUoHCESRpJHcUZ76J+TR8/8QhoHbdpl5+MKhubXCdgQsNm4T3ozi4pJ4i0tfMpHP1Dv64ssy6pwRQrLsiZalqUty9J79sgaDUJEw/NXNKJPaxdNfAFUhpszjkrj+ws9tAz6IM/PIZkuTuol/TiFKFLVX0PZKR9TGsCUjxWuSKG1Lp54e/z48fIVXIgoSE128c5trfAHDF5PSWll9d/TWZ9l06Oli2RP/JdiRM0lQik3XFWJt2z36TnU4ykfLcsqXpEiwrmkhRBR4i2TXJukKPpn1p9pCUX9JYk3jNZ6dB3FccAsyypekUJrLStkCyFEA9FAxvFGTY0aXizLUsBYnCE7p0Q3pBrF05ewFSksywJYq7U+PaaBCSGEqJKUeCthWVY74ArgcqAt8F5tBFVdWutfqc8zfAohhKiQJN4yQqXbE4ErQz93Ak2BwVrrJbUbnhBChNmdDUkeyEiNdSQiihIt8VY6nMiyrH8Da4FPcDpSnQl0BPYC22o9OiFEg/Gothk6JcDVXwcpDNTCoIE73oEWl0CrCfDJnOhfX8RMoo3jrarEeyewCzgtfKrIUBuqEEIA8MMGw9+mOwMJ5m01dGxsuHlYFD9A9+XBnaGWrQIf/OtNOG1Y9K4vYioRkm24qhLveGAi8F/LshYDrwBv4pR+hRACgG25ptLXByzJA+kpkFvgvG6eEd3ri5hKtMRbaVWz1vpNrfWRQD9gOs58zZuAloAUe4UQAJx0sGJYW+d523S49tAoL/+XkgQf3AQDOsMRfeDla6N7fRFTRpV+xLuIejVrrZcDN1qW9U/gHOBPwOeWZWmt9dDaDFAIUb+s3+Dj7Q+ycLvhonObkdnGS5pXMfN8N+v2OYk3zVsLn54nDHIeIu4kWom3WsOJQhNTvAG8YVlWH5xqaCFEAnno8e3s2BUEYMfOAA/e1Q4Aj0txcNNYRiYaKkm8EdJaLwP+EsVYhBD1nDGG3VlBNnvczEtLgb2K4Yt9nH5IvV8/RdRjZZeSjHeVJl7LslZRRUcqrXWPqEYkhKi3lFKcOrYJl/4QoNDltONe9nauJF5xQEwN5j9SSj2CM8S1M9DfGLM0tL0HMBlogTMq52JjzKpyzncDTwIn4OS5B4wxL9XwLVRLVSXee8KeK+AZ4JraC0cIUd+de2ZTbliwh4Ic5zt5ghVWRC2oYVXzJ8ATwIwy258HnjHGTFFKXQS8ABxdzvkX4qwx3x0nSS9QSn1jjPmjJsFUR1WLJEwOf21Z1qNltwkhEs+rF6Qz4e1cgja8dF56rMMRDVxNEq8xZiY4tTBFlFKtgUGUrKL3NvC0UqqVMWZHmUucC7xojLGBHUqpT4CzgYerHUw1yerUQoiIFfgNSW44sU8SW+8Oq17OK4QHP4Zd2XD9OOjRLnZBigYnip2rOgCbjDFBAGNMUCm1ObS9bOLtCKwLe70+dFytk8QrhIjILV8W8tB3hbRMho8uT2NEJ+fjI8dn8E94gWbvTXcO/HgOrHkOkr2xC1Y0aEqpiZQeNTPJGDMpVvFEW5RHuQsh4tG6PTbPfJXH4L25NN1TwJXP7cUYw7q9ht6vBlk/Y23JwZt3w469sQtWNDhlJ9Awxkwyxlhhj0iT7gbgoFDHqaIOVO1C28taD3QKe92xguOirrq9mhtblrUy/Bjp1SxE/Ev2QPtCPyvSU9jrdT42hjyWy0nDUtmYDVMGjWLA/0K1dqP7QbvmMYxWNDTRGk5kjNmulFoInA9MCf1cUE77LsD7wJ+UUh/hdK46DRgVlUCqUJ1ezUKIBJXZyEWfDh5+3VPykTF/m03/HQHAzSOjT+HnTj14tF8OQy8bDC6pTBORq0kbr1LqSeAMIBP4Rim1yxjTF7gKmKyUug3YA1wcds5U4DZjjMaZDGoYUDTU6C5jzFrqQLV6NQshEtfTVzXhfw/kkheaTNcoRb/mcOtwxY8bDWNH9WHoMEm4ovpq2Kv5euD6cravwEmo5Z0zNux5ELi62jeOgqqqmj2A0lr7w7ZdCgwEftRaf1S74Qkh6ovWTdzM/HM6x72cx8486J+puMxKolmaDOQVBybRZq6q6uvpu8CEoheWZd0KTAJGAm9alnVFLcYmhKhHbNvw928C7Ap6cKV4GNHZTZOUWEcl4kGirU5UVeK1gM/DXl8HXKG1toCLiFExXQhR9yYvDPLtGhsD2AYm/WJ4dKa/yvOEqIpBlXrEu6oSbzOt9WYAy7J6A02A90L7PsGZI1MIkQD2FOw/bfuiLcHyDy7wgT9QyxGJeGErVeoR76pKvLmWZWWEnlvAUq11Qei1QibgECJhTDjUQ4fGoRfG4LKDnDegnEkynv0CMi6AxhfBR7PrNEbRMBmlSj3iXVWJcwZwt2VZLwBXAtPC9vUEttRWYEKIOjRrBUxbAIf1rHCx+WapirU3prByp+HXbQF6tUqmX6a79EGBIPzlVQjaEPTBja/AGcPr4A2IhiwRkm24qhLvP4CpwA3AUuDRsH0XAjNrKS4hRF1ZsAZG31ZSNfy/W2Ds4HIPdbsUvVsrereuYBlAl4LUpJJrZaTWQsAi3tiJlXerHMe7FuhtWVZzrfXuMrsfAny1FpkQom7MWVW6PXbm8goTb5VcLnjvb3DDK5DihZdkFVFRNSnxlqOcpIvWOiv64Qgh6tzovpCeArkF4HbB8Yce2PWOPxRWPBWd2ERCsBOgJ3M46RwlRKLr1R7mPQTfLYGh3WBI91hHJBKMlHiFEImnd3vnIUQMSBuvEEIIUYcSYexuOJnRXAghhKhDUuIVQggRU9LGK4QQQtQhaeMVQggh6lAiLIwQThKvEEKImEq0zlWSeIUQ+/tivjOD1fED4Yi+sY5GxDlJvA2UZVk9gMlAC2AXcLHWelVsoxKiAZo2H8be4zx/8GP4+X6ZVEPUqkRr442n4UTPA89orXsAzwAvxDgeIWouKxdOuAvaTHBW+KlLs34reR60Ye7qur2/SDg2qtQj3sVF4rUsqzUwCHg7tOltYJBlWa1iF5UQB+DBj+HLhbB9Lzz+OXy1sO7ufcKh4A1VhqUlw1H96u7eIiHJerwNUwdgk9Y6CKC1DlqWtTm0fUdMIxOiJgr9pV8X1OFCYIf1gjkPwOyVMLqfTCUpal2iVTXHS+KNiGVZE4GJAJmZmTGORohK3HQqfL0Ilq6Hs0bAuBou01dTh3Z1HkLUgep2rlJKdQY+CdvUFGhsjGle5rg7gGuAzaFNPxljrq1pnNESL4l3A3CQZVnuUGnXDbQLbS+mtZ4ETAIYP368qfswRVwr8MEf26FTK0hNPrBrtWsOSx531sn11uKf6fdL4L8ahveAcw7ff//CtZjrXiJQGMAzbhBqzCEwsnftxSMSUnXbdY0xfwADi14rpR6n4nz2ujHmphoHVwviIvFqrbdblrUQOB+YEvq5QGst1cyibuzYC6Nuhd82QZc2MPNeJ3keqNpMurNWwLF3Oh2oAPblgS8Ar30Pq7dCiwyCWXm4d+7DC2xYsQtr1+HMXvwDXa45svbiEgkneABVzUqpJOBC4PhoxVPb4qJzVchVwHWWZa0Ergu9FqJuvD3TSboAa7fBa9/FNp5wtg3XvQjdr4UrniEn18/6hVsw4+4tSbpA4TUvwbUvwrzVsCcHVm/FvXNf8f6W+dn4lZs3P9wYi3ch4pitVKlHNZ0CbDLGzK9g/3lKqcVKqa+UUiMOLNLoiIsSL4DWegUwLNZxiATVtlnp19Eo7UbLWzPg6S+c56u3cGdOF1pu284/snJLHZbs9+936nMDjmLi4ukoAzcfcTZZKWncNP1TWHYE9OlQF9GLBFC2c5VSqrg/TsgkY8ykCk6/DKhozN3zwL3GGL9S6ljgU6VUb2PMrgMM+YDETeIVDcyeHHjzR2jV2GlbbOhDCM4+DO441xkCNLovXHJUrCMqsTev1EtXdh5bGzXd7zADpVra3uo1jGtOuJRbjzwLl7HZmdaYW2Z9RoodgN05tRuzSChl23hDSbaiRFtMKXUQcCQwvrz9xpitYc+/VkptAPoBPxxIvAdKEq+oe/4AHHGr02MXYOEfcP9FMQ0pKm4/13nUN+OPhMnfw7zVbO7aiZeGjiHPnUznnds5YeVCMrP3siO9Ec8cOobe2zexokV7pvQaSrNgAQC7UzMAeOfTZzh3xVw4fRgc1jOW70jEmWDNv3hfAvyvohKsUuogY8ym0POBQGfgt/KOrUuSeEXd27S7JOkCfLkgPhJvfdU4DeY8yLr1OXy5K5XDVtosWJjPX0661NlvG/AF8RjDwF3ZpNiGHsCyjPSSaxjD7peuhy4FTrV6Q6+hEPHiUuD68A1KqanAbcYYDdynlBoMBAEfMD68FBwrknhF3WvXDLq3hVVbnNdH9IltPOECQae+1e2OdSROZ62XvoEOLeHaE8qPacdep/02LQmuH1f+MKbd2SzOS2HE217yfAFcCpoGbCgIQLIbAjYoRbMCPym2M8pOAR18AfYkJznXUIpurZOgXVrtvV+RsGo6gYYxpkc528aGPb+k5lHVHkm8ou4leeHHe+CVb6F1E5hwdKwjcrwxHf70HLgUTL7eabetC8bAOzNhyx646Aho3RT25jrV8dv3Osfc9wFcNw5uOQt+XQ/rd8KRfWHMHbBknXPMs9Ng/n+gRSPndTAIZzwEn82jZZPmtLvoFla3yMQGdqclQ24hadmGjCQ321OSKHC7SrXztvAFSLJtfC4XYw52M7prPfgyIuJSMAHmZw6njEnMeSTGjx9v3njjjViHIeqTRhdAjtOuSesmsO3Vurnv7e/AXe8BkN2xLeu+f5h+q1bACffsf+xZw+HD2U5PqL7t4dcyQ3tcYR9gyR7IL+mp/OKho5l48p9K9hf4oTDAidm5zOvUnF1BReesPA7OK8Rr2wzr7qHLwan0G5zGwM5eXK7E+nAUFYr6L8Koq7aUSkQznm8b179sUuIVokhKUkniTfHW3X2/XlT8tNH6LZx37zpmTHmEZuUd+8Hskudlky447bVF8ksPD9qbHFZNbAwEbNIxNOvXiJVXpRG0DRv3JtPGbfP7ziBr/R4yGykGSUlX1DJZj1c0DNPmO8u1jRsMgw+OdTSR2bIbcguhW9s6u+V3qwMUBuH47u6qS2xv/QWungRuF7x4dd0EmJ0POfnFL/3KxaPfvkkzX0FUb7MnOY2nhh7nvDCGtDwf3VKCfH5TUzo0K0qsih25Qfo8W0BWAZBiwOuiY+MgC67w0jw1sT4cRd05gF7NDZIk3obo07lw2gPO8/s/gvmP1P8VZKb8ABOedjov/flEeOpPVZ9zgP72eQGPznRKfRcM9PDmeamVn3DsQFj9bK3HVcpd78GSkh7eXmNz3Lpl2ERxWrnGqTTzBfg592vuPfpC0gKGo9slMXpQCqnJpe8y8cNQ0vW4IMlJyOuz4aHZQR44Sj4uRO0IxDqAOiZ/SQ3RD7+WPC/wwdxV9T/x3vehk3TB6YV753nQvFGt3vKNBSV/zm8vCvDKmTa/bDa0TFP0aFVPZkst6jxVxn7f/1O88NdT4KPZsHUPJHlg+77yTnV4XE5v6K6ZMOUGyGxGO+CZKgMqv+QRsMvdLERUJFqJt558+ohqOW4AuEL/dRkpcHiv2MYTifApFJukQXpKdK67dB3cPAVe/dZptwxzSNuSX+8+rRTnvFXI4c/l0fvRXCb/sv/0iLFgbjyZ/KbOF5BtaY0BCHo9+6c/28DZI+D/ToM8H+ysYuaogA1rt8O3i2H8ExHH89jJybRIc85Psp2+pgNaw9+HSTuvqD0BVfoR76TE2xCdMAh+uBt++R2OGxh5m+mmXfDGD3BQc7joyJpNgvD9Eli2EU4aDJ1aR37eq3+GG16GrFyntJschc5LW/c4KwIVzTm8KxtuOq1493sXpHLf94UUBpyq5sOec9pSbQPP/OzjksFVxLA316keX7IeLhkNt55dszi3ZTljlgd2hoxQdfcf2wn6Atw5ZTuTz70NlIscbxKT//cSJ61ZtP81fAG4/BlYtsl5Xh3694gPtdq72XlbI2zb4HIpjDGoBCuNiLoXSLDhRJJ4G6JAED6Z43SugsiqmfMKYeQtznqx4CSCu86v3n3fmQnnP+o8v+s9WPwYtNl/zt/yzLKb8X/HXkeKF57qmUxUVnRdvrEk6YLT4/dPx0ITZ8al5mmKR8Y5JevsQkPTFJz2S6BbC5dTQl6zDZqll1/tfe+H8PEc5/m/3wZ/0Jmkwu2CpqFZnbbugZ37oG9Hp9r/wY9hwy4Y2h3ufNfpPBW0Id/nTBoy63647iV4ZyYu4C5g/djLmdz/CF7534v7Jd1S8yf7g06Vc4GveP+elDRWnXMcfUa0I+PnX+HH5dzffwxftOzOuYt/4rSV82lx5hA27LT5ZnUA6yA3QzpUXHrdvM9w4zQ/WQWG20d7OKyjlHRF7fMnVt6VxNsgPT0V/vOZ83zGMujfCY7uX/k5a7eVJF2A75dW/75Tfyl5vn2vs3zcSVaVpxljOPX1fHbmOlXBF75TwPzrwxLXzOUwoDN0b1e9eA7tCh1bOpNJAMxZCSNuhrkPOpP4n/YArNwCfz6RRg+MZ9qEVB6e4ad1huKBrrugx73OurMpXvjsZqdz1ezfYPyTkFsAfcusvnPXe3D3+87zBy6CXu3h7IedEmhGitNju6i6+5Vv94931RbodZ1TMqckodqhFp92OVmlDl/evC0f9h7CzbP+SyAlmeRHLgXbZvulk9gV9HD70WfzdZ9BZAXdNNpmaNFnOFu7KAqMc70ZHXry53GX0SzJ4H8ylxyf853hy8tSGdOt/D/9CZ/4+Op3p0F37iYfW/+eQrInwT4VRZ3zJ1itiiTehmjT7jKvI1jhqmsbp0p6dWiaxuMGlH/c71vhm0XOECWrW+l9o/o4VdUAjVKdZBmB4OxV3DBtFnMzu/Df7oPYnmNg8R/Ofe7/2CkxetzOjEsDO8ObN5bMvlSZpukw50EYey8sWONsW74RflkDr34HC9Y62x78GDJSGPbgx3zg9cCr18Ixz8IOJwFS4Ie73ocxh8DJ9zvxgPOzUytYt6PknkWJ9eYpTsxF1b45EQ7/CSXdcOeumMsb/Ufy8LCxjNy0knS/jw/7DGH8iVfRucDP+/2PZWVaKk3nemmUrFg14WGnKOxWYLshaJPts8nOBzDgVaUm0tiTb4q7jQZtmLYywJhuHpbvsJmz0WZkR5dTAwBs2FfSTp5VADk+Zx4OIWpT/ehxUXfkT6oh+tOxTgLclgWHdIJTh1Z9Tmoy/HSvszbrQS3Knw5x7TYYfJOzjJzbBV/e5iSj8Ps2TnXaeM8a4fSarcryjXiO+je3Fjp/Wueedi3Hn90NrP9zVikqEgg67+fLhXDHO5EPN8psBqcOKUm86SnQLXO/jlbc+4GTYAGumVSSdIts3u30tg5b+J2gDcuehAsfg0/m7n/v6ra1hju0i3P9JesYuXEljQvz+bZzXzpe/RgtCnNYdVAHeu7OoUUgCLgwLjdbc2BrTtj7Chpw2fu/V1NmgT+lcCvncICZ6w2NHvWRuy+IMZCRBHMnJtO7lYt/jvRw2ad+gjZMHOymRVpilUREbORJiVfUiZ9/K+kc1aOaVaw92sGqZ2D9DqcUG2lHpdZN4S8nV7z/h19L1m4N2k7VclHiXbER7nwPUpPg3gugbYQLvevVEEq6q5u2ZkG3Xny4OINFR5zLE9++Wf45uYWRXbvIrWdBerJTlXvWYfDBz041cf+OsGorXH0cvPgNxd+rk7zOIu7LNpRcY802uLnMFKKdWsH8NU4J/PH/Op2Uitp87SqmWg3PdGXddo7TwQzgrIdJ/Xguf533BXcccSa7GzVmd5Mm4FFk+IPFp1Q4ibzB+ZJklxxbVNp1KejZQjG0vZsZcwpYg/N7smCNj8LGyc65OKXar1bb9G7l4uKBHo7u4ibbZ+hdX4ZcibiXn1h5VxJvTEybD+PuA9t2lmxb8Igz3rI6GqU6HXqiyTrYGR9aVJIbEbbm6vF3lbSlrt0O398V2TVH9naGD+3N4/ZRZ7DK7QyZedI6jvG//oS1fR2cMgQ273HGI3dqBTefUfoaN70G7/7kVH9PuaGkZ3CRbXudEumqLfC5dq4FcP5ImHGvU32cV+h8QWnTxOlhPaIHXPA4/Pgr7AyVfvN8BFs3xb09q+R9HncnhT/ex9QdGXTPS6Zf+H07tIQ9OaWrmQ/OdNp/z36k4n+T8Ormp68gf/56Pu81mJ65+WxplEKO10Nanp98l6LonWYEbfa4XCjA6wZfEIozp0s5k10Yw1WDFLnGw4a9hhtHeDillxufz5A5UxHKuxS6XKEe7ab4dOugkk++9k0UtTAdrxAV8iXY75sk3liYtsBJugD78pzORdVNvLWhXycnoX6unV65pw1zthf6S5IuwKrNkV+zSxuY9xB8vQivGQBhhUzPBSNh3AQW9+nL20uC9Goc4JKhKaWHOX0xv6Qj2cZd5N33KWn3OaXFoG3491c+Rt39OifOWrH/vd+Z6VQ9z1hW8j7uPh9Gh9Lnh//n9A4//cHiU8YeeTnXLPiOU1cvcDbk+7j17qU80vsoMnoPYs1PC2mVsw/SkuHtG2HqfGdyEHAy2Lt/g68Wlo7DpZwcV1Ql/OaP8LRTlX7v8jRuPe8+GvsLSFVejtu4GxeQ43Jx9IWtOLSt4u3FATq53Iwf6OawTh7SPIa5mwz+gOGYl/MpKhhfNtDFc6fvPztXUpJiaDPDl6Ghv2nGJi/JBcrQpwlcbbk5XHovi1hKrLwriTcmRvWBJ/7nPE9JgiHdYxtPuMN6OY9wyV6nfffFr53Xfx67/3mV6d4Ourfj7iybFW/ms2qXzZ9HJDHw2DPYvM8w6ukC9oVql7PsIDeMCPu1zCtd7fzMt9lMnZTHFxNSeVn7uX+6j75Z5XfNsI1i8ZIsBoZvdJepPj1tGLx2HT9NXsRTGX35qushJAcDjPt9ER5jU9ClLS90HQ5ATnIqJ532F+YsfR16HgT9OsLgg1m7qYCcRRtYc9rRHN2vK428brjnAyf2tGSYfhdc+XxJZ69Qp7THphdw66dO1f4+j5d9qUmMvrgV/qwAfXulcGwfZy3co/uUXWNXMSJU2fHTVWm8NM9Pl+aKm0Yl7fdvsDXbZvEWm1eva8Ir3+bz3mpDVqNUju8MP6+BpdsN138RoEmKYvwA+TgQoi7IX1osnDnCGb6if3cmoqjv0z0CTLoaLh/jtPEe0rlGl+jQ1MXsa9NLbft1h12cdAFmbbC5YUTYAacMcRaC+N8vLG/elses49myJsiHSwOsz3JKkHcefhrDN6+my76duE4d6sxlbRv+MuYCXj7kSN7f4WPUltU0OsOCc0fuH9glR/FZ68N49wdnfOx/uw/i0Al3MSx/G2feMJCCj0uSdfesbSzaYtNhxUIyMl7nqGETmNXuXMg0kA+tHs5l8z87Ys97hDcnLeejpgczOKc9d0y91eld7XbBzWcC8OB3YVXUAZsMr+F0K412jSP/+j+kQ8XjclfttBn+bC6786BVuuLIfsksdinIhRcXG8hz/v2MgTcWBSXxitiRzlWiTpw8xHk0JMN6RP2Sg9u6aN9YsTE0jOWUXmVKpF4PfH4Lj0zbx9+nl/xxNklRXG55ee0XP6vI5OR/P8pPVyTTrLEHPpsLU37k/c4jybM9jDvrr6AUu27LoHk5Y1J/WO1n/kY/BzVV5AUV+T7D0syOrHR14PWPbfy4wOOikfGzrE17Bl55P03zc7k0axmzNppSvYp3+BSXfFLIgrWNWO61oNDN59/5aJ2RwTWPXQbAjHVBXp3hY3fABW6cjlrGMNHyVCvpVuWDJX52h/rK7cg1rNwapPhPXjm9mXNCc3Ec0qYedqQyxulvEI1ZzoSoRyTxiphqnqZ49RQPHy0PclIvD2N7lF96u3ZMIxZmFTB3Y5Az+no5qbfzq7vypnTW7rbp2cpFqlexNdvwQ9dBLL+8P1u/yAdsCNi0b+2lWTmLE63ZGeToyT5sV5n7eg2+ommuCEKql+ykZBYc1BWArNR0Hk8NTR6ilJMkmiaDx8Vba43TTdPtD+2Daz/z8f5CP3kB0NsVdsCQkR/AH9bx+eAIO4pHqleZXslXDnJzz3zYkguX9ndx7SHJvKADdGyi+MfIevZRsHAtjL0HtmbBX06CRyfEOiJRm6TEK0Td+WCJn3PfKsA2MH11gCOuTSMjef8/wlSvYko5y/o1SVEMbOckzS3ZhkHPF7A1B1SZtuGNuTD61UKS3Io7jyqZCvGb34PYrnJKe8Eyy/EUDQ0yJuxDIpRwPa7in2337uatt56k0+7tdL36UacLcsj0jTiTW3hdeFWQZoV+cpJKSnOtynnfB6JFEw8XDkliX67Nab09XDbEy1VDDbl+aJTk3Ms6aP924Xrh1rdgS6h3+mP/hSuOcYaAifiUWHlXEq+IrbcXBoqHxC7fbvPLpiBHdvUQCCU6jzvyv8jv1wbZGuq5a9xu8IeSpwLcbn5cZwDDrA0+dv4jhVSv4rjuHpQJYIp6HhdJ9Tj1sEXbvE5yqJFdLgAAFdBJREFUvXXmxzwx9ESyk0NfAoqSsAvI8aH2FPBSn5FM+XwSnffu5I+WbUquaQzkBsDrIkVBm0CADaHEm4whFxdP6yBd/r+9O49zsrr3OP45z5NkkhmYYdgGBGV1RVaPFEVUFsWlaN13XMGt16X2auta61JrvdW2alt8abWItipoBderda9VTy1XFBSryL5vMmuW59w/nsAsBGFgkmcy+b1fr7wySZ6EX3gl+eacnKUDDK1wWFdjqYxbOhU7dIxaOkQVrpP5/+NX78S59tUEpDy6ekkGVdWw2rp4KFZ1jvH5tw4PfBLnztEhxvdthd3KTcUafCFQyl/WU7RhhZW8ErwiUIO6O8xIby9cEvE3L3jikyQX/s0fqfzw8WHOHLRjL9OBFQ4hJ713bFEIIo7fUi0KNVrMojoBm+ogFoYOMYVNpPxBT0Wu/yEfUsRqEjjtQtwyOswv36hjbW0Kkgm6rV3Hje88x3XjGm8wEYvHqfFclrUrZ9qAkdSEIjw7/V70pDtIbe7GLgmBE4b1tWzyLN1LHEZuqmFTyKH/gaWc/6L/RSGU8kg5ys98z/q1WyCZoixsSXrgAeP2DLN/V3jwwxQbPWfLF41VhPgsFKVfjd/qb7eykg9SZXhhh5OmJ1lzdZhoa19/+Z5z/dXEFq3xt0JsDdPtRPa08pdjS5PgFYG6cUyEkojiyzUe5x0QpkeZw+Uv1FGbXsPj8hcSzQrel86OMGNeimHdHT5aYZky2/NDq0HwxkLQtZ3/To+FoTQC39Z5fviGoNR6TBoeYuKwKFW1HtfOqvW7k0MOfxw8mk+m3kwsGeeeEcewqLQzxWHL4CWLeL9Lny3/xkfd+vJRt34MW7uJjyo6QNT15/N6QFkRrKjk2JPLOawrLKxWnPxsCtKNvKTrUFQdp85t8ruz67Ax7m1ZNWvmZwlmzk8vhhFu/MmVaNCodS241uJ5fjdzbRKirf2d36srvPeLoKsQubITwauU+gaoTZ8ArrPWvtLkmGLgT8AB+CuW/9haO2tXSm0Jrf3tJ9ooay0vfenhWfjRIWGcBl2osXD99n3FzexhHNfPZVw/P7B+UGWZOa+W5emFonqWQkkYHv5BfTdmUUjxt4kxjnysjkTED7FvLaxOKgZ1d5m30vp3ioYgafnM7cURF/yC1/r29gMv5TGml2UW/aG6ftnGpR07MfmUi6Eu5YethUYjqYpCjNkrzJ5dXC57tI6y2gSVEf/tWJxIEk56Wwev/x/X+LJS9atQhRQkbfoqhYffA748FiHhOuAorj/YoUO0wJoXIg/s9GvyZGvtd2219mPgW2ttf6XUnsA7Sqn+1trKnf0HW4IErwjEJTMTTPmXH1QTB7s8dmJ9GE47KcIlMxNY4I8Tdv63vc4lig8nRZn5RYp9uihG98k8Ynr/bg5RZRttTbYoPb1pSZWC0iI/3Ir8NZPf3n33+t92XQcVBVJJf2qQBWXBi4T8wN18XF2q0UCrA/pGWFYFy6tSxEKQ8CxDVm0k7jqU1CUxm/cH3ryyo013OTtO44Ffmwd7JYEih3JSdIrH6do9TKKumKoNSXp3DXHNKJcTB4SoaJcHv++KwpO974KnAecCWGu/VEoZ4Gjg6az9iztAgre5lqzxt5yr6OCPtMw0IlZs1xNz6luHT36a4rEGyzOP7uPyxRUts4RhzzLFpcO3/TKfNS/JKdNq/K7tZBxKIrhYbjjED/wkqvFUh5CDU1e/K1FxCJy45wdrmgWoSfrdy5s/UTwajYhesCrJ4X/yw33iYJdOu0f5fGWYopRHqCLGwR0d1m9K0qFIcdWoEJNmemysSnebO/7jhRyYdlqYO97xSKI4fXCIc/d32KMF5wILkRs7/ZqdppRSwLvA9dbaDU1u3wNY2ODyIiDw4fESvM1RG4dRN9ZvKP/lcvjVucHWlKeGdnd4Z6HfchvaLbiguOvN+Jbfk0lZph7rcEQ/l4r0b8Cbajy/pen6U4eclOVnY8L8/B8e1QnoFLO893Uq42MPKId1cVi+uVNrfY3fj+5Z1lXHob2/LvWMeSk23RCjLmmpSfgDvpo6ai/LmmrL/FUprpxVR8iBx0+LMmS3EKfuv9XhQuSXJi95pdRkYHKDq6ZYa6c0udcoa+1ipVQRcB9wP3B2NstsKRK8zbF4TX3oArw9N7ha8tyzp0e4+90kKQvXjgzuZdi9QeswGoKj+7t0Kqm/bnU1UJvyPxg8y1UjXFbWQHWt31pdvNaDZObt//bsqJj1eQpC6da7Wz/yWBWFsOnW735d/POikNrmpvPtixTtixR9yh0+31um1og2pknwpkO2adA2PWZx+rxOKfUg8HyGwxYBvYDV6ct7AG/sYrW7TIK3OXp1abyP6zHDgq0nj3UqVvzyyOAD5IHji1DAik2WnxweaRS6T8/zuOI1D8IOLpbDdlPceFiYx/8vBWRu5W7hKkb0cnl+vh/Kylpsgw+XsKs4X7so4NpDQry+0KN7iWK/ztJNLApR8173SqkSIGSt3Zjuaj4dmJ3h0KeBiwGTHlx1IHBGhuNySoK3OSJheOd2f7u5buVw4oigKxK7qGs7h6fOyrCWJPCXuakti3ukUNw0OkR5THHZcJc11RazzOOEfUJ8uCjF4x8nqEl3Wbsu/NchEWIRhZcerW2VotzzWJ+e0zu8T4g/TIiQ9Cxjn0rx9hJ/ttHUYxzO3FfGDYgC0/zvmxXAdKWUiz+scS5wGYBSajZwjLV2GfAr4FGl1H/wvy1PttZu2sZj5owEb3N1bA+XHR10FSIHhlY4zPjCb9m2i/hdxwCuo7h1TH1r/SIdZsqJUZ6ek2DRBsvlI8JEw4qZXzRuFafKiyCh6FmmePwUfxT31M8sby/yV8TwPMtvjZXgFYWnmWs1W2u/BoZu47YhDf6uAk7ZpdqyQIJXiG24fqRDuwh8uc4ycaBDj/bf/eFwysDGXecT9na576gwL/8nxaG9HH56aJg11ZbyKFuWfrzpraQ/FQgAxZxlTdaIFkK0OXkfvFrrB4CxQB1QCVxpjDHBViXaAkcprhq+a9OarjwoxJUH1b/NOhc3Du91lZaG/WxxyV0h2ry20Kf1EjDQGDMY+AXw14DrEWKH7ZGKN7rcv2znH+v86XVEbqul5NZqrpnq/4w17ZMkZz4T58EPk9u5txABUk1ObVzet3iNMQ3X3Xwf6Km1dowx0nYQrd7N4yOcNTOZXojF8vujd26bvoUbPB79HHAdEq7Dw196DPpnHee95L8NnpyTojwGZwzM+7e8aJMKIG0baGvvwh8CL0joitbus5Upnp+bZFB3lxfOCvH3BR5j+zocvo1lLbcnkaLRABWLYv7axvOL563OPN9YiMAVVu62/uDVWn+MP+k5kwpjTCp93OnAmcCh3/FYW1ZD6dZNthkTwVi43uOgB6vZ5O/axxOnR7ln/K7Nae7fyWFsN4/XlyvCnmV8xyQXj4zxyNw6VlRCWRROHdAyy3AK0eIKLHiVbbrbSR7SWp8A3AOMNcZ8syP3Oeecc+zUqVOzWpcoHD+aVcszc5IM393lsVOjREPw969StC9SjNijceBNn5Pg5CfrIOKCtZyzn+LPp2WeS9xctQl/PedoxB++sbrK8q9lHgMrHHrIGs6iZbT4C0ndXNMoiOzPM6yb2oa0+hbv9mitvw/8GjhiR0NXiJY0c26Se99NALB4Y5Ih3eN8vMzj2c/8AU13jI9w/eiiLcevqrH+fofpKUXvt2AXcDTceLxklxLFUXu6vLvE8tZSj2P7KsqK2vRnmshHBfaSzPvgxd/kOA48o7XefN1YY8za4EoShaQq0Tg411bbLaEL8IhJNAreyqRqNJ+gOtX8T52ahGXGp0k6xBTH7vPdb+OHPvGY/Ko/7GH/zvDhWS6xcIF90gnRiuR98BpjugRdgyhsJw4IMX4vl1fmp9ivq8M1o8JM/zTJ4o1+IA/o2rir+ZJhLre/l+DbhB9+P9TNm9VnreWoR2p4e4G/MtaPR4U5YT+X3h1ddivb+rGe+qL+i8Gna2DeOhhW0ax/UojsKrDvgXkfvEIELRJSvHxBMVVxS0nE/wR5fVIxd78Vp30R3Dy2qNHx7aMOK64MM/0Ly14dFcN77Fjwrqq0vPpViooStSV0AX73jzj3/G+S4gi8fHF7RvVrPFBLV8Br6R1JO8Wgd+kuPFkhsqGZS0bmOwleIVrI5tAF6NdRMWFAGM9CadHWx8YiDmcP3PHHXldtOXBKHYs2WhSW7u0Vyzf5Ldm6uH9eHYeH3q/bKnhvO8Sha7Fl0SbLhfs7dGzb41aEaPUkeIXIoCpuufXNJCsqLVeNCDFst8yt0gXrPS6emWBdjeW2MWGO3tPvVj7lqTgz5vm/q3aKwb8vLWL3DN3AO+qDpR6L0l3XFsWIvmH2Lod4wnLfG9Vsnrjer/PWU4ZCjuJqLWErWrECe3lK8AqRwRUvJnjk33537gvzU3xzdZT2GUYDT3o+wetf+7F38l/jrLo2SklE8ey8+jVc1tbApbMSzDrLb/r+a0mK1VUepVGHA3s6hN3tf+rs10VRHIZqf/A0h/Z2uSq9BvTIPRwe+6iO/SpcfjouukvPW4hgFFbySvAKkcHc1fXBua4GVlbajMG7trp+4FJ1wj+uY8yfolvXYFfAN75O8fHSFNe8HOfNL+tHPI/p5/LKBTFC2wnfXh0c3jiviCfnJNm3i8OkA+pbticOjnDi4J1balKIVqGwcleCV4hMLhwW4oOlCayFMX0c+pRn/mS4dXSYU/5SR7w2BQr63WtBwUhVw+JKh0XtomAt1dUe4x6uYX1146lHf/8qxZwVHkN7bH9VqeE9HYb3lIAVIt9J8AqRwUUHhBjew2FlleXw3s6W/XObOm4fl97tPObXAiF3y6IYH3hRjl+7hsEbKplbHOWrkijra7a+fzQE3WVFKVHoCuwtIMErxDYM6rZjg6FSGRaeSjoOnlLEUh7RzcuyhhwIO34/dMKDqgQPnVREt/ZtYXdOIcSOkne8ELvo/uOilESAlAfpkN2/toawtezWPcTj/11OWakLYddfKjLkQCzEwftEOHuodB0LgVKNT22ctHiF2EVH7R3itycXc+HLKbCAgqNGl3LjsDLat3NwHMX7k1xueSfF01/X3+97veTtJ0QhkhavEC1gQn+HPuUOuA5lMYdzBriUlbo46d989+3i8OiEEN/r7h/fox1cPlTefkIA/m+8DU9tnHzlFqIFdClWzJ7oMnsV7N0RKkq2/vQoDiveO8Nl8SaoKEY2KhCiQMlXbiFaSGmR4tDdVcbQ3cx1FL3LlISuEA01s8WrlOqklHpRKfWFUmqOUmqGUmqrDXOUUo8qpZYopWanTze0eO07QYJXCCFEwJrd12yBu621e1trBwJfAXdt49i7rLVD0qc7WqTcXSTBK4QQIljNzF1r7Tpr7ZsNrvon0CsbpWWDBK8QQoi8pZRygEuB57dxyI/S3dHPKaX2zWFp2yTBK4QQIlhNWrxKqclKKdPgNPk77v07oBK4P8NtNwD9093RM4CXlVLbX581y2RUsxBCiFbFWjsFmLK945RS9wB7AhOstV7T2621Sxv8/Wel1L1AT2BhC5bbbNLiFUIIEaydmMerlLoTOAD4gbW2bhvH9Gjw93ggBSzNdGwuSYtXCCFEXlFKDQB+CswH/qH8ZSYXWGtPUErNBo6x1i4DHlNKVQAe8C1wnLU2ua3HzRUJXiGEEMFq5vrM1trP2Ebb2Fo7pMHf43atsOyQ4BVCCBGsAltPRlmbYU+zAqC1Xk3AP7DvgM7AmqCLyJFCea7yPNuWQnyea4wxRwVZTL4r2ODNB1prY4zRQdeRC4XyXOV5ti3yPMXOkFHNQgghRA5J8AohhBA5JMHbum13AnkbUijPVZ5n2yLPUzSb/MYrhBBC5JC0eIUQQogcknm8rZjW+hbgZ8BAY8ynAZeTFVrrb4Da9AngOmPMK8FVlB1a6yhwLzAO/7m+b4z5roXf847WujfwXIOrOgClxpiOwVSUPVrr7wO3Ub/I4a3GmBnBVpUdWutj8Z9rGFgHnGeMWRBsVflNgreV0loPA0bQ+ucat4ST2+oXiwbuxg/cvYwxVmtdEXRBLc0Y8w2wZdUgrfV9tMHPGK21AqYCo4wxn2qtBwHvaa2fM8ZstVB/PtNalwOPAQcbY+Zrrc8Gfg/IPN5dIF3NrZDWugh4AH+PSZHntNbtgInATcYYC2CMWRlsVdmltY4AZwGPBF1LlnhAWfrvDsDytha6af2BlcaY+enLLwLjtdadA6wp70nwtk4/Bx5PtyAKwTSt9Sda6we11h2CLiYL+gFrgVu01kZr/abW+pCgi8qy44ClxpiPgy6kpaW/PJ0K/E1rvRC/e31isFVlzXygm9b6wPTls9LnewRUT5sgwdvKaK0PAjTwYNC15MgoY8xg4ED838oybWad71ygL/Dv9Oo/1wEztNalwZaVVRfQRlu7WusQ/s44xxtjegETgKfSPRttijFmI3AacK/W2gBdgQ1A4Dv85DMJ3tbnMGBfYEF64FFP4BWt9ZGBVpUlxpjF6fM6/C8bI4OtKCsW4X9QPQlgjPkAf93bvYIsKlu01j3wX8fTgq4lS4YAuxlj3gNIn1fhv2/bHGPMa8aYQ9JfGu8HYsBXAZeV1yR4WxljzF3GmN2MMb2NMb2BJcB4Y8yrAZfW4rTWJVrrsvTfCjgdmB1sVS3PGLMGeAM4AkBrvRd+y+E/QdaVRecCLxhj1gZdSJYsAXpqrfcG0FrvC1TQRsNIa90tfe4AdwJ/MMZUBVtVfmtzIw5FXqkApmutXfzu2LnAZcGWlDWXAI9orf8HSADnGGM2BFxTtpwHXBF0EdlijFmhtb4UeEZrvXlA1QXGmHVB1pVFt2utRwIR4FXgJwHXk/dk5SohhBAih6SrWQghhMghCV4hhBAihyR4hRBCiByS4BVCCCFySIJXCCGEyCEJXiGEECKHZB6vEDmmtX4TOAh/Pm8KWADcYYx5usHthwGnGWOeanC/7wH/BBamF1cRQuQhafEKEYzbjDHtgE7Ao8ATWuv+DW6fB0xqcp9J6euFEHlMgleIABljksBD+L1PQxrcNAMYqrXuC6C1bg+cBPwp50UKIVqUBK8QAUrvW7t53+X5DW6qxd9k4ML05TOAt4DluatOCJENErxCBOMGrfUGoAa4HbjIGPNJk2MeAs5Pb0M3OX1ZCJHnJHiFCMYdxpgOQGfgRWB00wOMMZ8CC4Gb8HczejmnFQohskKCV4gAGWPWAxcBx2qtj89wyBT84H3EGJPKaXFCiKyQ4BUiYOnt5H4N3Jne87ShJ4Ejgd/kvDAhRFbIPF4hWoffAFcDExteaYypBV4LpCIhRFbIfrxCCCFEDklXsxBCCJFDErxCCCFEDknwCiGEEDkkwSuEEELkkASvEEIIkUMSvEIIIUQOSfAKIYQQOSTBK4QQQuSQBK8QQgiRQ/8PyX1t43+kRikAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# create a dependence plot to show the effect of a single feature across the whole dataset\n", + "shap.dependence_plot(\"RM\", shap_values, X)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import shap\n", + "shap.initjs()\n", + "# summarize the effects of all the features\n", + "shap.summary_plot(shap_values, X)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# summarize the effects of all the features\n", + "shap.summary_plot(shap_values, X)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}