From 3435ffac1b4e3e6a5f31a19d3651bd54ecc0fd9a Mon Sep 17 00:00:00 2001 From: Stephen Dodson Date: Wed, 31 Jul 2019 09:59:52 +0000 Subject: [PATCH] Adding first implementation of eland.DataFrame.hist --- eland/dataframe.py | 5 +- eland/ndframe.py | 4 +- eland/operations.py | 55 ++++++++++-- eland/plotting.py | 39 +++++++-- eland/query.py | 14 ++- eland/query_compiler.py | 4 +- eland/tests/dataframe/test_describe_pytest.py | 2 +- eland/tests/dataframe/test_get_pytest.py | 2 +- eland/tests/dataframe/test_hist_pytest.py | 31 +++++++ eland/tests/dataframe/test_info_es_pytest.py | 2 +- eland/tests/dataframe/test_metrics_pytest.py | 2 +- .../plotting/test_dataframe_hist_pytest.ipynb | 87 ++++--------------- .../plotting/test_dataframe_hist_pytest.py | 38 ++++++-- 13 files changed, 180 insertions(+), 105 deletions(-) create mode 100644 eland/tests/dataframe/test_hist_pytest.py diff --git a/eland/dataframe.py b/eland/dataframe.py index e1f2ff3..48888bc 100644 --- a/eland/dataframe.py +++ b/eland/dataframe.py @@ -13,7 +13,8 @@ from pandas.io.formats.printing import pprint_thing from eland import NDFrame from eland import Series -from eland import hist_frame + +import eland.plotting as gfx class DataFrame(NDFrame): # This is effectively 2 constructors @@ -457,4 +458,4 @@ class DataFrame(NDFrame): def keys(self): return self.columns - hist = hist_frame + hist = gfx.ed_hist_frame diff --git a/eland/ndframe.py b/eland/ndframe.py index 8e5e411..24d5d20 100644 --- a/eland/ndframe.py +++ b/eland/ndframe.py @@ -227,8 +227,8 @@ class NDFrame(BasePandasDataset): raise NotImplementedError("Only sum of numeric fields is implemented") return self._query_compiler.max() - def _hist(self, interval) - return self._query_compiler._hist(interval) + def _hist(self, num_bins): + return self._query_compiler._hist(num_bins) def describe(self): return self._query_compiler.describe() diff --git a/eland/operations.py b/eland/operations.py index 9fc4729..e12667e 100644 --- a/eland/operations.py +++ b/eland/operations.py @@ -166,8 +166,8 @@ class Operations: results[field] = response['aggregations'][field]['value'] # Return single value if this is a series - if len(numeric_source_fields) == 1: - return np.float64(results[numeric_source_fields[0]]) + #if len(numeric_source_fields) == 1: + # return np.float64(results[numeric_source_fields[0]]) s = pd.Series(data=results, index=numeric_source_fields) @@ -203,7 +203,8 @@ class Operations: return s - def _hist_aggs(self, query_compiler, bins): + def _hist_aggs(self, query_compiler, num_bins): + # Get histogram bins and weights for numeric columns query_params, post_processing = self._resolve_tasks() size = self._size(query_params, post_processing) @@ -220,21 +221,59 @@ class Operations: max_aggs = self._metric_aggs(query_compiler, 'max') for field in numeric_source_fields: - body.hist_aggs(field, min_aggs, max_aggs, bins) + body.hist_aggs(field, field, min_aggs, max_aggs, num_bins) response = query_compiler._client.search( index=query_compiler._index_pattern, size=0, body=body.to_search_body()) - results = {} + # results are like + # "aggregations" : { + # "DistanceKilometers" : { + # "buckets" : [ + # { + # "key" : 0.0, + # "doc_count" : 2956 + # }, + # { + # "key" : 1988.1482421875, + # "doc_count" : 768 + # }, + # ... + bins = {} + weights = {} + + # There is one more bin that weights + # len(bins) = len(weights) + 1 + + # bins = [ 0. 36. 72. 108. 144. 180. 216. 252. 288. 324. 360.] + # len(bins) == 11 + # weights = [10066., 263., 386., 264., 273., 390., 324., 438., 261., 394.] + # len(weights) == 10 + + # ES returns + # weights = [10066., 263., 386., 264., 273., 390., 324., 438., 261., 252., 142.] + # So sum last 2 buckets for field in numeric_source_fields: - results[field] = response['aggregations'][field]['value'] + buckets = response['aggregations'][field]['buckets'] - s = pd.Series(data=results, index=numeric_source_fields) + bins[field] = [] + weights[field] = [] - return s + for bucket in buckets: + bins[field].append(bucket['key']) + + if bucket == buckets[-1]: + weights[field][-1] += bucket['doc_count'] + else: + weights[field].append(bucket['doc_count']) + + df_bins = pd.DataFrame(data=bins) + df_weights = pd.DataFrame(data=weights) + + return df_bins, df_weights def describe(self, query_compiler): query_params, post_processing = self._resolve_tasks() diff --git a/eland/plotting.py b/eland/plotting.py index 3e2ca2c..a12c898 100644 --- a/eland/plotting.py +++ b/eland/plotting.py @@ -7,40 +7,63 @@ from pandas.plotting._core import ( _raise_if_no_mpl, _converter, grouped_hist, _subplots, _flatten, _set_ticks_props) -def hist_frame(ed_df, column=None, by=None, grid=True, xlabelsize=None, +def ed_hist_frame(ed_df, column=None, by=None, grid=True, xlabelsize=None, xrot=None, ylabelsize=None, yrot=None, ax=None, sharex=False, sharey=False, figsize=None, layout=None, bins=10, **kwds): """ Derived from pandas.plotting._core.hist_frame 0.24.2 + + Ideally, we'd call hist_frame directly with histogram data, + but weights are applied to ALL series. For example, we can + plot a histogram of pre-binned data via: + + counts, bins = np.histogram(data) + plt.hist(bins[:-1], bins, weights=counts) + + However, + + ax.hist(data[col].dropna().values, bins=bins, **kwds) + + is for [col] and weights are a single array. + + We therefore cut/paste code. """ # Start with empty pandas data frame derived from - empty_pd_df = ed_df._empty_pd_df() + ed_df_bins, ed_df_weights = ed_df._hist(num_bins=bins) _raise_if_no_mpl() _converter._WARN = False if by is not None: - axes = grouped_hist(empty_pd_df, column=column, by=by, ax=ax, grid=grid, + raise NotImplementedError("TODO") + """ + axes = grouped_hist(data, column=column, by=by, ax=ax, grid=grid, figsize=figsize, sharex=sharex, sharey=sharey, layout=layout, bins=bins, xlabelsize=xlabelsize, xrot=xrot, ylabelsize=ylabelsize, yrot=yrot, **kwds) + """ return axes if column is not None: if not isinstance(column, (list, np.ndarray, ABCIndexClass)): column = [column] - empty_pd_df = empty_pd_df[column] - data = empty_pd_df._get_numeric_data() - naxes = len(empty_pd_df.columns) + ed_df_bins = ed_df_bins[column] + ed_df_weights = ed_df_weights[column] + naxes = len(ed_df_bins.columns) fig, axes = _subplots(naxes=naxes, ax=ax, squeeze=False, sharex=sharex, sharey=sharey, figsize=figsize, layout=layout) _axes = _flatten(axes) - for i, col in enumerate(com.try_sort(data.columns)): + for i, col in enumerate(com.try_sort(ed_df_bins.columns)): ax = _axes[i] - ax.hist(empty_pd_df[col].dropna().values, bins=bins, **kwds) + + # pandas code + # pandas / plotting / _core.py: 2410 + # ax.hist(data[col].dropna().values, bins=bins, **kwds) + + ax.hist(ed_df_bins[col][:-1], bins=ed_df_bins[col], weights=ed_df_weights[col]) ax.set_title(col) ax.grid(grid) diff --git a/eland/query.py b/eland/query.py index 17139de..0b12d6f 100644 --- a/eland/query.py +++ b/eland/query.py @@ -68,7 +68,7 @@ class Query: } self._aggs[name] = agg - def hist_aggs(self, name, field, min_aggs, max_aggs, bins): + def hist_aggs(self, name, field, min_aggs, max_aggs, num_bins): """ Add histogram agg e.g. "aggs": { @@ -80,6 +80,18 @@ class Query: } } """ + min = min_aggs[field] + max = max_aggs[field] + + interval = (max - min)/num_bins + + agg = { + "histogram": { + "field": field, + "interval": interval + } + } + self._aggs[name] = agg def to_search_body(self): body = {"query": self._query, "aggs": self._aggs} diff --git a/eland/query_compiler.py b/eland/query_compiler.py index bb5dc15..9f85081 100644 --- a/eland/query_compiler.py +++ b/eland/query_compiler.py @@ -370,5 +370,5 @@ class ElandQueryCompiler(BaseQueryCompiler): def describe(self): return self._operations.describe(self) - def _hist(self, interval): - return self._operations.hist(self, interval) + def _hist(self, num_bins): + return self._operations.hist(self, num_bins) diff --git a/eland/tests/dataframe/test_describe_pytest.py b/eland/tests/dataframe/test_describe_pytest.py index 42118eb..b425755 100644 --- a/eland/tests/dataframe/test_describe_pytest.py +++ b/eland/tests/dataframe/test_describe_pytest.py @@ -4,7 +4,7 @@ from io import StringIO from eland.tests.common import TestData -class TestDataFrameInfo(TestData): +class TestDataFrameDescribe(TestData): def test_to_describe1(self): pd_flights = self.pd_flights() diff --git a/eland/tests/dataframe/test_get_pytest.py b/eland/tests/dataframe/test_get_pytest.py index 8593d39..4d562bf 100644 --- a/eland/tests/dataframe/test_get_pytest.py +++ b/eland/tests/dataframe/test_get_pytest.py @@ -10,7 +10,7 @@ from eland.tests.common import ( import numpy as np -class TestDataFrameiLoc(TestData): +class TestDataFrameGet(TestData): def test_get1(self): ed_flights = self.ed_flights() diff --git a/eland/tests/dataframe/test_hist_pytest.py b/eland/tests/dataframe/test_hist_pytest.py new file mode 100644 index 0000000..796961a --- /dev/null +++ b/eland/tests/dataframe/test_hist_pytest.py @@ -0,0 +1,31 @@ +# File called _pytest for PyCharm compatability + +import numpy as np +import pandas as pd +from pandas.util.testing import assert_almost_equal + +from eland.tests.common import TestData + + +class TestDataFrameHist(TestData): + + def test_to_hist1(self): + pd_flights = self.pd_flights() + ed_flights = self.ed_flights() + + num_bins = 10 + + # pandas data + pd_distancekilometers = np.histogram(pd_flights['DistanceKilometers'], num_bins) + pd_flightdelaymin = np.histogram(pd_flights['FlightDelayMin'], num_bins) + + pd_bins = pd.DataFrame( + {'DistanceKilometers': pd_distancekilometers[1], 'FlightDelayMin': pd_flightdelaymin[1]}) + pd_weights = pd.DataFrame( + {'DistanceKilometers': pd_distancekilometers[0], 'FlightDelayMin': pd_flightdelaymin[0]}) + + ed_bins, ed_weights = ed_flights[['DistanceKilometers', 'FlightDelayMin']]._hist(num_bins=num_bins) + + # Numbers are slightly different + assert_almost_equal(pd_bins, ed_bins) + assert_almost_equal(pd_weights, ed_weights) diff --git a/eland/tests/dataframe/test_info_es_pytest.py b/eland/tests/dataframe/test_info_es_pytest.py index 41f84c6..5d363d4 100644 --- a/eland/tests/dataframe/test_info_es_pytest.py +++ b/eland/tests/dataframe/test_info_es_pytest.py @@ -3,7 +3,7 @@ from eland.tests.common import TestData -class TestDataFrameInfo(TestData): +class TestDataFrameInfoEs(TestData): def test_to_info1(self): ed_flights = self.ed_flights() diff --git a/eland/tests/dataframe/test_metrics_pytest.py b/eland/tests/dataframe/test_metrics_pytest.py index 8efda63..25a6848 100644 --- a/eland/tests/dataframe/test_metrics_pytest.py +++ b/eland/tests/dataframe/test_metrics_pytest.py @@ -6,7 +6,7 @@ from eland.tests.common import TestData from pandas.util.testing import assert_series_equal -class TestDataFrameMean(TestData): +class TestDataFrameMetrics(TestData): def test_to_mean(self): pd_flights = self.pd_flights() diff --git a/eland/tests/plotting/test_dataframe_hist_pytest.ipynb b/eland/tests/plotting/test_dataframe_hist_pytest.ipynb index b56ceb9..31dab35 100644 --- a/eland/tests/plotting/test_dataframe_hist_pytest.ipynb +++ b/eland/tests/plotting/test_dataframe_hist_pytest.ipynb @@ -2,24 +2,15 @@ "cells": [ { "cell_type": "code", - "execution_count": 18, + "execution_count": 35, "metadata": { "pycharm": { "is_executing": false } }, - "outputs": [ - { - "name": "stdout", - "text": [ - "In Index.__next__\n" - ], - "output_type": "stream" - } - ], + "outputs": [], "source": [ "from eland.tests.common import TestData\n", - "import matplotlib.pyplot as plt\n", "\n", "test_data = TestData()\n", "\n", @@ -29,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 36, "metadata": { "pycharm": { "is_executing": false @@ -38,11 +29,11 @@ "outputs": [ { "data": { - "text/plain": "array([[,\n ],\n [,\n ]],\n dtype=object)" + "text/plain": "array([[,\n ],\n [,\n ]],\n dtype=object)" }, "metadata": {}, "output_type": "execute_result", - "execution_count": 19 + "execution_count": 36 }, { "data": { @@ -61,24 +52,26 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 37, "metadata": { "pycharm": { - "is_executing": false + "is_executing": false, + "name": "#%%\n" } }, "outputs": [ { - "name": "stdout", - "text": [ - "Empty DataFrame\nColumns: [DistanceKilometers, DistanceMiles, FlightDelayMin, FlightTimeHour]\nIndex: []\n" - ], - "output_type": "stream" + "data": { + "text/plain": "array([[,\n ],\n [,\n ]],\n dtype=object)" + }, + "metadata": {}, + "output_type": "execute_result", + "execution_count": 37 }, { "data": { - "text/plain": "
", - "image/png": "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\n" + "text/plain": "
", + "image/png": "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\n" }, "metadata": { "needs_background": "light" @@ -87,54 +80,8 @@ } ], "source": [ - "ed_flights.hist(figsize=[10,10])" + "ed_flights.hist(figsize=[10,10])\n" ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "pycharm": { - "is_executing": false - } - }, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/eland/tests/plotting/test_dataframe_hist_pytest.py b/eland/tests/plotting/test_dataframe_hist_pytest.py index 01c4bb2..a9918d5 100644 --- a/eland/tests/plotting/test_dataframe_hist_pytest.py +++ b/eland/tests/plotting/test_dataframe_hist_pytest.py @@ -5,6 +5,7 @@ from eland.tests.common import TestData from pandas.util.testing import assert_series_equal import numpy as np +import pandas as pd class TestDataFrameHist(TestData): @@ -14,24 +15,25 @@ class TestDataFrameHist(TestData): pd_flights = test_data.pd_flights()[['DistanceKilometers', 'DistanceMiles', 'FlightDelayMin', 'FlightTimeHour']] ed_flights = test_data.ed_flights()[['DistanceKilometers', 'DistanceMiles', 'FlightDelayMin', 'FlightTimeHour']] + """ pd_flights.hist(figsize=[10, 10]) - ed_flights.hist(figsize=[10, 10]) + #ed_flights.hist(figsize=[10, 10]) pd_min = pd_flights['DistanceKilometers'].min() pd_max = pd_flights['DistanceKilometers'].max() - ed_min = ed_flights['DistanceKilometers'].min() - ed_max = ed_flights['DistanceKilometers'].max() + #ed_min = ed_flights['DistanceKilometers'].min() + #ed_max = ed_flights['DistanceKilometers'].max() - num_bins = 10.0 + #num_bins = 10.0 - bins = np.linspace(ed_min, ed_max, num=num_bins+1) + #bins = np.linspace(ed_min, ed_max, num=num_bins+1) - print(bins) + #print(bins) - print(np.diff(bins).mean()) + #print(np.diff(bins).mean()) - hist = ed_flights['DistanceKilometers'].hist(np.diff(bins).mean()) + #hist = ed_flights['DistanceKilometers'].hist(np.diff(bins).mean()) x = [2956., 768., 719., 2662., 2934., 1320., 641., 529., 426., 104.] @@ -43,4 +45,24 @@ class TestDataFrameHist(TestData): a = bins[0:10] print(np.histogram(a, weights=x, bins=bins)) + #counts, bins = np.histogram(data) + #plt.hist(bins[:-1], bins, weights=counts) + """ + + h1 = np.histogram(pd_flights['DistanceKilometers'], 10) + h2 = np.histogram(pd_flights['FlightDelayMin'], 10) + l1 = list(h1[0]) + l2 = list(h2[0]) + l1.append(0) + l2.append(0) + + d = {'DistanceKilometers': h1[1], + 'FlightDelayMin': h2[1]} + + df = pd.DataFrame(data=d) + + df.hist(weights=[l1, l2]) + + +