pyFOCI 0.3.0__tar.gz → 0.3.2__tar.gz

{pyfoci-0.3.0 → pyfoci-0.3.2}/.github/workflows/deploy-gh-pages.yml

@@ -19,7 +19,7 @@ jobs:
     - uses: actions/checkout@v7
       with:
         fetch-depth: 0
-    - uses: prefix-dev/setup-pixi@v0.9.6
+    - uses: prefix-dev/setup-pixi@v0.10.0
       with:
         pixi-version: v0.68.1
         environments: doc

{pyfoci-0.3.0 → pyfoci-0.3.2}/.github/workflows/lint.yml

@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v7
-      - uses: prefix-dev/setup-pixi@v0.9.6
+      - uses: prefix-dev/setup-pixi@v0.10.0
         with:
           pixi-version: v0.68.1
           environments: lint

{pyfoci-0.3.0 → pyfoci-0.3.2}/.github/workflows/python-app.yml

@@ -13,23 +13,21 @@ jobs:
     strategy:
       matrix:
         os: [windows-latest, ubuntu-latest, macos-latest]
+        environment: [latest]
+        include:
+          - os: ubuntu-latest
+            environment: oldest
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v7
-      - uses: prefix-dev/setup-pixi@v0.9.6
+      - uses: prefix-dev/setup-pixi@v0.10.0
         with:
           pixi-version: v0.68.1
-          environments: test
+          environments: ${{ matrix.environment }}
           frozen: true
 
-      - name: Clear pixi cache and rebuild environment
-        shell: bash
-        run: |
-          rm -rf .pixi
-          pixi install
-
       - name: Run tests
-        run: pixi run -e test test
+        run: pixi run -e ${{ matrix.environment }} test
 
       - name: Upload coverage reports to Codecov
         if: matrix.os == 'ubuntu-latest'

{pyfoci-0.3.0 → pyfoci-0.3.2}/.github/workflows/release.yml

@@ -15,7 +15,7 @@ jobs:
         uses: actions/checkout@v7
 
       - name: Install Pixi
-        uses: prefix-dev/setup-pixi@v0.9.6
+        uses: prefix-dev/setup-pixi@v0.10.0
         with:
           pixi-version: v0.68.1
 

{pyfoci-0.3.0 → pyfoci-0.3.2}/CHANGELOG.md

@@ -5,6 +5,25 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/2.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.2]
+
+### Added
+- The documentation now contains an example comparing FOCI and Lasso on a small non-linear real-world dataset.
+
+### Changed
+- Loosened the restriction to scikit-learn 1.8.
+
+## [0.3.1] - 2026-07-03
+
+### Added
+- The documentation now contains an example comparing FOCI with some scikit-learn feature selectors
+  on a small artificial redundant nonlinear dataset.
+
+### Changed
+- The default nearest neighbors strategy `nn_strategy="grouping"` is now
+  faster than quadratic in the number of unique rows.
+- Removed the restriction to Python < 3.13.
+
 ## [0.3.0] - 2026-06-26
 
 ### Added

