Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

CLN: ASV rolling benchmark #18725

Merged
merged 3 commits into from
Dec 13, 2017
Merged

CLN: ASV rolling benchmark #18725

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
09548b3
CLN: ASV Rolling Benchmark
mroeschke Dec 8, 2017
bbb33bc
additional cleanup
mroeschke Dec 11, 2017
5e1a79b
Add current rolling to gil.py
mroeschke Dec 12, 2017
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
42 changes: 29 additions & 13 deletions asv_bench/benchmarks/gil.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -180,19 +180,35 @@ def setup(self, method):
raise NotImplementedError
win = 100
arr = np.random.rand(100000)
rolling = {'rolling_median': rolling_median,
'rolling_mean': rolling_mean,
'rolling_min': rolling_min,
'rolling_max': rolling_max,
'rolling_var': rolling_var,
'rolling_skew': rolling_skew,
'rolling_kurt': rolling_kurt,
'rolling_std': rolling_std}

@test_parallel(num_threads=2)
def parallel_rolling():
rolling[method](arr, win)
self.parallel_rolling = parallel_rolling
if hasattr(DataFrame, 'rolling'):
rolling = {'rolling_median': 'median',
'rolling_mean': 'mean',
'rolling_min': 'min',
'rolling_max': 'max',
'rolling_var': 'var',
'rolling_skew': 'skew',
'rolling_kurt': 'kurt',
'rolling_std': 'std'}
df = DataFrame(arr).rolling(win)

@test_parallel(num_threads=2)
def parallel_rolling():
getattr(df, rolling[method])()
self.parallel_rolling = parallel_rolling
else:
rolling = {'rolling_median': rolling_median,
'rolling_mean': rolling_mean,
'rolling_min': rolling_min,
'rolling_max': rolling_max,
'rolling_var': rolling_var,
'rolling_skew': rolling_skew,
'rolling_kurt': rolling_kurt,
'rolling_std': rolling_std}

@test_parallel(num_threads=2)
def parallel_rolling():
rolling[method](arr, win)
self.parallel_rolling = parallel_rolling

def time_rolling(self, method):
self.parallel_rolling()
Expand Down
200 changes: 28 additions & 172 deletions asv_bench/benchmarks/rolling.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,185 +1,41 @@
from .pandas_vb_common import *
import pandas as pd
import numpy as np

from .pandas_vb_common import setup # noqa

class DataframeRolling(object):
goal_time = 0.2

def setup(self):
self.N = 100000
self.Ns = 10000
self.df = pd.DataFrame({'a': np.random.random(self.N)})
self.dfs = pd.DataFrame({'a': np.random.random(self.Ns)})
self.wins = 10
self.winl = 1000
class Methods(object):

def time_rolling_quantile_0(self):
(self.df.rolling(self.wins).quantile(0.0))
sample_time = 0.2
params = (['DataFrame', 'Series'],
[10, 1000],
['int', 'float'],
['median', 'mean', 'max', 'min', 'std', 'count', 'skew', 'kurt',
'sum', 'corr', 'cov'])
param_names = ['contructor', 'window', 'dtype', 'method']

def time_rolling_quantile_1(self):
(self.df.rolling(self.wins).quantile(1.0))
def setup(self, contructor, window, dtype, method):
N = 10**5
arr = np.random.random(N).astype(dtype)
self.roll = getattr(pd, contructor)(arr).rolling(window)

def time_rolling_quantile_median(self):
(self.df.rolling(self.wins).quantile(0.5))
def time_rolling(self, contructor, window, dtype, method):
getattr(self.roll, method)()

def time_rolling_median(self):
(self.df.rolling(self.wins).median())

def time_rolling_mean(self):
(self.df.rolling(self.wins).mean())
class Quantile(object):

def time_rolling_max(self):
(self.df.rolling(self.wins).max())
sample_time = 0.2
params = (['DataFrame', 'Series'],
[10, 1000],
['int', 'float'],
[0, 0.5, 1])
param_names = ['contructor', 'window', 'dtype', 'percentile']

def time_rolling_min(self):
(self.df.rolling(self.wins).min())
def setup(self, contructor, window, dtype, percentile):
N = 10**5
arr = np.random.random(N).astype(dtype)
self.roll = getattr(pd, contructor)(arr).rolling(window)

