edgepoint 3.5.2__tar.gz → 3.5.4__tar.gz

{edgepoint-3.5.2 → edgepoint-3.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edgepoint
-Version: 3.5.2
+Version: 3.5.4
 Summary: Find the point in a numeric column above which a binary outcome becomes meaningfully and reliably better.
 Author: Henry
 License: MIT
@@ -57,16 +57,17 @@ edgepoints_df, top_combos = search(df, outcome_col="hit")
 
 ## Correlation is not causation
 
-`search()` finds correlations, not causes. A great-looking threshold
-doesn't mean crossing it *causes* the outcome to improve, it may be
-riding along with something else entirely, or just noise. This risk is
-worse on small data: an 80% hit rate on 5 rows is far more likely to be
-a fluke than the same 80% on 500 rows.
-
-So supervise what you pass in. Only include columns with a plausible
-reason to relate to the outcome, treat thin `n` results as leads to
-investigate rather than decisions to act on, and re-run as more data
-arrives rather than locking in a threshold found on a thin slice.
+`search()` finds correlations, not causes. A great-looking threshold 
+doesn't mean crossing it causes the outcome to improve, it may be riding 
+along with something else entirely, or just noise. This risk is worse on 
+small data: an 80% hit rate on 5 rows is far more likely to be a fluke 
+than the same 80% on 500 rows.
+
+edgepoint is built to optimize well on small data, shrinkage, k-fold 
+survival, and the baseline gate all exist so a thin, noisy result doesn't 
+get to rank well. To get the best out of it on small data, if you have 
+domain knowledge, supervise which columns you pass in, If you don't have
+that knowledge, let edgepoint do its magic.
 
 ---
 

{edgepoint-3.5.2 → edgepoint-3.5.4}/README.md

@@ -29,16 +29,17 @@ edgepoints_df, top_combos = search(df, outcome_col="hit")
 
 ## Correlation is not causation
 
-`search()` finds correlations, not causes. A great-looking threshold
-doesn't mean crossing it *causes* the outcome to improve, it may be
-riding along with something else entirely, or just noise. This risk is
-worse on small data: an 80% hit rate on 5 rows is far more likely to be
-a fluke than the same 80% on 500 rows.
-
-So supervise what you pass in. Only include columns with a plausible
-reason to relate to the outcome, treat thin `n` results as leads to
-investigate rather than decisions to act on, and re-run as more data
-arrives rather than locking in a threshold found on a thin slice.
+`search()` finds correlations, not causes. A great-looking threshold 
+doesn't mean crossing it causes the outcome to improve, it may be riding 
+along with something else entirely, or just noise. This risk is worse on 
+small data: an 80% hit rate on 5 rows is far more likely to be a fluke 
+than the same 80% on 500 rows.
+
+edgepoint is built to optimize well on small data, shrinkage, k-fold 
+survival, and the baseline gate all exist so a thin, noisy result doesn't 
+get to rank well. To get the best out of it on small data, if you have 
+domain knowledge, supervise which columns you pass in, If you don't have
+that knowledge, let edgepoint do its magic.
 
 ---
 

{edgepoint-3.5.2 → edgepoint-3.5.4}/edgepoint/aggregate_kfold_combos.py

@@ -10,60 +10,50 @@ def aggregate_kfold_combos(
     min_coverage=None,
 ):
     """
-    Collapses k per-fold combos_df (one per validation fold, from
-    _score_combos_on_test) into one final row per combo.
-
-    A combo's edges are already fixed (decided once by fold[0]'s
-    recommend() call), so there's nothing to re-derive like edge_point.
-    Instead: collect (hit_rate, n, gap) votes from every fold the combo
-    survived, then re-apply its FIXED edges to the FULL df once for an
-    honest hit_rate/miss_rate/gap/n/coverage (not an average of
-    per-fold percentages). mean_gap/folds_appeared/folds_positive_gap
-    are stability diagnostics only - used in show_progress debug output,
-    not part of the returned df.
+    Collapses k per-fold combos_df snapshots (one per validation fold)
+    into one final row per combo.
+
+    Each combo's edges are fixed (decided once upstream), so nothing is
+    re-derived here. For every combo that survived at least one fold,
+    its fixed edges are re-applied to the FULL df once, giving an honest
+    hit_rate/miss_rate/gap/n/coverage (not an average of per-fold
+    percentages). mean_gap/folds_appeared/folds_positive_gap are
+    stability diagnostics carried for debug printing only, not part of
+    the returned df.
 
     Gates (applied before scoring, so dropped rows never affect the
-    min-max normalization or the printed summary):
-      - min_coverage: drop combos whose AGGREGATED coverage (re-derived
-        here, not assumed from per-fold passes) falls below this.
-      - baseline_full: drop combos whose AGGREGATED hit_rate falls
-        below the caller's fixed global qualify bar.
-    Both are optional (None = skip) and independent - a combo can fail
-    either, both, or neither. This is the same "beat the bar or you're
-    out" rule the per-fold gates upstream already enforce, applied once
-    more on the final aggregated number - callers no longer need to
-    re-filter after calling this.
+    min-max normalization or the summary):
+      - min_coverage: drop combos whose aggregated coverage falls below it.
+      - baseline_full: drop combos whose aggregated hit_rate falls below it.
+    Both optional (None = skip), independent, applied once here on the
+    final aggregated number.
 
     Scoring: shrink the aggregated gap by sample size (_shrink_gap),
     min-max normalize alongside coverage across surviving combos
-    (_normalize), blend with gap_weight - same recipe as
-    aggregate_kfold_edges/find(). Sorted best-first.
+    (_normalize), blend with gap_weight. Sorted best-first.
+
+    show_progress gates ALL printing in this function - the per-fold
+    vote trail, the dropped-combo table, the top-4 summary, and the
+    gate's drop-count line. Pass show_progress=False for a fully silent
+    call.
 
     Args:
         top_combos_df: original, un-narrowed lookup table - used to
             look up each combo's fixed edges/name by combo_num. When
             include_train_hit_rate=True, its hit_rate column is also
             carried through unchanged as train_hit_rate.
-        combo_fold_results: per-fold combos_df snapshots from the
-            walkthrough (already coverage-filtered per fold).
+        combo_fold_results: per-fold combos_df snapshots (already
+            coverage-filtered per fold).
         include_train_hit_rate: attaches train_hit_rate (copied as-is
             from top_combos_df's hit_rate) to the summary and returned
-            df. Test side (test_and_combo_val.py) passes True, since
-            top_combos_df there carries the train-computed hit_rate
-            worth showing alongside test-aggregated numbers. Train side
-            (train_and_combo_gen.py) doesn't - it'd be redundant there.
-
-    Always prints a top-4 summary (combo_num, combo, hit_rate, coverage,
-    n[, train_hit_rate], score) plus the gate's drop counts, regardless
-    of show_progress (which only gates the extra per-combo debug trail).
+            df. Test side passes True; train side doesn't (redundant
+            there).
 
     Returns: combo_num, combo[, train_hit_rate], hit_rate, miss_rate,
     gap, n, coverage, score - numeric fields (except score) stringified
     to 2dp, sorted best-first. score is the same 0-100 scaled value
-    shown in the printed summary (the internal _score, ready to compare
-    directly against a train-side score column once merged). Same shape
-    _format_combos_df_for_display()/_build_top_combos() already expect,
-    plus this one new column - only rows clearing the gates are included.
+    shown in the printed summary. Only rows clearing the gates are
+    included.
     """
     k = len(combo_fold_results)
 
@@ -216,32 +206,35 @@ def aggregate_kfold_combos(
     # combo, hit_rate, coverage, n[, train_hit_rate], score) rather than
     # every internal column, so it reads consistently with every other
     # stage's printout. full_df itself (with mean_gap etc.) is kept
-    # as-is for the return step below.
-    print(f"\n=== aggregate_kfold_combos: summary (top 4 of {len(full_df)} combo(s)) ===")
-    diagnostic_df = full_df.rename(columns={"_score": "score"})
-    diagnostic_cols = ["combo_num", "combo", "hit_rate", "coverage", "n"]
-    if include_train_hit_rate:
-        diagnostic_cols += ["train_hit_rate"]
-    diagnostic_cols += ["score"]
-    diagnostic_df = diagnostic_df[[c for c in diagnostic_cols if c in diagnostic_df.columns]]
-    for col in ["hit_rate", "coverage"]:
-        if col in diagnostic_df.columns:
-            diagnostic_df[col] = diagnostic_df[col].map(lambda v: f"{v:.2f}" if pd.notna(v) else "n/a")
-    if "score" in diagnostic_df.columns:
-        diagnostic_df["score"] = (diagnostic_df["score"] * 100).round(2)
-    diagnostic_df = diagnostic_df.head(4)
-    with pd.option_context(
-        "display.width", 1000, "display.max_columns", None,
-        "display.max_colwidth", None, "display.expand_frame_repr", False,
-    ):
-        print(diagnostic_df)
-
-    # deferred from the gate block above - printed HERE, under the
-    # summary df, instead of above it.
-    if baseline_gate_msg is not None:
-        print(baseline_gate_msg)
-
+    # as-is for the return step below. Gated by show_progress - this used
+    # to print unconditionally, which meant show_progress=False callers
+    # (e.g. test_and_combo_val.py's hardcoded call) still got console
+    # output; now it's silent like everything else in this function.
     if show_progress:
+        print(f"\n=== aggregate_kfold_combos: summary (top 4 of {len(full_df)} combo(s)) ===")
+        diagnostic_df = full_df.rename(columns={"_score": "score"})
+        diagnostic_cols = ["combo_num", "combo", "hit_rate", "coverage", "n"]
+        if include_train_hit_rate:
+            diagnostic_cols += ["train_hit_rate"]
+        diagnostic_cols += ["score"]
+        diagnostic_df = diagnostic_df[[c for c in diagnostic_cols if c in diagnostic_df.columns]]
+        for col in ["hit_rate", "coverage"]:
+            if col in diagnostic_df.columns:
+                diagnostic_df[col] = diagnostic_df[col].map(lambda v: f"{v:.2f}" if pd.notna(v) else "n/a")
+        if "score" in diagnostic_df.columns:
+            diagnostic_df["score"] = (diagnostic_df["score"] * 100).round(2)
+        diagnostic_df = diagnostic_df.head(4)
+        with pd.option_context(
+            "display.width", 1000, "display.max_columns", None,
+            "display.max_colwidth", None, "display.expand_frame_repr", False,
+        ):
+            print(diagnostic_df)
+
+        # deferred from the gate block above - printed HERE, under the
+        # summary df, instead of above it.
+        if baseline_gate_msg is not None:
+            print(baseline_gate_msg)
+
         print(f"\n[debug] final combos_df: {len(full_df)} combo(s) returned "
               f"(out of {len(per_combo_votes)} seen across folds)")
 

{edgepoint-3.5.2 → edgepoint-3.5.4}/edgepoint/aggregate_kfold_edges.py

@@ -25,8 +25,9 @@ def aggregate_kfold_edges(df, outcome_col, fold_results, gap_weight=60, shrinkag
     core.py, so ranking stays consistent between per-fold results and
     this final table.
 
-    Always prints the full diagnostic table before returning (separate
-    from show_progress, which only gates the extra per-fold trail).
+    show_progress gates ALL printing in this function - the per-fold
+    vote trail AND the full diagnostic table. Pass show_progress=False
+    for a fully silent call.
 
     Returns: column, edge_point, hit_rate, miss_rate, gap, n, coverage,
     score - numeric fields (except score) stringified to 2dp, same
@@ -113,18 +114,19 @@ def aggregate_kfold_edges(df, outcome_col, fold_results, gap_weight=60, shrinkag
         full_df = full_df.sort_values("_score", ascending=False).reset_index(drop=True)
 
     # full_df (with mean_gap/folds_appeared/folds_positive_gap) is the
-    # diagnostic view - always printed here so you can see it, regardless
-    # of what gets returned below. The printed table drops folds_appeared
-    # and folds_positive_gap (still computed above and kept internally in
-    # full_df, just not shown).
-    print(f"\n=== aggregate_kfold_edges: full diagnostic view ({len(full_df)} column(s)) ===")
-    with pd.option_context(
-        "display.width", 1000, "display.max_columns", None,
-        "display.max_colwidth", None, "display.expand_frame_repr", False,
-    ):
-        print(full_df.drop(columns=["_shrunk_gap", "_score", "folds_appeared", "folds_positive_gap"], errors="ignore"))
-
+    # diagnostic view. Gated by show_progress - this used to print
+    # unconditionally regardless of the flag; now it's silent when
+    # show_progress=False like everything else in this function. The
+    # printed table drops folds_appeared and folds_positive_gap (still
+    # computed above and kept internally in full_df, just not shown).
     if show_progress:
+        print(f"\n=== aggregate_kfold_edges: full diagnostic view ({len(full_df)} column(s)) ===")
+        with pd.option_context(
+            "display.width", 1000, "display.max_columns", None,
+            "display.max_colwidth", None, "display.expand_frame_repr", False,
+        ):
+            print(full_df.drop(columns=["_shrunk_gap", "_score", "folds_appeared", "folds_positive_gap"], errors="ignore"))
+
         print(f"\n[debug] final_df: {len(full_df)} column(s) returned "
               f"(out of {len(per_column_votes)} seen across folds)")
 

{edgepoint-3.5.2 → edgepoint-3.5.4}/edgepoint/main.py

@@ -443,7 +443,7 @@ def search(df, outcome_col="hit", min_coverage=10, show_progress=True, top_combo
     # baseline stats, or any later stage ever touches it.
     df = sanity_check_columns(df, outcome_col=outcome_col, show_progress=show_progress)
 
-    train_df, test_df = split_dataset(df)
+    train_df, test_df = split_dataset(df, show_progress=show_progress)
 
     baseline_full = _baseline_hit_rate(df, outcome_col)
     baseline_train = _baseline_hit_rate(train_df, outcome_col)

{edgepoint-3.5.2 → edgepoint-3.5.4}/edgepoint/split_router.py

@@ -34,21 +34,33 @@ def determine_split_ratio(row_count):
     return _SPLIT_TIERS[-1][1], _SPLIT_TIERS[-1][2]
 
 
-def split_dataset(df):
+def split_dataset(df, show_progress=True):
     """
     Splits df chronologically (oldest -> train, newest -> test) using a
-    ratio auto-picked from row count.
+    ratio auto-picked from row count via determine_split_ratio().
 
-    Returns: train_df, test_df
+    Chronological only, no shuffling/stratification - oldest split_idx
+    rows go to train, the rest to test.
+
+    Args:
+        df: input dataframe to split.
+        show_progress: if True (default), prints the resolved row count,
+            split label, and train_ratio. Previously this print was
+            unconditional regardless of caller intent - now it's gated
+            like every other stage in search.py, so passing
+            show_progress=False silences it same as everywhere else.
+
+    Returns:
+        (train_df, test_df) - both with reset_index(drop=True).
     """
     row_count = len(df)
     train_ratio, label = determine_split_ratio(row_count)
-
     split_idx = int(row_count * train_ratio)
     train_df = df.iloc[:split_idx].reset_index(drop=True)
     test_df = df.iloc[split_idx:].reset_index(drop=True)
 
-    print(f"Row count: {row_count:,} -> split method: {label} "
-          f"(train_ratio={train_ratio})\n")
+    if show_progress:
+        print(f"Row count: {row_count:,} -> split method: {label} "
+              f"(train_ratio={train_ratio})\n")
 
     return train_df, test_df

{edgepoint-3.5.2 → edgepoint-3.5.4}/edgepoint/test_and_combo_val.py

@@ -65,7 +65,7 @@ def _score_edges_on_test(fold, outcome_col, edges_df):
     )
 
 
-def _aggregate_edges_on_full_df(df, outcome_col, edges_df, fold_results, gap_weight, shrinkage_k):
+def _aggregate_edges_on_full_df(df, outcome_col, edges_df, fold_results, gap_weight, shrinkage_k, show_progress=True):
     """
     Test-side counterpart to aggregate_kfold_edges - never re-derives
     edge_point, never drops a column. Re-applies each frozen edge_point
@@ -148,12 +148,13 @@ def _aggregate_edges_on_full_df(df, outcome_col, edges_df, fold_results, gap_wei
 
     # Always printed, full table, no head/tail cut - pandas' own default
     # row truncation handles long tables (matches aggregate_kfold_edges).
-    print(f"\n=== test_results_df: full diagnostic view ({len(full_df)} column(s)) ===")
-    with pd.option_context(
-        "display.width", 1000, "display.max_columns", None,
-        "display.max_colwidth", None, "display.expand_frame_repr", False,
-    ):
-        print(full_df.drop(columns=["_shrunk_gap", "_score", "folds_appeared"], errors="ignore"))
+    if show_progress:
+        print(f"\n=== test_results_df: full diagnostic view ({len(full_df)} column(s)) ===")
+        with pd.option_context(
+            "display.width", 1000, "display.max_columns", None,
+            "display.max_colwidth", None, "display.expand_frame_repr", False,
+        ):
+            print(full_df.drop(columns=["_shrunk_gap", "_score", "folds_appeared"], errors="ignore"))
 
     if full_df.empty:
         return pd.DataFrame(columns=["column", "edge_point", "hit_rate", "miss_rate", "gap", "n", "coverage", "score"])
@@ -226,6 +227,7 @@ def test_and_combo_val(
     test_results_df = _aggregate_edges_on_full_df(
         test_df, outcome_col, train_results_df, edge_fold_results,
         gap_weight=GAP_WEIGHT, shrinkage_k=SHRINKAGE_K,
+        show_progress=show_progress,
     )
 
     # =====================================================================

{edgepoint-3.5.2 → edgepoint-3.5.4}/edgepoint.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edgepoint
-Version: 3.5.2
+Version: 3.5.4
 Summary: Find the point in a numeric column above which a binary outcome becomes meaningfully and reliably better.
 Author: Henry
 License: MIT
@@ -57,16 +57,17 @@ edgepoints_df, top_combos = search(df, outcome_col="hit")
 
 ## Correlation is not causation
 
-`search()` finds correlations, not causes. A great-looking threshold
-doesn't mean crossing it *causes* the outcome to improve, it may be
-riding along with something else entirely, or just noise. This risk is
-worse on small data: an 80% hit rate on 5 rows is far more likely to be
-a fluke than the same 80% on 500 rows.
-
-So supervise what you pass in. Only include columns with a plausible
-reason to relate to the outcome, treat thin `n` results as leads to
-investigate rather than decisions to act on, and re-run as more data
-arrives rather than locking in a threshold found on a thin slice.
+`search()` finds correlations, not causes. A great-looking threshold 
+doesn't mean crossing it causes the outcome to improve, it may be riding 
+along with something else entirely, or just noise. This risk is worse on 
+small data: an 80% hit rate on 5 rows is far more likely to be a fluke 
+than the same 80% on 500 rows.
+
+edgepoint is built to optimize well on small data, shrinkage, k-fold 
+survival, and the baseline gate all exist so a thin, noisy result doesn't 
+get to rank well. To get the best out of it on small data, if you have 
+domain knowledge, supervise which columns you pass in, If you don't have
+that knowledge, let edgepoint do its magic.
 
 ---
 

{edgepoint-3.5.2 → edgepoint-3.5.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "edgepoint"
-version = "3.5.2"
+version = "3.5.4"
 description = "Find the point in a numeric column above which a binary outcome becomes meaningfully and reliably better."
 readme = "README.md"
 requires-python = ">=3.9"

{edgepoint-3.5.2 → edgepoint-3.5.4}/setup.py

@@ -5,7 +5,7 @@ long_description = (Path(__file__).parent / "README.md").read_text(encoding="utf
 
 setup(
     name="edgepoint",
-    version="3.5.2",
+    version="3.5.4",
     author="Henry",
     description="Find where a metric, or combination of metrics, starts getting better while keeping the best coverage possible, then check if that holds on unseen data.",
     long_description=long_description,