{pyfoci-0.3.0/pyFOCI.egg-info → pyfoci-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyFOCI
-Version: 0.3.0
+Version: 0.3.2
 Summary: A template for scikit-learn compatible packages.
 Author-email: Robert Pollak <robert.pollak@jku.at>
 License-Expression: BSD-3-Clause
@@ -8,14 +8,16 @@ Project-URL: Homepage, https://github.com/m3dm-jku/pyFOCI
 Project-URL: Issues, https://github.com/m3dm-jku/pyFOCI/issues
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: POSIX
 Classifier: Operating System :: Unix
 Classifier: Operating System :: MacOS
 Classifier: Operating System :: Microsoft :: Windows
-Requires-Python: <3.13,>=3.12
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: scikit-learn==1.8
+Requires-Dist: scikit-learn>=1.6
 Requires-Dist: numpy
 Dynamic: license-file
 

{pyfoci-0.3.0 → pyfoci-0.3.2}/dev-readme.txt

@@ -3,9 +3,12 @@ Testing and merging:
 
 1. Locally:
 
+# On new Python release:
+pixi update
+
 pixi run -e lint lint
 
-pixi run -e test test
+pixi run -e latest test
 # Also examine the resulting coverage.xml.
 
 pixi run -e doc build-doc
@@ -22,6 +25,8 @@ Push dev branch to GitHub.
 
 Create pull request to trigger CI tests.
 
+Update the [Unreleased] changelog section, if relevant
+
 # Merge locally, as a workaround for https://github.com/orgs/community/discussions/5524,
 # "PR's "Rebase and Merge" should not alter commits if the head branch is already on top of the main one".
 printf 'Fast-forwarding main to dev: '; git merge-base --is-ancestor main dev && git branch -f main dev && echo OK || echo ERROR
@@ -30,7 +35,7 @@ git push origin main:main
 # By this, The GitHub repo setting "Automatically delete head branches"
 # deletes the dev branch in the pull request, for easier creation of the next pull request from dev.
 
-Update the [Unreleased] changelog section
+Check the formatting of https://github.com/m3dm-jku/pyFOCI/blob/main/CHANGELOG.md
 
 
 Releasing:
@@ -42,5 +47,5 @@ Update the changelog, commit with "Release 0.1.2".
 
 Tag the commit as "v0.1.2" and push it, including the tag.
 
-GitHub actions will then update the online docs and publish this release on GitHub and PyPI.
+Check the GitHub and PyPI release pages.
 

{pyfoci-0.3.0 → pyfoci-0.3.2}/doc/index.rst

@@ -9,7 +9,7 @@
 pyFOCI documentation
 #############################################
 
-**Date**: |today| **Version**: |version|
+**Date**: |today| **Version**: |release|
 
 **Useful links**:
 `Package Repository <https://pypi.org/project/pyFOCI>`__ |

{pyfoci-0.3.0 → pyfoci-0.3.2}/doc/user_guide.rst

@@ -33,7 +33,7 @@ FOCI performs **hierarchical forward selection**. The selection process, as desc
 How our Implementation Works
 ----------------------------
 
-We have added a ``max_features`` parameter, and a :math:`T_n` threshold ``min_delta``.
+We have added a ``max_features`` parameter, and a :math:`T_n` threshold ``min_delta`` to extend the stopping criteria.
 
 Also, the selection process, modified as in the `FOCI R reference implementation <https://cran.r-project.org/package=FOCI>`_
 and via **Fuchs, S. (2024)** , works as follows:

pyfoci-0.3.2/examples/plot_FOCISelector_bike_sharing.py

@@ -0,0 +1,191 @@
+"""
+===================================
+FOCI vs Lasso on real-world dataset
+===================================
+
+This example compares feature subsets selected by Feature Ordering by Conditional
+Independence (FOCI), Lasso, and a simple univariate mutual-information selector
+(as baseline) on a real-world regression task: hourly bike rental demand from the
+UCI/OpenML Bike Sharing Demand dataset.
+
+Bike demand depends on calendar and weather variables and shows strong nonlinear
+and cyclical effects (e.g. time-of-day and weekday patterns), making it a useful
+sanity check for nonlinear feature selection.
+
+We use a fixed chronological train/test split, a fixed five-feature budget for all
+methods, and the same nonlinear downstream regressor for evaluation. Lasso's
+regularization strength is selected by cross-validation.
+"""
+
+import time
+from functools import partial
+
+import matplotlib.pyplot as plt
+import numpy as np
+from sklearn.datasets import fetch_openml
+from sklearn.ensemble import HistGradientBoostingRegressor
+from sklearn.feature_selection import (
+    SelectFromModel,
+    SelectKBest,
+    mutual_info_regression,
+)
+from sklearn.linear_model import LassoCV
+from sklearn.metrics import mean_absolute_error, r2_score
+
+from pyFOCI import FOCISelector
+
+# -------------------------------------------------------------------------
+# Config
+# -------------------------------------------------------------------------
+K_FEATURES = 5
+STRIDE = 2  # for runtime reasons
+TRAIN_FRACTION = 0.75
+RANDOM_STATE = 0
+
+# -------------------------------------------------------------------------
+# 1. Load a real-world dataset
+# -------------------------------------------------------------------------
+bike = fetch_openml(
+    "Bike_Sharing_Demand",
+    version=2,
+    as_frame=True,
+    parser="pandas",
+)
+df = bike.frame.copy()
+
+# FOCISelector and Lasso work on numeric arrays. The OpenML copy contains a few
+# low-cardinality categorical columns, which we encode as deterministic integer
+# codes. We intentionally do not add sinusoidal or one-hot feature engineering:
+# the point is to compare feature selectors on a compact raw-feature view.
+for col in df.select_dtypes(["category", "object"]).columns:
+    df[col] = df[col].astype("category").cat.codes
+
+# Runtime-only deterministic thinning. The original rows are hourly, so this
+# keeps every second hour while preserving temporal order.
+df = df.iloc[::STRIDE].reset_index(drop=True)
+
+X_frame = df.drop(columns=["count"])
+y = df["count"].to_numpy(dtype=float)
+feature_names = X_frame.columns.to_numpy()
+X = X_frame.to_numpy(dtype=float)
+
+split = int(TRAIN_FRACTION * len(df))
+X_train, X_test = X[:split], X[split:]
+y_train, y_test = y[:split], y[split:]
+
+# -------------------------------------------------------------------------
+# 2. Feature selection benchmark
+# -------------------------------------------------------------------------
+selectors = [
+    (
+        "Mutual Info",
+        SelectKBest(
+            partial(mutual_info_regression, random_state=RANDOM_STATE),
+            k=K_FEATURES,
+        ),
+    ),
+    (
+        "LassoCV top-k",
+        SelectFromModel(
+            LassoCV(cv=5, random_state=RANDOM_STATE, max_iter=20000, n_jobs=-1),
+            threshold=-np.inf,
+            max_features=K_FEATURES,
+        ),
+    ),
+    (
+        "FOCI",
+        FOCISelector(
+            max_features=K_FEATURES,
+            min_delta=None,
+            random_state=RANDOM_STATE,
+        ),
+    ),
+]
+
+results = []
+w = 91
+print("\n" + "=" * w)
+print(
+    "Feature selector comparison on Bike Sharing Demand "
+    f"(n={len(df)}, p={X.shape[1]}, k={K_FEATURES})"
+)
+print("=" * w)
+header = f"{'Method':<14} | {'Time (s)':<8} | {'Test R²':<8} | {'MAE':<8} | Features"
+print(header)
+print("-" * w)
+
+for name, selector in selectors:
+    t0 = time.time()
+    selector.fit(X_train, y_train)
+    elapsed = time.time() - t0
+
+    support = selector.get_support()
+    selected_idx = np.flatnonzero(support)
+    selected_names = feature_names[selected_idx].tolist()
+
+    # Same downstream model for all selectors: the comparison is about which
+    # raw features are chosen, not about changing predictors between methods.
+    predictor = HistGradientBoostingRegressor(
+        max_iter=200,
+        learning_rate=0.05,
+        max_leaf_nodes=31,
+        random_state=RANDOM_STATE,
+    )
+    predictor.fit(X_train[:, selected_idx], y_train)
+    y_pred = predictor.predict(X_test[:, selected_idx])
+
+    test_r2 = r2_score(y_test, y_pred)
+    test_mae = mean_absolute_error(y_test, y_pred)
+
+    results.append(
+        {
+            "name": name,
+            "time": elapsed,
+            "r2": test_r2,
+            "mae": test_mae,
+            "features": selected_names,
+        }
+    )
+
+    print(
+        f"{name:<14} | {elapsed:8.3f} | {test_r2:8.4f} | "
+        f"{test_mae:8.2f} | {selected_names}"
+    )
+
+print("=" * w + "\n")
+
+# -------------------------------------------------------------------------
+# 3. Plotting results
+# -------------------------------------------------------------------------
+fig, ax = plt.subplots(1, 1, figsize=(7, 5))
+
+names = [result["name"] for result in results]
+r2_scores = [result["r2"] for result in results]
+runtimes = [result["time"] for result in results]
+
+x_pos = np.arange(len(names))
+width = 0.35
+
+ax_time = ax.twinx()
+ax.bar(x_pos - width / 2, r2_scores, width, label="Test R²", color="tab:purple")
+ax_time.bar(
+    x_pos + width / 2,
+    runtimes,
+    width,
+    label="Runtime (s)",
+    color="tab:orange",
+    alpha=0.7,
+)
+
+ax.set_title("Bike Sharing Demand: selected-feature utility vs runtime")
+ax.set_xticks(x_pos)
+ax.set_xticklabels(names, rotation=20, ha="right")
+ax.set_ylabel("Test R²", color="tab:purple", fontweight="bold")
+ax.tick_params(axis="y", labelcolor="tab:purple")
+ax.set_ylim(0, 1.05)
+
+ax_time.set_ylabel("Runtime (seconds)", color="tab:orange", fontweight="bold")
+ax_time.tick_params(axis="y", labelcolor="tab:orange")
+
+fig.tight_layout()
+plt.show()

pyfoci-0.3.2/examples/plot_FOCISelector_comparison.py

@@ -0,0 +1,204 @@
+"""
+===================================
+FOCI vs others on synthetic dataset
+===================================
+
+This example creates a small additive nonlinear synthetic dataset with redundant
+distractor features to demonstrate how Feature Ordering by Conditional Independence
+(FOCI) isolates complementary nonlinear signals, in comparison with some basic
+scikit-learn feature selectors.
+
+Univariate feature selectors (SelectKBest) evaluate features marginally, ranking
+redundant collinear features equally high. Lasso is a (sparse) linear method,
+therefore does not work well on strongly nonlinear data, similar to Recursive Feature
+Elimination (RFE) with a linear model, which also cannot deal well with collinear
+features. Tree-based RFE works better, but is much slower and still dilutes split
+importances across collinear groups. A kernel-based method (SequentialFeatureSelector
+with Support Vector Regression) works well, but takes even longer.
+"""
+
+import time
+
+import matplotlib.pyplot as plt
+import numpy as np
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.feature_selection import (
+    RFE,
+    SelectFromModel,
+    SelectKBest,
+    SequentialFeatureSelector,
+    f_regression,
+    mutual_info_regression,
+)
+from sklearn.linear_model import Lasso, LinearRegression
+from sklearn.metrics import r2_score
+from sklearn.model_selection import train_test_split
+from sklearn.pipeline import make_pipeline
+from sklearn.preprocessing import StandardScaler
+from sklearn.svm import SVR
+
+from pyFOCI import FOCISelector
+
+# -------------------------------------------------------------------------
+# Config
+# -------------------------------------------------------------------------
+K_FEATURES = 5
+N_DISTRACTORS = 4
+
+# -------------------------------------------------------------------------
+# 1. Generate small nonlinear dataset with collinearity
+# -------------------------------------------------------------------------
+random_state = np.random.RandomState(0)
+n, p = 600, 25
+X = random_state.normal(size=(n, p))
+
+# Create a redundant collinear distractor group for x0
+x0_distractors = range(4, 4 + N_DISTRACTORS)
+
+X[:, x0_distractors] = X[:, 0:1] + 0.01 * random_state.normal(size=(n, N_DISTRACTORS))
+
+# True underlying signals, all even.
+y = (
+    2 * (X[:, 0] ** 2 - 1)
+    + 2 * (X[:, 1] ** 2 - 1)
+    + 3 * np.exp(-X[:, 2] ** 2)
+    + 2 * np.cos(2.0 * X[:, 3])
+    + 0.1 * random_state.normal(size=n)
+)
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
+
+# -------------------------------------------------------------------------
+# 2. Benchmark comparison
+# -------------------------------------------------------------------------
+signal_groups = [
+    {0, *x0_distractors},
+    {1},
+    {2},
+    {3},
+]
+signal_group_names = ["x0", "x1", "x2", "x3"]
+
+# Used for downstream evaluation and as the estimator for tree-based RFE
+rf = RandomForestRegressor(n_estimators=100, random_state=0, n_jobs=-1)
+
+svr_rbf = make_pipeline(StandardScaler(), SVR(kernel="rbf", C=10.0, gamma="scale"))
+
+selectors = [
+    ("F-reg", SelectKBest(f_regression, k=K_FEATURES)),
+    ("Mutual Info", SelectKBest(mutual_info_regression, k=K_FEATURES)),
+    (
+        "Lasso (L1)",
+        SelectFromModel(
+            Lasso(alpha=0.01, random_state=0, max_iter=5000),
+            max_features=K_FEATURES,
+        ),
+    ),
+    (
+        "RFE (LinReg)",
+        RFE(estimator=LinearRegression(), n_features_to_select=K_FEATURES),
+    ),
+    ("RFE (RF)", RFE(estimator=rf, n_features_to_select=K_FEATURES)),
+    (
+        "SFS (SVR-RBF)",
+        SequentialFeatureSelector(
+            estimator=svr_rbf,
+            n_features_to_select=K_FEATURES,
+            direction="forward",
+            n_jobs=-1,
+        ),
+    ),
+    ("FOCI", FOCISelector(max_features=K_FEATURES, random_state=0)),
+]
+
+results = []
+w = 80
+print("\n" + "=" * w)
+print(
+    "Feature Selector comparison on small additive nonlinear data "
+    f"(n={n}, p={p}, k={K_FEATURES})"
+)
+print("=" * w)
+header = (
+    f"{'Method':<13} | {'Time (s)':<8} | {'Signal Cov':<10} | "
+    f"{'Test R²':<8} | {'Sel Groups':<12} | {'Sel Indices'}"
+)
+print(header)
+print("-" * w)
+
+for name, sel in selectors:
+    t0 = time.time()
+    sel.fit(X_train, y_train)
+    dt = time.time() - t0
+
+    support = sel.get_support()
+    sorted_idx = [int(i) for i in np.where(support)[0]]
+
+    selected_set = set(sorted_idx)
+    selected_groups = [
+        group_name
+        for group_name, group in zip(signal_group_names, signal_groups)
+        if (selected_set & group)
+    ]
+    selected_groups_str = ",".join(selected_groups) if selected_groups else "-"
+
+    captured_groups = len(selected_groups)
+    signal_coverage = captured_groups / len(signal_groups)
+
+    if sorted_idx:
+        rf.fit(X_train[:, sorted_idx], y_train)
+        y_pred = rf.predict(X_test[:, sorted_idx])
+        test_r2 = r2_score(y_test, y_pred)
+    else:
+        test_r2 = 0.0
+
+    results.append(
+        {
+            "name": name,
+            "time": dt,
+            "r2": test_r2,
+        }
+    )
+
+    print(
+        f"{name:<13} | {dt:8.3f} | {signal_coverage:10.2f} | "
+        f"{test_r2:8.4f} | {selected_groups_str:<12} | {sorted_idx}"
+    )
+
+print("=" * w + "\n")
+
+# -------------------------------------------------------------------------
+# 3. Plotting Results
+# -------------------------------------------------------------------------
+fig, ax = plt.subplots(1, 1, figsize=(7, 5))
+
+names = [r["name"] for r in results]
+r2_scores = [r["r2"] for r in results]
+runtimes = [r["time"] for r in results]
+
+x_pos = np.arange(len(names))
+width = 0.35
+
+ax_time = ax.twinx()
+ax.bar(x_pos - width / 2, r2_scores, width, label="Test R² Score", color="tab:purple")
+ax_time.bar(
+    x_pos + width / 2,
+    runtimes,
+    width,
+    label="Runtime (s)",
+    color="tab:orange",
+    alpha=0.7,
+)
+
+ax.set_title("Selected-feature utility vs Runtime")
+ax.set_xticks(x_pos)
+ax.set_xticklabels(names, rotation=20, ha="right")
+ax.set_ylabel("Test R² Score", color="tab:purple", fontweight="bold")
+ax.tick_params(axis="y", labelcolor="tab:purple")
+ax.set_ylim(0, 1.05)
+
+ax_time.set_ylabel("Runtime (seconds)", color="tab:orange", fontweight="bold")
+ax_time.tick_params(axis="y", labelcolor="tab:orange")
+
+fig.tight_layout()
+plt.show()