[Autoloop] [Autoloop: perf-comparison]

benchmarks/pandas/bench_between.py

@@ -0,0 +1,9 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+s = pd.Series(rng.standard_normal(100_000))
+for _ in range(3): s.between(-1.0, 1.0)
+N = 200
+t0 = time.perf_counter()
+for _ in range(N): s.between(-1.0, 1.0)
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "between", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_clip.py

@@ -0,0 +1,9 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+s = pd.Series(rng.standard_normal(100_000))
+for _ in range(3): s.clip(-1.0, 1.0)
+N = 100
+t0 = time.perf_counter()
+for _ in range(N): s.clip(-1.0, 1.0)
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "clip", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_combine_first.py

@@ -0,0 +1,12 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+s1 = pd.Series(rng.standard_normal(100_000))
+s2 = pd.Series(rng.standard_normal(100_000))
+# Put NaN in s1
+s1[::3] = float("nan")
+for _ in range(3): s1.combine_first(s2)
+N = 50
+t0 = time.perf_counter()
+for _ in range(N): s1.combine_first(s2)
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "combine_first", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_corr.py

@@ -0,0 +1,9 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+df = pd.DataFrame(rng.standard_normal((10_000, 5)), columns=list("ABCDE"))
+for _ in range(3): df.corr()
+N = 50
+t0 = time.perf_counter()
+for _ in range(N): df.corr()
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "corr", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_cov.py

@@ -0,0 +1,9 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+df = pd.DataFrame(rng.standard_normal((10_000, 5)), columns=list("ABCDE"))
+for _ in range(3): df.cov()
+N = 100
+t0 = time.perf_counter()
+for _ in range(N): df.cov()
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "cov", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_crosstab.py

@@ -0,0 +1,10 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+a = pd.Series(rng.choice(["A","B","C","D"], size=10_000))
+b = pd.Series(rng.choice(["X","Y","Z"], size=10_000))
+for _ in range(3): pd.crosstab(a, b)
+N = 30
+t0 = time.perf_counter()
+for _ in range(N): pd.crosstab(a, b)
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "crosstab", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_cummax.py

@@ -0,0 +1,9 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+s = pd.Series(rng.standard_normal(100_000))
+for _ in range(3): s.cummax()
+N = 100
+t0 = time.perf_counter()
+for _ in range(N): s.cummax()
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "cummax", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_cummin.py

@@ -0,0 +1,9 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+s = pd.Series(rng.standard_normal(100_000))
+for _ in range(3): s.cummin()
+N = 100
+t0 = time.perf_counter()
+for _ in range(N): s.cummin()
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "cummin", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_cut.py

@@ -0,0 +1,10 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+s = pd.Series(rng.standard_normal(100_000))
+bins = [-4, -2, -1, 0, 1, 2, 4]
+for _ in range(3): pd.cut(s, bins=bins, labels=False)
+N = 50
+t0 = time.perf_counter()
+for _ in range(N): pd.cut(s, bins=bins, labels=False)
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "cut", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_dataframe_apply_col.py

@@ -0,0 +1,9 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+df = pd.DataFrame(rng.standard_normal((10_000, 5)), columns=list("ABCDE"))
+for _ in range(3): df.apply(lambda col: col.mean(), axis=0)
+N = 100
+t0 = time.perf_counter()
+for _ in range(N): df.apply(lambda col: col.mean(), axis=0)
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "dataframe_apply_col", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_dataframe_astype.py

@@ -0,0 +1,9 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+df = pd.DataFrame({"a": rng.standard_normal(100_000), "b": rng.integers(0, 1000, size=100_000)})
+for _ in range(3): df.astype({"a": "float32", "b": "int32"})
+N = 100
+t0 = time.perf_counter()
+for _ in range(N): df.astype({"a": "float32", "b": "int32"})
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "dataframe_astype", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_dataframe_head_tail.py

@@ -0,0 +1,9 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+df = pd.DataFrame({"a": rng.standard_normal(100_000), "b": rng.integers(0, 1000, size=100_000)})
+for _ in range(3): df.head(10); df.tail(10)
+N = 1000
+t0 = time.perf_counter()
+for _ in range(N): df.head(10); df.tail(10)
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "dataframe_head_tail", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_diff.py