def time_rolling_std(self):
(self.df.rolling(self.wins).std())

def time_rolling_count(self):
(self.df.rolling(self.wins).count())

def time_rolling_skew(self):
(self.df.rolling(self.wins).skew())

def time_rolling_kurt(self):
(self.df.rolling(self.wins).kurt())

def time_rolling_sum(self):
(self.df.rolling(self.wins).sum())

def time_rolling_corr(self):
(self.dfs.rolling(self.wins).corr())

def time_rolling_cov(self):
(self.dfs.rolling(self.wins).cov())

def time_rolling_quantile_0_l(self):
(self.df.rolling(self.winl).quantile(0.0))

def time_rolling_quantile_1_l(self):
(self.df.rolling(self.winl).quantile(1.0))

def time_rolling_quantile_median_l(self):
(self.df.rolling(self.winl).quantile(0.5))

def time_rolling_median_l(self):
(self.df.rolling(self.winl).median())

def time_rolling_mean_l(self):
(self.df.rolling(self.winl).mean())

def time_rolling_max_l(self):
(self.df.rolling(self.winl).max())

def time_rolling_min_l(self):
(self.df.rolling(self.winl).min())

def time_rolling_std_l(self):
(self.df.rolling(self.wins).std())

def time_rolling_count_l(self):
(self.df.rolling(self.wins).count())

def time_rolling_skew_l(self):
(self.df.rolling(self.wins).skew())

def time_rolling_kurt_l(self):
(self.df.rolling(self.wins).kurt())

def time_rolling_sum_l(self):
(self.df.rolling(self.wins).sum())


class SeriesRolling(object):
goal_time = 0.2

def setup(self):
self.N = 100000
self.Ns = 10000
self.df = pd.DataFrame({'a': np.random.random(self.N)})
self.dfs = pd.DataFrame({'a': np.random.random(self.Ns)})
self.sr = self.df.a
self.srs = self.dfs.a
self.wins = 10
self.winl = 1000

def time_rolling_quantile_0(self):
(self.sr.rolling(self.wins).quantile(0.0))

def time_rolling_quantile_1(self):
(self.sr.rolling(self.wins).quantile(1.0))

def time_rolling_quantile_median(self):
(self.sr.rolling(self.wins).quantile(0.5))

def time_rolling_median(self):
(self.sr.rolling(self.wins).median())

def time_rolling_mean(self):
(self.sr.rolling(self.wins).mean())

def time_rolling_max(self):
(self.sr.rolling(self.wins).max())

def time_rolling_min(self):
(self.sr.rolling(self.wins).min())

def time_rolling_std(self):
(self.sr.rolling(self.wins).std())

def time_rolling_count(self):
(self.sr.rolling(self.wins).count())

def time_rolling_skew(self):
(self.sr.rolling(self.wins).skew())

def time_rolling_kurt(self):
(self.sr.rolling(self.wins).kurt())

def time_rolling_sum(self):
(self.sr.rolling(self.wins).sum())

def time_rolling_corr(self):
(self.srs.rolling(self.wins).corr())

def time_rolling_cov(self):
(self.srs.rolling(self.wins).cov())

def time_rolling_quantile_0_l(self):
(self.sr.rolling(self.winl).quantile(0.0))

def time_rolling_quantile_1_l(self):
(self.sr.rolling(self.winl).quantile(1.0))

def time_rolling_quantile_median_l(self):
(self.sr.rolling(self.winl).quantile(0.5))

def time_rolling_median_l(self):
(self.sr.rolling(self.winl).median())

def time_rolling_mean_l(self):
(self.sr.rolling(self.winl).mean())

def time_rolling_max_l(self):
(self.sr.rolling(self.winl).max())

def time_rolling_min_l(self):
(self.sr.rolling(self.winl).min())

def time_rolling_std_l(self):
(self.sr.rolling(self.wins).std())

def time_rolling_count_l(self):
(self.sr.rolling(self.wins).count())

def time_rolling_skew_l(self):
(self.sr.rolling(self.wins).skew())

def time_rolling_kurt_l(self):
(self.sr.rolling(self.wins).kurt())

def time_rolling_sum_l(self):
(self.sr.rolling(self.wins).sum())
def time_quantile(self, contructor, window, dtype, percentile):
self.roll.quantile(percentile)