Merge pull request #423 from githubnext/autoloop/perf-comparison

[Autoloop: perf-comparison] Iteration 392: gaussianKDE benchmark pair

Author: mrjf

benchmarks/pandas/bench_business_offsets.py

@@ -0,0 +1,58 @@
+"""
+Benchmark: Business and Quarter date offsets — QuarterEnd, QuarterBegin,
+BMonthEnd, BMonthBegin, BYearEnd, BYearBegin.
+Mirrors tsb bench_business_offsets.ts.
+Dataset: 5,000 dates; 50 measured iterations.
+Outputs JSON: {"function": "business_offsets", "mean_ms": ..., "iterations": ..., "total_ms": ...}
+"""
+import json
+import time
+from datetime import datetime, timedelta, timezone
+
+import pandas as pd
+from pandas.tseries.offsets import (
+    BMonthBegin,
+    BMonthEnd,
+    BYearBegin,
+    BYearEnd,
+    QuarterBegin,
+    QuarterEnd,
+)
+
+SIZE = 5_000
+WARMUP = 5
+ITERATIONS = 50
+
+q_end = QuarterEnd(1)
+q_begin = QuarterBegin(1)
+bm_end = BMonthEnd(1)
+bm_begin = BMonthBegin(1)
+by_end = BYearEnd(1)
+by_begin = BYearBegin(1)
+
+base = datetime(2020, 1, 15, tzinfo=timezone.utc)
+dates = [base + timedelta(days=i) for i in range(SIZE)]
+ts_dates = [pd.Timestamp(d) for d in dates]
+
+for _ in range(WARMUP):
+    for d in ts_dates[:100]:
+        d + q_end
+        d + q_begin
+        d + bm_end
+        d + bm_begin
+        d + by_end
+        d + by_begin
+
+t0 = time.perf_counter()
+for _ in range(ITERATIONS):
+    for d in ts_dates:
+        d + q_end
+        d + q_begin
+        d + bm_end
+        d + bm_begin
+        d + by_end
+        d + by_begin
+total_ms = (time.perf_counter() - t0) * 1000
+mean_ms = total_ms / ITERATIONS
+
+print(json.dumps({"function": "business_offsets", "mean_ms": mean_ms, "iterations": ITERATIONS, "total_ms": total_ms}))

benchmarks/pandas/bench_case_when.py

@@ -0,0 +1,35 @@
+"""Benchmark: case_when — conditional value selection on 100k-element Series (pandas 2.2+)"""
+import json, time
+import numpy as np
+import pandas as pd
+
+ROWS = 100_000
+WARMUP = 5
+ITERATIONS = 20
+
+data = np.arange(ROWS, dtype=float) % 100
+s = pd.Series(data)
+cond1 = s < 25
+cond2 = s < 50
+cond3 = s < 75
+
+caselist = [
+    (cond1, "low"),
+    (cond2, "medium-low"),
+    (cond3, "medium-high"),
+]
+
+for _ in range(WARMUP):
+    s.case_when(caselist)
+
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    s.case_when(caselist)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "case_when",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_categorical_ops.py

@@ -0,0 +1,60 @@
+"""Benchmark: categorical operations on 100k-element Series
+
+Covers pd.Categorical.from_codes, value_counts (sort by freq), and pd.crosstab.
+"""
+import json
+import time
+import numpy as np
+import pandas as pd
+
+ROWS = 100_000
+WARMUP = 3
+ITERATIONS = 10
+
+# Build a categorical Series from codes + categories
+CATEGORIES = ["alpha", "beta", "gamma", "delta", "epsilon"]
+codes = np.arange(ROWS) % len(CATEGORIES)
+cat_series = pd.Series(pd.Categorical.from_codes(codes, categories=CATEGORIES))
+
+# Build a second categorical for crosstab
+CATEGORIES2 = ["x", "y", "z"]
+codes2 = np.arange(ROWS) % len(CATEGORIES2)
+cat_series2 = pd.Series(pd.Categorical.from_codes(codes2, categories=CATEGORIES2))
+
+# Warm up
+for _ in range(WARMUP):
+    cat_series.value_counts()
+    cat_series.value_counts(sort=True)
+    pd.crosstab(cat_series, cat_series2)
+
+# Measure value_counts (analogous to catFreqTable)
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    cat_series.value_counts(sort=False)
+freq_table_ms = (time.perf_counter() - start) * 1000 / ITERATIONS
+
+# Measure value_counts sorted by freq (analogous to catSortByFreq)
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    cat_series.value_counts(sort=True)
+sort_by_freq_ms = (time.perf_counter() - start) * 1000 / ITERATIONS
+
+# Measure crosstab (analogous to catCrossTab)
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    pd.crosstab(cat_series, cat_series2)
+cross_tab_ms = (time.perf_counter() - start) * 1000 / ITERATIONS
+
+mean_ms = (freq_table_ms + sort_by_freq_ms + cross_tab_ms) / 3
+
+print(json.dumps({
+    "function": "categorical_ops",
+    "mean_ms": mean_ms,
+    "iterations": ITERATIONS,
+    "total_ms": mean_ms * ITERATIONS,
+    "details": {
+        "freqTableMs": freq_table_ms,
+        "sortByFreqMs": sort_by_freq_ms,
+        "crossTabMs": cross_tab_ms,
+    },
+}))