@@ -0,0 +1,9 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+s = pd.Series(rng.standard_normal(100_000))
+for _ in range(3): s.diff(1)
+N = 200
+t0 = time.perf_counter()
+for _ in range(N): s.diff(1)
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "diff", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_drop_duplicates.py

@@ -0,0 +1,9 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+s = pd.Series(rng.integers(0, 5_000, size=100_000))
+for _ in range(3): s.drop_duplicates()
+N = 50
+t0 = time.perf_counter()
+for _ in range(N): s.drop_duplicates()
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "drop_duplicates", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_duplicated.py

@@ -0,0 +1,9 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+s = pd.Series(rng.integers(0, 5_000, size=100_000))
+for _ in range(3): s.duplicated()
+N = 50
+t0 = time.perf_counter()
+for _ in range(N): s.duplicated()
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "duplicated", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_expanding_mean.py

@@ -0,0 +1,9 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+s = pd.Series(rng.standard_normal(100_000))
+for _ in range(3): s.expanding().mean()
+N = 50
+t0 = time.perf_counter()
+for _ in range(N): s.expanding().mean()
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "expanding_mean", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_explode.py

@@ -0,0 +1,11 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+# Each row has a list of 1-5 items
+data = [[int(x) for x in rng.integers(0, 100, size=rng.integers(1, 6))] for _ in range(10_000)]
+s = pd.Series(data)
+for _ in range(3): s.explode()
+N = 50
+t0 = time.perf_counter()
+for _ in range(N): s.explode()
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "explode", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_groupby_agg.py

@@ -0,0 +1,13 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+df = pd.DataFrame({
+    "group": rng.choice(["A","B","C","D","E"], size=100_000),
+    "val1": rng.standard_normal(100_000),
+    "val2": rng.standard_normal(100_000),
+})
+for _ in range(3): df.groupby("group").agg({"val1": ["mean","std","min","max"], "val2": ["sum","count"]})
+N = 30
+t0 = time.perf_counter()
+for _ in range(N): df.groupby("group").agg({"val1": ["mean","std","min","max"], "val2": ["sum","count"]})
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "groupby_agg", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_interpolate.py

@@ -0,0 +1,11 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+arr = rng.standard_normal(100_000).tolist()
+for i in range(0, 100_000, 10): arr[i] = None
+s = pd.Series(arr, dtype="float64")
+for _ in range(3): s.interpolate()
+N = 30
+t0 = time.perf_counter()
+for _ in range(N): s.interpolate()
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "interpolate", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_isin.py

@@ -0,0 +1,10 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+s = pd.Series(rng.integers(0, 10_000, size=100_000))
+test_set = list(range(0, 10_000, 4))
+for _ in range(3): s.isin(test_set)
+N = 50
+t0 = time.perf_counter()
+for _ in range(N): s.isin(test_set)
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "isin", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_mask.py

@@ -0,0 +1,10 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+s = pd.Series(rng.standard_normal(100_000))
+cond = s < 0
+for _ in range(3): s.mask(cond, 0.0)
+N = 100
+t0 = time.perf_counter()
+for _ in range(N): s.mask(cond, 0.0)
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "mask", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_melt.py

@@ -0,0 +1,14 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+df = pd.DataFrame({
+    "id": range(10_000),
+    "A": rng.standard_normal(10_000),
+    "B": rng.standard_normal(10_000),
+    "C": rng.standard_normal(10_000),
+})
+for _ in range(3): df.melt(id_vars=["id"], value_vars=["A","B","C"])
+N = 50
+t0 = time.perf_counter()
+for _ in range(N): df.melt(id_vars=["id"], value_vars=["A","B","C"])
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "melt", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_nlargest.py

@@ -0,0 +1,9 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+s = pd.Series(rng.standard_normal(100_000))
+for _ in range(3): s.nlargest(10)
+N = 100
+t0 = time.perf_counter()
+for _ in range(N): s.nlargest(10)
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "nlargest", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_nsmallest.py

@@ -0,0 +1,9 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+s = pd.Series(rng.standard_normal(100_000))
+for _ in range(3): s.nsmallest(10)
+N = 100
+t0 = time.perf_counter()
+for _ in range(N): s.nsmallest(10)
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "nsmallest", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_pct_change.py

@@ -0,0 +1,9 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+s = pd.Series(rng.standard_normal(100_000))
+for _ in range(3): s.pct_change()
+N = 200
+t0 = time.perf_counter()
+for _ in range(N): s.pct_change()
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "pct_change", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_pivot.py

