LightGBM 4.7: native Polars and PyArrow in the sklearn API

If you train tabular models after dinner, the awkward step used to be: clean in Polars (or keep Arrow tables from a Parquet pipeline), then convert everything to NumPy or pandas before LGBMClassifier.fit. LightGBM v4.7.0 (released 18 July 2026) shrinks that friction. According to the v4.7.0 release notes, the Python package now supports Polars inputs (via Arrow interoperability / narwhals) and the scikit-learn methods accept PyArrow Table as input.

This Hub note is for employed people studying after work. It is not a trading CTA, not investment advice, and not a claim that one library wins every benchmark.

What actually landed in v4.7.0

From the official release highlights and change list:

• Polars support in the Python package, building on Arrow interoperability (including work via the Arrow PyCapsule Interface).
• PyArrow Table as input in scikit-learn methods (Support PyArrow Table as an input in scikit-learn methods).
• Related pieces: Arrow array / Polars series as position, and broader Arrow-friendly plumbing.

Also worth knowing if you upgrade tonight:

• Minimum Python 3.10+ for the package path described in the release.
• PyArrow floor was raised in the same release train (notes mention bumps toward recent PyArrow versions)—check your environment before assuming an old Arrow wheel is fine.
• GPU / ROCm / multi-GPU CUDA and Dask fixes are in the same release, but this note focuses on the tabular I/O story for evening notebooks.

Cite the primary source, not rumor: LightGBM v4.7.0.

Why this matters for a modern tabular stack

A practical after-work stack often looks like:

1. Parquet / Arrow on disk
2. Polars (or Arrow tables) for prep
3. scikit-learn-style estimators for the model loop

Until native table support, step 3 forced a type conversion tax—extra RAM, extra copies, and one more place for dtype surprises. Native Polars / PyArrow in the sklearn API means your evening script can stay closer to one representation from read the file to fit the booster.

You still need honest validation splits, careful categoricals, and readable feature names. Native input types do not replace judgment.

Minimal evening sketch (illustrative)

Install a current LightGBM 4.7.x wheel in a fresh venv, then try a tiny Polars frame through the familiar sklearn API. Exact optional extras depend on your OS wheel—follow the release / docs if import fails.

# Illustrative after-work sketch — verify against LightGBM 4.7 docs on your machine
import polars as pl
from lightgbm import LGBMClassifier

df = pl.DataFrame(
    {
        "x1": [0.1, 0.4, 0.7, 0.2, 0.9],
        "x2": [1, 0, 1, 0, 1],
        "y": [0, 0, 1, 0, 1],
    }
)
X = df.select(["x1", "x2"])
y = df["y"]

clf = LGBMClassifier(n_estimators=20, verbose=-1)
clf.fit(X, y)
print(clf.predict(X))

If you already hold a pyarrow.Table, the same idea applies: pass the table into the sklearn fit / predict path that v4.7 documents, instead of bouncing through pandas only to please the estimator.

Keep the first run tiny. Confirm lightgbm.version starts with 4.7 before you blame your data.

How this differs from pandas vs Polars Hub notes

Our earlier Hub angle on pandas 3 Copy-on-Write vs Polars is about dataframe ergonomics and ETL. This note is different: gradient boosting sklearn API eating modern column stores. You can keep pandas for last-mile charts and still use Polars upstream—LightGBM 4.7 is about reducing the glue layer at fit().

After-work checklist (45 minutes)

1. Create a throwaway venv; upgrade to LightGBM 4.7.x from the release assets / PyPI.
2. Print lightgbm.version and your Python version (at least 3.10 per release notes).
3. Fit one tiny Polars or PyArrow example; do not start with a work-sized extract.
4. Only then point at a real Parquet file and a proper time- or group-aware validation plan.

If the blocker is still shaky Python packages and DataFrames, start with fundamentals first—native Arrow support will not help a confused environment.

Closing

LightGBM v4.7.0 (18 July 2026) is a concrete step toward a modern tabular loop: Polars and PyArrow Table in the sklearn API, as stated in the official release. Use it to shorten evening glue code—not to invent performance myths. Read the release notes, keep validation honest, and treat this as educational tooling commentary.

Next step: strengthen Python and data hygiene with Intro to Python Programming—the only enrollment CTA in this note.

Sources

• LightGBM v4.7.0 release notes (published 2026-07-18)