| ============================================= |
| MEP28: Remove Complexity from Axes.boxplot |
| ============================================= |
|
|
| .. contents:: |
| :local: |
|
|
|
|
| Status |
| ====== |
| **Discussion** |
|
|
| Branches and Pull requests |
| ========================== |
|
|
| The following lists any open PRs or branches related to this MEP: |
|
|
| #. Deprecate redundant statistical kwargs in ``Axes.boxplot``: https://github.com/phobson/matplotlib/tree/MEP28-initial-deprecations |
| #. Deprecate redundant style options in ``Axes.boxplot``: https://github.com/phobson/matplotlib/tree/MEP28-initial-deprecations |
| #. Deprecate passings 2D NumPy arrays as input: None |
| #. Add pre- & post-processing options to ``cbook.boxplot_stats``: https://github.com/phobson/matplotlib/tree/boxplot-stat-transforms |
| #. Exposing ``cbook.boxplot_stats`` through ``Axes.boxplot`` kwargs: None |
| #. Remove redundant statistical kwargs in ``Axes.boxplot``: None |
| #. Remove redundant style options in ``Axes.boxplot``: None |
| #. Remaining items that arise through discussion: None |
|
|
| Abstract |
| ======== |
|
|
| Over the past few releases, the ``Axes.boxplot`` method has grown in |
| complexity to support fully customizable artist styling and statistical |
| computation. This lead to ``Axes.boxplot`` being split off into multiple |
| parts. The statistics needed to draw a boxplot are computed in |
| ``cbook.boxplot_stats``, while the actual artists are drawn by ``Axes.bxp``. |
| The original method, ``Axes.boxplot`` remains as the most public API that |
| handles passing the user-supplied data to ``cbook.boxplot_stats``, feeding |
| the results to ``Axes.bxp``, and pre-processing style information for |
| each facet of the boxplot plots. |
|
|
| This MEP will outline a path forward to rollback the added complexity |
| and simplify the API while maintaining reasonable backwards |
| compatibility. |
|
|
| Detailed description |
| ==================== |
|
|
| Currently, the ``Axes.boxplot`` method accepts parameters that allow the |
| users to specify medians and confidence intervals for each box that |
| will be drawn in the plot. These were provided so that advanced users |
| could provide statistics computed in a different fashion that the simple |
| method provided by matplotlib. However, handling this input requires |
| complex logic to make sure that the forms of the data structure match what |
| needs to be drawn. At the moment, that logic contains 9 separate if/else |
| statements nested up to 5 levels deep with a for loop, and may raise up to 2 errors. |
| These parameters were added prior to the creation of the ``Axes.bxp`` method, |
| which draws boxplots from a list of dictionaries containing the relevant |
| statistics. Matplotlib also provides a function that computes these |
| statistics via ``cbook.boxplot_stats``. Note that advanced users can now |
| either a) write their own function to compute the stats required by |
| ``Axes.bxp``, or b) modify the output returned by ``cbook.boxplots_stats`` |
| to fully customize the position of the artists of the plots. With this |
| flexibility, the parameters to manually specify only the medians and their |
| confidences intervals remain for backwards compatibility. |
|
|
| Around the same time that the two roles of ``Axes.boxplot`` were split into |
| ``cbook.boxplot_stats`` for computation and ``Axes.bxp`` for drawing, both |
| ``Axes.boxplot`` and ``Axes.bxp`` were written to accept parameters that |
| individually toggle the drawing of all components of the boxplots, and |
| parameters that individually configure the style of those artists. However, |
| to maintain backwards compatibility, the ``sym`` parameter (previously used |
| to specify the symbol of the fliers) was retained. This parameter itself |
| requires fairly complex logic to reconcile the ``sym`` parameters with the |
| newer ``flierprops`` parameter at the default style specified by ``matplotlibrc``. |
|
|
| This MEP seeks to dramatically simplify the creation of boxplots for |
| novice and advanced users alike. Importantly, the changes proposed here |
| will also be available to downstream packages like seaborn, as seaborn |
| smartly allows users to pass arbitrary dictionaries of parameters through |
| the seaborn API to the underlying matplotlib functions. |
|
|
| This will be achieved in the following way: |
|
|
| 1. ``cbook.boxplot_stats`` will be modified to allow pre- and post- |
| computation transformation functions to be passed in (e.g., ``np.log`` |
| and ``np.exp`` for lognormally distributed data) |
| 2. ``Axes.boxplot`` will be modified to also accept and naïvely pass them |
| to ``cbook.boxplots_stats`` (Alt: pass the stat function and a dict |
| of its optional parameters). |
| 3. Outdated parameters from ``Axes.boxplot`` will be deprecated and |
| later removed. |
|
|
| Importance |
| ---------- |
|
|
| Since the limits of the whiskers are computed arithmetically, there |
| is an implicit assumption of normality in box and whisker plots. |
| This primarily affects which data points are classified as outliers. |
|
|
| Allowing transformations to the data and the results used to draw |
| boxplots will allow users to opt-out of that assumption if the |
| data are known to not fit a normal distribution. |
|
|
| Below is an example of how ``Axes.boxplot`` classifies outliers of lognormal |
| data differently depending one these types of transforms. |
|
|
| .. plot:: |
| :include-source: true |
|
|
| import numpy as np |
| import matplotlib.pyplot as plt |
| from matplotlib import cbook |
| np.random.seed(0) |
|
|
| fig, ax = plt.subplots(figsize=(4, 6)) |
| ax.set_yscale('log') |
| data = np.random.lognormal(-1.75, 2.75, size=37) |
|
|
| stats = cbook.boxplot_stats(data, labels=['arithmetic']) |
| logstats = cbook.boxplot_stats(np.log(data), labels=['log-transformed']) |
|
|
| for lsdict in logstats: |
| for key, value in lsdict.items(): |
| if key != 'label': |
| lsdict[key] = np.exp(value) |
|
|
| stats.extend(logstats) |
| ax.bxp(stats) |
| fig.show() |
|
|
| Implementation |
| ============== |
|
|
| Passing transform functions to ``cbook.boxplots_stats`` |
| ------------------------------------------------------- |
|
|
| This MEP proposes that two parameters (e.g., ``transform_in`` and |
| ``transform_out`` be added to the cookbook function that computes the |
| statistics for the boxplot function. These will be optional keyword-only |
| arguments and can easily be set to ``lambda x: x`` as a no-op when omitted |
| by the user. The ``transform_in`` function will be applied to the data |
| as the ``boxplot_stats`` function loops through each subset of the data |
| passed to it. After the list of statistics dictionaries are computed the |
| ``transform_out`` function is applied to each value in the dictionaries. |
|
|
| These transformations can then be added to the call signature of |
| ``Axes.boxplot`` with little impact to that method's complexity. This is |
| because they can be directly passed to ``cbook.boxplot_stats``. |
| Alternatively, ``Axes.boxplot`` could be modified to accept an optional |
| statistical function kwarg and a dictionary of parameters to be directly |
| passed to it. |
|
|
| At this point in the implementation users and external libraries like |
| seaborn would have complete control via the ``Axes.boxplot`` method. More |
| importantly, at the very least, seaborn would require no changes to its |
| API to allow users to take advantage of these new options. |
|
|
| Simplifications to the ``Axes.boxplot`` API and other functions |
| --------------------------------------------------------------- |
|
|
| Simplifying the boxplot method consists primarily of deprecating and then |
| removing the redundant parameters. Optionally, a next step would include |
| rectifying minor terminological inconsistencies between ``Axes.boxplot`` |
| and ``Axes.bxp``. |
|
|
| The parameters to be deprecated and removed include: |
|
|
| 1. ``usermedians`` - processed by 10 SLOC, 3 ``if`` blocks, a ``for`` loop |
| 2. ``conf_intervals`` - handled by 15 SLOC, 6 ``if`` blocks, a ``for`` loop |
| 3. ``sym`` - processed by 12 SLOC, 4 ``if`` blocks |
|
|
| Removing the ``sym`` option allows all code in handling the remaining |
| styling parameters to be moved to ``Axes.bxp``. This doesn't remove |
| any complexity, but does reinforce the single responsibility principle |
| among ``Axes.bxp``, ``cbook.boxplot_stats``, and ``Axes.boxplot``. |
|
|
| Additionally, the ``notch`` parameter could be renamed ``shownotches`` |
| to be consistent with ``Axes.bxp``. This kind of cleanup could be taken |
| a step further and the ``whis``, ``bootstrap``, ``autorange`` could |
| be rolled into the kwargs passed to the new ``statfxn`` parameter. |
|
|
| Backward compatibility |
| ====================== |
|
|
| Implementation of this MEP would eventually result in the backwards |
| incompatible deprecation and then removal of the keyword parameters |
| ``usermedians``, ``conf_intervals``, and ``sym``. Cursory searches on |
| GitHub indicated that ``usermedians``, ``conf_intervals`` are used by |
| few users, who all seem to have a very strong knowledge of matplotlib. |
| A robust deprecation cycle should provide sufficient time for these |
| users to migrate to a new API. |
|
|
| Deprecation of ``sym`` however, may have a much broader reach into |
| the matplotlib userbase. |
|
|
| Schedule |
| -------- |
| An accelerated timeline could look like the following: |
|
|
| #. v2.0.1 add transforms to ``cbook.boxplots_stats``, expose in ``Axes.boxplot`` |
| #. v2.1.0 Initial Deprecations , and using 2D NumPy arrays as input |
|
|
| a. Using 2D NumPy arrays as input. The semantics around 2D arrays are generally confusing. |
| b. ``usermedians``, ``conf_intervals``, ``sym`` parameters |
|
|
| #. v2.2.0 |
|
|
| a. remove ``usermedians``, ``conf_intervals``, ``sym`` parameters |
| b. deprecate ``notch`` in favor of ``shownotches`` to be consistent with |
| other parameters and ``Axes.bxp`` |
|
|
| #. v2.3.0 |
|
|
| a. remove ``notch`` parameter |
| b. move all style and artist toggling logic to ``Axes.bxp`` such ``Axes.boxplot`` |
| is little more than a broker between ``Axes.bxp`` and ``cbook.boxplots_stats`` |
|
|
|
|
| Anticipated Impacts to Users |
| ---------------------------- |
|
|
| As described above deprecating ``usermedians`` and ``conf_intervals`` |
| will likely impact few users. Those who will be impacted are almost |
| certainly advanced users who will be able to adapt to the change. |
|
|
| Deprecating the ``sym`` option may import more users and effort should |
| be taken to collect community feedback on this. |
|
|
| Anticipated Impacts to Downstream Libraries |
| ------------------------------------------- |
|
|
| The source code (GitHub master as of 2016-10-17) was inspected for |
| seaborn and python-ggplot to see if these changes would impact their |
| use. None of the parameters nominated for removal in this MEP are used by |
| seaborn. The seaborn APIs that use matplotlib's boxplot function allow |
| user's to pass arbitrary ``**kwargs`` through to matplotlib's API. Thus |
| seaborn users with modern matplotlib installations will be able to take |
| full advantage of any new features added as a result of this MEP. |
|
|
| Python-ggplot has implemented its own function to draw boxplots. Therefore, |
| no impact can come to it as a result of implementing this MEP. |
|
|
| Alternatives |
| ============ |
|
|
| Variations on the theme |
| ----------------------- |
|
|
| This MEP can be divided into a few loosely coupled components: |
|
|
| #. Allowing pre- and post-computation transformation function in ``cbook.boxplot_stats`` |
| #. Exposing that transformation in the ``Axes.boxplot`` API |
| #. Removing redundant statistical options in ``Axes.boxplot`` |
| #. Shifting all styling parameter processing from ``Axes.boxplot`` to ``Axes.bxp``. |
|
|
| With this approach, #2 depends and #1, and #4 depends on #3. |
|
|
| There are two possible approaches to #2. The first and most direct would |
| be to mirror the new ``transform_in`` and ``transform_out`` parameters of |
| ``cbook.boxplot_stats`` in ``Axes.boxplot`` and pass them directly. |
|
|
| The second approach would be to add ``statfxn`` and ``statfxn_args`` |
| parameters to ``Axes.boxplot``. Under this implementation, the default |
| value of ``statfxn`` would be ``cbook.boxplot_stats``, but users could |
| pass their own function. Then ``transform_in`` and ``transform_out`` would |
| then be passed as elements of the ``statfxn_args`` parameter. |
|
|
| .. code:: python |
|
|
| def boxplot_stats(data, ..., transform_in=None, transform_out=None): |
| if transform_in is None: |
| transform_in = lambda x: x |
|
|
| if transform_out is None: |
| transform_out = lambda x: x |
|
|
| output = [] |
| for _d in data: |
| d = transform_in(_d) |
| stat_dict = do_stats(d) |
| for key, value in stat_dict.item(): |
| if key != 'label': |
| stat_dict[key] = transform_out(value) |
| output.append(d) |
| return output |
|
|
|
|
| class Axes(...): |
| def boxplot_option1(data, ..., transform_in=None, transform_out=None): |
| stats = cbook.boxplot_stats(data, ..., |
| transform_in=transform_in, |
| transform_out=transform_out) |
| return self.bxp(stats, ...) |
|
|
| def boxplot_option2(data, ..., statfxn=None, **statopts): |
| if statfxn is None: |
| statfxn = boxplot_stats |
| stats = statfxn(data, **statopts) |
| return self.bxp(stats, ...) |
|
|
| Both cases would allow users to do the following: |
|
|
| .. code:: python |
|
|
| fig, ax1 = plt.subplots() |
| artists1 = ax1.boxplot_optionX(data, transform_in=np.log, |
| transform_out=np.exp) |
|
|
|
|
| But Option Two lets a user write a completely custom stat function |
| (e.g., ``my_box_stats``) with fancy BCA confidence intervals and the |
| whiskers set differently depending on some attribute of the data. |
|
|
| This is available under the current API: |
|
|
| .. code:: python |
|
|
| fig, ax1 = plt.subplots() |
| my_stats = my_box_stats(data, bootstrap_method='BCA', |
| whisker_method='dynamic') |
| ax1.bxp(my_stats) |
|
|
| And would be more concise with Option Two |
|
|
| .. code:: python |
|
|
| fig, ax = plt.subplots() |
| statopts = dict(transform_in=np.log, transform_out=np.exp) |
| ax.boxplot(data, ..., **statopts) |
|
|
| Users could also pass their own function to compute the stats: |
|
|
| .. code:: python |
|
|
| fig, ax1 = plt.subplots() |
| ax1.boxplot(data, statfxn=my_box_stats, bootstrap_method='BCA', |
| whisker_method='dynamic') |
|
|
| From the examples above, Option Two seems to have only marginal benefit, |
| but in the context of downstream libraries like seaborn, its advantage |
| is more apparent as the following would be possible without any patches |
| to seaborn: |
|
|
| .. code:: python |
|
|
| import seaborn |
| tips = seaborn.load_data('tips') |
| g = seaborn.factorplot(x="day", y="total_bill", hue="sex", data=tips, |
| kind='box', palette="PRGn", shownotches=True, |
| statfxn=my_box_stats, bootstrap_method='BCA', |
| whisker_method='dynamic') |
|
|
| This type of flexibility was the intention behind splitting the overall |
| boxplot API in the current three functions. In practice however, downstream |
| libraries like seaborn support versions of matplotlib dating back well |
| before the split. Thus, adding just a bit more flexibility to the |
| ``Axes.boxplot`` could expose all the functionality to users of the |
| downstream libraries with modern matplotlib installation without intervention |
| from the downstream library maintainers. |
|
|
| Doing less |
| ---------- |
|
|
| Another obvious alternative would be to omit the added pre- and post- |
| computation transform functionality in ``cbook.boxplot_stats`` and |
| ``Axes.boxplot``, and simply remove the redundant statistical and style |
| parameters as described above. |
|
|
| Doing nothing |
| ------------- |
|
|
| As with many things in life, doing nothing is an option here. This means |
| we simply advocate for users and downstream libraries to take advantage |
| of the split between ``cbook.boxplot_stats`` and ``Axes.bxp`` and let |
| them decide how to provide an interface to that. |
|
|
