From 13ece9b51371aabcf0cd63b11159a82dec2ddeca Mon Sep 17 00:00:00 2001 From: Rebecca Bilbro Date: Fri, 30 Aug 2019 15:43:16 -0400 Subject: [PATCH 1/8] adds advisors names to release changelog (#963) --- docs/changelog.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index 0b4786591..722aeacbf 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -7,8 +7,8 @@ Version 1.0 ----------- * Tag: v1.0_ -* Deployed: Not yet deployed -* Contributors: Benjamin Bengfort, Rebecca Bilbro, Nathan Danielsen, Kristen McIntyre, Larry Gray, Prema Roman, Carl Dawson, Daniel Navarrete, Francois Dion, Halee Mason, Jeff Hale, Jiayi Zhang, Jimmy Shah, John Healy, Justin Ormont, Kevin Arvai, Michael Garod, Mike Curry, Nabanita Dash, Naresh Bachwani, Nicholas A. Brown, Piyush Gautam, Pradeep Singh, Rohit Ganapathy, Ry Whittington, Sangarshanan, Sourav Singh, Thomas J Fan, Zijie (ZJ) Poh, Zonghan, Xie +* Deployed +* Contributors: Benjamin Bengfort, Rebecca Bilbro, Nathan Danielsen, Kristen McIntyre, Larry Gray, Prema Roman, Adam Morris, Tony Ojeda, Edwin Schmier, Carl Dawson, Daniel Navarrete, Francois Dion, Halee Mason, Jeff Hale, Jiayi Zhang, Jimmy Shah, John Healy, Justin Ormont, Kevin Arvai, Michael Garod, Mike Curry, Nabanita Dash, Naresh Bachwani, Nicholas A. Brown, Piyush Gautam, Pradeep Singh, Rohit Ganapathy, Ry Whittington, Sangarshanan, Sourav Singh, Thomas J Fan, Zijie (ZJ) Poh, Zonghan, Xie .. warning:: **Python 2 Deprecation**: Please note that this release deprecates Yellowbrick's support for Python 2.7. After careful consideration and following the lead of our primary dependencies (NumPy, scikit-learn, and Matplolib), we have chosen to move forward with the community and support Python 3.4 and later. From 4db12724d10d4abe6cf97374380d11ac9025ac3e Mon Sep 17 00:00:00 2001 From: Benjamin Bengfort Date: Mon, 16 Sep 2019 09:12:46 -0400 Subject: [PATCH 2/8] September 9, 2019 Minutes (#971) * 2019-09-09 minutes * add additional contributors * small spelling and typo corrections added a bit more about Eunice's role in the meeting --- docs/governance/index.rst | 3 +- docs/governance/minutes/2019-09-09.rst | 208 +++++++++++++++++++++++++ 2 files changed, 210 insertions(+), 1 deletion(-) create mode 100644 docs/governance/minutes/2019-09-09.rst diff --git a/docs/governance/index.rst b/docs/governance/index.rst index d27f18f26..a94daf5ef 100644 --- a/docs/governance/index.rst +++ b/docs/governance/index.rst @@ -215,4 +215,5 @@ Board of Advisors Minutes .. toctree:: :maxdepth: 1 - minutes/2019-05-15.rst \ No newline at end of file + minutes/2019-05-15.rst + minutes/2019-09-09.rst diff --git a/docs/governance/minutes/2019-09-09.rst b/docs/governance/minutes/2019-09-09.rst new file mode 100644 index 000000000..296933a4f --- /dev/null +++ b/docs/governance/minutes/2019-09-09.rst @@ -0,0 +1,208 @@ +.. -*- mode: rst -*- + +September 9, 2019 +================= + +Yellowbrick Advisory Board Meeting Held on September 9, 2019 from 2030-2230 EST via Video Conference Call. Rebecca Bilbro presiding as Chair, Benjamin Bengfort serving as Secretary and Edwin Schmierer as Treasurer. Minutes taken by Benjamin Bengfort. + +Attendees: Benjamin Bengfort, Larry Gray, Rebecca Bilbro, Tony Ojeda, Kristen McIntyre, Prema Roman, Edwin Schmierer, Adam Morris, Eunice Chendjou + +Agenda +------ + +A broad overview of the topics for discussion in the order they were presented: + +1. Welcome (Rebecca Bilbro) +2. Summer 2019 Retrospective (Rebecca Bilbro) +3. GSoC Report (Adam Morris) +4. YB API Audit Results (Benjamin Bengfort) +5. OpenTeams Participation (Eunice Chendjou) +6. Fall 2019 Contributors and Roles +7. Yellowbrick v1.1 Milestone Planning +8. Project Roadmap through 2020 +9. Other business + +Votes and Resolutions +--------------------- + +*There were no votes or resolutions during this board meeting*. + +Summer 2019 Retrospective +------------------------- + +In traditional agile development, sprints are concluded with a retrospective to discuss what went well, what didn't go well, what were unexpected challenges, and how we can adapt to those challenges in the future. Generally these meetings exclude the major stakeholders so that the contributors to the sprint can speak freely. Because the Board of Advisors are the major stakeholders of the Yellowbrick project, there was an intermediate retrospective with just the maintainers of the Summer 2019 semester so they could communicate anonymously and frankly with the Board. Their feedback as well as additions by the advisors follow. + +Accomplishments +~~~~~~~~~~~~~~~ + +tl;dr we had a very productive summer! + +- Larry stepped into the new coordinator role, setting the tone for future coordinators +- We had two new maintainers: Prema and Kristen +- Approximately 12 new contributors +- 65 Pull Requests were merged +- 35 tweets were tweeted +- Only 95 issues remain open (down from over 125, not including new issues) +- 3 Yellowbrick talks in DC, Texas, and Spain +- We completed our first Google Summer of Code successfully + +Perhaps most importantly, Version 1.0 was released. This release included some big things from new visualizers to important bug/API fixes, a new datasets module, plot directives and more. We are very proud of the result! + +Shoutouts +~~~~~~~~~ + +- To Larry for being the first coordinator! +- To Prema for shepherding in a new contributor from the PyCon sprints who enhanced our SilhouetteScores visualizer! +- To Kristen for working with a new contributor to introduce a brand new NFL receivers dataset! +- To Nathan for working with a new contributor on the cross-operating system tests! +- To Benjamin for shoring up the classifier API and the audit! +- To Adam and Prema for spearheading the GSoC application review and to Adam for serving as guide and mentor to Naresh, our GSoC student! +- To Rebecca for mentoring the maintainers! + +Challenges +~~~~~~~~~~ + +- It was difficult to adjust to new contributors/GSoC +- "Contagious issues" made it tough to parallelize some work +- Maintainer vacation/work schedules caused communication interruptions +- Balancing between external contributor PRs and internal milestone goals +- This milestone may have been a bit over-ambitious + +Moving Forward +~~~~~~~~~~~~~~ + +These are some of the things that worked well for us and that we should keep doing: + +- Make sure the "definition of done" is well defined/understood in issues +- Balancing PR assignments so that no one gets too many +- Using the "assignee" feature in GitHub to assign PRs so that it's easier to see who is working on what tasks +- Use the maintainer's Slack channel to unify communications +- Communication in general -- make sure people know what's expected of them and what to expect of us +- Getting together to celebrate releases! +- Pair reviews of PRs (especially for larger PRs) + +Semester and Roadmap +-------------------- + +The fall semester will be dedicated to completing **Yellowbrick Version 1.1**. The issues associated with this release can be found in the `v1.1 Milestone on GitHub `_. + +The primary milestone objectives are as follows: + +1. Make quick methods prime time (and extend the oneliners page) +2. Add support for sklearn Pipelines and FeatureUnions + +The secondary objectives are at the discretion of the core contributors but should be along one of the following themes: + +1. A neural-network specific package for deep learning visualization +2. Adding support for visual pipelines and other multi-image reports +3. Creating interactive or animated visualizers + +The maintainers will create a Slack channel and discuss with the Fall contributors what direction they would like to go in, to be decided no later than September 20, 2019. + +Fall 2019 Contributors +~~~~~~~~~~~~~~~~~~~~~~~~ + +===================== ================= +Name Role +===================== ================= +Adam Morris Coordinator +Prema Roman Maintainer +Kristen McIntyre Maintainer +Benjamin Bengfort Maintainer +Nathan Danielsen Maintainer +Lawrence Gray Core Contributor +Michael Chestnut Core Contributor +Prashi Doval Core Contributor +Saurabh Daalia Core Contributor +Bashar Jaan Khan Core Contributor +Rohan Panda Core Contributor +Pradeep Singh Core Contributor +Mahkah Wu Core Contributor +Thom Lappas Core Contributor +Stephanie R Miller Core Contributor +Coleen W Chen Core Contributor +Franco Bueno Mattera Core Contributor +Shawna Carey Core Contributor +George Krug Core Contributor +Aaron Margolis Core Contributor +Molly Morrison Core Contributor +===================== ================= + +Project Roadmap +~~~~~~~~~~~~~~~ + +With the release of v1.0, Yellowbrick has become a stable project that we would like to see increased usage of. The only urgent remaining task is that of the quick methods - which will happen in v1.1. Beyond v1.1 we have concluded that it would be wise to understand who is really using the software and to get feature ideas from them. We do have a few themes we are considering. + +- *Add a neural package for ANN specific modeling*. We already have a text package for natural language processing, as deep learning is becoming more important, Yellowbrick should help with the interpretability of these models as well. +- *Reporting and data engineering focused content*. We could consider a text output format (like .ipynb) that allows easy saving of multiple visualizers to disk in a compact format that can be committed to GitHub, stored in a database, and redrawn on demand. This theme would also include model management and maintenance tasks including detecting changes in models and tracking performance over time. +- *Visual optimization*. This tasks employs optimization and learning to enhance the quality of the visualizers, for example by maximizing white space in ``RadViz`` or ``ParallelCoordinates``, detecting inflection points as with the ``kneed`` port in ``KElbow``, or adding layout algorithms for better clustering visualization in ``ICDM`` or the inclusion of word maps or trees. +- *Interactive and Animated visualizers*. Adding racing bar charts or animated TSNE to provide better interpetibility to visualizations or adding an Altair backend to create interactive Javascript plots or other model visualization tools like pyldaviz. +- *Publication and conferences*. We would like to continue to participate in PyCon and other conferences. We might also submit proposals to O'Reilly to do Yellowbrick/Machine Learning related books or videos. + +These goals are all very high level but we also want to ensure that the package makes progress. Lower level goals such as adding 16 new visualizers in 2020 should be discussed at the January board meeting. To that end, advisors should look at how they're using Yellowbrick in their own work to consider more detailed roadmap goals. + +Minutes +------- + +In her welcome, Rebecca described the goal of our conversation for the second governance meeting was first to talk about how things went over the summer, to celebrate our successes with the v1.0 launch and to highlight specific activities such as GSoC and the audit. The second half of the meeting is to be used to discuss our plans for the fall, which should be more than half the conversation. In so doing she set a technical tone for the mid-year meetings that will hopefully serve as a good guideline for future advisory meetings. + +Google Summer of Code +~~~~~~~~~~~~~~~~~~~~~ + +Adam reports that Naresh successfully completed the GSoC period and that he wrote a positive review for him and shared the feedback we discussed during the v1.0 launch. You can read more about his summer at his `blog, which documents his journey `_. + +Naresh completed the following pull requests/tasks: + +1. Added train alpha and test alpha to residuals +2. Added an alpha parameter to ``PCA`` +3. Added a stacked barchart helper and stacking to ``PoSVisualizer`` +4. Updated several visualizers to use the stacked barchart helper function +5. Updated the ``DataVisualizer`` to handle target type identification +6. Added a ``ProjectionVisualizer`` base class. +7. Updated Manifold and PCA to extend the ``ProjectionVisualizer`` +8. Added final tweaks to unify the functionality of ``PCA``, ``Manifold``, and other projections. + +We will work on sending Naresh a Yellowbrick T-shirt to thank him and have already encouraged him to continue to contribute to Yellowbrick (he is receptive to it). We will also follow up with him on his work on effect plots. + +If we decide to participate in GSoC again, we should reuse the idea list for the application, but potentially it's easiest to collaborate with matplotlib for GSoC 2020. + +API Audit Results +~~~~~~~~~~~~~~~~~ + +We conducted a full audit of all visualizers and their bases in Yellowbrick and categorized each as red (needs serious work), yellow (has accumulated technical debt), and green (production-ready). A summary of these categorizations is as follows: + +- There are 14 base classes, 1 red, 3 yellow, and 10 green +- There are 36 visualizers (7 aliases), 4 red, 7 yellow, 25 green +- There are 3 other visualizer utilities, 2 red, 1 green +- There are 35 quick methods, 1 for each visualizer (except manual alpha selection) + +Through the audit process, we clarified our API and ensured that the visualizers conformed to it: + +- ``fit()`` returns ``self``, ``transform()`` returns ``Xp``, ``score()`` returns [0,1], ``draw()`` returns ``ax``, and ``finalize()`` returns ``None`` (we also updated ``poof()`` to return ``ax``). +- No ``_`` suffixed properties should be set in ``__init__()`` +- Calls to ``plt`` should be minimized (and we added ``fig`` to the visualizer) +- Quick methods should return the fitted/scored visualizer + +Additionally, we took into account the number/quality of tests for each visualizer, the documentation, and the robustness of the visualization implementation to rank the visualizers. + +Along the way, a lot of technical debt was cleaned up; including unifying formatting with black and flake8 style checkers, updating headers, unifying scattered functionality into base classes, and more. + +In the end, the audit should give us confidence that v1.0 is a production-ready implementation and that it is a stable foundation to grow the project on. + +OpenTeams +~~~~~~~~~ + +Eunice Chendjou, COO of OpenTeams, joined the meeting to observe Yellowbrick as a model for successful open source community governance, and to let the Advisory Board know about OpenTeams. OpenTeams is designed to highlight the contributions and work of open source developers and to help support them by assisting them in winning contracts and finding funding. Although currently it is in its initial stages, they have a lot of big plans for helping open source teams grow. + +Please add your contributions to Yellowbrick by joining `OpenTeams `_. Invite others to join as well! + +Action Items +------------ + +- Add your contributions to the Yellowbrick OpenTeams projection +- Send invitations to those interested in joining the 2020 board (all) +- Begin considering who to nominate for January election of board members (all) +- Send Naresh a Yellowbrick T-shirt or thank you (Adam) +- Create the Fall 2019 contributors Slack channel (Benjamin) +- Start thinking about how to guide the 2020 roadmap (all) +- Publications task group for O'Reilly content (Kristen, Larry) From 8e048a04589c491b5a04540d5aef766456f8a85d Mon Sep 17 00:00:00 2001 From: Kristen McIntyre Date: Mon, 23 Sep 2019 12:03:13 -0400 Subject: [PATCH 3/8] Update clustering and regression example notebooks (#970) * Update clustering and regression example notebooks - In the clustering visualizers notebook, fixed calinski_harabasz_score typo that was updated in the documentation and library in PR #902. - Renamed the example notebooks so that new users can easily identify them. Issue #470 * highlighted Visualizer in regression_visualizers.ipynb --- examples/clustering.ipynb | 249 ------------------- examples/clustering_visualizers.ipynb | 332 ++++++++++++++++++++++++++ examples/regression.ipynb | 239 ------------------ examples/regression_visualizers.ipynb | 279 ++++++++++++++++++++++ 4 files changed, 611 insertions(+), 488 deletions(-) delete mode 100644 examples/clustering.ipynb create mode 100644 examples/clustering_visualizers.ipynb delete mode 100644 examples/regression.ipynb create mode 100644 examples/regression_visualizers.ipynb diff --git a/examples/clustering.ipynb b/examples/clustering.ipynb deleted file mode 100644 index 899a118f4..000000000 --- a/examples/clustering.ipynb +++ /dev/null @@ -1,249 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "import matplotlib as mpl \n", - "import matplotlib.pyplot as plt \n", - "\n", - "from sklearn.cluster import KMeans\n", - "from sklearn.datasets import make_blobs\n", - "\n", - "from yellowbrick.cluster import KElbowVisualizer, SilhouetteVisualizer\n", - "\n", - "mpl.rcParams[\"figure.figsize\"] = (9,6)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Yellowbrick — Clustering Evaluation Examples\n", - "\n", - "The Yellowbrick library is a diagnostic visualization platform for machine learning that allows data scientists to steer the model selection process. It extends the scikit-learn API with a new core object: the `Visualizer`. Visualizers allow models to be fit and transformed as part of the scikit-learn pipeline process, providing visual diagnostics throughout the transformation of high-dimensional data.\n", - "\n", - "In machine learning, clustering models are unsupervised methods that attempt to detect patterns in unlabeled data. There are two primary classes of clustering algorithms: *agglomerative* clustering which links similar data points together, and *centroidal* clustering which attempts to find centers or partitions in the data.\n", - "\n", - "Currently, Yellowbrick provides two visualizers to evaluate *centroidal* mechanisms, particularly K-Means clustering, that help users discover an optimal $K$ parameter in the clustering metric:\n", - "- `KElbowVisualizer` visualizes the clusters according to a scoring function, looking for an \"elbow\" in the curve. \n", - "- `SilhouetteVisualizer` visualizes the silhouette scores of each cluster in a single model." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Load the Data\n", - "\n", - "For the following examples, we'll use scikit-learn's `make_blobs()` function to create a sample two-dimensional dataset with 8 random clusters of points." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# Generate synthetic dataset with 8 blobs\n", - "X, y = make_blobs(n_samples=1000, n_features=12, centers=8, shuffle=True, random_state=42)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Elbow Method \n", - "\n", - "K-Means is a simple unsupervised machine learning algorithm that groups data into the number $K$ of clusters specified by the user, even if it is not the optimal number of clusters for the dataset. \n", - "\n", - "Yellowbrick's `KElbowVisualizer` implements the “elbow” method of selecting the optimal number of clusters by fitting the K-Means model with a range of values for $K$. If the line chart looks like an arm, then the “elbow” (the point of inflection on the curve) is a good indication that the underlying model fits best at that point.\n", - "\n", - "In the following example, the `KElbowVisualizer` fits the model for a range of $K$ values from 4 to 11, which is set by the parameter `k=(4,12)`. When the model is fit with 8 clusters we can see an \"elbow\" in the graph, which in this case we know to be the optimal number since we created our synthetic dataset with 8 clusters of points. " - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Instantiate the clustering model and visualizer\n", - "model = KMeans()\n", - "visualizer = KElbowVisualizer(model, k=(4,12))\n", - "\n", - "visualizer.fit(X) # Fit the data to the visualizer\n", - "visualizer.poof() # Draw/show/poof the data" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "By default, the scoring parameter `metric` is set to `distortion`, which computes the sum of squared distances from each point to its assigned center. However, two other metrics can also be used with the `KElbowVisualizer`—`silhouette` and `calinski_harabaz`. The `silhouette` score is the mean silhouette coefficient for all samples, while the `calinski_harabaz` score computes the ratio of dispersion between and within clusters.\n", - " \n", - "The `KElbowVisualizer` also displays the amount of time to fit the model per $K$, which can be hidden by setting `timings=False`. In the following example, we'll use the `calinski_harabaz` score and hide the time to fit the model." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Instantiate the clustering model and visualizer \n", - "model = KMeans()\n", - "visualizer = KElbowVisualizer(model, k=(4,12), metric='calinski_harabaz', timings=False)\n", - "\n", - "visualizer.fit(X) # Fit the data to the visualizer\n", - "visualizer.poof() # Draw/show/poof the data" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "It is important to remember that the Elbow method does not work well if the data is not very clustered. In this case, you might see a smooth curve and the optimal value of $K$ will be unclear.\n", - "\n", - "You can learn more about the Elbow method at Robert Grove's [Blocks](https://bl.ocks.org/rpgove/0060ff3b656618e9136b)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Silhouette Visualizer \n", - "\n", - "Silhouette analysis can be used to evaluate the density and separation between clusters. The score is calculated by averaging the silhouette coefficient for each sample, which is computed as the difference between the average intra-cluster distance and the mean nearest-cluster distance for each sample, normalized by the maximum value. This produces a score between -1 and +1, where scores near +1 indicate high separation and scores near -1 indicate that the samples may have been assigned to the wrong cluster.\n", - "\n", - "The `SilhouetteVisualizer` displays the silhouette coefficient for each sample on a per-cluster basis, allowing users to visualize the density and separation of the clusters. This is particularly useful for determining cluster imbalance or for selecting a value for $K$ by comparing multiple visualizers.\n", - "\n", - "Since we created the sample dataset for these examples, we already know that the data points are grouped into 8 clusters. So for the first `SilhouetteVisualizer` example, we'll set $K$ to 8 in order to show how the plot looks when using the optimal value of $K$. \n", - "\n", - "Notice that graph contains homogeneous and long silhouettes. In addition, the vertical red-dotted line on the plot indicates the average silhouette score for all observations." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Instantiate the clustering model and visualizer \n", - "model = KMeans(8)\n", - "visualizer = SilhouetteVisualizer(model)\n", - "\n", - "visualizer.fit(X) # Fit the data to the visualizer\n", - "visualizer.poof() # Draw/show/poof the data" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For the next example, let's see what happens when using a non-optimal value for $K$, in this case, 6. \n", - "\n", - "Now we see that the width of clusters 1 and 2 have both increased and their silhouette coefficient scores have dropped. This occurs because the width of each silhouette is proportional to the number of samples assigned to the cluster. The model is trying to fit our data into a smaller than optimal number of clusters, making two of the clusters larger (wider) but much less cohesive (as we can see from their below-average scores)." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Instantiate the clustering model and visualizer \n", - "model = KMeans(6)\n", - "visualizer = SilhouetteVisualizer(model)\n", - "\n", - "visualizer.fit(X) # Fit the data to the visualizer\n", - "visualizer.poof() # Draw/show/poof the data" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "anaconda-cloud": {}, - "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.5" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} diff --git a/examples/clustering_visualizers.ipynb b/examples/clustering_visualizers.ipynb new file mode 100644 index 000000000..7dcdbfb3b --- /dev/null +++ b/examples/clustering_visualizers.ipynb @@ -0,0 +1,332 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import matplotlib as mpl \n", + "import matplotlib.pyplot as plt \n", + "\n", + "from sklearn.cluster import KMeans\n", + "from sklearn.datasets import make_blobs\n", + "\n", + "from yellowbrick.cluster import InterclusterDistance, KElbowVisualizer, SilhouetteVisualizer\n", + "\n", + "mpl.rcParams[\"figure.figsize\"] = (9,6)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Yellowbrick — Clustering Evaluation Examples\n", + "\n", + "The Yellowbrick library is a diagnostic visualization platform for machine learning that allows data scientists to steer the model selection process. It extends the scikit-learn API with a new core object: the `Visualizer`. Visualizers allow models to be fit and transformed as part of the scikit-learn pipeline process, providing visual diagnostics throughout the transformation of high-dimensional data.\n", + "\n", + "In machine learning, clustering models are unsupervised methods that attempt to detect patterns in unlabeled data. There are two primary classes of clustering algorithms: *agglomerative* clustering which links similar data points together, and *centroidal* clustering which attempts to find centers or partitions in the data.\n", + "\n", + "Currently, Yellowbrick provides several visualizers to evaluate *centroidal* mechanisms, particularly K-Means clustering, that help users discover an optimal $K$ parameter in the clustering metric:\n", + "- `KElbowVisualizer` — visualizes the clusters according to a scoring function, looking for an \"elbow\" in the curve\n", + "- `SilhouetteVisualizer` — visualizes the silhouette scores of each cluster in a single model\n", + "- `InterclusterDistance` — visualizes the relative distance and size of clusters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load the Data\n", + "\n", + "For `KElbowVisualizer` and `SilhouetteVisualzer` examples, we'll use scikit-learn's `make_blobs()` function to create a sample two-dimensional dataset with 8 random clusters of points." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Generate synthetic dataset with 8 blobs\n", + "X, y = make_blobs(n_samples=1000, n_features=15, centers=8, random_state=42)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Elbow Method \n", + "\n", + "K-Means is a simple unsupervised machine learning algorithm that groups data into the number $K$ of clusters specified by the user, even if it is not the optimal number of clusters for the dataset. \n", + "\n", + "Yellowbrick's `KElbowVisualizer` implements the “elbow” method of selecting the optimal number of clusters by fitting the K-Means model with a range of values for $K$. If the line chart looks like an arm, then the “elbow” (the point of inflection on the curve) is a good indication that the underlying model fits best at that point.\n", + "\n", + "In the following example, the `KElbowVisualizer` fits the model for a range of $K$ values from 4 to 11, which is set by the parameter `k=(4,12)`. When the model is fit with 8 clusters we can see an \"elbow\" in the graph, which in this case we know to be the optimal number since we created our synthetic dataset with 8 clusters of points. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Instantiate the clustering model and visualizer\n", + "model = KMeans()\n", + "visualizer = KElbowVisualizer(model, k=(4,12))\n", + "\n", + "visualizer.fit(X) # Fit the data to the visualizer\n", + "visualizer.poof() # Draw/show/poof the data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By default, the scoring parameter `metric` is set to `distortion`, which computes the sum of squared distances from each point to its assigned center. However, two other metrics can also be used with the `KElbowVisualizer`—`silhouette` and `calinski_harabasz`. The `silhouette` score is the mean silhouette coefficient for all samples, while the `calinski_harabasz` score computes the ratio of dispersion between and within clusters.\n", + " \n", + "The `KElbowVisualizer` also displays the amount of time to fit the model per $K$, which can be hidden by setting `timings=False`. In the following example, we'll use the `calinski_harabasz` score and hide the time to fit the model." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Instantiate the clustering model and visualizer \n", + "model = KMeans()\n", + "visualizer = KElbowVisualizer(model, k=(4,12), metric='calinski_harabasz', timings=False)\n", + "\n", + "visualizer.fit(X) # Fit the data to the visualizer\n", + "visualizer.poof() # Draw/show/poof the data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It is important to remember that the Elbow method does not work well if the data is not very clustered. In this case, you might see a smooth curve and the optimal value of $K$ will be unclear.\n", + "\n", + "You can learn more about the Elbow method at Robert Grove's [Blocks](https://bl.ocks.org/rpgove/0060ff3b656618e9136b)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Silhouette Visualizer \n", + "\n", + "Silhouette analysis can be used to evaluate the density and separation between clusters. The score is calculated by averaging the silhouette coefficient for each sample, which is computed as the difference between the average intra-cluster distance and the mean nearest-cluster distance for each sample, normalized by the maximum value. This produces a score between -1 and +1, where scores near +1 indicate high separation and scores near -1 indicate that the samples may have been assigned to the wrong cluster.\n", + "\n", + "The `SilhouetteVisualizer` displays the silhouette coefficient for each sample on a per-cluster basis, allowing users to visualize the density and separation of the clusters. This is particularly useful for determining cluster imbalance or for selecting a value for $K$ by comparing multiple visualizers.\n", + "\n", + "Since we created the sample dataset for these examples, we already know that the data points are grouped into 8 clusters. So for the first `SilhouetteVisualizer` example, we'll set $K$ to 8 in order to show how the plot looks when using the optimal value of $K$. \n", + "\n", + "Notice that graph contains homogeneous and long silhouettes. In addition, the vertical red-dotted line on the plot indicates the average silhouette score for all observations." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Instantiate the clustering model and visualizer \n", + "model = KMeans(8)\n", + "visualizer = SilhouetteVisualizer(model)\n", + "\n", + "visualizer.fit(X) # Fit the data to the visualizer\n", + "visualizer.poof() # Draw/show/poof the data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For the next example, let's see what happens when using a non-optimal value for $K$, in this case, 6. \n", + "\n", + "Now we see that the width of clusters 1 and 2 have both increased and their silhouette coefficient scores have dropped. This occurs because the width of each silhouette is proportional to the number of samples assigned to the cluster. The model is trying to fit our data into a smaller than optimal number of clusters, making two of the clusters larger (wider) but much less cohesive (as we can see from their below-average scores)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Instantiate the clustering model and visualizer \n", + "model = KMeans(6)\n", + "visualizer = SilhouetteVisualizer(model)\n", + "\n", + "visualizer.fit(X) # Fit the data to the visualizer\n", + "visualizer.poof() # Draw/show/poof the data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Intercluster Distance Maps\n", + "\n", + "Intercluster distance maps display an embedding of the cluster centers in 2 dimensions with the distance to other centers preserved, e.g. the closer two centers are in the visualization, the closer they are in the original feature space.\n", + "\n", + "The clusters are sized according to a scoring metric. By default, they are sized by membership, e.g. the number of instances that belong to each center. This gives a sense of the relative importance of clusters. Note however, that because two clusters overlap in the 2D space, it does not imply that they overlap in the original feature space." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Generate synthetic dataset with 12 random clusters\n", + "X, y = make_blobs(n_samples=1000, n_features=12, centers=12, random_state=42)\n", + "\n", + "# Instantiate the clustering model and visualizer\n", + "model = KMeans(6)\n", + "visualizer = InterclusterDistance(model)\n", + "\n", + "visualizer.fit(X) # Fit the data to the visualizer\n", + "visualizer.poof() # Draw/show/poof the data" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "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/examples/regression.ipynb b/examples/regression.ipynb deleted file mode 100644 index 6ceb97962..000000000 --- a/examples/regression.ipynb +++ /dev/null @@ -1,239 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np \n", - "import pandas as pd\n", - "import matplotlib as mpl \n", - "import matplotlib.pyplot as plt \n", - "\n", - "from sklearn.linear_model import Lasso, LassoCV, Ridge\n", - "from sklearn.model_selection import cross_val_predict, train_test_split\n", - "\n", - "from yellowbrick.datasets import load_concrete\n", - "from yellowbrick.regressor import AlphaSelection, PredictionError, ResidualsPlot\n", - "\n", - "mpl.rcParams['figure.figsize'] = (9,6)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Yellowbrick - Regression Examples \n", - "\n", - "The Yellowbrick library is a diagnostic visualization platform for machine learning that allows data scientists to steer the model selection process. It extends the scikit-learn API with a new core object: the Visualizer. Visualizers allow visual models to be fit and transformed as part of the scikit-learn pipeline process, providing visual diagnostics throughout the transformation of high-dimensional data.\n", - "\n", - "Estimator score visualizers *wrap* scikit-learn estimators and expose the Estimator API such that they have `fit()`, `predict()`, and `score()` methods that call the appropriate estimator methods under the hood. Score visualizers can wrap an estimator and be passed in as the final step in a `Pipeline` or `VisualPipeline`.\n", - "\n", - "In machine learning, regression models attempt to predict a target in a continuous space. Yellowbrick has implemented the following regressor score visualizers that display the instances in model space to better understand how the model is making predictions:\n", - "- `AlphaSelection` visual tuning of regularization hyperparameters\n", - "- `PredictionError` plot the expected vs. the actual values in model space \n", - "- `Residuals Plot` plot the difference between the expected and actual values" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Load Data\n", - "\n", - "Yellowbrick provides several datasets wrangled from the [UCI Machine Learning Repository](http://archive.ics.uci.edu/ml/). For the following examples, we'll use the `concrete` dataset, since it is well-suited for regression tasks.\n", - "\n", - "The `concrete` dataset contains 1030 instances and 9 attributes. Eight of the attributes are explanatory variables, including the age of the concrete and the materials used to create it, while the target variable `strength` is a measure of the concrete's compressive strength (MPa)." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# Use Yellowbrick to load the concrete dataset\n", - "X, y = load_concrete()\n", - "\n", - "# Create the train and test data \n", - "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Residuals Plot \n", - "\n", - "A residual is the difference between the observed value of the target variable (y) and the predicted value (ŷ), i.e. the error of the prediction. The `ResidualsPlot` Visualizer shows the difference between residuals on the vertical axis and the dependent variable on the horizontal axis, allowing you to detect regions within the target that may be susceptible to more or less error. \n", - "\n", - "If the points are randomly dispersed around the horizontal axis, a linear regression model is usually well-suited for the data; otherwise, a non-linear model is more appropriate. The following example shows a fairly random, uniform distribution of the residuals against the target in two dimensions. This seems to indicate that our linear model is performing well." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Instantiate the linear model and visualizer \n", - "model = Ridge()\n", - "visualizer = ResidualsPlot(model)\n", - "\n", - "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", - "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "g = visualizer.poof() # Draw/show/poof the data" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Yellowbrick's `ResidualsPlot` Visualizer also displays a histogram of the error values along the right-hand side. In the example above, the error is normally distributed around zero, which also generally indicates a well-fitted model. If the histogram is not desired, it can be turned off with the `hist=False` flag." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Instantiate the linear model and visualizer \n", - "model = Ridge()\n", - "visualizer = ResidualsPlot(model, hist=False)\n", - "\n", - "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", - "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "g = visualizer.poof() # Draw/show/poof the data" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Prediction Error Plot \n", - "\n", - "Yellowbrick's `PredictionError` Visualizer plots the actual targets from the dataset against the predicted values generated by the model. This allows us to see how much variance is in the model. Data scientists can diagnose regression models using this plot by comparing against the 45-degree line, where the prediction exactly matches the model." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Instantiate the linear model and visualizer \n", - "model = Lasso()\n", - "visualizer = PredictionError(model)\n", - "\n", - "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", - "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "g = visualizer.poof() # Draw/show/poof the data" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Alpha Selection Visualizer\n", - "\n", - "The `AlphaSelection` Visualizer demonstrates how different values of alpha influence model selection during the regularization of linear models. Since regularization is designed to penalize model complexity, the higher the alpha, the less complex the model, decreasing the error due to variance (overfit). However, alphas that are too high increase the error due to bias (underfit). Therefore, it is important to choose an optimal alpha such that the error is minimized in both directions.\n", - "\n", - "To do this, typically you would you use one of the \"RegressionCV” models in scikit-learn. E.g. instead of using the `Ridge` (L2) regularizer, use `RidgeCV` and pass a list of alphas, which will be selected based on the cross-validation score of each alpha. This visualizer wraps a “RegressionCV” model and visualizes the alpha/error curve. If the visualization shows a jagged or random plot, then potentially the model is not sensitive to that type of regularization and another is required (e.g. L1 or Lasso regularization)." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Create a list of alphas to cross-validate against \n", - "alphas = np.logspace(-10, 1, 400)\n", - "\n", - "# Instantiate the linear model and visualizer \n", - "model = LassoCV(alphas=alphas)\n", - "visualizer = AlphaSelection(model)\n", - "\n", - "visualizer.fit(X, y) # Fit the data to the visualizer\n", - "g = visualizer.poof() # Draw/show/poof the data" - ] - } - ], - "metadata": { - "anaconda-cloud": {}, - "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.7" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} diff --git a/examples/regression_visualizers.ipynb b/examples/regression_visualizers.ipynb new file mode 100644 index 000000000..a95003c25 --- /dev/null +++ b/examples/regression_visualizers.ipynb @@ -0,0 +1,279 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np \n", + "import pandas as pd\n", + "import matplotlib as mpl \n", + "import matplotlib.pyplot as plt \n", + "\n", + "from sklearn.linear_model import Lasso, LassoCV, Ridge\n", + "from sklearn.model_selection import cross_val_predict, train_test_split\n", + "\n", + "from yellowbrick.datasets import load_concrete\n", + "from yellowbrick.regressor import AlphaSelection, PredictionError, ResidualsPlot\n", + "\n", + "mpl.rcParams['figure.figsize'] = (9,6)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Yellowbrick - Regression Examples \n", + "\n", + "The Yellowbrick library is a diagnostic visualization platform for machine learning that allows data scientists to steer the model selection process. It extends the scikit-learn API with a new core object: the `Visualizer`. Visualizers allow visual models to be fit and transformed as part of the scikit-learn pipeline process, providing visual diagnostics throughout the transformation of high-dimensional data.\n", + "\n", + "Estimator score visualizers *wrap* scikit-learn estimators and expose the Estimator API such that they have `fit()`, `predict()`, and `score()` methods that call the appropriate estimator methods under the hood. Score visualizers can wrap an estimator and be passed in as the final step in a `Pipeline` or `VisualPipeline`.\n", + "\n", + "In machine learning, regression models attempt to predict a target in a continuous space. Yellowbrick has implemented the following regressor score visualizers that display the instances in model space to better understand how the model is making predictions:\n", + "- `AlphaSelection` — visual tuning of regularization hyperparameters\n", + "- `PredictionError` — plot the expected vs. the actual values in model space \n", + "- `ResidualsPlot` — plot the difference between the expected and actual values" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Load Data\n", + "\n", + "Yellowbrick provides several datasets wrangled from the [UCI Machine Learning Repository](http://archive.ics.uci.edu/ml/). For the following examples, we'll use the `concrete` dataset, since it is well-suited for regression tasks.\n", + "\n", + "The `concrete` dataset contains 1030 instances and 9 attributes. Eight of the attributes are explanatory variables, including the age of the concrete and the materials used to create it, while the target variable `strength` is a measure of the concrete's compressive strength (MPa)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Use Yellowbrick to load the concrete dataset\n", + "X, y = load_concrete()\n", + "\n", + "# Create the train and test data \n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Residuals Plot \n", + "\n", + "A residual is the difference between the observed value of the target variable (y) and the predicted value (ŷ), i.e. the error of the prediction. The `ResidualsPlot` Visualizer shows the difference between residuals on the vertical axis and the dependent variable on the horizontal axis, allowing you to detect regions within the target that may be susceptible to more or less error. \n", + "\n", + "If the points are randomly dispersed around the horizontal axis, a linear regression model is usually well-suited for the data; otherwise, a non-linear model is more appropriate. The following example shows a fairly random, uniform distribution of the residuals against the target in two dimensions. This seems to indicate that our linear model is performing well." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Instantiate the linear model and visualizer \n", + "model = Ridge()\n", + "visualizer = ResidualsPlot(model)\n", + "\n", + "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", + "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", + "visualizer.poof() # Draw/show/poof the data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Yellowbrick's `ResidualsPlot` Visualizer also displays a histogram of the error values along the right-hand side. In the example above, the error is normally distributed around zero, which also generally indicates a well-fitted model. If the histogram is not desired, it can be turned off with the `hist=False` flag." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Instantiate the linear model and visualizer \n", + "model = Ridge()\n", + "visualizer = ResidualsPlot(model, hist=False)\n", + "\n", + "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", + "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", + "visualizer.poof() # Draw/show/poof the data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Prediction Error Plot \n", + "\n", + "Yellowbrick's `PredictionError` Visualizer plots the actual targets from the dataset against the predicted values generated by the model. This allows us to see how much variance is in the model. Data scientists can diagnose regression models using this plot by comparing against the 45-degree line, where the prediction exactly matches the model." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Instantiate the linear model and visualizer \n", + "model = Lasso()\n", + "visualizer = PredictionError(model)\n", + "\n", + "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", + "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", + "visualizer.poof() # Draw/show/poof the data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Alpha Selection Visualizer\n", + "\n", + "The `AlphaSelection` Visualizer demonstrates how different values of alpha influence model selection during the regularization of linear models. Since regularization is designed to penalize model complexity, the higher the alpha, the less complex the model, decreasing the error due to variance (overfit). However, alphas that are too high increase the error due to bias (underfit). Therefore, it is important to choose an optimal alpha such that the error is minimized in both directions.\n", + "\n", + "To do this, typically you would you use one of the \"RegressionCV” models in scikit-learn. E.g. instead of using the `Ridge` (L2) regularizer, use `RidgeCV` and pass a list of alphas, which will be selected based on the cross-validation score of each alpha. This visualizer wraps a “RegressionCV” model and visualizes the alpha/error curve. If the visualization shows a jagged or random plot, then potentially the model is not sensitive to that type of regularization and another is required (e.g. L1 or Lasso regularization)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create a list of alphas to cross-validate against \n", + "alphas = np.logspace(-10, 1, 400)\n", + "\n", + "# Instantiate the linear model and visualizer \n", + "model = LassoCV(alphas=alphas, cv=3)\n", + "visualizer = AlphaSelection(model)\n", + "\n", + "visualizer.fit(X, y) # Fit the data to the visualizer\n", + "visualizer.poof() # Draw/show/poof the data" + ] + } + ], + "metadata": { + "anaconda-cloud": {}, + "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 +} From 3bf9b03e4ecb2d7e6e09ee92b5600976b0d49085 Mon Sep 17 00:00:00 2001 From: Benjamin Bengfort Date: Wed, 25 Sep 2019 11:05:13 -0400 Subject: [PATCH 4/8] update travis-slack integration --- .travis.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index be339917a..a30573261 100644 --- a/.travis.yml +++ b/.travis.yml @@ -42,7 +42,7 @@ install: conda install coveralls; fi -script: +script: - python -m nltk.downloader popular - make test @@ -50,4 +50,4 @@ after_success: coveralls notifications: slack: - secure: mWKVHmEc22FJSp6Rrnd1j4QYCgZY4NJSrA8kZ5wj2/lf1iHI/CfWGTf7+Qihqe+rt0FOU0+UA9SzvSHRD1bV76q/zINayQ0EyJAfQzvIWIRGGnnMSO/79WoEYF56wwjpc5pLUTh6QV5qqfy+8nNGQ1/uJ0h6FtsUaSa/g61a5ZJEVBIjIpH8PgMxM64dRgJCmAdQuXkBP5Uf3yHlCtYk+Jr+gyXU2oqwMZ1VWgZkEo1Tqo7W9WY8dkOaAkzXDT61OqtcyyTuVSYbmK4i3c84681NBpb7wT6BfiCCAd3tn5AIKCkJVJ0ga0XeF6MdDpnicpku4FaN+fQjwkPiU47o/aFp8RNp27JQ9AhvH7wMuu5O8HDhszjRkfGOlUbuPOTavc22o4j0ShsrLiTQRJRhQQzJoquPuPj5wHqCCN+ice7IVUHj3ZC2jpJKDEYUNnr1fATtOwocimc6PhJM/IoeHgEEHpi37b+AxnhgOFoBlgsq2f4nsRD9JsLHqIpJCHgMjKxc6p3FtcFcXZDlDXQIcCzSRiPhG207dahspA3aPLj4Z+tOLJwh7/PSEfp02kcgPMM/MLYTWcaBv14aYi69kvQoZTfqVY8tIohg3ygda5siOCTTgqGriJYzkmdY5/Dp51kabhl+cEVIxPyY0miqyl3hZjqkqCnnOtg06qqxLLM= + secure: AfQ3fbiBTZZaRS8i+oTCs9F2Z8+kkKLX8ymi1OGpRA91As1A3c0CrXfZ+7wBh5IpdF0FFTZh5EH26+M63Fs5DX3uYNJeZzosv0H/xdw/zY0DeD4/SXVisHeOjv6Zn5TI2uYuKqHmHke/UJ3tl/p+GhTWFJBTgSXhXYNtGc8K1sOINr+GjS5uylwD3RAFJDQ/ABuwxH6iJCBANDtCJErKtbMSaHl3HpajL7YNgPBInAQSEMwx7bOke4gAoQBizpCzNoo25pHSWXvkAvlEg6MklUFapETOwBCgiQkZr5eNCSviEOjuM84rvn/7pG7dbA03R8Ax0fQ8ILkIKTKN4Wrm8AxbELnajPJyz+grMKbBmzDOKmqw+y7iewVyRrfj9hVtp5E5DBm5GrYtnVU7oamOkjM3cSrkCEJEEjbzEzKQv978N1E1ZdixQ17cp7GYVkhkixhZ3nXFI0XFhDYsIq5rokdIdgEHo9bTERzw6awlVGxordMe2FxavKB4fWi5CIQmOdXY5Tc3GAYfmvYjq3MQ9ACBLTF75rQbX8DYLaqOAMWMa6Q4HnBeiark4nZJNt2HKfDUL7B9OA8LTaK/ttUBt0xCt6iKCwpRHL+kZTgiUfjwfJXoufsB07Z7TtUcJ8t6+aebdd/Pap9LwBk379UrHFKQEZ6DkK1hHOMaqAC5cOQ= From 2df72120476fc791787b644fe756841e40032efd Mon Sep 17 00:00:00 2001 From: Benjamin Bengfort Date: Tue, 1 Oct 2019 16:58:52 -0400 Subject: [PATCH 5/8] Changes poof to show (#973) Per some feedback we've received; this PR updates the `poof()` method to `show()` and modifies all documentation references to the method name. This change updates the code in a number of places and the following changes were applied: 1. Change the `poof()` method on `Visualizer` and a 2 instances of `poof()` overrides on subclasses. 2. Change `fit_transform_poof` to `fit_transform_show`. 3. Change calls to `poof()` in various parts of the code and tests 4. Update documentation and docstrings 5. Update example notebooks with global find and replace 6. Update `finalize()` docstrings 7. Remove v0.8 deprecation warning from `DecisionBoundaries` 8. Adds a DeprecationWarning to a stub `poof()` method that calls `show()` --- .travis.yml | 2 +- CONTRIBUTING.md | 10 +- README.md | 4 +- docs/README.md | 12 +- .../api/classifier/class_prediction_error.rst | 12 +- docs/api/classifier/classification_report.rst | 2 +- docs/api/classifier/confusion_matrix.rst | 8 +- docs/api/classifier/prcurve.rst | 12 +- docs/api/classifier/rocauc.rst | 10 +- docs/api/classifier/threshold.rst | 4 +- docs/api/cluster/elbow.rst | 8 +- docs/api/cluster/icdm.rst | 2 +- docs/api/cluster/index.rst | 2 +- docs/api/cluster/silhouette.rst | 2 +- docs/api/contrib/boundaries.rst | 4 +- docs/api/contrib/missing/bar.rst | 4 +- docs/api/contrib/missing/dispersion.rst | 4 +- docs/api/contrib/scatter.rst | 2 +- docs/api/features/index.rst | 4 +- docs/api/features/jointplot.rst | 6 +- docs/api/features/manifold.py | 6 +- docs/api/features/manifold.rst | 6 +- docs/api/features/pca.rst | 8 +- docs/api/features/pcoords.rst | 4 +- docs/api/features/radviz.rst | 2 +- docs/api/features/rankd.rst | 10 +- docs/api/figures.rst | 4 +- docs/api/model_selection/cross_validation.rst | 4 +- docs/api/model_selection/importances.rst | 6 +- docs/api/model_selection/learning_curve.rst | 6 +- docs/api/model_selection/rfecv.py | 4 +- docs/api/model_selection/rfecv.rst | 4 +- docs/api/model_selection/validation_curve.py | 6 +- docs/api/model_selection/validation_curve.rst | 8 +- docs/api/regressor/alphas.rst | 2 +- docs/api/regressor/influence.rst | 2 +- docs/api/regressor/peplot.rst | 2 +- docs/api/regressor/residuals.rst | 4 +- docs/api/target/binning.rst | 2 +- docs/api/target/class_balance.rst | 6 +- docs/api/target/feature_correlation.rst | 8 +- docs/api/text/dispersion.rst | 2 +- docs/api/text/freqdist.rst | 16 +- docs/api/text/postag.rst | 14 +- docs/api/text/tsne.rst | 12 +- docs/api/text/umap_vis.py | 2 +- docs/api/text/umap_vis.rst | 12 +- docs/contributing/developing_visualizers.rst | 14 +- docs/faq.rst | 4 +- docs/gallery.py | 2 +- docs/quickstart.rst | 32 +- docs/tutorial.py | 2 +- docs/tutorial.rst | 2 +- examples/LCOMBS/testing.ipynb | 18 +- examples/NealHumphrey/testing_yb.ipynb | 8 +- .../comparing_corpus_visualizers.ipynb | 2 +- examples/agodbehere/PytorchExample.html | 12513 ---------------- examples/agodbehere/PytorchExample.ipynb | 6 +- examples/balavenkatesan/testing.py | 2 +- examples/bbengfort/alphas.ipynb | 12 +- examples/bbengfort/cluster.ipynb | 12 +- examples/bbengfort/errors.md | 223 - examples/bbengfort/pipeline.ipynb | 48 +- examples/bbengfort/regression.ipynb | 2 +- examples/bbengfort/testing.ipynb | 22 +- ...onfusionMatrix label_encoder example.ipynb | 4 +- examples/cjmorale/PCA_Examples.ipynb | 4 +- examples/clustering_visualizers.ipynb | 10 +- examples/examples.ipynb | 56 +- examples/exbald/data/testing.ipynb | 20 +- examples/gary-mayfield/testing.ipynb | 6 +- .../Iris - clustering example.ipynb | 12 +- .../silhouette-visualizer-test.ipynb | 10 +- examples/iguk1987/Yellowbrick_Tour.ipynb | 26 +- examples/jkeung/learning_curve.ipynb | 8 +- examples/jkeung/testing.ipynb | 2 +- examples/lwgray/ClassPredictionError.ipynb | 2 +- .../Visualizing a credit model.ipynb | 2 +- .../mike-curry00/Silhouette_Plot_Data.ipynb | 4 +- examples/morganmendis/testing.ipynb | 16 +- ...Decision Boundaries Example Notebook.ipynb | 20 +- .../ndanielsen/Missing Values Examples.ipynb | 8 +- examples/ndanielsen/Missing Values.ipynb | 8 +- .../ScatterViz Example (Iris Dataset).ipynb | 2 +- .../ThresholdVisualizer Example.ipynb | 2 +- .../Yellowbrick in the Flower Garden.ipynb | 20 +- .../MultipleVisualizerExample.ipynb | 4 +- examples/nealhumphrey/confusionMatrix.ipynb | 8 +- examples/nealhumphrey/light-dark-text.ipynb | 2 +- examples/pbs929/features-pipeline.ipynb | 4 +- examples/pbs929/gridsearch.ipynb | 26 +- examples/pbs929/pcoords.ipynb | 44 +- examples/pbs929/rankd.ipynb | 24 +- examples/pbwitt/testing.ipynb | 8 +- examples/pdamodaran/feature_visualizer.ipynb | 4 +- examples/pdamodaran/jointplot.ipynb | 6 +- .../adding-scatterplot-alpha.ipynb | 8 +- .../rebeccabilbro/balanced_binning_docs.ipynb | 12 +- examples/rebeccabilbro/barchart_colors.ipynb | 16 +- examples/rebeccabilbro/check_is_fitted.ipynb | 56 +- .../conf_matrix_class_names.ipynb | 6 +- ...correcting_percents_confusion_matrix.ipynb | 14 +- .../rebeccabilbro/cvscores_enhancements.ipynb | 12 +- .../cvscores_experimentation.ipynb | 4 +- examples/rebeccabilbro/dispersion_plots.ipynb | 4 +- .../feature_importances_fix.ipynb | 10 +- examples/rebeccabilbro/freqtext.ipynb | 10 +- examples/rebeccabilbro/pipelines.ipynb | 8 +- .../prediction_error_alpha.ipynb | 26 +- examples/rebeccabilbro/rocauc_bug_fix.ipynb | 8 +- .../rebeccabilbro/rocauc_bug_research.ipynb | 28 +- examples/rebeccabilbro/size_param_issue.ipynb | 2 +- examples/rebeccabilbro/testing.ipynb | 16 +- .../tsne_alpha_manual_legend.ipynb | 4 +- .../rebeccabilbro/tsne_resolve_colors.ipynb | 4 +- examples/regression_visualizers.ipynb | 8 +- examples/tuulihill/Tuulitest.ipynb | 20 +- examples/walkthrough.ipynb | 10 +- examples/zjpoh/correlated_var.ipynb | 10 +- .../zjpoh/stacked_feature_importance.ipynb | 24 +- tests/base.py | 2 +- tests/rand.py | 2 +- tests/test_base.py | 46 +- .../test_classifier/test_boundaries.py | 36 +- tests/test_contrib/test_scatter.py | 10 +- tests/test_features/test_base.py | 10 +- tests/test_features/test_radviz.py | 8 +- tests/test_pipeline.py | 30 +- tests/test_utils/test_wrapper.py | 6 +- yellowbrick/base.py | 29 +- .../classifier/class_prediction_error.py | 10 +- .../classifier/classification_report.py | 9 +- yellowbrick/classifier/confusion_matrix.py | 6 +- yellowbrick/classifier/prcurve.py | 2 +- yellowbrick/classifier/rocauc.py | 9 +- yellowbrick/classifier/threshold.py | 8 +- yellowbrick/cluster/elbow.py | 2 +- yellowbrick/cluster/silhouette.py | 2 +- yellowbrick/contrib/classifier/boundaries.py | 18 +- yellowbrick/contrib/missing/bar.py | 11 +- yellowbrick/contrib/missing/dispersion.py | 11 +- yellowbrick/contrib/scatter.py | 7 +- yellowbrick/features/base.py | 6 +- yellowbrick/features/decomposition.py | 2 +- yellowbrick/features/jointplot.py | 2 +- yellowbrick/features/manifold.py | 2 +- yellowbrick/features/pca.py | 2 +- yellowbrick/features/pcoords.py | 10 +- yellowbrick/features/radviz.py | 9 +- yellowbrick/features/rankd.py | 15 +- yellowbrick/gridsearch/pcolor.py | 2 +- .../model_selection/cross_validation.py | 6 +- yellowbrick/model_selection/importances.py | 2 +- yellowbrick/model_selection/learning_curve.py | 8 +- yellowbrick/model_selection/rfecv.py | 6 +- .../model_selection/validation_curve.py | 8 +- yellowbrick/pipeline.py | 19 +- yellowbrick/regressor/alphas.py | 4 +- yellowbrick/regressor/residuals.py | 21 +- yellowbrick/target/binning.py | 12 +- yellowbrick/target/class_balance.py | 16 +- yellowbrick/target/feature_correlation.py | 2 +- yellowbrick/text/base.py | 10 +- yellowbrick/text/dispersion.py | 9 +- yellowbrick/text/freqdist.py | 2 +- yellowbrick/text/postag.py | 6 +- yellowbrick/text/umap_vis.py | 2 +- 167 files changed, 836 insertions(+), 13513 deletions(-) delete mode 100644 examples/agodbehere/PytorchExample.html delete mode 100644 examples/bbengfort/errors.md diff --git a/.travis.yml b/.travis.yml index a30573261..990d7e041 100644 --- a/.travis.yml +++ b/.travis.yml @@ -50,4 +50,4 @@ after_success: coveralls notifications: slack: - secure: AfQ3fbiBTZZaRS8i+oTCs9F2Z8+kkKLX8ymi1OGpRA91As1A3c0CrXfZ+7wBh5IpdF0FFTZh5EH26+M63Fs5DX3uYNJeZzosv0H/xdw/zY0DeD4/SXVisHeOjv6Zn5TI2uYuKqHmHke/UJ3tl/p+GhTWFJBTgSXhXYNtGc8K1sOINr+GjS5uylwD3RAFJDQ/ABuwxH6iJCBANDtCJErKtbMSaHl3HpajL7YNgPBInAQSEMwx7bOke4gAoQBizpCzNoo25pHSWXvkAvlEg6MklUFapETOwBCgiQkZr5eNCSviEOjuM84rvn/7pG7dbA03R8Ax0fQ8ILkIKTKN4Wrm8AxbELnajPJyz+grMKbBmzDOKmqw+y7iewVyRrfj9hVtp5E5DBm5GrYtnVU7oamOkjM3cSrkCEJEEjbzEzKQv978N1E1ZdixQ17cp7GYVkhkixhZ3nXFI0XFhDYsIq5rokdIdgEHo9bTERzw6awlVGxordMe2FxavKB4fWi5CIQmOdXY5Tc3GAYfmvYjq3MQ9ACBLTF75rQbX8DYLaqOAMWMa6Q4HnBeiark4nZJNt2HKfDUL7B9OA8LTaK/ttUBt0xCt6iKCwpRHL+kZTgiUfjwfJXoufsB07Z7TtUcJ8t6+aebdd/Pap9LwBk379UrHFKQEZ6DkK1hHOMaqAC5cOQ= + secure: YvJ/aF5Ev2wgqoSc+QG4LA8XCovdfW7w7FiOMiRA6zrLjywEC12KzVDBTotIRFJVncCmh/WuyTCJUYfYA1Q0MrySpAF8cDr4fdGnO3skopU9Nx7pVuXOrHQ2LcVTEE0sGAeYH+hGrT+7TsbGR9iwki5xkkT0g1QEgJqvLhph6Y6gQMAtPceXU7wnIJf9Fn4IdTrDbeAawxhYsuVLTptGSS9UHYsV0P3lwPg1FItduE1UzNhyicBXzj/8f56/xBxNeYEGwFMhE1oad3lm9BRLzpqGwsIHWR5JLIYcX+y1YceFvB+vz4Xsf6H+XaCCb7uzBfC2BAc9+gr0zjUbiLcTyA1LyuR9kOlFCUx/nSGkJyhXcMb+NbA0vK9JY7ss2kempoxCDCkzpjFNasqGJMyPagI3na8YRu1RTTmBJUip9U+oN80Kr4lSMzbLDCDA2LTQBeL3zSSW51foiQPIDowK/CYQSMo/0IVp2x9ronWhDBbszHkXoWCv6/AMzjGhASDDg4AJD40zLo/pcEevcJdTraO915Sp8PtltbLnuuklJSi1xci5O6ja/ldyC7lKPm77z9nlx805349dLTkNpD27xXpALWPUJBNNrVpD3H6SvYB3b2IVgVjENdHZGLcCjlbwgdZ30zPik4Sj/w+8GoGxh5l/V6wHUhwOMm7ZKr7lcXk= diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index f2da93d0a..4611e3ca6 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -165,11 +165,11 @@ These two basic types of visualizers map well to the two basic estimator objects The scikit-learn API is object oriented, and estimators are initialized with parameters by instantiating their class. Hyperparameters can also be set using the `set_attrs()` method and retrieved with the corresponding `get_attrs()` method. All scikit-learn estimators have a `fit(X, y=None)` method that accepts a two dimensional data array, `X`, and optionally a vector `y` of target values. The `fit()` method trains the estimator, making it ready to transform data or make predictions. Transformers have an associated `transform(X)` method that returns a new dataset, `Xprime` and models have a `predict(X)` method that returns a vector of predictions, `yhat`. Models may also have a `score(X, y)` method that evaluate the performance of the model. -Visualizers interact with scikit-learn objects by intersecting with them at the methods defined above. Specifically, visualizers perform actions related to `fit()`, `transform()`, `predict()`, and `score()` then call a `draw()` method which initializes the underlying figure associated with the visualizer. The user calls the visualizer's `poof()` method, which in turn calls a `finalize()` method on the visualizer to draw legends, titles, etc. and then `poof()` renders the figure. The Visualizer API is therefore: +Visualizers interact with scikit-learn objects by intersecting with them at the methods defined above. Specifically, visualizers perform actions related to `fit()`, `transform()`, `predict()`, and `score()` then call a `draw()` method which initializes the underlying figure associated with the visualizer. The user calls the visualizer's `show()` method, which in turn calls a `finalize()` method on the visualizer to draw legends, titles, etc. and then `show()` renders the figure. The Visualizer API is therefore: - `draw()`: add visual elements to the underlying axes object - `finalize()`: prepare the figure for rendering, adding final touches such as legends, titles, axis labels, etc. -- `poof()`: render the figure for the user. +- `show()`: render the figure for the user. Creating a visualizer means defining a class that extends `Visualizer` or one of its subclasses, then implementing several of the methods described above. A barebones implementation is as follows:: @@ -201,7 +201,7 @@ This simple visualizer simply draws a line graph for some input dataset X, inter ```python visualizer = MyVisualizer() visualizer.fit(X) -visualizer.poof() +visualizer.show() ``` Score visualizers work on the same principle but accept an additional required `model` argument. Score visualizers wrap the model (which can be either instantiated or uninstantiated) and then pass through all attributes and methods through to the underlying model, drawing where necessary. @@ -231,7 +231,7 @@ class MyVisualizerTests(VisualTestCase): try: visualizer = MyVisualizer() visualizer.fit(X) - visualizer.poof() + visualizer.show() except Exception as e: pytest.fail("my visualizer didn't work") ``` @@ -287,7 +287,7 @@ class MyVisualizer(Visualizer): >>> model = MyVisualizer() >>> model.fit(X) - >>> model.poof() + >>> model.show() Notes ----- diff --git a/README.md b/README.md index 2cf88fdbe..be3ae6a7b 100644 --- a/README.md +++ b/README.md @@ -54,7 +54,7 @@ visualizer = Rank2D( ) visualizer.fit(X, y) # Fit the data to the visualizer visualizer.transform(X) # Transform the data -visualizer.poof() # Show the data +visualizer.show() # Finalize and render the figure ``` ### Model Visualization @@ -69,7 +69,7 @@ model = LinearSVC() model.fit(X,y) visualizer = ROCAUC(model) visualizer.score(X,y) -visualizer.poof() +visualizer.show() ``` For additional information on getting started with Yellowbrick, view the quickstart guide in the [documentation](https://www.scikit-yb.org/en/latest/) and check out our [examples notebook](https://github.com/DistrictDataLabs/yellowbrick/blob/develop/examples/examples.ipynb). diff --git a/docs/README.md b/docs/README.md index 7de9bbe02..a2ef6fe95 100644 --- a/docs/README.md +++ b/docs/README.md @@ -2,7 +2,7 @@ *Welcome to the Yellowbrick docs!* -If you're looking for information about how to use Yellowbrick, for our contributor's guide, for examples and teaching resources, for answers to frequently asked questions, and more, please visit the latest version of our documentation at [www.scikit-yb.org](https://www.scikit-yb.org/). +If you're looking for information about how to use Yellowbrick, for our contributor's guide, for examples and teaching resources, for answers to frequently asked questions, and more, please visit the latest version of our documentation at [www.scikit-yb.org](https://www.scikit-yb.org/). ## Building the Docs @@ -16,9 +16,9 @@ You will then be able to build the documentation from inside the `docs` director ## reStructuredText -Yellowbrick uses [Sphinx](http://www.sphinx-doc.org/en/master/index.html) to build our documentation. The advantages of using Sphinx are many; we can more directly link to the documentation and source code of other projects like Matplotlib and scikit-learn using [intersphinx](http://www.sphinx-doc.org/en/master/usage/extensions/intersphinx.html). In addition, docstrings used to describe Yellowbrick visualizers can be automatically included when the documentation is built via [autodoc](http://www.sphinx-doc.org/en/master/usage/extensions/autodoc.html#sphinx.ext.autodoc). +Yellowbrick uses [Sphinx](http://www.sphinx-doc.org/en/master/index.html) to build our documentation. The advantages of using Sphinx are many; we can more directly link to the documentation and source code of other projects like Matplotlib and scikit-learn using [intersphinx](http://www.sphinx-doc.org/en/master/usage/extensions/intersphinx.html). In addition, docstrings used to describe Yellowbrick visualizers can be automatically included when the documentation is built via [autodoc](http://www.sphinx-doc.org/en/master/usage/extensions/autodoc.html#sphinx.ext.autodoc). -To take advantage of these features, our documentation must be written in reStructuredText (or "rst"). reStructuredText is similar to markdown, but not identical, and does take some getting used to. For instance, styling for things like codeblocks, external hyperlinks, internal cross references, notes, and fixed-width text are all unique in rst. +To take advantage of these features, our documentation must be written in reStructuredText (or "rst"). reStructuredText is similar to markdown, but not identical, and does take some getting used to. For instance, styling for things like codeblocks, external hyperlinks, internal cross references, notes, and fixed-width text are all unique in rst. If you would like to contribute to our documentation and do not have prior experience with rst, we recommend you make use of these resources: @@ -28,7 +28,7 @@ If you would like to contribute to our documentation and do not have prior exper ## Adding New Visualizers to the Docs -If you are adding a new visualizer to the docs, there are quite a few examples in the documentation on which you can base your files of similar types. +If you are adding a new visualizer to the docs, there are quite a few examples in the documentation on which you can base your files of similar types. The primary format for the API section is as follows: @@ -48,7 +48,7 @@ A brief introduction to my visualizer and how it is useful in the machine learni visualizer = MyVisualizer(LinearRegression()) visualizer.fit(X, y) - g = visualizer.poof() + g = visualizer.show() Discussion about my visualizer and some interpretation of the above plot. @@ -62,7 +62,7 @@ API Reference :show-inheritance: ``` -This is a pretty good structure for a documentation page; a brief introduction followed by a code example with a visualization included using [the plot directive](https://matplotlib.org/devel/plot_directive.html). This will render the `MyVisualizer` image in the document along with links for the complete source code, the png, and the pdf versions of the image. It will also have the "alt-text" (for screen-readers) and will not display the source because of the `:include-source:` option. If `:include-source:` is omitted, the source will also be included. +This is a pretty good structure for a documentation page; a brief introduction followed by a code example with a visualization included using [the plot directive](https://matplotlib.org/devel/plot_directive.html). This will render the `MyVisualizer` image in the document along with links for the complete source code, the png, and the pdf versions of the image. It will also have the "alt-text" (for screen-readers) and will not display the source because of the `:include-source:` option. If `:include-source:` is omitted, the source will also be included. The primary section is wrapped up with a discussion about how to interpret the visualizer and use it in practice. Finally the `API Reference` section will use `automodule` to include the documentation from your docstring. diff --git a/docs/api/classifier/class_prediction_error.rst b/docs/api/classifier/class_prediction_error.rst index 9e9696616..dc20f609a 100644 --- a/docs/api/classifier/class_prediction_error.rst +++ b/docs/api/classifier/class_prediction_error.rst @@ -40,7 +40,7 @@ The class prediction error chart provides a way to quickly understand how good y visualizer.score(X_test, y_test) # Draw visualization - visualizer.poof() + visualizer.show() In the above example, while the ``RandomForestClassifier`` appears to be fairly good at correctly predicting apples based on the features of the fruit, it often incorrectly labels pears as kiwis and mistakes kiwis for bananas. @@ -56,13 +56,13 @@ By contrast, in the following example, the ``RandomForestClassifier`` does a gre from yellowbrick.datasets import load_credit X, y = load_credit() - + classes = ['account in default', 'current with bills'] # Perform 80/20 training/test split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=42) - + # Instantiate the classification model and visualizer visualizer = ClassPredictionError( RandomForestClassifier(n_estimators=10), classes=classes @@ -75,10 +75,10 @@ By contrast, in the following example, the ``RandomForestClassifier`` does a gre visualizer.score(X_test, y_test) # Draw visualization - visualizer.poof() + visualizer.show() + + - - API Reference ------------- diff --git a/docs/api/classifier/classification_report.rst b/docs/api/classifier/classification_report.rst index 3c357b63a..5eadd88ad 100644 --- a/docs/api/classifier/classification_report.rst +++ b/docs/api/classifier/classification_report.rst @@ -33,7 +33,7 @@ The classification report visualizer displays the precision, recall, F1, and sup visualizer.fit(X_train, y_train) # Fit the visualizer and the model visualizer.score(X_test, y_test) # Evaluate the model on the test data - visualizer.poof() # Draw/show/poof the data + visualizer.show() # Finalize and show the figure The classification report shows a representation of the main classification metrics on a per-class basis. This gives a deeper intuition of the classifier behavior over global accuracy which can mask functional weaknesses in one class of a multiclass problem. Visual classification reports are used to compare classification models to select models that are "redder", e.g. have stronger classification metrics or that are more balanced. diff --git a/docs/api/classifier/confusion_matrix.rst b/docs/api/classifier/confusion_matrix.rst index c286543ef..f7a6d8ffc 100644 --- a/docs/api/classifier/confusion_matrix.rst +++ b/docs/api/classifier/confusion_matrix.rst @@ -47,7 +47,7 @@ scikit-learn documentation on `confusion matrices `_ (or anything with an ``inverse_transform`` method that performs the mapping), or a ``dict`` with the encoding-to-string mapping as in the example below: -.. plot:: +.. plot:: :context: close-figs :alt: ConfusionMatrix plot with class names @@ -63,7 +63,7 @@ Class names can be added to a ``ConfusionMatrix`` plot using the ``label_encoder from sklearn.model_selection import train_test_split as tts from sklearn.linear_model import LogisticRegression from yellowbrick.classifier import ConfusionMatrix - + iris = load_iris() X = iris.data y = iris.target @@ -81,7 +81,7 @@ Class names can be added to a ``ConfusionMatrix`` plot using the ``label_encoder iris_cm.fit(X_train, y_train) iris_cm.score(X_test, y_test) - iris_cm.poof() + iris_cm.show() API Reference diff --git a/docs/api/classifier/prcurve.rst b/docs/api/classifier/prcurve.rst index c0954029e..037025caa 100644 --- a/docs/api/classifier/prcurve.rst +++ b/docs/api/classifier/prcurve.rst @@ -28,11 +28,11 @@ Binary Classification X_train, X_test, y_train, y_test = tts(X, y, test_size=0.2, shuffle=True) - # Create the visualizer, fit, score, and poof it + # Create the visualizer, fit, score, and show it viz = PrecisionRecallCurve(RidgeClassifier()) viz.fit(X_train, y_train) viz.score(X_test, y_test) - viz.poof() + viz.show() The base case for precision-recall curves is the binary classification case, and this case is also the most visually interpretable. In the figure above we can see the precision plotted on the y-axis against the recall on the x-axis. The larger the filled in area, the stronger the classifier is. The red line annotates the *average precision*, a summary of the entire plot computed as the weighted average of precision achieved at each threshold such that the weight is the difference in recall from the previous threshold. @@ -59,11 +59,11 @@ To support multi-label classification, the estimator is wrapped in a `OneVsRestC X_train, X_test, y_train, y_test = tts(X, y, test_size=0.2, shuffle=True) - # Create the visualizer, fit, score, and poof it + # Create the visualizer, fit, score, and show it viz = PrecisionRecallCurve(RandomForestClassifier(n_estimators=10)) viz.fit(X_train, y_train) viz.score(X_test, y_test) - viz.poof() + viz.show() A more complex Precision-Recall curve can be computed, however, displaying the each curve individually, along with F1-score ISO curves (e.g. that show the relationship between precision and recall for various F1 scores). @@ -86,14 +86,14 @@ A more complex Precision-Recall curve can be computed, however, displaying the e X_train, X_test, y_train, y_test = tts(X, y, test_size=0.2, shuffle=True) - # Create the visualizer, fit, score, and poof it + # Create the visualizer, fit, score, and show it viz = PrecisionRecallCurve( MultinomialNB(), per_class=True, iso_f1_curves=True, fill_area=False, micro=False, classes=encoder.classes_ ) viz.fit(X_train, y_train) viz.score(X_test, y_test) - viz.poof() + viz.show() .. seealso:: `Scikit-Learn: Model Selection with Precision Recall Curves `_ diff --git a/docs/api/classifier/rocauc.rst b/docs/api/classifier/rocauc.rst index 35fc89023..9419c9cb3 100644 --- a/docs/api/classifier/rocauc.rst +++ b/docs/api/classifier/rocauc.rst @@ -31,14 +31,14 @@ This leads to another metric, area under the curve (AUC), which is a computation visualizer.fit(X_train, y_train) # Fit the training data to the visualizer visualizer.score(X_test, y_test) # Evaluate the model on the test data - visualizer.poof() # Draw/show/poof the data + visualizer.show() # Finalize and show the figure .. warning:: - Versions of Yellowbrick =< v0.8 had a `bug `_ - that triggered an ``IndexError`` when attempting binary classification using + Versions of Yellowbrick =< v0.8 had a `bug `_ + that triggered an ``IndexError`` when attempting binary classification using a Scikit-learn-style estimator with only a ``decision_function``. This has been - fixed as of v0.9, where the ``micro``, ``macro``, and ``per-class`` parameters of + fixed as of v0.9, where the ``micro``, ``macro``, and ``per-class`` parameters of ``ROCAUC`` are set to ``False`` for such classifiers. @@ -75,7 +75,7 @@ ROC curves are typically used in binary classification, and in fact the Scikit-L visualizer.fit(X_train, y_train) # Fit the training data to the visualizer visualizer.score(X_test, y_test) # Evaluate the model on the test data - visualizer.poof() # Draw/show/poof the data + visualizer.show() # Finalize and render the figure .. warning:: The target ``y`` must be numeric for this figure to work, or update to the latest version of sklearn. diff --git a/docs/api/classifier/threshold.rst b/docs/api/classifier/threshold.rst index 443d728a2..4b4f4faec 100644 --- a/docs/api/classifier/threshold.rst +++ b/docs/api/classifier/threshold.rst @@ -24,7 +24,7 @@ A visualization of precision, recall, f1 score, and queue rate with respect to t visualizer = DiscriminationThreshold(model) visualizer.fit(X, y) # Fit the data to the visualizer - visualizer.poof() # Draw/show/poof the data + visualizer.show() # Finalize and render the figure One common use of binary classification algorithms is to use the score or probability they produce to determine cases that require special treatment. For example, a fraud prevention application might use a classification algorithm to determine if a transaction is likely fraudulent and needs to be investigated in detail. In the figure above, we present an example where a binary classifier determines if an email is "spam" (the positive case) or "not spam" (the negative case). Emails that are detected as spam are moved to a hidden folder and eventually deleted. @@ -40,7 +40,7 @@ Generally speaking, the threshold is balanced between cases and set to 0.5 or 50 - **Queue Rate**: The "queue" is the spam folder or the inbox of the fraud investigation desk. This metric describes the percentage of instances that must be reviewed. If review has a high cost (e.g. fraud prevention) then this must be minimized with respect to business requirements; if it doesn't (e.g. spam filter), this could be optimized to ensure the inbox stays clean. -In the figure above we see the visualizer tuned to look for the optimal F1 score, which is annotated as a threshold of 0.43. The model is run multiple times over multiple train/test splits in order to account for the variability of the model with respect to the metrics (shown as the fill area around the median curve). +In the figure above we see the visualizer tuned to look for the optimal F1 score, which is annotated as a threshold of 0.43. The model is run multiple times over multiple train/test splits in order to account for the variability of the model with respect to the metrics (shown as the fill area around the median curve). API Reference diff --git a/docs/api/cluster/elbow.rst b/docs/api/cluster/elbow.rst index aed5d0c6d..4c8072202 100644 --- a/docs/api/cluster/elbow.rst +++ b/docs/api/cluster/elbow.rst @@ -24,7 +24,7 @@ To demonstrate, in the following example the ``KElbowVisualizer`` fits the ``KMe visualizer = KElbowVisualizer(model, k=(4,12)) visualizer.fit(X) # Fit the data to the visualizer - visualizer.poof() # Draw/show/poof the data + visualizer.show() # Finalize and render the figure By default, the scoring parameter ``metric`` is set to ``distortion``, which computes the sum of squared distances from each point to its assigned center. @@ -51,9 +51,9 @@ The ``KElbowVisualizer`` also displays the amount of time to train the clusterin ) visualizer.fit(X) # Fit the data to the visualizer - visualizer.poof() # Draw/show/poof the data + visualizer.show() # Finalize and render the figure -By default, the parameter ``locate_elbow`` is set to ``True``, which automatically find the "elbow" which likely corresponds to the optimal value of k using the "knee point detection algorithm". However, users can turn off the feature by setting ``locate_elbow=False``. You can read about the implementation of this algorithm at "`Knee point detection in Python `_" by Kevin Arvai. +By default, the parameter ``locate_elbow`` is set to ``True``, which automatically find the "elbow" which likely corresponds to the optimal value of k using the "knee point detection algorithm". However, users can turn off the feature by setting ``locate_elbow=False``. You can read about the implementation of this algorithm at "`Knee point detection in Python `_" by Kevin Arvai. In the following example, we'll use the ``calinski_harabasz`` score and turn off ``locate_elbow`` feature. @@ -76,7 +76,7 @@ In the following example, we'll use the ``calinski_harabasz`` score and turn off ) visualizer.fit(X) # Fit the data to the visualizer - visualizer.poof() # Draw/show/poof the data + visualizer.show() # Finalize and render the figure It is important to remember that the "elbow" method does not work well if the data is not very clustered. In this case, you might see a smooth curve and the optimal value of :math:`K` will be unclear. diff --git a/docs/api/cluster/icdm.rst b/docs/api/cluster/icdm.rst index a7c1a70dd..70b5ecfc4 100644 --- a/docs/api/cluster/icdm.rst +++ b/docs/api/cluster/icdm.rst @@ -22,7 +22,7 @@ Intercluster distance maps display an embedding of the cluster centers in 2 dime visualizer = InterclusterDistance(model) visualizer.fit(X) # Fit the data to the visualizer - visualizer.poof() # Draw/show/poof the data + visualizer.show() # Finalize and render the figure API Reference ------------- diff --git a/docs/api/cluster/index.rst b/docs/api/cluster/index.rst index 7e971fc23..f392db365 100644 --- a/docs/api/cluster/index.rst +++ b/docs/api/cluster/index.rst @@ -9,7 +9,7 @@ Clustering models are unsupervised methods that attempt to detect patterns in un - :doc:`silhouette`: visualize the silhouette scores of each cluster in a single model. - :doc:`icdm`: visualize the relative distance and size of clusters. -Because it is very difficult to ``score`` a clustering model, Yellowbrick visualizers wrap scikit-learn clusterer estimators via their ``fit()`` method. Once the clustering model is trained, then the visualizer can call ``poof()`` to display the clustering evaluation metric. +Because it is very difficult to ``score`` a clustering model, Yellowbrick visualizers wrap scikit-learn clusterer estimators via their ``fit()`` method. Once the clustering model is trained, then the visualizer can call ``show()`` to display the clustering evaluation metric. .. toctree:: :maxdepth: 2 diff --git a/docs/api/cluster/silhouette.rst b/docs/api/cluster/silhouette.rst index bfe237329..53c5b15e0 100644 --- a/docs/api/cluster/silhouette.rst +++ b/docs/api/cluster/silhouette.rst @@ -28,7 +28,7 @@ The Silhouette Visualizer displays the silhouette coefficient for each sample on visualizer = SilhouetteVisualizer(model, colors='yellowbrick') visualizer.fit(X) # Fit the data to the visualizer - visualizer.poof() # Draw/show/poof the data + visualizer.show() # Finalize and render the figure API Reference diff --git a/docs/api/contrib/boundaries.rst b/docs/api/contrib/boundaries.rst index 21d677033..ba19ab919 100644 --- a/docs/api/contrib/boundaries.rst +++ b/docs/api/contrib/boundaries.rst @@ -27,7 +27,7 @@ The DecisionBoundariesVisualizer is a bivariate data visualization algorithm tha ) viz.fit(X_train, y_train) viz.draw(X_test, y_test) - viz.poof() + viz.show() .. plot:: @@ -54,7 +54,7 @@ The DecisionBoundariesVisualizer is a bivariate data visualization algorithm tha ) viz.fit(X_train, y_train) viz.draw(X_test, y_test) - viz.poof() + viz.show() API Reference diff --git a/docs/api/contrib/missing/bar.rst b/docs/api/contrib/missing/bar.rst index dd876f33e..7bd93b7f4 100644 --- a/docs/api/contrib/missing/bar.rst +++ b/docs/api/contrib/missing/bar.rst @@ -32,7 +32,7 @@ Without Targets Supplied visualizer = MissingValuesBar(features=features) visualizer.fit(X) # Fit the data to the visualizer - visualizer.poof() # Draw/show/poof the data + visualizer.show() # Finalize and render the figure With Targets (``y``) Supplied @@ -61,7 +61,7 @@ With Targets (``y``) Supplied visualizer = MissingValuesBar(features=features) visualizer.fit(X, y=y) # Supply the targets via y - visualizer.poof() # Draw/show/poof the data + visualizer.show() # Finalize and render the figure API Reference diff --git a/docs/api/contrib/missing/dispersion.rst b/docs/api/contrib/missing/dispersion.rst index 791c2006e..7d500802c 100644 --- a/docs/api/contrib/missing/dispersion.rst +++ b/docs/api/contrib/missing/dispersion.rst @@ -30,7 +30,7 @@ Without Targets Supplied visualizer = MissingValuesDispersion(features=features) visualizer.fit(X) - visualizer.poof() + visualizer.show() With Targets (y) Supplied @@ -58,7 +58,7 @@ With Targets (y) Supplied visualizer = MissingValuesDispersion(features=features) visualizer.fit(X, y=y) # supply the targets via y - visualizer.poof() + visualizer.show() API Reference diff --git a/docs/api/contrib/scatter.rst b/docs/api/contrib/scatter.rst index 4ca7a4c27..d6f754956 100644 --- a/docs/api/contrib/scatter.rst +++ b/docs/api/contrib/scatter.rst @@ -25,7 +25,7 @@ A scatter visualizer simply plots two features against each other and colors the visualizer.fit(X, y) # Fit the data to the visualizer visualizer.transform(X) # Transform the data - visualizer.poof() # Draw/show/poof the data + visualizer.show() # Finalize and render the figure API Reference diff --git a/docs/api/features/index.rst b/docs/api/features/index.rst index 63879a5fd..3dce89d93 100644 --- a/docs/api/features/index.rst +++ b/docs/api/features/index.rst @@ -26,8 +26,8 @@ Feature analysis visualizers implement the ``Transformer`` API from scikit-learn, meaning they can be used as intermediate transform steps in a ``Pipeline`` (particularly a ``VisualPipeline``). They are instantiated in the same way, and then fit and transform are called on -them, which draws the instances correctly. Finally ``poof`` or ``show`` -is called which displays the image. +them, which draws the instances correctly. Finally ``show`` is called which +finalizes and displays the image. .. code:: python diff --git a/docs/api/features/jointplot.rst b/docs/api/features/jointplot.rst index cda14ccc9..a0cb45b21 100644 --- a/docs/api/features/jointplot.rst +++ b/docs/api/features/jointplot.rst @@ -25,7 +25,7 @@ The ``JointPlotVisualizer`` plots a feature against the target and shows the dis visualizer = JointPlotVisualizer(columns="cement") visualizer.fit_transform(X, y) # Fit and transform the data - visualizer.poof() # Draw/show/poof the data + visualizer.show() # Finalize and render the figure The ``JointPlotVisualizer`` can also be used to compare two features. @@ -44,7 +44,7 @@ The ``JointPlotVisualizer`` can also be used to compare two features. visualizer = JointPlotVisualizer(columns=["cement", "ash"]) visualizer.fit_transform(X, y) # Fit and transform the data - visualizer.poof() # Draw/show/poof the data + visualizer.show() # Finalize and render the figure In addition, the ``JointPlotVisualizer`` can be plotted with hexbins in the case @@ -64,7 +64,7 @@ of many, many points. visualizer = JointPlotVisualizer(columns="cement", kind="hexbin") visualizer.fit_transform(X, y) # Fit and transform the data - visualizer.poof() # Draw/show/poof the data + visualizer.show() # Finalize and render the figure API Reference diff --git a/docs/api/features/manifold.py b/docs/api/features/manifold.py index eb02263b6..1f2e7edd1 100644 --- a/docs/api/features/manifold.py +++ b/docs/api/features/manifold.py @@ -77,7 +77,7 @@ def dataset_example(dataset="occupancy", manifold="all", path="images/", **kwarg raise Exception("unknown dataset '{}'".format(dataset)) oz.fit(X, y) - oz.poof(outpath=path) + oz.show(outpath=path) def select_features_example( @@ -96,7 +96,7 @@ def select_features_example( X, y = load_occupancy() model.fit(X, y) - model.named_steps["viz"].poof(outpath=path) + model.named_steps["viz"].show(outpath=path) class SCurveExample(object): @@ -137,7 +137,7 @@ def plot_manifold_embedding(self, algorithm="lle", path="images"): oz = Manifold(ax=ax, manifold=algorithm, colors="nipy_spectral") oz.fit(self.X, self.y) - oz.poof(outpath=path) + oz.show(outpath=path) def plot_all_manifolds(self, path="images"): """ diff --git a/docs/api/features/manifold.rst b/docs/api/features/manifold.rst index e45ba0f81..e9c46755a 100644 --- a/docs/api/features/manifold.rst +++ b/docs/api/features/manifold.rst @@ -74,7 +74,7 @@ this by assigning a color to each label and showing the labels in a legend. visualizer = Manifold(manifold="tsne") visualizer.fit(X, y) # Fit the data - visualizer.poof() # Draw/show/poof the data + visualizer.show() # Finalize and render the figure .. image:: images/occupancy_tsne_manifold.png @@ -111,7 +111,7 @@ the ``f_classif`` score to find the 3 best features in our occupancy dataset. ]) model.fit(X, y) # Fit the data to the model - model.named_steps['viz'].poof() # Draw/show/poof the data + model.named_steps['viz'].show() # Finalize and render the figure .. image:: images/occupancy_select_k_best_isomap_manifold.png @@ -138,7 +138,7 @@ continuous by counting the number of unique values in ``y``. visualizer = Manifold(manifold="isomap", n_neighbors=10) visualizer.fit(X, y) # Fit the data - visualizer.poof() # Draw/show/poof the data + visualizer.show() # Finalize and render the figure .. image:: images/concrete_isomap_manifold.png diff --git a/docs/api/features/pca.rst b/docs/api/features/pca.rst index d3f799dcc..d0b37011f 100644 --- a/docs/api/features/pca.rst +++ b/docs/api/features/pca.rst @@ -20,7 +20,7 @@ The PCA Decomposition visualizer utilizes principal component analysis to decomp visualizer = PCADecomposition(scale=True, color=colors) visualizer.fit_transform(X, y) - visualizer.poof() + visualizer.show() The PCA projection can also be plotted in three dimensions to attempt to visualize more principal components and get a better sense of the distribution in high dimensions. @@ -38,7 +38,7 @@ The PCA projection can also be plotted in three dimensions to attempt to visuali visualizer = PCADecomposition(scale=True, color=colors, proj_dim=3) visualizer.fit_transform(X, y) - visualizer.poof() + visualizer.show() Biplot @@ -58,7 +58,7 @@ The PCA projection can be enhanced to a biplot whose points are the projected in visualizer = PCADecomposition(scale=True, proj_features=True) visualizer.fit_transform(X, y) - visualizer.poof() + visualizer.show() .. plot:: @@ -72,7 +72,7 @@ The PCA projection can be enhanced to a biplot whose points are the projected in visualizer = PCADecomposition(scale=True, proj_features=True, proj_dim=3) visualizer.fit_transform(X, y) - visualizer.poof() + visualizer.show() API Reference ------------- diff --git a/docs/api/features/pcoords.rst b/docs/api/features/pcoords.rst index 723942115..e3a302a46 100644 --- a/docs/api/features/pcoords.rst +++ b/docs/api/features/pcoords.rst @@ -34,7 +34,7 @@ Data scientists use this method to detect clusters of instances that have simila visualizer.fit_transform(X, y) # Finalize the title and axes then display the visualization - visualizer.poof() + visualizer.show() By inspecting the visualization closely, we can see that the combination of transparency and overlap gives us the sense of groups of similar instances, sometimes referred to as "braids". If there are distinct braids of different classes, it suggests that there is enough separability that a classification algorithm might be able to discern between each class. @@ -67,7 +67,7 @@ Normalization techniques can be directly applied to the visualizer without pre-t # Fit the visualizer and display it visualizer.fit_transform(X, y) - visualizer.poof() + visualizer.show() Now we can see that each feature is in the range ``[-3, 3]`` where the mean of the feature is set to zero and each feature has a unit variance applied between ``[-1, 1]`` (because we're using the ``StandardScaler`` via the ``standard`` normalize parameter). This version of parallel coordinates gives us a much better sense of the distribution of the features and if any features are highly variable with respect to any one class. diff --git a/docs/api/features/radviz.rst b/docs/api/features/radviz.rst index dc0529f98..326931025 100644 --- a/docs/api/features/radviz.rst +++ b/docs/api/features/radviz.rst @@ -40,7 +40,7 @@ A good starting place is the `scikit-learn Imputer. ` and vectorize the text using TF-IDF. Once the corpus is vectorized we can visualize it, showing the distribution of classes. -.. note to contributors: the below code requires an additional dependency on umap-learn - that is not part of the core requirements, so has not been modified with a plot +.. note to contributors: the below code requires an additional dependency on umap-learn + that is not part of the core requirements, so has not been modified with a plot directive. See umap_vis.py to regenerate images. .. code:: python @@ -49,7 +49,7 @@ After importing the required tools, we can use the :doc:`the hobbies corpus <../ # Instantiate the text visualizer umap = UMAPVisualizer() umap.fit(docs, labels) - umap.poof() + umap.show() .. image:: images/umap.png @@ -63,7 +63,7 @@ the ``UMAPVisualizer``. umap = UMAPVisualizer(metric='cosine') umap.fit(docs, labels) - umap.poof() + umap.show() .. image:: images/umap_cosine.png @@ -76,7 +76,7 @@ see if any meaningful patterns are observed. # Don't color points with their classes umap = UMAPVisualizer(labels=["documents"], metric='cosine') umap.fit(docs) - umap.poof() + umap.show() .. image:: images/umap_no_labels.png @@ -105,7 +105,7 @@ us to look for clusters of related text by their contents: umap = UMAPVisualizer() umap.fit(docs, ["c{}".format(c) for c in clusters.labels_]) - umap.poof() + umap.show() .. image:: images/umap_kmeans.png diff --git a/docs/contributing/developing_visualizers.rst b/docs/contributing/developing_visualizers.rst index 2b1af4539..5f5b9bdbb 100644 --- a/docs/contributing/developing_visualizers.rst +++ b/docs/contributing/developing_visualizers.rst @@ -26,11 +26,11 @@ These two basic types of visualizers map well to the two basic estimator objects The scikit-learn API is object oriented, and estimators are initialized with parameters by instantiating their class. Hyperparameters can also be set using the ``set_attrs()`` method and retrieved with the corresponding ``get_attrs()`` method. All scikit-learn estimators have a ``fit(X, y=None)`` method that accepts a two dimensional data array, ``X``, and optionally a vector ``y`` of target values. The ``fit()`` method trains the estimator, making it ready to transform data or make predictions. Transformers have an associated ``transform(X)`` method that returns a new dataset, ``Xprime`` and models have a ``predict(X)`` method that returns a vector of predictions, ``yhat``. Models may also have a ``score(X, y)`` method that evaluate the performance of the model. -Visualizers interact with scikit-learn objects by intersecting with them at the methods defined above. Specifically, visualizers perform actions related to ``fit()``, ``transform()``, ``predict()``, and ``score()`` then call a ``draw()`` method which initializes the underlying figure associated with the visualizer. The user calls the visualizer's ``poof()`` method, which in turn calls a ``finalize()`` method on the visualizer to draw legends, titles, etc. and then ``poof()`` renders the figure. The Visualizer API is therefore: +Visualizers interact with scikit-learn objects by intersecting with them at the methods defined above. Specifically, visualizers perform actions related to ``fit()``, ``transform()``, ``predict()``, and ``score()`` then call a ``draw()`` method which initializes the underlying figure associated with the visualizer. The user calls the visualizer's ``show()`` method, which in turn calls a ``finalize()`` method on the visualizer to draw legends, titles, etc. and then ``show()`` renders the figure. The Visualizer API is therefore: - ``draw()``: add visual elements to the underlying axes object - ``finalize()``: prepare the figure for rendering, adding final touches such as legends, titles, axis labels, etc. -- ``poof()``: render the figure for the user (or saves it to disk). +- ``show()``: render the figure for the user (or saves it to disk). Creating a visualizer means defining a class that extends ``Visualizer`` or one of its subclasses, then implementing several of the methods described above. A barebones implementation is as follows: @@ -62,7 +62,7 @@ This simple visualizer simply draws a line graph for some input dataset X, inter visualizer = MyVisualizer() visualizer.fit(X) - visualizer.poof() + visualizer.show() Score visualizers work on the same principle but accept an additional required ``estimator`` argument. Score visualizers wrap the model (which can be either fitted or unfitted) and then pass through all attributes and methods through to the underlying model, drawing where necessary. @@ -139,7 +139,7 @@ Visual tests are notoriously difficult to create --- how do you test a visualiza try: visualizer = MyVisualizer() assert visualizer.fit(X, y) is visualizer, "fit should return self" - visualizer.poof() + visualizer.show() except Exception as e: pytest.fail("my visualizer didn't work: {}".format(e)) @@ -181,7 +181,7 @@ For example, create your test function located in ``tests/test_regressor/test_my def test_my_visualizer_output(self): visualizer = MyVisualizer() visualizer.fit(X) - visualizer.poof() + visualizer.show() self.assert_images_similar(visualizer) The first time this test is run, there will be no baseline image to compare against, so the test will fail. Copy the output images (in this case ``tests/actual_images/test_regressor/test_myvisualizer/test_my_visualizer_output.png``) to the correct subdirectory of baseline_images tree in the source directory (in this case ``tests/baseline_images/test_regressor/test_myvisualizer/test_my_visualizer_output.png``). Put this new file under source code revision control (with git add). When rerunning the tests, they should now pass. @@ -367,7 +367,7 @@ The initial documentation for your visualizer will be a well structured docstrin -------- >>> model = MyVisualizer() >>> model.fit(X) - >>> model.poof() + >>> model.show() Notes ----- @@ -400,7 +400,7 @@ There are quite a few examples in the documentation on which you can base your f visualizer = MyVisualizer(LinearRegression()) visualizer.fit(X, y) - g = visualizer.poof() + g = visualizer.show() Discussion about my visualizer and some interpretation of the above plot. diff --git a/docs/faq.rst b/docs/faq.rst index f8b231278..218fda939 100644 --- a/docs/faq.rst +++ b/docs/faq.rst @@ -95,7 +95,7 @@ Finally please note that you can manipulate the default colors that Yellowbrick How can I save a Yellowbrick plot? ---------------------------------- -Save your Yellowbrick plot by passing an ``outpath`` into ``poof()``: +Save your Yellowbrick plot by passing an ``outpath`` into ``show()``: .. code:: python @@ -105,7 +105,7 @@ Save your Yellowbrick plot by passing an ``outpath`` into ``poof()``: visualizer = KElbowVisualizer(MiniBatchKMeans(), k=(4,12)) visualizer.fit(X) - visualizer.poof(outpath="kelbow_minibatchkmeans.png") + visualizer.show(outpath="kelbow_minibatchkmeans.png") ... diff --git a/docs/gallery.py b/docs/gallery.py index ff7b185a8..c1ea52a0f 100644 --- a/docs/gallery.py +++ b/docs/gallery.py @@ -87,7 +87,7 @@ def savefig(viz, name, gallery=GALLERY): raise ValueError("name should not specify extension") outpath = path.join(gallery, name + ".png") - viz.poof(outpath=outpath) + viz.show(outpath=outpath) print("created {}".format(outpath)) diff --git a/docs/quickstart.rst b/docs/quickstart.rst index 96553f382..9e36da933 100644 --- a/docs/quickstart.rst +++ b/docs/quickstart.rst @@ -44,7 +44,7 @@ Once installed, you should be able to import Yellowbrick without an error, both Using Yellowbrick ----------------- -The Yellowbrick API is specifically designed to play nicely with scikit-learn. The primary interface is therefore a ``Visualizer`` -- an object that learns from data to produce a visualization. Visualizers are scikit-learn `Estimator `_ objects and have a similar interface along with methods for drawing. In order to use visualizers, you simply use the same workflow as with a scikit-learn model, import the visualizer, instantiate it, call the visualizer's ``fit()`` method, then in order to render the visualization, call the visualizer's ``poof()`` method, which does the magic! +The Yellowbrick API is specifically designed to play nicely with scikit-learn. The primary interface is therefore a ``Visualizer`` -- an object that learns from data to produce a visualization. Visualizers are scikit-learn `Estimator `_ objects and have a similar interface along with methods for drawing. In order to use visualizers, you simply use the same workflow as with a scikit-learn model, import the visualizer, instantiate it, call the visualizer's ``fit()`` method, then in order to render the visualization, call the visualizer's ``show()`` method. For example, there are several visualizers that act as transformers, used to perform feature analysis prior to fitting a model. The following example visualizes a high-dimensional data set with parallel coordinates: @@ -54,15 +54,15 @@ For example, there are several visualizers that act as transformers, used to per visualizer = ParallelCoordinates() visualizer.fit_transform(X, y) - visualizer.poof() + visualizer.show() As you can see, the workflow is very similar to using a scikit-learn transformer, and visualizers are intended to be integrated along with scikit-learn utilities. Arguments that change how the visualization is drawn can be passed into the visualizer upon instantiation, similarly to how hyperparameters are included with scikit-learn models. -The ``poof()`` method finalizes the drawing (adding titles, axes labels, etc) and then renders the image on your behalf. If you're in a Jupyter notebook, the image should just appear. If you're in a Python script, a GUI window should open with the visualization in interactive form. However, you can also save the image to disk by passing in a file path as follows: +The ``show()`` method finalizes the drawing (adding titles, axes labels, etc) and then renders the image on your behalf. If you're in a Jupyter notebook, the image should just appear in the notebook output. If you're in a Python script, a GUI window should open with the visualization in interactive form. However, you can also save the image to disk by passing in a file path as follows: .. code-block:: python - visualizer.poof(outpath="pcoords.png") + visualizer.show(outpath="pcoords.png") The extension of the filename will determine how the image is rendered. In addition to the ``.png`` extension, ``.pdf`` is also commonly used for high-quality publication ready images. @@ -85,9 +85,9 @@ Visualizers can also wrap scikit-learn models for evaluation, hyperparameter tun visualizer.fit(X_train, y_train) visualizer.score(X_test, y_test) - visualizer.poof() + visualizer.show() -Only two additional lines of code are required to add visual evaluation of the classifier model, the instantiation of a ``ClassificationReport`` visualizer that wraps the classification estimator and a call to its ``poof()`` method. In this way, Visualizers *enhance* the machine learning workflow without interrupting it. +Only two additional lines of code are required to add visual evaluation of the classifier model, the instantiation of a ``ClassificationReport`` visualizer that wraps the classification estimator and a call to its ``show()`` method. In this way, Visualizers *enhance* the machine learning workflow without interrupting it. .. TODO:: Walkthrough visual pipelines and text analysis. @@ -149,7 +149,7 @@ The machine learning workflow is the art of creating *model selection triples*, visualizer = Rank2D(algorithm="pearson") visualizer.fit_transform(X) - visualizer.poof() + visualizer.show() .. plot:: :include-source: False @@ -163,7 +163,7 @@ The machine learning workflow is the art of creating *model selection triples*, X, y = load_bikeshare() visualizer = Rank2D(algorithm="pearson") visualizer.fit_transform(X) - visualizer.poof() + visualizer.show() plt.tight_layout() This figure shows us the Pearson correlation between pairs of features such that each cell in the grid represents two features identified in order on the x and y axes and whose color displays the magnitude of the correlation. A Pearson correlation of 1.0 means that there is a strong positive, linear relationship between the pairs of variables and a value of -1.0 indicates a strong negative, linear relationship (a value of zero indicates no relationship). Therefore we are looking for dark red and dark blue boxes to identify further. @@ -176,7 +176,7 @@ In this chart, we see that the features ``temp`` and ``feelslike`` have a strong visualizer = JointPlotVisualizer(columns=['temp', 'feelslike']) visualizer.fit_transform(X, y) - visualizer.poof() + visualizer.show() .. plot:: :include-source: False @@ -189,7 +189,7 @@ In this chart, we see that the features ``temp`` and ``feelslike`` have a strong X, y = load_bikeshare() visualizer = JointPlotVisualizer(columns=['temp', 'feelslike']) visualizer.fit_transform(X, y) - visualizer.poof() + visualizer.show() This visualizer plots a scatter diagram of the apparent temperature on the y axis and the actual measured temperature on the x axis and draws a line of best fit using a simple linear regression. Additionally, univariate distributions are shown as histograms above the x axis for temp and next to the y axis for feelslike. The ``JointPlotVisualizer`` gives an at-a-glance view of the very strong positive correlation of the features, as well as the range and distribution of each feature. Note that the axes are normalized to the space between zero and one, a common technique in machine learning to reduce the impact of one feature over another. @@ -215,7 +215,7 @@ At this point, we can train our model; let's fit a linear regression to our mode visualizer = ResidualsPlot(LinearRegression()) visualizer.fit(X_train, y_train) visualizer.score(X_test, y_test) - visualizer.poof() + visualizer.show() .. plot:: :include-source: False @@ -237,7 +237,7 @@ At this point, we can train our model; let's fit a linear regression to our mode visualizer = ResidualsPlot(LinearRegression()) visualizer.fit(X_train, y_train) visualizer.score(X_test, y_test) - visualizer.poof() + visualizer.show() The residuals plot shows the error against the predicted value (the number of riders), and allows us to look for heteroskedasticity in the model; e.g. regions in the target where the error is greatest. The shape of the residuals can strongly inform us where OLS (ordinary least squares) is being most strongly affected by the components of our model (the features). In this case, we can see that the lower predicted number of riders results in lower model error, and conversely that the the higher predicted number of riders results in higher model error. This indicates that our model has more noise in certain regions of the target or that two variables are colinear, meaning that they are injecting error as the noise in their relationship changes. @@ -257,7 +257,7 @@ Along with generating the residuals plot, we also measured the performance by "s alphas = np.logspace(-10, 1, 200) visualizer = AlphaSelection(RidgeCV(alphas=alphas)) visualizer.fit(X, y) - visualizer.poof() + visualizer.show() .. plot:: :include-source: False @@ -274,7 +274,7 @@ Along with generating the residuals plot, we also measured the performance by "s alphas = np.logspace(-10, 1, 200) visualizer = AlphaSelection(RidgeCV(alphas=alphas)) visualizer.fit(X, y) - visualizer.poof() + visualizer.show() When exploring model families, the primary thing to consider is how the model becomes more *complex*. As the model increases in complexity, the error due to variance increases because the model is becoming more overfit and cannot generalize to unseen data. However, the simpler the model is the more error there is likely to be due to bias; the model is underfit and therefore misses its target more frequently. The goal therefore of most machine learning is to create a model that is *just complex enough*, finding a middle ground between bias and variance. @@ -292,7 +292,7 @@ We can now train our final model and visualize it with the ``PredictionError`` v visualizer = PredictionError(Ridge(alpha=3.181)) visualizer.fit(X_train, y_train) visualizer.score(X_test, y_test) - visualizer.poof() + visualizer.show() .. plot:: :include-source: False @@ -314,7 +314,7 @@ We can now train our final model and visualize it with the ``PredictionError`` v visualizer = PredictionError(Ridge(alpha=3.181)) visualizer.fit(X_train, y_train) visualizer.score(X_test, y_test) - visualizer.poof() + visualizer.show() The prediction error visualizer plots the actual (measured) vs. expected (predicted) values against each other. The dotted black line is the 45 degree line that indicates zero error. Like the residuals plot, this allows us to see where error is occurring and in what magnitude. diff --git a/docs/tutorial.py b/docs/tutorial.py index b1f98544a..43b707a46 100644 --- a/docs/tutorial.py +++ b/docs/tutorial.py @@ -79,7 +79,7 @@ def visualize_model(X, y, estimator, path, **kwargs): ) visualizer.fit(X, y) visualizer.score(X, y) - visualizer.poof(outpath=path) + visualizer.show(outpath=path) if __name__ == "__main__": diff --git a/docs/tutorial.rst b/docs/tutorial.rst index ebebd930e..674879223 100644 --- a/docs/tutorial.rst +++ b/docs/tutorial.rst @@ -203,7 +203,7 @@ Now let's refactor our model evaluation function to use Yellowbrick's ``Classifi ) visualizer.fit(X, y) visualizer.score(X, y) - visualizer.poof() + visualizer.show() for model in models: visualize_model(X, y, model) diff --git a/examples/LCOMBS/testing.ipynb b/examples/LCOMBS/testing.ipynb index 833fe3ba7..b407899a9 100644 --- a/examples/LCOMBS/testing.ipynb +++ b/examples/LCOMBS/testing.ipynb @@ -287,7 +287,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -314,7 +314,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -366,7 +366,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -393,7 +393,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -466,7 +466,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { @@ -528,7 +528,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { @@ -602,7 +602,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { @@ -657,7 +657,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { @@ -713,7 +713,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] } ], diff --git a/examples/NealHumphrey/testing_yb.ipynb b/examples/NealHumphrey/testing_yb.ipynb index d0901af3f..266437ece 100644 --- a/examples/NealHumphrey/testing_yb.ipynb +++ b/examples/NealHumphrey/testing_yb.ipynb @@ -124,7 +124,7 @@ "visualizer = Rank2D(features = names, algorithm = 'pearson')\n", "visualizer.fit(X, y)\n", "visualizer.transform(X)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -179,7 +179,7 @@ " cr_viz = ClassificationReport(model) #,classes=city_options\n", " cr_viz.fit(X_train, y_train)\n", " cr_viz.score(X_test, y_test)\n", - " cr_viz.poof()\n", + " cr_viz.show()\n", " \n" ] }, @@ -225,7 +225,7 @@ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[1;32mfrom\u001b[0m \u001b[0myellowbrick\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mclassifier\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mClassificationReport\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[1;31m#This produces an IndexError: list index out of range.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mtrain_and_classification_report\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mLogisticRegression\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m\u001b[0m in \u001b[0;36mtrain_and_classification_report\u001b[0;34m(model)\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0mcr_viz\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mClassificationReport\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m#,classes=city_options\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0mcr_viz\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m \u001b[0mcr_viz\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 13\u001b[0m \u001b[0mcr_viz\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mtrain_and_classification_report\u001b[0;34m(model)\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0mcr_viz\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mClassificationReport\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m#,classes=city_options\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0mcr_viz\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m \u001b[0mcr_viz\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 13\u001b[0m \u001b[0mcr_viz\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n", "\u001b[0;32mC:\\Users\\humph\\Documents\\Github\\yellowbrick\\yellowbrick\\classifier.py\u001b[0m in \u001b[0;36mscore\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 133\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mscores\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;32mlambda\u001b[0m \u001b[0ms\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mdict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mzip\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mclasses_\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0ms\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mscores\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m 134\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mscores\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mzip\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkeys\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mscores\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m--> 135\u001b[0;31m \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 136\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m 137\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mdraw\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", "\u001b[0;32mC:\\Users\\humph\\Documents\\Github\\yellowbrick\\yellowbrick\\classifier.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, y, y_pred)\u001b[0m\n\u001b[1;32m 158\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mcolumn\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m 159\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mrow\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mclasses_\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m--> 160\u001b[0;31m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0max\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcolumn\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mrow\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mrow\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mcolumn\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mva\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'center'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mha\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'center'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 161\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m 162\u001b[0m \u001b[0mfig\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minterpolation\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'nearest'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mcmap\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcmap\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvmin\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mvmax\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", "\u001b[0;31mIndexError\u001b[0m: list index out of range" @@ -329,7 +329,7 @@ " class_balance = yb.classifier.ClassBalance(model, classes=city_options)\n", " class_balance.fit(X_train, y_train)\n", " class_balance.score(X_test, y_test)\n", - " class_balance.poof()" + " class_balance.show()" ] }, { diff --git a/examples/Sangarshanan/comparing_corpus_visualizers.ipynb b/examples/Sangarshanan/comparing_corpus_visualizers.ipynb index ab17641f9..b19a09f68 100644 --- a/examples/Sangarshanan/comparing_corpus_visualizers.ipynb +++ b/examples/Sangarshanan/comparing_corpus_visualizers.ipynb @@ -80,7 +80,7 @@ " if 't-sne' in dim_reduction.lower():\n", " viz = TSNEVisualizer(alpha = alpha)\n", " viz.fit(docs,labels)\n", - " viz.poof()" + " viz.show()" ] }, { diff --git a/examples/agodbehere/PytorchExample.html b/examples/agodbehere/PytorchExample.html deleted file mode 100644 index b5f57a448..000000000 --- a/examples/agodbehere/PytorchExample.html +++ /dev/null @@ -1,12513 +0,0 @@ - - - -PytorchExample - - - - - - - - - - - - - - - - - - - -
-
- -
-
-
In [1]:
-
-
-
from sklearn.datasets import make_circles, load_iris
-from sklearn.model_selection import train_test_split
-
-import torch
-
-import numpy as np
-
-import yellowbrick as yb
-import matplotlib
-import matplotlib.pylab as plt
-
-# dtype = torch.long
-# device = torch.device("cpu")
-
- -
-
-
- -
-
-
-
-
-

Load data & prepare

-
-
-
-
-
-
In [2]:
-
-
-
X, y = make_circles(n_samples=1000, noise=0.1)
-
-# 75/25 train/test split
-orig_X_train, orig_X_test, orig_y_train, orig_y_test = train_test_split(X, y, test_size=0.25)
-
-# Transform data into tensors.
-X = torch.tensor(orig_X_train, dtype=torch.float)
-y = torch.tensor(orig_y_train, dtype=torch.long)
-
- -
-
-
- -
-
-
-
-
-

Visualize data

-
-
-
-
-
-
In [3]:
-
-
-
import yellowbrick.contrib.scatter
-visualizer = yellowbrick.contrib.scatter.ScatterVisualizer()
-
-visualizer.fit(orig_X_train, orig_y_train)
-visualizer.poof()
-
- -
-
-
- -
-
- - -
- -
- - - - -
- -
- -
- -
-
- -
-
-
-
-
-

Basic Neural Net

3 things are needed for an optimization problem:

-
    -
  1. model
  2. -
  3. Loss function
  4. -
  5. Optimizer
  6. -
- -
-
-
-
-
-
In [4]:
-
-
-
from torch import nn
-
-# Sequential model allows easy model experimentation
-model = nn.Sequential(
-          nn.Linear(2, 16),    # input dim 2. 16 neurons in first layer.
-          nn.ReLU(),           # ReLU activation
-          #nn.Dropout(p=0.2),  # Optional dropout
-          nn.Linear(16, 4),     # Linear from 16 neurons down to 2
-          nn.ReLU(),
-          nn.Linear(4,2),
-          nn.Softmax(dim=1)    # Softmax activation to normalize output weights
-        )
-
-
-# Loss function. CrossEntropy is valid for classification problems.
-loss_fn = nn.CrossEntropyLoss()
-
-# Optimizer. Many to choose from. 
-optimizer = torch.optim.Adam(params=model.parameters())
-
-# Optimizer iterations
-for i in range(1000):
-    # Clear the gradient at the start of each step.
-    optimizer.zero_grad()
-    
-    # Compute the forward pass
-    output = model(X)
-    
-    # Compute the loss
-    loss = loss_fn(output, y)
-    
-    # Backprop to compute the gradients
-    loss.backward()
-    
-    # Update the model parameters
-    optimizer.step()
-
-print(loss.item())
-
- -
-
-
- -
-
- - -
- -
- - -
-
0.46360188722610474
-
-
-
- -
-
- -
-
-
-
-
-

What do the activation regions look like?

(an exercise in Tensor math)

- -
-
-
-
-
-
In [5]:
-
-
-
%matplotlib inline
-
-# Make a grid 
-ns = 25
-xx, yy = np.meshgrid(np.linspace(-1.5, 1.5, 2*ns), np.linspace(-1.5, 1.5, 2*ns))
-# Shape of each is [ns, ns]
-
-# Combine into a single tensor
-G = torch.tensor(np.array([xx, yy]), dtype=torch.float)
-# Shape is [2, ns, ns]
-
-# reshape to be convenient to work with
-G = G.reshape((2, G.shape[1]*G.shape[2])).transpose(0,1)
-# Now a tensor of shape [ns*ns, 2]. Sequence of x,y coordinate pairs
-
-result = model(G).detach()
-# For each row (sample) in G, get the prediction under the model
-# The variables inside the model are tracked for gradients. 
-# Call "detach()" to stop tracking gradient for further computations.
-# Result is shape [ns*ns, 2] since model takes 2-dim vectors and generates a 2-dim prediction
-
-c0 = result[:,0]
-# weights assigned to class 0
-
-c1 = result[:,1]
-# weights assigned to class 1
-
-plt.hexbin(G[:,0].detach().numpy(), G[:,1].detach().numpy(), c0.numpy(), gridsize=ns, cmap='viridis')
-# Gridsize is half that of the meshgrid for clean rendering.
-
-plt.title("Class 0 Activation")
-plt.axis('equal')
-plt.show()
-plt.hexbin(G[:,0].detach().numpy(), G[:,1].detach().numpy(), c1.numpy(), gridsize=ns, cmap='viridis')
-plt.title("Class 1 Activation")
-plt.axis('equal')
-plt.show()
-
- -
-
-
- -
-
- - -
- -
- - - - -
- -
- -
- -
- -
- - - - -
- -
- -
- -
-
- -
-
-
-
-
-

What is the classification performance?

Case study in working with Yellowbrick

- -
-
-
-
-
-
In [6]:
-
-
-
from sklearn.base import BaseEstimator
-
-class NetWrapper(BaseEstimator):
-    """
-    Wrap our model as a BaseEstimator
-    """
-    _estimator_type = "classifier"
-    # Tell yellowbrick this is a classifier
-    
-    def __init__(self, model):
-        # save a reference to the model
-        self.model = model
-        self.classes_ = None
-    
-    def fit(self, X, y):
-        # save the list of classes
-        self.classes_ = list(set(i for i in y))
-    
-    def predict_proba(self, X):
-        """
-        Define predict_proba or decision_function
-        
-        Compute predictions from model. 
-        Transform input into a Tensor, compute the prediction, 
-        transform the prediction back into a numpy array
-        """
-        v = model(torch.tensor(X, dtype=torch.float)).detach().numpy()
-        print("v:", v.shape)
-        return v
-        
-
-wrapped_net = NetWrapper(model)
-# Wrap the model
-
-# Use ROCAUC as per usual
-ROCAUC = yb.classifier.ROCAUC(wrapped_net)
-
-ROCAUC.fit(orig_X_train, orig_y_train)
-print(orig_X_test.shape, orig_y_test.shape)
-print(orig_X_train.shape, orig_y_train.shape)
-ROCAUC.score(orig_X_test, orig_y_test)
-ROCAUC.poof()
-
- -
-
-
- -
-
- - -
- -
- - -
-
(250, 2) (250,)
-(750, 2) (750,)
-v: (250, 2)
-
-
-
- -
- -
- - - - -
- -
- -
- -
-
- -
-
-
-
-
-

Custom Modules

Implementing new functionality, e.g. radial activation regions for "circular" neurons

- -
-
-
-
-
-
In [7]:
-
-
-
# weight: a * (x-c)^T(x-c), a is a real number
-
-class Circle(torch.nn.Module):
-    """
-    Extend torch.nn.Module for a new "layer" in a neural network
-    """
-    def __init__(self, k, data):
-        """
-        k is the number of neurons to use
-        data is passed in to use as samples to initialize centers
-        """
-        super().__init__()
-        
-        # k is not a Parameter, so there is no gradient and this is not updated in optimization
-        self.k = int(k)
-        
-        # Parameters always have gradients computed
-        self.alpha = torch.nn.Parameter(torch.normal(mean=torch.zeros(k), std=torch.ones(k)*0.5).unsqueeze(1))
-        self.C = torch.nn.Parameter(data[np.random.choice(data.shape[0], k, replace=False), :].unsqueeze(1))
-        
-        
-    def forward(self, x): 
-        diff = (x - self.C)        
-        # compact way of writing inner products, outer products, etc.
-        tmp = torch.einsum('kij,kij->ki', [diff, diff])
-
-        return (self.alpha * torch.einsum('kij,kij->ki', [diff, diff])).transpose(0,1)
-
- -
-
-
- -
-
-
-
In [8]:
-
-
-
from tqdm import tqdm
-loss_fn = torch.nn.CrossEntropyLoss()
-model = nn.Sequential(
-          Circle(16, X),
-          nn.ReLU(),
-          nn.Linear(16,4),
-          nn.ReLU(),
-          nn.Linear(4,2),
-          nn.Softmax(dim=1)
-        )
-optimizer = torch.optim.Adam(params=model.parameters())
-for i in tqdm(range(1000)):
-    optimizer.zero_grad()
-    output = model(X)
-    loss = loss_fn(output, y)
-    loss.backward()
-    optimizer.step()
-
- -
-
-
- -
-
- - -
- -
- - -
-
100%|██████████| 1000/1000 [00:26<00:00, 37.85it/s]
-
-
-
- -
-
- -
-
-
-
In [9]:
-
-
-
%matplotlib inline
-
-ns = 25
-xx, yy = np.meshgrid(np.linspace(-1.5, 1.5, 2*ns), np.linspace(-1.5, 1.5, 2*ns))
-G = torch.tensor(np.array([xx, yy]), dtype=torch.float)
-
-
-# reshape...
-G = G.reshape((2, G.shape[1]*G.shape[2])).transpose(0,1)
-result = model(G).detach()
-
-c0 = result[:,0]
-c1 = result[:,1]
-
-plt.hexbin(G[:,0].detach().numpy(), G[:,1].detach().numpy(), c0.numpy(), gridsize=ns, cmap='viridis')
-plt.title("Class 0 Activation")
-plt.axis('equal')
-plt.show()
-plt.hexbin(G[:,0].detach().numpy(), G[:,1].detach().numpy(), c1.numpy(), gridsize=ns, cmap='viridis')
-plt.title("Class 1 Activation")
-plt.axis('equal')
-plt.show()
-
- -
-
-
- -
-
- - -
- -
- - - - -
- -
- -
- -
- -
- - - - -
- -
- -
- -
-
- -
-
-
-
In [10]:
-
-
-
wrapped_net = NetWrapper(model)
-ROCAUC = yb.classifier.ROCAUC(wrapped_net)
-
-ROCAUC.fit(orig_X_train, orig_y_train)
-wrapped_net.predict_proba(orig_X_test)
-ROCAUC.score(orig_X_test, orig_y_test)
-ROCAUC.poof()
-
- -
-
-
- -
-
- - -
- -
- - -
-
v: (250, 2)
-v: (250, 2)
-
-
-
- -
- -
- - - - -
- -
- -
- -
-
- -
-
-
-
In [11]:
-
-
-
%matplotlib inline
-
-# Show the centers of each "kernel" 
-
-centers = model[0].C.squeeze().detach().numpy()
-scales = model[0].alpha.squeeze().detach().numpy()
-
-plt.scatter(centers[:,0], centers[:,1])
-plt.scatter(X[:,0], X[:,1], alpha=0.1)
-plt.axis('equal')
-
-print(centers.shape)
-
- -
-
-
- -
-
- - -
- -
- - -
-
(16, 2)
-
-
-
- -
- -
- - - - -
- -
- -
- -
-
- -
-
-
-
In [12]:
-
-
-
%matplotlib inline
-from matplotlib import cm
-
-# Show the contours of the activation regions of each kernel
-
-ns = 25
-xx, yy = np.meshgrid(np.linspace(-2, 2, ns), np.linspace(-2, 2, ns))
-G = torch.tensor(np.array([xx, yy]), dtype=torch.float)
-G = G.reshape((2, G.shape[1]*G.shape[2])).transpose(0,1)
-G = G.expand(centers.shape[0], ns*ns, 2)
-Z = torch.tensor(scales).unsqueeze(1) * torch.einsum('kij,kij->ki', [G-torch.tensor(centers).unsqueeze(1), G-torch.tensor(centers).unsqueeze(1)])
-
-plt.scatter(centers[:,0], centers[:,1])
-plt.scatter(X[:,0], X[:,1], alpha=0.1)
-cmap = cm.get_cmap('tab20')
-for i in range(Z.shape[0]):
-    if scales[i] > 0:   
-        plt.contour(np.linspace(-2, 2, ns), np.linspace(-2, 2, ns), Z[i].reshape(ns, ns), [-0.5,0.5], antialiased=True, colors=[cmap(i)], alpha=0.8, linestyles='dotted')
-    else:
-        plt.contour(np.linspace(-2, 2, ns), np.linspace(-2, 2, ns), Z[i].reshape(ns, ns), [-0.5,0.5], antialiased=True, colors=[cmap(i)], alpha=0.3, linestyles='solid')
-
-plt.axis('equal')
-
- -
-
-
- -
-
- - -
- -
- - -
-
/Users/andrewgodbehere/environments/torch/lib/python3.7/site-packages/matplotlib/contour.py:1230: UserWarning: No contour levels were found within the data range.
-  warnings.warn("No contour levels were found"
-
-
-
- -
- -
Out[12]:
- - - - -
-
(-2.0, 2.0, -2.0, 2.0)
-
- -
- -
- -
- - - - -
- -
- -
- -
-
- -
-
-
- - - - - - diff --git a/examples/agodbehere/PytorchExample.ipynb b/examples/agodbehere/PytorchExample.ipynb index ddd67b323..72c28c419 100644 --- a/examples/agodbehere/PytorchExample.ipynb +++ b/examples/agodbehere/PytorchExample.ipynb @@ -61,7 +61,7 @@ "visualizer = yellowbrick.contrib.scatter.ScatterVisualizer()\n", "\n", "visualizer.fit(orig_X_train, orig_y_train)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -232,7 +232,7 @@ "print(orig_X_test.shape, orig_y_test.shape)\n", "print(orig_X_train.shape, orig_y_train.shape)\n", "ROCAUC.score(orig_X_test, orig_y_test)\n", - "ROCAUC.poof()\n" + "ROCAUC.show()\n" ] }, { @@ -347,7 +347,7 @@ "ROCAUC.fit(orig_X_train, orig_y_train)\n", "wrapped_net.predict_proba(orig_X_test)\n", "ROCAUC.score(orig_X_test, orig_y_test)\n", - "ROCAUC.poof()\n" + "ROCAUC.show()\n" ] }, { diff --git a/examples/balavenkatesan/testing.py b/examples/balavenkatesan/testing.py index 35a67117f..afb43d52a 100644 --- a/examples/balavenkatesan/testing.py +++ b/examples/balavenkatesan/testing.py @@ -114,4 +114,4 @@ def show_plot(X, y, n_neighbors=10, h=0.2): model.predict(X) # visualizer = KnnDecisionBoundariesVisualizer(model, classes=school.target_names, features=school.feature_names[:2]) visualizer = KnnDecisionBoundariesVisualizer(model) - visualizer.fit_draw_poof(X, y) + visualizer.fit_draw_show(X, y) diff --git a/examples/bbengfort/alphas.ipynb b/examples/bbengfort/alphas.ipynb index 25f71df7b..8a883a93c 100644 --- a/examples/bbengfort/alphas.ipynb +++ b/examples/bbengfort/alphas.ipynb @@ -171,7 +171,7 @@ "source": [ "model = AlphaSelection(RidgeCV(alphas=alphas, scoring=\"neg_mean_squared_error\"))\n", "model.fit(X, y)\n", - "model.poof()" + "model.show()" ] }, { @@ -195,7 +195,7 @@ "source": [ "model = AlphaSelection(LassoCV(alphas=alphas))\n", "model.fit(X, y)\n", - "model.poof()" + "model.show()" ] }, { @@ -219,7 +219,7 @@ "source": [ "model = AlphaSelection(LassoLarsCV())\n", "model.fit(X, y)\n", - "model.poof()" + "model.show()" ] }, { @@ -243,7 +243,7 @@ "source": [ "model = AlphaSelection(ElasticNetCV(alphas=alphas))\n", "model.fit(X, y)\n", - "model.poof()" + "model.show()" ] }, { @@ -279,7 +279,7 @@ "source": [ "model = ManualAlphaSelection(Ridge())\n", "model.fit(X, y)\n", - "model.poof()" + "model.show()" ] }, { @@ -303,7 +303,7 @@ "source": [ "model = ManualAlphaSelection(Lasso())\n", "model.fit(X, y)\n", - "model.poof()" + "model.show()" ] }, { diff --git a/examples/bbengfort/cluster.ipynb b/examples/bbengfort/cluster.ipynb index 687004da9..d5a14d87c 100644 --- a/examples/bbengfort/cluster.ipynb +++ b/examples/bbengfort/cluster.ipynb @@ -102,7 +102,7 @@ "X, y = make_blobs(centers=8)\n", "visualizer = KElbowVisualizer(KMeans(), k=(4,12))\n", "visualizer.fit(X)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -124,7 +124,7 @@ "source": [ "visualizer = KElbowVisualizer(KMeans(), k=(4,12), metric=\"silhouette\")\n", "visualizer.fit(X)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -146,7 +146,7 @@ "source": [ "visualizer = KElbowVisualizer(KMeans(), k=(4,12), metric=\"calinski_harabaz\")\n", "visualizer.fit(X)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -177,7 +177,7 @@ "X, y = make_circles(n_samples=N_SAMPLES)\n", "visualizer = KElbowVisualizer(KMeans(), k=(4,12))\n", "visualizer.fit(X)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -201,7 +201,7 @@ "X, y = make_moons(n_samples=N_SAMPLES)\n", "visualizer = KElbowVisualizer(KMeans(), k=(4,12))\n", "visualizer.fit(X)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -243,7 +243,7 @@ "X, y = make_blobs(centers=8)\n", "visualizer = SilhouetteVisualizer(KMeans(6))\n", "visualizer.fit(X)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { diff --git a/examples/bbengfort/errors.md b/examples/bbengfort/errors.md deleted file mode 100644 index 788769cf2..000000000 --- a/examples/bbengfort/errors.md +++ /dev/null @@ -1,223 +0,0 @@ -### Error 1 - -Trying to import Yellowbrick: - -``` - -from yellowbrick.text import FreqDistVisualizer ---------------------------------------------------------------------------- -ImportError Traceback (most recent call last) - in () -----> 1 from yellowbrick.text import FreqDistVisualizer - -ImportError: No module named 'yellowbrick' -``` - -Was not in a virtualenv, tried to get a virtualenv set up; still having problems with yellowbrick. -Solved: sys.path.append - -### Error 2 - -On import, deprecation warning: - -``` -/usr/local/lib/python3.5/site-packages/sklearn/cross_validation.py:44: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20. - "This module will be removed in 0.20.", DeprecationWarning) -``` - -In my user testing I'm using Scikit-Learn 0.18 - -### Error 3 - -Running `FreqDistVisualizer` in a pipeline: - -``` -from sklearn.pipeline import Pipeline -from sklearn.feature_extraction.text import CountVectorizer -from yellowbrick.text import FreqDistVisualizer - -visualizer = Pipeline([ - ('norm', TextNormalizer()), - ('count', CountVectorizer(tokenizer=lambda x: x, preprocessor=None, lowercase=False)), - ('viz', FreqDistVisualizer()) -]) - -visualizer.fit_transform(documents(), labels()) -visualizer.named_steps['viz'].poof() -``` - -I get the following error: - -``` ---------------------------------------------------------------------------- -AttributeError Traceback (most recent call last) - in () - 9 ]) - 10 ----> 11 visualizer.fit_transform(documents(), labels()) - 12 visualizer.named_steps['viz'].poof() - -/usr/local/lib/python3.5/site-packages/sklearn/pipeline.py in fit_transform(self, X, y, **fit_params) - 301 Xt, fit_params = self._fit(X, y, **fit_params) - 302 if hasattr(last_step, 'fit_transform'): ---> 303 return last_step.fit_transform(Xt, y, **fit_params) - 304 elif last_step is None: - 305 return Xt - -/usr/local/lib/python3.5/site-packages/sklearn/base.py in fit_transform(self, X, y, **fit_params) - 495 else: - 496 # fit method of arity 2 (supervised transformation) ---> 497 return self.fit(X, y, **fit_params).transform(X) - 498 - 499 - -AttributeError: 'NoneType' object has no attribute 'transform' -``` - -This is because the `fit()` method needs to return self. -Also, the features passed into fit do not match the vector y that I'm passing to it. -Instead, features needs to be added as input to the initializer, or passed to -`inverse_transform` as needed on the vectorizer. - -### Error 4 - -If I don't call poof() then I get a graphic displayed in the notebook that's not finalized. I think this is going to be a weirdness of `%matplotlib inline` - -![No poof called, no finalize](figures/nopoofnofinal.png) - - -### Error 5 - -Ran the TSNE visualizer ... but ended up with an empty figure? - -![No TSNE?](figures/notsne.png) - -### Error 6 - -I created a classifier, and I wanted to get a ClassBalance, ClassificationReport, _and_ ROCAUC for each of them. So I trained the model, then created the `ScoreVisualizer` by passing in the _trained_ model, and called score on it. - -``` -from sklearn.linear_model import LogisticRegression -from yellowbrick.classifier import ClassBalance, ClassificationReport, ROCAUC - -logit = LogisticRegression() -logit.fit(docs_train, labels_train) - -logit_balance = ClassBalance(logit) -logit_balance.score(docs_test, labels_test) -logit_balance.poof() -``` - -Because I didn't pass in a classes argument I got the following: - -``` ---------------------------------------------------------------------------- -TypeError Traceback (most recent call last) - in () - 1 logit_balance = ClassBalance(logit) -----> 2 logit_balance.score(docs_test, labels_test) - 3 logit_balance.poof() - -/Users/benjamin/Repos/tmp/yellowbrick/yellowbrick/classifier.py in score(self, X, y, **kwargs) - 488 y_pred = self.predict(X) - 489 self.scores = precision_recall_fscore_support(y, y_pred) ---> 490 self.support = dict(zip(self.classes_, self.scores[-1])) - 491 return self.draw() - 492 - -TypeError: zip argument #1 must support iteration -``` - -Passing the following fixed the problem: - -``` -logit_balance = ClassBalance(logit, classes=set(labels_test)) -``` - -### Error 7 - -Attempting to get a classification report for a multi-class classifier: - -``` -logit_balance = ClassificationReport(logit, classes=set(labels_test)) -logit_balance.score(docs_test, labels_test) -logit_balance.poof() -``` - -In the same way as before led to the following exception: - -``` ---------------------------------------------------------------------------- -IndexError Traceback (most recent call last) - in () - 1 logit_balance = ClassificationReport(logit, classes=set(labels_test)) -----> 2 logit_balance.score(docs_test, labels_test) - 3 logit_balance.poof() - -/Users/benjamin/Repos/tmp/yellowbrick/yellowbrick/classifier.py in score(self, X, y, **kwargs) - 133 self.scores = map(lambda s: dict(zip(self.classes_, s)), self.scores[0:3]) - 134 self.scores = dict(zip(keys, self.scores)) ---> 135 return self.draw(y, y_pred) - 136 - 137 def draw(self, y, y_pred): - -/Users/benjamin/Repos/tmp/yellowbrick/yellowbrick/classifier.py in draw(self, y, y_pred) - 158 for column in range(len(self.matrix)+1): - 159 for row in range(len(self.classes_)): ---> 160 self.ax.text(column,row,self.matrix[row][column],va='center',ha='center') - 161 - 162 fig = plt.imshow(self.matrix, interpolation='nearest', cmap=self.cmap, vmin=0, vmax=1) - -IndexError: list index out of range -``` - -And it displayed the following: - -![No classification report](figures/nocr.png) - -**NOTE**: Same behavior when I tried to fit and score the classifier myself. - -### Error 8 - -Running a ROCAUC on a multiclass classifier: - -``` -logit_balance = ROCAUC(logit) -logit_balance.score(docs_test, labels_test) -logit_balance.poof() -``` - -Resulted in a warning that we didn't have a binary classifier: - -``` ---------------------------------------------------------------------------- -ValueError Traceback (most recent call last) - in () - 1 logit_balance = ROCAUC(logit) -----> 2 logit_balance.score(docs_test, labels_test) - 3 logit_balance.poof() - -/Users/benjamin/Repos/tmp/yellowbrick/yellowbrick/classifier.py in score(self, X, y, **kwargs) - 311 """ - 312 y_pred = self.predict(X) ---> 313 self.fpr, self.tpr, self.thresholds = roc_curve(y, y_pred) - 314 self.roc_auc = auc(self.fpr, self.tpr) - 315 return self.draw(y, y_pred) - -/usr/local/lib/python3.5/site-packages/sklearn/metrics/ranking.py in roc_curve(y_true, y_score, pos_label, sample_weight, drop_intermediate) - 503 """ - 504 fps, tps, thresholds = _binary_clf_curve( ---> 505 y_true, y_score, pos_label=pos_label, sample_weight=sample_weight) - 506 - 507 # Attempt to drop thresholds corresponding to points in between and - -/usr/local/lib/python3.5/site-packages/sklearn/metrics/ranking.py in _binary_clf_curve(y_true, y_score, pos_label, sample_weight) - 312 array_equal(classes, [-1]) or - 313 array_equal(classes, [1]))): ---> 314 raise ValueError("Data is not binary and pos_label is not specified") - 315 elif pos_label is None: - 316 pos_label = 1. - -ValueError: Data is not binary and pos_label is not specified - -``` \ No newline at end of file diff --git a/examples/bbengfort/pipeline.ipynb b/examples/bbengfort/pipeline.ipynb index ae3d1fe76..25b286ea2 100644 --- a/examples/bbengfort/pipeline.ipynb +++ b/examples/bbengfort/pipeline.ipynb @@ -192,7 +192,7 @@ " def draw(self, **kwargs):\n", " pass\n", " \n", - " def poof(self, model=None):\n", + " def show(self, model=None):\n", " \"\"\"\n", " Visualizes either data features \n", " or fitted model scores\n", @@ -245,7 +245,7 @@ " def transform(self, X):\n", " pass\n", " \n", - " def poof(self, data=None):\n", + " def show(self, data=None):\n", " \"\"\"\n", " Visualize data features individually or together\n", " \"\"\"\n", @@ -301,9 +301,9 @@ " def draw(self, X, y):\n", " pass \n", " \n", - " def poof(self, **kwargs):\n", + " def show(self, **kwargs):\n", " \"\"\"\n", - " The user calls poof\n", + " The user calls show\n", " \"\"\"\n", " pass\n", "\n" @@ -374,7 +374,7 @@ " plt.plot([0,1],[0,1],'m--',c=self.colors['diagonal'])\n", "\n", "\n", - " def poof(self, **kwargs):\n", + " def show(self, **kwargs):\n", " \"\"\" \n", " Called by user.\n", " \n", @@ -435,7 +435,7 @@ " return ax\n", "\n", "\n", - " def poof(self):\n", + " def show(self):\n", " \"\"\"\n", " Plots a classification report as a heatmap.\n", " \"\"\"\n", @@ -526,7 +526,7 @@ "source": [ "sviz = ROCAUC(model)\n", "sviz.score(y,y_pred)\n", - "sviz.poof() " + "sviz.show() " ] }, { @@ -563,7 +563,7 @@ "y_pred = model.predict(X)\n", "sviz = ROCAUC(model)\n", "sviz.score(y,y_pred)\n", - "sviz.poof() " + "sviz.show() " ] }, { @@ -600,7 +600,7 @@ "y_pred = model.predict(X)\n", "sviz = ROCAUC(model)\n", "sviz.score(y,y_pred)\n", - "sviz.poof() " + "sviz.show() " ] }, { @@ -637,7 +637,7 @@ "y_pred = model.predict(X)\n", "sviz = ClassificationReport(model)\n", "sviz.score(y,y_pred)\n", - "sviz.poof() " + "sviz.show() " ] }, { @@ -674,7 +674,7 @@ "y_pred = model.predict(X)\n", "sviz = ClassificationReport(model)\n", "sviz.score(y,y_pred)\n", - "sviz.poof() " + "sviz.show() " ] }, { @@ -711,7 +711,7 @@ "y_pred = model.predict(X)\n", "sviz = ClassificationReport(model)\n", "sviz.score(y,y_pred)\n", - "sviz.poof() " + "sviz.show() " ] }, { @@ -769,7 +769,7 @@ " draw_best_fit(y, y_pred, self.ax, 'linear', ls='--', lw=2, c=self.colors['line'])\n", " return self.ax\n", " \n", - " def poof(self):\n", + " def show(self):\n", " self.ax.set_xlim(y.min()-1, y.max()+1)\n", " self.ax.set_ylim(y_pred.min()-1, y_pred.max()+1)\n", " self.ax.set_title('Prediction Error for {}'.format(self.name))\n", @@ -826,7 +826,7 @@ "sviz = PredictionError(model)\n", "y_pred = cv.cross_val_predict(model, X, y, cv=12)\n", "sviz.score(y,y_pred)\n", - "sviz.poof() " + "sviz.show() " ] }, { @@ -863,7 +863,7 @@ "sviz = PredictionError(model)\n", "y_pred = cv.cross_val_predict(model, X, y, cv=12)\n", "sviz.score(y,y_pred)\n", - "sviz.poof() " + "sviz.show() " ] }, { @@ -900,7 +900,7 @@ "sviz = PredictionError(model)\n", "y_pred = cv.cross_val_predict(model, X, y, cv=12)\n", "sviz.score(y,y_pred)\n", - "sviz.poof() " + "sviz.show() " ] }, { @@ -940,9 +940,9 @@ " \n", " return self.ax\n", "\n", - " def poof(self):\n", + " def show(self):\n", " \"\"\"\n", - " The user calls poof\n", + " The user calls show\n", " \"\"\"\n", " self.ax.hlines(y=0, xmin=0, xmax=100)\n", " self.ax.set_title('Residuals for {} Model'.format(self.name))\n", @@ -991,7 +991,7 @@ "y_test_pred = model.predict(X_test)\n", "sviz = ResidualsPlot(model)\n", "sviz.score(y_train, y_train_pred,y_test, y_test_pred)\n", - "sviz.poof() " + "sviz.show() " ] }, { @@ -1030,7 +1030,7 @@ "y_test_pred = model.predict(X_test)\n", "sviz = ResidualsPlot(model)\n", "sviz.score(y_train, y_train_pred,y_test, y_test_pred)\n", - "sviz.poof() " + "sviz.show() " ] }, { @@ -1069,7 +1069,7 @@ "y_test_pred = model.predict(X_test)\n", "sviz = ResidualsPlot(model)\n", "sviz.score(y_train, y_train_pred,y_test, y_test_pred)\n", - "sviz.poof() " + "sviz.show() " ] }, { @@ -1115,7 +1115,7 @@ " colors = self.colors[0:len(self.classes)]\n", " plt.bar(np.arange(len(self.support)), self.support.values(), color=colors, align='center', width=0.5)\n", "\n", - " def poof(self):\n", + " def show(self):\n", " \"\"\"\n", " Plots a class balance chart\n", " \"\"\"\n", @@ -1166,7 +1166,7 @@ "y_pred = model.predict(X)\n", "sviz = ClassBalance(model)\n", "sviz.score(y,y_pred)\n", - "sviz.poof() " + "sviz.show() " ] }, { @@ -1196,7 +1196,7 @@ "y_pred = model.predict(X)\n", "sviz = ClassBalance(model)\n", "sviz.score(y,y_pred)\n", - "sviz.poof() " + "sviz.show() " ] }, { diff --git a/examples/bbengfort/regression.ipynb b/examples/bbengfort/regression.ipynb index 486778185..ce6e7fe9f 100644 --- a/examples/bbengfort/regression.ipynb +++ b/examples/bbengfort/regression.ipynb @@ -965,7 +965,7 @@ "model = PredictionError(LassoCV())\n", "model.fit(X_train, y_train)\n", "model.score(X_test, y_test)\n", - "model.poof()" + "model.show()" ] } ], diff --git a/examples/bbengfort/testing.ipynb b/examples/bbengfort/testing.ipynb index 9dfd2ca34..d9eb483e3 100644 --- a/examples/bbengfort/testing.ipynb +++ b/examples/bbengfort/testing.ipynb @@ -264,7 +264,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 9\u001b[0m ])\n\u001b[1;32m 10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdocuments\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 12\u001b[0m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnamed_steps\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'viz'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 9\u001b[0m ])\n\u001b[1;32m 10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdocuments\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 12\u001b[0m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnamed_steps\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'viz'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/usr/local/lib/python3.5/site-packages/sklearn/pipeline.py\u001b[0m in \u001b[0;36mfit_transform\u001b[0;34m(self, X, y, **fit_params)\u001b[0m\n\u001b[1;32m 301\u001b[0m \u001b[0mXt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfit_params\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_fit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mfit_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 302\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlast_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'fit_transform'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 303\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mlast_step\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mXt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mfit_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 304\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mlast_step\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 305\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mXt\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/usr/local/lib/python3.5/site-packages/sklearn/base.py\u001b[0m in \u001b[0;36mfit_transform\u001b[0;34m(self, X, y, **fit_params)\u001b[0m\n\u001b[1;32m 495\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 496\u001b[0m \u001b[0;31m# fit method of arity 2 (supervised transformation)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 497\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mfit_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 498\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 499\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mAttributeError\u001b[0m: 'NoneType' object has no attribute 'transform'" @@ -293,7 +293,7 @@ "])\n", "\n", "visualizer.fit_transform(documents(), labels())\n", - "visualizer.named_steps['viz'].poof()" + "visualizer.named_steps['viz'].show()" ] }, { @@ -325,7 +325,7 @@ "docs = vect.fit_transform(documents(), labels())\n", "viz = FreqDistVisualizer() \n", "viz.fit(docs, vect.named_steps['count'].get_feature_names())\n", - "viz.poof()" + "viz.show()" ] }, { @@ -360,7 +360,7 @@ "\n", "viz = TSNEVisualizer() \n", "viz.fit(docs, labels())\n", - "viz.poof()" + "viz.show()" ] }, { @@ -435,7 +435,7 @@ "source": [ "logit_balance = ClassBalance(logit, classes=set(labels_test))\n", "logit_balance.score(docs_test, labels_test)\n", - "logit_balance.poof()" + "logit_balance.show()" ] }, { @@ -452,7 +452,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mlogit_balance\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mClassificationReport\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlogit\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclasses\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabels_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mlogit_balance\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdocs_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0mlogit_balance\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mlogit_balance\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mClassificationReport\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlogit\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclasses\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabels_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mlogit_balance\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdocs_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0mlogit_balance\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/Users/benjamin/Repos/tmp/yellowbrick/yellowbrick/classifier.py\u001b[0m in \u001b[0;36mscore\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 133\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscores\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclasses_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscores\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 134\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscores\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkeys\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscores\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 135\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 136\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 137\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/Users/benjamin/Repos/tmp/yellowbrick/yellowbrick/classifier.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, y, y_pred)\u001b[0m\n\u001b[1;32m 158\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mcolumn\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 159\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mrow\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclasses_\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 160\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcolumn\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mrow\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mrow\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcolumn\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mva\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'center'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mha\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'center'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 161\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 162\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minterpolation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'nearest'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcmap\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmax\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mIndexError\u001b[0m: list index out of range" @@ -472,7 +472,7 @@ "source": [ "logit_balance = ClassificationReport(logit, classes=set(labels_test))\n", "logit_balance.score(docs_test, labels_test)\n", - "logit_balance.poof()" + "logit_balance.show()" ] }, { @@ -489,7 +489,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mlogit_balance\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mClassificationReport\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mLogisticRegression\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mlogit_balance\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdocs_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mlogit_balance\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdocs_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0mlogit_balance\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mlogit_balance\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mClassificationReport\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mLogisticRegression\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mlogit_balance\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdocs_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mlogit_balance\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdocs_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0mlogit_balance\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/Users/benjamin/Repos/tmp/yellowbrick/yellowbrick/classifier.py\u001b[0m in \u001b[0;36mscore\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 133\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscores\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclasses_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscores\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 134\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscores\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkeys\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscores\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 135\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 136\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 137\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/Users/benjamin/Repos/tmp/yellowbrick/yellowbrick/classifier.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, y, y_pred)\u001b[0m\n\u001b[1;32m 158\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mcolumn\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 159\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mrow\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclasses_\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 160\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcolumn\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mrow\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mrow\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcolumn\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mva\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'center'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mha\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'center'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 161\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 162\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minterpolation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'nearest'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcmap\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmax\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mIndexError\u001b[0m: list index out of range" @@ -510,7 +510,7 @@ "logit_balance = ClassificationReport(LogisticRegression())\n", "logit_balance.fit(docs_train, labels_train)\n", "logit_balance.score(docs_test, labels_test)\n", - "logit_balance.poof()" + "logit_balance.show()" ] }, { @@ -527,7 +527,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mlogit_balance\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mROCAUC\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlogit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mlogit_balance\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdocs_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0mlogit_balance\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mlogit_balance\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mROCAUC\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlogit\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mlogit_balance\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdocs_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0mlogit_balance\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/Users/benjamin/Repos/tmp/yellowbrick/yellowbrick/classifier.py\u001b[0m in \u001b[0;36mscore\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 311\u001b[0m \"\"\"\n\u001b[1;32m 312\u001b[0m \u001b[0my_pred\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 313\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mthresholds\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mroc_curve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 314\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mroc_auc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mauc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfpr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtpr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 315\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/usr/local/lib/python3.5/site-packages/sklearn/metrics/ranking.py\u001b[0m in \u001b[0;36mroc_curve\u001b[0;34m(y_true, y_score, pos_label, sample_weight, drop_intermediate)\u001b[0m\n\u001b[1;32m 503\u001b[0m \"\"\"\n\u001b[1;32m 504\u001b[0m fps, tps, thresholds = _binary_clf_curve(\n\u001b[0;32m--> 505\u001b[0;31m y_true, y_score, pos_label=pos_label, sample_weight=sample_weight)\n\u001b[0m\u001b[1;32m 506\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 507\u001b[0m \u001b[0;31m# Attempt to drop thresholds corresponding to points in between and\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/usr/local/lib/python3.5/site-packages/sklearn/metrics/ranking.py\u001b[0m in \u001b[0;36m_binary_clf_curve\u001b[0;34m(y_true, y_score, pos_label, sample_weight)\u001b[0m\n\u001b[1;32m 312\u001b[0m \u001b[0marray_equal\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mor\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 313\u001b[0m array_equal(classes, [1]))):\n\u001b[0;32m--> 314\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Data is not binary and pos_label is not specified\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 315\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mpos_label\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 316\u001b[0m \u001b[0mpos_label\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", @@ -538,7 +538,7 @@ "source": [ "logit_balance = ROCAUC(logit)\n", "logit_balance.score(docs_test, labels_test)\n", - "logit_balance.poof()" + "logit_balance.show()" ] } ], diff --git a/examples/cjmorale/ConfusionMatrix label_encoder example.ipynb b/examples/cjmorale/ConfusionMatrix label_encoder example.ipynb index d617c6d2b..5a22fbcc3 100644 --- a/examples/cjmorale/ConfusionMatrix label_encoder example.ipynb +++ b/examples/cjmorale/ConfusionMatrix label_encoder example.ipynb @@ -48,7 +48,7 @@ "viz = ConfusionMatrix(LogisticRegression(), classes=classes, label_encoder =le)\n", "viz.fit(X_train, y_train)\n", "viz.score(X_test, y_test)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -85,7 +85,7 @@ "cm = ConfusionMatrix(model, classes=classes, label_encoder = mapping)\n", "cm.fit(X_train, y_train)\n", "cm.score(X_test, y_test)\n", - "cm.poof()" + "cm.show()" ] } ], diff --git a/examples/cjmorale/PCA_Examples.ipynb b/examples/cjmorale/PCA_Examples.ipynb index 231c30c28..6fa830a7c 100644 --- a/examples/cjmorale/PCA_Examples.ipynb +++ b/examples/cjmorale/PCA_Examples.ipynb @@ -34,7 +34,7 @@ "visualizer = PCADecomposition(**params)\n", "visualizer.fit(X)\n", "visualizer.transform(X)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -64,7 +64,7 @@ "visualizer = PCADecomposition(**params)\n", "visualizer.fit(X)\n", "visualizer.transform(X)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { diff --git a/examples/clustering_visualizers.ipynb b/examples/clustering_visualizers.ipynb index 7dcdbfb3b..3d1ca940b 100644 --- a/examples/clustering_visualizers.ipynb +++ b/examples/clustering_visualizers.ipynb @@ -107,7 +107,7 @@ "visualizer = KElbowVisualizer(model, k=(4,12))\n", "\n", "visualizer.fit(X) # Fit the data to the visualizer\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Finalize and render the figure" ] }, { @@ -151,7 +151,7 @@ "visualizer = KElbowVisualizer(model, k=(4,12), metric='calinski_harabasz', timings=False)\n", "\n", "visualizer.fit(X) # Fit the data to the visualizer\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Finalize and render the figure" ] }, { @@ -210,7 +210,7 @@ "visualizer = SilhouetteVisualizer(model)\n", "\n", "visualizer.fit(X) # Fit the data to the visualizer\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Finalize and render the figure" ] }, { @@ -254,7 +254,7 @@ "visualizer = SilhouetteVisualizer(model)\n", "\n", "visualizer.fit(X) # Fit the data to the visualizer\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Finalize and render the figure" ] }, { @@ -303,7 +303,7 @@ "visualizer = InterclusterDistance(model)\n", "\n", "visualizer.fit(X) # Fit the data to the visualizer\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Finalize and render the figure" ] } ], diff --git a/examples/examples.ipynb b/examples/examples.ipynb index bd49a3cb5..ef29482c7 100644 --- a/examples/examples.ipynb +++ b/examples/examples.ipynb @@ -151,7 +151,7 @@ "\n", "Feature analysis visualizers implement the `Transformer` API from scikit-learn, meaning they can be used as intermediate transform steps in a `Pipeline` (particularly a `VisualPipeline`).\n", "\n", - "They are instantiated in the same way, and then fit and transform are called on them, which draws the instances correctly. Finally `poof` or `show` is called which displays the image. " + "They are instantiated in the same way, and then fit and transform are called on them, which draws the instances correctly. Finally `show` or `show` is called which displays the image. " ] }, { @@ -232,7 +232,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Finalize and render the figure" ] }, { @@ -264,7 +264,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Finalize and render the visualizer" ] }, { @@ -289,7 +289,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Finalize and render the visualizer" ] }, { @@ -345,7 +345,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Finalize and render the visualizer" ] }, { @@ -408,7 +408,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Finalize and render the visualizer" ] }, { @@ -436,7 +436,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Finalize and render the visualizer" ] }, { @@ -491,7 +491,7 @@ "visualizer = JointPlotVisualizer(feature=feature, target=target)\n", "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Finalize and render the visualizer" ] }, { @@ -544,7 +544,7 @@ "source": [ "visualizer = PCADecomposition(scale=True, center=False, col=y)\n", "visualizer.fit_transform(X,y)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -566,7 +566,7 @@ "source": [ "visualizer = PCADecomposition(scale=True, center=False, col=y, proj_dim=3)\n", "visualizer.fit_transform(X,y)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -672,7 +672,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Finalize and render the visualizer" ] }, { @@ -707,7 +707,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Finalize and render the visualizer" ] }, { @@ -746,7 +746,7 @@ "visualizer = AlphaSelection(model)\n", "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Finalize and render the visualizer" ] }, { @@ -837,7 +837,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Finalize and render the visualizer" ] }, { @@ -872,7 +872,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Finalize and render the visualizer" ] }, { @@ -930,7 +930,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Finalize and render the visualizer" ] }, { @@ -988,7 +988,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Finalize and render the visualizer" ] }, { @@ -1077,7 +1077,7 @@ "visualizer = KElbowVisualizer(model, k=(4,12))\n", "\n", "visualizer.fit(X) # Fit the data to the visualizer\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Finalize and render the visualizer" ] }, { @@ -1113,7 +1113,7 @@ "visualizer = SilhouetteVisualizer(model)\n", "\n", "visualizer.fit(X) # Fit the data to the visualizer\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Finalize and render the visualizer" ] }, { @@ -1268,7 +1268,7 @@ "# Create the visualizer and draw the vectors \n", "tsne = TSNEVisualizer()\n", "tsne.fit(docs, labels)\n", - "tsne.poof()" + "tsne.show()" ] }, { @@ -1291,7 +1291,7 @@ "# Only visualize the sports, cinema, and gaming classes \n", "tsne = TSNEVisualizer(classes=['sports', 'cinema', 'gaming'])\n", "tsne.fit(docs, labels)\n", - "tsne.poof()" + "tsne.show()" ] }, { @@ -1314,7 +1314,7 @@ "# Don't color points with their classes \n", "tsne = TSNEVisualizer()\n", "tsne.fit(docs)\n", - "tsne.poof()" + "tsne.show()" ] }, { @@ -1342,7 +1342,7 @@ "\n", "tsne = TSNEVisualizer() \n", "tsne.fit(docs, [\"c{}\".format(c) for c in clusters.labels_])\n", - "tsne.poof()" + "tsne.show()" ] }, { @@ -1372,7 +1372,7 @@ "source": [ "Note that the `FreqDistVisualizer` does not perform any normalization or vectorization, and it expects text that has already be count vectorized.\n", "\n", - "We first instantiate a `FreqDistVisualizer` object, and then call `fit()` on that object with the count vectorized documents and the features (i.e. the words from the corpus), which computes the frequency distribution. The visualizer then plots a bar chart of the top 50 most frequent terms in the corpus, with the terms listed along the x-axis and frequency counts depicted at y-axis values. As with other Yellowbrick visualizers, when the user invokes `poof()`, the finalized visualization is shown." + "We first instantiate a `FreqDistVisualizer` object, and then call `fit()` on that object with the count vectorized documents and the features (i.e. the words from the corpus), which computes the frequency distribution. The visualizer then plots a bar chart of the top 50 most frequent terms in the corpus, with the terms listed along the x-axis and frequency counts depicted at y-axis values. As with other Yellowbrick visualizers, when the user invokes `show()`, the finalized visualization is shown." ] }, { @@ -1398,7 +1398,7 @@ "\n", "visualizer = FreqDistVisualizer(features=features)\n", "visualizer.fit(docs)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -1433,7 +1433,7 @@ "\n", "visualizer = FreqDistVisualizer(features=features)\n", "visualizer.fit(docs)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -1486,7 +1486,7 @@ "\n", "visualizer = FreqDistVisualizer(features=features)\n", "visualizer.fit(docs)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -1512,7 +1512,7 @@ "\n", "visualizer = FreqDistVisualizer(features=features)\n", "visualizer.fit(docs)\n", - "visualizer.poof()" + "visualizer.show()" ] } ], diff --git a/examples/exbald/data/testing.ipynb b/examples/exbald/data/testing.ipynb index 09e8f16f3..d0b8b44dd 100644 --- a/examples/exbald/data/testing.ipynb +++ b/examples/exbald/data/testing.ipynb @@ -458,7 +458,7 @@ "\n", "Parallel Coordinates: plot instances as lines along vertical axes to detect clusters\n", "\n", - "Feature analysis visualizers implement the Transformer API from Scikit-Learn, meaning they can be used as intermediate transform steps in a Pipeline (particularly a VisualPipeline). They are instantiated in the same way, and then fit and transform are called on them, which draws the instances correctly. Finally poof or show is called which displays the image." + "Feature analysis visualizers implement the Transformer API from Scikit-Learn, meaning they can be used as intermediate transform steps in a Pipeline (particularly a VisualPipeline). They are instantiated in the same way, and then fit and transform are called on them, which draws the instances correctly. Finally show or show is called which displays the image." ] }, { @@ -526,7 +526,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -553,7 +553,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -607,7 +607,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -656,7 +656,7 @@ "\n", "#visualizer.fit(X, y) # Fit the data to the visualizer\n", "#visualizer.transform(X) # Transform the data\n", - "#visualizer.poof() # Draw/show/poof the data" + "#visualizer.show() # Draw/show/show the data" ] }, { @@ -752,7 +752,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { @@ -810,7 +810,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { @@ -905,7 +905,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { @@ -942,7 +942,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { @@ -979,7 +979,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { diff --git a/examples/gary-mayfield/testing.ipynb b/examples/gary-mayfield/testing.ipynb index 0bcdfaaae..be1481606 100644 --- a/examples/gary-mayfield/testing.ipynb +++ b/examples/gary-mayfield/testing.ipynb @@ -122,7 +122,7 @@ "\n", "visualizer.fit(train_images, train_labels)\n", "visualizer.score(test_images, test_labels)\n", - "g = visualizer.poof()" + "g = visualizer.show()" ] }, { @@ -147,7 +147,7 @@ "\n", "visualizer.fit(train_images, train_labels)\n", "visualizer.score(test_images, test_labels)\n", - "g = visualizer.poof()" + "g = visualizer.show()" ] }, { @@ -172,7 +172,7 @@ "\n", "visualizer.fit(train_images, train_labels)\n", "visualizer.score(test_images, test_labels)\n", - "g = visualizer.poof()" + "g = visualizer.show()" ] } ], diff --git a/examples/gokriznastic/Iris - clustering example.ipynb b/examples/gokriznastic/Iris - clustering example.ipynb index 6e1d76a33..987808dd6 100644 --- a/examples/gokriznastic/Iris - clustering example.ipynb +++ b/examples/gokriznastic/Iris - clustering example.ipynb @@ -302,7 +302,7 @@ "visualizer = KElbowVisualizer(model, k=(2,11))\n", "\n", "visualizer.fit(X) # Fit the data to the visualizer\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -336,7 +336,7 @@ "visualizer = KElbowVisualizer(model, k=(2,11), metric='calinski_harabaz', timings=False)\n", "\n", "visualizer.fit(X) # Fit the data to the visualizer\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -387,7 +387,7 @@ "visualizer = SilhouetteVisualizer(model)\n", "\n", "visualizer.fit(X) # Fit the data to the visualizer\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -421,7 +421,7 @@ "visualizer = SilhouetteVisualizer(model)\n", "\n", "visualizer.fit(X) # Fit the data to the visualizer\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -514,7 +514,7 @@ " >>> from sklearn.cluster import KMeans\n", " >>> model = SilhouetteVisualizer(KMeans(10))\n", " >>> model.fit(X)\n", - " >>> model.poof()\n", + " >>> model.show()\n", " \"\"\"\n", "\n", " def __init__(self, model, ax=None, **kwargs):\n", @@ -659,7 +659,7 @@ "visualizer = SilhouetteVisualizer(model)\n", "\n", "visualizer.fit(X) # Fit the data to the visualizer\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { diff --git a/examples/gokriznastic/silhouette-visualizer-test.ipynb b/examples/gokriznastic/silhouette-visualizer-test.ipynb index 6ae91dcc3..e4eef26df 100644 --- a/examples/gokriznastic/silhouette-visualizer-test.ipynb +++ b/examples/gokriznastic/silhouette-visualizer-test.ipynb @@ -162,7 +162,7 @@ " >>> from sklearn.cluster import KMeans\n", " >>> model = SilhouetteVisualizer(KMeans(10))\n", " >>> model.fit(X)\n", - " >>> model.poof()\n", + " >>> model.show()\n", " \"\"\"\n", "\n", " def __init__(self, model, ax=None, **kwargs):\n", @@ -323,7 +323,7 @@ "visualizer = SilhouetteVisualizer(model, ax=ax)\n", "\n", "visualizer.fit(X) # Fit the training data to the visualizer\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -347,7 +347,7 @@ "visualizer = SilhouetteVisualizer(model, ax=ax)\n", "\n", "visualizer.fit(X) # Fit the training data to the visualizer\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -378,7 +378,7 @@ "visualizer = SilhouetteVisualizer(model, ax=ax)\n", "\n", "visualizer.fit(X) # Fit the training data to the visualizer\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -402,7 +402,7 @@ "visualizer = SilhouetteVisualizer(model, ax=ax)\n", "\n", "visualizer.fit(X) # Fit the training data to the visualizer\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { diff --git a/examples/iguk1987/Yellowbrick_Tour.ipynb b/examples/iguk1987/Yellowbrick_Tour.ipynb index e1afa2b6e..20860bf92 100644 --- a/examples/iguk1987/Yellowbrick_Tour.ipynb +++ b/examples/iguk1987/Yellowbrick_Tour.ipynb @@ -998,7 +998,7 @@ "\n", "visualizer.fit(X, y) # Fit the training data to the visualizer\n", "visualizer.score(X, y) # Evaluate the model on the test data\n", - "g = visualizer.poof()" + "g = visualizer.show()" ] }, { @@ -1046,7 +1046,7 @@ "\n", "visualizer.fit(X, y)\n", "visualizer.transform(X)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -1084,7 +1084,7 @@ "\n", "visualizer.fit(X, y)\n", "visualizer.transform(X)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -1117,7 +1117,7 @@ "\n", "visualizer.fit(X, y)\n", "visualizer.transform(X)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -1184,7 +1184,7 @@ "\n", "# Fit and display\n", "viz.fit(X, y)\n", - "viz.poof()\n", + "viz.show()\n", "\n", "# ElasticNet\n", "# Create a new figure\n", @@ -1200,7 +1200,7 @@ "\n", "# Fit and display\n", "viz.fit(X, y)\n", - "viz.poof()\n", + "viz.show()\n", "\n", "# Lasso\n", "# Create a new figure\n", @@ -1216,7 +1216,7 @@ "\n", "# Fit and display\n", "viz.fit(X, y)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -1725,7 +1725,7 @@ " visualizer = ClassificationReport(estimator, classes=['Low', 'Medium', 'High'], cmap='PRGn')\n", " visualizer.fit(X, y) \n", " visualizer.score(X, y)\n", - " visualizer.poof() " + " visualizer.show() " ] }, { @@ -1893,7 +1893,7 @@ "\n", "visualizer.fit(X_train, y_train)\n", "visualizer.score(X_test, y_test)\n", - "g = visualizer.poof()\n", + "g = visualizer.show()\n", "\n", "# Visualizaing class prediction error for Random Forest Classifier model\n", "classes = ['Low', 'Medium', 'High']\n", @@ -1910,7 +1910,7 @@ "\n", "visualizer.fit(X_train, y_train)\n", "visualizer.score(X_test, y_test)\n", - "g = visualizer.poof()\n", + "g = visualizer.show()\n", "\n", "# Visualizaing class prediction error for Extra Trees Classifier model\n", "classes = ['Low', 'Medium', 'High']\n", @@ -1927,7 +1927,7 @@ "\n", "visualizer.fit(X_train, y_train)\n", "visualizer.score(X_test, y_test)\n", - "g = visualizer.poof()" + "g = visualizer.show()" ] }, { @@ -1976,9 +1976,9 @@ "ax = plt.subplot(411)\n", "viz = ValidationCurve(ExtraTreesClassifier(class_weight='balanced'), ax=ax, param_name=\"max_depth\", param_range=np.arange(1, 11), cv=3, scoring=\"accuracy\")\n", "\n", - "# Fit and poof the visualizer\n", + "# Fit and show the visualizer\n", "viz.fit(X, y)\n", - "viz.poof()" + "viz.show()" ] }, { diff --git a/examples/jkeung/learning_curve.ipynb b/examples/jkeung/learning_curve.ipynb index 71630010d..925ce52d5 100644 --- a/examples/jkeung/learning_curve.ipynb +++ b/examples/jkeung/learning_curve.ipynb @@ -102,7 +102,7 @@ "source": [ "viz = LearningCurveVisualizer(GaussianNB())\n", "viz.fit(X,y)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -133,7 +133,7 @@ "source": [ "viz = LearningCurveVisualizer(GaussianNB(), train_sizes=np.linspace(.1, 1.0, 15))\n", "viz.fit(X,y)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -166,7 +166,7 @@ " train_sizes=np.linspace(.1, 1.0, 15),\n", " cv = ShuffleSplit(n_splits=100, test_size=0.2, random_state=0))\n", "viz.fit(X,y)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -199,7 +199,7 @@ " train_sizes=np.linspace(0.1, 1.0, 5),\n", " cv = ShuffleSplit(n_splits=100, test_size=0.2, random_state=0))\n", "viz.fit(X,y)\n", - "viz.poof()" + "viz.show()" ] }, { diff --git a/examples/jkeung/testing.ipynb b/examples/jkeung/testing.ipynb index c5c8a5ad9..82d1cf396 100644 --- a/examples/jkeung/testing.ipynb +++ b/examples/jkeung/testing.ipynb @@ -191,7 +191,7 @@ "source": [ "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] } ], diff --git a/examples/lwgray/ClassPredictionError.ipynb b/examples/lwgray/ClassPredictionError.ipynb index bc3a648f3..4e5b6f496 100644 --- a/examples/lwgray/ClassPredictionError.ipynb +++ b/examples/lwgray/ClassPredictionError.ipynb @@ -67,7 +67,7 @@ "visualizer.score(X_test, y_test)\n", "\n", "# Display visualization\n", - "visualizer.poof()\n", + "visualizer.show()\n", "plt.show()" ] }, diff --git a/examples/mattandahalfew/Visualizing a credit model.ipynb b/examples/mattandahalfew/Visualizing a credit model.ipynb index 4dc5d68d2..f02249412 100644 --- a/examples/mattandahalfew/Visualizing a credit model.ipynb +++ b/examples/mattandahalfew/Visualizing a credit model.ipynb @@ -207,7 +207,7 @@ "visualizer = ROCAUC(LinearSVC())\n", "visualizer.fit(mydata,y)\n", "visualizer.score(mydata,y)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { diff --git a/examples/mike-curry00/Silhouette_Plot_Data.ipynb b/examples/mike-curry00/Silhouette_Plot_Data.ipynb index 5988e2220..a5944aad6 100644 --- a/examples/mike-curry00/Silhouette_Plot_Data.ipynb +++ b/examples/mike-curry00/Silhouette_Plot_Data.ipynb @@ -277,7 +277,7 @@ "elbow_visualizer = KElbowVisualizer(KMeans(random_state=42), k=(2,10), timings=False)\n", "elbow_visualizer.fit(X)\n", "elbow_visualizer.size = (600, 400)\n", - "elbow_visualizer.poof()" + "elbow_visualizer.show()" ] }, { @@ -304,7 +304,7 @@ "\n", "silhouette_visualizer.fit(X)\n", "elbow_visualizer.size = (600, 400)\n", - "silhouette_visualizer.poof()" + "silhouette_visualizer.show()" ] }, { diff --git a/examples/morganmendis/testing.ipynb b/examples/morganmendis/testing.ipynb index ac5d39f40..467c68b2a 100644 --- a/examples/morganmendis/testing.ipynb +++ b/examples/morganmendis/testing.ipynb @@ -443,7 +443,7 @@ "- RadViz: plot data points along axes ordered around a circle to detect separability \n", "- Parallel Coordinates: plot instances as lines along vertical axes to detect clusters \n", "\n", - "Feature analysis visualizers implement the `Transformer` API from Scikit-Learn, meaning they can be used as intermediate transform steps in a `Pipeline` (particularly a `VisualPipeline`). They are instantiated in the same way, and then fit and transform are called on them, which draws the instances correctly. Finally `poof` or `show` is called which displays the image. " + "Feature analysis visualizers implement the `Transformer` API from Scikit-Learn, meaning they can be used as intermediate transform steps in a `Pipeline` (particularly a `VisualPipeline`). They are instantiated in the same way, and then fit and transform are called on them, which draws the instances correctly. Finally `show` or `show` is called which displays the image. " ] }, { @@ -586,7 +586,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -623,7 +623,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -689,7 +689,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -743,7 +743,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -826,7 +826,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { @@ -863,7 +863,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { @@ -900,7 +900,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] } ], diff --git a/examples/ndanielsen/Decision Boundaries Example Notebook.ipynb b/examples/ndanielsen/Decision Boundaries Example Notebook.ipynb index 54748f3b7..439007c52 100644 --- a/examples/ndanielsen/Decision Boundaries Example Notebook.ipynb +++ b/examples/ndanielsen/Decision Boundaries Example Notebook.ipynb @@ -101,7 +101,7 @@ "viz = DecisionViz(model, title=title, features=['Feature One', 'Feature Two'], classes=['Class A', 'Class B'])\n", "viz.fit(X_train, y_train)\n", "viz.draw(X_test, y_test)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -127,7 +127,7 @@ "viz = DecisionViz(model, title=title, features=['Feature One', 'Feature Two'], classes=['Class A', 'Class B'])\n", "viz.fit(X_train, y_train)\n", "viz.draw(X_test, y_test)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -142,7 +142,7 @@ "viz = DecisionViz(model, title=title, features=['Feature One', 'Feature Two'], classes=['Class A', 'Class B'])\n", "viz.fit(X_train, y_train)\n", "viz.draw(X_test, y_test)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -157,7 +157,7 @@ "viz = DecisionViz(model, title=title, features=['Feature One', 'Feature Two'], classes=['Class A', 'Class B'])\n", "viz.fit(X_train, y_train)\n", "viz.draw(X_test, y_test)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -172,7 +172,7 @@ "viz = DecisionViz(model, title=title, features=['Feature One', 'Feature Two'], classes=['Class A', 'Class B'])\n", "viz.fit(X_train, y_train)\n", "viz.draw(X_test, y_test)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -187,7 +187,7 @@ "viz = DecisionViz(model, title=title, features=['Feature Alpha', 'Feature Beta'], classes=['Class A', 'Class B'])\n", "viz.fit(X_train, y_train)\n", "viz.draw(X_test, y_test)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -202,7 +202,7 @@ "viz = DecisionViz(model, title=title, features=['Feature One', 'Feature Two'], classes=['Class A', 'Class B'])\n", "viz.fit(X_train, y_train)\n", "viz.draw(X_test, y_test)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -217,7 +217,7 @@ "viz = DecisionViz(model, title=title, features=['Feature One', 'Feature Two'], classes=['Class A', 'Class B'])\n", "viz.fit(X_train, y_train)\n", "viz.draw(X_test, y_test)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -232,7 +232,7 @@ "viz = DecisionViz(model, title=title, features=['Feature One', 'Feature Two'], classes=['Class A', 'Class B'])\n", "viz.fit(X_train, y_train)\n", "viz.draw(X_test, y_test)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -247,7 +247,7 @@ "viz = DecisionViz(model, title=title, features=['Feature One', 'Feature Two'], classes=['Class A', 'Class B'])\n", "viz.fit(X_train, y_train)\n", "viz.draw(X_test, y_test)\n", - "viz.poof()" + "viz.show()" ] }, { diff --git a/examples/ndanielsen/Missing Values Examples.ipynb b/examples/ndanielsen/Missing Values Examples.ipynb index 10570cd21..431e3202c 100644 --- a/examples/ndanielsen/Missing Values Examples.ipynb +++ b/examples/ndanielsen/Missing Values Examples.ipynb @@ -130,7 +130,7 @@ "source": [ "viz = MissingValuesDispersion(classes=classes)\n", "viz.fit(X)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -159,7 +159,7 @@ "source": [ "viz = MissingValuesDispersion(classes=classes)\n", "viz.fit(X, y=y)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -202,7 +202,7 @@ "source": [ "oz = MissingValuesBar(classes=classes)\n", "oz.fit(X)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -231,7 +231,7 @@ "source": [ "oz = MissingValuesBar(classes=classes)\n", "oz.fit(X, y=y)\n", - "oz.poof()" + "oz.show()" ] }, { diff --git a/examples/ndanielsen/Missing Values.ipynb b/examples/ndanielsen/Missing Values.ipynb index 13837cbe3..b5680f742 100644 --- a/examples/ndanielsen/Missing Values.ipynb +++ b/examples/ndanielsen/Missing Values.ipynb @@ -350,7 +350,7 @@ " def finalize(self, **kwargs):\n", " \"\"\"\n", " Finalize executes any subclass-specific axes finalization steps.\n", - " The user calls poof and poof calls finalize.\n", + " The user calls show and show calls finalize.\n", "\n", " Parameters\n", " ----------\n", @@ -389,7 +389,7 @@ "source": [ "viz = MissingValuesBarVisualizer(features=headers.Attribute.values)\n", "viz.fit(matrix)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -591,7 +591,7 @@ " def finalize(self, **kwargs):\n", " \"\"\"\n", " Finalize executes any subclass-specific axes finalization steps.\n", - " The user calls poof and poof calls finalize.\n", + " The user calls show and show calls finalize.\n", "\n", " Parameters\n", " ----------\n", @@ -633,7 +633,7 @@ "\n", "viz = MissingValueDensity(features=headers.Attribute.values)\n", "viz.fit(matrix)\n", - "viz.poof()" + "viz.show()" ] }, { diff --git a/examples/ndanielsen/ScatterViz Example (Iris Dataset).ipynb b/examples/ndanielsen/ScatterViz Example (Iris Dataset).ipynb index 870a51cd3..8c4ecc5d8 100644 --- a/examples/ndanielsen/ScatterViz Example (Iris Dataset).ipynb +++ b/examples/ndanielsen/ScatterViz Example (Iris Dataset).ipynb @@ -117,7 +117,7 @@ "source": [ "visualizer = ScatterViz(classes=classes, features=features, color=colors)\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { diff --git a/examples/ndanielsen/ThresholdVisualizer Example.ipynb b/examples/ndanielsen/ThresholdVisualizer Example.ipynb index 71f207feb..53b236607 100644 --- a/examples/ndanielsen/ThresholdVisualizer Example.ipynb +++ b/examples/ndanielsen/ThresholdVisualizer Example.ipynb @@ -97,7 +97,7 @@ ], "source": [ "viz = ThresholdVisualizer(model, n_trials=100, title=\"Spam vs Ham Thresholds\", quantiles=(0.10, 0.5, .9))\n", - "viz.fit_poof(X, y)" + "viz.fit_show(X, y)" ] }, { diff --git a/examples/ndanielsen/Yellowbrick in the Flower Garden.ipynb b/examples/ndanielsen/Yellowbrick in the Flower Garden.ipynb index 71dc94707..ccbd796e3 100755 --- a/examples/ndanielsen/Yellowbrick in the Flower Garden.ipynb +++ b/examples/ndanielsen/Yellowbrick in the Flower Garden.ipynb @@ -240,7 +240,7 @@ "visualizer = RadViz(classes=classes, features=features)\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -300,7 +300,7 @@ "visualizer = RadViz(classes=classes, features=features)\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -342,7 +342,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -399,7 +399,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -468,7 +468,7 @@ "\n", "visualizer.fit(X_scaled, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() " + "visualizer.show() " ] }, { @@ -545,7 +545,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Fit the training data to the visualizer\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Evaluate the model on the test data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0mg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Draw/show/poof the data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Fit the training data to the visualizer\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Evaluate the model on the test data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0mg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Draw/show/show the data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/usr/local/var/pyenv/versions/3.5.2/envs/yellowbrick/lib/python3.5/site-packages/yellowbrick/classifier.py\u001b[0m in \u001b[0;36mscore\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 133\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscores\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclasses_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscores\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 134\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscores\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkeys\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscores\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 135\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 136\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 137\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/usr/local/var/pyenv/versions/3.5.2/envs/yellowbrick/lib/python3.5/site-packages/yellowbrick/classifier.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, y, y_pred)\u001b[0m\n\u001b[1;32m 158\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mcolumn\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 159\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mrow\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclasses_\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 160\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcolumn\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mrow\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mrow\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcolumn\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mva\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'center'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mha\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'center'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 161\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 162\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minterpolation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'nearest'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcmap\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmax\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mIndexError\u001b[0m: list index out of range" @@ -569,7 +569,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data\n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { @@ -668,7 +668,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Fit the training data to the visualizer\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Evaluate the model on the test data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0mg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Draw/show/poof the data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Fit the training data to the visualizer\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Evaluate the model on the test data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0mg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Draw/show/show the data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/usr/local/var/pyenv/versions/3.5.2/envs/yellowbrick/lib/python3.5/site-packages/yellowbrick/classifier.py\u001b[0m in \u001b[0;36mscore\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 133\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscores\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclasses_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscores\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 134\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscores\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkeys\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscores\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 135\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 136\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 137\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/usr/local/var/pyenv/versions/3.5.2/envs/yellowbrick/lib/python3.5/site-packages/yellowbrick/classifier.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, y, y_pred)\u001b[0m\n\u001b[1;32m 158\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mcolumn\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 159\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mrow\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclasses_\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 160\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcolumn\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mrow\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mrow\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcolumn\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mva\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'center'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mha\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'center'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 161\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 162\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minterpolation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'nearest'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcmap\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmax\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mIndexError\u001b[0m: list index out of range" @@ -692,7 +692,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data\n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { @@ -796,7 +796,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data\n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { diff --git a/examples/nealhumphrey/MultipleVisualizerExample.ipynb b/examples/nealhumphrey/MultipleVisualizerExample.ipynb index 00b0147e8..882e0143e 100644 --- a/examples/nealhumphrey/MultipleVisualizerExample.ipynb +++ b/examples/nealhumphrey/MultipleVisualizerExample.ipynb @@ -182,7 +182,7 @@ "\n", "vg = VisualizerGrid(visualizers, ncols=2)\n", "vg.fit(X,y)\n", - "vg.poof()\n" + "vg.show()\n" ] }, { @@ -226,7 +226,7 @@ "vg = VisualizerGrid(visualizers, ncols=2)\n", "vg.fit(X_train, y_train)\n", "vg.score(X_test, y_test)\n", - "vg.poof()" + "vg.show()" ] }, { diff --git a/examples/nealhumphrey/confusionMatrix.ipynb b/examples/nealhumphrey/confusionMatrix.ipynb index bf7d6b245..f8b28af29 100644 --- a/examples/nealhumphrey/confusionMatrix.ipynb +++ b/examples/nealhumphrey/confusionMatrix.ipynb @@ -93,7 +93,7 @@ "cm.score(X_test, y_test)\n", "\n", "#How did we do?\n", - "cm.poof()" + "cm.show()" ] }, { @@ -123,7 +123,7 @@ "cm2 = ConfusionMatrix(model, classes=None) #classes can be auto-calculated\n", "cm2.fit(X_train, y_train)\n", "cm2.score(X_test, y_test, percent=False)\n", - "cm2.poof()" + "cm2.show()" ] }, { @@ -250,7 +250,7 @@ "cm3.score(X_test_music, y_test_music, percent=True)\n", "\n", "#The diagonal line, not as obvious in the previous example, shows us where our correct predictions are\n", - "cm3.poof()" + "cm3.show()" ] }, { @@ -275,7 +275,7 @@ "#We can also use the classes option to zoom in on a subset of the matrix\n", "cm4 = ConfusionMatrix(music_model, classes=[\"AC\",\"AD\",\"AE\",\"AF\",\"AG\"])\n", "cm4.score(X_test_music, y_test_music, percent=True)\n", - "cm4.poof()" + "cm4.show()" ] }, { diff --git a/examples/nealhumphrey/light-dark-text.ipynb b/examples/nealhumphrey/light-dark-text.ipynb index d54dad97b..99d136041 100644 --- a/examples/nealhumphrey/light-dark-text.ipynb +++ b/examples/nealhumphrey/light-dark-text.ipynb @@ -155,7 +155,7 @@ "cm = ConfusionMatrix(model, classes=[0,1,2,3,4,5,6,7,8,9])\n", "cm.fit(X_train, y_train)\n", "cm.score(X_test, y_test)\n", - "cm.poof()" + "cm.show()" ] }, { diff --git a/examples/pbs929/features-pipeline.ipynb b/examples/pbs929/features-pipeline.ipynb index 5cfa0b729..976c01788 100644 --- a/examples/pbs929/features-pipeline.ipynb +++ b/examples/pbs929/features-pipeline.ipynb @@ -293,7 +293,7 @@ "# ('joinplot', JointPlotVisualizer(feature=features[0], ax=ax[2,1])),\n", " ('pca', PCADecomposition(ax=ax[2,1]))\n", "])\n", - "pl.fit_transform_poof(X, y);" + "pl.fit_transform_show(X, y);" ] }, { @@ -330,7 +330,7 @@ "# ('joinplot', JointPlotVisualizer(feature=features[0], cvax=ax[2,1])),\n", " ('pca', PCADecomposition(ax=ax[2,1]))\n", "])\n", - "pl.fit_transform_poof(X.values, y);" + "pl.fit_transform_show(X.values, y);" ] }, { diff --git a/examples/pbs929/gridsearch.ipynb b/examples/pbs929/gridsearch.ipynb index 4bd3493f2..100cdefa0 100644 --- a/examples/pbs929/gridsearch.ipynb +++ b/examples/pbs929/gridsearch.ipynb @@ -482,7 +482,7 @@ ], "source": [ "gs_viz = GridSearchColorPlot(gs, 'C', 'kernel')\n", - "gs_viz.fit(X, y).poof()" + "gs_viz.fit(X, y).show()" ] }, { @@ -503,7 +503,7 @@ ], "source": [ "gs_viz = GridSearchColorPlot(gs, 'kernel', 'C')\n", - "gs_viz.fit(X, y).poof()" + "gs_viz.fit(X, y).show()" ] }, { @@ -524,7 +524,7 @@ ], "source": [ "gs_viz = GridSearchColorPlot(gs, 'C', 'gamma')\n", - "gs_viz.fit(X, y).poof()" + "gs_viz.fit(X, y).show()" ] }, { @@ -552,7 +552,7 @@ ], "source": [ "gs_viz = GridSearchColorPlot(gs, 'kernel', 'gamma')\n", - "gs_viz.fit(X, y).poof()" + "gs_viz.fit(X, y).show()" ] }, { @@ -580,7 +580,7 @@ ], "source": [ "gs_viz = GridSearchColorPlot(gs, 'C', 'kernel', metric='mean_fit_time')\n", - "gs_viz.fit(X, y).poof()" + "gs_viz.fit(X, y).show()" ] }, { @@ -792,7 +792,7 @@ "\u001b[0;31mKeyError\u001b[0m: 'param_foo'", "\nDuring handling of the above exception, another exception occurred:\n", "\u001b[0;31mYellowbrickKeyError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mgs_viz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGridSearchColorPlot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'foo'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'kernel'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mgs_viz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mgs_viz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGridSearchColorPlot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'foo'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'kernel'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mgs_viz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/base.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 187\u001b[0m \"\"\"\n\u001b[1;32m 188\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 189\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 190\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/pcolor.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 138\u001b[0m \u001b[0;31m# Project the grid search results to 2 dimensions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 139\u001b[0m x_vals, y_vals, best_scores = self.param_projection(\n\u001b[0;32m--> 140\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mx_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0my_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmetric\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 141\u001b[0m )\n\u001b[1;32m 142\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/base.py\u001b[0m in \u001b[0;36mparam_projection\u001b[0;34m(self, x_param, y_param, metric)\u001b[0m\n\u001b[1;32m 162\u001b[0m \u001b[0mArray\u001b[0m \u001b[0mof\u001b[0m \u001b[0mscores\u001b[0m \u001b[0mto\u001b[0m \u001b[0mbe\u001b[0m \u001b[0mdisplayed\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0meach\u001b[0m \u001b[0mparameter\u001b[0m \u001b[0mvalue\u001b[0m \u001b[0mpair\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 163\u001b[0m \"\"\"\n\u001b[0;32m--> 164\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mparam_projection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcv_results_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 165\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 166\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", @@ -803,7 +803,7 @@ ], "source": [ "gs_viz = GridSearchColorPlot(gs, 'foo', 'kernel')\n", - "gs_viz.fit(X, y).poof()" + "gs_viz.fit(X, y).show()" ] }, { @@ -823,7 +823,7 @@ "\u001b[0;31mKeyError\u001b[0m: 'param_foo'", "\nDuring handling of the above exception, another exception occurred:\n", "\u001b[0;31mYellowbrickKeyError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mgs_viz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGridSearchColorPlot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'C'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'foo'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mgs_viz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mgs_viz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGridSearchColorPlot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'C'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'foo'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mgs_viz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/base.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 187\u001b[0m \"\"\"\n\u001b[1;32m 188\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 189\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 190\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/pcolor.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 138\u001b[0m \u001b[0;31m# Project the grid search results to 2 dimensions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 139\u001b[0m x_vals, y_vals, best_scores = self.param_projection(\n\u001b[0;32m--> 140\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mx_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0my_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmetric\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 141\u001b[0m )\n\u001b[1;32m 142\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/base.py\u001b[0m in \u001b[0;36mparam_projection\u001b[0;34m(self, x_param, y_param, metric)\u001b[0m\n\u001b[1;32m 162\u001b[0m \u001b[0mArray\u001b[0m \u001b[0mof\u001b[0m \u001b[0mscores\u001b[0m \u001b[0mto\u001b[0m \u001b[0mbe\u001b[0m \u001b[0mdisplayed\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0meach\u001b[0m \u001b[0mparameter\u001b[0m \u001b[0mvalue\u001b[0m \u001b[0mpair\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 163\u001b[0m \"\"\"\n\u001b[0;32m--> 164\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mparam_projection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcv_results_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 165\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 166\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", @@ -834,7 +834,7 @@ ], "source": [ "gs_viz = GridSearchColorPlot(gs, 'C', 'foo')\n", - "gs_viz.fit(X, y).poof()" + "gs_viz.fit(X, y).show()" ] }, { @@ -861,7 +861,7 @@ "\u001b[0;31mKeyError\u001b[0m: 'foo'", "\nDuring handling of the above exception, another exception occurred:\n", "\u001b[0;31mYellowbrickKeyError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mgs_viz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGridSearchColorPlot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'C'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'kernel'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'foo'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mgs_viz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mgs_viz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGridSearchColorPlot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'C'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'kernel'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'foo'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mgs_viz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/base.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 187\u001b[0m \"\"\"\n\u001b[1;32m 188\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 189\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 190\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/pcolor.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 138\u001b[0m \u001b[0;31m# Project the grid search results to 2 dimensions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 139\u001b[0m x_vals, y_vals, best_scores = self.param_projection(\n\u001b[0;32m--> 140\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mx_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0my_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmetric\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 141\u001b[0m )\n\u001b[1;32m 142\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/base.py\u001b[0m in \u001b[0;36mparam_projection\u001b[0;34m(self, x_param, y_param, metric)\u001b[0m\n\u001b[1;32m 162\u001b[0m \u001b[0mArray\u001b[0m \u001b[0mof\u001b[0m \u001b[0mscores\u001b[0m \u001b[0mto\u001b[0m \u001b[0mbe\u001b[0m \u001b[0mdisplayed\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0meach\u001b[0m \u001b[0mparameter\u001b[0m \u001b[0mvalue\u001b[0m \u001b[0mpair\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 163\u001b[0m \"\"\"\n\u001b[0;32m--> 164\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mparam_projection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcv_results_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 165\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 166\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", @@ -872,7 +872,7 @@ ], "source": [ "gs_viz = GridSearchColorPlot(gs, 'C', 'kernel', metric='foo')\n", - "gs_viz.fit(X, y).poof()" + "gs_viz.fit(X, y).show()" ] }, { @@ -898,7 +898,7 @@ "\u001b[0;31mValueError\u001b[0m: could not convert string to float: 'linear'", "\nDuring handling of the above exception, another exception occurred:\n", "\u001b[0;31mYellowbrickValueError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mgs_viz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGridSearchColorPlot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'C'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'kernel'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'param_kernel'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mgs_viz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mgs_viz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mGridSearchColorPlot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'C'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'kernel'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'param_kernel'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mgs_viz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/base.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 187\u001b[0m \"\"\"\n\u001b[1;32m 188\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 189\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 190\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/pcolor.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 138\u001b[0m \u001b[0;31m# Project the grid search results to 2 dimensions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 139\u001b[0m x_vals, y_vals, best_scores = self.param_projection(\n\u001b[0;32m--> 140\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mx_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0my_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmetric\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 141\u001b[0m )\n\u001b[1;32m 142\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/projects/yellowbrick/yellowbrick/gridsearch/base.py\u001b[0m in \u001b[0;36mparam_projection\u001b[0;34m(self, x_param, y_param, metric)\u001b[0m\n\u001b[1;32m 162\u001b[0m \u001b[0mArray\u001b[0m \u001b[0mof\u001b[0m \u001b[0mscores\u001b[0m \u001b[0mto\u001b[0m \u001b[0mbe\u001b[0m \u001b[0mdisplayed\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0meach\u001b[0m \u001b[0mparameter\u001b[0m \u001b[0mvalue\u001b[0m \u001b[0mpair\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 163\u001b[0m \"\"\"\n\u001b[0;32m--> 164\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mparam_projection\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mestimator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcv_results_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_param\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetric\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 165\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 166\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", @@ -909,7 +909,7 @@ ], "source": [ "gs_viz = GridSearchColorPlot(gs, 'C', 'kernel', metric='param_kernel')\n", - "gs_viz.fit(X, y).poof()" + "gs_viz.fit(X, y).show()" ] }, { diff --git a/examples/pbs929/pcoords.ipynb b/examples/pbs929/pcoords.ipynb index 3045c037b..a265f317b 100644 --- a/examples/pbs929/pcoords.ipynb +++ b/examples/pbs929/pcoords.ipynb @@ -272,7 +272,7 @@ "source": [ "# numpy inputs\n", "visualizer = ParallelCoordinates(features=features, classes=classes)\n", - "visualizer.fit_transform_poof(X.values, y.values);" + "visualizer.fit_transform_show(X.values, y.values);" ] }, { @@ -296,7 +296,7 @@ "source": [ "# numpy inputs, no labels\n", "visualizer = ParallelCoordinates(classes=classes)\n", - "visualizer.fit_transform_poof(X.values, y.values);" + "visualizer.fit_transform_show(X.values, y.values);" ] }, { @@ -320,7 +320,7 @@ "source": [ "# dataframe inputs\n", "visualizer = ParallelCoordinates(classes=classes)\n", - "visualizer.fit_transform_poof(X, y);" + "visualizer.fit_transform_show(X, y);" ] }, { @@ -371,7 +371,7 @@ ], "source": [ "visualizer = ParallelCoordinates(normalize='minmax', classes=classes)\n", - "visualizer.fit_transform_poof(X, y);" + "visualizer.fit_transform_show(X, y);" ] }, { @@ -394,7 +394,7 @@ ], "source": [ "visualizer = ParallelCoordinates(normalize='maxabs', classes=classes)\n", - "visualizer.fit_transform_poof(X, y);" + "visualizer.fit_transform_show(X, y);" ] }, { @@ -417,7 +417,7 @@ ], "source": [ "visualizer = ParallelCoordinates(normalize='standard', classes=classes)\n", - "visualizer.fit_transform_poof(X, y);" + "visualizer.fit_transform_show(X, y);" ] }, { @@ -440,7 +440,7 @@ ], "source": [ "visualizer = ParallelCoordinates(normalize='l1', classes=classes)\n", - "visualizer.fit_transform_poof(X, y);" + "visualizer.fit_transform_show(X, y);" ] }, { @@ -463,7 +463,7 @@ ], "source": [ "visualizer = ParallelCoordinates(normalize='l2', classes=classes)\n", - "visualizer.fit_transform_poof(X, y);" + "visualizer.fit_transform_show(X, y);" ] }, { @@ -486,7 +486,7 @@ ], "source": [ "visualizer = ParallelCoordinates(normalize='l2', classes=classes)\n", - "visualizer.fit_transform_poof(X, y);" + "visualizer.fit_transform_show(X, y);" ] }, { @@ -503,7 +503,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# should raise YellowbrickValueError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mvisualizer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mParallelCoordinates\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnormalize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'bad'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclasses\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform_poof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m;\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# should raise YellowbrickValueError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mvisualizer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mParallelCoordinates\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnormalize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'bad'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclasses\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform_show\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m;\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/Google Drive/projects/other/yellowbrick/yellowbrick/features/pcoords.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, ax, features, classes, normalize, sample, color, colormap, vlines, vlines_kwds, **kwargs)\u001b[0m\n\u001b[1;32m 205\u001b[0m raise YellowbrickValueError(\n\u001b[1;32m 206\u001b[0m \u001b[0;34m\"'{}' is an unrecognized normalization method\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 207\u001b[0;31m \u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnormalize\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 208\u001b[0m )\n\u001b[1;32m 209\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msample\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msample\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mAttributeError\u001b[0m: 'ParallelCoordinates' object has no attribute 'normalize'" ] @@ -512,7 +512,7 @@ "source": [ "# should raise YellowbrickValueError\n", "visualizer = ParallelCoordinates(normalize='bad', classes=classes)\n", - "visualizer.fit_transform_poof(X, y);" + "visualizer.fit_transform_show(X, y);" ] }, { @@ -561,7 +561,7 @@ ], "source": [ "visualizer = ParallelCoordinates(classes=classes, sample=200)\n", - "visualizer.fit_transform_poof(X, y);" + "visualizer.fit_transform_show(X, y);" ] }, { @@ -582,7 +582,7 @@ ], "source": [ "visualizer = ParallelCoordinates(classes=classes, sample=0.2)\n", - "visualizer.fit_transform_poof(X, y);" + "visualizer.fit_transform_show(X, y);" ] }, { @@ -618,8 +618,8 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mYellowbrickTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# should raise YellowbrickTypeError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mvisualizer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mParallelCoordinates\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msample\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'bad'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform_poof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m;\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/Google Drive/projects/other/yellowbrick/yellowbrick/features/base.py\u001b[0m in \u001b[0;36mfit_transform_poof\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 70\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mresult\u001b[0m \u001b[0mof\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mtransform\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 71\u001b[0m \"\"\"\n\u001b[0;32m---> 72\u001b[0;31m \u001b[0mXp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 73\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 74\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mXp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# should raise YellowbrickTypeError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mvisualizer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mParallelCoordinates\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msample\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'bad'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform_show\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m;\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/Google Drive/projects/other/yellowbrick/yellowbrick/features/base.py\u001b[0m in \u001b[0;36mfit_transform_show\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 70\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mresult\u001b[0m \u001b[0mof\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mtransform\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 71\u001b[0m \"\"\"\n\u001b[0;32m---> 72\u001b[0;31m \u001b[0mXp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 73\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 74\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mXp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/.virtualenvs/yellowbrick/lib/python3.6/site-packages/sklearn/base.py\u001b[0m in \u001b[0;36mfit_transform\u001b[0;34m(self, X, y, **fit_params)\u001b[0m\n\u001b[1;32m 495\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 496\u001b[0m \u001b[0;31m# fit method of arity 2 (supervised transformation)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 497\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mfit_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 498\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 499\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/Google Drive/projects/other/yellowbrick/yellowbrick/features/base.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 191\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 192\u001b[0m \u001b[0;31m# Draw the instances\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 193\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 194\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 195\u001b[0m \u001b[0;31m# Fit always returns self.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/Google Drive/projects/other/yellowbrick/yellowbrick/features/pcoords.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 240\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 241\u001b[0m raise YellowbrickTypeError(\n\u001b[0;32m--> 242\u001b[0;31m \u001b[0;34m\"`sample` parameter must be int or float\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 243\u001b[0m )\n\u001b[1;32m 244\u001b[0m \u001b[0mX\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mX\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_samples\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", @@ -630,7 +630,7 @@ "source": [ "# should raise YellowbrickTypeError\n", "visualizer = ParallelCoordinates(classes=classes, sample='bad')\n", - "visualizer.fit_transform_poof(X, y);" + "visualizer.fit_transform_show(X, y);" ] }, { @@ -645,8 +645,8 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mYellowbrickValueError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# should raise YellowbrickValueError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mvisualizer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mParallelCoordinates\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msample\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform_poof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m;\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/Google Drive/projects/other/yellowbrick/yellowbrick/features/base.py\u001b[0m in \u001b[0;36mfit_transform_poof\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 70\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mresult\u001b[0m \u001b[0mof\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mtransform\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 71\u001b[0m \"\"\"\n\u001b[0;32m---> 72\u001b[0;31m \u001b[0mXp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 73\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 74\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mXp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# should raise YellowbrickValueError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mvisualizer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mParallelCoordinates\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msample\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform_show\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m;\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/Google Drive/projects/other/yellowbrick/yellowbrick/features/base.py\u001b[0m in \u001b[0;36mfit_transform_show\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 70\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mresult\u001b[0m \u001b[0mof\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mtransform\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 71\u001b[0m \"\"\"\n\u001b[0;32m---> 72\u001b[0;31m \u001b[0mXp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 73\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 74\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mXp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/.virtualenvs/yellowbrick/lib/python3.6/site-packages/sklearn/base.py\u001b[0m in \u001b[0;36mfit_transform\u001b[0;34m(self, X, y, **fit_params)\u001b[0m\n\u001b[1;32m 495\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 496\u001b[0m \u001b[0;31m# fit method of arity 2 (supervised transformation)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 497\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mfit_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 498\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 499\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/Google Drive/projects/other/yellowbrick/yellowbrick/features/base.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 191\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 192\u001b[0m \u001b[0;31m# Draw the instances\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 193\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 194\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 195\u001b[0m \u001b[0;31m# Fit always returns self.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/Google Drive/projects/other/yellowbrick/yellowbrick/features/pcoords.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 229\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msample\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 230\u001b[0m raise YellowbrickValueError(\n\u001b[0;32m--> 231\u001b[0;31m \u001b[0;34m\"`sample` parameter of type `int` must be greater than 1\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 232\u001b[0m )\n\u001b[1;32m 233\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_samples\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msample\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", @@ -657,7 +657,7 @@ "source": [ "# should raise YellowbrickValueError\n", "visualizer = ParallelCoordinates(classes=classes, sample=-1)\n", - "visualizer.fit_transform_poof(X, y);" + "visualizer.fit_transform_show(X, y);" ] }, { @@ -672,8 +672,8 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mYellowbrickValueError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# should raise YellowbrickValueError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mvisualizer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mParallelCoordinates\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msample\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1.1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform_poof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m;\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/Google Drive/projects/other/yellowbrick/yellowbrick/features/base.py\u001b[0m in \u001b[0;36mfit_transform_poof\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 70\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mresult\u001b[0m \u001b[0mof\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mtransform\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 71\u001b[0m \"\"\"\n\u001b[0;32m---> 72\u001b[0;31m \u001b[0mXp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 73\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 74\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mXp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# should raise YellowbrickValueError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mvisualizer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mParallelCoordinates\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msample\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1.1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform_show\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m;\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/Google Drive/projects/other/yellowbrick/yellowbrick/features/base.py\u001b[0m in \u001b[0;36mfit_transform_show\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 70\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mresult\u001b[0m \u001b[0mof\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mtransform\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 71\u001b[0m \"\"\"\n\u001b[0;32m---> 72\u001b[0;31m \u001b[0mXp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 73\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 74\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mXp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/.virtualenvs/yellowbrick/lib/python3.6/site-packages/sklearn/base.py\u001b[0m in \u001b[0;36mfit_transform\u001b[0;34m(self, X, y, **fit_params)\u001b[0m\n\u001b[1;32m 495\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 496\u001b[0m \u001b[0;31m# fit method of arity 2 (supervised transformation)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 497\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mfit_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 498\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 499\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/Google Drive/projects/other/yellowbrick/yellowbrick/features/base.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 191\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 192\u001b[0m \u001b[0;31m# Draw the instances\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 193\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 194\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 195\u001b[0m \u001b[0;31m# Fit always returns self.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/Google Drive/projects/other/yellowbrick/yellowbrick/features/pcoords.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 235\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msample\u001b[0m \u001b[0;34m<=\u001b[0m \u001b[0;36m0\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msample\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 236\u001b[0m raise YellowbrickValueError(\n\u001b[0;32m--> 237\u001b[0;31m \u001b[0;34m\"`sample` parameter of type `float` must be between 0 and 1\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 238\u001b[0m )\n\u001b[1;32m 239\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_samples\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msample\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", @@ -684,7 +684,7 @@ "source": [ "# should raise YellowbrickValueError\n", "visualizer = ParallelCoordinates(classes=classes, sample=1.1)\n", - "visualizer.fit_transform_poof(X, y);" + "visualizer.fit_transform_show(X, y);" ] }, { diff --git a/examples/pbs929/rankd.ipynb b/examples/pbs929/rankd.ipynb index de5767d4d..80f538faf 100644 --- a/examples/pbs929/rankd.ipynb +++ b/examples/pbs929/rankd.ipynb @@ -390,7 +390,7 @@ "source": [ "# get features from column names...\n", "visualizer = Rank1D(algorithm='shapiro')\n", - "visualizer.fit_transform_poof(X, y);" + "visualizer.fit_transform_show(X, y);" ] }, { @@ -422,7 +422,7 @@ "source": [ "# Raw numpy version\n", "visualizer = Rank1D(algorithm='shapiro', features=features)\n", - "visualizer.fit_transform_poof(X.values, y.values);" + "visualizer.fit_transform_show(X.values, y.values);" ] }, { @@ -454,7 +454,7 @@ "source": [ "# numpy version, no feature names\n", "visualizer = Rank1D(algorithm='shapiro')\n", - "visualizer.fit_transform_poof(X.values, y.values);" + "visualizer.fit_transform_show(X.values, y.values);" ] }, { @@ -486,7 +486,7 @@ "source": [ "# disable tick labels\n", "visualizer = Rank1D(algorithm='shapiro', show_feature_names=False)\n", - "visualizer.fit_transform_poof(X.values, y.values);" + "visualizer.fit_transform_show(X.values, y.values);" ] }, { @@ -525,7 +525,7 @@ "source": [ "# get features from column names...\n", "visualizer = Rank1D(algorithm='shapiro', orient='v')\n", - "visualizer.fit_transform_poof(X, y);" + "visualizer.fit_transform_show(X, y);" ] }, { @@ -557,7 +557,7 @@ "source": [ "# Raw numpy version\n", "visualizer = Rank1D(algorithm='shapiro', features=features, orient='v')\n", - "visualizer.fit_transform_poof(X.values, y.values);" + "visualizer.fit_transform_show(X.values, y.values);" ] }, { @@ -589,7 +589,7 @@ "source": [ "# numpy version, no feature names\n", "visualizer = Rank1D(algorithm='shapiro', orient='v')\n", - "visualizer.fit_transform_poof(X.values, y.values);" + "visualizer.fit_transform_show(X.values, y.values);" ] }, { @@ -621,7 +621,7 @@ "source": [ "# disable tick labels\n", "visualizer = Rank1D(algorithm='shapiro', show_feature_names=False, orient='v')\n", - "visualizer.fit_transform_poof(X.values, y.values);" + "visualizer.fit_transform_show(X.values, y.values);" ] }, { @@ -915,7 +915,7 @@ "source": [ "# get features from column names...\n", "visualizer = Rank2D()\n", - "visualizer.fit_transform_poof(X, y);" + "visualizer.fit_transform_show(X, y);" ] }, { @@ -939,7 +939,7 @@ "source": [ "# raw numpy version\n", "visualizer = Rank2D(features=features)\n", - "visualizer.fit_transform_poof(X.values, y.values);" + "visualizer.fit_transform_show(X.values, y.values);" ] }, { @@ -961,7 +961,7 @@ "source": [ "# numpy version, no feature names\n", "visualizer = Rank2D()\n", - "visualizer.fit_transform_poof(X.values, y.values);" + "visualizer.fit_transform_show(X.values, y.values);" ] }, { @@ -983,7 +983,7 @@ "source": [ "# disable tick labels\n", "visualizer = Rank2D(show_feature_names=False)\n", - "visualizer.fit_transform_poof(X.values, y.values);" + "visualizer.fit_transform_show(X.values, y.values);" ] }, { diff --git a/examples/pbwitt/testing.ipynb b/examples/pbwitt/testing.ipynb index 3a2c71b4a..47409c852 100644 --- a/examples/pbwitt/testing.ipynb +++ b/examples/pbwitt/testing.ipynb @@ -628,7 +628,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -653,7 +653,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -909,7 +909,7 @@ "visualizer = PredictionError(lasso)\n", "visualizer.fit(fit_and_evaluate(dataset, Lasso, \"X_train\",'Lasso_vis')[0], fit_and_evaluate(dataset, Lasso, \"y_train\",'Lasso_vis')[1]) # Fit the training data to the visualizer\n", "visualizer.score(fit_and_evaluate(dataset, Lasso, \"X_train\",'Lasso_vis')[2], fit_and_evaluate(dataset, Lasso, \"y_train\",'Lasso_vis')[3])\n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { @@ -956,7 +956,7 @@ "visualizer = ResidualsPlot(ridge)\n", "visualizer.fit(fit_and_evaluate(dataset, Ridge, \"X_train\",'Ridge_vis')[0], fit_and_evaluate(dataset, Ridge, \"y_train\",'Ridge_vis')[1]) # Fit the training data to the visualizer\n", "visualizer.score(fit_and_evaluate(dataset, Ridge, \"X_train\",'Ridge_vis')[2], fit_and_evaluate(dataset, Ridge, \"y_train\",'Ridge_vis')[3]) # Evaluate the model on the test data \n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { diff --git a/examples/pdamodaran/feature_visualizer.ipynb b/examples/pdamodaran/feature_visualizer.ipynb index db07521ae..0253fa431 100644 --- a/examples/pdamodaran/feature_visualizer.ipynb +++ b/examples/pdamodaran/feature_visualizer.ipynb @@ -233,7 +233,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -331,7 +331,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] } ], diff --git a/examples/pdamodaran/jointplot.ipynb b/examples/pdamodaran/jointplot.ipynb index 955ea685c..35c314873 100644 --- a/examples/pdamodaran/jointplot.ipynb +++ b/examples/pdamodaran/jointplot.ipynb @@ -291,7 +291,7 @@ " self.y_ax.hist(y, bins=hist_bins, color=histcolor_y, \n", " orientation='horizontal', **self.xy_args)\n", " \n", - " def poof(self, **kwargs):\n", + " def show(self, **kwargs):\n", "\n", " \"\"\" \n", " Creates the labels for the feature and target variables\n", @@ -306,7 +306,7 @@ "\n", " \"\"\"\n", " Finalize executes any subclass-specific axes finalization steps.\n", - " The user calls poof and poof calls finalize.\n", + " The user calls show and show calls finalize.\n", "\n", " Parameters\n", " ----------\n", @@ -405,7 +405,7 @@ "source": [ "visualizer = JointPlotVisualizer(feature=feature, target=target, joint_plot=\"hex\")\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { diff --git a/examples/peterespinosa/adding-scatterplot-alpha.ipynb b/examples/peterespinosa/adding-scatterplot-alpha.ipynb index 1b2607532..d44c1e8f7 100644 --- a/examples/peterespinosa/adding-scatterplot-alpha.ipynb +++ b/examples/peterespinosa/adding-scatterplot-alpha.ipynb @@ -77,7 +77,7 @@ "\n", "visualizer.fit(X, y)\n", "visualizer.transform(X)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -371,7 +371,7 @@ " def finalize(self, **kwargs):\n", " \"\"\"\n", " Finalize executes any subclass-specific axes finalization steps.\n", - " The user calls poof and poof calls finalize.\n", + " The user calls show and show calls finalize.\n", "\n", " Parameters\n", " ----------\n", @@ -431,7 +431,7 @@ "\n", "visualizer.fit(X, y)\n", "visualizer.transform(X)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -464,7 +464,7 @@ "\n", "visualizer.fit(X, y)\n", "visualizer.transform(X)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { diff --git a/examples/rebeccabilbro/balanced_binning_docs.ipynb b/examples/rebeccabilbro/balanced_binning_docs.ipynb index 8d6824759..eb51b5992 100644 --- a/examples/rebeccabilbro/balanced_binning_docs.ipynb +++ b/examples/rebeccabilbro/balanced_binning_docs.ipynb @@ -88,7 +88,7 @@ " --------\n", " >>> visualizer = BalancedBinningReference()\n", " >>> visualizer.fit(y)\n", - " >>> visualizer.poof()\n", + " >>> visualizer.show()\n", "\n", "\n", " Notes\n", @@ -149,7 +149,7 @@ " return self\n", "\n", "\n", - " def poof(self, **kwargs):\n", + " def show(self, **kwargs):\n", " \"\"\"\n", " Creates the labels for the feature and target variables.\n", " \"\"\"\n", @@ -160,7 +160,7 @@ " def finalize(self, **kwargs):\n", " \"\"\"\n", " Finalize executes any subclass-specific axes finalization steps.\n", - " The user calls poof and poof calls finalize.\n", + " The user calls show and show calls finalize.\n", "\n", " Parameters\n", " ----------\n", @@ -208,9 +208,9 @@ " # Initialize the visualizer\n", " visualizer = BalancedBinningReference(ax=ax, bins=bins, target=target, **kwargs)\n", " \n", - " # Fit and poof the visualizer\n", + " # Fit and show the visualizer\n", " visualizer.fit(y)\n", - " visualizer.poof()" + " visualizer.show()" ] }, { @@ -229,7 +229,7 @@ " # Instantiate and fit the visualizer\n", " visualizer = BalancedBinningReference()\n", " visualizer.fit(y)\n", - " return visualizer.poof()\n", + " return visualizer.show()\n", "\n", "\n" ] diff --git a/examples/rebeccabilbro/barchart_colors.ipynb b/examples/rebeccabilbro/barchart_colors.ipynb index c09e85a60..758f3368f 100644 --- a/examples/rebeccabilbro/barchart_colors.ipynb +++ b/examples/rebeccabilbro/barchart_colors.ipynb @@ -82,7 +82,7 @@ "\n", "visualizer.fit(X, y)\n", "visualizer.transform(X)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -123,7 +123,7 @@ " features=features, orient='v', size=(600, 300), color=[\"crimson\"]\n", ")\n", "visualizer.fit(docs)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -162,7 +162,7 @@ ")\n", "\n", "visualizer.fit(X, y)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -200,7 +200,7 @@ "colors = [\"lightpink\", \"pink\", \"hotpink\", \"crimson\", \"orchid\"]\n", "viz = FeatureImportances(model, colors=colors)\n", "viz.fit(X, y)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -229,7 +229,7 @@ "model = LogisticRegression(multi_class=\"auto\", solver=\"liblinear\")\n", "viz = FeatureImportances(model, stack=True, relative=False, colormap=\"viridis\")\n", "viz.fit(X, y)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -278,7 +278,7 @@ "visualizer = MissingValuesBar(features=features, color=\"lime\")\n", "\n", "visualizer.fit(X)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -315,7 +315,7 @@ ")\n", "\n", "visualizer.fit(y)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -355,7 +355,7 @@ "visualizer = FeatureCorrelation(labels=features, color=\"rebeccapurple\")\n", "\n", "visualizer.fit(X, y)\n", - "visualizer.poof()" + "visualizer.show()" ] } ], diff --git a/examples/rebeccabilbro/check_is_fitted.ipynb b/examples/rebeccabilbro/check_is_fitted.ipynb index c64681a6f..5e62b9c86 100644 --- a/examples/rebeccabilbro/check_is_fitted.ipynb +++ b/examples/rebeccabilbro/check_is_fitted.ipynb @@ -71,7 +71,7 @@ "oz = ClassPredictionError(fitted_model)\n", "oz.fit(X_train, y_train)\n", "oz.score(X_test, y_test)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -96,7 +96,7 @@ "oz = ClassPredictionError(unfitted_model)\n", "oz.fit(X_train, y_train)\n", "oz.score(X_test, y_test)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -121,7 +121,7 @@ "oz = ClassificationReport(fitted_model)\n", "oz.fit(X_train, y_train)\n", "oz.score(X_test, y_test)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -146,7 +146,7 @@ "oz = ClassificationReport(unfitted_model)\n", "oz.fit(X_train, y_train)\n", "oz.score(X_test, y_test)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -171,7 +171,7 @@ "oz = ConfusionMatrix(fitted_model)\n", "oz.fit(X_train, y_train)\n", "oz.score(X_test, y_test)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -196,7 +196,7 @@ "oz = ConfusionMatrix(unfitted_model)\n", "oz.fit(X_train, y_train)\n", "oz.score(X_test, y_test)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -221,7 +221,7 @@ "oz = PrecisionRecallCurve(fitted_model)\n", "oz.fit(X_train, y_train)\n", "oz.score(X_test, y_test)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -246,7 +246,7 @@ "oz = PrecisionRecallCurve(unfitted_model)\n", "oz.fit(X_train, y_train)\n", "oz.score(X_test, y_test)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -271,7 +271,7 @@ "oz = ROCAUC(fitted_model)\n", "oz.fit(X_train, y_train)\n", "oz.score(X_test, y_test)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -296,7 +296,7 @@ "oz = ROCAUC(unfitted_model)\n", "oz.fit(X_train, y_train)\n", "oz.score(X_test, y_test)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -320,7 +320,7 @@ "source": [ "oz = DiscriminationThreshold(fitted_model)\n", "oz.fit(X, y)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -344,7 +344,7 @@ "source": [ "oz = DiscriminationThreshold(unfitted_model)\n", "oz.fit(X, y)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -384,7 +384,7 @@ "source": [ "viz = FeatureImportances(fitted_model)\n", "viz.fit(X, y)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -416,7 +416,7 @@ "source": [ "viz = FeatureImportances(unfitted_model)\n", "viz.fit(X, y)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -487,7 +487,7 @@ "oz = PredictionError(unfitted_linear_model)\n", "oz.fit(X_train, y_train)\n", "oz.score(X_test, y_test)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -512,7 +512,7 @@ "oz = PredictionError(fitted_linear_model)\n", "oz.fit(X_train, y_train)\n", "oz.score(X_test, y_test)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -537,7 +537,7 @@ "oz = ResidualsPlot(unfitted_linear_model)\n", "oz.fit(X_train, y_train)\n", "oz.score(X_test, y_test)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -562,7 +562,7 @@ "oz = ResidualsPlot(fitted_linear_model)\n", "oz.fit(X_train, y_train)\n", "oz.score(X_test, y_test)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -587,7 +587,7 @@ "oz = ResidualsPlot(unfitted_nonlinear_model)\n", "oz.fit(X_train, y_train)\n", "oz.score(X_test, y_test)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -612,7 +612,7 @@ "oz = ResidualsPlot(fitted_nonlinear_model)\n", "oz.fit(X_train, y_train)\n", "oz.score(X_test, y_test)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -646,7 +646,7 @@ "source": [ "oz = AlphaSelection(unfitted_cv_model)\n", "oz.fit(X, y)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -670,7 +670,7 @@ "source": [ "oz = AlphaSelection(fitted_cv_model)\n", "oz.fit(X, y)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -709,7 +709,7 @@ "\n", "# visualizer = KElbowVisualizer(unfitted_cluster_model, k=(4,12))\n", "# visualizer.fit(X)\n", - "# visualizer.poof()" + "# visualizer.show()" ] }, { @@ -720,7 +720,7 @@ "source": [ "# visualizer = KElbowVisualizer(fitted_cluster_model, k=(4,12))\n", "# visualizer.fit(X)\n", - "# visualizer.poof()" + "# visualizer.show()" ] }, { @@ -745,7 +745,7 @@ "# NOTE: Silhouette Scores doesn't have a quick method\n", "visualizer = SilhouetteVisualizer(unfitted_cluster_model)\n", "visualizer.fit(X)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -769,7 +769,7 @@ "source": [ "visualizer = SilhouetteVisualizer(fitted_cluster_model)\n", "visualizer.fit(X)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -793,7 +793,7 @@ "source": [ "visualizer = InterclusterDistance(unfitted_cluster_model)\n", "visualizer.fit(X)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -817,7 +817,7 @@ "source": [ "visualizer = InterclusterDistance(fitted_cluster_model)\n", "visualizer.fit(X)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { diff --git a/examples/rebeccabilbro/conf_matrix_class_names.ipynb b/examples/rebeccabilbro/conf_matrix_class_names.ipynb index 536c86cdb..1d73b4da0 100644 --- a/examples/rebeccabilbro/conf_matrix_class_names.ipynb +++ b/examples/rebeccabilbro/conf_matrix_class_names.ipynb @@ -78,7 +78,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mcm\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mConfusionMatrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclasses\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mcm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mcm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 6\u001b[0m \u001b[0mcm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mcm\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mConfusionMatrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mclasses\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mcm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mcm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 6\u001b[0m \u001b[0mcm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/yellowbrick/classifier/confusion_matrix.py\u001b[0m in \u001b[0;36mscore\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 175\u001b[0m \u001b[0;31m# Compute the confusion matrix and class counts\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 176\u001b[0m self.confusion_matrix_ = confusion_matrix_metric(\n\u001b[0;32m--> 177\u001b[0;31m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclasses_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msample_weight\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msample_weight\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 178\u001b[0m )\n\u001b[1;32m 179\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclass_counts_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclass_counts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/sklearn/metrics/classification.py\u001b[0m in \u001b[0;36mconfusion_matrix\u001b[0;34m(y_true, y_pred, labels, sample_weight)\u001b[0m\n\u001b[1;32m 257\u001b[0m \u001b[0mlabels\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 258\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0ml\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0my_true\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ml\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mlabels\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 259\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"At least one label specified must be in y_true\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 260\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 261\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0msample_weight\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mValueError\u001b[0m: At least one label specified must be in y_true" @@ -91,7 +91,7 @@ "cm = ConfusionMatrix(model, classes=classes)\n", "cm.fit(X_train, y_train)\n", "cm.score(X_test, y_test)\n", - "cm.poof()" + "cm.show()" ] }, { @@ -126,7 +126,7 @@ ")\n", "cm.fit(X_train, y_train)\n", "cm.score(X_test, y_test)\n", - "cm.poof()" + "cm.show()" ] }, { diff --git a/examples/rebeccabilbro/correcting_percents_confusion_matrix.ipynb b/examples/rebeccabilbro/correcting_percents_confusion_matrix.ipynb index 9671ba0ea..dd5893843 100644 --- a/examples/rebeccabilbro/correcting_percents_confusion_matrix.ipynb +++ b/examples/rebeccabilbro/correcting_percents_confusion_matrix.ipynb @@ -71,7 +71,7 @@ "cm = ConfusionMatrix(model, percent=True)\n", "cm.fit(oX_train, oy_train)\n", "cm.score(oX_test, oy_test)\n", - "cm.poof()" + "cm.show()" ] }, { @@ -117,7 +117,7 @@ "cm = ConfusionMatrix(model, percent=True)\n", "cm.fit(gX_train, gy_train)\n", "cm.score(gX_test, gy_test)\n", - "cm.poof()" + "cm.show()" ] }, { @@ -154,7 +154,7 @@ "cm = ConfusionMatrix(model, percent=True)\n", "cm.fit(rX_train, ry_train)\n", "cm.score(rX_test, ry_test)\n", - "cm.poof()" + "cm.show()" ] }, { @@ -262,7 +262,7 @@ " >>> viz = ConfusionMatrix(LogisticRegression())\n", " >>> viz.fit(X_train, y_train)\n", " >>> viz.score(X_test, y_test)\n", - " >>> viz.poof()\n", + " >>> viz.show()\n", " \"\"\"\n", "\n", "\n", @@ -466,7 +466,7 @@ "cm = ConfusionMatrix(model, percent=True)\n", "cm.fit(oX_train, oy_train)\n", "cm.score(oX_test, oy_test)\n", - "cm.poof()" + "cm.show()" ] }, { @@ -490,7 +490,7 @@ "cm = ConfusionMatrix(model, percent=True)\n", "cm.fit(gX_train, gy_train)\n", "cm.score(gX_test, gy_test)\n", - "cm.poof()" + "cm.show()" ] }, { @@ -514,7 +514,7 @@ "cm = ConfusionMatrix(model, percent=True)\n", "cm.fit(rX_train, ry_train)\n", "cm.score(rX_test, ry_test)\n", - "cm.poof()" + "cm.show()" ] } ], diff --git a/examples/rebeccabilbro/cvscores_enhancements.ipynb b/examples/rebeccabilbro/cvscores_enhancements.ipynb index af8739a5f..b5f743301 100644 --- a/examples/rebeccabilbro/cvscores_enhancements.ipynb +++ b/examples/rebeccabilbro/cvscores_enhancements.ipynb @@ -55,7 +55,7 @@ "oz = CVScores(RidgeClassifier(), cv=cv)\n", "\n", "oz.fit(X, y)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -143,7 +143,7 @@ " >>> y = iris.target\n", " >>> visualizer = CVScores(model=clf, cv=5, scoring='f1_macro')\n", " >>> visualizer.fit(X,y)\n", - " >>> visualizer.poof()\n", + " >>> visualizer.show()\n", "\n", " Notes\n", " -----\n", @@ -301,9 +301,9 @@ " # Initialize the visualizer\n", " visualizer = cv_scores(model, X, y, ax=ax, cv=cv, scoring=scoring)\n", "\n", - " # Fit and poof the visualizer\n", + " # Fit and show the visualizer\n", " visualizer.fit(X, y)\n", - " visualizer.poof(**kwargs)\n", + " visualizer.show(**kwargs)\n", " return visualizer.ax" ] }, @@ -336,7 +336,7 @@ ")\n", "\n", "oz.fit(X, y)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -374,7 +374,7 @@ ")\n", "\n", "oz.fit(X, y)\n", - "oz.poof()\n", + "oz.show()\n", "\n" ] }, diff --git a/examples/rebeccabilbro/cvscores_experimentation.ipynb b/examples/rebeccabilbro/cvscores_experimentation.ipynb index 2cc8f98c8..88100e8ff 100644 --- a/examples/rebeccabilbro/cvscores_experimentation.ipynb +++ b/examples/rebeccabilbro/cvscores_experimentation.ipynb @@ -124,7 +124,7 @@ ")\n", "\n", "oz.fit(X, y)\n", - "oz.poof()\n" + "oz.show()\n" ] }, { @@ -173,7 +173,7 @@ ")\n", "\n", "oz.fit(X, y)\n", - "oz.poof()" + "oz.show()" ] } ], diff --git a/examples/rebeccabilbro/dispersion_plots.ipynb b/examples/rebeccabilbro/dispersion_plots.ipynb index f7cb6403e..e82f5d502 100644 --- a/examples/rebeccabilbro/dispersion_plots.ipynb +++ b/examples/rebeccabilbro/dispersion_plots.ipynb @@ -263,7 +263,7 @@ " def finalize(self, **kwargs):\n", " \"\"\"\n", " The finalize method executes any subclass-specific axes\n", - " finalization steps. The user calls poof & poof calls finalize.\n", + " finalization steps. The user calls show & show calls finalize.\n", " Parameters\n", " ----------\n", " kwargs: generic keyword arguments.\n", @@ -398,7 +398,7 @@ " \n", " oz = DispersionPlot(target_characters, colormap='tab20b', labels=titles)\n", " oz.fit(chapter_text, titles)\n", - " oz.poof()" + " oz.show()" ] }, { diff --git a/examples/rebeccabilbro/feature_importances_fix.ipynb b/examples/rebeccabilbro/feature_importances_fix.ipynb index 03150e808..0e5f40935 100644 --- a/examples/rebeccabilbro/feature_importances_fix.ipynb +++ b/examples/rebeccabilbro/feature_importances_fix.ipynb @@ -121,7 +121,7 @@ " >>> from sklearn.ensemble import GradientBoostingClassifier\n", " >>> visualizer = FeatureImportances(GradientBoostingClassifier())\n", " >>> visualizer.fit(X, y)\n", - " >>> visualizer.poof()\n", + " >>> visualizer.show()\n", " \"\"\"\n", "\n", " def __init__(self, model, ax=None, labels=None, relative=True,\n", @@ -384,7 +384,7 @@ "source": [ "lr_importances = FeatureImportances(LogisticRegression())\n", "lr_importances.fit(X,y)\n", - "lr_importances.poof()" + "lr_importances.show()" ] }, { @@ -406,7 +406,7 @@ "source": [ "lr_importances = FeatureImportances(LogisticRegression(), absolute=True)\n", "lr_importances.fit(X,y)\n", - "lr_importances.poof()" + "lr_importances.show()" ] }, { @@ -449,7 +449,7 @@ "source": [ "lr_importances = FeatureImportances(LogisticRegression(), size=(1080, 720))\n", "lr_importances.fit(X,y)\n", - "lr_importances.poof()" + "lr_importances.show()" ] }, { @@ -471,7 +471,7 @@ "source": [ "lr_importances = FeatureImportances(LogisticRegression(), absolute=True, size=(1080, 720))\n", "lr_importances.fit(X,y)\n", - "lr_importances.poof()" + "lr_importances.show()" ] } ], diff --git a/examples/rebeccabilbro/freqtext.ipynb b/examples/rebeccabilbro/freqtext.ipynb index c4f8239ae..8abbefa68 100644 --- a/examples/rebeccabilbro/freqtext.ipynb +++ b/examples/rebeccabilbro/freqtext.ipynb @@ -160,7 +160,7 @@ "source": [ "Note that the `FreqDistVisualizer` does not perform any normalization or vectorization, and it expects text that has already be count vectorized.\n", "\n", - "We first instantiate a `FreqDistVisualizer` object, and then call `fit()` on that object with the count vectorized documents and the features (i.e. the words from the corpus), which computes the frequency distribution. The visualizer then plots a bar chart of the top 50 most frequent terms in the corpus, with the terms listed along the x-axis and frequency counts depicted at y-axis values. As with other Yellowbrick visualizers, when the user invokes `poof()`, the finalized visualization is shown." + "We first instantiate a `FreqDistVisualizer` object, and then call `fit()` on that object with the count vectorized documents and the features (i.e. the words from the corpus), which computes the frequency distribution. The visualizer then plots a bar chart of the top 50 most frequent terms in the corpus, with the terms listed along the x-axis and frequency counts depicted at y-axis values. As with other Yellowbrick visualizers, when the user invokes `show()`, the finalized visualization is shown." ] }, { @@ -186,7 +186,7 @@ "\n", "visualizer = FreqDistVisualizer()\n", "visualizer.fit(docs, features)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -231,7 +231,7 @@ "\n", "visualizer = FreqDistVisualizer()\n", "visualizer.fit(docs, features)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -294,7 +294,7 @@ "\n", "visualizer = FreqDistVisualizer()\n", "visualizer.fit(docs, features)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -330,7 +330,7 @@ "\n", "visualizer = FreqDistVisualizer()\n", "visualizer.fit(docs, features)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { diff --git a/examples/rebeccabilbro/pipelines.ipynb b/examples/rebeccabilbro/pipelines.ipynb index de7139e95..05cc34486 100644 --- a/examples/rebeccabilbro/pipelines.ipynb +++ b/examples/rebeccabilbro/pipelines.ipynb @@ -10,7 +10,7 @@ "\n", "`VisualPipelines` sequentially apply a list of transforms, visualizers, and a final estimator which may be evaluated by additional visualizers. Intermediate steps of the pipeline must be kinds of 'transforms', that is, they must implement `fit` and `transform` methods. The final estimator only needs to implement `fit`.\n", "\n", - "Any step that implements draw or poof methods can be called sequentially directly from the VisualPipeline, allowing multiple visual diagnostics to be generated, displayed, and saved on demand. If `draw` or `poof` is not called, the visual pipeline should be equivalent to the simple pipeline to ensure no reduction in performance.\n", + "Any step that implements draw or show methods can be called sequentially directly from the VisualPipeline, allowing multiple visual diagnostics to be generated, displayed, and saved on demand. If `draw` or `show` is not called, the visual pipeline should be equivalent to the simple pipeline to ensure no reduction in performance.\n", "\n", "The purpose of the pipeline is to assemble several steps that can be cross-validated together while setting different parameters. These steps can be visually diagnosed by visualizers at every point in the pipeline." ] @@ -149,7 +149,7 @@ "\n", "visualizer.fit(X, y)\n", "visualizer.transform(X)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -177,7 +177,7 @@ "\n", "visualizer.fit(X, y)\n", "visualizer.transform(X)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -228,7 +228,7 @@ "source": [ "multivisualizer.fit(X, y)\n", "multivisualizer.transform(X)\n", - "multivisualizer.poof()" + "multivisualizer.show()" ] } ], diff --git a/examples/rebeccabilbro/prediction_error_alpha.ipynb b/examples/rebeccabilbro/prediction_error_alpha.ipynb index 54f319c33..7c22a5bfc 100644 --- a/examples/rebeccabilbro/prediction_error_alpha.ipynb +++ b/examples/rebeccabilbro/prediction_error_alpha.ipynb @@ -91,7 +91,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data\n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { @@ -122,7 +122,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data\n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { @@ -312,7 +312,7 @@ " >>> model = PredictionError(Lasso())\n", " >>> model.fit(X_train, y_train)\n", " >>> model.score(X_test, y_test)\n", - " >>> model.poof()\n", + " >>> model.show()\n", "\n", " Notes\n", " -----\n", @@ -399,7 +399,7 @@ " def finalize(self, **kwargs):\n", " \"\"\"\n", " Finalize executes any subclass-specific axes finalization steps.\n", - " The user calls poof and poof calls finalize.\n", + " The user calls show and show calls finalize.\n", "\n", " Parameters\n", " ----------\n", @@ -477,7 +477,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data\n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { @@ -490,7 +490,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data\n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { @@ -503,7 +503,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data\n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { @@ -516,7 +516,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data\n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { @@ -541,7 +541,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the model\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -555,7 +555,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the model\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -623,7 +623,7 @@ " >>> model = ResidualsPlot(Ridge())\n", " >>> model.fit(X_train, y_train)\n", " >>> model.score(X_test, y_test)\n", - " >>> model.poof()\n", + " >>> model.show()\n", "\n", " Notes\n", " -----\n", @@ -793,7 +793,7 @@ " def finalize(self, **kwargs):\n", " \"\"\"\n", " Finalize executes any subclass-specific axes finalization steps.\n", - " The user calls poof and poof calls finalize.\n", + " The user calls show and show calls finalize.\n", "\n", " Parameters\n", " ----------\n", @@ -943,7 +943,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the model\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { diff --git a/examples/rebeccabilbro/rocauc_bug_fix.ipynb b/examples/rebeccabilbro/rocauc_bug_fix.ipynb index 319e64b27..ee1bb68c5 100644 --- a/examples/rebeccabilbro/rocauc_bug_fix.ipynb +++ b/examples/rebeccabilbro/rocauc_bug_fix.ipynb @@ -136,7 +136,7 @@ " >>> viz = ROCAUC(LogisticRegression())\n", " >>> viz.fit(X_train, y_train)\n", " >>> viz.score(X_test, y_test)\n", - " >>> viz.poof()\n", + " >>> viz.show()\n", " \"\"\"\n", "\n", " def __init__(self, model, ax=None, classes=None,\n", @@ -287,7 +287,7 @@ " def finalize(self, **kwargs):\n", " \"\"\"\n", " Finalize executes any subclass-specific axes finalization steps.\n", - " The user calls poof and poof calls finalize.\n", + " The user calls show and show calls finalize.\n", "\n", " Parameters\n", " ----------\n", @@ -697,13 +697,13 @@ " oz = ROCAUC(classifier)\n", " oz.fit(X_train, y_train)\n", " oz.score(X_test, y_test)\n", - " g = oz.poof()\n", + " g = oz.show()\n", " \n", "for classifier in binary_classifiers:\n", " oz = ROCAUC(classifier, micro=False, macro=False, per_class=False)\n", " oz.fit(X_train, y_train)\n", " oz.score(X_test, y_test)\n", - " g = oz.poof()" + " g = oz.show()" ] }, { diff --git a/examples/rebeccabilbro/rocauc_bug_research.ipynb b/examples/rebeccabilbro/rocauc_bug_research.ipynb index 70a365615..38b1da577 100644 --- a/examples/rebeccabilbro/rocauc_bug_research.ipynb +++ b/examples/rebeccabilbro/rocauc_bug_research.ipynb @@ -179,7 +179,7 @@ " oz = ROCAUC(classifier)\n", " oz.fit(X_train, y_train)\n", " oz.score(X_test, y_test)\n", - " g = oz.poof()" + " g = oz.show()" ] }, { @@ -274,7 +274,7 @@ " oz = ROCAUC(classifier)\n", " oz.fit(X_train, y_train)\n", " oz.score(X_test, y_test)\n", - " g = oz.poof()" + " g = oz.show()" ] }, { @@ -289,7 +289,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0moz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mROCAUC\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mLinearSVC\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0moz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mROCAUC\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mLinearSVC\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/yellowbrick/classifier/rocauc.py\u001b[0m in \u001b[0;36mscore\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 176\u001b[0m \u001b[0;31m# Compute ROC curve and ROC area for each class\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 177\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 178\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mroc_curve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpos_label\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 179\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mroc_auc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mauc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mIndexError\u001b[0m: too many indices for array" ] @@ -299,7 +299,7 @@ "oz = ROCAUC(LinearSVC())\n", "oz.fit(X_train, y_train)\n", "oz.score(X_test, y_test)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -314,7 +314,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0moz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mROCAUC\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mSVC\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0moz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mROCAUC\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mSVC\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/yellowbrick/classifier/rocauc.py\u001b[0m in \u001b[0;36mscore\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 176\u001b[0m \u001b[0;31m# Compute ROC curve and ROC area for each class\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 177\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 178\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mroc_curve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpos_label\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 179\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mroc_auc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mauc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mIndexError\u001b[0m: too many indices for array" ] @@ -324,7 +324,7 @@ "oz = ROCAUC(SVC())\n", "oz.fit(X_train, y_train)\n", "oz.score(X_test, y_test)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -347,7 +347,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0moz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mROCAUC\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mSGDClassifier\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0moz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mROCAUC\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mSGDClassifier\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/yellowbrick/classifier/rocauc.py\u001b[0m in \u001b[0;36mscore\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 176\u001b[0m \u001b[0;31m# Compute ROC curve and ROC area for each class\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 177\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 178\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mroc_curve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpos_label\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 179\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mroc_auc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mauc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mIndexError\u001b[0m: too many indices for array" ] @@ -357,7 +357,7 @@ "oz = ROCAUC(SGDClassifier())\n", "oz.fit(X_train, y_train)\n", "oz.score(X_test, y_test)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -380,7 +380,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0moz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mROCAUC\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mPassiveAggressiveClassifier\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0moz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mROCAUC\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mPassiveAggressiveClassifier\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/yellowbrick/classifier/rocauc.py\u001b[0m in \u001b[0;36mscore\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 176\u001b[0m \u001b[0;31m# Compute ROC curve and ROC area for each class\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 177\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 178\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mroc_curve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpos_label\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 179\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mroc_auc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mauc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mIndexError\u001b[0m: too many indices for array" ] @@ -390,7 +390,7 @@ "oz = ROCAUC(PassiveAggressiveClassifier())\n", "oz.fit(X_train, y_train)\n", "oz.score(X_test, y_test)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -405,7 +405,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0moz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mROCAUC\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mRidgeClassifier\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0moz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mROCAUC\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mRidgeClassifier\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/yellowbrick/classifier/rocauc.py\u001b[0m in \u001b[0;36mscore\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 176\u001b[0m \u001b[0;31m# Compute ROC curve and ROC area for each class\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 177\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 178\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mroc_curve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpos_label\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 179\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mroc_auc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mauc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mIndexError\u001b[0m: too many indices for array" ] @@ -415,7 +415,7 @@ "oz = ROCAUC(RidgeClassifier())\n", "oz.fit(X_train, y_train)\n", "oz.score(X_test, y_test)\n", - "oz.poof()" + "oz.show()" ] }, { @@ -430,7 +430,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0moz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mROCAUC\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mRidgeClassifierCV\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0moz\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mROCAUC\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mRidgeClassifierCV\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0moz\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/yellowbrick/classifier/rocauc.py\u001b[0m in \u001b[0;36mscore\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 176\u001b[0m \u001b[0;31m# Compute ROC curve and ROC area for each class\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 177\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 178\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mroc_curve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpos_label\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 179\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mroc_auc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mauc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtpr\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 180\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mIndexError\u001b[0m: too many indices for array" ] @@ -440,7 +440,7 @@ "oz = ROCAUC(RidgeClassifierCV())\n", "oz.fit(X_train, y_train)\n", "oz.score(X_test, y_test)\n", - "oz.poof()" + "oz.show()" ] }, { diff --git a/examples/rebeccabilbro/size_param_issue.ipynb b/examples/rebeccabilbro/size_param_issue.ipynb index 3a8d7a45b..0032ed28e 100644 --- a/examples/rebeccabilbro/size_param_issue.ipynb +++ b/examples/rebeccabilbro/size_param_issue.ipynb @@ -61,7 +61,7 @@ "\n", "oz.fit(X_train, y_train)\n", "oz.score(X_test, y_test)\n", - "oz.poof()" + "oz.show()" ] }, { diff --git a/examples/rebeccabilbro/testing.ipynb b/examples/rebeccabilbro/testing.ipynb index 82b037f68..18ab89b77 100644 --- a/examples/rebeccabilbro/testing.ipynb +++ b/examples/rebeccabilbro/testing.ipynb @@ -220,7 +220,7 @@ "\n", "visualizer = FreqDistVisualizer()\n", "visualizer.fit(docs, features)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -256,7 +256,7 @@ "\n", "visualizer = FreqDistVisualizer()\n", "visualizer.fit(docs, features)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -333,7 +333,7 @@ "\n", "visualizer = FreqDistVisualizer()\n", "visualizer.fit(docs, features)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -369,7 +369,7 @@ "\n", "visualizer = FreqDistVisualizer()\n", "visualizer.fit(docs, features)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -412,7 +412,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# Create the visualizer and draw the vectors\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mtsne\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mTSNEVisualizer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mtsne\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdocs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0mtsne\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# Create the visualizer and draw the vectors\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mtsne\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mTSNEVisualizer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mtsne\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdocs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0mtsne\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.5/lib/python3.5/site-packages/yellowbrick/text/tsne.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 265\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 266\u001b[0m \u001b[0;31m# Draw the vectors\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 267\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvecs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 268\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 269\u001b[0m \u001b[0;31m# Fit always returns self.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/3.5/lib/python3.5/site-packages/yellowbrick/text/tsne.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, points, target, **kwargs)\u001b[0m\n\u001b[1;32m 309\u001b[0m \u001b[0;31m# Plot the points\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 310\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpoints\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mseries\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 311\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpoints\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'x'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpoints\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'y'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcolors\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mlabel\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malpha\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0.7\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlabel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 312\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 313\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mfinalize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mKeyError\u001b[0m: 'Paula_Hawkins-The-Girl-On-The-Train'" @@ -433,7 +433,7 @@ "# Create the visualizer and draw the vectors \n", "tsne = TSNEVisualizer()\n", "tsne.fit(docs, labels)\n", - "tsne.poof()" + "tsne.show()" ] }, { @@ -459,7 +459,7 @@ "# Only visualize the books by female authors\n", "tsne = TSNEVisualizer(classes=female)\n", "tsne.fit(docs, labels)\n", - "tsne.poof()" + "tsne.show()" ] }, { @@ -484,7 +484,7 @@ "# Only visualize the books by male authors\n", "tsne = TSNEVisualizer(classes=male)\n", "tsne.fit(docs, labels)\n", - "tsne.poof()" + "tsne.show()" ] }, { diff --git a/examples/rebeccabilbro/tsne_alpha_manual_legend.ipynb b/examples/rebeccabilbro/tsne_alpha_manual_legend.ipynb index 2f5de8116..37826a3ce 100644 --- a/examples/rebeccabilbro/tsne_alpha_manual_legend.ipynb +++ b/examples/rebeccabilbro/tsne_alpha_manual_legend.ipynb @@ -597,7 +597,7 @@ "source": [ "tsne = TSNEVisualizer()\n", "tsne.fit(docs, labels)\n", - "tsne.poof()" + "tsne.show()" ] }, { @@ -630,7 +630,7 @@ "source": [ "tsne = TSNEVisualizer(alpha=0.5)\n", "tsne.fit(docs, labels)\n", - "tsne.poof()" + "tsne.show()" ] }, { diff --git a/examples/rebeccabilbro/tsne_resolve_colors.ipynb b/examples/rebeccabilbro/tsne_resolve_colors.ipynb index def562d7b..3840c47e4 100644 --- a/examples/rebeccabilbro/tsne_resolve_colors.ipynb +++ b/examples/rebeccabilbro/tsne_resolve_colors.ipynb @@ -138,7 +138,7 @@ "\n", "tsne = TSNEVisualizer(colors=[\"purple\",\"blue\",\"orchid\",\"indigo\",\"plum\",\"navy\"])\n", "tsne.fit(docs, labels)\n", - "tsne.poof()" + "tsne.show()" ] }, { @@ -527,7 +527,7 @@ "source": [ "tsne = TSNEVisualizer(colors=[\"purple\",\"blue\",\"orchid\",\"indigo\",\"plum\",\"navy\"])\n", "tsne.fit(docs, labels)\n", - "tsne.poof()" + "tsne.show()" ] }, { diff --git a/examples/regression_visualizers.ipynb b/examples/regression_visualizers.ipynb index a95003c25..aa5c395bc 100644 --- a/examples/regression_visualizers.ipynb +++ b/examples/regression_visualizers.ipynb @@ -113,7 +113,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Finalize and render the figure" ] }, { @@ -156,7 +156,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Finalize and render the figure" ] }, { @@ -201,7 +201,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data \n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Finalize and render the figure" ] }, { @@ -250,7 +250,7 @@ "visualizer = AlphaSelection(model)\n", "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Finalize and render the figure" ] } ], diff --git a/examples/tuulihill/Tuulitest.ipynb b/examples/tuulihill/Tuulitest.ipynb index a9ad1953f..3b204ab92 100644 --- a/examples/tuulihill/Tuulitest.ipynb +++ b/examples/tuulihill/Tuulitest.ipynb @@ -354,7 +354,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -381,7 +381,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -450,7 +450,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mvisualizer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mRadViz\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeatures\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfeatures\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Fit the data to the visualizer\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Transform the data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Draw/show/poof the data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mvisualizer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mRadViz\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeatures\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfeatures\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Fit the data to the visualizer\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Transform the data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Draw/show/show the data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/Users/tuulimorrill/anaconda3/lib/python3.6/site-packages/yellowbrick/features/base.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 182\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 183\u001b[0m \u001b[0;31m# Draw the instances\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 184\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 185\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 186\u001b[0m \u001b[0;31m# Fit always returns self.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/Users/tuulimorrill/anaconda3/lib/python3.6/site-packages/yellowbrick/features/radviz.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 181\u001b[0m \u001b[0mrow_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrepeat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexpand_dims\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrow\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 182\u001b[0m \u001b[0mxy\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mrow_\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mrow\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 183\u001b[0;31m \u001b[0mkls\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclasses_\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 184\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 185\u001b[0m \u001b[0mto_plot\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkls\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mxy\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mTypeError\u001b[0m: list indices must be integers or slices, not str" @@ -463,7 +463,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -487,7 +487,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mvisualizer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mParallelCoordinates\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeatures\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfeatures\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Fit the data to the visualizer\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Transform the data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Draw/show/poof the data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mvisualizer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mParallelCoordinates\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mclasses\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeatures\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfeatures\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Fit the data to the visualizer\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Transform the data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Draw/show/show the data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/Users/tuulimorrill/anaconda3/lib/python3.6/site-packages/yellowbrick/features/base.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 182\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 183\u001b[0m \u001b[0;31m# Draw the instances\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 184\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 185\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 186\u001b[0m \u001b[0;31m# Fit always returns self.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/Users/tuulimorrill/anaconda3/lib/python3.6/site-packages/yellowbrick/features/pcoords.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 175\u001b[0m \u001b[0;31m# TODO: How to map classmap to labels?\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 176\u001b[0m \u001b[0mlabel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0midx\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;31m# Get the label for the row\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 177\u001b[0;31m \u001b[0mlabel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclasses_\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mlabel\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 178\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 179\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mlabel\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mused_legends\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mTypeError\u001b[0m: list indices must be integers or slices, not str" @@ -500,7 +500,7 @@ "\n", "visualizer.fit(X, y) # Fit the data to the visualizer\n", "visualizer.transform(X) # Transform the data\n", - "visualizer.poof() # Draw/show/poof the data" + "visualizer.show() # Draw/show/show the data" ] }, { @@ -576,7 +576,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data\n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { @@ -636,7 +636,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data\n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { @@ -705,7 +705,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Fit the training data to the visualizer\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Evaluate the model on the test data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0mg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpoof\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Draw/show/poof the data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Fit the training data to the visualizer\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Evaluate the model on the test data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0mg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvisualizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Draw/show/show the data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/Users/tuulimorrill/anaconda3/lib/python3.6/site-packages/yellowbrick/classifier.py\u001b[0m in \u001b[0;36mscore\u001b[0;34m(self, X, y, **kwargs)\u001b[0m\n\u001b[1;32m 133\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscores\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclasses_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscores\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 134\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscores\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkeys\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscores\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 135\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 136\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 137\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m/Users/tuulimorrill/anaconda3/lib/python3.6/site-packages/yellowbrick/classifier.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, y, y_pred)\u001b[0m\n\u001b[1;32m 154\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 155\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mcls\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclasses_\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 156\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscores\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'precision'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscores\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'recall'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscores\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'f1'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 157\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 158\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mcolumn\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatrix\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mKeyError\u001b[0m: 'high'" @@ -719,7 +719,7 @@ "\n", "visualizer.fit(X_train, y_train) # Fit the training data to the visualizer\n", "visualizer.score(X_test, y_test) # Evaluate the model on the test data\n", - "g = visualizer.poof() # Draw/show/poof the data" + "g = visualizer.show() # Draw/show/show the data" ] }, { diff --git a/examples/walkthrough.ipynb b/examples/walkthrough.ipynb index 2cd3bac52..59b39cd16 100644 --- a/examples/walkthrough.ipynb +++ b/examples/walkthrough.ipynb @@ -41,7 +41,7 @@ "\n", "visualizer = Rank2D(algorithm=\"pearson\")\n", "visualizer.fit_transform(X)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -54,7 +54,7 @@ "\n", "visualizer = JointPlotVisualizer(feature='temp', target='feelslike')\n", "visualizer.fit_transform(X['temp'], X['feelslike'])\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -75,7 +75,7 @@ "visualizer = ResidualsPlot(LinearRegression())\n", "visualizer.fit(X_train, y_train)\n", "visualizer.score(X_test, y_test)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -92,7 +92,7 @@ "alphas = np.logspace(-10, 1, 200)\n", "visualizer = AlphaSelection(RidgeCV(alphas=alphas))\n", "visualizer.fit(X, y)\n", - "visualizer.poof()" + "visualizer.show()" ] }, { @@ -107,7 +107,7 @@ "visualizer = PredictionError(Ridge(alpha=3.181))\n", "visualizer.fit(X_train, y_train)\n", "visualizer.score(X_test, y_test)\n", - "visualizer.poof()" + "visualizer.show()" ] } ], diff --git a/examples/zjpoh/correlated_var.ipynb b/examples/zjpoh/correlated_var.ipynb index 90e0e08c1..8c1b8cb00 100644 --- a/examples/zjpoh/correlated_var.ipynb +++ b/examples/zjpoh/correlated_var.ipynb @@ -137,7 +137,7 @@ "source": [ "fea_corr = FeatureCorrelation(labels=feature_names)\n", "fea_corr.fit(X, y)\n", - "fea_corr.poof()" + "fea_corr.show()" ] }, { @@ -181,7 +181,7 @@ "fea_corr = FeatureCorrelation(method='mutual_info-regression',\n", " labels=feature_names)\n", "fea_corr.fit(X, y, discrete_features=discrete_features, random_state=0)\n", - "fea_corr.poof()" + "fea_corr.show()" ] }, { @@ -318,7 +318,7 @@ " labels=feature_names, \n", " sort=True)\n", "fea_corr.fit(X, y, discrete_features=discrete_features, random_state=0)\n", - "fea_corr.poof()" + "fea_corr.show()" ] }, { @@ -481,7 +481,7 @@ "fea_corr = FeatureCorrelation(method='mutual_info-classification',\n", " feature_index=[1, 3, 5, 7, 9])\n", "fea_corr.fit(X_pd, y, random_state=0)\n", - "fea_corr.poof()" + "fea_corr.show()" ] }, { @@ -524,7 +524,7 @@ "fea_corr = FeatureCorrelation(method='mutual_info-classification',\n", " feature_names=feature_to_plot)\n", "fea_corr.fit(X_pd, y, random_state=0)\n", - "fea_corr.poof()" + "fea_corr.show()" ] }, { diff --git a/examples/zjpoh/stacked_feature_importance.ipynb b/examples/zjpoh/stacked_feature_importance.ipynb index 1abf34978..fd90d27e0 100644 --- a/examples/zjpoh/stacked_feature_importance.ipynb +++ b/examples/zjpoh/stacked_feature_importance.ipynb @@ -94,7 +94,7 @@ "source": [ "viz = FeatureImportances(LogisticRegression())\n", "viz.fit(X_iris, y_iris)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -116,7 +116,7 @@ "source": [ "viz = FeatureImportances(LogisticRegression(), relative=False)\n", "viz.fit(X_iris, y_iris)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -138,7 +138,7 @@ "source": [ "viz = FeatureImportances(LogisticRegression(), absolute=True)\n", "viz.fit(X_iris, y_iris)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -160,7 +160,7 @@ "source": [ "viz = FeatureImportances(LogisticRegression(), relative=False, absolute=True)\n", "viz.fit(X_iris, y_iris)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -191,7 +191,7 @@ "source": [ "viz = FeatureImportances(LogisticRegression(), stack=True)\n", "viz.fit(X_iris, y_iris)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -213,7 +213,7 @@ "source": [ "viz = FeatureImportances(LogisticRegression(), stack=True, relative=False)\n", "viz.fit(X_iris, y_iris)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -235,7 +235,7 @@ "source": [ "viz = FeatureImportances(LogisticRegression(), stack=True, absolute=True)\n", "viz.fit(X_iris, y_iris)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -257,7 +257,7 @@ "source": [ "viz = FeatureImportances(LogisticRegression(), stack=True, relative=False, absolute=True)\n", "viz.fit(X_iris, y_iris)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -299,7 +299,7 @@ "source": [ "viz = FeatureImportances(LogisticRegression(), stack=True, relative=True)\n", "viz.fit(X_digits, y_digits)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -328,7 +328,7 @@ "source": [ "viz = FeatureImportances(LinearRegression())\n", "viz.fit(X_iris, y_iris)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -350,7 +350,7 @@ "source": [ "viz = FeatureImportances(LinearRegression(), stack=True)\n", "viz.fit(X_iris, y_iris)\n", - "viz.poof()" + "viz.show()" ] }, { @@ -391,7 +391,7 @@ "source": [ "viz = FeatureImportances(LogisticRegression(), relative=False, absolute=False, stack=True)\n", "viz.fit(X_pd, y)\n", - "viz.poof()" + "viz.show()" ] } ], diff --git a/tests/base.py b/tests/base.py index 09ae206b6..270dc12bc 100644 --- a/tests/base.py +++ b/tests/base.py @@ -105,7 +105,7 @@ def assert_images_similar( visualizer : yellowbrick visualizer, default: None An instantiated yellowbrick visualizer that has been fitted, - transformed and had all operations except for poof called on it. + transformed and had all operations except for show called on it. ax : matplotlib Axes, default: None The axis to plot the figure on. diff --git a/tests/rand.py b/tests/rand.py index 78b930d85..31b4dc97e 100644 --- a/tests/rand.py +++ b/tests/rand.py @@ -104,4 +104,4 @@ def finalize(self): if __name__ == "__main__": r = RandomVisualizer() r.fit() - r.poof(outpath="test.png") + r.show(outpath="test.png") diff --git a/tests/test_base.py b/tests/test_base.py index a05894fcc..25d71c06a 100644 --- a/tests/test_base.py +++ b/tests/test_base.py @@ -113,9 +113,9 @@ def test_finalize_interface(self): assert viz.finalize() is viz.ax @patch("yellowbrick.base.plt") - def test_poof_show_interface(self, mock_plt): + def test_show_interface(self, mock_plt): """ - Test poof calls plt.show and other figure finalization correctly + Test show calls plt.show and other figure finalization correctly """ class CustomVisualizer(Visualizer): @@ -124,16 +124,16 @@ class CustomVisualizer(Visualizer): _, ax = plt.subplots() viz = CustomVisualizer(ax=ax) viz.finalize = MagicMock() - assert viz.poof() is ax + assert viz.show() is ax viz.finalize.assert_called_once_with() mock_plt.show.assert_called_once_with() mock_plt.savefig.assert_not_called() @patch("yellowbrick.base.plt") - def test_poof_savefig_interface(self, mock_plt): + def test_show_savefig_interface(self, mock_plt): """ - Test poof calls plt.savefig and other figure finalization correctly + Test show calls plt.savefig and other figure finalization correctly """ class CustomVisualizer(Visualizer): @@ -142,16 +142,16 @@ class CustomVisualizer(Visualizer): _, ax = plt.subplots() viz = CustomVisualizer(ax=ax) viz.finalize = MagicMock() - assert viz.poof(outpath="test.png") is ax + assert viz.show(outpath="test.png") is ax viz.finalize.assert_called_once_with() mock_plt.show.assert_not_called() mock_plt.savefig.assert_called_once_with("test.png") @patch("yellowbrick.base.plt") - def test_poof_warns(self, mock_plt): + def test_show_warns(self, mock_plt): """ - Test poof issues a warning when no axes has been modified + Test show issues a warning when no axes has been modified """ class CustomVisualizer(Visualizer): @@ -159,7 +159,23 @@ class CustomVisualizer(Visualizer): with pytest.warns(YellowbrickWarning): viz = CustomVisualizer() - assert viz.poof() is not None + assert viz.show() is not None + + def test_poof_deprecated(self): + """ + Test that poof issues a deprecation warning + """ + + class CustomVisualizer(Visualizer): + pass + + viz = CustomVisualizer() + viz.show = MagicMock() + + with pytest.warns(DeprecationWarning, match="please use show"): + viz.poof() + + viz.show.assert_called_once() ########################################################################## @@ -231,8 +247,8 @@ def test_draw_visualizer_grid(self): grid = VisualizerGrid(visualizers) grid.fit(X, y) - # poof is required here (do not replace with finalize)! - assert grid.poof() is not None + # show is required here (do not replace with finalize)! + assert grid.show() is not None self.assert_images_similar(grid) @@ -253,8 +269,8 @@ def test_draw_with_rows(self): grid = VisualizerGrid(visualizers, nrows=2) grid.fit(X, y) - # poof is required here (do not replace with finalize)! - assert grid.poof() is not None + # show is required here (do not replace with finalize)! + assert grid.show() is not None self.assert_images_similar(grid) @@ -275,8 +291,8 @@ def test_draw_with_cols(self): grid = VisualizerGrid(visualizers, ncols=2) grid.fit(X, y) - # poof is required here (do not replace with finalize)! - assert grid.poof() is not None + # show is required here (do not replace with finalize)! + assert grid.show() is not None self.assert_images_similar(grid) diff --git a/tests/test_contrib/test_classifier/test_boundaries.py b/tests/test_contrib/test_classifier/test_boundaries.py index f901a1491..933fbcfff 100644 --- a/tests/test_contrib/test_classifier/test_boundaries.py +++ b/tests/test_contrib/test_classifier/test_boundaries.py @@ -79,25 +79,7 @@ def test_decision_boundaries(self): """ model = neighbors.KNeighborsClassifier(3) viz = DecisionViz(model) - viz.fit_draw_poof(X_two_cols, y=y) - - def test_deprecated(self): - """ - Assert the DecisionViz class issues deprecation warning - """ - with pytest.deprecated_call(): - model = neighbors.KNeighborsClassifier(3) - DecisionViz(model) - - def test_deprecated_message(self): - """ - Test the deprecation warning message - """ - with pytest.warns( - DeprecationWarning, match="Will be moved to yellowbrick.contrib in v0.8" - ): - model = neighbors.KNeighborsClassifier(3) - DecisionViz(model) + viz.fit_draw_show(X_two_cols, y=y) def test_init(self): """ @@ -316,9 +298,9 @@ def test_fit_draw(self): viz.fit.assert_called_once_with(X_two_cols, y) viz.draw.assert_called_once_with(X_two_cols, y) - def test_fit_draw_poof(self): + def test_fit_draw_show(self): """ - Test fit draw poof shortcut + Test fit draw show shortcut """ model = neighbors.KNeighborsClassifier(3) viz = DecisionBoundariesVisualizer( @@ -327,13 +309,13 @@ def test_fit_draw_poof(self): viz.fit = mock.Mock() viz.draw = mock.Mock() - viz.poof = mock.Mock() + viz.show = mock.Mock() - viz.fit_draw_poof(X_two_cols, y=y) + viz.fit_draw_show(X_two_cols, y=y) viz.fit.assert_called_once_with(X_two_cols, y) viz.draw.assert_called_once_with(X_two_cols, y) - viz.poof.assert_called_once_with() + viz.show.assert_called_once_with() @pytest.mark.xfail(reason="numpy structured arrays have changed since v1.14") def test_integrated_plot_numpy_named_arrays(self): @@ -366,7 +348,7 @@ def test_integrated_plot_numpy_named_arrays(self): y = np.array([1, 1, 0, 1, 0, 0, 1, 0]) visualizer = DecisionBoundariesVisualizer(model, features=["a", "f"]) - visualizer.fit_draw_poof(X, y=y) + visualizer.fit_draw_show(X, y=y) self.assertEquals(visualizer.features_, ["a", "f"]) self.assert_images_similar(visualizer) @@ -377,7 +359,7 @@ def test_integrated_scatter_numpy_arrays_no_names(self): model = neighbors.KNeighborsClassifier(3) visualizer = DecisionBoundariesVisualizer(model, features=[1, 2]) - visualizer.fit_draw_poof(X, y) + visualizer.fit_draw_show(X, y) assert visualizer.features_ == [1, 2] @pytest.mark.xfail(sys.platform == "win32", reason="images not close on windows") @@ -395,7 +377,7 @@ def test_real_data_set_viz(self): y = data.target visualizer = DecisionBoundariesVisualizer(model) - visualizer.fit_draw_poof(X, y) + visualizer.fit_draw_show(X, y) self.assert_images_similar(visualizer) @pytest.mark.skipif(pd is None, reason="test requires pandas") diff --git a/tests/test_contrib/test_scatter.py b/tests/test_contrib/test_scatter.py index 28c15b8eb..4cf81302c 100644 --- a/tests/test_contrib/test_scatter.py +++ b/tests/test_contrib/test_scatter.py @@ -88,7 +88,7 @@ def test_scatter_no_features(self): """ X_two_cols = self.X[:, :2] visualizer = ScatterViz() - visualizer.fit_transform_poof(X_two_cols, self.y) + visualizer.fit_transform_show(X_two_cols, self.y) assert visualizer.features_ == ["Feature One", "Feature Two"] def test_scatter_only_two_features_allowed_init(self): @@ -134,7 +134,7 @@ def test_integrated_scatter(self): # Test the visualizer features = ["temperature", "relative humidity"] visualizer = ScatterViz(features=features) - visualizer.fit_transform_poof(X[:, :2], y) + visualizer.fit_transform_show(X[:, :2], y) def test_alpha_param(self): """ @@ -181,7 +181,7 @@ def test_integrated_scatter_with_pandas(self): # Test the visualizer features = ["temperature", "relative humidity"] visualizer = ScatterViz(features=features) - visualizer.fit_transform_poof(X, y) + visualizer.fit_transform_show(X, y) @pytest.mark.xfail(reason="numpy structured arrays have changed since v1.14") def test_integrated_scatter_numpy_named_arrays(self): @@ -197,7 +197,7 @@ def test_integrated_scatter_numpy_named_arrays(self): X_named = self.X.astype(dt, casting="unsafe") visualizer = ScatterViz(features=["one", "two"]) - visualizer.fit_transform_poof(X_named, self.y) + visualizer.fit_transform_show(X_named, self.y) assert visualizer.features_ == ["one", "two"] def test_integrated_scatter_numpy_arrays_no_names(self): @@ -205,7 +205,7 @@ def test_integrated_scatter_numpy_arrays_no_names(self): Test scaterviz on regular numpy arrays """ visualizer = ScatterViz(features=[1, 2]) - visualizer.fit_transform_poof(self.X, self.y) + visualizer.fit_transform_show(self.X, self.y) assert visualizer.features_ == [1, 2] def test_scatter_image(self): diff --git a/tests/test_features/test_base.py b/tests/test_features/test_base.py index f25abcebb..d732811e9 100644 --- a/tests/test_features/test_base.py +++ b/tests/test_features/test_base.py @@ -100,9 +100,9 @@ def test_transform_returns_unmodified(self): visualizer = FeatureVisualizer().fit(X, y) assert visualizer.transform(X, y) is X - def test_fit_transform_poof(self): + def test_fit_transform_show(self): """ - Test the fit/transform/poof quick method + Test the fit/transform/show quick method """ class MockFeatureVisaulizer(FeatureVisualizer): @@ -111,13 +111,13 @@ class MockFeatureVisaulizer(FeatureVisualizer): viz = MockFeatureVisaulizer() viz.fit = Mock(return_value=viz) viz.transform = Mock(return_value="a") - viz.poof = Mock() + viz.show = Mock() X, y = self.discrete - assert viz.fit_transform_poof(X, y, outpath="a.png", clear_figure=True) == "a" + assert viz.fit_transform_show(X, y, outpath="a.png", clear_figure=True) == "a" assert viz.fit.called_once_with(X, y) assert viz.transform.called_once_with(X, y) - assert viz.poof.called_once_with(outpath="a.png", clear_figure=True) + assert viz.show.called_once_with(outpath="a.png", clear_figure=True) ########################################################################## diff --git a/tests/test_features/test_radviz.py b/tests/test_features/test_radviz.py index 0513ca254..9a91d313a 100644 --- a/tests/test_features/test_radviz.py +++ b/tests/test_features/test_radviz.py @@ -138,7 +138,7 @@ def test_integrated_radviz_with_pandas(self): # Test the visualizer visualizer = RadViz() - visualizer.fit_transform_poof(X, y) + visualizer.fit_transform_show(X, y) self.assert_images_similar(visualizer, tol=0.1) @pytest.mark.xfail(sys.platform == "win32", reason="images not close on windows") @@ -154,7 +154,7 @@ def test_integrated_radviz_with_numpy(self): # Test the visualizer visualizer = RadViz() - visualizer.fit_transform_poof(X, y) + visualizer.fit_transform_show(X, y) self.assert_images_similar(visualizer, tol=0.1) @pytest.mark.xfail(sys.platform == "win32", reason="images not close on windows") @@ -181,7 +181,7 @@ def test_integrated_radviz_pandas_classes_features(self): # Test the visualizer visualizer = RadViz(features=features, classes=classes) - visualizer.fit_transform_poof(X, y) + visualizer.fit_transform_show(X, y) self.assert_images_similar(visualizer, tol=0.1) @pytest.mark.xfail(sys.platform == "win32", reason="images not close on windows") @@ -207,5 +207,5 @@ def test_integrated_radviz_numpy_classes_features(self): # Test the visualizer visualizer = RadViz(features=features, classes=classes) - visualizer.fit_transform_poof(X, y) + visualizer.fit_transform_show(X, y) self.assert_images_similar(visualizer, tol=0.1) diff --git a/tests/test_pipeline.py b/tests/test_pipeline.py index b642f795a..0f1c2c5dd 100644 --- a/tests/test_pipeline.py +++ b/tests/test_pipeline.py @@ -157,9 +157,9 @@ def test_visual_steps_property(self): assert "d" in pipeline.visual_steps assert "e" not in pipeline.visual_steps - def test_pipeline_poof(self): + def test_pipeline_show(self): """ - Test the poof call against the VisualPipeline + Test the show call against the VisualPipeline """ pipeline = VisualPipeline( @@ -172,13 +172,13 @@ def test_pipeline_poof(self): ] ) - pipeline.poof() - pipeline.steps[1][1].poof.assert_called_once_with(outpath=None) - pipeline.steps[3][1].poof.assert_called_once_with(outpath=None) + pipeline.show() + pipeline.steps[1][1].show.assert_called_once_with(outpath=None) + pipeline.steps[3][1].show.assert_called_once_with(outpath=None) - def test_pipeline_savefig_poof(self): + def test_pipeline_savefig_show(self): """ - Test the poof call with an outdir to save all the figures + Test the show call with an outdir to save all the figures """ pipeline = VisualPipeline( [ @@ -193,21 +193,21 @@ def test_pipeline_savefig_poof(self): # Must use path joining for Windows compatibility tmpdir = os.path.join("tmp", "figures") - pipeline.poof(outdir=tmpdir) - pipeline.steps[1][1].poof.assert_called_once_with( + pipeline.show(outdir=tmpdir) + pipeline.steps[1][1].show.assert_called_once_with( outpath=os.path.join(tmpdir, "b.pdf") ) - pipeline.steps[3][1].poof.assert_called_once_with( + pipeline.steps[3][1].show.assert_called_once_with( outpath=os.path.join(tmpdir, "d.pdf") ) - pipeline.steps[4][1].poof.assert_called_once_with( + pipeline.steps[4][1].show.assert_called_once_with( outpath=os.path.join(tmpdir, "e.pdf") ) @pytest.mark.skip(reason="need to find a way for fit to return self in mocks") - def test_fit_transform_poof_and_draw_calls(self): + def test_fit_transform_show_and_draw_calls(self): """ - Test calling fit, transform, and poof on the pipeline + Test calling fit, transform, and show on the pipeline """ pipeline = VisualPipeline( @@ -234,8 +234,8 @@ def test_fit_transform_poof_and_draw_calls(self): continue step.transform.assert_called_once_with(X) - pipeline.poof() + pipeline.show() for name, step in pipeline.named_steps.items(): if name in {"a", "c", "e"}: continue - step.poof.assert_called_once_with(outpath=None) + step.show.assert_called_once_with(outpath=None) diff --git a/tests/test_utils/test_wrapper.py b/tests/test_utils/test_wrapper.py index 83384fc7b..f6cbf9162 100644 --- a/tests/test_utils/test_wrapper.py +++ b/tests/test_utils/test_wrapper.py @@ -35,7 +35,7 @@ def __init__(self, ax=None, **kwargs): self.ax = ax self.fit = mock.MagicMock() self.finalize = mock.MagicMock() - self.poof = mock.MagicMock() + self.show = mock.MagicMock() self.set_title = mock.MagicMock() @property @@ -92,13 +92,13 @@ def test_super_methods(self): # Assert that visualizer methods are called obj.fit() obj.finalize() - obj.poof() + obj.show() obj.set_title() assert obj.ax is None obj.fit.assert_called_once_with() obj.finalize.assert_called_once_with() - obj.poof.assert_called_once_with() + obj.show.assert_called_once_with() obj.set_title.assert_called_once_with() def test_wrapped_methods(self): diff --git a/yellowbrick/base.py b/yellowbrick/base.py index c329b86db..916487b24 100644 --- a/yellowbrick/base.py +++ b/yellowbrick/base.py @@ -197,18 +197,18 @@ def finalize(self, **kwargs): Notes ----- - The user calls poof and poof calls finalize. Developers should + The user calls show and show calls finalize. Developers should implement visualizer-specific finalization methods like setting titles or axes labels, etc. """ return self.ax - def poof(self, outpath=None, clear_figure=False, **kwargs): + def show(self, outpath=None, clear_figure=False, **kwargs): """ - Poof makes the magic happen and a visualizer appear! You can pass in - a path to save the figure to disk with various backends, or you can - call it with no arguments to show the figure either in a notebook or - in a GUI window that pops up on screen. + Makes the magic happen and a visualizer appear! You can pass in a path to + save the figure to disk with various backends, or you can call it with no + arguments to show the figure either in a notebook or in a GUI window that + pops up on screen. Parameters ---------- @@ -224,7 +224,7 @@ def poof(self, outpath=None, clear_figure=False, **kwargs): Notes ----- - Developers of visualizers don't usually override poof, as it is + Developers of visualizers don't usually override show, as it is primarily called by the user to render the visualization. """ # Ensure that draw has been called @@ -251,6 +251,15 @@ def poof(self, outpath=None, clear_figure=False, **kwargs): # Return ax to ensure display in notebooks return self.ax + def poof(self, *args, **kwargs): + """ + This method is deprecated, please use ``show()`` instead. + """ + warnings.warn( + "this method is deprecated, please use show() instead", DeprecationWarning + ) + return self.show(*args, **kwargs) + ## //////////////////////////////////////////////////////////////////// ## Helper Functions ## //////////////////////////////////////////////////////////////////// @@ -454,7 +463,7 @@ class VisualizerGrid(Visualizer): >>> mv = VisualizerGrid(visualizers, ncols=2) >>> mv.fit(X_train, y_train) >>> mv.score(X_test, y_test) - >>> mv.poof() + >>> mv.show() """ def __init__(self, visualizers=[], nrows=None, ncols=None, axarr=None, **kwargs): @@ -538,7 +547,7 @@ def score(self, X, y): return self - def poof(self, outpath=None, clear_figure=False, **kwargs): + def show(self, outpath=None, clear_figure=False, **kwargs): if self.axarr is None: return @@ -562,5 +571,5 @@ def poof(self, outpath=None, clear_figure=False, **kwargs): if clear_figure: plt.gcf().clear() - # Return Axes array to ensure poof works in notebooks + # Return Axes array to ensure show works in notebooks return self.axarr diff --git a/yellowbrick/classifier/class_prediction_error.py b/yellowbrick/classifier/class_prediction_error.py index 013e05f47..05c1eb3d6 100644 --- a/yellowbrick/classifier/class_prediction_error.py +++ b/yellowbrick/classifier/class_prediction_error.py @@ -208,8 +208,14 @@ def draw(self): def finalize(self, **kwargs): """ - Finalize executes any subclass-specific axes finalization steps. - The user calls poof and poof calls finalize. + Adds a title and axis labels to the visualizer, ensuring that the + y limits zoom the visualization in to the area of interest. Finalize + also calls tight layout to ensure that no parts of the figure are + cut off. + + Notes + ----- + Generally this method is called from show and not directly by the user. """ # Set the title diff --git a/yellowbrick/classifier/classification_report.py b/yellowbrick/classifier/classification_report.py index 7eca50741..91b7f3ea8 100644 --- a/yellowbrick/classifier/classification_report.py +++ b/yellowbrick/classifier/classification_report.py @@ -102,7 +102,7 @@ class ClassificationReport(ClassificationScoreVisualizer): >>> viz = ClassificationReport(LogisticRegression()) >>> viz.fit(X_train, y_train) >>> viz.score(X_test, y_test) - >>> viz.poof() + >>> viz.show() Attributes ---------- @@ -263,13 +263,16 @@ def draw(self): def finalize(self, **kwargs): """ - Finalize executes any subclass-specific axes finalization steps. - The user calls poof and poof calls finalize. + Adds a title and sets the axis labels correctly. Also calls tight layout + to ensure that no parts of the figure are cut off in the final visualization. Parameters ---------- kwargs: generic keyword arguments. + Notes + ----- + Generally this method is called from show and not directly by the user. """ # Set the title of the classifiation report self.set_title("{} Classification Report".format(self.name)) diff --git a/yellowbrick/classifier/confusion_matrix.py b/yellowbrick/classifier/confusion_matrix.py index adb92cacc..6c06c6a68 100644 --- a/yellowbrick/classifier/confusion_matrix.py +++ b/yellowbrick/classifier/confusion_matrix.py @@ -131,7 +131,7 @@ class ConfusionMatrix(ClassificationScoreVisualizer): >>> viz = ConfusionMatrix(LogisticRegression()) >>> viz.fit(X_train, y_train) >>> viz.score(X_test, y_test) - >>> viz.poof() + >>> viz.show() """ def __init__( @@ -320,10 +320,10 @@ def draw(self): # Return the axes being drawn on return self.ax - def poof(self, outpath=None, **kwargs): + def show(self, outpath=None, **kwargs): if outpath is not None: kwargs["bbox_inches"] = kwargs.get("bbox_inches", "tight") - return super(ConfusionMatrix, self).poof(outpath, **kwargs) + return super(ConfusionMatrix, self).show(outpath, **kwargs) def finalize(self, **kwargs): self.set_title("{} Confusion Matrix".format(self.name)) diff --git a/yellowbrick/classifier/prcurve.py b/yellowbrick/classifier/prcurve.py index 8069f834a..96d8a7cbd 100644 --- a/yellowbrick/classifier/prcurve.py +++ b/yellowbrick/classifier/prcurve.py @@ -175,7 +175,7 @@ class PrecisionRecallCurve(ClassificationScoreVisualizer): >>> viz = PrecisionRecallCurve(LinearSVC()) >>> viz.fit(X_train, y_train) >>> viz.score(X_test, y_test) - >>> viz.poof() + >>> viz.show() Notes ----- diff --git a/yellowbrick/classifier/rocauc.py b/yellowbrick/classifier/rocauc.py index 5a61e9702..5c91ac6dd 100644 --- a/yellowbrick/classifier/rocauc.py +++ b/yellowbrick/classifier/rocauc.py @@ -164,7 +164,7 @@ class classification is not defined for binary classification problems >>> oz = ROCAUC(LogisticRegression()) >>> oz.fit(X_train, y_train) >>> oz.score(X_test, y_test) - >>> oz.poof() + >>> oz.show() """ def __init__( @@ -348,13 +348,16 @@ def draw(self): def finalize(self, **kwargs): """ - Finalize executes any subclass-specific axes finalization steps. - The user calls poof and poof calls finalize. + Sets a title and axis labels of the figures and ensures the axis limits + are scaled between the valid ROCAUC score values. Parameters ---------- kwargs: generic keyword arguments. + Notes + ----- + Generally this method is called from show and not directly by the user. """ # Set the title and add the legend self.set_title("ROC Curves for {}".format(self.name)) diff --git a/yellowbrick/classifier/threshold.py b/yellowbrick/classifier/threshold.py index 68c70bf69..040cb06b4 100644 --- a/yellowbrick/classifier/threshold.py +++ b/yellowbrick/classifier/threshold.py @@ -420,12 +420,16 @@ def draw(self): def finalize(self, **kwargs): """ - Finalize executes any subclass-specific axes finalization steps. - The user calls poof and poof calls finalize. + Sets a title and axis labels on the visualizer and ensures that the + axis limits are scaled to valid threshold values. Parameters ---------- kwargs: generic keyword arguments. + + Notes + ----- + Generally this method is called from show and not directly by the user. """ super(DiscriminationThreshold, self).finalize(**kwargs) diff --git a/yellowbrick/cluster/elbow.py b/yellowbrick/cluster/elbow.py index bee510b00..603c16674 100644 --- a/yellowbrick/cluster/elbow.py +++ b/yellowbrick/cluster/elbow.py @@ -208,7 +208,7 @@ class KElbowVisualizer(ClusteringScoreVisualizer): >>> from sklearn.cluster import KMeans >>> model = KElbowVisualizer(KMeans(), k=10) >>> model.fit(X) - >>> model.poof() + >>> model.show() Notes ----- diff --git a/yellowbrick/cluster/silhouette.py b/yellowbrick/cluster/silhouette.py index d37f82a69..ae956ea8c 100644 --- a/yellowbrick/cluster/silhouette.py +++ b/yellowbrick/cluster/silhouette.py @@ -109,7 +109,7 @@ class SilhouetteVisualizer(ClusteringScoreVisualizer): >>> from sklearn.cluster import KMeans >>> model = SilhouetteVisualizer(KMeans(10)) >>> model.fit(X) - >>> model.poof() + >>> model.show() """ def __init__(self, model, ax=None, colors=None, is_fitted="auto", **kwargs): diff --git a/yellowbrick/contrib/classifier/boundaries.py b/yellowbrick/contrib/classifier/boundaries.py index 45047f712..6f09a46b4 100644 --- a/yellowbrick/contrib/classifier/boundaries.py +++ b/yellowbrick/contrib/classifier/boundaries.py @@ -14,8 +14,6 @@ from collections import OrderedDict -from sklearn.utils.deprecation import deprecated - from matplotlib.patches import Patch from matplotlib.colors import ListedColormap @@ -32,7 +30,6 @@ ########################################################################## -@deprecated("Will be moved to yellowbrick.contrib in v0.8") def decisionviz( model, X, @@ -159,7 +156,7 @@ def decisionviz( **kwargs ) - # Fit, draw and poof the visualizer + # Fit, draw and finalize the visualizer visualizer.fit(X, y) visualizer.finalize() @@ -172,7 +169,6 @@ def decisionviz( ########################################################################## -@deprecated("Will be moved to yellowbrick.contrib in v0.8") class DecisionBoundariesVisualizer(ClassificationScoreVisualizer): """ DecisionBoundariesVisualizer is a bivariate data visualization algorithm @@ -487,13 +483,15 @@ def draw(self, X, y=None, **kwargs): def finalize(self, **kwargs): """ - Finalize executes any subclass-specific axes finalization steps. - The user calls poof and poof calls finalize. + Sets the title and axis labels and adds a legend. Parameters ---------- kwargs: generic keyword arguments. + Notes + ----- + Generally this method is called from show and not directly by the user. """ # Divide out the two features feature_one, feature_two = self.features_ @@ -512,14 +510,14 @@ def fit_draw(self, X, y=None, **kwargs): self.fit(X, y, **kwargs) self.draw(X, y, **kwargs) - def fit_draw_poof(self, X, y=None, **kwargs): + def fit_draw_show(self, X, y=None, **kwargs): """ Fits a transformer to X and y then returns visualization of features or fitted model. - Then calls poof to finalize. + Then calls show to finalize. """ self.fit_draw(X, y, **kwargs) - self.poof(**kwargs) + return self.show(**kwargs) DecisionViz = DecisionBoundariesVisualizer diff --git a/yellowbrick/contrib/missing/bar.py b/yellowbrick/contrib/missing/bar.py index 99e0b5c72..d924f24a4 100644 --- a/yellowbrick/contrib/missing/bar.py +++ b/yellowbrick/contrib/missing/bar.py @@ -74,7 +74,7 @@ class MissingValuesBar(MissingDataVisualizer): >>> from yellowbrick.contrib.missing import MissingValuesBar >>> visualizer = MissingValuesBar() >>> visualizer.fit(X, y=y) - >>> visualizer.poof() + >>> visualizer.show() """ def __init__(self, width=0.5, color=None, colors=None, classes=None, **kwargs): @@ -183,13 +183,16 @@ def draw_stacked_bar(self, nan_col_counts): def finalize(self, **kwargs): """ - Finalize executes any subclass-specific axes finalization steps. - The user calls poof and poof calls finalize. + Sets a title and x-axis labels and adds a legend. Also ensures that the + y tick values are correctly set to feature names. Parameters ---------- kwargs: generic keyword arguments. + Notes + ----- + Generally this method is called from show and not directly by the user. """ # Set the title self.set_title("Count of Missing Values by Column") @@ -262,7 +265,7 @@ def missing_bar(X, y=None, ax=None, classes=None, width=0.5, color="black", **kw # Fit and transform the visualizer (calls draw) visualizer.fit(X, y) - visualizer.poof() + visualizer.show() # Return the axes object on the visualizer return visualizer.ax diff --git a/yellowbrick/contrib/missing/dispersion.py b/yellowbrick/contrib/missing/dispersion.py index e6f089057..812fbf69c 100644 --- a/yellowbrick/contrib/missing/dispersion.py +++ b/yellowbrick/contrib/missing/dispersion.py @@ -67,7 +67,7 @@ class MissingValuesDispersion(MissingDataVisualizer): >>> from yellowbrick.contrib.missing import MissingValuesDispersion >>> visualizer = MissingValuesDispersion() >>> visualizer.fit(X, y=y) - >>> visualizer.poof() + >>> visualizer.show() """ def __init__(self, alpha=0.5, marker="|", classes=None, **kwargs): @@ -153,13 +153,16 @@ def draw_multi_dispersion_chart(self, nan_locs): def finalize(self, **kwargs): """ - Finalize executes any subclass-specific axes finalization steps. - The user calls poof and poof calls finalize. + Sets the title and x-axis label and adds a legend. Also ensures that + the y tick labels are set to the feature names. Parameters ---------- kwargs: generic keyword arguments. + Notes + ----- + Generally this method is called from show and not directly by the user. """ # Set the title self.set_title("Dispersion of Missing Values by Feature") @@ -226,7 +229,7 @@ def missing_dispersion( # Fit and transform the visualizer (calls draw) visualizer.fit(X, y) - visualizer.poof() + visualizer.show() # Return the axes object on the visualizer return visualizer.ax diff --git a/yellowbrick/contrib/scatter.py b/yellowbrick/contrib/scatter.py index 0d062184c..d38004c29 100644 --- a/yellowbrick/contrib/scatter.py +++ b/yellowbrick/contrib/scatter.py @@ -331,13 +331,16 @@ def draw(self, X, y, **kwargs): def finalize(self, **kwargs): """ - Finalize executes any subclass-specific axes finalization steps. - The user calls poof and poof calls finalize. + Adds a title and a legend and ensures that the axis labels are set as + the feature names being visualized. Parameters ---------- kwargs: generic keyword arguments. + Notes + ----- + Generally this method is called from show and not directly by the user. """ # Divide out the two features feature_one, feature_two = self.features_ diff --git a/yellowbrick/features/base.py b/yellowbrick/features/base.py index e65344277..4bd027e70 100644 --- a/yellowbrick/features/base.py +++ b/yellowbrick/features/base.py @@ -93,7 +93,7 @@ def transform(self, X, y=None): """ return X - def fit_transform_poof(self, X, y=None, **kwargs): + def fit_transform_show(self, X, y=None, **kwargs): """Fit, transform, then visualize data in one step. A helper method similar to ``fit_transform`` that allows you to fit, @@ -109,7 +109,7 @@ def fit_transform_poof(self, X, y=None, **kwargs): Dependent target dataset optionally used for training. kwargs : dict, optional - Keyword arguments to pass to the ``poof()`` method. + Keyword arguments to pass to the ``show()`` method. Returns ------- @@ -117,7 +117,7 @@ def fit_transform_poof(self, X, y=None, **kwargs): The transformed dataset X prime. """ Xp = self.fit_transform(X, y) - self.poof(**kwargs) + self.show(**kwargs) return Xp diff --git a/yellowbrick/features/decomposition.py b/yellowbrick/features/decomposition.py index c8cbb4448..5a4971911 100644 --- a/yellowbrick/features/decomposition.py +++ b/yellowbrick/features/decomposition.py @@ -119,7 +119,7 @@ class ExplainedVariance(FeatureVisualizer): >>> visualizer = ExplainedVariance() >>> visualizer.fit(X) >>> visualizer.transform(X) - >>> visualizer.poof() + >>> visualizer.show() """ diff --git a/yellowbrick/features/jointplot.py b/yellowbrick/features/jointplot.py index ab4f4732c..bebacc557 100644 --- a/yellowbrick/features/jointplot.py +++ b/yellowbrick/features/jointplot.py @@ -122,7 +122,7 @@ class JointPlot(FeatureVisualizer): >>> viz = JointPlot(columns=["temp", "humidity"]) >>> viz.fit(X, y) - >>> viz.poof() + >>> viz.show() """ # TODO: should we couple more closely with Rank2D? diff --git a/yellowbrick/features/manifold.py b/yellowbrick/features/manifold.py index 80aadcab1..99eeeea32 100644 --- a/yellowbrick/features/manifold.py +++ b/yellowbrick/features/manifold.py @@ -199,7 +199,7 @@ class Manifold(ProjectionVisualizer): >>> viz = Manifold(manifold='isomap', target='discrete') >>> viz.fit_transform(X, y) - >>> viz.poof() + >>> viz.show() Notes ----- diff --git a/yellowbrick/features/pca.py b/yellowbrick/features/pca.py index 59b6ee5b6..44db15b98 100644 --- a/yellowbrick/features/pca.py +++ b/yellowbrick/features/pca.py @@ -144,7 +144,7 @@ class PCA(ProjectionVisualizer): >>> y = iris.target >>> visualizer = PCA() >>> visualizer.fit_transform(X, y) - >>> visualizer.poof() + >>> visualizer.show() """ diff --git a/yellowbrick/features/pcoords.py b/yellowbrick/features/pcoords.py index 8876e00b3..18d620b9a 100644 --- a/yellowbrick/features/pcoords.py +++ b/yellowbrick/features/pcoords.py @@ -253,7 +253,7 @@ class ParallelCoordinates(DataVisualizer): >>> visualizer = ParallelCoordinates() >>> visualizer.fit(X, y) >>> visualizer.transform(X) - >>> visualizer.poof() + >>> visualizer.show() Notes ----- @@ -497,13 +497,17 @@ def draw_classes(self, X, y, **kwargs): def finalize(self, **kwargs): """ - Finalize executes any subclass-specific axes finalization steps. - The user calls poof and poof calls finalize. + Performs the final rendering for the multi-axis visualization, including + setting and rendering the vertical axes each instance is plotted on. Adds + a title, a legend, and manages the grid. Parameters ---------- kwargs: generic keyword arguments. + Notes + ----- + Generally this method is called from show and not directly by the user. """ # Set the title self.set_title( diff --git a/yellowbrick/features/radviz.py b/yellowbrick/features/radviz.py index ddb871a47..eef62dfd3 100644 --- a/yellowbrick/features/radviz.py +++ b/yellowbrick/features/radviz.py @@ -161,7 +161,7 @@ class RadialVisualizer(DataVisualizer): >>> visualizer = RadViz() >>> visualizer.fit(X, y) >>> visualizer.transform(X) - >>> visualizer.poof() + >>> visualizer.show() Attributes ---------- @@ -351,13 +351,16 @@ def draw(self, X, y, **kwargs): def finalize(self, **kwargs): """ - Finalize executes any subclass-specific axes finalization steps. - The user calls poof and poof calls finalize. + Sets the title and adds a legend. Removes the ticks from the graph to + make a cleaner visualization. Parameters ---------- kwargs: generic keyword arguments. + Notes + ----- + Generally this method is called from show and not directly by the user. """ # Set the title self.set_title("RadViz for {} Features".format(len(self.features_))) diff --git a/yellowbrick/features/rankd.py b/yellowbrick/features/rankd.py index 229135632..81c655d1f 100644 --- a/yellowbrick/features/rankd.py +++ b/yellowbrick/features/rankd.py @@ -104,7 +104,7 @@ class RankDBase(MultiFeatureVisualizer): >>> visualizer = Rank2D() >>> visualizer.fit(X, y) >>> visualizer.transform(X) - >>> visualizer.poof() + >>> visualizer.show() Notes ----- @@ -196,14 +196,15 @@ def rank(self, X, algorithm=None): def finalize(self, **kwargs): """ - Finalize executes any subclass-specific axes finalization steps. - The user calls poof and poof calls finalize. + Sets a title on the RankD plot. Parameters ---------- - kwargs: dict - generic keyword arguments + kwargs: generic keyword arguments. + Notes + ----- + Generally this method is called from show and not directly by the user. """ # There is a known bug in matplotlib 3.1.1 that affects RankD plots # See #912 and #914 for details. @@ -272,7 +273,7 @@ class Rank1D(RankDBase): >>> visualizer = Rank1D() >>> visualizer.fit(X, y) >>> visualizer.transform(X) - >>> visualizer.poof() + >>> visualizer.show() """ ranking_methods = {"shapiro": lambda X: np.array([shapiro(x)[0] for x in X.T])} @@ -391,7 +392,7 @@ class Rank2D(RankDBase): >>> visualizer = Rank2D() >>> visualizer.fit(X, y) >>> visualizer.transform(X) - >>> visualizer.poof() + >>> visualizer.show() Notes ----- diff --git a/yellowbrick/gridsearch/pcolor.py b/yellowbrick/gridsearch/pcolor.py index 39efe7177..eabd1639d 100644 --- a/yellowbrick/gridsearch/pcolor.py +++ b/yellowbrick/gridsearch/pcolor.py @@ -125,7 +125,7 @@ class GridSearchColorPlot(GridSearchVisualizer): {'kernel': ['rbf', 'linear'], 'C': [1, 10]}) >>> model = GridSearchColorPlot(gridsearch, x_param='kernel', y_param='C') >>> model.fit(X) - >>> model.poof() + >>> model.show() """ def __init__( diff --git a/yellowbrick/model_selection/cross_validation.py b/yellowbrick/model_selection/cross_validation.py index 09d1b3a0d..f471058b8 100644 --- a/yellowbrick/model_selection/cross_validation.py +++ b/yellowbrick/model_selection/cross_validation.py @@ -93,7 +93,7 @@ class CVScores(ModelVisualizer): >>> y = iris.target >>> visualizer = CVScores(model=clf, cv=5, scoring='f1_macro') >>> visualizer.fit(X,y) - >>> visualizer.poof() + >>> visualizer.show() Notes ----- @@ -257,8 +257,8 @@ def cv_scores(model, X, y, ax=None, cv=None, scoring=None, color=None, **kwargs) # Initialize the visualizer visualizer = CVScores(model, ax=ax, cv=cv, scoring=scoring, color=None) - # Fit and poof the visualizer + # Fit and show the visualizer visualizer.fit(X, y) - visualizer.poof(**kwargs) + visualizer.show(**kwargs) return visualizer diff --git a/yellowbrick/model_selection/importances.py b/yellowbrick/model_selection/importances.py index f0b8908d0..aa0da6067 100644 --- a/yellowbrick/model_selection/importances.py +++ b/yellowbrick/model_selection/importances.py @@ -114,7 +114,7 @@ class FeatureImportances(ModelVisualizer): >>> from sklearn.ensemble import GradientBoostingClassifier >>> visualizer = FeatureImportances(GradientBoostingClassifier()) >>> visualizer.fit(X, y) - >>> visualizer.poof() + >>> visualizer.show() """ def __init__( diff --git a/yellowbrick/model_selection/learning_curve.py b/yellowbrick/model_selection/learning_curve.py index 07ca55162..1f432dfac 100644 --- a/yellowbrick/model_selection/learning_curve.py +++ b/yellowbrick/model_selection/learning_curve.py @@ -154,7 +154,7 @@ class LearningCurve(ModelVisualizer): >>> from sklearn.naive_bayes import GaussianNB >>> model = LearningCurve(GaussianNB()) >>> model.fit(X, y) - >>> model.poof() + >>> model.show() Notes ----- @@ -411,7 +411,7 @@ def learning_curve( kwargs : dict Keyword arguments that are passed to the base class and may influence the visualization as defined in other Visualizers. These arguments are - also passed to the `poof()` method, e.g. can pass a path to save the + also passed to the `show()` method, e.g. can pass a path to save the figure to. Returns @@ -434,7 +434,7 @@ def learning_curve( exploit_incremental_learning=exploit_incremental_learning, ) - # Fit and poof the visualizer + # Fit and show the visualizer oz.fit(X, y) - oz.poof(**kwargs) + oz.show(**kwargs) return oz diff --git a/yellowbrick/model_selection/rfecv.py b/yellowbrick/model_selection/rfecv.py index 3d75ff951..f98e65a2c 100644 --- a/yellowbrick/model_selection/rfecv.py +++ b/yellowbrick/model_selection/rfecv.py @@ -321,7 +321,7 @@ def rfecv(model, X, y, ax=None, step=1, groups=None, cv=None, scoring=None, **kw kwargs : dict Keyword arguments that are passed to the base class and may influence the visualization as defined in other Visualizers. These arguments are - also passed to the `poof()` method, e.g. can pass a path to save the + also passed to the `show()` method, e.g. can pass a path to save the figure to. Returns @@ -332,8 +332,8 @@ def rfecv(model, X, y, ax=None, step=1, groups=None, cv=None, scoring=None, **kw # Initialize the visualizer oz = RFECV(model, ax=ax, step=step, groups=groups, cv=cv, scoring=scoring) - # Fit and poof the visualizer + # Fit and show the visualizer oz.fit(X, y) - oz.poof(**kwargs) + oz.show(**kwargs) return oz diff --git a/yellowbrick/model_selection/validation_curve.py b/yellowbrick/model_selection/validation_curve.py index f7b012f23..3d9c47ad8 100644 --- a/yellowbrick/model_selection/validation_curve.py +++ b/yellowbrick/model_selection/validation_curve.py @@ -136,7 +136,7 @@ class ValidationCurve(ModelVisualizer): >>> pr = np.logspace(-6,-1,5) >>> model = ValidationCurve(SVC(), param_name="gamma", param_range=pr) >>> model.fit(X, y) - >>> model.poof() + >>> model.show() Notes ----- @@ -379,7 +379,7 @@ def validation_curve( kwargs : dict Keyword arguments that are passed to the base class and may influence the visualization as defined in other Visualizers. These arguments are - also passed to the `poof()` method, e.g. can pass a path to save the + also passed to the ``show()`` method, e.g. can pass a path to save the figure to. Returns @@ -402,7 +402,7 @@ def validation_curve( pre_dispatch=pre_dispatch, ) - # Fit and poof the visualizer + # Fit and show the visualizer oz.fit(X, y) - oz.poof(**kwargs) + oz.show(**kwargs) return oz diff --git a/yellowbrick/pipeline.py b/yellowbrick/pipeline.py index 481cc8845..c5c2540ba 100644 --- a/yellowbrick/pipeline.py +++ b/yellowbrick/pipeline.py @@ -37,10 +37,10 @@ class VisualPipeline(Pipeline): must implement fit and transform methods. The final estimator only needs to implement fit. - Any step that implements draw or poof methods can be called sequentially + Any step that implements draw or show methods can be called sequentially directly from the VisualPipeline, allowing multiple visual diagnostics to be generated, displayed, and saved on demand. - If draw or poof is not called, the visual pipeline should be equivalent to + If draw or show is not called, the visual pipeline should be equivalent to the simple pipeline to ensure no reduction in performance. The purpose of the pipeline is to assemble several steps that can be @@ -71,7 +71,7 @@ class VisualPipeline(Pipeline): def visual_steps(self): return dict(step for step in self.steps if isinstance(step[1], Visualizer)) - def poof(self, outdir=None, ext=".pdf", **kwargs): + def show(self, outdir=None, ext=".pdf", **kwargs): """ A single entry point to rendering all visualizations in the visual pipeline. The rendering for the output depends on the backend context, @@ -88,7 +88,7 @@ def poof(self, outdir=None, ext=".pdf", **kwargs): The extension of the file to save the visualization to. kwargs : dict - Keyword arguments to pass to the ``poof()`` method of all steps. + Keyword arguments to pass to the ``show()`` method of all steps. """ axes = [] for name, step in self.visual_steps.items(): @@ -97,15 +97,16 @@ def poof(self, outdir=None, ext=".pdf", **kwargs): else: outpath = None - ax = step.poof(outpath=outpath, **kwargs) + ax = step.show(outpath=outpath, **kwargs) axes.append(ax) # Return axes array to ensure figures are shown in notebook return axes - def fit_transform_poof(self, X, y=None, outpath=None, **kwargs): + def fit_transform_show(self, X, y=None, outpath=None, **kwargs): """ - Fit the model and transforms and then call poof. + Fit the model and transforms and then call show. """ - self.fit_transform(X, y, **kwargs) - self.poof(outpath, **kwargs) + Xp = self.fit_transform(X, y, **kwargs) + self.show(outpath, **kwargs) + return Xp diff --git a/yellowbrick/regressor/alphas.py b/yellowbrick/regressor/alphas.py index 77a2f7cf0..bbc298cbf 100644 --- a/yellowbrick/regressor/alphas.py +++ b/yellowbrick/regressor/alphas.py @@ -93,7 +93,7 @@ class AlphaSelection(RegressionScoreVisualizer): >>> from sklearn.linear_model import LassoCV >>> model = AlphaSelection(LassoCV()) >>> model.fit(X, y) - >>> model.poof() + >>> model.show() Notes ----- @@ -289,7 +289,7 @@ class ManualAlphaSelection(AlphaSelection): ... ) ... >>> model.fit(X, y) - >>> model.poof() + >>> model.show() Notes ----- diff --git a/yellowbrick/regressor/residuals.py b/yellowbrick/regressor/residuals.py index beb0de665..ac9dd2f5c 100644 --- a/yellowbrick/regressor/residuals.py +++ b/yellowbrick/regressor/residuals.py @@ -119,7 +119,7 @@ class PredictionError(RegressionScoreVisualizer): >>> model = PredictionError(Lasso()) >>> model.fit(X_train, y_train) >>> model.score(X_test, y_test) - >>> model.poof() + >>> model.show() Notes ----- @@ -229,12 +229,17 @@ def draw(self, y, y_pred): def finalize(self, **kwargs): """ - Finalize executes any subclass-specific axes finalization steps. - The user calls poof and poof calls finalize. + Finalizes the figure by ensuring the aspect ratio is correct and adding + the identity line for comparison. Also adds a title, axis labels, and + the legend. Parameters ---------- kwargs: generic keyword arguments. + + Notes + ----- + Generally this method is called from show and not directly by the user. """ # Set the title on the plot self.set_title("Prediction Error for {}".format(self.name)) @@ -450,7 +455,7 @@ class ResidualsPlot(RegressionScoreVisualizer): >>> model = ResidualsPlot(Ridge()) >>> model.fit(X_train, y_train) >>> model.score(X_test, y_test) - >>> model.poof() + >>> model.show() Notes ----- @@ -639,12 +644,16 @@ def draw(self, y_pred, residuals, train=False, **kwargs): def finalize(self, **kwargs): """ - Finalize executes any subclass-specific axes finalization steps. - The user calls poof and poof calls finalize. + Prepares the plot for renderig by adding a title, legend, and axis labels. + Also draws a line at the zero residuals to show the baseline. Parameters ---------- kwargs: generic keyword arguments. + + Notes + ----- + Generally this method is called from show and not directly by the user. """ # Add the title to the plot self.set_title("Residuals for {} Model".format(self.name)) diff --git a/yellowbrick/target/binning.py b/yellowbrick/target/binning.py index 3dcd60d05..9ea204be8 100644 --- a/yellowbrick/target/binning.py +++ b/yellowbrick/target/binning.py @@ -57,7 +57,7 @@ class BalancedBinningReference(TargetVisualizer): -------- >>> visualizer = BalancedBinningReference() >>> visualizer.fit(y) - >>> visualizer.poof() + >>> visualizer.show() Notes @@ -123,13 +123,15 @@ def fit(self, y, **kwargs): def finalize(self, **kwargs): """ - Finalize executes any subclass-specific axes finalization steps. - The user calls poof and poof calls finalize. + Adds the x-axis label and manages the tick labels to ensure they're visible. Parameters ---------- kwargs: generic keyword arguments. + Notes + ----- + Generally this method is called from show and not directly by the user. """ self.ax.set_xlabel(self.target) for tk in self.ax.get_xticklabels(): @@ -177,8 +179,8 @@ def balanced_binning_reference(y, ax=None, target="y", bins=4, **kwargs): # Initialize the visualizer visualizer = BalancedBinningReference(ax=ax, bins=bins, target=target, **kwargs) - # Fit and poof the visualizer + # Fit and show the visualizer visualizer.fit(y) - visualizer.poof() + visualizer.show() return visualizer diff --git a/yellowbrick/target/class_balance.py b/yellowbrick/target/class_balance.py index 4927bd3eb..d4ef5edcc 100644 --- a/yellowbrick/target/class_balance.py +++ b/yellowbrick/target/class_balance.py @@ -62,7 +62,7 @@ class ClassBalance(TargetVisualizer): A list of class names for the x-axis if the target is already encoded. Ensure that the labels are ordered lexicographically with respect to the values in the target. A common use case is to pass - LabelEncoder.classes\_ as this parameter. If not specified, the labels + ``LabelEncoder.classes_`` as this parameter. If not specified, the labels in the data will be used. colors: list of strings @@ -89,14 +89,14 @@ class ClassBalance(TargetVisualizer): To simply observe the balance of classes in the target: >>> viz = ClassBalance().fit(y) - >>> viz.poof() + >>> viz.show() To compare the relationship between training and test data: >>> _, _, y_train, y_test = train_test_split(X, y, test_size=0.2) >>> viz = ClassBalance() >>> viz.fit(y_train, y_test) - >>> viz.poof() + >>> viz.show() """ def __init__(self, ax=None, labels=None, colors=None, colormap=None, **kwargs): @@ -209,13 +209,17 @@ def draw(self): def finalize(self, **kwargs): """ - Finalize executes any subclass-specific axes finalization steps. - The user calls poof and poof calls finalize. + Finalizes the figure for drawing by setting a title, the legend, and axis + labels, removing the grid, and making sure the figure is correctly zoomed + into the bar chart. Parameters ---------- kwargs: generic keyword arguments. + Notes + ----- + Generally this method is called from show and not directly by the user. """ # Set the title self.set_title("Class Balance for {:,} Instances".format(self.support_.sum())) @@ -298,7 +302,7 @@ def class_balance( A list of class names for the x-axis if the target is already encoded. Ensure that the labels are ordered lexicographically with respect to the values in the target. A common use case is to pass - LabelEncoder.classes\_ as this parameter. If not specified, the labels + ``LabelEncoder.classes_`` as this parameter. If not specified, the labels in the data will be used. colors: list of strings diff --git a/yellowbrick/target/feature_correlation.py b/yellowbrick/target/feature_correlation.py index 65a0b6cda..04596a025 100644 --- a/yellowbrick/target/feature_correlation.py +++ b/yellowbrick/target/feature_correlation.py @@ -109,7 +109,7 @@ class FeatureCorrelation(TargetVisualizer): >>> viz = FeatureCorrelation() >>> viz.fit(X, y) - >>> viz.poof() + >>> viz.show() """ def __init__( diff --git a/yellowbrick/text/base.py b/yellowbrick/text/base.py index 8306b8085..39cff2eb9 100644 --- a/yellowbrick/text/base.py +++ b/yellowbrick/text/base.py @@ -98,12 +98,12 @@ def transform(self, X): """ return X - def fit_transform_poof(self, X, y=None, **kwargs): + def fit_transform_show(self, X, y=None, **kwargs): """ Fit to data, transform it, then visualize it. Fits the text visualizer to X and y with optional parameters by - passing in all of kwargs, then calls poof with the same kwargs. + passing in all of kwargs, then calls show with the same kwargs. This method must return the result of the transform method. Parameters @@ -115,13 +115,13 @@ def fit_transform_poof(self, X, y=None, **kwargs): An array or series of target or class values kwargs : dict - Pass generic arguments to the drawing method + Pass generic arguments to the show method Returns ------- X : numpy array This method must return a numpy array with the same shape as X. """ - Xp = self.fit_transform(X, y, **kwargs) - self.poof(**kwargs) + Xp = self.fit(X, y, **kwargs).transform(X) + self.show(**kwargs) return Xp diff --git a/yellowbrick/text/dispersion.py b/yellowbrick/text/dispersion.py index f6eef357b..d36cafe20 100644 --- a/yellowbrick/text/dispersion.py +++ b/yellowbrick/text/dispersion.py @@ -247,11 +247,16 @@ def draw(self, points, target=None, **kwargs): def finalize(self, **kwargs): """ - The finalize method executes any subclass-specific axes - finalization steps. The user calls poof & poof calls finalize. + Prepares the figure for rendering by adding a title, axis labels, and + managing the limits of the text labels. Adds a legend outside of the plot. + Parameters ---------- kwargs: generic keyword arguments. + + Notes + ----- + Generally this method is called from show and not directly by the user. """ self.ax.set_ylim(-1, len(self.indexed_words_)) diff --git a/yellowbrick/text/freqdist.py b/yellowbrick/text/freqdist.py index 186ea497b..4c75b45d5 100644 --- a/yellowbrick/text/freqdist.py +++ b/yellowbrick/text/freqdist.py @@ -264,7 +264,7 @@ def draw(self, **kwargs): def finalize(self, **kwargs): """ The finalize method executes any subclass-specific axes - finalization steps. The user calls poof & poof calls finalize. + finalization steps. The user calls show & show calls finalize. Parameters ---------- diff --git a/yellowbrick/text/postag.py b/yellowbrick/text/postag.py index b1119a068..213ab59e4 100644 --- a/yellowbrick/text/postag.py +++ b/yellowbrick/text/postag.py @@ -136,7 +136,7 @@ class PosTagVisualizer(TextVisualizer): -------- >>> viz = PosTagVisualizer() >>> viz.fit(X) - >>> viz.poof() + >>> viz.show() """ def __init__( @@ -419,10 +419,10 @@ def finalize(self, **kwargs): ) ) - def poof(self, outpath=None, **kwargs): + def show(self, outpath=None, **kwargs): if outpath is not None: kwargs["bbox_inches"] = kwargs.get("bbox_inches", "tight") - return super(PosTagVisualizer, self).poof(outpath, **kwargs) + return super(PosTagVisualizer, self).show(outpath, **kwargs) ########################################################################## diff --git a/yellowbrick/text/umap_vis.py b/yellowbrick/text/umap_vis.py index e3545e3ac..77aeea641 100644 --- a/yellowbrick/text/umap_vis.py +++ b/yellowbrick/text/umap_vis.py @@ -168,7 +168,7 @@ class UMAPVisualizer(TextVisualizer): >>> model = MyVisualizer(metric='cosine') >>> model.fit(X) - >>> model.poof() + >>> model.show() """ From 49d47034434ce7eb2828a0e6f7d55fedda732bb1 Mon Sep 17 00:00:00 2001 From: Benjamin Bengfort Date: Sun, 6 Oct 2019 08:46:20 -0400 Subject: [PATCH 6/8] fix 3.5 and earlier syntax error --- yellowbrick/classifier/base.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/yellowbrick/classifier/base.py b/yellowbrick/classifier/base.py index 508291933..76188aeff 100644 --- a/yellowbrick/classifier/base.py +++ b/yellowbrick/classifier/base.py @@ -115,7 +115,7 @@ def __init__( encoder=None, is_fitted="auto", force_model=False, - **kwargs, + **kwargs ): # A bit of type checking if not force_model and not isclassifier(model): From 9856335ae9ca6370fa47c02d6f9a87e789c9dbe5 Mon Sep 17 00:00:00 2001 From: Benjamin Bengfort Date: Sun, 6 Oct 2019 09:11:43 -0400 Subject: [PATCH 7/8] Updates manifold documentation with fit_transform. Updates the manifold documentation code examples and regenerates the manifold images with the latest code base. Fixes #967 --- .../images/concrete_isomap_manifold.png | Bin 79641 -> 81627 bytes .../images/concrete_tsne_manifold.png | Bin 121106 -> 124538 bytes ...ccupancy_select_k_best_isomap_manifold.png | Bin 40278 -> 41955 bytes .../images/occupancy_tsne_manifold.png | Bin 41332 -> 43302 bytes docs/api/features/manifold.py | 6 +++--- docs/api/features/manifold.rst | 14 +++++++------- 6 files changed, 10 insertions(+), 10 deletions(-) diff --git a/docs/api/features/images/concrete_isomap_manifold.png b/docs/api/features/images/concrete_isomap_manifold.png index 124264e9d46685325dd4b1baebc5a1ed0021906f..25c4d15801ab2074e2b0b5cb6687f503a557b094 100644 GIT binary patch literal 81627 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�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

cYN$u|y*7W8ps$ zvFppQ^hUW%jivBG155Mm^$*#2+RUS_zgre-rrOCgY&g=2=Ts8UCXG-q_(J~6*}>Tzf9$>VJzRjQo%{IKZnOTK_J6u$ed73m1#&u30$ zrhDz7Lf+fXpVbp4CE&t7=3n}sZKgd{^pjM#jw^VODs_9Wa$B!V#80J58ABXU+F$%);yuJ8$H3lNMd9%VX4{7YLNAeJlDyq*?@7)XO#TUKzc! zmues_8~wj%y5{J(yJ(xF!Nf^p+qP|+ZJac=lg4Ol+qSL7wr$&d)9<}^*Zeclg>&$hzsYuQRH7Jt{a-}jtL1TBYSp0P%J8(6%L9eHjQwkReV30nhAt9 zWr?7~BY3#GF;l4CoUIa)3XK%cu}qwF=cM;rt-OHd`~=}TdSWA|uCJv63IYg-rUmee zXo@fh6u`z~@Q>;Q-w zDEca|UncqrGqMg2m8t2KwTseF?C3TH+UlIFDmzsx7qxU$z_VgbIeLG z5Z`SZl$@NM9N>DfIW#_+KyCR)^JOaxZ?gYF-H&2F!F{<@7 z&|_&K?9;nf5`wLa29+~nvOMGV_epZln%2Z_;RytEN|EH|v3NMcVg4GTq+PbM{K)EV z)MYeT-tMa2FI@=vHWIR+VuSZE+))AQi#NFn8fPk5EvK^*%QzKg=l;`H+L-AwMPI_%!LPlz90u}&O zob)t(T_Z4G+aFLp2Q3}vB(y+FxmVr*#{<{_TbZM2fdK8z?Rn=9RD2$BA8=$uKd|AY z8ShUE2^C8q85vnKgR@Z)goEBnYafq~iXB0=KZA8)*wf%8uYOG0TF~P&(BS;W-MU^_>)R{p#KoE)f zYmT76^#;Zg(Hqen;YY;$E4O4Ns^6mvynM%Rx9z|TcuP@zqzLnT%<8}?$HuI5#%t+3 z`YF2!HBtqkK$vYOSqTlv#N2qT&EJMeuuH2VSSyiW>hPRBg!7Gmn-+7J1~Q=r-Myu znOKt@+R~ZZRu^ZU$3A6dyn@lvlIGVSM(B|X^2E4rssF|>?~#w z@|J>m_^na{`8>b=s&L4?7%*@fqpX&X5eD6OB8M!Hks%pOM9fLk-tDpRzb*#+zU;lz zJ^uB~4FYfSQe8w}Z$l!;$#n3%?fHbPTK0a?Zpztgqcz-d5kmKy>a9=cZ|vp9+o1dN zE_S9{rxAZR_+Xha)A(|86Des3`whk}1DR zP>yN{O$Y3aj3l%YjBx%)g@|R3R)kzGpa3l2PHHzmXg^n69+;;|hFzY0^0o#rwc z*#Dj+Cft-UqMM70WFRZRvm#-#5fhSpfZUiU^S$74$Nxd9e>p2eVIR);3m$etXxN5t z|C@FXR?jESv<@3VtOWO}wE9+H@@IcaEG0(~7{MH5v>wxVNzP6u+mAd z8pBNx@HApb4O+I<#L!fKih!t8JC-s@G{-*^ihH_aLRCCDXhWad1P1s{nTfGmsaDSy z^?I1iCq2S5oW{AX9haM?{?y88yrQo=ea=}_KcJdmHO);&e1vC2*8DtrF|`u`HMSCz z4f&g!2?1W4GyvY!iM?BsLZpUUnVYEH<=r))fS*Z<&0Q==Q9s1)qEXM(eCB8ko=WqkKE*p9eUH8}+RL za=RoEQM=?U@ds^v;sRx;Jr+M9R|xGfPNf`p7(fNdIjv!J#@^`(L|-WMuT3YgAmXb> zvrI4ar3(*xOb{sckz@Lb>9#syQgo{*kfx>lHdhR4z_g<$;FrtJsvPMQFk*?w$^L!D zl@G!pP9+!g4|#rk8?MTFYWhy>t0?qnz23Rx{0YK@bd9Xos0GgPEMWn=+J^=4VqDvDipmC|R+0lNiwquLg^kRc2p! zvLJP4-*fZAWQSmnuqUYPn`}uplUEM#0s&j*LCwM%EKnvo4>lVy{6n zV8KwFe4yIb1Ivwi(7`a+RS2Xn6glDv`L>T;GByY%f||<84r4?c&IL=iTCmANrf5po zN;y1d-)hmIEhsBTk~AbW)MI%6lAis1jn)e||Co=)CH-ORxr1KFPBq7>kaf_fL2!7z z_JlaT*@*Q4rlM^$NdBAM#s!g?UqLDSG{~^w%BI2Gf5qAN`I)bv*qgP+KZdf%>l%Od zl~hzM?}TfRIyek@aji^I`~e-M)sYirW(?0Sm~z^9F}!ns5(xIc3mU?LV(}%QiOiG) z&gUgF6y)WFL{e%fZLvjHnZ=-jiKuB&4>FlD<166MwukVR&6Sc;*;f>bI|--EGE))w0U{vx3b9+zlC z(k#`^N@-b9khbFde3^cJB6dyp;>kp@y1|<3NqnGxJN+dJB83$Io$n_m2_(@{Bace_ zq5u3Um$9|My({wVf(hwG9?93T3b|lonTTg|o+Tw%#%1j>AQ1^+u|k?w#A0*XWq z{4P6WgM0DNK=(7YIfcQ8LwIN>e8S>90{%5j;;y0rtEQe9)4XZNMxd_)g1^~5r*)FD z=XNK!%H6&ESBQMvEblw{Pt5#$OdT8&m6{YG77S%md+C|6b3ysFY+C_ARBFE>>>zOM zmjZ1i^A&l=xbf_0rm$MhTa%P(5Eia*{A^)vxjY@uX?qjWc#W~OhJ2=o@0StUzl%Af zq7HX=pg13&^$dSrvNVYZWpn;XTM=n{1H8=E5T69g#>{?1#1nT;dLnOU@$K=t6pl2y z>~>Nn_JJB;*0^@`UDQW11AZeUtx;*D>FDQoXo4<6Z_p0a67?tikYI2P;FqH$*Ud0d zAj5AR+{JaD9SB5|)hugGN;o$jJ=&{Oz(NALfOU@$5^HD9hXW`nZEFj*zndJmMa+Ei zdcrC{rB_elDqY3Pl_QF}Y?B`5k~zPMeFok=H~mA65@tdca?nn0sf)k1S&Yx<8WtNg z+9Iy-{`Mn}qIv}_60g2mC9tQIZb)to3gU=T5ul#-O@R@#tg@2udvol}aMU!^gt^$L zWM`|#a7qruv=VC+Rk2{u_VdN9znrHklc@M)*LMPn=Uwvx`Z#ocE+aGr;FLDCIEJnuw6r4p*szdV|M z;-K0m+DqWYC}P7K+&(IifOm8@AevArdS_OQg5r2gaXi@jYhS!>*D0E`?g&5j>#=u50^pjo1gv zO=1yq0y8!Y`$R~K&*LP}C0OLG7j)oLYG|*Tnj$zV7%?{&*+oU6KGSnHHcUEs@=0i^ zkD%2Nf*`V(GEl`NfgvtViNX!nvX>=>+pPb@7hPt1TtCgR&uR6lLgj45M>eR%|&l&g=#eMOB zrK%(HhNB5VQ}?;&6c*)WlRq2%p4|0{XFc`CR~*vdc}1U$HE~^wY&F37>;4Lk)+`Xp^BNm zi`mZ<%oxllByTMX=nKiwtKw!l^AVr?*4Ht#5t&h4ZI&_nsc8*KPA#t%@@=BCJ$tMy zf4^1pq~Kn;{iM_7d3zFYf7NC4YsC7CC0`LN%v&Fjik7EOBEfn5fVyKyv)6xbCRh>{ zHw(00=7?SQi_3ZY{^9>YA~@J+{*i?%0sl~8(niTu{Fk>@TY2o>2Cw(gZ%hylvizH_VhskH5PGY z2(86^HN|m;zUK^81;y@LvfG@8N{Uy|>2D$1eGgQua{B-%6A|=NbCH(x!e*%LPJh@w z)>nu?BgOzfM}LdmEK=?4IEyU_Zxv048Sx^xFYTCHD7`d3D%%k|)lc*i!foWjBnZ+A zABvk2HmH~E(y75z_|lPUIndlY5S*Js%uaIg1KU}<^~U@+fToJOD1JZuM`TPmA6B{r zA3Xc=V5(N`wKG3vM}8&G>3OEKd%tEL(+c54;(aHo?MxWcd#m~q17G@?&##l;SrdF= z4VNZ{T7;b&d3X)A<&S?VqN0twMBPBIN5t!tp$M+?kVhsDQphyLbwzcY=R`jprfYEj z@e^G8?L6Y~o3qC7D-L|@47m6nICgDsAs+#pFfw>su3sluvPhEfR*a6h8QtG80Ki$b zR}4+kGyg=!`rZ5Wjg@G%NOc2y!_EKfD4^3RB7gITa4M2)PcPCVTi~3W0dznV&3Sr> zgI%2}lowY+{BObrqs;B=uzGPCuu4j&KZ@HBo=uWcGRWYMjm90LCD^I+c3>0hHvyJ9 zmuc0ufccPZQ3Ks=T?U}|z^^Macu&Uge}vCOGVKE1(Mr%su&zN;krJ2tjPs!o3R-6{ zw|QNjmoJnVdrjs<=f~k{vybHFDO{83n%u5<|2?0r@k{8PQ*wIC_;*8F1Bzz1wo*R5!1`1;yB1Go@kaf7NeFPskT^xhi;6YZJ68ADMv+E9(iE&yCb}TyKX8ngRP}eB! zIoXl8b)JIedg2zs1ca**Vb=Krv*Cj^+@cBMp=1qI3&x3p4l$8lSP;$8miO~eoG&Fu_FsYE@}cjx>AWlDyFzl%Z%9pN}5V`HiZbMW6}Hc4N{y4hWV(I zW}vlKRFI**VQ$^i%7U$i|3rq4i)vgbjCx;?1~shEW^gBT_ziH#^9;K+LDT>U>uh#AAw8E8m9ytwqp=EvuasB?3%vBAEfl7}<5o-JHaD2jG}aCGX*Zu_k)gBk#77js zQ`dhaG;}0Y@VYWa@|(zQ3?#*y25splh+pKdr$RrW>E=HATIeOrFQ7Im8QEa?Et0^? zARpMM+eM|vC%Dr|8~KYGUA;ZYvK8YR8JRovfd(402mO|rq%iM!T;B>+{Kb2b6vIJD zR68HCPkM8x=AS|egvI>-n1%x$4Mq0OI!0I6gadgr{{Ho!&1fo_R9zHYkFR#O+h_ra zv)u!snD6rP{)@(AGRwMs^Igz-vs_$KCT-%@(HfwUgJ-f^o~UXm1MReAXX+^(ckKQa ztdfTdE>rr#k#dd%Ic9R4?PI1=75V8ukZPojoO92i8<;VpQSEEEFj0{kn9S<6{OsG% znbhE=9Kz!xH+u}osgY3Wi_1aR=l62)4nf%t3}Y_Qqn? z1($+{3P82Ux9XbuhuN?iy{PjG$B!rS|Ctgdu91A}Gji+K!N^?Dbl&cI@@HD{=keY8 zjib+>e1Q+Y3;zB%3_qv!n+X}urTJCGmBrKf2^A_h_SL~P1*PbE8#n9wK zT5op(y)HZ=SXH}vmZiA-lWqgyO>ogFiMNFb2A#r-r+NPRjClwVUdG8|@vWsId5 z26Ri~OCkxkn|>d+GC|EHfZZc>F(qjwXuW59JhLDd^!kD1X6$T{DmIQ$G1!}w4$S)} z7CyjojUxK_ic?BW+i!~Qj9xwOmz-vM+4=HcZ0?fwI3TWC z5`!QT@`@O}a8+63k#V`9eR*B|<CZ!~BoSnEq znbXqVJvaozOo?1H9Rta%6|`g(e4Zk9lG>}*2SeRl{SXjOu1%Wsw&>8^r1$(bUf7cE`eWxEU4RL(@TRtqRg`jA$AaMt&K9ZO74ZzJ(NkCEYVP0T zM`G#=!>M-w3sb~ik0Xsv zTaZMrCa#@T(WDjM=Bs{_;2$R0tL|P?o!j5{4rgP25^;6@oV~p{v@ip0lT651 zMTT-y!dtBawM2w-h>u|T$b_tRX2itP*p*%&r=rt;vjPut>I;mAa`nf`;?w`12AsQP zOw@L=8*-37tF88?BB@yCWQj1{6x!XKZFSLOqLT07C-!_d6IiXKQMfxV{^WY|`Rx9y zYFX`;O~!#yh$>_h)-h+iGsQo2>e|ht2tY$MID>gz7wK<*%4_U%Udn9@E1jQyfVP^w zJNpKdtr{VB*6GJ{J!2LueMKTC@+|k(yvn9Rm0{RA5mQ&gWw@Q%1{8lk|7gwz#2slQ zIf9i21-bMss54(DemgdShP_Bw`*oU;Lf|=RonS?9!D`x>oU8iP`8X!0v_|zTt4HRm zZP%$1Dw4aR0?XN%G}G-@amN<~LjZ?e7!u}dr$I-|+BNQ0lSuqla-CkY=zcKs53t6i zO9Ls9@K`Q&+W8H1ztX4!XHOb;ig2<8MUng} z$J_0pIfnLf7L$0okN^4k;WL@__2@$x(6@y7;c51e?(-LDls~hOXfLuG{Z-ftp@8H9 z(qsmujcy;t8NyBk7%`JArv6nS!Q&t;FsGjZI)9q4`gI|tsoF$yROZo>0=>3cz55tl z(>0U@>7xo=*uTR)HY3_OluoG98FtmiQlTQ#S3ez_M74_dYnrHPHSQnQEK4I1GRCas z=GaY(0Q}G&Rm1ey6Cq*S&plti*ccr(dTmk=j&x>^ihl znfV`S=+Q)>Xtqy*p>!?DNFwdJIZsUj|iD1d(`<3YAtlJgcQy$g@OF~QRqk>}K zI_c|4cWubVV(f#VI3q|p(Za{ZHpBCqmO_W>npPAUT9-)J6Hau-W$1>P(-YxS)&B9Y zbcZ-h#C;lB+S{H-8m)`xM1o}VxM^iKGoFt%rg2oj63){-==#>o*{HTdo&R+NRp8xLx zCCmT2K)@MHq*`4&?&M&*Q2Pjq^4ANZOAtZq5W3oeZl7E4{1Zd?1ejq8=V?WqtHPFI zoy0AqVng{K3PQNZ^Ayy#u9N=Rk!!HpGLC>2Yy$2bse%-r(h?$%nu}Q zp~V!Xa^fVNGSXDHzvA`15u`Zawl-FGB?U`leY1G%?&OalS&)!tVC`yv)vlS<5Tf}xRdZ8_ts&mV#ir}|53_fM+h**ZeoWUb= z*3TchcDV_uDF@_5f>7ed=HT!6B;#_p5|i3$(VVL}VcVr+OR$D2wwZtPbM$-R9cO{VQI= z6G>W|0Tt5ok}ox=43|R$tmI`}yhv8*xYE{@}`4$Qt-7Hr@P9VhE`*PpJB z2h#|(i*UZ3I&b)klB8Q;I2u{0_NC zBSMqMt?WmL6A`DX08~2VCqG%xV7-57k_ldC1$kAAsg;EP{(7fI%+e`Bw*7suFRyuG z9Mqk6{ln*l_3PTJ+1{>=cAzUZ1TdDFpdN?e9oN-7#of!5oBm^V{pF}axgn$I2p1*y z3JSMB;NuUYG60DRe8Op>CZ)jJRK!n*Y+4mgcJP-jilC$nF|?O|ZD(lm->k({q_w*qp3JpJEfwG1c*3iITt0!yB@>WHvA2blL=`OHi)T z2%eG4D1|K*{lqh3=;;hhn}(&)gbKn80VF?HMKlH#AEZ>hVE7u}fQOecBpEMixu3t^@#R)U5M{^Tc#Co z+}c#0c!DG({%K9#5Z3|d^Ccdh3rdkq(-RmgYMEA%4eVN)qVcm(-HK8%KYp{^4ft9K zGpOa@&c(1uDaWc7EoaLSkILqu6*@cZJ@#klh5R**x6gWK)1KYQ{S zY?B`e&(L-WgOb6m)!=l+aaei5kfe!ixsx=s2|5Io=t;sVKK z2iJ~mSL!YLlwg`q>ofwT;ggAb>&eM3(z7UTP?52q>l`;g&cpO^jvtdbof-~*4Mb+7#>DYaDMz2DlA<5aoJ=A_643GNXYGvUu;ef=wUp;kUC zRoBrJ>XS?kn=}>!fF+_Qt2TtwiPpuDm@YyhZJDx6Jijs9PEi{^;!=X(F$l^4Q(v}} zQ5%SW>+ljl4S+OOfL)U3`0=(UWp$zGH=@jDKwfsaK+6ejOw3TNFRwG3evjglj9rmE=Oe9|zflR|U=oDWD za6B}I)X!hJJErz7lV`nle|;D~|!(JXHQL=l%Pr|^awJyuft}F~iPdtq$H*r5`!FScz?5bW}H)Oxpk*4G6 z+3E$$GpOQ`IXIwt{3WOTOLwhLyI;xxBe&xzXXf(@Pb^135sS8o&Fu_T8fQ8!m0MN= zPX5(9kx{kcLZ&j2-UH5rktjzgP)Rc>9GJ||ABEegRN%tXs3V#7)#8?^xrS@254&WW zxj-A=#ga^uT*cAS6MY`F{jk(du6ouoNftSLOO?f}aoJ(k`;_=H-e<$;x@U9JAMSe< zS3T)C;e8e}Z->$*;U+elM>>ir=&aRCpKE#ZCf|J7t6puSbhpU@el*SpiR`4#VGms&93w0GsJ=HC+N++RYO){Zvb zx-D?kVLU$h(p`ueu@L2hDHR9J^&56$@j&iHFU!N$yIkTZw=Lv~q$F&Sr~3ZRq)7vO zBXK-}R4;J_cN{P^J4|Ymxc_rlz5$vr8LW|_CJ4Vg$*{~d45>_JWi11|U zDn9$LpkjFz*Ii6v;j>*d5K)}l9N`$}owi$wWG$;S7OyL7*)7M6!@1&-AJ+HJq`mv7 zMu;8ps~4_`so~bU=SSTQC$N2mRMJ95#H1mtorN?J7koX-pH$Q+MC7akZx&Lk=(YYZ z!v2(om)5RtS;Cdj#ipen`%?xC*}?KCc`5o|cqJtcb5nQo0}IICuFA`G(l%yh1qx9Y zx#QMve7qh|B@WNb^u4dVnV~LpcgNnXbl0nu8!R784Ce)rXG02gL+#{;9bp03fAB)a z-O6&w8@Vu+JPH;)C)B=OSd)k8m=yvVr$DM)9f6tpP(t?9u}vHy?E60*;leE4-JLi8;T}Y8cv=1 zWZU{g)T6L$g6hN9Dwk+mE%5FLMtHkDx}FEJ&sLNn_6wF!3M6Fz2Cjm93P4!x8Y0tI zl&6w3(?^dNlBnwDO>Mdpn{-zAWusV{X*Qk`JOpMoE9)ccbS_4hqILp<9jAz0Ifk4EFTbeLE4n~U{z&fIkaDI#J7iaWOO@ebgLO9k@ZZK={@w2m7 zgSN+0nwHH|RWP}fFcW)04to2S((ya-DUV!n*Xx*F2+(Z{j|7(~9D#>)sH zl>xnm-+Zqq=2!Kl?W=%UDg~|oXnd$lQ}zP{NZf(*Dn^w7HS&gI@iDI>WU>i=cx-XS z$1zo1f9>x4{#cc^H`6F&rLvHbH& zJ3rCzb{KW$Q$!Ybg{RJ|a6(48!i&v)3Fq<7w)+{gxQb27y4biCuRyILXkAOVG9{zr zF5Y%sjt>DCDUobflTZ{F;c)<{aI>tOM>5dXSq2H)VdFV)8qnyqeWGN>P58Ix7PgA` zoLZpyImxhEH>pa1ATpxZnej!VO?Rub_$6)HW)^TF=HOKEep$NxTkY!QVmr4sAv$W$ zQQdzvJnB1GtyFxPim>n(kI8{AgRDGn(MDUcp)ui82Tr+3N>e@(+Y9 zFXR3KTyQ@2fU!1BBSt0jj7}ZZUq#b?IZ70` zmPiVVirSu~?;|tJipagPlW#e8P)L7*LrWpgj*?(Xzh;E$9sTFhMDC2vv#y15riO)( zz&ClOxsZY`pN9FfFPa_q&BHj4Jdys4!m{x%=hsjTLtLg*J35q#Fg%%LdYu%C7uXZu zJ1`L61+P%QQ5bqRWbFD{pxRA+O2w_igFD6<;-ECfB&ti(!8{*#dg`8#(Sr8%Flt0= znUQ_EH;W}96_y0)a#FeqlQ3gerr7qg3d?1YFLesSAgApf46t`7b#~jb|AxeR#*v;0 z#~w)R4b=H3#!J*j4&JZTEiF-)P`HjX)jiHr;eSwcE8LBX={caAk;;tBWfZDtv_2lY zcjwJ6>jv*f^>99pD#(v-2OfjQUkK?qu48Ca?53TsM;hCo!rFd^DX^r zDsYj*BVzvxGF3#p`>xmlFT=IUSZf-T?;9>(6TF#6WUf&+Ix6E+3h2W0B2O6rA^nt; zOhfOsV5J=7UqfDpsyIHM@`MtxJAB(&1hz7{VO=^#tlA<2f(2fJW(iM8<=9&)E^ieY zhH3#{ufjr=s0)hr#>~4}I&6daO0hT){eI+(ZIpBmSOpeloSbS$$y;85t%HZMrXyoU z72oT8>ZDPRg%ru}(M0*mkla^Tba(pSF^5cXA~b~cvb=P*$%*q_RRkh=ud(laHcqL` zBZMqQDOA3iJp!6W=#@9dFN@Ds7oRyU=f(kL znuE)B1iR}VxUH|=`g;#7X&UOp6pQ>|<<<1C{FL+(MQGN)f3H7d)(nS-n<>c$s;lpN zNNkL1pBd|hVRWBhgdtp~mh6c$bgkybfRl7=uS#~dMaO?U0;>*VxO*w7WG^|Q=vc!_ zEkx5`{ij2~yicQas^51Lt%zaZB#JG0Tc?TZbx&9*ZDKk~AmJkox1P-oe^Lc8fx2h$ zD+I4V1xQngT7JFUGT>LtFrdKq)iE>_>^J`TNA4ZKK7aj_kJiM`&g&bpxQ-wgWI@;^ zGVr8+h4?S9ET!;vC5IY$&PXeY8>x)FD<|J{bB(Yl=;o|lt$G}ppyMK!}QURlQ$wWl1^A^p7X_RxUl)6DgYR1sRYRZY$c$LWUhu`gE^w&fg|6c`>fWoT=a*10qa@v$1zfhCUqc~f=`W8<*%{ewst z1i8|h=oKB``?+kp^CyxDrkJ7LZ0p~e82vF+zKND2Mzs+XBfZRB39Tzm^Kh(^Jgi4Vw# z;AJ!6Z%xDGp@2w>`?xHlYFEhYiwCuqYw)sq81|>B0E=&_Tp*F=-3~X0=IP8hucdx@ z&hcT7WJ3iyb-(ZZk_tnsqbU0g*u#X-`ox313&!)8vvIl%DuQU+V~fAqb{ju&8QjgS z9=xM1$k&bM*~=ozm_^*`f%@4GU)nJ@;3`tx+q20mKF>YGL$YbDpE+xnIen39)2xFn zdskiYtM3Vj@2LGo$g7x63!b_MXVwg*(NFy8-JV$+DtD?y*d?6Ab1*DO!bo=L$tDFN ze+`ySuFn_Pte8qtOEgmPaj@sr2bF#S_a|rWeVJZO1kjG1@^nve9og7U@X=VFX}5*x zo+!JD)I&qY#Pp!oO(1=bqm2|s2)O=kG-$*{8YCDN8&QFTVl*_I6obae`{;|7Kf|mK z4f;JiXC>Lj|?8bRdsoId|_DVWU^V@e3Vh*`m|UvS1}M#p?z`#tW!WR_J- zUJmJsdpz_g%J!;O2a;|hKc3T%6n@?^jtBV9EE9xmnxJ0`vA$FcP-n_F!2+4T?o%63 z-TmUgEFCcXxW{0TX$wOZ1j(&?gy%!98dIRG>6QS?KEzF2c68!ewM zeS*3@zuXCH_HVH8f0TK@>jAPRnH0PNmMxm*UmrYcey8!8<@h573AyuATf{6C)mWSt z{Qxmg715`>UFTZO`a8Ocy`f9st6n~EKR!MHWkQ$v;JnC_N#mS?M#i!4)v+t)c=>?f ze<9UcC2OLKuj+qI-t**zfXD5$QXRdQVw&xh1YBsRQf{4XS+wcnYwL3<jex_Zj;Qvgix!>E2ua5qtmpU0+29&TfsyhNoKTHJmv7W>JCoe!AblYF$4F zoB=ml;wa`2>6vxa+O(_=Lgue_(G$I*WVR87e68oyrgi5cL$K@*W>>CZ&)o1&P*N}Q z%NE$Hh3ejYtTUgdX40W-9Isy$wZ|2LVnjRVtkPU6C>!Ca&$X_#dsSycyobu~vQL)3 zt-Q=&j3g#D`UH30;xuHbFEj6`Dh4$J(7^2Eqm@fzg(9kXY0(jbhH8d#)>6dug9;X{ zvY%Spk))~F8GJ;Q;Qa>qxV?*u=PA>Sk=L85#q!hdtSEA8Cfy({nFI?+T_+b(Bbu5( zOIuj&apUroBoU$MCBmorD=Rot`>tl)5w{l=;7rLHFI2%bi8G zg#&E5R&>q>P3ayyGIe-pikE2y9&Xch?5$g-AH0DJew*D@(KvV#2|J*XgcYlo^se75 z8dt+Tw$So*O+THV91k78eD6_b;~QM%iM)bpsW1bS4RK?U2n!^vyX1@^R!*_G#{h?> zH%Es`&Keq~_5OE@i4|hUVD+{Bawv-5(H2A5@wywGojUyJU^sL(t{XU^pst?|RtKo-J=zACNMm#xDsrdb>vOgx{+oLU& zB~zysqL)N#rmhi&T1xMLWsf^+(#w(P3t0r4fbYg*xn0t?8 ziGA9kjSzip!;jNqv)VESJDM8x*c6zsO4|mrfoW2J>2bF-;B4RnsNvhUANHxFe1Rj1 zWqznF+=fIOc^cTsT6yTHPRJ8f7M{xa9RcvJ1aR5hT76NnDi{aV!y zXNSyxSdNecBqWqLFy-xz)?ak5pe-d#EP1wftEd^hre{kdsaw%Be{g(3jO@Z>{vpV3 zwfv6uqG=r?v`vobjA$tnOG2s)BRe~^51~tW(+4<#wOSu?1MNd(lG+OGGT?y`5Cr(0 z(B^WeXNE?yr9`q>nPPn<+6q&ex@|8|)GX%g2KI3p1%+>f6rwU{!GSGb#)ZFz-obvS zTMQM+6i%vZe0x3o;*b~6=COif4|DMsJofLX4`jtg79Bp^Z~E$aCyZb+GoplBt_eQ-+?;2GMABR4~gZIr}dvv_o0gcU^WI z8A(gz75#FNik=OYQFh*@;W6!Fxru{2aF4O+j1`ZqTJ%{^V#m_aMOY$>LW7DG&BzUM8XO;B~8oP6_E5Ku_g{b2p5ge%e5D(cE)-J}G zi{x^&>bw$_vhBlX*KCO#T)x8Pw+d5{>%Kv%^FJiF+z}IA3VHG7sx=-Hdv<&R5DAF9 zUOjVQT_CvHHO1k+zdzDxsu7%cFPJH5_|GE_-`am9H=sv7r8X z8mtDm;pt@eFXMiPofQ#}WRBAe?FkD@#{(@?xqm!w-(6LN?hC_+n1Lv2_g{Evfv#n; zxrHyhXa#2w6qhr$`y~BcQ#acDx$xC{`!_n?+NrjupN=Qh=fGyQ9bbi1^2 z^NE~cc=2r>qXjJ@LuzajSrOpz^6&*hz(=k#w74{z*r~XQRm6%c+mwO?NrB-Ms zqf`d{xn(Z}88ZE^e6VPKuI4E6ONO2}hjhP*$<9)=-T7hgeU=Z1$K^+cyVyhp!4TC7 z$H`yiH9hl!VL&8i37ZDn8Gza)+6DJyYUCpym^yq8c^j`qodglT`)>E>7%O<0-gDIi z;IGU`AS>Z1mG4cQ_ouH!B7H}!8SwRPmMNbhg!>J4HBfvdMHOohGJ~!1XoIR8b&3MY zd-Xo`=^EwwTz-|k+uDd}nL(LZ1+~t0R&Pshz@NFy})1m;h?Eg%tZJh0dH+E_%2`ISmZ42Pob`^-+uI&H^MI1b zv>11Ytsn){Nj1x3Q3^7MIHIirjzg3G%1%TkOm!4&{wG4^h`{@3A9!>Eo*ETGJ)49keignL>Kc8DObX^2^wt zsc9M5=DeRpO)k4Ypn?(qi|bGE5LJ2jMnb8!e@Gg=MPf0=n$rNe)w;8sS^>6+anE7H zq?~z%kaY^5fQ^LmFBCwgA2I;PR+_0fAN9k4?{?T}j9}|Xb`^?B(L~x@Ol&|dY#l#JEtiTdm07qxhlmKs33Y&5Ld>9fpv>R)RJh)Nt`9m4U zy5_8^seOWjX=O|~6<7HrsouVCKe)S;wQF3xU3ukB;_%=;z7PJn&nn4vYHsEnby8*E zd1mutk+@;-ele!<#NNWve&=412pl+))m+ZNp(%v{jzU~pr2twNvy)M&#d}e%MO88D z?=5c+r&@!g4y&VM8-{)zYFqiizRf-TQ!{~K!~pL*1aJBd+t|F)#ke555fJCUr_XyI z%Owk3mdi4XoS51O34&xf87gM|AYVumro>s@42Pq&=AJ2O9QW(CxRy$}P_B^pWtpuA<9EC0jbIzHR zsv$iOztGS%Sln#b{qc&+VL^0SSRV~m`M}cqmus{NBh^(^RoAyw{cCn14CdU%qPrVK z^8Fo^VHKvgMXhzlHUK!IDbLitXj>>&~%bZ{sO0^LN&H|D7Al-7sNKzn3J`b0oHKX=S{e zj{e(O$e?j5;gutmQ)nPVGDZyYnh7^R$847;u3+3CA$Z9sz*MZH>eWn-7#$3eJ9y}TO zt9^azr5R4g+m&_s)UdH_qcLx6G-_?R#|6;QyS;3Felay!af=R%wh`tSuHoLSgCT_!hD(;O zh;vzl<>WTwu{pH)V=2IxC|%8>VZQZ?>?oR`Ooy`dya7|dz>op&emMv&7%E~6 zGe|4SpuO%<&BtHtR@h(`at?d(2_f3i&&^L2n{5S9o%x2i*c36kZ88d|fp2$mFyD}*gX?d;wZ*cH(ZuL!|60|-ZJ#3z(z~V zaW!N*25WeHVdHAuK(5p{+p&MN-6uXpLuMB@Ul9I|#!#RZ(OD;70QY;wB^IexFPQFC zc_%0*E`KA)sMt<1dsSe~SibRRT9v{w^T?ZPrU#8N^nyYGnA+j%V%}2QI zXHl>b@Llg{C7=Xv*0Z13;77&=EP;B?71JI%3)1v#7U&6$znoGVJ@ zuD8eD(C4X$|G;$Pv3c(K(lu%nY!Y{>2zSYZ_CxD*+_+|MaCRz}jbLDC!4_lXMor%J zm@F90+ju&*Y!Z(S}x1ytOhop(2l?_9L%r9 z@O;2>Qj6mz6hBy;(pz<$&faXzm&X3s$9_)G9jeIgF=2-A&&;&nsa$k8q@#_-4`JuI zI5T*`RnH%C{6kN{0>Mkj#T*HM2$~_n^%LZvq+0wjyp*g^c80CSjVMJuy#j(K0bf=L zlQd$RT3e)uheLY3(N?;DcP|tr!$Tr5l2=eb`>M#piqS;r_Q9F5+`19i+j@eUM~TpD z?9Q+F8BV#RG2gB^pI*?*uF>k?J)URn;7+-!9~T;B7d;{~<`j084t!O>8FXV}KK$w4QBo1VVL`P|;>Dn?O+^@i=NX@o z3gtBK5~;4?`__!CfR5=U5Ax0vB1tSBx5}V^cdS=4Qky@94JZHBej@8Mgx@Rv)is`5 ze^wisITUa*ToQcjT(kb|VZ$|b=<`8Kg1mMmleBC zwkvAb^mK?GR5$i3WpOsZE-Tht6PH$Iq-e8IG@61?&iXG|1Isq1R{W%p++(#mfrFNt z{1Ig~l!G?WJ`}+{Sb@I`5?M&V0?8*4a7#^0X@wwf3n;;YY^@vKCCg3)mw7&59LA7Rfgt4G)LkmjCr9mgm zwZ&b-kp;5+!W8m$Sff;ssvwN2>M1$UqKVr$a&F}clxPJgHy?(+%M|v`Q;2)ZM#l~7 zpXc8EOthObkOP9oK=cse&6ry4`m)bZ+V7*@g%+Uf5^7Jc#LO|o%|#T;HwC2qpA_V&KsT^?P8t7zJSyCm)N(}pappGN$hEn8= zr$r_AB92jIcm+F?eU8;XBgje20-c4iw|-5=w#JNPux68cM3=z-fY>hB;xSNgXtnrm zHlMg!0ydXA=mAb7KEq26HQHwPuJ_TuBxZ2+Q^s`yyDJJ$Dzv3S4olNI-pB7pnG?x3 zV`)T0by3Sa^qR)Z_9VWc5OzUe%w{(6r7KDXWIjED+e52;8D0@?tEPT(JcCbz(=d zS|V<&(eD!Es`-6qe7Yz_oP1EK>m?$S3E~em!96n=!zow(?Cn$&Z)k7tG#t&FysXioGYu5~}r1pK|xd`6)#6HF$G#0u)A zLc(Qhw2|`o&5B8{@-d)%L`y?s0~fU13D}13fHKt>1Zk}4^FNQs@4WI~`aHHhcf;`e zAqV_ZXF~Em68YD$`=8w3=1b+~zb4I{++VuDOCj|Kkoq+vHFysoQ48NrD_d3Xe;@ov zm;LH~U=b1k$m%zujM4YdcH8qD7K1;QOmspUdi8yvr(0`?Wqg~VJf?GHUdi)Q(CF1` zx1i?@jv$eHV9{hn5khZW8E^<*!I55qoKFWY_+q8tc;UL@hrcujs?z^0nx}xjPE!rY zDkP#)vYH+Gx+vJ7{ZcezlL7pyh^Cz(%vs!|ezcrtN1d_Li`ZSsz*Jt$$X`omSz)C} zl-DYKPNOBGZYd_lUAM@)i8!xrgq)PtR;YjuXG9H%w(r2|17M39DigrF>D^}baDK!r zYJFZC`=C}4oDUbP;jHf+{u#vjFs|`>Z&A(uzG_Iyz_eJ$VRtUfOFmSIF^1FM;3Kyu z=^`tNwRPF`#8=1CAzKb6fW<>fL;ifH);ZPYv&V0p9kI-cT}yz8z!F_s z#q6E`BR|WU=+A&Apno}2YJv{A!>O3lugq%xrqPWNoY3M^ zhA-_)#I^huFGLdql-EuX_*QX*o`40dJ|3q}L?XDcm7Ya9r<5tQ;J!rfzvj=)T`kv=)la+0Ru5a<9+-2?2FJG*n+x`rc69 zy?XOs`6Ja>E;0DrQ2PFQ?0oEK2la8@bM<|6eSR7en0(!M2$qPg*6wVbVEwfR?wgJE!ykUmx1EzdWGAaPE zYy2aKB?xbKg$aCtNgh?l(*Q z3^cW-bI-l*s60;LxZu`$h%7LMtA2ySIajKyz~%}1x~c$R=J<_$k4~%XTJ~! zWAVdtvd6jpHRopZTqvGfkt|5CI#cM8Lt)~<*axTTYi@PP^DOq*&mcy=j`5}(U2(uw zq8=ZCyw~oU_u|`xxxaAD%GBS#U&GaS=&D`B6h+^*+6%>rAwQ>zI|pHWpR?3nu5>us zkH0y3U4#R9snfV9YeWqfTlOiw=yc8fE_&R#>_TJjdW?XJsK(dDjqH&%+daX~(Te>0 z7r{Ke8D0K2U(UvxK82h>KsT`Le&=?01iz%EL(R%c4ej`Oc?5sCIdsC%^)dktdmecv z*b_=>U&s>24qjCAw6dC(m2{2X_GdoN+l9Ji{9*e1KTPMe24D}$k_#1htryreBz(ns zTysPM`zP+%5845Iyi=qIB0l?SK2XGvT_2}ilbBskz>fplj}X_6Q|(pWo6|thHu#B} zFu1%CQLe$-*N9|X-L8mc#8c+U>MnQF-$&XcfwdGeqKVegDdX`%=KFa(q|Vh5aEHD< zPPUO&NdJnDpaii=nx09t#yn-CXJZm@K>KKzDEv&|`aWE)@%@a#@}cS#i}wTB!x~$8 zugc#cjl0x1>>8ar_OE7*8S#`qgeBWd_PSO^lI=+?)o4mvKHlQkcQkxXHB|H$FQKrw z6t)cPiJDOfXd%S9{w!U?p*&-=WmdKu>}=277-cI5Qzt%5k#Rk*j*7|Jl|0tyb#(vw z*5B&*=%!*(0}7bjq^!71CG{m6$YmC# zVZ>V4TWev7A;+>V7I?Z-z$=FjhqEO+KhEGz*2E5*Um62>idzn?o3xWkW{GIkFHAAz zrZ^heZX58laP3@434uuTabs}>T+)??7eHaDyR>}HC?d#|Y}ym+tzh4rq(l92E@*b8 zq{hzO?;UuBc5O~x-?GZzK$advwA_4IY%=4>_@~jDKePcls}NVXUDvq(x?F1=6oPsn z5N^I-xY7!#D}h2c>3Wy4c~v-CUZw#mZAWw=Tw)11zStO;LRbWVfMCc(JbhRN`v~VE z*Yh5%5p`$5<+eBqi)8I!jMccZwV7fTCsrm}Va00+nb>2Sm7-a8D78}WUoHxtqmAp`QQQnBKh|F(21~pd`W?6o`(^#f z?=6i{o&D0j{~>%$QT>*Z>b(z3}j+>gLv($iJ!pH8`~1^Fnm zX~U&`id85#V6A;jXH0m&%r5EOnVW} zBKxuLhYYdrjvn0B6{V?8HPs@ZwX1YWU7pEDsA_4eEm{t;z{glGWL8U^j42=nXT9g6 z&BqSoM}Po`6-+kexN%?Qdj0X(l~Y(q4l0xW*}rFHW#zq}S5|ZB=41k4{${eq;h}^k zq5!Kc90FZG1H-S~CgCWKciGcZg^-dSsparR+z3c4NQw`dWF%Bn`gpvMf;nXmBXh9tSHD~pnW6}V zU0CZy;vI)V-olF}$ga4q+fVk3WshJ zvNv98(6>V4%$tCf@%s3<^EJoaK;%NFv89ob!+kRwjS+i3?SP72SMN zXcC+;9q$viQHNyBBl3M4AyxzI->(qz_HK1bvMpi047`(zF7YKe zZP1iDF0%1SN>zO2i==9X#E>+A^)xD0q9DRnr@4rTh!iMJ;n5>KrmdF4>|L~+CrHAN zt56M1&7DBPH=+j3=tKbUh-S>)qbYSl86EP?}gPOIed_#fJ1yc zhVndU39|G!qUJVvOBmrx22mX9`LJHG-EaZlb9K~z_?tOK>=m8EE9>nN=(kN)k;1G! zG`LvP)j>AcMXn-!2gjT@>i|i#6TCnV3=Srj{IY0NoWS6SG+%eeoZz_>(~~N{pHNpb zO*WOYlH{t>c0B~@CxzDRGDk+r5O#<>8oc7)jgHWRN+N2pR4#aso1qnIMZwAWh$L1R zhPT(x7{cGdOU5|Rv*l+ZnMXjpm3#n^((m2G=um2Uig` zT+4nW-=w#GR++aa&&CCRw!3exjDNm&X4eoLQW1~!{R+zNPYC$2hvGU{Yai!KU2r~3 zxm0C6K(Fj<(Fvhzf0_0Abkmeg2FKvFnvrI8bJ5gsqDgQdJCQxY-SzbHzT}j{qs0zk z>pdpyUyF=sLIz#g;3gF{hd>I6C@z;9h~1^i#ZUj@olfu9Ni<)LWE7w(;$7T-Zf+*K&q-}aSZtI& z4+@N2Vk#S-J(hDYQ7p|cz9<2GKZT!CcveexwDmg>8Ocmih=$xjxl3qDS%MrzN$(~z zm^4&Th)GK0o3LIzY|>=htcVN)QGvlnu}^rR@2Bl>3Z{6+fK{>}f%0a3!k`tJ z;{z7JA3-Ec6YKoMU~M~Dkz1Rn9qja3?uOcS?<=>__mOsmJJ2ml-#z+aW%*or!hylb zFmaCJE1MQH_Kqz)AdhM7J9`QZ4OHHSAcyJ9lt3$cp)wa5UOpnU(A(2)#amw>B&#yp z*E10}{^u9yz_~G_$YNw*fbWt|`!FnTegj(IY&cy8d06*4daw$5mT@bRPx?bf)9_x3z^UpmQJ2pU3bzsF9v9O+Y^!a*Ux z0njDRDG-FaExu2T_l~>Zk2cn?Q}2Olrc1B}xTHahdQFawjzRk0Q3JtXzT$1&9nbyq zf^>|Gw(jpYH!QceN##%ffBjNLMG>vIvCeOe#dd5@(ig>}BF^ z&QB^Dy8Bv$WOd!iWAk2n?@$s9_J0xe4IlI;l~Yf?ysWaSd3$52e1`pF4>1q_Z<%&lGYI|ZW1ve;7|_06-M#uA5y{JlqRgXjarivdU@}da z-Tkom6YWSCtr`(4-`P8a+Q0fRGjxhubdc3g-$=tf)9 zc1;9oCb<^9IA_Qx+|sgk0zm9`|6$I5yG%0nZZE0;)<$7Lcdz6jsmL7#ml*VgRd(aH ztV3q0NsQ}rU*MCP|8s)!X+DL(#5!O8$Q`f68%f|bW@*-DadOjr0CC9jLGHTc&+mji z31X_z@h@5?j51;blKRskoY;Cq-K^=98ovB?D|Qs%n*DNCv^03t05gEdII81+l-&?p?8HwvRT1jWTV^ zc~ut`e2g&%pTK6Tv9;xU7n{o6jgp zloGxIzKHw#;32A?sC&>LRQ~g{i{zYg?InHnuk#`J$(*(DltHWIotl!7d5MD8_9pSA z8@<7%wfeCKIUJ-EEW~D)1?@@QhFIs$LVlOL*I6tU?>qYWs$*V@dEG+8jN>Af(=QT- zXaQz_b{t}|XQI9g*90xclkX&qOlh|_AR?F5aeN#!(}>^OykpR-Z5z$dop8MHRVOFG z9#ZEO0_{6`wG}rNLBmo}_N_Ll52e&Y&rm&|1y?!A^4Jc@z-fcGG8V<#HR7lT-pJ)8NQS!jKgk1Qiq& z747p=NAY;w;yAmWC*Dq~KWMt1GrC4*XHf~?kHp#H$PlJ0<*DKJYBau?T37q z+yA_uJ>G4MYx{0l^t)I-XbA<7K@dgjV(?+923Hzjm{}_s@2^r7Bj-N(j_RM8+Cu?q z@r8<|?NP6OQ?OM!B_Pts-;E>Uofo49&!i)_1#h7&o2=T8FaFi;G|MyW;j*~X*6fB^ zE)6|9Hg(PaT3F%*K&;qyiB%X3VI)pS?DI5Mg=t{^)o?L|3e497!`I}iU$xiHZNWPv zF{F6c2k3u|?%IBVe0z%m{H5>QbGGg6rtb$fo{t3Tqnmk!DB!P_AxeFjUi2f4joAG{ z1M{!f4%KNauVm*8@P(jpx-d5ih>k-+ky#pzTGglw7vV#=ewsY<%OPV>fi7E^gL3ek zGUR=ziu6E}xa;9z^|@DB+UxTU+FaiZG6Lp7{`SOM8PoY|rQ7qiWKVn+8s1;79<>}T za?VL`x0cJikcYL{2s;gUeEqbNrRxGB6~?ZY9#D`Gft$AZ`M!Cm`xfcjGxat;rBJ@` z)RObc<@0gqOF#_idnfMOAIg76{BbA$nYe1x79Hzzm#?b)BKxm=SBET2ls-3&*QTFN z=ii{b%qt{2rCh<#LNOp5mzHQlDMWqj@xISxIkY6X1e2c(E6HeFrwX&#XGGo9@j=v} z%@e1Hw*4B!;}X;Ry0f-n4`GxaJz-GN&=l5V@XU5C^2t;u2h*LdXuI#_oJO*g`Mgn| z>GOm|bEVh-hU`W$q^oOexP>yofuc04_0!PdviFELb%Q&vDTb5F^D(q$@tB&Ah;5+5<~s=ybjpxvxvOf4_+mb z2uHMZbKLy_uF*7*0tK)^FGQ;kP{`ZW&q&ABH?iOpN` zP>XpnpbTmrgCf;)Lf@1@8AloL+wB6jmoIdZa86Zh;RLYB_=?v05$RJ84Q!NTgr|J@ z6N#Z|8GcZlWp?L{({xtod-iuW9-Yeb5>^nYHB2*0&xW&Zqy1n=P0_yauYjtlbKIQl zkX)}4fUPP-VT&YU3q!rGmt`H0TA>zD^B+rMUx*w)TLsYZOg}*Sgbb|q4FSP8gdaSG z357%#hnY_gk`X#}_p-tYMocB6W8kcu0A50~!!8Qc5OdlsB0}lL$t3NQ$Vggs0NF0g-h~X_hKKi2AsN zC5savV$*oOPN!#3QXz_0FdwnG?zRuApY~smXKeUk-!YqueWvBJ6+PB`EZ5d9|EPPfD)qL`Z87r`s7XM_@5wUQDu^A zog4xS6L9qq>e(gD5c8Pw3G^CTV86ES>R42=Kv0pDEr_wF%K;$tP#TggvGt`e1*uVd zf~&au4e{S| z6(rKxkRfFAFrNTHdj3hj`3S%HC&DdMI6h8&0$45sne)#}OmG#&>cJ=tqQp2>v>r_9 z6)fxR-_R*RmvdFpUet|3h>(xi=vTD?bPgXtaINff*=sUhgz`JtNh#&|z00+h*|A7K#g7>j5pj3DRhH5o& zJ|K%sbTlt$z#?1~g7n)8`WY8fFuKcfB>~ui)lS0-19099t5JA*AlX~P5=99A_?h?P z^J8JS1p0S{sZ&fWd!)F5UD#4~wmLWJtx{UEOl#{VPYbf88a8-Yr7L*SHDE0!$qb(r=_OXI8iO zyZA3@8#_{#l>-R@Y7BoGXLxh}@uprxRT(xo`TnIL3@Z4a5nlGFt$e`-kzo~be^WVO z@3CUhD|8w>_TZm&Stp;}!3H#<5&ZyIcs@p}UG5Uhrx#M;Wy~~dwjy&eBMCOntk>;) zzV#KCY_b9?8%qCj_p%#vhFHa2uN@MSPO;Td#qD>l!$Z}JKjcAZoK$b`UiccRh&NJX z3CXT>(Hvg${)(>j)jEZ&UvT4j5KOx~31kPV2mNtwNYJVYDC50VV5>p(MOKcmXdPFRpXB;d`Q#E_w5$`+QUo?5cIVZA7FY@O5EA(q3!^#9hc`kCLh1 z4bZj@AqS@$Azg-#4O~SL@CKCwRoVRyKh{vgbie55POE1H5=Qs?*dS0e?OEclBq$Hl z)H!RoDcQMIjci+PvKRf^2O%QejrY%$J_}X&|7a*9>Xy%wm!Gy&(O% ziKX%}EfFY|cpnA~pK^!pE*dSTJNbXBpSJ25{uPEGu2u5m_~Xi{=r4Zx%qm0JG9g=2 zDP5YVFHzeHss{upf%4n;4^Tsn11Ju3aM1+eLXU~PFT{JLJQSr0tUNQtvHpi`{K2Cl ziUjp>Zk{&AH=&p0?l;603;>r)%4P2@2xrxAOE_({Vds_2fIrLgp2}eA!)PpwB(!uz z=y#GRj!r~rr7+_m4|%Iq|F{aE(Tx1x41i=e^joL03ix>@UT!JHdwW+^GEAa-D5&q# zs7+(^b0xCuqZX4Lm;7bcM4pZJ7%hlQ88*ngKQ`LZI^TaRW_v+{_X99q`(SJ^BP>5BK7`vzoR9GeG#z*ton8%3@Oet& z^A=xQ)Ibp<^**Wa2_-d4jdH`J*f=;ej%i?s62BV(B)f_sL^Yq}t*UJ+$8L2qT}8w4 z#!1nsXQ$v)1<{1lU#66G?4iTI{~kp6SJZyY=uc7!u$ zWV4Rud4m=>p*q1!TX{6JoR8%nsfOeqj}h5o}bv9^Saye6Q2s*1H^ zn#cnB_s>LmiJpG?`ah2{XtHeAPJ|xJZr~gi1`R@xD0R=h7I#6&bZfpy@Q^OZ``Tt8DA&GMvDY28B?<63AX>!76t5Z4bDZ zw}80iy5OLA6fv4bhuDE$qMBvd6ziw#xzZ_>b<)ILO_5U$v0s>2hG``*3+&bZ&a;~$ z0Nf(uOuJ0C%2FH@|LU;RKduRRe(Ee{yQM!pNy;P}-r(ue2il0mqt89q&e8ULo5!yGSuAtj>#D^*zstr>nGku;o8hQu_QDL-1g(Lzi;s zh2^PljF@EkgW=W-gnxI5G+SDfNKgD#%Gq@ej6IeD;k9KeCaIPVWCt4o2LteW2M{Z> zAiSvY^jnbUS6!C-#+?<#M3DQJwuOGYRST&L9krQT7Jw~q z-be=7vPjla^rJ!f-zS1bGhl%(cZZxbXlujwLHB0q@{MvikIrg^PQ8Fg8jeHGsrf!S zv_zhh8cx=R?z|G$;W&nywE5kimZj0mCd6Cda}Mn6rSvn=_I>43^z!en#Ac!TXgI7@ zhnRQXz#7t~{KvS6+dW{r^tO@x{-9}FUQRpSzC*p>hWXt6Y>))2z5yQ!bkQM?D;gPs zy*|T>Y3t4~mYJ)q2{mvDmf?QcM&lW8;Z1To5nn+)tU-DNLy0(wf|=<=TD_B(6@$9} zsB)lWA3y|Y4qBmq$t4{&gVhyKRy(@1xlE-#D1x^4rm0Kb@{(a^U$xFT#ULD6lpSfm z#l)vWPKs&9;W$+)Z~n(RRnTc6<*ITRQR^0{k>9px#?l94*F@=*PdKZtSDXRzF8j%u z*Ddby^CBlv63Jyn?c4FEpw}6;3?6AB*;-3R_)qREiVe%J$<-1%RckONlk$fPoFWib>A29A(a8#9m< zzi3!CQ>Co>IZm#L6&&t@wn2(P&CVdG@R2xM7_J$K<8-ylZWK=>>(AEmio!Mk>fF}; zD8Il9vHufz+9@jO|0`hIH)NC7lHOpQk7uc?qdGjxq@%jG7gxWOi%&x_#be>4{X7w*$H; zI~hneb|Kv5>wCCH-ZZ*W{&;Nt5O2bULq-fcozP9>M&gF#-UCk2OVk(X*B!&Og&6`! z14DuIZ6~@SY^-69!CV#{<_&ZcJ|fNrCk~(Cn3bqEFKR0;E`F?Hr)_G>yuBslq%AMQ zl>v#Cf|hp20bFN!PV0Hyny}pC9ZSkXQ1!RFQ_v>x}CktOQlPFq~7i z!+|CBgl3_Ya)>$)h0c1nnYgjm@c&4`v1Zes@IC#K z;FH76j~4+pBIFK<*|lmo+Vu@45-1irK109{#fC6mfu2bO=p-d3LfBv;=?xUP)phuk z|1_oJzel{0gK<4(yO?)eT5H1lZt>U^98UN;B?5-ErmFI-%K^O01A7PZmu8Z}2oEIk zJyyzYUXUd}cA0vqu;`)C`@zqdVL)jx3E{;VIFu`t>i%i5+V`e4L;bqR-64}&VtqyA zwQnx;V`epm!h%@s+cN02R}VwtT^*r4#|afa7q-+G)nHO=d?K%H8?v{#oWXib&E?Gt zw28&p!Z3XOSVks{=}6^%Op++2i?8I*+-YgOxIC@0Jv=IW5d8pl=R`MNJp}_sH>38a z&GJ0W2?@lU`nHs^yaBLLRI4De`z0@auNTY1=l&Gk{ayz`vAHBn3d^@{!`Ek!62=q7 zxjQms6NLU_QB;U+RTdgV?^aPcA(!0y@b&seG|{qZXPeaX1Z8==pfZ%tiZ-z5pxml0 z5TaDxPbHXiwg=95rQi>{0@4YyaSVQyVFJ39C|==i0UHU#q`jU^`o54P*IB*}vq8x~ z$g!9V>bVV9ik|7S5X^aH0B#bL(lnLWiM5R536Doq*V|3`n{Eyl6ksO#*0fOVs&=YV zMu7Htt1VXHJ9(`z&SWiU30LI+fIuREi{SGpYY8oI?+SZ!_@CjF zZxLsg4WgOi2l2A1SXU7W0|T~Vh|V_du9!rd|E)BnkX?eg#_!XyT|EWu@Q0-`QIx0@%Nxuy=(g#wqGf?&S>VakM2OouvTaET+iEwhO|jRz zX^_W8u;D9{I!=Pm0{`4Djr^&OyCV)oEAT!cjaSL@G53mFu%z`y8t||*JxFF?vnF)K zDW7B7kb@R2_DA~AUMIX_O9gxH>tPaQPTTk^fdE*y$B&z6=~G^&YEY|zj%yeKNFn6* z?f<=W{WlGEZZjEnmSz+Ln<-L(X(m9C9jXBWdd%7Lfsk2>c~N zw(nHX$V)@6Xebd%*ys%CJL2;G_jhmN#R zx~-YF2f;Xw&V7CL)SfG{i53&)6G)OC<-`4Fh&iVV0|fER6-W-ri;f||edPwCH9yQa zQD>KH7AKmli{U6!Ue3%5iC3+W*T8!ZpC&Oip+NdPoLcC%Rk-6XOVEM1{X`sMF!*eZ zs$-f3>DQD2+%Rr&00p~!GZA3ZWToPCUH>VvEn0=jhzWXOPN?6N%fgtH&!w%rU15g5 z$D+dkc*oj|)>*x6T?m%GLLxvo+jFww8-iDsS}PRNlqqj#budJltOQ)DQpa|fJ&soL zQs~bMqutdgfKF1~)lVJ#X`8`B+{1dtaz~8eOgk6nZoawbjJGn-EJIeOJU_U?f^3lv zQn+#fJEC9m^ZjLkCRB_hA{r%8%i;+3z~KvXG|7sB#pWA30#Z6-psQ)ppu{ z@yP%1P`US*!ds*Gc#<|%KQqbyjSx}!4hLbX2IExk@Uv|;tcJIO8(uWX6f^Xv`c&Bs zgYCHJ^YiG>l)Mop6TS_DEF=7-0RZ z;p)X4SVD)##Eq^GFO%0>hB_>>7G)aTxkXUyDvSyi@7N(9+({cvR+qx0va&X$CaL`v zvX8jP2;CH1xKCg@Svh@df^ds!h#37Nx`oer9xGzDeuZ(+-yr7~>yKvBPFMgzSpuVk{fo4|KS7g1ne_lkPPv-$H#fg_M6ctGL#+OBi?43R4~uJxvc=yK zd2of_U*0XnVF{O)wnkE_khS#duxoV+jPezwpfZ2t$DfBAwMRp!af|ruWgBJkNO}u> z;B@8(ocB7vT{v_+YIOl`iizAvgZ!?(DxgD634Fd;Zd`!41-5UKkWB?wI-3T6CVsZa zb*K+Tg_|`}UK&ZG2B9a-@{I!2_}o<{RYp+KpfE z2+n3hSFr2CpP5;%i1w|wq}wHYip*;%DX}J9pi9-A6$58QQ80%E%6)%KQ|uLC^iD$s>>CuhY$I3bZoI2^&7w8dhOJH<+;9R8LUPMV`)2 z5P1pojd)xRK^`3+=bQkJQeoe3b>L*qW^&fHR+|RBp5C;ckP!&UlL55TiwGnAyaYXo z*n3~B(o~hjtyPRMoXNv_u;8mo!~)uJV^MAX9IGNs_G8tu;YLryOQ@dI>U&(?+2A`} z$=~^Y45cj3RXOVO5mNe(NOOLjh8%u{I%O%?oG_O!7@y=A8ZlMPottQJt>PjuXBwO> zD?H2az6zOo9lO>3IF!%&o$~EZgHfp(QNDSRy;X~?ZzS1DJM`e7VYh*^69vJ(=zUE*8xcI~ zI${mXg@}xq8BDcy(zjV_c{)-hV=`c4B9@Z`S2~5JHJ7Hm`j5h6)vK>0xc)T2H7uCG zTK4fKVJ5e>da-3zMMEYkrb+$EfoPVJ*@}@o*Bl{_K81-Fd3$?6En5(S;p}V${Z^&uo)`$-yS|)K@#`t zo~dSwpx_G`0a^%oZRcNfLaKR?$mol&-4=kMp$cEMC|dN8OM6(|(dB{l(DSW1LAOWO z2isic2WbfFtLru>TudS)KU~H^PCkZY#*B-`i^)gGUx1E@=C%`6^`iuwNGXU|b+2Lx z)C#iJvHc1&F%VG-SY58|u+HYGXPJE9q-ZYA~ zxu9w%ZD@oev9*(HZ(TV&JBh0p7SH$2zU7;ep+E3_`tW?Zm(T3?BoC)s6l{y1l`H>6 zgV~lH%il2B_0e6)=STtwxRjv+w?BkmcM%cP=K9#n@ zE-DS^(J9vaQj||Jp+R_Fy{+Sue)AUD=0ewVE?zBllncjiojbD#Vi!`r$0ON8<1P{3t!7&ZKM<<|;$aEn~BUHP08j;AFi8 z#_LrgYixTXF~$w5)~H7nrLItQns67Z?VqjGoCq$b`f}eyJK|^aFKzdZ`Uzbyf%F=u zMt>Vk71XRuXk22VSG8h%EanLGF}`oT^V&N-6m{`~_8}g`vNjGs+%OXTWfji0&^4x8YlaAj-ig(Eh9KcgsFRNF*3}Gt4h^M-7A2Mf+gOe z!uzO-J1o*wO+!is*XPml@&!l}?^F=)(?i7_Qm{^qzdD!@VOXY=K>-!(soupJG=DH>n^td-KXu>=Y4?}UQ3`bs;cfj zhS`EadU)Zw%=6#JO?moCRD|3JrD%%D#uL$o(^#TM_@<6(X@nE}DUfQcF6r*Dm6q=^ zVRB-jI0>(xZbHAINNt_y<*9CN zvjgn8Yy2>ay&IAkdLC9SO8SrEkA-g%nIwu3icjC6s-xBRg^Q*13c7c?nbWXHNJUK? z{WRxE6%nFGEM9KH62fB49qsqw6j-F4-`LbU@V)63t-6CFF_(Lw|%K;g*F?0g2 zlNz0N)cY-t+R5D505;UIjWk&PtM$;5;(W_rQHvR6N|B@wayHO`Wf2G7RE{;w;moTh z5fRKz&`@LV5TvRS-~WbbT&k)bexrf|@opZN(vu=k^ov?FCU+RST(Whajbh*E z9b_y`R{P3niU>UV0&T5JQxZG{vSae$4%?t~l03*{D1_5Bc^A0*W{Xs_gw^~W_ku~y z*)$l?_?_#v_Gqw3(I;zQNe2^9aDqP>v)G`W3A;u@e`o*`F`Vp@{ZI5A2r z+`QqDGCp`{87W{AREg2hHiqy-^}(sS14S{y^sEPEf}u(}ep=AQYZydJu+PNDk8jcuuX zY!fVMAzh`@F(Q5;X7+@MTZ^Ons$qHW(C4)Z0B{LmZsqSA&}u{$l>&w5;y{S8aA*6HBCK8dseftxS>afL4o$e@(Wg%QFDhv!t`qTbWn9J=M$5z`m+C~}*E zF!nI!Fm|)Fd}IGbEj`5japJdrUXaEVu3?Dw&V8h)XRP4~TAOE75B(HLMn3I^P+B~d z8^WaMZb4ohdsiq82{I*fpN`}AG(Nx@#`0Nbl1~*RNflue_jpNM28Uga-qdx_cX*m;0PP zyPR%w85@73Jv~lg!S(IbSj@lR%O^nO96EJgX{@cRH2YVb%;+Oo;@$Jr=gT<>)$_|i zJ{DbyXILA}3sflzYgld{#7px9OvOLMBhrhZi=%o^n zcc}_2DB4e#*?g~~BfqOkRrmiu38Jc#X;ShC4CqK`I4ufS+xlYr*Z1}-6(Ar(+@<;~ z$TRv&!oOzm9hd))rfUq0tBba28a1{#VS~nP%!!T31PvP7wrw;v8naQO#-p+Pz8Ko6`l$zq$1^e8BxxHVwI_@kw#OoG!RI;CDtk18QC?g?Jm`TgR zpA}iYUC8bbnxD|E0e9a}R>1O+Ho~NTJDH6@{i`TcS7X+Y(S? zldct$K!P%=oA_meaH)BOReO&*)i}r5QT{WMcT$lt)mVZv?c^SZIiq=5c~nqYEzi%f zx&;Dj4_OR+?C7za4UgzCE8{d|e-!1y>f68l3V5y6%3GdJ6%5!}-@or2I7XfGe{Hj> z+rE~I9-VVLv`?;M@VY~O_Ppmiskq1I*;HU2y&6gKm+uflCQdWEXb-u+7<=Ax+2;x% zcNINRBk7u7D)heEk@_e4(RO&ARuCM;QsAp;mX!=_Y`?AWJhjl>?)Q1=U-#v2dky+2 zVhgU5$~@UYk|f6JO?c1&nV^4#w@?+%Ec5S5m3mp*KA?N$DGd#qXbL8y{z#zvRpPi^ zdjG&gx(-*|-2e1Jwu5}@aiPuN5v!aR{r42{m&3^3LPwDaj$Xq_qVi=ap#|-uM^EIZ<71P(F zR}W1-F5UfyqoAm$VvXHjsEoPqCoO{+)D0q-8j!l-brtn>v23;1r?9JH3#O<&!+1bp-h97cIIdf0L8!&xR<=~fS_JpXC_617( zhh?b3C(0@#&1FGFT@XGW6@cqk;uyx_gb-rG1+}8r;+Rxl#_~laNVk525boMvZM^+BEAbf)FV7}lu5KPV&Ala=nZv67 zSQGG}2CxPvCqEyAF*qW{AP{GjUv7AQv|!q*Itwi>;vR0sGbQ!5+()HH@Q32^dE*P{ z^rez|Xj^~ghuEPG+q}-%uo9#8H`*joeR9h>pITdU|CfetsigYD3}q|i`8v?%HG=g2 zigyaL`dii0A;x66VF-FbrO!Z32$PYZPS6Q!s(?1#8<;0RiLJ-W)f6G>Ok-X0TUGdF~^%VWIiWvJ@nuCe1aZG(B-0b&eE z)Y9Ep^RIep+cU5+alLxH%s>dk%3FlxIL>e5wA5#<5mS883)R&MpnXUD<^pxSvHZ1+ zGnxBO144p>UcQwDoETN&CSoPUtrQ1QWWs>uOe#zMV_zvM=Va60Z@#^8>U20`F7{*P z#vDYS`(sA7Tl3eCw{b`p@x&L#Z@QyS%uv1f z0c4pFF(-GBkEc_n#C}V4TesIu)4co-R0tIJNkv6v*;^12hBSV%3JQ*IZQUvJMnps~ zGBTd*oUKlY{G8mVOeW$b`0~dU^?j7t#)sv0 zLc7=Ti-Fo$%sl1M+|ZUV3m^dropxL3BCW$i@JxL{(=iVe!CjYj8Mgnka#6g#6#l*) zz8goSKocoQtcn2XDMcvB*wC{*%iVuI*%SJ?&-?SCBai0}CD~?A7}meLv-LD zw{(BpkpLjh&QMB0he75`rl|(ZnO&|Dj_cbkUMZbS13jPrybC*42Y<;9c_YOCsMNJr zeMN^4j2ncFjCu%bTQL~db>b-k6nK|UElks85}iE z$bJaR-uSm*K$nEzlaj#8CfapPj8`N)sjIKxLx3QH*kL2Whac#c7z*QTw`)GALgx`a zqL)M8K9nk@850Q-NB;8DXQBybiGnNnJju6g$!w)9Xo~E-ODy1lo)8@DZp(xrOsF!E z(#4!9#tZ&>J!q*IBRgV1v)A{HNp|Mp@LYiHt!@4M`sF&=*|H-*Yu%9&w*4B&oIg={ zbcacoq3o_;II^b+F3r15Ga>g6_bZ6ze$(FG;ebH!yr=EYXWRd3nabzJe_j*+Wai78 z{C~UxeOVB!g{Ge9rt^Ing!qfripAmNlBmRI4FC}}xP)@Q87~S&BMYU6^dzk4VmdA` z_XhG?ywp3H#zshczAaTd6ELwsQOW1>$C$0?t*W7~{8i{UB^B^6kE=*>gkcd!N3$m0 z@Jmv}<#mrjbm=MwH+1 z6N*kps&UtvbCg4wXrvIKRyhGq9@w`1Ps1#-p5gLeM?w(n-o3&M3m|cAdQ@f(j{BXD zhZmJNiq%x0fbSN2uzS5uMuHGh3sbbHIRhZgB5sNjS@ad(lG(7m`@A))4w@*M>9TvE z1JZ(~fogL*F%IGSluRWl6Wi|=d%2otNb@uE!scx^J+-obMn8fC1v+m7Bn9a9^3WvK z#&;5;1NKcw0wVtcnMB0>@;HM_G)I=TxZ&e1mmNY8mNbCFiU-_~qRbgf93fx>&NEKQ z<3i~-BOT<8m<1nO{3iSqxrbLQ_<;NUtM8_JeS@umj+oOgCbYeYA3oq{N(BEFEq$i< zRgai!7uug(H4D@(qya3;(kaDaLY(?dEK1wTCX&RU?hrdeS3QM@0fZwGPGa`>e6t}< zHIpf{2L6~mZk`j$ienr)WXPYuDT-Ws{0HcLV>X}ZNQw4q5IHDpaQtj-Ey`Kb>%>_XEd?)CjUHhtygYOCX4x?5+$H+2}JBXc**(~6T zQ)w;cDAg7dJZ-8~AwEWY=aI1p(}oCNzv11{9c?Kt?b^#n#D5r-;y+mQ+_&Oe@#;JN zwt4^VC zC}nqN3D4`wN^eeiVV!?~`skE~HkBfDgf+iH3TdXv7~T)b z2gVKl>#vhH#c3kJS#0Y@OpkBPgJZ4uHxR{w_XsKnCc{2QPL?Wq#fvD5ZvEEOt#gt# zLx<@^#UQA-oIWl$AYGl4WE`Ejs_dTreq@xttqf*^hfuo~;hom#sk6pQtSrL{LR3vxJKJBs2-==UCc?iwAxx z;&1VQ$A;kzzQo|?I7}PJd+tFP}ugP^+f)2P)BctPTvNGG`4VN_dY?x8c@5F ztE^bnXIYkUd-9EEDh&u?J>{lC9K?lWWVe1}LeJfmB~BDx2E~V?clO)R1Q~wZ76K{5 z1yeZVvCFC5FWp@~di7@N&LGA{@Q-WF@z2p@{j%qu@&o?$0!tuuNGHmTz_XO64@tsI zF21E&f+Fm>-EmoH{VcY!MG2t-ST3KQz4bmtJpJH7%jF3jvRhDGEE*{uF+X$Z(gII#seb^OevlZwagT__$HbwobCa+D#5rgVhOCf zwEp{Hr^GU_tqk5*kJfzbaAKy$NCayprrhua1ldTy_ATd8lIgfoo(E~=8>H7>Ekml4 zqG!XfTi8pQ`9pY|3)_-B4(>OA<5+OB@j{#FKL^}{(wsoQ8DsB=C4Z;3Qpkrz zw{puCBKmLqWSN$9?dSiLDJ*{Y($Il3W*{L|7l}|>y)bTvm=_*r-ZSAwU7J4tJK~t& zxZ7TJngs%;G_3}fxuAa!DP6|xG0WP7|Bf2ZGs%zk zBQ1fq<{9!Fz7>=vuIW0ZOSJYYuL{uR-bgFad(U+4N~p-)mgbcOT|3qS{=Fjbn0k$+ z5y6!=nOK!;kcCWk3D@FvM5`nDlHEWR;$s8NI4Z}3ECYQ(&~SnWKdfLh&}Jy3XuMC^ zO2a!|5RJ!wY{9Q#h$9D(FKGYS%@)REVkhilr{fQ>Pc$`Ft<7&L zwQQq6u*MpG&0uHn$`GM!AkMakUpUsdmQ+!fr7S0T zz34zLHnV2OL8anI2gAY!M5u3-KjsiL4omu-TPsc5lh{BpF6X}fEkl~jCe7)SFDi zSgT(9?g+u>p8sOmF*?SP&8vWW_B*y~2#}TMBnGTjW)3o7u~LgF?Ie6aCXxtM)g|UR z0WHtb_Fa?q;I9-;10~4BWDk_k{PkRV;*4T<6%DtKmpY4f7kj2oTa?s<3o{Aff}-OG z@i8qfN|9wG_#1LA<^mFOJMmYrb&|k8pB(GrH*+=;bh(EIk&YchV5JPXIo1tpld7|L zap&1#Qp^hZ>@0)P+E3Br+MH|iORshqh8=@@4_ZlP5lNlmGjudfVhAR}jfUMS9@r$b z{pQjZ3fc{-ATd7hzoSeAA5F1-pO4&rNmab{CzC$i6x)D^Nw)2iFY4SRqXa;PgY{D- zF~5JF1{su@Y$O@D?!(y?L0+4L%Tw&XlWj_cp<&W2jnAI-ftfff^fO3(oH(dVTzoJ6 zXT9aM092uhC7|{70z2l!;(SaPa+pE8RoNXqc=F5+B?*(`(qGDvSxD1_n8JjTXmwjf zT-0lQDm&K}X%HEm*x!!I_PL!(hO0a`axMJ395N}&x}iM+E` zL@oVmTois)etPBq-!RdLe$EYS-A8X$)N~x)&nC)qRLB=yAC2Nl zokB_}VRXw_u0roOY8DJ5D`?ngBiOPNF+&de9P&N@;KXbm(kZ5ZKIi@_L3pZm*0~|? zY-csFufP-)k?Rryt5L&$?Lu~dJah@J0FU<;l7`$_!kMKyyj+?nI5^rMu^+{rqROa! zadf>qAr!oN@IE@6Gp?>>{%mThF$y=tG($+fJnn$;Vc&YFX1%m4^5VbN#s;Tki~!Jn zM|fokv%N98n|F|NO z2!Kg#nkbZNbFRER)s0W$&c*Q^l4YGRsZ*LiHVs!?CL8Oy^^F3^L}@H9L^oAI55IcdNF*6zPfx7Pv)9gpmD4W6RRz#{iSES zQmQ#y$D&T)pXbl_f^R|Wo+sDL`F|FdI$FQ(tiN@CetRI(-3*h!m5dK%&eGVNX8yj{ zzt$S_?KFF(mmgIJsm{sV^ehx0n%WXIl`6z3%{42{y%hP_mpW_ydi;~q?`!SI_*^GL z-Sn*KJ&Ox6oEXSn?61eTN>%xlUkFXj8mO=UN|gn=_lo|}p3`37al%fm{f^I73^06g z1z>&~>)4E2f6HdM%v?`I&0KJ4=Y3~H^-mvYps}0wuw%f3fJ5^d!oy11A|M#FKENo9 zQa~jW>&uF+-acBaz~#r>8z4GNi!?AaS|FIz6WwK#YNy*=^*HKW_5Zm5w&$$4<|vg3 z^cG<4?}yhlvvNv^III)HR)?R$cXjyF#G zQ{zn5gP-=&F(gFFVg3T%^R+IwTw1*z?(24Xtl|zZpuQq5g<5{)&PlV3(dNf)7)bpsUs6^0VwIaMau@$8mnbO3Da^BdIj5L6b+06WCw8xA zpSSpm<55D8rESMHBvd42&O>2lcxRIIkdIS;C4-%Cs*EEqj*eoPJN^tUpQo-Jb|YGE zEPRj9eK5Jd+E>Wl-qH+KDa0i}9p~g`Th6%&HwR%&5a!~7@;jrb^cB?NxpgZ(5<6jj zC%KrP4(&&6u!B6{OhGt7(s)daFUCV_*l8FDS;hRqPZ!%elavNCDG$XsY!kD0v3y%Dg5a(PElRC4*i%r z{m%HgP!T{$rnM-Dy(LvxrybuMv0)o4{=soNv{FRd!M$7u?8YliEB5179VPdY70v9t z1TdYPtqha9b+Iu;c-9bi>HgFbBzGPO=|+vyT|@7u12ipPy^PQ?ald?}cv z8d|nl$ul5(Cq6-yAbZ}*HxiXbp|8H>F+bhv$Ci_dT^!*E7LSaE>KTgB&QB};5^n0X zL`SbllDt=?(a`4s#jCZTy)YyxWiSc!ElMZ57p9~s_m)3P7!whvlwxUglDj4<>rHO zidssF5t4II{q3!@&({(SJHc_e0h5*rl00~MNnt*eGy5?##_U<(K$Wt(BDW7T{jrdk z-L88ZJKfio^(ZrKXePBi2lm{P5hYzO+INIW)>-;{m+ z^@tu${Jmz;jus?>!NmT3Upfh$alt9XgpfGZJlg-YR0~wE3C}exscu>XVIU+{VQ4Lx z0X;z+6o75cprA728!k{^O^4;1Yf${rH8b?`c>xD12~AdJuH6IrcC-%0%hQ#dC$;l@ zpXrhOI}9(aECGtY4*&$g;{eDl3#o2HNG9Tx0quzBQ9>HfAaF9iO4QfLaK3){bBV2+ zWdQ{Uvw&Doy+2#f?`}R;^P{Dz7pg?ISd6d*7D&HX2}!9JigZ!Zwx%Kue?>M8tx>L0 zodCPlpd;5B@OD|g?+Fe|Na3#_TyLxzeO|BimEeNFX6I6bD}xRJt1#!a`2i~&M@|oZp`g0 z)9m6T=}XY{vOnT}QkO?G_!>-kWfkPNIK!#)U#oDK|E_tA7VmB2=%obDl7u1{kM}Q0F ziv4@aWBNExvJ86eeIWd4ar70?%9O?m!?+skLX@8-i5>MCj--H)1=d3!)iUk4DGqv? zE1w-o1vG>jxTGj^V;uim2jvxk@!sL7SrmpegOiWLB$d}S^!Hj0D1uJ5t6CLKKDCn5 z)zT)jEzBSV<*>=zivj?GJ3v8P<33AYlYO8DfXE4cw=!u`tW^RKbAN(+VR+X^R^6j5}=k}|-QB1&BJ z^*;NMn*}s%HnDg9c?U%L& zaN_`mg@=v{Dl$)LaE?eVrNx%lINP7ao{B19$-gg6(gavQ7V5IjKH7U5$?%#n>n+bK zl~N*xj3{vkNUQ0@$(mv)Tt8r082F9|uk~3+s3-sSD>i{~VwfwR$_#>Y9!kX{{j@9k zN>SG$5zIOT$f!PBg)4*{|JK(ZKUgUMvm0mz7$?yOU`M5hqaTuhYgoGyV z?6>(2*=EO}MY87-^BxE>Fug0=r-YDTW$7=oeQ0TwFee63i%qsP4?1PieWN0hV0~){ z+CUb8*cua~bL8aL^%asOGLHCMY)`OSOH`g=W!ledbulsYQs|wrkNQeEOw=*~s8&jF zJ>)~G1uGEh%!*oY+ZVSL{EpdUSib8c#F#US=}=LXLp8Q_=~M_Laf^t!FPuZF0U@#s zzgqI8YXKMLD<`EH@uI3H(SCoW>+3XRU^CQVReoJ1%uQ9tCBz8hL_nP||KnN_;os_+RS zq%ZL4mhwti1X1|WqAD&J{3a}iF(f$>zxnYJa&9P#mwYRE!{ zD07Hw41Fo|n-X!X>`gr}Kv7L3__*I+v*3OSCElZhV`piE6SEp`kou?hd0Ss6Zd}_m zZ7n1L!|j6>f)4cqQ^P}6*|$G7zY4bhMZ#;5{R+5iPyq&};oQj;^fb`hGC$BmDO0OS zY~p-OX@WB&2}f3>sxUAgEmbjFSoX_@l=l$kpbHeJaQ%IZeGLUJ!0H`tJq=u#;5K(% zN?Xej}#G zJ%p&P-SzBcp!`!Z$t^EU=ciNIUo;l1>Eb`;Z#jGUJ&LN?2K$N$xl$;W{($*J>VaAc z-qjHA#qa?pW8~w@7ZnNP~sU|&Yr#Z*BW<}JwRY57de;lxjKWdP|%!E2;tb+ z{)}N9bkc~!KS@yGsU#i(y7dR_=|mEV^Oyz;NSq~6RcgztO(zpi(W!;WKPf502w{*1 z2I1?m1ava4^0&EwoUEGLcGtGi?v0E=HtZ>fl}DA{9ih>cLqndA*6q~i&HEYeKFWy1 z7X@Lap={~&@+4v(R7UX)a#nuGY}S6rl-ZB1r5bItO9zMI28is)Gbw59^|*z2^K};T zi74@CbS{IxYGk>)_=t?M4>jrv!)q5z(zx%WE(3_2J4lYv{6W1riPpa&BBOf@J6wJw z)LZxMo_?T3lbezZMylVoa)nV+h=kkKfQ9D@6k$Rk5?(<@LV+6Fj_^MTNeNjECnB*~ z-M=zY0Sghk9{FBCK_mlJZFfs(uYab0DXhO`a_c=51S!xevi6vT(>p>ju;6jiV2N@t za;wl~_7X)n!J5w(WXpx{2cM*synV+B~y0- zpu5Zw#qOuDSYPeAXJ%S;|LrMyKWmJ@(}9P#cgOlZ zM5Vy@uo1wKUN3t!x-dk{(3UH)s5tjWB#AUw11b2jXOd7DmlRml3Nk|N&W=RUHx0BH5g?wAn-ccNL&$OT;BL7Od)QmX)^xbUWO(s<|BluI! zfaGd?DYKksw3%#NK}(&$sB?O^M9kTt?OCHiMQM5KpDtYwX-^>WVk0ECs_H!?~VGTAOEE=b5*;q{-SWa;Ljx>|=M@YL5<4xyVk>*6mZohL(=Z(9FTNIBl?@WE@e4#WSp!vZ2yCO`+B`?;JV+~R6KZ4JQ7Tj6zR+XxYkVi+`TK`+33N9yOkKC z6)^c+LO-~bKhir-_I}?T6@8y>)9$9#@akQH6$qcrL(T^kicq0;yqfKbGHQJ7)pq7B z1ma#lJvl;B=If@XVvyd;Rq0Y4;adI`Uc|)pf^VtqH^!65z2-I~EWAHD{rzcPSJ>|@ z35ABt+qZ9v?{Mpigdg|+_87&qegG`L`L#;bS>L++tPHWDL{HT^zeYiunvfIN+Kt$0 zlW3dG(ueu$d7su@kmOkKQY1k4c}xuTe%!z}Z~a$Cy}W@rDg*lRW{on8(ZsnOw@qG@ z#+%$DGHva*l)@Nc0`yDy-@r0T&pdVNpF=%sn#QA0$IRExjxa#ef=M|+gZ1-xUC(s7 zaGTcYzOLRzv(}4zvV~t~-aK>X$u^nV`;BXw@Z_r$aE_k2qu=B!rq1_Gm0}A%siBlD ze{8?IBa9(VqpBCtad)nKb!SDMQA~tg@2HJJ_|C)>gs&`WikGShNX=?FHCS|Oz1R9} ze$c7uU|aIBD=m#^f`M40q@~pb7?|e>ni2{FE|9_nD!bi6r69;LO=Se{VJ|HMo;xiv z-n%*|T51U!f;Q?hM$faM4N{&B-aFUOYK!&+x=mm!Z`3XPYhDz&XryDCFn)GMe0adm zb8XZmLFYr@*Ar2QVFfx7%xA@k{}jCKVgs+M=dYaQ!qnspBmz$fVyk&*E2-93^mt<^ z%xdR`53z@|j4_Uppz^r-)Vu$7cZ}jb)HoK>on|Q;mzt1&s zZqS%&u(`f!ab$ai&03E+tLX#P(_~HO5Q`d7_LJ7VJx+stcspu^kwT8sAV9w57K-=A&>ZJaeAeo!%g;?KGU_3rrw;;!7o+OMDu0l z9IAsn(S0=mW~N$oF2(K(O+A}e^!8_x+9q|c8;bEAg4oJm)GI~k??!H7dZV=E4}oIon{t@$l78Il6gFe_u2*{mdL)kP zx5VhI-$ysE9_8Q)s{*AHk+eP*5n?DX%EO_xrlIw?jM-Fk(}h;n*b?qg6J!IfMO;Z)KFj_ViHeQjx3`Rae+Xrlyo88#p z%0Nskq924zCp#Qp7!GxtgdAc#V$D%ey(fAzAHNt+E%fbczw{ZUq=@3lN2UoC z44`AQo=vD@cZ##p$fMoB^vjQ`WW9dSw^Wa_%hKOvE1K=1vXb@SN%W#+rCHQYqt%b4 z1DMy}o9tVN58ME}Ep~sdRoD^R89oZ@2u^o`1RR3oLh}-VNIfU5$=%DlFd=#Vt*nE# ztkqV;%wH7NHGi9&3HzNMP} zo4*;Jvb1E8_sF-pXpgWJJmWGpe8$ZieCcI(HRKsbLWk+f_ct=H-qlFLYG62wK7Nk$hq0AB$>j3{c zR%3TR{7?6H1A1H79uYZM*&2u^9v(SBF z6BsuA>JZO$BOHcM6t`7NgW1c%&Feim!Jq)cW5J?ZLRCsT!w7Dm%b()zY{AquT-doQ z-d(i{jgriIKv;C?uy2#}XZSqcE_O8|;es8(euTpj^+{G!Vc{GO2y^{+`k}5WM*}ae zW&q9icTtT58N41_6f59&Jc*yS1%2xnJhQr(=~rZ_?`%V#N&tf%=(Yqm6Z*c^R)Oow z2?uEHL5##=q~1SAki6>gKY9HMLSsU(4pGSC>=Py)FyV2j86S&zslLw#3)^q-71)tTIp2qm2Aelw^>$4>py?1}U@dAKSe z$(MNJ+wN@_d>HYR{pc+oz1-TGd5;s_9s+A=E!nm6+ov7Z9g|*^lF^O(fRV)9P{zR( zzQGe@ny>)Fb_Ts;dMYM-BSEUfJ{)exuM>A1EhsZp=ah~{b~!Q<30MjgO44tAjhE?V zls^dA>x8Zj93YKj;W|>yz}^hSHGaF{tDdyB{+>@)6G#VhIKO$K^(hVS5T>#SGCOF| z>L1s3ne1Igp?#yAnWFh7om<|&z!{^i+mj6?UEj1n9jAyBjlxloM`6-A+-xn!-VS8F zVVe&0;EjP_OMOSg4W`S>owzuN=%LD4IRLJg2OPq3LfkxyI}5Vgf7kGAqRtG^Hph0G(|Dyw z(C21UGnNiEtCS)lC`AwX6H2JR`m>63>umoBj`XN0Z7*MezYTYUWW~sUQm^SBq=H?0 zsUT0K3fVHY`%8tDU%G6ZjUt)bqq+~-2ig31{uq9HfuER4$Koo!f1*#G?$*H-_LAy0 zlKiX}u$9LHC02{t1A6OLXPI4hF~oGa8z42@+LZ`RChK(hdeMej#OarcZ*o{T87#ia z;MzzD5Z=7RrH_eY#kr$(MPzB(a?ywn!{sHh?aaL}5s6DM){n14^}Qv+^_+xp9m!|+SKO>6hOLPgY& zgjh~$9|g<}A?_emhMS50|tm`ch;=tT-QJ5zrvUe}kUi%TF6 zh?$&l;qulr>hXG)6(8*xsT8W-)4R&0RB;XZHuuLcs5@oC!gvb~ZKUDhHG$t2bm%zc zpW2=BFqitr-XO@{!AP|-oW5A}f}-VNMrPm!8bx<1l+X}TY{S?QRh<;$i-E$*b8WL^ zmOuXdbv!kB4?&6F5@IrQjDj4%?kDPvz1#{V6f9(j51|NlhEiLm*rjFk5=H4wEKLc| zdbt&!bbGDmC$boA>zrMGU82K>@pmB&OsIVNCDT8M zM<%j7Ex8m(hlrTA7L`Q>rGzMj^_yqd3VQDBA-)P)7)2UyO2YC{D=I5FAq)C*30+XsxrBtFZYd415^eC)>yk`YKUGB+F?~jxoiR zHybJikV&F4{P9OP4VZi7Z_7u6IZVdaT)p01{OId>=8(P3{94$-@$@X)3DV`mmAe>oLGBz9m0HkR0fbu!ZX{QKa>RIeAl+vsZe@x9Ay z*8Ue5zuEJzt-|X%NCQNaa#zlCI+i}1Z>YIq9 z?iiYszp?7dU~~5ZrbC&=Nz+Ng?oTW)Bmpv%(WXThG0X}dH-DPJ%72l)pv~4T%Iy2L zc;yv}Id<#yc>m`7h@|@ft@|{UEZ%YN&M$D^JboD$;~D64rSSHNx%C3t=WP6y+r4e= z^f3|@%1NNLD7ZRrAu@1GuY84>w>?G7|F3L`Fa|2glcY8gIbzXB>USUbG`W;CB!cAn zB$iJuKW@R1v9e$B%blPu-1?3>UQkFM>fR5tA{+P4`l$@i7(vv>^p!WcNd0_A^0B54=yp5tcX!OiKX!06PjdC`6Rg5%43?w3j+eBw$hBwa~W?EPd@%#=p z5YJZ56U&khe9kQ>o_~=}XOIhc$M<0|2ai0X=5_b8j(+;x!s;#yrOg#S{&X>SY$_lW zk6rgd7m`e7!X~A0oP@3Oxz&VSMVXS)0tu92G3z&Qx;5_oLZQ~kuG7}!lxc5k7?hl) zzO!J7^eg;+NYsHzz}eGU(B-jmSEn{}VPRpz=Cz`u7vhJWJ8AH5f|Yz)(MxZ~10Dv( z+m-Iyu;=5j?%p?_>u--ICW0+79v=6K@PVA1IANTP-_uE?6}|xirgM<@`LX4doFH^H zld0Ppc88OPr_M15McRaJtUYMGmB-U{zTx?o!s^0C(_Xvb9wk|k%N|LQz!S#F4oo{8 zLF=Qo<{z<_od}9)T7P^ZT-$t(3}vHeB{G_7_M`>zIV1pkUv%rFGexIsCdt+75g#T= zhOc5o`w_pk!Fc!?|ufhU$6mXYwjLpt<3qYp%Q6vzI|5bG!5^yz^aeXj~q zayUWP)VK3j=X!L^=(1tiBF9Sp$7w>uI9lm^+=E=;?32fG_QEW zfqcvVa{gTKAiyr>o4g(3E2<<+s;rDLw>)G z_oLB2`g%;I6~^X2S>L~@0VL>ZGar7)$%$-^12{0v$j|iro(O1trprr-0p0U0IIr5#)j~vpVUg5quXiI^PWX=?qrC*O z{x3|ySSF7H5md;OWV-B>vLmVGrF1M8E`ak5RrUWz_sq}EZ1466FD9P+6 z1n*no-PvK^oB-1H75}hBMKiY6WTJ?3>p0KjM*P;B^MD#`UR9%~W`n%Ui-#?sm%yrV zIflS(52gY?OZRz3^Pk~&yHNNnb<=72Fvo|IA8F6Hcxn{-yP+z+$Ut#0Sjt*fB85hbVkSJZWJ5 zvCK>)>$fqgwE$C%35cY_*U~mKS?^D^?*nm%9V{<55h)|m%M*2h1CA7-E#%_Xa zN4jK-+UK@;TQKwVyNfO|btV8ptDOM!Cv!u@DL2qPp9Z(bA=g+DxMryHi?w_))QZot ziBq0eVk>i?S_d1YjCIm_OqSM4=ad;~pY(&1<0dQxyF!)7I|)B{W1@47*(nb^#xFDQ z+;l_+izItaYq1VxUz&eM`I_;!TT`)HI66}#t`UWct&T~rZ*D>&?;kb`Hgs1I;gLc z6cY|ZK^Rr(;e#axZ)~61cFDGM{5=`A9?MF0cewab58T{f%s&)i6ST1ilyrb@afD9z z>K|Thj_}3f*wlhB{D`aP5T&+)(*^5@B*5l{fv)!Q^2^ncN#_`ozR6x#G=DhoQ+KF* zo9H#MR5x(?wlS<|FZQ<-M~g2mx3v{)4K9xO9y21ufYAimco!LrCMaHl4$^R~f-qe| zWJBqVvNneSs@1Ai$k@FH9uh#7uU)`Pzvf^YyzA3M!3$gI4qM0T_#Q%<=>UhSmi(2E z{DD5tHt$whZhHj(Mw;r}H*&~TA-!Gkb$qdH&HfK<3m3)uylkA%SPF0$&zX#dKmYBF2 ztx`*nRlWFlTqjM@Nq(0)>>&I*yVdUi+mSixg9xn-nCXZlCH_z}($pTN3nS1NaTGLw zsCQv!)#&~lXK2`@>eCc4T*x3!vWuvO?i5gy-?C25ZI{vd6)`keN5tUr71etik&RWw zN~W_1*wG`MFg6D-XFXZ>jJJ@_SjN-^p!@gtc^uAzVi+RK z?UcK`^yvVFf#)~|bY8)U)JkdkN3h|?rhRuGKab3~u)aq;XQ=vX;l&)ZVRI-gyC$kwK>vQD@A3&C1&Oo? z!XIh|^lllcP$ZXq^=7uka`=(#u*~EE;w*OV7t-U7tq*`ieCe(e?i*cYcRGiaQVCjP zyJK)yt9QQ%Ip|Y`b7KytUkXC4K>IpGGw%Fm>Kg6-yACyg^ld>UAK7qpRkYdO8XMWz zE&?)T-1G@ynw_1(@tTzIbn=@o&~D%g<;j&u>|?)UEb8Whp|m zh(25)Jj_1->fY@>kfDK5zV#UpSxp(iUoN@W%i_UQ%=0}9L|w(nNfzrtF8VOs@iLsa zyU>4)=e>ys^{|-zs?q*-TXlW^wzf{hh$B>g%) zxL!wCjfWh<_M!X%>r$Wy0)=AoA!_9dh_Ig>3xzSB4x$%8kT2x3ii4ERRh!np5;O&6J>p;f`f?;A; z=SGnrTTU0AYjsg2pkh+PBQ=PXhpt}vy0aBmOMYgfh9%w=PC~9EOW^j$t*J3YSs_<- z{4t8OOsdBq#s}G959N0qfjk42UrhmBfU;d_DE+Za%lM}ld&@rDXI=zgCYPQ6~X|IppLA?9c<5{`qA9n8Vk_%k)0`vpRM;wHNaUvRgx)c;cN(h!Q3C;oh!#S zOXut$apH53{AXn8)lKDM%JHVY$$VL#tA0~5!J(Z1G~1noarW1TPf(spwPdY#J};1Q zwV6JD?+zUt*SHlXQ4ou1q6Zoq9_Pm2#|_i9o@;IHu}XP{NOeP8Ku`z%LSpq(p8@!P zQRVg}_A^Shve5bR2w{{@tT70}Q03hYq9n&*IKt$xlIEw^+9racHp01$JOF?YFRnfV#WX1` z_UU2{dCNywSqJ?ahr@18kZCdM;V$*BId~3%o6Fd+n5i0irY=Lut~|#g)ai5{;)eWi z1U|0it+>ap=iqpw9=<`h5HR0aIY#;LYZQh2eE+I~3Wao!(t2Qfq_>5&IzP`Ym0Fq28D8jAw z0*qSUq(sjKKNQE z|8w5Eb-8L*O^!LnQG4mdZ{_ftv-FoNi*LsJ`{Xxwz4hj@!X09^0X$zUW=_OGr~ds> z8#pF!tPbr?P%u+*yWe0NT3k(ILDc674N%m7rnS27?2K&B9si|D4;~SYJ80?*bZ>2@ zFHj8Cz)9tkc%UNNUG0~{aD=*IsxqLrG@!)s$UKUYdp}>k&3I|ZC=820KT;AF-w%!c zYK6_Fo?g2f^T}fIvhTL>g~arV88XR3fma)TxB4BqSIUjI7)bq9v(7H!x*KzTY_=PD z8`yi#{ykE&o9p|c>36;AcO87Q5Lo_XcA7FH8)L$zh z4A!MmYF>LW)@ zr-DEoTq4GT!OEyO;ff-Po?cyBHnANE=|=bdUT zmO<55qfyzrzu?JE97{Vrv@nU^ zeehv`GyrDot1!oqdR&fHyXTs23UzFm9FZ}YB*%RmD7)Z6=$#7-VISEKN zxy6n{uKetg^RHe2lZb;zwwjmA_Cq*nfpGqKDGA-kd-4>}7zkFyE@4RBGrIr=?3dvT zKg#r320k!HoCdw&yoU6$oibK<$>g&!(pS+r5|Xt+N=97uIUeC|@d7Mo3(k}mc*=iD z;M3fcGm0ooqNd1T+yy2!D*SLQ)$ps042t$a7Lp4AMeVP_)$PARA2|>KO-f9`Pkb)V zaTj5+0Rt-=BqWqE-?1Luv5+{}YhX14W@S0s*LtSDD8^km4yM$&4}Z~+x3j?^al#(D z&+Tzv)gbD^Czn{vQC7p~PZGi&&H@NOavP?dFX>C{kDMUbxU}ZZO?m1Yv*gn{$ z*PUQ5=puI81kc3niOx&G3F`pUnD5<@8j@tRP4Nwme2ofj6yC)VnVEsS`a z59*)-jl?49++KBB$r68E&mr1W3Lpy23EW|@N*e3roJy&HG5=OiyV^Dd+awBYfFtj} zmb}X$;7o2|0@`q#sxcX8?@_2oDDS6vf|1`(S@85qb>Caon^}+L<9}b;=Wf{j!Y2q7 z6jV7+%c*+8vs+ITNn#ChHWXX{-POK+d{e>^nG293przTc#7A3MTDm&fV}M^>@&T$s zhIxL9LODghML$jLdUAO{X)R2#;D${e!<7SZT_d6+eKffIWI-e>@VvqrzrxEq96upQ zu(cssF-l4=b3K$9Q7E4|CKva=D(2m6{mdBCnrbF5w8S0G!%a(UZX`y!vJ0RQx?@7) zM2;?grwnSr| zO3yk0!zql!zzCb67vw+4g6 z)UD21d^&g#p+Y^c4W508%M+$V8#TwkTl^XUwK$zlhGTyEu<*E9y5jJSps#EMC~s3H z#2_%aa;8*;%d_KKoJZYj;XHh81=x2jJ5j(KZb~nEPS}1oajswbvwDmDC9W#>#FRn| z4KK)ap<$%b)gXW2dsD>i_b$H6DNyNxVBn-lfRPbXbu(LoT-k;4HP|_9U7c@$JNBKt zK$ipN6`VsjMv97EAA-D$6(6;VYtPWQYbj`Kemt=$}{%T6?`oxWprH9PVpB^h#* zIoG)(Tbj@#xdq&tdZ)6FiJzgsus&T<(9O%a95Ap40y0~l49MQD_2JI~kteYTsC#7w z;?mMP^_jg-?Xwk}7GCtA?h})`M4%#8e5N|p5`~;MGM5#DFC(ZC-~+IX%)z4RJxFL` z+|BGhJm0P!h?hv3zcG!tzAX(%Z$m4LyHXx5J)$=7jV|p&&Dcza!{kFdzm27E4mjB* z#(uvglIAOQI9hfC)`3YLn84De*BUZXyWBjp%;UCptfH3myy>Bf!~C8rGn`l-i_|nP zO{$(I6^yhTo73)BLV1i#$rZ z`{<1RjLF}v{Cv*->f|kOOCEO|jvQ%?cCrq>Veb`j zyrFg@uUF2)0``Nm{k}K8%N!;DC!2QfbNu*h zkLT#9Q-Z?n9d6ovrTP4gm`7bJxM&?XGOln^PjMCjqv1_l(ZD0aLEzL|}jvJ_5=%w+)WY`c!gQ*#HWv_&@^wKb%5 z$XG}K4V#cj9{#2xBb18f&}MXmfIlko7>qc(J2A)dy?0Od4tN+FnpA1pW9n{apBiQ1 z+P$k$tf8rK-|UY+gY&)BZOg5-tn75R>$YaEo**4Py74KVC6d zM%EF{0@TH0G@$8{vI_OqGkFw2u{34Q3Sk0DB6pivN2NXTA9u>`J~os;Q|5xH?tX{* z$@X@J1rcTIL>U=o=f#MRSN`wq+oYhs3oL}J*3*ne=I6`e%5W79HY(z_qvAap|3JUL?rgGm+PZ2fWHr{+% zdFviwhG2NmeW~7^h5UQ%d^it?XKkbtgaH|)SkS;kop6#-K|#c3EDTXmbOB?bs*(P) zzx;WJZgN>PWLd~#ObymmOp^^1Nb1zH5OdM-w^*O*3o4Epv{(?Gmag$2D@HjBpZE=F z1xqqF*^&yJhK;74{^Wgy2C~z$3)3h!E-wUk$ZWQH&*ulsj%UHxp6d8t%6bUoI<>PG zSij>*`+H2k3t@LNe`^G!&r@NKLG+wVZlV9Cyj_rT^i7=IJEYD8x2`781|kxq+?f$@ zKlY^V%OO2vKs-q;capFlo5WOjMzrtmt*>N6XvhSg@!w#GKU0KUP zZ+H5=@Y-V|Egob_AsDYc%~M^T$RfE>SL)pv{@Esa!$(zlmO{gh!tY;uY;D(Zp{z&l z>0Qash0MyRa)E;hS7$Wa8oX9rU&BiffdH^1f=QE^HmWZ$;LUi>*!2kWq&}Qerg=O_ zbSEe}!(JrKgUbKk;R0||Vj)0Z1BWWVQ9{6gxYjjFb`Wu8#MXxxC)*MY{xp@&eX|X_ znZFXgcqr0Z74iIA{MnKHshPRo?)~O>I^Okxp8gyZw`@xNMjtLg9?_D?G)TsphEMX21*mUN%t^C7Q*~ z_NFv(n(dNf@dty-7(96-tPTEyUuH$+O)pJE`zA1k7v?en-$PLdwm?Bq@$sAHcrWwo zu-o@Th(Du1wdU5V=@70Rrz!wda5zB&I;w!X#g6)(5h~5-eDD=0L}@zwM2l8-J7cO- z{cRxwz6Da$6;Yvzl?AN9h{}ipi$+8BU_#FH^mKs+Z^nC~LN|*>OMI-|C_*W zds3r9#h<2^rgCPnR0{*lLcK&06w#!_?%S?ybxMUL-gWnH{kPL7bC)^#uhcqjY(HQ9~Z*-d>_N|c)LV} zj(4PVoj@#M4}i+kQ7Z$^&C{X9HMti`QS|^5TNp>zTN7Fj?y;T_*HHP_GJ4$A!$ggF zR+HpoB&Pl2POtwKk@0ioZW&VmyaIV74~f*z1xLa&{TpqC^HJ6&+@QcS0XJ(WKevC{ z;VQ#^tsa!02e&joxInP2NMim@XpE{g%20u5m}I7)k3{~}6ICZ@LoED6b@jcQN+L(` z2F|%Mp=beD1n}LA;uE)r`V9g}81TT{M&U>4PQGZ|AI>(s-FASs7sisV^~>Mzlgz?~ zaoqfhDHfxJF$1l|^x^P?j6n(K%$Fk;$qgv#oihhQ-MdpjhsmCNsuh(27n!*_ zo&WitqTf?usFdNy%c1JJLw*cvv)L+47Sf9{8JKT5x)~1iXxfHxs?mrb9ZW0-SVA)D z`Pr6x#lMkP`rX8@+Vb-D&vJ7JR@U3Z46~^Nk%`pntIQrc3lWIh)bS>2d|bAivIF!I zV~tD+LDD|3-$RLZ+!_&@3Vi$(BB!HIBVNsYm8}H{OkZq#NN*PCt8BgN3~aS&sx=+&W04 zFmk-JFUgINK=T_!>*&o1p2F<6>Yi>RKg(f+_{nBh`^Mo$v?bNc!_>Z`e{KX(wWWn@ zGSK2WhPwBA&2ZotROq81mslzb)0)*iLoBVONrt5e%ON*+>IHg^5d5z>IokF|G}RHr z0j;D(2UxvK3ncCRQGJhq#Wb$N?~%WPMSUX72X7Bgaiby8S%=^~nVGu(yOjSq!hc9S z-X>A2g$QY_jS5U?LuVG0f6U`#=EtR4KEN{&*BexLoPY7m;mt4rkiY^3SgY$r8toAs zAoa-eTPU%md_qoF^S%Vfb`x^;X&IhdRzhquQB~dT6ZxfxsH({%^~3_dTG{Ha*``nR z23YL==yu2dg0NVDMODC!om>?=D?363GM+zCLE?-=HTgg~5BCeXTDHHwKwW4HY|6w^ zT^Q9P@;!?*kkEf^+t-!kgtAIGgnnSedL?F5;h&j9C}*k{bSxr6ThEv`zwp)`TN3)h zzGWUY*OD3fvj`{}Ajt_Ns_N#XJWP6IP3-m1T%Gc#TNyYSoOJlMV(3Cwi3p70Uot}l z1U(&YW_CAgd{+UN%uOvREhm3c)I{iy16Om|!2UW0pczVV^4RMf_H4)I)%-Xi!hB*p zi)VC+6CKmh)LU}${l6ZRACyQ4B?cvDJ7a&UoY)PIvgMErGeUC2_+2P>nGIP|KSTA_!kiJe%k?SAnasK8Pds8!XyiPB=r)!$8YKSkaNQf;Z=XGZYd}Owt^8rHFU|^u% zSUc6Me6nF#+%oPexHT<7IteRY>S0|yIzmLr5Nt4|!(5ORZyQLI;xHn{;c1Z+`to-c zuGL7`Y6KfcFkQ;n=it}mT(X_0hK)E6W9l4T5Z$miVa91Fr1|?_b%w|4)>Xy5wS2Z& z{)WD+O5GNS)&=gX!2g-=@E9i8%Vx`1${J^L8Ltpv3J8D9mH$t4$ zV4%48p2u$vej=MsBGj1FW@Dhp(DdDIHb*v_W8{bwal!KwPT)=+j4W#KhiYdq&qmQs zYbbyVz(HhwX>g||VmStf0GiSS?dcz$bf%ClVPM3SK92}L7Y3DXmbG&G=}1)2+uXn2 zh^gUm1Aefw?W=dqy2H72dxp7`aE+TP6ieW~$D@F~QjYk7%FPRXypbI%7!CJAMKmQn zYIYM@da^#jt9U>?Uztfv67)rk+9GM<>12s=np)+OTAk2O)73a{T&N!)#2xElQ6uUT z9dmdsB9dNDzFE-;5J?-eAnc-!pJ7dx4V{VyCo!^q1D)mVGp0N_R}HLwoXBY2E_nj+ zIXNG6_hbAo9FzYSj-4Tqk!_qoGEoa5e!T0euI7KP_>Z`Mt{Dy>L0RkyMJZ*HXp+u< z6}UkOEQK4~&z16b>vwv~6Dh{9P|n|&otZOX0A!Ll0~*Re(1Y11iT;*JiC11Nd(aT4 zyMVW_2L9C^(C_JxC++A|eCF2WMtT-ZIqkS~eCq^l7Q9b29JdHX+$4#jIX39_V+QPp znKmcSGX%$H%i=ys&xTGbcx}Z5-;J4&QdENuy~eT%(O}ERSM>=ye`@#F%n4S@w^ihZE+ed?Jc2_Zs_putUoFnk%GLvDEU zVYKuJ;clqqVP=u-7?B@Rv;FrKPWvz;CWDO5hinu=x%UekAxd`)94=%ZmQ#twZ+XYJKpF}CBZv8)!e4EAZ%k#3K?poh zy8p3VJUC)Vtr|2wcIN4(MQjQnrviDsOsoL-S@ z&tQSiD|2~f_;wVZS7FopLA_oqO$PfY!}};>yYeM$l$m_D=iCO%50u8-z=fqnvKL?- zZ}0lgT?XRS$#G9lL<9+UKe|f^x|*Oi=sNNJEtV;W5hL$jRjlqRd^Jj7Sv?xd0ldTO zkI@U22s8-CeUvQG%2936_`-Y&{)auwNQ*HV@!u4G`_{Oq+E&}x(lL>*SlvV|Z8SRs`^*9A zY%8zlnS?Y~sttAUvkW~2hcMH+`3n+pTMw-;x9BCilK$N#G}WF6^F&L&lNf77S8 zIxF0Z8dnX~(;ItRqrO=qrDYowAsPjoT*+^6ITo&fyGv`c%?hGw%1x8b2F^DdW`&h@f%MgX9)1xy_7{s)TaM9MwY`8d`m>2yF?v|)Vz_qc~w z(;0i~9*K!jKkcSLu6DP*0eP(_j+1=mW(wC$3WO%0i!22l-oJOpsj}WrHY@@_M)$yy z1j%OgLpEIoO_V_m%q8f#drNz;|IywxR3yG|vsL$nrl^>Bqn=D~Qs4|x>Gm@P7OPW* z*gg$*WaQYAbFYMffZlX8MSqeWWBJ25J^lD}LeMpg@oCM0j0rtNv6# zXZWh`&G-`P^2-1FCr@<0!@#t>w6tY=MvvT{87!%5tfK6U+3+yymwL6}N!GwZ$k|>9 zr+kLm=;sX-@NVnk?>Dl~|$11}@ma)|`k9b5};z=Y4P ztF%W7u*l5-s6PZVZg18ZA&f~=DtuG~55Ty)Ik@Dl{5WLLgspMXT<06ee99U8edQPTTI=3cg?Gt!D zBQ~MLp*s^0{+|-LVya~-8p%Hf*`iT!I)RE&-O^xY`uf-`cboATZ|Gwq4ZWiiJ<9rD zT2WVM;0Jhi*63+ZbIsh=tqK5HZmzw!XC$@WT{}!w0S&;S zG#t*i4XWbbu%q>cV4c>-i0~A@53re2%lI|{a9z#AUcfwaJ@k5Y+L3EAtgxull( zhI3qjSPZnrDJ1DEQkeNQ_<=MO_IUE$vDWnSzW*ADgc#YSZ7q>oJA)?|7GzWwzubQ^ zSG;>eH!?o;2G^_q({A=C1T;a=(QBD?a+o>2FRx$Lc(-#hXHDhi2V?M{nM%vj#FjRL zW6bTZ?p_A36Incmuk$thpxqCT?-5hNio!2#_G)^;p4mEfgr*5bvN@u;1Uyj$S}}aF z?+o0zB&fWXRJ@V#Z)XKmyV#nbN7x7r;hIYr_M0$FL9S*hT2rxVlEPUXw!a{$gL!}@ zK1uz@?v5PpqDHPE|{UH#-}1!`az5yg})gHEjQ5hhy*k zR>?aJkfXO33E@s7PO+MQbW{AlL%4X|ntdr9(GSWp#689HBEenCO_3PFtmY(|rQ@~~ z%;cuGrCfqTV`(d`Q`sM^9xnFXihWe(PcDM>%&V`RcV^FaKx=oH*=r`1Z;n`~1-ny20)-4n)%hO4ej~4Sp=ncL z>WTOO)Y?IoHD6Z~nG~3fZ~4*L6U$DR0|s-OPaHSd6+lQZ9Nq9l5E>&*_i!v^8#|?# zgS09IDaY&O=CtPHKmZ_Zkw6QPR1Aul#M)Yt6%e7XZ^*G)y@x}3+U-eo#S^sonAVmt zNN^*3?c5L0i&y@;C|Iojj>K$;!EPJ5;x>Cz6dg%TrE4Z49*>gCDaPfvLmfKivP}?hAhuh#CMsI2rw#KHrN zB!m&}l#v^%Yg>wmZ~pP{0w&X3!(U)zBvicDsHG`E!^vYK=!9qo;6drUAueph(-ad@ z_ZfVsvd{Qd=7x{d9bZI^&-eAioY`oHjw#)VEsd9-3D-mW| zYg-2}gc2Csn@>5uQ7fdk9q6UK|C6OgP@YDhq1Fqh_4#yf{NVn9WRq2tOQ0=XTkmJV zK@%JsE7N&DA)<`iZc1M$OP@<1YK$xW#B5xV&)xFaO7k#zx|!n3_=92PL$52n{= z>%kXYD6@QD;fq*ZvAA&7c&i?6!Tw_r(jE$ojgGWU#qR1;pu;0wIG{eWx5tm?(Z z7m!K+8=p9WiVB4=r8{=yDb@9%EO+;V{uAUHZDB9(pDINPqHeEx7=YsWPQe&( z#W=b>eMLZB!GWv9^%`{C_a49DV?2O0WQF>C%g{w}F9~cr%D2V9$Z35RFX)Z05L5wR ze2gm!PUdFzn*FATxp7(&A!ZmTJ^2AnCe1-@YKaRVeLH5AgsnztzB`I1RsKCX(d@#< zbAGaJmpBDe3p%s_-S&v`t0nX7p^DVjs`55%i~h=C*CuS^{mamsIiag1h6w zH@^P;Y6A@Uyg`qOEpG-s)U6O+tDKsh5mz=vw%6`HsdpfzDo?rEgA!G_0jFs z{_g;!T;8z6dw;?;uiQNRy5p50(8D62f(7I7hcScbLdiz>4gKrL24dwt!r-7pLrU$h zoLnjM)iY~XK?W1mhC1b@kTbd2HC@+%&Tol0^wr8Jq#(kdJB7JH9eb|qhc2n|d{G-8 zDSzUw7NSKG4W>ex2j@=Z!6g=kYjj9B++LS@q%4aXBe|Rq&0ZL5#ti0$k1flAwD26z z@jIH2qy_XrjbO>H1=;TU@!t#pdTkLG5k9uyNg+F-mwv<+*1<;);9UCuVB>s7-3JUH zFRr`AbN(3=rOkjAZ-Y$`5-MFuKtv)mafyBid*!dqVbw&RiE{cCGOkO5z8L9g%|4ii& zeePq)z2VfFK%Gd4jVX3L_}4W(ljChA5s|ij{?C)S;atX;5lD*wIA5FauLs;!i5!2g zrH8UuU^FhcIl;YZS_vfcNJPRyw}U0?Z=V0Gj$UhD0cR*Wj2obach@pVr^fYbyNQS? zv(F-F0EJ2d=Eq*aqS_+F%>Sx%PlLM$w9x-L0*b-@rEN#@HN!5Lq4lx^Jh!)DSXkUV z0#x=oPv8w>?*VOfllrh{!Qbwis=?D&=)~W`fF3DK&#|HRl0OUeX=`8oiL9!P^XcaT zHedj2v`1MNCS*cERNmUe9UozvwfpbRPoO1+5^Nv_$R? zkJ~eK5;;;xdT1foD-X!mUnNU7WH+`15_~$AwSJ(qQJVANKSO;;EtJyg_=d8LPwu@x%h?xEQBmxq zPLQf%G?!JIV*iT-f>2E-Lsu?rzvyTuJE5!B9u`W}(cxovFyW%08k-Z`{(UfDHm@Y1 zV_f1vbv5mXb_<1@7~+Sb&e*@KU!8`CF{>lC+1HO7J+46XF6^46=m8^z+s*71V7aaM zzMnBNRVZZ={`mT?-0@??lKIlTA32eb6{O3vyXdO> z-M3-HGVU@HTM{9Dkx7G#pAsbSela36LM&^8##(6SKO$Ac(v6M>6P*L|{h_(<%9v2j z>AN2?5S#ig3U*10%R8yYaF{RbihX$B@{J;ZR50wDv zy7iCPBHX(EFQRx4>(G|QQl zRM!p4_;{w!P-p%5+q9@G`DdNpW{xv2#7)r~H1FjInjIe%;Qg!so>@=8+FsAW7rkDW z$0MY&qqwE@?0W{=wV7|x zK-nQh0p5yM)B|QhBf@3TlN;s(&+EdsH_tjmaEv7W-%$qFw&-opO^Uy45iklyijYx3 zKAv*ZU?FB*=3SKO1mBw#eOU=rjP+am25bk{)OCac!H_%K8YUb;9Bbl|b|&PPJGt z%oW5)5gKj+x^fe$YUVAP6=oD&IwH`YY#PycK#*L}7WiDZ5IcQ98psOAoLlJiN<1&X zCa@av`fse?zLXpvJ*D|p?G0b_ZmFUWcJAC1*5$g+%RvU%feo>oc70#FFRmejfiW5M zj;1o0mo8KDhVcc#R86ST;)5Bg9VuRtUi6>$!71z3<&LV9U(e7)%tYd`t+>=-t2*%dFRzZc|YMHn{QnjoK zrr)M@j}i9vlR}Ob|5K_~Vp#Tw z?o+2%l=IB1_h~`e-9rW4-mN0wPBuU(O6-v4^>^j!WvyjzR4oE>|4WNwQsI*a6D0{& zR$d|73G2kNywTsfR1P9>+}Qb&tI1?V3fUn{BM8(McsU{{;h=st6VO}H6}}J{5S<** zASU3CfWGB*5biS~r4*wuy$Ld22xIapV$SX;n@C5&O>)EggIDiBNtBi8Pa(8 zajjon!BW|qY7<4Q*_=gCsdg0AO!ni@z6a-p>z{v(kYfnUT< zG=s8Dbs8)JQv>9@<6nb&sFO2ZF!SCQ8tTajCuub_4dmQrKF>dOtl?d6EM&Z7=kMSk ztbQZW)3yZ}A7xAH9D5d+72B*4?D@?8HR zy}N~**uwszotKI3%0(5~`|yQeR|5vrI*QC7Au|_ow=_fit-}TahdtqzIUTR6x$#lj zlUZNwHR)y#Ub~w2_1sj{&H?`R!`1o!Wyf~RZgc(U?>!7}io5y?qTu_1z^m#){4{IY zNBb`w#8f|xk_Y`%MJ9G1n1xVFLb9Y={xv4lcj#)J=QNvk zR2sL%v~0#xl`Ng=ilDmI`$=)^nCekN;8ed9jx*dRfP&5fSTaR}kSK#9GTRV>TyIJs zLhQ{Ro^h|f&uFc#|P{8`DAMXlI5@zm*=`S(#5b-$U z69nX~=az+}{pDl;Bw9}{2`%B&uiNMzYU-ctQFN}Dl&EH!=^7azi(k7gSSBe^96ZLR zpYA^Ig#PCUqmQz!-xDZ8XBCbSu&_WP{mYFFnj}~`h^Fe6E@OmKC0)JYch zo{XAz0fj}Vf2v5X)}qYpf_oHC744F)*0ayHfE(^dyqNTQg`f@cWH{%sgoeV&PD3NF zco!i9MI{8~tK%H|g&R$?=afB8sr73e%uOU}=VRbpKx*0mQ4Q-BQ(vwSk+#0cML&*2Z@?QaE}*`mch~g45zWna0Vr>dN4aq;%Ra7!X4gii zJ|B%57f>xkX1Y`pV+x>K7(0ZLl9RZ^{h{u%gX!nMdV+k?Oli=euNT@=Y6=31RvLWF zE5XB8h@uK`Cx9WgBI!G=xk>713|5X2B+s2_`<#8I#|%jRj@kIz{^{sN0%iU3l>sv`GDTGrr|?%_p>65!ftcozUS?b(i#0>v&dWF zg+ZGYVBl4QteWK`Qxti4Tg(aSc^wvAXr#dGubhYo5A<{<4w=+h8)^Z0(ZJ7n;eMQA zk28g2flA*D1xg_-i;wo>hm`<9Ge17e#i<=2a<9REbEARvB*j)i)Ts%u|$(w6ls~PM>_1=F_v?(kV2Il0v1cF=IIRbgpo?4f%+4jqtDsmhL07tBESZ;=29A^b_Qv$DM8HYnph1e8K@D&}{0 zh;`fLT3UqWZyVqGe7An~?K><_D+>w^;NzU#PvnPf3nu_=uPurpjJgLVk!esg_P^|N zakvo+0A=KZVl-?!`SEgfG&)Le7#F_245VVTX@x{lVv@S`Ne{c?Xf>GsTy~-Cs-STu zc^{%V#@RTdjx)Jbizy&>2X=u}!z?)Kg9!kT$!5Tf9$<|QsHsfDkUGhNeKi~Rh_;Z|C{vc<*y9P{)_{T}F5j%a|8erSQnv~`oJ=?$4nd_StQ zF{%GQ7NAXkZVV>ox5a!&c-$d`ZtqwTORT#u?0saXqLkyT{14*R+xBkp>j5mz`EPmdMn*Kb*MVhdHMg|hO?sYraHh*CWq8Vzo;XSoduAH z4k)`6@$m_($WEDqz1_3!5`l6po50fp`Yf#8fG(mZxuJs8yt!BYnKV;EI0m^MFuQs) z*@I|6md|Va`plnj43|=nivNHE+a+xyRF&G|CR|JPH5lASjBRdqCPHAJYJ(5{b&90q zl1L(jOf$H72n^P~t4YHa6_cjKOTIwzHkGdilQO^=?s|At5rJeOTeVH)U3$moq6}Og z@Z@grG8ecy`pN?F^yrvhl_Hq`GDy0_M~VdzMg>)IwO2_F)gJ;^qer&8GjKd?!72m^ z982mP(nwdkW$o*qOXeHphnWTkHPdrj0xx6H7NZx=Cd*v=hvT5Txh>&L@EbVLa&>8~B8M z^vA*e1&(USe6_)%gccPalBe9&Wig25wIV!GacVTmV%AaYfR@BG;gpeHI1#jj*4P=& ze02j|0x1o+h-P=Xw`!>18Yq1B44yfay@RttK>|zmSruNYA6GdCNE^bkM?|d==`xY4 zEFyqT$~#6j=mc&er9W%(XXBDb84h5BFnH7pS1wzW@Uf?9hSTZPfdot|A4IsRDddQ=Gv1%T6t21*qq?1!ghz|H%_Z_1 z_SB;1`da^)vl1}k0VUny+>D%XJ!tvgn4=XK`JTLRZ+g;RM;_`0#hmq4w?k&1tMWla5VKA07vs}f#6GrZYsgX#o2FTSq46Z{5^Vs zefVMoK9RK*4aF8QR$%$O=x4Tmc3M0gEQFLaaQ~Ky;Osj1d7~%LpMu?*OXR(ut~Eax zf#{^Wwx%ps`S15%<2BA=D)xHt!#tO*NvgtCXR-*zw><_ryx^_qGZC>uAx0@=oM9b0 zG65v*oW%xrLC)x>&Z94a4z9^{K7t`?KfTM(phxm`fPV9l(Ynw{gmr#Anq@6*8%m6g95u3|#8ghbM?F4PU9$yg$U}GH_-*r|Fgl!=;Tc-}-iyy#om(H5v#m{VWy#-wVn$|io1pX zvDD`47?tNP`iHccG+g}Fm>r-I;sJ4f{c*^03U%uV#_aC#lb$U)<4e%(1YH_X_)5YY z{oP*0nmzIj5zP{W-W*-_Y+Jg z^bmB-z_ZVMY)VK=lD=5V`GM#Ub`cwleh@VkkJ-Cc(1;L04z+*e?n^VCD$OTd3llZ% zx+Ri;HG~s|uCpM%O3nNf71hdO4-|-bipT#z%0ECF&oe;DcMnak+c6~nwIuI&G=}^? z4c9~d@55|f??3VW{|wJ{SGJrdaiGvafJMSrQzQldH<_ne{=i4o7?=Gzh(A* zVQC)LoHLa)QhbvUVyQ`V*OYp=I<@$k?&aRtt@w?_S0d+t#xI5Oi_rc+sy_L;M;7tZ^)V0u zZt?Ek-`@^WhLF55i>W-1wg;iR-yG`v@0KnG6VQ3|Va z>?AwG#Q}5AaDt?fUEv9=g=&1gH+}zL@$WSMlSzf#Pe5J7@NSHVDd5%F);tOJ>IXmX zdy5wbvwAhboRj4_Qqm_PcN(R7@pYLyUL$?4umQ?#rJ?T{6Vc*D&27$dm&w~ zV?z%G9UMsKZ5pjx7UT=%?ENhDz(cUhhx;hrYuqlD>TYTwf#C<2I zQd?0`(eY73U;i`^l3*{*?>x<-Su2~gh&?}5_)K@RcDRq($y|CZ3hwJaO|`zMv-6TN;Z+iuPUB?@JNdD)!&MU))m zIMY^Mc+F=6+qs=^jv=J!3jKLueD*J8De>v zW$4)wcoE#HxPZuOQI0Jr1rn1`a=4gRpG#Mw>q2eY7!I6mTrBo|$aB2$2dJiw%p>xijOL*)?DhjV*74fIHxdW4 zzajYC0DIgtH{P;zVZ75B=nM0T=)zatnBfdnxl5r z1}E`&Z*2cfGu?{*#dR{@epzw)yfOB^Sofa1qU-~r%HAVjg4FvK-8-f%&pRB9$R|}dPe?|^*>g+p=14$~A z&DM3}yL3k$VZX;pE4(Q&hYB@-wRT2k@&{Q>gTQ1LLpc|92fVmO!NH6!U&r|EGeV>| zfoVB9)r`F486p4Ql>GTS%p-%2rk&Aj7hS z^X!*hqe4KRn*LF>Mgo_zyin{@s(Efis{bO|8 z{r5HuH=d}O*w(~sY&TY8+qP}9jjhH;lQecFHX1u=-1wRE_rI@at-R0r&PV&eKDJ2F z%FkSnu9D@t9UsW-oSmOtbo2(;x<>{@o)_?~sC0)xOISN9pql{0X(R>>>L^+C(<2k~$Z<2q@SQ9y7}Q*0&oOiLCx&yZL1 zKRXMyBVNxAVNdYEfjK0&4(*z0`-bWDwC2V?6C*RT%ieH2KWG0k>Hn&A+Eq;9T zBZeq;2RP>Yr!)&TkQNeOwW;>fEv&4c6S=Ps`Jjqf#_>3ByUTPY`XR4&4O{2uy*B6X zK8s53{G(m|G%(DfJ4kKdezj`KGZdL6&nR4r2YrJeiZShvIle)m6;)a9#jVSwh0c(b z5EIkIOnJ2Ybt>aM)84Na_E#cke5KG7ypc9dE;thB4Go44c>6Yb%e}YXh+et^ zvkx~dAN+-C{0;vyAmSn#HNK~*79fd_zO{wQSJ!{nL7lh4Am!!b({v1bFNEl^x}&+O z`2O*)&vhSsXJ==xb1ZKdq)(&Lcqs4^v(5huuq4g2JtC$4Js1D)^wRAi+Fv~*sVG>5 zp~7o2D>)vZaFNa!Y8Sh2YrFa8nb^kr-P4P9b72Exn)XuK8#5KhbD~b|DL0u6^t`Ze zxhmkY1hx%bX2DEN2UIQi_@|gQ5VRs+6Fsh`mq8&J8T1e_oJuA3u@NLGJFBGYX(`zFj&H0iQ&V!#CiE~(CI?O zf+U~MPw|oBz+{SP*)gt0uF#g&`9ca;r?JY4iJQ~#%}3?1U(yh*1a9(Rgyn{&%nv8O z%G)y*q}e+d=MGy%W+@+V7WPhOv(x~apC@zl$f_ejHTBwkMolA!9oRWBYzI4fD!|F9 zzmNjz>(WVayv2LZ9%G(e(ZgN#XLmaUuz#`+ztjj@ZPx`{u6oBx%A>Nj)D{>tm-F1O zB{2qRHcDfAub&n+ZF(d!y}T&@`(7L#m@pp~-|LrB6T5CIEN|*0DSGsDbn@ni+y2t~ zG%_jh@6SR9Qs}4TUyNfU7E0YL6=dHjBuULOi+<_He(qP1QW;{qo<&q)u$;YkT6RN) z)cy3Au!#aUfKS$0H}k@8^L~$>f!v{e&55oV<_k70p&o&9s{ftnwj?9t=(}NdkmS-y z%7udWpldzJ2+I||<>XWmB;u4?18c)k}IFL|JS2MzVwj=!)Aazu5 zMEhrw^cMbLAZhk6NF2>$#6N0anWzWr8b+d? zvc4xF_Odj7=~_2h0b$){W5MpCnsD>z>-weX%Z6MKxSk>HaaV2ES0T6f%XU#$@^eN< zjRL$bemitH!;ty7FC)sRXPca7Zws<<-Pz`RaQz?nl!+LK7go))$m`S)Il&d{4kmT|66-xm;)Cb z+D%V9vJmaBY`Xp!d+lrX_D-MSTY9ByX&MER_)Y&a91gk!g0dMbmn1GsAR5|GMZ}9} zvN?!_WaDJB=khJeW$QT^6_%nl_&t_bvp(g zf%CW9-nQ81+St>z3?zq`%-%z{d2Xa#y@MHu)-$=BhP>tuVq0I`?EE{F+#Uzsk4hVl zjqFp?!Gd3}o(Z_7oR(Be;3Tt5=hMv0(~E=)j#2Bahc!4OH7(gTzGzzZSO9{CulL3W%!iUUv;KZ?8zST7N zxMjE(D$R*Xxpi(3hS}sE@EYprT7kVc2jy@t(D*8F`7F2JO>8$Oj;+O* zEBM+kwDaGm=J&r{Q3?4EF{QgOpO>$KmKLUaLLU%%E|#`fvDF0rCiar**Z#@!vERU@ zMY6>@8!D=)b)%SX=NjqfAD@eyd1BBd+UZC9WoNrGjpEEa z=LOBs?Cb#Bqt4E#iRfs!mqtH1GZtuC0+OQ7AGgZ4FGi_0t1$bCK6?z3h=k(f{J_B>!=S=h`n~MxkskLoWMIdCD1kW^4spX5j7Se3YTz}sKLR6LsCPL@@2q`i^a(a zrI22vl|MG_qnGRzQz>p8y_D(wgd~@q97w9 z|9aWHI$X8Pr~XmDyHh;r|A%npd0tqIjHCeZc1s!;sKWQpCOV@`i^W`n+2Yx*g?6tECr!KUOn-uNp=@v8FM|4Sl4mf z-5Eu{%kaNL)3G=6kQgAfxBpxr;z{WT!|#bW|0?~Lhk#~`wPJfzfYl2nJMZbosY9lNU5q4kwdV6!2iIzDB#f3T?|48~Nj7I*>=zzoy-PGQT@>B;d*N-<;$7wwu_E1p7^BuXAfq(w)kIOf;?$=Ynw@=lB8I#{yEpA<7o-@zF;aG-x(JTt>T! z*Q1n)e`mzeu3d#6U0=_^?~Kc}`g{2ww}I1%@5hNZE2fFg=PPUh50-%$q%RGmdusX5 zSW3cgoc|RDmv{As-0DyeZyS@vj-x-v&MtZD`%te)XIBBNrSXN&xC6Yw;Sk5igIe*J zhTDVf@kiHoE?))%Qm1Byv^iF7z1`a?$Kjr}!5QT&G1a@EUh75c|(Dr)q_xrOP5Wb0=>HW0* zDqQ_OW@$CqGHcN(_BnOol*pfPW?r|2RV%QH8N zr{pQEu;k|jr;h+uM?-Wt85oQ$JC(O)kH_3`Gm2<2pQWaJ9ugZo(hbRb`fHa z^ss8vnazmWDlDD&DyjTFfD2tz;DQ6FAJT^ z#N#C!Fm&AgXfY;9bbIyGS@-WX9-0T!Nb%Pu10pT4BU|wl&nOD)4?T5fxT5~XX5GCT zloV#s?(Po-NCilLNhX~@w8I^+$Nkyw;=grVa(r8|Cz&OTq$jJcXjjO2YIQVw?8jz) z-y-!U?R9yl-i4|6?LAxPy}rL9w(s@bLE_HfP>$&c2Vzzv=W8eHEY;aHzV;JLdDn&D z50a}iMY#4yGbp**pMb*U+YnDxi=c1V*k&;5f!XI9Oyhe#m!i=+2`B96nPEHdy|3MwyQ;@&zXb28FKX=|gR~WLDhd6{+V` zb~)Qcyg#kM;>toOA$4;Z!$kCYk5$D%NR#R`iV{{iJfdgsFOPJG{-q$yAVkq4HGJt+ zOGqgA&f}3hUAP&Ys%`wR$IdfOe!wZkC&Q0p{Ar?}>R%z^7w0cg33K`$zW+OMHwmOK z2t@wpxxZecg-bl&;0vts1*W^V-;6W1u75AIUcWM$FfmNv+j6rX;)tWb=^oWJ`FIo7 zz+!@$XQKeKez5|$G0<7(e=Bs3QnHNKC3!e?5IN}gi}!Vt*ad0uh+^+(6wg1*2bAe1z8Uw2ygLw^hLQ z6CkGG#`t^T^uQq`!8GgYtyOS!K4uw4md=8NXJQg&zVEpOEEN2C{Kl}<30jh+uas8@ zF|=07C01)j1t07A8)^wi**I(^r(K)W^00){IZ=0E`=y2|@cqMt+fm+pyLc6cY`+_7 zGu{5m4}*R#SLjTsH_m~xesF*86IRz*LjN!)ls(ooy@V_n%;7mJ7>J*V`~6VsuVfBo zPWHiF;`?5KKKYr7`FcT;xbUKSBj{#~X6P@RrkKGM5ez;uo)ebv{VPfV zk>ksK3I5}D#?fAF0c>7u{LTFmzZ z3Wt%M?Gf0!nc}!_ca5>UVh`O&0!iyT%|v=SME!11%2tO<@pm_5ib(%1;ZL*i1a2Wm z*j-=@qOU&lbz2%*Ty%U%Ku%sd_3%vsx^KDC5QQ{w%4QTS*?z(l`=7v+k=#WnI# zhq~%O`n6l9F8a;iHjYNgB_A&1dw$9&u{4#6_E0(h487EXbV_%o9QT}m?^orI;ozj& z+Jy0+mVB+s$($~ z8)Ay!ecTJil*Tw^nCo?Jk$*-V$2(FD z4MVta=c9kJ*uo53UjM6p&eG~v{|q8*4-9?$t8560P?d1yKw0AY#CreTsx=^iZ-d9#l&j+W=1DklLg7pp`!?KUpP*uYx^WfGqo+jE` znf5yf&Yj}CEaSw0c4%lYvrBLr*(xh8(&CL_xJ zdkhvpeWBFQAy2{!PO?V);bCLAc+fO=G;vfL8}&wM&@;(c>~X*^bY$jvF!6F3?`yb~ zeI2`f_4xJ<^QRHQ&QBdviI(%;>#rjmnBI5*hr`kR9-<;Z^X9@U~*;P-|lEVfjFXF|e?1>_@9@^bC~slVvF- zSKBoG>|n@q;)BFD(wr%ZI}PLDg+bUJ7p9K%qczE5>ZZSTGC7wg?rZ0$>=YgU18oV7 zLLVN4363FH7vp3P0f<$zVKFGAn2wAdTD%0;+b)djboT(G$*MXS6Bd_NH2|LexbN@C zb^#OJ29nq8;()%eO|Bu%rJtuAY zrVH8+HomXN#DXD7DL1VbM@&H2Wy*>~p`CGwE~W~U8eJ+KCPKk)V{YH9hM9ocg<6+1 z!CI!=EQ5zlh5XXjQnl^Yy8WwvFfQ<@aO)J*EExEh)?5QzGb#x~hwX^~dd|ZPvOjm?KbHQu<`tEG6 zGV^}8rv=N7!WMpM$>;PIDAt}LKn_Y7e8MtGmIV%{R9li8G^NXwm7kCZiQQM_*6r`z z>%l&}6}PcHLKY^1%F~2S3Qmgwk@XF>gQx^mQsD3+c)Fv&Bv8Cawtm*cas0b+J)3=|=QVi;L!K`29~@Da&+(3u zk1VX*)#minVqVn;_O88{&0p2l_IMMqhFRAY>6*!rurL?#Y*D+b3uY`>{nPjg7xXDc z*DurS!>r`*1i?nfRTmo%z3=n$554#9ZMhFwB*djWuL^dyv*x?i&et1d`mk!go9&83 zzp04rGK_s{J(WP=vY6`jE0t)_c%kDM>NDbz2R#{agNJk$CseI%A*>j5;u(@ZM&<}A z1vfRsbVVQkLWP9y*{(uYMwPX81|o~t(mGJ4pKW45t5k*PAZM6wm*}=-Ak-m}C#i_c zPRxYs4iU+`J<4s$8v}l(f00K0bhiI~>!GNp&w$pvq}r@w`JpVB$(Y)_cB zg}9TC)T|kAtP+W&CGU`ItWiayj(8kZDd8%T0zx!3>?NJJ)MDW_IDAI2!n=LNN8VbTCWF!Tb!em)D=@t1ibnaZmJf&HG}~ z;chzcK`~!q;cM6~aA;nTcHG-|oe?4JWYn95<o zCd2Z3aa-e43-?WF{y*=Vva<;_6$x__*rs1Wi?*2A6)avREi_xs*t$Je#PU_RpN+zR zj6{0DPoEc~*;RN4De8Yv>)SN_-A50R4Zk@=l8IJS)lnjrID!+cNdRnw$np87U!D~*}>+j%({9Gm(wqX?1Rc}>GaW_B{VHTC>x z$_9Rg?O3j%_&535(q-WMxsFs$sL6yO0f?6phS6`+>9wh6)~$(SS)hxGJnJFuC%y=L}Mc`7%rd@Yur_2-NU2gmg?j zr_{9_%^90LetvjA_Ro1e13!F|AZ}HsF#JAHf>;K!Iwz9O7*BgNm{`f~2^?r;i8H$X zgAog6LH|Y>=Jexi?T|io+dH$V2nbz>b)t%#ZQh(GD8}PAewC5L==abRx8aR&V9#QI zeKcfrgSDwmqSdjoR>6RY-Jc%a)Vk6Lb(V)s5reR88vm2$Q@=KGe>tOuj!}_R;8XL@>{iT$oPG0}|sDMca9VfWAU2Ic@?EX&+=#eY!}} zeuz3DV~BzU95t#AD9)We(e$3(TZ?86e`p+|vwOEnA~O>(%#E5RrDP51hm}P(!z+kI zL6?{eeACuQV9c>tQLxYwYM0TnZ#o&SsbG~z6Js5Q>lto8V}bLgHN9T#XnDltUBXkZ z99%&Ab(^Da3m!5BgI{?rLL;pNA74dEH9?Zi*2ra}`2JJ(=ibX`s%swD>?nptj^%2- z?>aa=e}NPzV{7=I;&b`&d%gL^RstLgB`bmoh?-6k2to0Q^L!0{YdwstFO^CSw-9G_ zdd>|#TlW(D1+I#<(H@eSVEx)XMg$wz#XYvPen$mhd3FBI*SW7~j*DFr7FrBewF=cg z)9~q#tx@b&>8dOAt&1!F_V(IK02j)U-+5?{I8!jsbyA+c4^NJJzM2ZIrdh;R&H&E^ zwWHN+t$t=qks}xV#V&G5ZC{`?h3*xUkE7wJDq8{fyArn8FsjK?>^);AVMnmkAhk&CR# zW=C%K;|CV^YviNys{8!}5l9R+WVKUzMs zpsTr%RvIA6CHx_)^u$@swnDM}Hwy^O)-l4wWqon!O>T6}(`pE>2&~b)Th(f!wo6!` z>$k#+=p60vSwWl?@O4X;s+lBxJ@xl{wD$!+J$VU`Bp$u~;RquE^B$Tpn0I8F!Y>78 zDCz)ZM5$F__`4mz-xvEKQ2mB-FLlX`=pQe;FBq2T1c#rcS2@oSI1{P9T zu%b7=&9N`hM0Yyj!xigarJ+DNf~s$_89r;5^&F~dFjW(>sDOX{ANMpwOWk4O7_zRbjCSPe(zfoYo`|D-{D`eA9X z>8_?}%%MU0!Y|BuFTKKHimDNw_7sef4)M}5Nl>N4>oXVF@>%UJa?}-9tFpJ(mSksQ zl~B~0Nd8h?v6?YoEbEg#Wt*?8efJeqg4)2d{ET_t(-%+r-1n#RNF$Gja}i3OA)QA zjE_`NSQ(=xsZU6~Rwf$=;RDq3p5{ngUfu`ZFBlAjqECaeaV z^FUBYfOW+e_*4t6P4RuWqD|Ot<})(bA`svfmUtOx9DVZ_&lrSYQ%E)=`h$w3bi;lR z$qJ4OEQ)ut7dg{0ywZauG|g^8=9OB?=>IgKzTJ-5kEcx!MK&_Af9v{P5&VRx6FdE7 z2`@y|u)R24l^_OPHCX?rJ}5EuhEVRlo!=dbdrj4SXv1=prbfR!BlBrYMS5_|7OUg}zxVt@XNb#A+?3 z?8y2)d==pBU-KrVlkL%94K{~q8OHfBQLVWtq_8Hg6`i#b19AaSiadOiV$wq8lm1Lk z@Jzv>1rYPhw-CJIJ%(H$nRNeqKOw2Ud3m;}*ct703dYMd4u}P;8U0%QqOCJ?94U?G z>(nbD^~aqe_3QnoM5#0@9eYv5N))HXu$tQmafV_U13GiGJ$$2+_|UMG$nYoSZ1H`y zn7`S+%Dyy=;AOQVndY4TY7r@yn*oEW5mf*{9Ai;x`;>YqbPWxbAciq4ha!-f3^_d@ zw@5Q1x6!(`(gD8@t5zKgmOVkle)4;>V(X0I8i`}42O3zu3NL2WItO; zuEfc{1;R6FB+|9Ad2uxPx8CzMWT=#ANt}MM-u`U(O5yXYZFy3!_?;#@7v4#O{te~f zncZIBDkhbd6_gcR^0vRXKQTc@U8Uzj!MfCVHKAPCw95i7wx#5hva-aXH zRg38xZm7sNP&m=%eps%2unh9K&2~W&PvOks;g&nYgK_1RB|yWnmX_Dco4OrxMPLjy z(gb*-CtP%}{v&}vF(PL_-ojiQtFu>xU=E?lMu?G`b~_=-3U;m2;Fqi;x-n|mQHW?W zd<{Y>b5ooA7rpTr3eF<_6d=y@`8-<-Q z_+9-#buaj?u}Nw7(ei6~y#j0P!x&VE#Q+R>XwY8cV7SBKD`7zV+SFx%4fUPVP_9Nt zW*x39X#el+!lORNcXi#GmtZC`YKoW!fF{KnX%X9uHlvI?T@!Uz##G%kGlFD)OXy%LrE78I=)RRG`TpaTAS*aq^)UM+@L$g^SpF7W8MxOacWt zz@;oaq6npGZR2`nRjsd?88VoaaWR_t6EL=s(61gaLwQiteZZ=MzU z3TAG$X1IBH4D^JhaQ42V9UELp#*bJC-a+hRYvN!cXY;L}d~Cx>q=F(hqquZsXrWxw z#jFZT33Q9YJ;RGJL5p>2mx8owd$9=uc?{^blafz2dOWZ5>wCP?3t}yOY=yb_&1`An zU%m^wvnvQ{z@D)qLRXyRH3gFmwr0Yg7E{oZt4CQw0JJS9mjWn35IOr1xD;vNq*tcC zN``;&4C~vRfl;C=5s#!n*r*}a*{E_SDI)A8eb)RG#wousm#tT@T5TG4zRYqNM{RQI9Kwf6ZT7cm5Oz}#|o{v$w&TXeWyH2E%>Q+apn{l)qwewq>|NXp)!`6@vgpW@> zf?NR=puxMQONs>Te;eBkCkl@}f3#vu!D6$Ts27~Gxim#=F|!a|fkW{^6Sv}eOf*Qd znz1lHkl+iSB2NPPG0TOU}*hQPGUe5m?tf2Et z(fgTpe$}XMa|yCYK^ruWYdFV?L3sCD(vjtoKAlw9sOFuDfi5l3E9JQspmDYdU((Sb zeG}|gP+Qpks}bUej(2)Zw?7s-)8;v9VZmyBC}Cbrt*u3FTZ6c&MTbzBHO*;U6T?hZ zmQ8kQltRMi{6ik8Trmc?Vt~7NQP6ftu~5lTH_VQq6VcDEnz0cu;*l)mAH~WgbI|Cw zgd_n}bK}U!&vq}@|Eapwv&3LsQ`%_DEe4Rq+|zr>3;f!;vHu$(AaZFh5p&5lG)~I= zMPm&Ct@b~zi4ss}-!*hT@_}$q_%JZK(nb`!_;hkw z#1LyX0{KUqebCWUs?{xKk$F-qVAEhD6O5l6%Z}e^Dr|@w)(G2$j+@F@N-)W6S;X&# zAFmkm-%WBW|qyS z1xSxXwK~#naZZ;x1`5`_O?~8E^Bej;oE=>Mf(}a>ouyl-&92<=X1O?_$vt@zWz|}5 ziMMy`jJ)P|v~c_QV%Kq`L37oU{JeE>_ON>yMy3io+bPe-9K`?N+biDlYp_i$UJ;rQ zH&bJxekn8La3r5r*aO(jc@>twBpmzvLv+*H_#13!o@ne)5!5b{i`iV|KOe{q^O=^@ zj(Iv$324CjKN>~cAuUrl7tuC$81oTY1kx`#ATurqsi zWvZI@K@~tr+A*i;$q#E>5OghDRh`6&QZNo=&c?}J`SLsR41*lN7O&_2OIoWPH0)9* z3vjd|tUA%;vsi7Kr#4A+h7hf2z4E|Es5Gc!HwTBEgfZ6yB}n+!Pvz*uAlh`w zE!VMfz6hx(OlRSCA=@Ey%Y$8D>swJP7 zT3gb5sOn~r#KMdoU&msNi8Yc>dBLpK^X}pCx}WIu2j&Am`+#s5B=-%Jj^ANSIx9mA zRQI?tzPt2I+F3m~|JE^CoByKimNLWdK~z%GXwSeNWAGk%a-9PcqLW*h|4eJvG{P21 z3L~OXRYF_V@KgmCrmKm+7RYn~6Io!$TiYT92u*@&tq+TjP=kd_5l7gG$Y#?X-`x(3 zIX@P4^Mwl&`630n>drguSsx>L(=FFPslMN9XID~THvKfOEt*jk^)8qJCZhcQT}L+z z10$Q-Z9sNgN-7Cal7@mcW5_{D74IQIvs)&0#1(EA&Y;%s|JXx%mEY4lNZD1k=80=~ zM<)oOTY3FDsth1RO^S?(D2k|Dos+6v8l!m z*>{}5fyM}!;j;KvJ_Mh!r$j=7gU=4!-wdHx90k!h+%~S-jJBf5eVabAnFwEBkDYXuYJ!%bK33eEqL32a$^yd zB2UldUwJ*eGCp_r?5RGhm8FKD?_brAJ_1LnB9E-%l%YX%TaDrSE6J$qVfRP}_G)gQ zNySwnQ&M~^mm$mydJXEc_ z8=|GV^qyvNlG;?}+9uEA&r3*vAdeVYc+PD>B{yzZvl~#x|LCMEH0;;#?pk z)1WA1Sj7ItBEsQU-op-N$?b%q#IV+!M$F8$2*L;r1R3|=Ai8Z0Kj?g4-Gd<~B3~xq zz4zB_x)S_|`PH$zfW?5l8-2|Yw+7)Q8~C=91XCdcq1h$4dY25NTGeT|=XpIaVoE;h zfdHt9d4>L?1P+gTjcPc208M5hP%6c5fFe#DBAJzTV)LHM%@S_i+JrPP%EZ~j zC|Mj>+rp$9JEf{#8f?v+Vy(c_gRfF$1RaeYk`^RMk5w*DS_0%u-9UiQ5!j%?Z$e8?=#h zD2splZ*!-%hL?H%RtF6=G;Wd0S3V@RB$+-@!6P-?z)_bdCP7wdM?ei4fq|;zoCVNn32=svsoJd-Hk!v3 z7SgwDcH#9{3zt@o&7)O9`zQ$`1yykYxa`Y)9@kYCzw}DrO95IQ%Kqq9bAOJFa;r)!qxlFf5MmmoBHR`mLY;Asx74-4BE&9_5JD2 z?VCW^vki12pz_d8WvMR!}K(aE_hxqMn^v3^@(%ZPI)k;J)pD3L1G{&&_O- z1C;V_GidyQ&8R&lAz~o6jszlN>9n6#-%QrCd*kgNd$!Eqf`(gsD-FACXOzgqG%*;8 z@IsR6RW0s@e=70Uw%~kWlVlaR9%reBND&mLrYno;KFM7ePISqos)oa0lh}~U2J5ht zG%12lTBck7KpX$h3t-J;erewwb}&GzqB44%+tz^uZHq1{;_bq5U|$}~e6n;Cab>Pv z^gc{V)p@ETQ5k|wW;+0s8hr*-wa)er>x2?)%d$7R7eK!Fo>7wW%@QX4es6d6*3Z(|F?)OGh zlYIOF$iC_hELnfBbw&1m3Sfv-RBi6mszD?~J>?GIzBi6OvC9e4DMpmyQt3Lns5|!Y z5y<2y5{l3g2%hrsX9IcWhl`7A)y#esW9Ls~%27^>qYP7>B-M5P>S2qnS5}{Ainu5f`nK-bZ@49b$}uL+5qAwNMVYu8QcGmA z--;^r(+ppT(+<0+!iDS&&*&oOV#mD%G|8j_&wRICpZ5N@k&09*e!%4Eh!On%u!l`zwuVQ6fn#3p~mkB?7 zZNIoiOu!4qHp)v^rn;= z7x)>CasX(HvU;nOL>vIGYZgUDvF1)Z`|V}vDcf71PACi*RrB)a-~5VOag8`9pO~jb z!gNFGXk$|uqO_E@m8S6yh+YPgAgU_g^Aw-fW-n zcVi#Ze;>EnESP)wXz0)n=pn58&?}>j3(L-zHnBBP3F;zyUxX|CnlK{AQ?>3(ZdQX> z@Vht!ykF}z{!bE60_?baDitxVE@kylekapn`E<4L67~ts0oo#-!>2AD<7y>Vu@lRc z76_2fN@C<3TOT8fVLV(MOx)G!GUU! z*0Sxn4?JA<8Jl=%lkNcIEt|lF5cUWEw{KLCu${@qTF!o{Kre@KM8WHm;n78(t}7aG zYJdO~63NCdr-fCj;)?o`F2~w)7Ln7}-ddZu1*vHr(s||1_gpxM)!r{Z7=8PscDyS3 zE_$yGJ_p|IO$I*MnoZ%*C*XI!6L@^A_-~DF?(s$f$dkmg>rL|RPg?6q3dYUdz?HEc zmYG(9z6FLj%qrDxyS|zGl#R!M@rOEK!3Ycb1uCU_86^#s!(}}`L zLfi^GJA;;Pb>g=yAF!Jj?dPR>zN%&%Biir#fqQi$TfcEXw`g7NgQ#bQU8dASeIFc6 zCY**4CE-#O?!VjYmt+2S2Y2k|{~-Z;ivb{wB<$OYY)km#b=J&x*zaKl=wrcGf3o}y zKS7OFFN2|>MWYaHn-hhQMWYl_drT?|j(tgyDlH=*C5u!vA{Q5rrQJ`l6R(k#9 z8?cKoy?Ej)kk>>OLEDgf5WH;l@$IzBW5(wlpxrcf-TQ{rxsJc^eVKc?{nXddeY-7F zkF>}M{uax~eVdY1uJUSATn=QWPIA6UaV+rgjlOMTYLZq+@wO1G#+j+&EaN?a7yr`} zg&sBxNF>ZA{rLCjSly8VMXw%|{s)q%2nIL*n|17px$3Y!6*J(1d?U3>Ha=ZlWV3$;;rZwaRmMK;-<%}%1QiY>Gdy2SQ@W^|DG72#rd{M+#_{UjsR8Ss?aF+ zzF+PP1O?A+dF7Zfq$$}tqb@x?Tc0g2c)#5<+JDn; zy6|9@{~hz5{~hy006E^zFp0Uj=^S1`5iFV0LOs_2+E9I%igHPhzn1B-!Dc@ z;UoECX=k;L9ld|kS}^BIKlA-Cy&l_J@Nf`y#2-+!FEVq5zQgxNz+I;^^zun?>JWi2w<&#u^M+6VeN@M%w1J=-zHYcwnk4sU^P;z`nUeU=CK6bfhx!YJjv-ian-35H z@a9Wn2X8fO>QRZDLdXt!BPWG@mp|Z>ZL;y`zfI4^$4y~5)qP9+WC)?T0w70^ceaXy zsef(wNT9pZt|1&xH7)outP_@Y_Ddohvy?tl4{f(nOODGGnjy_s@$PXuSC?G-9EBd& zEo(komnPdFsMs}%-%%{T6q#2!WxzF;<9+gfEC=rY$b1e}B)bO1bQUG@i~6i3OfAL? zqXVkaB_bC$4w|ns9UR3tvg~eeLWe@VVJFnbVnHp(L(B^_5TF`=`2cB$mcVn_b9^^U z(+D^E56|c|YT2?u*c*o1AaWFlv}&~c^ahuXanJy-fkdB*IgM6L3Lv0VR&9UL1DHW* zcoc{jcv2&bfd`;h>7~#wQ0peg)7w;}#ixh?S!5my_+$7U{eTfOWo${w7xNORga0*t zoSqn%GMKgH>*9rO@VG8eabkCMMvvcr9#1hQPjXwI=TTHh7>TBv zsCNvCh-^b>V#17jjlSd#C*JzF#nN1n6&9gEqk8D9B2MY+%7xAWH%PyIMGh-Hff>L>DD zp>(}>XQ2Qm9zmg1OND%b$}0P5Nbe%zY?W6m7JynmKmQJsvzz(hApLVXPe1Q0AT_6M&ZA0;t7bUv#09)eq|@6}n4$`SUUpd+QAKb53pz zzR~pZ=n1SN=2QG~`WN&Ui45$T=XW!f`Pw5M`8oHcPp?qRb~ZB6NO79N7JH$`7FeiD z%zg3sd6W%+)i+HX#lv?NK*Kk$9v(p!LNT;YM`2A_Xc!^%<89C!*e&i}+u6whU2}X4V5KpXJcVKNVBaTqKGDl91Shq>3nH za#*LzrrZsB10i$P*x6Cjm7QJ^*!iWA^8AN?;u>1L`oEp-E`a%CriI%6dKo}eykF3O zfuwHV$DZR0-)@q~&&0b`KWmHhn0x;c8XR!;KDZwWKhe#la)5TSel9Neh~BUHo5d>l zAml|ZrvH)(J$*l0c~BFM5ttwF?MdKyhaH8c2*-wcGQkab7I^~Ssq&2+!G{~+uy(^z zFF$)#v&CI>L`0v}zGRp_=HLHB{_r*=i4qr-$jf^>nhT->M2c5)MUhD?o&r+4RGrD6 z@x{($#nGd5a_u~DQfWqmxeE#~Bu94;Z5-dpJqD>Y9&>7qK5X0u502DGaDipAK1c zmyXxQtw$S^69z-`!`?SKJcWAZ-yFHj9Dxr>FOOtM)v7|QN{hB-mWDfYvi^48J39S1?IO^F^Kp~Rh z-O zfaG=@5CiW0FP;A>W;oR?^8Y`Y zzA~t;rsbF=0u!53zk*JCwuJ+y#A`_3PfV@mNq;j#39{g5#J|& z$&-L01V2-e6tCM|Z!FX@`7ZrAk1z@smuNX#e`Owcf7$-(`9>0(qQMws_ahl7F8tV+ zdksN`;`@TUVNI!v_#fJUudwA8Vs=1F!~OvuZsSJ*35pohqLWE9sP%hk@h?_{RiQ_X zMno0+tcb-b@JjqNXcXUg`s0CTO_a9<6O4^Ds`+erVjxQhkZQX^!}&HRbud=>o4(?A z(~^H^E)2NeUzE**2YoA5?3w#@SB1*(fo(VY^q1@C+Lr=`U-ABdIacN=Kc2`G+PAF8 zRL>o{j?y2ic%@gU6mYAAVhr4^MO%WF>WxN+m1#zH_}!<+m5{%M2wHOj={{;eNNC3T zPfuZ(#`f#y1^4yke^`mt;^>i4#1H~(0P4w9Lw_qdzf2Dt>)!vjhdr2-)|J}adg%Bs zjqvMS#f4V7qsJP_AbdasvEANO%a{T_fFF}-R6oFLe0Z}7jw#ODld%LB4r zyzQN}=h$9^PV}985%=#4O!+$SF z3Hb@3P)gE+lU6hsngKb#9*MV(BuF80Gxu6d$U!VY5kndW{F3e54y945yMTTNB>5B{ z!2NP}yBj`u9L1g2lq5|{kmmET#ePM@f-q@5fh!aob*LpAb$=Io4;f$nSB0+(Xskg( z(pUYT0iL~nYXtrcRF)a(pYe+E$017eFgL0>A2BCj!7GuZ#kL!Fj> z9#PUOQYI3aoj1M?5L6Ay;r85=9s7WRY8d~)K*5d`vXm5(;`za}@1g<{W^kvqK4n2u zb09x3Oli}bl>yE0Fz~Qla>t_Y^=`Bvm;*v?J550t`P7x68M(FSGpET@EM|IC)}Xn& zA~xZY>9u_TV}0LwdS*KoUK7IL5;on*z{ty(tj9nj`8ub5W#c#I5OilFGCrzGYw z>}&W2xjOC@F*SPMbubtHQx^c%v%#0S%)t18A2Zur5ESFpn&`G`GV&EIcu(H1NjeqB zXvFzld$@BL_-hOaj>5>o`r&?_XZh&voDD%I7|JcetTk>Tj4%)S05C_WE=v)xq&{B^ zpT%<@{{7W=?D<#{ODS0>dmqvO5~f&o#>|QkM6dB@nv$uX``R6zIRaHYj{nNdYN?%S z|3B^v4GRkk??o5Hiv0lLio-Zx+qu^{>1om-5uba!OZ&0T%FkiCwp}{gO+fVLMeNII zLEwLeKumxKDxaTRr7x&ZI?#>wG>2V121MpzNVN5`>{@zr)6i#ylceIWSl@->$QM|1 z++V+A?*{;lU^mi?wC$aNH@`cU@!V-h%zmI8DwvFLg@oVwTZpE+w6kqCwHj}FK~p5i zE6&Y;nw!s&gQQ$7L?S4CR%ZR%#1VnR1}aL2%*^&>x(|IS)9be`&0z>+UctP{jp+A> zXmj?owtc>HA?be%uTu<{@POc*w!ViS2WV{kTIZ@DCV<*8k;+-1nod z&O)3QveaRz{`SO?K4e;W9Ku1mQ zAr7#z{YW5VBzUPn&Td^58qYp+(r~+yQtpU|Mc5Lu%+Sn2z$j#_JQCbzZH#Kwmxl?6 zt^B(BXX>VHR)|WBx5W!Z6^^8uHk@$>D4`8(f8un#AVwB=Vbpu*!NwtSVb?+Cy#V{r zUHXf^b^#Ujg>OiL{|c2R0nX#@Wb>Qe6B;uA1M#`{eJjJ&AOqrmeV4!rfh&JUBm!dF zO5%VnN7d>-#CWB@cj(mE@Sqk(J_lz!erX70F2%DMMA5WFl~!okWYfi+*>3Txp8L6j z{5Bko0CQsFj^>?lcKQ8@F1v?Fqp|-Vf=B zw?7B&|MMnzcw4FWFL1Y(_rCGTy3n5>6(mnfrG~U9P!#_}30pEj#a0T%OA|kP2}$Qz zIQ4`|S#)RvtIbt++fkTGS+s4LFoHv*+L@p#tS(j@)P%?(E=|y%&{8K>J^&YOX_Sj2 z!;rGQXm7w8T2t)-+=8k(E8d5Z`=3WLc|P(>*ZI zt$jeq8Mvkk5f55?W_ZJ0oMH~bgTF|4h2LvusE4%1H^(DQv9ej7|~j6slXYeq|dAV5u()zqD%fnkyDsE3(DVYdMD z*O#a2Ke%rjb;JH>REJf6EslgL7DSMV|E414Qq$YxOOdQHjMF4Y_6t0G6#hqX_1{|l z?&7Uq*%%cGk#H!|H+%{#q9`bRDknE_R^Q+`>1#Y}F2}Kf_@-N}&8v`-q=obTcHfyL z@RTR8^>GWic`wy6WIK6xcNcN_hlY5Gviq)ooA3uRy9VJtkDVJ{UT5{*kVnkt;q_)? zuz!O+QjtjoZ6~{0@bua~d>LxJ(+xlc>R1k;4T*cb(Nla6yxsEtS36W&X20UM>Qlb$ z4}Jy2wL|T@m;PYh5yLTQqR)QAXd#IQCm|Q&5*0J(^s*x+@kbEpsZj`k`z-{ty|W`J z7;z0Zsl;N?v^^+=AF?O5FWdgOoqMbgXTAK(y7*W>NBiM-Fsrq;l>JN(n_lPZ>+7O~ zn2yxT|JJQgfCgLwcuw)Y$WyPY>0Z+O#>xEmE~_QW%n@?>H2VnA?`cBgZV!kOlvo`P zDAPpGkpKSS1^}f*RP*p+guHnfn}f$;)jt>+kR*^aQLsV5)QL&mcr@rvx#GCEG|JRu zc$G$V1eUCdVGUNB7V;x$Dop0Qx*>Q=c zM5gzY&O(=OHDnXZ$GL6<@$i9RBuT19$j*9;?)ipx}DIg(goY zt@jSdOt%s<{O#zhoi%1*5oyT%Hko>INDODi1L?yl^X)!m(-Z&B{uJ?zRrB}-213mI zC%jNg8y0+~fgf4EFhk~t32eK~{@m#L#Q)HZ{PX?w-r=~SiJ60g<6)7|Wu<#(hph9d ztaE7m{bl@maojsmg2*fWLx~XEzAp*uBeLs)8Z4{woKKw&Y_M04QD-a$IXf15uK<_) z$&zl`=Q4C!6tkR39}$EgsfKnngO&hM4P}{gV1i?rlR@12dG@=CUnq?#_OT!LCt>1h z7}#3nGY?c6WdhQ?U)j!KsRxVhpQqPS^zJ`^Xh;h}#Nqp%?Hg1D8`0B5@WVtffBmNE ze<~R-8_O*5b1tmsibAJ)wu6g3cs5^i?xov^o|?+jEtYUU6l;Ps1#*A&oAc{ z7#QSlqN$L^$Aen+Dd@rznbRi8TnIn|uhtiWM9p@Q~R2pFzSwXEEhSrbld3a^m0Jv&RqsSb|pWv2^6oUPzwM<*JQAPSS z0OV%qD*%EoP=*Tm|6hAJ?S6wl^4f`M4D481qGAq)y4bqJs5kjX zNnQ6-ci69NMX?0}$2(yBXkmAvj%mtX-P}?y?zyM!SW2p?RxSBA=S8S(Lq;*Cg#|%{ z3Dyb1&wm}EoBxphBBnW#!1O8QNj(TM(_VE{`wS^xPYq>6F|I!x2c;ED{;eclk!y9N zZMx-N#zX!1n8-5A;e1pE_8ZrV@}4`0tl$pN<7prN=QZYifA4jEy!!OZszSmVBxZif z0@we@b0IE*k%w=soc^Rey}Tylcp73kiC$y(S=dlet9HcvBv zG>~heyuZ%adjB%x#~}s2Z8&%#d!*9Ij~D^?Ll8{;b!2^W2(6&8-dGxwc%29oh#jbl z!fj{c3DK&3T5bO`;jhfl2_iaw`4`W4;;{O)!Y1zQ1u98Oj?rRK$RThRmQEc6aGJ2j zl*Q!3Rp96C_Q`9E_m#D7v}E{7_v1S@o=9MN1c^~#Ab)L!8ZGw|yH1*ZbIeEG4a^P$ zt?0{#cE?;yQ&lAMR*NA-DNrGfrf@@8OBSUPC&q}BWHa8*HJXONT)ybWvjhLFOO^!0 zgT+Hq#hlE4u>|YKh|(N}8gtDc58>NIPPu+C#q|PiY>J2~B!MbbCbW1sksPLwFsOtV z7D;~qQ!hBnegrpsGO9#XfwJSb#~>}VBzu@n@S7FwNGZnlJ0=5n!dgV~go4a=N0VNP zKX6{YT~6Oo0(`qvg4BnviUg$gFD0nw=LBg1mI=$X^?9z>{3=hohi@0#z*XG%MS{b|P71z9fICqHPrASgK#U)9I^gt(?&Uwho+O*j1O?ZWImDfY=U`NnLxV z;QjiYSik{q+A6Zl|CMxnTHt4L%lXTfJ>Y^kPg|02SA)pp@%6`wFjl{$$cEyA!G)oT z+7%RZ&J?tpq7`_}>WU7|L+`YM8)MjyW;=zlr#bjj?fUN~l~6aE6NHAF9+-Uq2pew?Q^(}xvRg1bv(?vD(-rH_&7<(xPQ(mG-oEm?1+ zEK1|hB=TQ!umYgwFCxd;4LvmYJY?{DXLL+OMINchdO^P8(y(Ol|8W6O%FxmY)lN?s zi#n%@*i|UC#uqsMh^Dw*<7S8+9AcoGuW#wJ#6{Wcg*X^7!6almE-y=Q$ljX0#+{2% zGWiM;+cj+Z4Ii*YzYVCt0&iN}+V!~o$@?2&(130a;uDpTyfo>YVtHk379XFk8f2ot zZ7AW&vf##&;p6eTphTWUx?zJEQ$1=t68RgEePVfB&CivZmr>)ZNP;AuD;wFV2-;Pu zX2aG?KTZj*!FHJPuV!IFEsvajHjSv0>2Euxm4la1fV~sj(dP)`zyQzje$xpO3msDj1YyINMl*0-wif{My7Y=m0fbhQR)(57A#SELYDjiqRgL zP+~!mrb$68-YT=Ix8YM{pb4hz`R5I@JMkR5xk;X7iGD<741=XOej^l|Hpi_n0$boj z+GvCs0U_THgGHJWcmnk*QNFZI40~R}%2!qzI-j@XK4ZaXBhM5T9Skb0Z&3@^d*WGz zQi*kBMlXx!rHY4vQz9vStMMnHV5d^a_yby4VOBqzPPVqe8&ZC+2`un1`9+JVKuVsO zf`9HGl5KgIz;^*y!UGm;_su+ijxj6Bf)JEMCK0?)23hfeCn;z>WXYR15`h=Qa50)(M@9GYPx{eq2FpEl}MHGAQpnZtq zJ9g=$s&}M>@HxKc&SM)(5v%~SwR3-!$Lld%R&VBV2QDNFZb+*m^?dP7qmEJEfXY8s| zSZoodBn^_)Oc+W_pWKor_j0_5v8YuiF8AbsF~SqOiM&lH{UIzN&ENA(?P{@Pb$*PHJ8)33XP#WB+rjrtWKmvdlI&O7KX?Of!G`!y1g zF|plkZv2+7-XoFg5ozam==wXvj|G4=zhW`fd@D{R9d=9K?+#5aY;6!#JWIyoMnEgf z7i%A0ycEk90wW#p*tFU^MLMqN7_7?}<}p4L76ts>|MxM(9mk(1YpyroBk_UjHR-WQxRy;+j!?-o8G5l+^iD z3r?45hTdS)KXV+P;q)>amW!jFj#Fr}7#NGTybOl^i1MUBpEFmFOh3WRC~;iLQG5I< zV84s>^+Uirz7mX3ay+9Q0&690geBqc+vfLakF{WY!AXsf8_vl;P)^vwOK@te;1&PkC# z6WyC}Kp4p8ZKBg~>u#Czai3`WChLXCknZpVa@6a(gPB3N#xbb2)mIVDm_0IAl;HB_ ztHb+CaMg~%XCR=7ZLW;PANgJHCXfOP-JlVq?%zo}H@zCYzg~I2>Qq1yDks;|?7n*r zL0_>uSVhQ#K{aT0h5F|(^aiG;ZY!IIVZ+$9%Vpdo!O9kCF-tw)%HtK{+jZzQBY(|ju44W-)Uk7qq(m#$hh%R5EXRuJ*DX*u0)|g@i7?&&HG_uwB$7`HJ znlfeIUkkNTo=pV;N@iV-E?gELle!wE1uuk+_mcW)c_HJ2j}7{`Q1(09`do#$;% zrfb*!2zu@@wex&(7~<%0Gqx>}t3(gB@|p$|6q5>euZWP~RV+WC9bkG9HZlLVJ$a2T z$l*lKoSXxV3WYSB%W|&%VTyfNzl2G$+mrh59w|S!^Vh8tGLHc#@6Q|*+IsHV@3eIX z>EUxHlKxsJVCZ@xmQRI>D$_2sU8tq;kV7O?)IeK5@Spo?WB)INGCQ_Mac*jB!53hH zw0g=_3c%PlN*`EHmzOb|Jx#xhQ7f?E3;`j{-_;_uUEtOM!?FxP*YisOTcp-G4!+RG zsU8zHiO}cm5$TcJg~EKmqM-u;p8!XL%##rfy~ncO6?%hk`Cng&62$8vC{>Ql&Q8xh zStEqSj+qJw9Ye4CkRy|#G*^Zc6^5RB=oh(=0;WvQ#WTl@*KGKKQ?_FO3ax}135&ufA;($b8MPS2N0MBqPA z;0Im^{O>=JBSaDHFPy(g)b?*nX6D5AIJ8`~GX{a7aV+{?BXqb`1k)P?cnbn*zPLEg&Qsux7wA2i~fp zA?C>p%e})j6gg6{%A`()|w0C^pD3LU>Kpmp8KnM62dG==5VEspM z?WUP4p}nmpc8g%GHDNo8pNWtKbpKm9q^|8pps~ZOeo2v2a#U5I5GIGcoFQ9GsgpDx zIHp1j={3exsPm2gEKTi5*N+4h;zV}qY9)?7Yn0kVNLJNXFqLZPb~r?|!X{{cBz9#= z)LWVH*;GLxB4ttR=f22qR<1X_xA=xCKB1OL0L)Zq*&4hcS+2pyDKtE5fai$G?6BVq#v4 zqQDod@Qo)ocFA~oxW36s&i39!q?!h%5WFU;VAy?Xcwf(aw06i$T*9^*w_47vI9dApXOm(zDD!@b`S^RyL#EU8dHvm= zr{)>h%-+!72}lLRY)d{>z*`L8{;0H zty1j<>YN9X5DXvS>h+VCA`HOr}mrpnF!cGK`zpp{N_p244}MW`ZY# z0{~oZaGRo^Fd_z5VW=Oe3u?LN9gE`^kCAYp?1S>>JGlyZ!Im1|%2~kksPlOGtsSZi z$q9_r$ax1YRqBlJKTy~_9unm_&9ByFn?I=Je#-~S_E`LlpmQW@9@-xRnMKYAbF`0*?esXA z-2I`QPXvo4aa6>aR!m;Q;4${gnhs5dAhGsc&esQ6tHiwc9%_+AA`~{^WwVXjK&Kuf z$~pCMX&lRzJw^&r)D=0f+lH=KnAW@RZ)W->B*|glgNr92{*)dZv3W z9#*^WeD&W&lD3S8+5HRUhT*Vf>cq+$X{R{dL^_D*EkLWKpKz{89WWBA8=p z?8q1zTiW(Ks%6UCoy&CFCDh#8rqU0}XcD)mFw!Fr7pB{;dsJLIw;*(hbPC4Vzs_^j zt4?6K?ptD;LmJIvkOqr7rWd!tHMFKE_Q~RDOBwg*=UgF*Vf~#C-(-DWs_gs`^P7;U zf@qJe2>6Fa2%nSx7)M7xQ^7%22fo+vzBT}CC!e5l(^rBVm{n2Jr z$K$@@+eNE@{Alh7wicGuHsO2$F1I8X@4iF5D?TOqgvetVcpb zU81o*0)G#9JdCj>3vOu8pj}8!V!jQP_+Qf5Rd#EH3{xbB9f5bIrk9iGy7K`aa2}lM zr~Y8BTS}jZc&zD#wM6o{DNaWShxJQ2g})QckL*^R(fBtpW3aZor5L+c=JF{0m(97x z6h+mqG$Xpyv8sr9bn|GtfAMUrVH4&;_U^Wz_@1JDG7T?r6cd{bLmcN7MzJ)Xhbm9Y ze`k5d-2COCwzy7zE9(RooYz_q8s8U!bCk8Uds!TiEX*Xgo=;IXt2w^=Y$cHA;|#HU zngfcQLh4hqwrt&__VCJlMDFZQ^S)k>8zZ){{F!iS?(v=sMcklwwg_jkVwzR|GwV_af7q6#aWF?yi3jo1<+AT&`{l0o4hbh<(OSh z&Z(2IP_>?VqtH*>p{0(@D(sDYb@=?zd<~G<>Ne_#62J=vbzM^<(e+lYNb@I7&BGGv z(p~p3+yq3-#WZZ>_Y!Z>Y17@Wa5&aFk*x_w1EC@pxmQ`d=AxXWTt=e>ifZTg7l>Y| zn>;UyT#o4AAR9N+A=C`jBQA$0@`xRi8uy zygT3NsswNl8ecgsmeika1Q^wM!%KgHw_``Bp=|~HR7aWJo&<#%{IhG20OW$zDdV+lPz{rd4vvV_drcd-EbXWbR9fDIkFE%1kT z6s=fGz2sY@gk8InJRDzLcy7c2Ao5;0FF_7Fx_qvGm2oc0uKKUz!rmtxOp_F}(7)~d zmwD7~R7$&PyUa`4w;{gl+d)d;D7F*QA^ju#E-HoLO zhDZ$rw zFp!<0;{n96Vh3@HlKh%_K*ZBMZHZqzhhWj{N8^xA_qY2dFHLi|n#`i_Mh#j;MOH;6 z|MZ$un${$d`^4*luF9)uDBbKaFh=~6GyDOMBpGHkwQrZ}-`OjbwVj*z>plA9xtfVuQ4<^i^5`W!IIpTeLl||1W&tq;%cZkNfB+)c+R-|fE3_9LOuI;$1A0x z>bab}kP_GfWFyfRkAtxEt4T_8&*fK@F+-<=T`=5+*)SC9aI#SBQ%$ALL-wsh4dv8a znH}01+Tn7B3}a_CQOn9ta8cgIlWJ5Apc2a^=pwUG)(QK*r4qJ3rtI>6Cv*rI+iipL z4PG*|QFGP(L(RXFVWdpR-TmCpaM4}5w}#(b>F{=?%W7~)>?ZZujI64Ee^gV@_R>>+ zcb-#&>mC<`CpiA`GEil0N1>Eov$<@WVRWxdh`KqKf_EM1m9&ilfw|e%(a}7y@AZIb z1EmMs_c>|OGULOe#4EDmRdpCDRn6;7UxWX?4W{Z6MV(3}<#EHH<63$Mr%~e`G6)_0 zs?aK)(i-#i`ffDL{y8{AJ}t%M^;@+4@Uzbb=&savwOE9SfC06j3@*nOxULjJQAE2h zL&akm-%f&or4%}2=+-Y#gvMr3?VGt`RaQ@1W(DY0odAtX217j#``$0Lju=<`AmQ`J zq6udhL*fz-(&SA$7G!x?bI^`4`5p7OMIuICr^G#9zG4&nx_$9{977InjNmLm+U|M^ zLCY08$?GwW>{v&uN|w}BtCMA9<9`<|rtAVl$2wT}(}+kbOrky+2VRfc!MAHAoGsal%j5~CW8 zRCY`HVhZ6=Agl;(p1kQ}vE`RD;Y{v|)Nhl&w_w543hOCxf{FsAoDKmeJd#r~q z#BL3u$A>exktUImbGt%ccBI++)9=Pm{x%F@W}1w=*I!yDWY?LKz{-M9^HT(51eR|x zIno2m<&++XVtr(}hA^jM%OdcM4mpDWf-{h$vDs zB*aj;D@xPE{g-qrtO@>nYW*WxQ|kx5)Jmbw)6x@(y!tDu-iN56@(y-NH8SnXpO~>l z`XRGiap|%|Ms-cnbId$sLZzy>nQUz>iqzEhhjDHc*MxWmz9yiJ(pyASz}0D*_89-y zfaxV|oc?mf!gxYiWj*1lsWI^n7t!Mi>f1e0`#IbfA)w^A6`=og?DtV6nHTgrx6$NS zmpmT~kH=pf4X2(oI(9}Su@F5d#Vf8CPLCKhbxi#|Hu_su?vp-!zvnM>$s>J-z9(D` zT0Bznp#&oxa_Kx!FQEN=g(%Qm8Ij9HIGxEA5Q?xBkefBFrEO$py!<)u)VXGrEeP3% zU|vr`j(5!_fA)0oGky$KmSQ0+jylgE|7Zq=vHL9GD-5Nd2&v z3erR?QtXN|gS-0|k{-;@k0o*Co-cBf)2$QeEZamV#t0y!0?acPMs$A#r zzrO7uiU^tB5qHZS*INR|f*UFhZ?g$ndU@J9pwyK0#+MoK?rY0kS6)ra{uZ$?>?9A~ zrslDVR*?h%!zV7*EQEGpZolZ~0LYcD<{e^PuBKx%P%Y4Go5e$vF^0stC|T6VFmejG zZ4@KhBw3U;<1!lApUpWi!{?&?B5S@2?@MucnrJ@?2x;J_Di!BL*-O`-tLAca;FqBt zaS-I&AAl)6Ym$xPSj(`T6^EozD{-9XwpV-Ei1jn|0zunmf-tYI^j@TrpS^ADD_ZdLm36DXn<)d_UE;E3U~w zWVm_PPG!`nqSmNOP;`o?V1)xKoRQnRF2oAzQ-<8Fgbdzk z02k$7SM-#=W_=OZn|Rr;s@m>bHyR?0KYM`}M%{GjbiD~X@%Sj#&=Y+$McTwo)}O%Y z*6-M5Uy=lRG0CMZMLm7L4FoM|x6=#=Rj3#x!wxC?2{(>IidIl?yeuH=yvX*mQPsi= z6xQ2Pt3VargEGYSIw=uU0=t!>pI>?|r&%i=lZA@9Ovo3HXi|adfWp?{ zDP8tfx{p^y4CtE0T}v!}ZlP|V2A}pIf3M7ciN|y4mW^y&UMfOIr{pFTTb00O9x0_q*s}l{jd}Jj@Td24-xN@iktHP}mS=j4yj@NN9dN{(L z--s97YNXsC^I3WExC-PDEozFWSBYbS%E8cBnjsO|*vHiaP0dh=K&nVuLN}LRggZE4Kt!i&#hRG0Q5GG}m*XVm8l8Cyfm# zzWh2~Z#N;TC|)V|c@f#T)i-Pc>%kSwI{sFda7L~tDoaqrLQP@<}6TgR43Jt z0cJmAi}_%sgt-o;C<~Q446z4-f_~!c%2!Cu*ddn4ktp!8KjAi&(?G<*SJ(V`^rl9X zj;XhpDO~m@Dz)5>Nh=LeY}{!A~RC$PBrO+t-2 z1ApCQxaaaBxHDdts>lPeq(#|^?eWKYI^bGRqLWPY$tjQ4*uP8Xh%IC{j=pPmhTF(JK6cmp;yZSeEzF`D`D1~h zORypn8rmIUI5T!7V6A3?SI93tED92{Fd3)*X2|LZtKr$16A)&RoB3Hn@@Hh zLu_8>eKH1!eA0m%AXjAofv9bp@Vq&`_4&_#^#hQ+wEaPmcf9F)uPsTSZN`*>D6@c^ z_Z@;^;M1B$ENoT@_B;s5^M0A@2L7FNPjUa@(^l!+Y_r8cJ&?|(43g;%?uam^IrwnP z5?4Grk6V0U=CUKDn8Ki?UD!n783Dvn+MdCrEr)s(qQzIU!^{jAOf1GazeMcsiX&yZ zyLaPvET93j0;X7}e^_$4*7ljxMJ4lQtDflW_=eR1f?&hV&W5+HXpgv1UtsUp~^VYRV^8lqCqyn~4R+C(;N!&y#;;CiJz%f{k(FVU982~ht4%S8>`#kjW z-mf@p8-scnUV0epmaUsEC!@XN+KY*KO4D^6N#mZ6tHQ!tch{QD6X@>&Y{W4OnCR=r@Tg;iw-1}NawSL+!~Jbak6Tt zPB7M}**4yw{pJ4ggH#Wl++X&C@xbx3P-OCe1iL@Af8BW^ukIm-TxP^Eyon^jYElzjmq z-bBpsX{)ob{t77v&epw#wVDhsf@@&MB%tmlm%U^S4}$q;FeW2vGEQwrRi^A%PAvBV zc%oNw`*4$}d-`?9u|*cGmd5)4XLo&(g33ssdN_s#P^kGPE5LAY121j=_13{B6Fwef zh8m&TO!t>@_>~|OT^YkZi+4OJtYmbVOxkyj*KV3skE>Rifp(xts1H_?)+W{R5}?i^ zs@(zivb&-#fC~nEz))7Aw~OHMvajBk;d(m@HAXL+L~kUK;{G4xKY(eQ9PNFR_p-(C zwuN+hI{RN&nOy(ryY0s(+hd2S9a|TanXZ4-(MroPLK_^0Ms}=6+^3p7!qG`aTZa#( zFnisYGHKEx>+FP&S7$N&o} z!uqGiJ#%;Rw?0)g5^5o*N*Tv?rgzBxD#iaMq)}@FS{nkAx-+G1WP#1hB8nPouV=rc84?#SL-1VJEUhe~}a zA3>mL$3|z0-SPiH?=!eK zuXIrD7mmVABnOSG8T%7A+ld!m!-8O)KZ<9k8Fg%DCCFAeG#X& zYk+duD{3)1WTlM7mHo@Ys{L1|A9Q-yYCh@%{eB01)-e@~34jVT`WwEVY*!z1#j&-$ z?@lzZu&^5G(lRoP?d>o9j`gDd+c1#>D&IMT%GO$Qv^>lZ5o(6TNh+h6! zWIKGqkmKYMu2=}<>dX0eT7T^5t+3d+l@-_J%IY7MIzwaJlQT1%w(_O8+-#|c1O-~O zfyY%MY-(zqr?OAuyuM+eqgEGN3qB)xL(h^tcRDTLV(WPxo49q3%0-)Ehl&aqEeh=@ zl}qMmvLq`wyOB!Mzlj42%mQTM2u4;mCJc=0D^hf>fDex$ikk z$i$U>6;;fxPfSRQDoCT>H=I{PSl1-=@Q2=hlZBa)O@97^3^ZUHqP#L-dXkJ7aekBi zYc!UM{k;#^;r7#iU1U6wB1GkM(5sWx9Q3Cm1d1@hw3xQVa;PX2y>4cBj^8U!8?N?n zgN(hHz^vjR%U64jJ*q+XhpF)T!u7WH4D@beksC8_n|SL3f>_fI&0>tv=QTeqF0W5M z9;bl@7|$WlMy2}qqhVR|o+|7)s+`A78tMbpj_S~y{z8&$`7za2SU6#SBLZkigz(ljp+oAj>zfX+)o}OB$gI0&z{}}#b8(z5WDjh+Qn0<6+tHLU9%%}gl2@Db zP40C@B=BLhe@_;qItX(xaB(W_yP6JGUtITvS?pmkKxu_;`ts2&a4Ka4rZ1;XS3N3gk{BGvG(*rK*j!Vdfm6so$+S$L)*-*G8rA((3Gb z_p`_s8`2!l`2|wc0*AK0GP_4I=fRy{C-8xx9(mkt6&BgAHq^+A;)Z}a8D{%U>DKiZ z(%0vH(nynR$x}tBhA8b6kh|o;6$r=YI7Y3|)H}bmEAUTyvsxC5kL3@AkJWyCInh@X zS)2+N#z1J5$1)-*r`Z2(fb2{tJizv&R^06hrj#Iinwv9R7O&5xgKh)~iXLB_Hms*6 zGl3HoEzj*>14B=5MZZE%KLZdP%UfKPeQ5MYpE2~wEE{}i#yA~MC}#8D;oAC2kI(!^ zDK|d1K1x@0qLjRcKgmF7xpF<`N0=Rw86E^?A&Z{kGv7P7$ z5d$vi);^;yxx{UKkL#>urJPZczpD?`#Ad#bG-$4Q4R7i=V&1YL%?hWNy%V8=78#$x zVtR05^jqg^jIHeKpV97r(IKej5sHzj>qtq`?Z`sMh|sbTJFxbcVV z(JDt*3F*OJfD8U+&SL&%{SB8O-fuJ>&>Hc&n-9SYu zER=oRjfqLzJggK{W$Bbp^_L?~eAcC;^!dNO(gwhl-z6n_gz4S1)5i4NiIHf2e|vUu z9k2Y-qasag7defKF(TJ_#XTg-UvwdC#&;$ao{E@j0)c99c}$tyVjq;RbL}Suix2SY z|AmjEHE5X?D2V55<1{&jnXP{>-pj9gA%~SUCzB?&Cegs&_N?zc*ixd{s}Wt>AeWwu zG~XN4sD)L<7&@?TrGjD0^Kv3%=9hHYvEo(?G!q5XUz^4wIn@|ET8ccKuC<57F@{`8 zDy%~LLOBvkN`ngd5d9Y~muwdL>9V>;PJMQfNl;uP$zlqVv<&Om0@lWB*keQdV>Wlh zWxdDr9OLF*cxy_}W~s7>O5?9`vp+RA!&s%KKiPw7w%ako)_KFi*=^RomaG- zJ?>BrUrl7BFmtaoNQmvZ~uVA=$RGB_KYQ$J~MrWS*X!Czr zg6S)B=CI3J$i;By2Q8*2v<2@~CqPuzlJSONvHQ=dLWhXj6iU6mp#kps>V(`uV|o** z7Ta^~?_xNMr^Cgfu4B*D8n+WPP+{;P-PYrRR$Q6p$|^Gf>G;HFJhv#ab*xMOxy2nqA~up z=FW!_T1?7dv28IA1DGB9ma4}dC3RWXF0E47rWswwjXI#(V%E4~1*BZ_{G|718Sba^ zLmZutqt@>}2NNXT=l9;{Th0e~;_usKAIUDCv_a~0@}W-h9P1yZ(3Ip}8Tz(d90L34 z@z<}nug@r!)T(N@_zM!=^o$lWf9oU_xv_{mViNXcJ?=-z#5goX;XOiaTCijBEVOpN z=fq;9sCRuo%_|;P#tb|1o9UCpaIoUrR_3^$?V!WX*Q5>#-2PYh3XgU3Qko_}t0_Wv zmB70=1+|?a9w?4BDN8yN=p80Li(#5G@*1%*XR%!!UY;pF^c`AF#WHu_uhk6Li+aP{ zz4P-h7<{*XN7eayFoEcB`&1QqCK!e5T%8h{mW-%N8bh^V#kf*}1_Vl^pg!^7$8Lav z)ch9)6X->Ae-ysbs-D~mb@wZMo-NZ~rlaj&qWPsK53}n*)^bLvPTHN(oZ-xQFfjgf znEy`7J14B35|ue>7^B+la_yF~Wkgv^=h-M~q(Wm$6DoebW9)OT(z>;vWh;i2JEniZ zVBKSLQ4TE@;Qpg{AV~6gU!BsdLJIVqg(+XNdJ(J!i@eeT!npp^;4}YljKzEL zl4!8bPCw=ARvYppAiapR-0g1 zqv9IB5{Jx0NXI~r6VPL6gH54(5IZ;FgGYy#$Ds}U%cot|eZglP@kAoTc0yR1)RAPl zYRZ@NR*h~H;&C`)^W;`1EpaAuBH`rp%rfnVw7)d4Po<9pccg3c1E-n%gu_V_B23y* zOZ@?s{-A6_1XLx#2anZPt-r_RRcXxoYI+bW4)^oH9Aqx!KPWTAI$O>VQCMb|uKnj- zFKvfZ=F-Sip|VPOy>8lck&Ce$P;CWXvX)!_V^<9esHZyxFC3rCzm4EML`)nV-?lVH zWmyqU8k)X|tfn6WBFmgJH6v`A#-Tc_L4J%OS}~r^bJ)y>a8<{@-ZyO#@s-{$dm8Fc z%LfdzDCy-D8IoSq=CyoXna@O?)5>@v9!EfrGxZmris;Ic8438}7OF)JC^dDlu_B+~ zH&wW3$vF+!1j%py4>zXr;i|x^!ipDv+@0EPpHT7#GN<91z-4oVW~a1S6HVf;`_}J! zzUgC-N)b-}8&+>|RWQvUWrE`}ZEHb2ru&3WO4y?D3Bz;3GasXdi6FUDNmHV;+N_JD z{1%@6W($dPnUE2`#k%p;uTT;%*>ginqFasCNMO2{T~%SV;qr;QL_|?Sbb_VT9|u8O zVGinZ;H}DyiQ=v$cZrGdD_}rDHZyQ=?&G5iapSplIa&7=TNEKi%G&GRSWrv=c`(UU zDJ6p%HK=FjKh7!fMd{*w9uZiD#^VcibvyqMPM@Y@``8N4dhZHyCpO24ii)5Q$zlDc zf{7u$VqKVX?)!jC39enYv3*$=2xk+F57lGv8Q_6L)(jsGK# z!n9e$E1tZ^+}G_xzj2ug+~QvCVs4d4?XADkOIq%TZI%V^{|N;T$wGEqt{r~~ESrNn z4j6=~nKR0PwzC5P3b8p=P+?W>J9D-^Kd`1{je-j746VB~Ri}o%{$F!f9uDRA_NStS z&|=A2ipuy(iR_Jir@@S6WQ{P!zD2e+B3rVA$i57NEE#(tL?YW@hOsY+Ng2!7-lM*M z{NBIbKi=!TuJ^BV&6(#p=f3afbARspI?p-xV`Ob4qw@4?nN=-&MNtAgqEy+RpwhvM z7m+xf%Zj4Y=i-*cn%p{MmW5fV;I&`RsOy?uH&wj8?V>Dsd;;sumG!hwRp8((1C2yz;GaaKJ$oo0+iSE~NT_U=ZId z9d^XEp1*|abtHVMjH;QH^&$ei^?yAkX_Mz;-Y6+|>H+6PT(V2+o8|kWvP=1Jp4aFM zZzcjcq^}*1Pq?`-#CqR`JxiBEKl99!S9Q%hRtMWmTmJCfH4&tp(&F)OL)XTOkI%d? z7{t6X(6}oLV_|C3%gSc#?L*O?eUfg+T(ZvN^UO=~tToPn>*R!@c%leBKk}A?ve=S; ziy;nC(d_TMqFc{-*;)0A(ubA7B~v*XzaC<~l(8D@lTF7+e>F-Ay)YDMIh?L~?8doa z#g)4bH#wtk zLq}?T&&$`7vQtgH?DF2#A-UU)ANZy2s5??B zaJIKVTy4t-c_m0jTRM31hjz@8MnMjpPppRU3K{l^QCL2aCjCT7;i-|$aDT}SBysOm zY5ZkPoA}lF#Aw6UZ^+^1f6hcP9~?tEh0i&MyV@xt9Rj(0^z5at{2bTgIl~p{8&wUh zO#Hb63sJCYJ)Xx?D)t?o+JP80woEvnn`j)9l+>UV+19zDhsVSpWbFdoIgAAT|N z8^OsQdcQ-ontKlFlRp`vCgNGzql;b; zqW+m5$sNbnN-80fL)DG92QKN}q*}V?G1QXLA4`S9xN!k?s+m_+kw`^Fi(403n)KfI z>f=569z?mKF1T^_qWX&kXY5SVUJV{EHfq&ZvHj{x0=vf_d7j7~S{3L}YE zk8$c}wq>q`-w3jB?@H@&$Ei4X%ad4NB92O^{nN%yv>X=5XfZ}ld{+`u4=TW4RrL0$@AS)$S=2jvn|KX@` zw@h9<_CzoYtY#Le#`2!bW6Aw{@I_&wJR{y!n|o5_>ie0aQ(6k}ix*Nnb{a%ek#+7) zg{5>63f6WcC>M8Gv~w0*SXWp0=q&rYWAV&!8iq0Anw5gCZmj*drz8G!@kBbIkiNDT zM)r~{KlfcJCDbCI}=W<@E7G2*yUj`3mcdw7t(@! z65{>6a0Qhlzr1>6Yo52chcrg43)AQ9d4wso`nFL1TZ9p`q8Op(_zsiTE~_Jc0j{=d zg%yQ_pu(k}R-J!zN}+1iQ_8DlnzwU{uxb06FClq6;dDc(V9VTC51i(C?QOqHfoVpQ z9*0HJ*nPygR-Jyt@1uLaJV)6^@h&yfO>9ZnpD|}@y5zWut&p`VB4~u}p5{C%EPfaga*X?6>UYFt>~x$9{)J1)?4q59$7{h_ zee`Cin?Jc;-p#K%$l=^X>FvxQ=uQic{G!WvTflXJ(QSmeu?T&jZUonJhVqAX-N{>wbM)WPs~mAg&>ey(;FK@W!IvXLj+TQdCWVB2 z<=~&0v6!Ux=?2g;(md|g7iGG8<6Qq5kP*_V=Hbqqzg=}A?zjcS_X zIkA%ux0D1S5cX!C=Fu1+_bBJBI*d2>XV2YoFXGYl&>V#d4R5A=mjOos!&@U51M?(9 z=7*mOiyNB^t#ym8(E%gF1_xsG5$6x{hj3XJ8Qv+EwH?P_?l=GEb3Ddp|MHw&A;bab5d!7LUfe=|&n4K|=PK^IXW!3u#0(>V;E>3*5&~X`G^i zKnh&wl)zmOUoj^)W`4nDbjzsU!EY;l#PLI*MLc)Df`&n#{%0TQBci*TKj*q>;PF5G z(AL;*qcQy1|LvMb{Mkba&rTim{S(2!51J5$8)0SZ*-FO``q)+f{HO2?jb`S@vatOT zqU>smc=#?$`IBQTo#MJRcS{~Nwt;rcMLJE7GjvsSomnEv-dRM>b!o!X>{!nz3hF;D zC=Ha)vJwGp9zh;J+b#y^jORF z6=8*`kDn^uv!_>k|18Em0b{bsyS7|M&%_+6rcILbRI93Y3AZQ6e}x1JNdIeqzs4%N zdiX#ghzaYXe-%{tSE&oYq!7r9i>D5QCPWqR186^F{k4;o{{MV?2nyZ${B(+(pT{$b zZn~W5CACO={`QZN3iajDD#M_lAfyk4xz3j|6w9wXkgLrhzq{7o+1ZI*+o`XYW8xH3 zv9`8Oxo)kLu=a7;$7yxy6VgKz0^y?rGb`j?ym+w^R5Orp8v0@BG`+Ui&n4?qOrtL4 zQiUX1gf<-Q{*&UVA%!IJ0WK{`@D+3J4UazF_CNZWZFcv4Z23^&wGHoCqa_-b+IaOiV~P9G` zk(^Kw5$c%h{MR%tafjIEmKF)O2?d-*Lv5dRzM`UHt;cMHho`4qN}gW2T;Y*p%mtqF zU)j=OHm%2JXJ#D8je%%FNg7b(k|wIbzbY#`d$7>(imJN0)8{xrP-miXX`MnY-Q0ZO zy*!Epri_S=9;)?T63~>EmQE3~ixAjaNls5M+1uSta@sC!AFXoAudEaY=DXA2Pwh*- zX^${4$Ql?xP*=vxPMvqD;|%PTI{DJ(3Eh=?#SF?pT-a78+B^%KX&dKvIQ zCGc#@@Lfrw!u}>;2+#7&)#vtSx+F zU|}JoNH|scETg=?4`}x1>GtPpCy85qfas>lAmaiy>Wzhsis2|!ikO%f>zOlILWX$` zgc9=W_v)3Prt@f}zO{Ac{jYEQ2-|Gz?AVM91x-y&VEVpy_uAL?wkg8$ z^5&q&_YJwsT6t@GyKB)4DkWtSx3=1T-f3rZH6lEGmAbS+4kpM_>a$OryrfU~c>4KM(YKS_WrPZ?wstN&S0k_}K$A0|tffeKNQdN%qYQWhVOMMPOHuC{pz_q1$ zqCHv!T|sHG8Mg<)^p&n;3xMYVy!$jO4^MGNhX!?-Xxsw|b(&Lnxwud(-n%sFtWTYw zW_vWRVNbezR|6T0sI@KQJSq-6UT3;JCP~11p;s}_5h^IC>hA82CgI(436_lkrt>{- z2|HWAtK24=J>FITZMU|zfWHm`$4p2|!x`r5Es|6n8Y1o=e9c>J(^P!C6G+$j_1T~R*LFo->{rIfMnEQ{R$N%`$ z?UpF6xvZJFyoEsM1vFI@5zIVN6Gd0Y`v40jBql;(uzlFkX0v78WU<-k>rl<^6p4O- z{NmwZlLIG^f4DwS(Q~^mfNLL&tRBOM1aPXE2BAnMV6)8i z`E(3yufVk8ej%tp<-c4-SOXs9E%&J7CKbl(Tw|6kQa)p+DSe*C!7;oHS1 z&YNob`ueqAi*Y$HWfCqkr&=ma&%7z9f%LAzzQ<@Z>Af>iEAE;_y-A5E;IPimpI-{t z+1oo!w?#!nMj|{s%7;oVOZnve9a=(}_E#$oL*NO2;K#%(gW!u%KXKxOjMqXe0|P^) zFU10U5|`UUiibdCNoc7@ z^L(rK`@PmB+T;M31H_kCUiK5Ub~7C>X}`Ke53mK)a~`iZ^_=^nkHKJSwC2Xng=XHk z*XFR;my3FjNd~oV@_`wJ0A%;}_B?9tqDLzWzrKZ)IuqX)0@vo2bU|oo0b*A2R8R;J zSX}s)4TVAtlCGJ1&33Zc+1UxfV3xwhB?IfrMB!y^5N-xbEnyA2>qOd09VI>~DgVnC zoj}@RK6<1)SAcSg;7blPHhYiJS5$oD^J6#@xDA=0bPHrc^r4Z56+{N{?)Px0DlI^d z2oRY{?$%@hzQzJL`%@Y=0u+VC#Sx2(i=7=Ey%B7}wiP1-4G(<*dT60i<1y`g4|O;> zIa6T4jqIWp#X~qV;cM6Qz~vq?X>1n1`?N(r_w?L(!7kDVym2r`^X#X#HuRU*H#SHs z;5h2c{Cqy(UNqnx|AovjaeyCkmiX%Gs!SlQ5^x_9#2$cL-8WMDj*gBp9y8BrYm3<{ zV|7I!2>Nf$CMBe#U;!TsUcUVOcMr@MaQ49kIXMT2Fdj{!XJkKM=ak!lwIvn}*hCRC z^xT)^#>or-0*|_}lpFU#0gwtNCafBMbqa&r;fH*%1q6b9Y+cSM3dvyLy&Yh}9Hz`G zbKCU1a&!bPT{%dZjz^I@NQP6?|4p-OI<6k1TmJ`X*uk*> fi!AQ{!R@qQwL<(Q#y;wm17S2(^;AlftRDXt4ft#V literal 121106 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 literal 40278 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 diff --git a/docs/api/features/images/occupancy_tsne_manifold.png b/docs/api/features/images/occupancy_tsne_manifold.png index ed2f566eb9e87db238a8189c6dde913d198c772c..e10d0f51fa1f1fab48887eaaa0ec28ecff33de75 100644 GIT binary patch literal 43302 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 diff --git a/docs/api/features/manifold.py b/docs/api/features/manifold.py index 1f2e7edd1..b066f913f 100644 --- a/docs/api/features/manifold.py +++ b/docs/api/features/manifold.py @@ -76,7 +76,7 @@ def dataset_example(dataset="occupancy", manifold="all", path="images/", **kwarg else: raise Exception("unknown dataset '{}'".format(dataset)) - oz.fit(X, y) + oz.fit_transform(X, y) oz.show(outpath=path) @@ -95,7 +95,7 @@ def select_features_example( ) X, y = load_occupancy() - model.fit(X, y) + model.fit_transform(X, y) model.named_steps["viz"].show(outpath=path) @@ -136,7 +136,7 @@ def plot_manifold_embedding(self, algorithm="lle", path="images"): oz = Manifold(ax=ax, manifold=algorithm, colors="nipy_spectral") - oz.fit(self.X, self.y) + oz.fit_transform(self.X, self.y) oz.show(outpath=path) def plot_all_manifolds(self, path="images"): diff --git a/docs/api/features/manifold.rst b/docs/api/features/manifold.rst index e9c46755a..19f7b1207 100644 --- a/docs/api/features/manifold.rst +++ b/docs/api/features/manifold.rst @@ -71,10 +71,10 @@ this by assigning a color to each label and showing the labels in a legend. X, y = load_occupancy() # Instantiate the visualizer - visualizer = Manifold(manifold="tsne") + viz = Manifold(manifold="tsne") - visualizer.fit(X, y) # Fit the data - visualizer.show() # Finalize and render the figure + viz.fit_transform(X, y) # Fit the data to the visualizer + viz.show() # Finalize and render the figure .. image:: images/occupancy_tsne_manifold.png @@ -110,7 +110,7 @@ the ``f_classif`` score to find the 3 best features in our occupancy dataset. ("viz", Manifold(manifold="isomap", n_neighbors=10)), ]) - model.fit(X, y) # Fit the data to the model + model.fit_transform(X, y) # Fit the data to the model model.named_steps['viz'].show() # Finalize and render the figure .. image:: images/occupancy_select_k_best_isomap_manifold.png @@ -135,10 +135,10 @@ continuous by counting the number of unique values in ``y``. X, y = load_concrete() # Instantiate the visualizer - visualizer = Manifold(manifold="isomap", n_neighbors=10) + viz = Manifold(manifold="isomap", n_neighbors=10) - visualizer.fit(X, y) # Fit the data - visualizer.show() # Finalize and render the figure + viz.fit_transform(X, y) # Fit the data to the visualizer + viz.show() # Finalize and render the figure .. image:: images/concrete_isomap_manifold.png From 753e4bac33d20e1101d663dd4beaf1db0250bb03 Mon Sep 17 00:00:00 2001 From: Benjamin Bengfort Date: Sun, 6 Oct 2019 09:39:47 -0400 Subject: [PATCH 8/8] Hotfix v1.0.1 Version bump and changelog for hotfix candidate. --- docs/changelog.rst | 21 +++++++++++++++++++++ tests/__init__.py | 2 +- yellowbrick/version.py | 6 +++--- 3 files changed, 25 insertions(+), 4 deletions(-) diff --git a/docs/changelog.rst b/docs/changelog.rst index 722aeacbf..11c69efe9 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -3,6 +3,27 @@ Changelog ========= +Hotfix 1.0.1 +------------ + +* Tag: v1.0.1_ +* Deployed +* Contributors: Benjamin Bengfort, Rebecca Bilbro, Kristen McIntyre + +.. warning:: **Major API change**: the ``poof()`` method is now deprecated, please use ``show()`` instead. After a significant discussion with community members we have deprecated our original "make the magic happen" method due to concerns about the usage of the word. We've renamed the original method to and created a stub method with the original name that issues a deprecation warning and calls ``show()``. + +Changes: + - Changes ``poof()`` to ``show()``. + - Updated clustering and regression example notebooks. + - Fixes a syntax error in Python 3.5 and earlier. + - Updated Manifold documentation to fix example bug. + - Added advisors names to the release changelog. + - Adds advisory board minutes for Fall 2019. + - Updates our Travis-CI semi-secure token for Slack integration. + + +.. _v1.0.1: https://github.com/DistrictDataLabs/yellowbrick/releases/tag/v1.0.1 + Version 1.0 ----------- diff --git a/tests/__init__.py b/tests/__init__.py index ee5426a0b..d15f1d4e6 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -27,7 +27,7 @@ ## Test Constants ########################################################################## -EXPECTED_VERSION = "1.0.post1" +EXPECTED_VERSION = "1.0.1" ########################################################################## diff --git a/yellowbrick/version.py b/yellowbrick/version.py index e1c893b33..11b80ef33 100644 --- a/yellowbrick/version.py +++ b/yellowbrick/version.py @@ -20,10 +20,10 @@ __version_info__ = { "major": 1, "minor": 0, - "micro": 0, + "micro": 1, "releaselevel": "final", - "post": 1, - "serial": 15, + "post": 0, + "serial": 16, } ##########################################################################