@@ -0,0 +1,15 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+rows = 100
+cols = 20
+df = pd.DataFrame({
+    "row": np.repeat(range(rows), cols),
+    "col": list(range(cols)) * rows,
+    "val": rng.standard_normal(rows * cols),
+})
+for _ in range(3): df.pivot(index="row", columns="col", values="val")
+N = 100
+t0 = time.perf_counter()
+for _ in range(N): df.pivot(index="row", columns="col", values="val")
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "pivot", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_qcut.py

@@ -0,0 +1,9 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+s = pd.Series(rng.standard_normal(100_000))
+for _ in range(3): pd.qcut(s, q=10, labels=False, duplicates="drop")
+N = 30
+t0 = time.perf_counter()
+for _ in range(N): pd.qcut(s, q=10, labels=False, duplicates="drop")
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "qcut", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_rank.py

@@ -0,0 +1,10 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+s = pd.Series(rng.integers(0, 1000, size=100_000))
+# warm-up
+for _ in range(3): s.rank(method="average")
+N = 50
+t0 = time.perf_counter()
+for _ in range(N): s.rank(method="average")
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "rank", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_resample.py

@@ -0,0 +1,10 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+idx = pd.date_range("2020-01-01", periods=100_000, freq="1min")
+s = pd.Series(rng.standard_normal(100_000), index=idx)
+for _ in range(3): s.resample("1h").mean()
+N = 50
+t0 = time.perf_counter()
+for _ in range(N): s.resample("1h").mean()
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "resample", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_rolling_std.py

@@ -0,0 +1,9 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+s = pd.Series(rng.standard_normal(100_000))
+for _ in range(3): s.rolling(window=20).std()
+N = 50
+t0 = time.perf_counter()
+for _ in range(N): s.rolling(window=20).std()
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "rolling_std", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_rolling_var.py

@@ -0,0 +1,9 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+s = pd.Series(rng.standard_normal(100_000))
+for _ in range(3): s.rolling(window=20).var()
+N = 50
+t0 = time.perf_counter()
+for _ in range(N): s.rolling(window=20).var()
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "rolling_var", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_sample.py

@@ -0,0 +1,9 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+s = pd.Series(rng.standard_normal(100_000))
+for _ in range(3): s.sample(n=1000, random_state=42)
+N = 100
+t0 = time.perf_counter()
+for _ in range(N): s.sample(n=1000, random_state=42)
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "sample", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_series_abs.py

@@ -0,0 +1,9 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+s = pd.Series(rng.standard_normal(100_000))
+for _ in range(3): s.abs()
+N = 200
+t0 = time.perf_counter()
+for _ in range(N): s.abs()
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "series_abs", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_series_map.py

@@ -0,0 +1,10 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+s = pd.Series(rng.integers(0, 1_000, size=100_000))
+mapping = {i: i * 2 for i in range(1_000)}
+for _ in range(3): s.map(mapping)
+N = 30
+t0 = time.perf_counter()
+for _ in range(N): s.map(mapping)
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "series_map", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_series_nunique.py

@@ -0,0 +1,9 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+s = pd.Series(rng.integers(0, 5_000, size=100_000))
+for _ in range(3): s.nunique()
+N = 200
+t0 = time.perf_counter()
+for _ in range(N): s.nunique()
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "series_nunique", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_series_replace.py

@@ -0,0 +1,10 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+s = pd.Series(rng.integers(0, 10, size=100_000))
+mapping = {i: i*10 for i in range(10)}
+for _ in range(3): s.replace(mapping)
+N = 50
+t0 = time.perf_counter()
+for _ in range(N): s.replace(mapping)
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "series_replace", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))

benchmarks/pandas/bench_stack.py

@@ -0,0 +1,9 @@
+import pandas as pd, json, time, numpy as np
+rng = np.random.default_rng(42)
+df = pd.DataFrame(rng.standard_normal((1000, 20)), columns=[f"c{i}" for i in range(20)])
+for _ in range(3): df.stack()
+N = 100
+t0 = time.perf_counter()
+for _ in range(N): df.stack()
+elapsed = time.perf_counter() - t0
+print(json.dumps({"function": "stack", "mean_ms": elapsed/N*1000, "iterations": N, "total_ms": elapsed*1000}))