Save (more) persistent LightGBM trained classifiers for sleep staging

[raphaelvallat]

Related to #157

To avoid issues with model persistence in joblib/pickle, we could export the LightGBM Booster as .txt file with:

clf.save_model('lgbm_model.clf')
clf = lgb.Booster(model_file='lgbm_model.clf')

See also: https://muttoni.github.io/blog/machine-learning/2021/01/22/Fixing-Inconsistent-LightGBM-Predictions-In-Production.html#exporting-using-lightgbms-save_model

[raphaelvallat]

Summary of options

1. Zenodo + pooch (recommended)
   The infrastructure already exists. pooch downloads files on first use and caches them locally — exactly the pattern used for sample data. You'd upload the .txt files to a Zenodo record (new one, separate from samples since these aren't tutorial data) and add a fetch_classifier function. _load_model calls it transparently when the file isn't cached yet. No repo bloat. Files are checksummed and versioned.

2. Keep .joblib in the repo, skip .txt for now
   The .joblib files already work and are already committed (~36 MB). Only future classifier versions (v0.6.0+) would go straight to Zenodo as .txt. The current PR's code changes in staging.py are still useful for that future. Simplest short-term path.

3. Git LFS
   Deferred migration — worth doing eventually, but needs all contributors to install git-lfs and would affect both .joblib and .txt.

4. GitHub Releases
   Same idea as Zenodo but less permanent (releases can be deleted). Zenodo gives a DOI and guaranteed long-term availability.

Recommendation

Option 1 for future model versions, Option 2 as a bridge for the current .txt files.

Concretely for this PR: don't commit the .txt files to git. Instead, prepare the pooch infrastructure (a new "classifiers" registry entry + fetch_classifier function) so that _load_model transparently downloadsand caches them from Zenodo on first use. The .joblib files remain the bundled fallback until the Zenodo record is populated.

The existing fetch_sample function can't be reused directly because classifiers live in a different Zenodo record with different versioning. But the pattern is identical — it's a second pooch.Pooch registry.

The code-level changes would look like this (you'd populate the checksums after uploading to Zenodo):

fetchers.py — add a "classifiers" registry alongside "sample":

REGISTRY = {
    "sample": { ... },          # existing
    "classifiers": {
        "v0.5.0": {
            "base_url": "https://zenodo.org/records/<RECORD_ID>/files",
            "registry": {
                "clf_eeg_lgb_0.5.0.txt":                  "md5:...",
                "clf_eeg+eog_lgb_0.5.0.txt":              "md5:...",
                ...
            },
        },
    },
}

_load_model in staging.py — fall through to pooch when the .txt isn't bundled:
all_matching_files = glob.glob(clf_dir + name + "*.txt")
if not all_matching_files:
    # Not bundled — fetch from Zenodo and cache locally
    path_to_model = str(fetch_classifier(name_pattern))

[remrama]

Ya, I was thinking it'd be best to pull these from Zenodo using pooch as well. Repo is smaller and updates are way easier.