benchmarks/pandas/bench_contingency.py

@@ -0,0 +1,78 @@
+"""
+Benchmark: contingency — expected_freq, relative_risk, odds_ratio, association
+Pure-numpy equivalents (no scipy) matching the TypeScript benchmark.
+Dataset: same 4x4 table as the TypeScript benchmark.
+"""
+import json
+import time
+import numpy as np
+
+WARMUP = 10
+ITERS = 50
+
+observed = np.array([
+    [120, 80, 40, 60],
+    [90, 110, 70, 30],
+    [50, 60, 100, 90],
+    [40, 50, 90, 120],
+], dtype=float)
+
+two_by_two = np.array([
+    [60.0, 40.0],
+    [30.0, 70.0],
+])
+
+
+def expected_freq(obs):
+    row_sums = obs.sum(axis=1, keepdims=True)
+    col_sums = obs.sum(axis=0, keepdims=True)
+    total = obs.sum()
+    return row_sums * col_sums / total
+
+
+def relative_risk(obs):
+    a, b = obs[0, 0], obs[0, 1]
+    c, d = obs[1, 0], obs[1, 1]
+    risk0 = a / (a + b)
+    risk1 = c / (c + d)
+    return risk0 / risk1
+
+
+def odds_ratio(obs):
+    a, b = obs[0, 0], obs[0, 1]
+    c, d = obs[1, 0], obs[1, 1]
+    return (a * d) / (b * c)
+
+
+def association_cramer(obs):
+    exp = expected_freq(obs)
+    chi2 = np.sum((obs - exp) ** 2 / exp)
+    n = obs.sum()
+    r, c = obs.shape
+    return np.sqrt(chi2 / n / min(r - 1, c - 1))
+
+
+# Warm up
+for _ in range(WARMUP):
+    expected_freq(observed)
+    relative_risk(two_by_two)
+    odds_ratio(two_by_two)
+    association_cramer(observed)
+
+# Measure
+start = time.perf_counter()
+for _ in range(ITERS):
+    expected_freq(observed)
+    relative_risk(two_by_two)
+    odds_ratio(two_by_two)
+    association_cramer(observed)
+total_s = time.perf_counter() - start
+total_ms = total_s * 1000
+mean_ms = total_ms / ITERS
+
+print(json.dumps({
+    "function": "contingency",
+    "mean_ms": round(mean_ms, 4),
+    "iterations": ITERS,
+    "total_ms": round(total_ms, 4),
+}))

benchmarks/pandas/bench_entropy.py

@@ -0,0 +1,44 @@
+import numpy as np
+import json
+import time
+
+N = 100
+WARMUP = 5
+ITERS = 50
+
+p = np.arange(1, N + 1, dtype=float)
+q = np.arange(N, 0, -1, dtype=float)
+
+# Normalise
+p_norm = p / p.sum()
+q_norm = q / q.sum()
+
+
+def entropy_fn(pk):
+    pk = pk / pk.sum()
+    return -np.sum(pk * np.log(pk + 1e-300))
+
+
+def kl_divergence(pk, qk):
+    pk = pk / pk.sum()
+    qk = qk / qk.sum()
+    mask = pk > 0
+    return np.sum(pk[mask] * np.log(pk[mask] / (qk[mask] + 1e-300)))
+
+
+for _ in range(WARMUP):
+    entropy_fn(p)
+    kl_divergence(p, q)
+
+t0 = time.perf_counter()
+for _ in range(ITERS):
+    entropy_fn(p)
+    kl_divergence(p, q)
+total_ms = (time.perf_counter() - t0) * 1000
+
+print(json.dumps({
+    "function": "entropy_klDivergence",
+    "mean_ms": total_ms / ITERS,
+    "iterations": ITERS,
+    "total_ms": total_ms,
+}))

benchmarks/pandas/bench_feather.py

@@ -0,0 +1,42 @@
+"""
+Benchmark: read_feather / to_feather — Arrow Feather v2 round-trip on 10k rows
+"""
+import json
+import time
+import io
+import pandas as pd
+import numpy as np
+
+ROWS = 10_000
+WARMUP = 3
+ITERATIONS = 20
+
+rng = np.random.default_rng(42)
+df = pd.DataFrame({
+    "id": np.arange(ROWS, dtype=np.int64),
+    "value": np.arange(ROWS, dtype=np.float64) * 1.1,
+    "label": [f"cat_{i % 50}" for i in range(ROWS)],
+})
+
+# Warm up
+for _ in range(WARMUP):
+    buf = io.BytesIO()
+    df.to_feather(buf)
+    buf.seek(0)
+    pd.read_feather(buf)
+
+# Measure round-trip
+start = time.perf_counter()
+for _ in range(ITERATIONS):
+    buf = io.BytesIO()
+    df.to_feather(buf)
+    buf.seek(0)
+    pd.read_feather(buf)
+total = (time.perf_counter() - start) * 1000
+
+print(json.dumps({
+    "function": "feather",
+    "mean_ms": total / ITERATIONS,
+    "iterations": ITERATIONS,
+    "total_ms": total,
+}))

benchmarks/pandas/bench_flags_options.py

@@ -0,0 +1,73 @@
+"""
+Benchmark: flags and options (pandas equivalent)
+
+Measures:
+ - DataFrame.flags.allows_duplicate_labels get+set
+ - pd.get_option / pd.set_option / pd.reset_option for multiple keys
+ - pd.options proxy read
+
+Dataset: 10,000-row Series and DataFrame; 20 measured iterations.
+"""
+
+import json
+import time
+
+import numpy as np
+import pandas as pd
+
+N = 10_000
+WARMUP = 5
+ITERS = 20
+
+data = np.arange(N, dtype=np.float64)
+s = pd.Series(data)
+df = pd.DataFrame({"a": data, "b": data})
+
+
+def bench_flags_options():
+    sink = 0
+    for _ in range(ITERS + WARMUP):
+        # flags on Series
+        prev = s.flags.allows_duplicate_labels
+        s.flags.allows_duplicate_labels = not prev
+        s.flags.allows_duplicate_labels = prev
+        sink ^= int(s.flags.allows_duplicate_labels)
+
+        # flags on DataFrame
+        prev_df = df.flags.allows_duplicate_labels
+        df.flags.allows_duplicate_labels = not prev_df
+        df.flags.allows_duplicate_labels = prev_df
+        sink ^= int(df.flags.allows_duplicate_labels)
+
+        # options get/set/reset
+        v = pd.get_option("display.max_rows")
+        pd.set_option("display.max_rows", v + 1)
+        pd.reset_option("display.max_rows")
+        sink ^= int(pd.options.display.max_rows > 0)
+
+        pd.set_option("display.max_columns", 20)
+        pd.reset_option("display.max_columns")
+        sink ^= int(pd.options.display.max_columns > 0)
+
+    return sink
+
+
+# Warm-up
+bench_flags_options()
+
+# Measure
+t0 = time.perf_counter()
+for _ in range(ITERS):
+    bench_flags_options()
+total = (time.perf_counter() - t0) * 1000  # ms
+
+print(
+    json.dumps(
+        {
+            "function": "flags_options",
+            "mean_ms": total / ITERS,
+            "iterations": ITERS,
+            "total_ms": total,
+        }
+    )
+)