scikit-rec 0.4__tar.gz → 0.4.2__tar.gz

{scikit_rec-0.4 → scikit_rec-0.4.2}/.github/workflows/ci.yml

@@ -16,7 +16,7 @@ jobs:
         with:
           python-version: "3.12"
       - name: Install ruff
-        run: pip install ruff
+        run: pip install ruff==0.16.0
       - name: Check formatting
         run: ruff format --check .
       - name: Check lint

{scikit_rec-0.4 → scikit_rec-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scikit-rec
-Version: 0.4
+Version: 0.4.2
 Summary: A scikit-style recommender systems library
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://github.com/intuit/scikit-rec
@@ -26,7 +26,7 @@ Requires-Dist: boto3<3.0.0,>=1.26.27; extra == "aws"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0; extra == "dev"
-Requires-Dist: ruff>=0.4; extra == "dev"
+Requires-Dist: ruff==0.16.0; extra == "dev"
 Requires-Dist: mypy>=1.0; extra == "dev"
 Requires-Dist: moto[s3]>=4.0; extra == "dev"
 Requires-Dist: pre-commit>=3.0; extra == "dev"

{scikit_rec-0.4 → scikit_rec-0.4.2}/docs/advanced/orchestration.md

@@ -66,8 +66,9 @@ Per-scorer constructor kwargs. Optional; defaults preserve historical scorer beh
 | Key | Used by | Type | Description |
 |-----|---------|------|-------------|
 | `on_degenerate_target` | `multioutput` | `DegenerateTargetPolicy` or `"raise"` / `"constant"` | Policy for single-class targets in the training slice. `"raise"` (default) aborts training with the offending column names; `"constant"` fits a constant predictor for degenerate columns and trains the rest. See [`MultioutputScorer` degenerate-target handling](../user-guide/scorers.md#degenerate-target-handling-on_degenerate_target). |
+| `batch_chunk_dir` | `independent` | `str` | Directory for the temporary per-item chunks written during batch training (default: the system temp directory). Unused when the interactions are already partitioned into `ITEM_ID=<value>/` directories. See [Batch (partitioned) training](../user-guide/capability-matrix.md#batch-partitioned-training). |
 
-Scorers without entries here (`multiclass`, `independent`, `universal`, `sequential`, `hierarchical`) accept no `scorer_config` keys today — passing any key raises.
+Scorers without entries here (`multiclass`, `universal`, `sequential`, `hierarchical`) accept no `scorer_config` keys today — passing any key raises.
 
 ### Embedding Config
 
@@ -182,6 +183,7 @@ capability_matrix()
 #     "scorer_config_keys": {
 #         "multioutput": ("on_degenerate_target",),
 #         "mixed_type_multi_target": ("target_specs",),
+#         "independent": ("batch_chunk_dir",),
 #         "multiclass": (),
 #         # ...
 #     },

{scikit_rec-0.4 → scikit_rec-0.4.2}/docs/examples/index.md

@@ -67,3 +67,21 @@ Side-by-side comparison of all three `ContextMode` variants on a synthetic datas
 - `SCORING_LAYER` — most expressive; context, user, and item representations combined in a final linear layer
 
 See the [Contextualized Two-Tower Guide](../user-guide/two-tower.md) for architecture details and ANN serving patterns.
+
+---
+
+## Multi-label — Per-label vs Joint XGBoost under `MultioutputScorer`
+
+`nb_examples/multioutput_per_label_vs_joint_xgb.ipynb`
+
+Three model structures behind the **same** `MultioutputScorer` API, on one wide
+binary-multilabel frame with correlated labels.
+
+**What it covers:**
+
+- **Per-label** (`MultiOutputClassifierEstimator`) — N independent boosters
+- **Joint `one_output_per_tree`** (`JointXGBMultiOutputClassifierEstimator`, default) — one booster, GPU-capable, **no** cross-label learning (metrics match per-label)
+- **Joint `multi_output_tree`** — one booster, shared vector-leaf splits = **genuine cross-label learning** (CPU-only); shows the small AUC lift on the correlated label
+- The general `sample_weight='balanced'` class-weighting passthrough
+
+See [per-label vs joint estimators](../user-guide/scorers.md#per-label-vs-joint-estimators) for the contract.

{scikit_rec-0.4 → scikit_rec-0.4.2}/docs/getting-started/datasets.md

@@ -225,6 +225,19 @@ interactions_ds = InteractionsDataset(
 )
 ```
 
+### Partitioned Datasets
+
+Point `data_location` at a directory (local or S3) to read every `.parquet` file in it, including subdirectories. Directories starting with `_` or `.` (such as Spark's `_temporary`) are skipped.
+
+```python
+interactions_ds = InteractionsDataset(data_location='s3://my-bucket/data/interactions/')
+```
+
+Hive-style `key=value/` directories are supported, e.g. data written by Spark's `partitionBy`:
+
+- `ITEM_ID=<value>/` restores `ITEM_ID` as a column, since it is required. `IndependentScorer` batch training also uses this layout to train each item from its own files.
+- Other keys such as `month=` or `dt=` are ignored, so they never become features by accident. Declare them in the client schema to load them as columns.
+
 ### Using Example Datasets
 
 The library includes sample datasets for experimentation:
@@ -288,6 +301,7 @@ Different scorers have different dataset requirements:
 ### 2. Data Quality
 - Remove duplicate interactions
 - Handle missing values consistently
+- Remove rows with missing `USER_ID` or `ITEM_ID`: training and `recommend()` reject them
 - Ensure ID consistency across datasets
 
 ### 3. Train/Test Split
@@ -314,6 +328,10 @@ Different scorers have different dataset requirements:
 
 **Solution**: Check your schema matches your actual data types.
 
+### ValueError: 'USER_ID' column in interactions contains N null value(s)
+
+**Solution**: Drop or fill rows with missing IDs (the message lists the first rows). Null IDs usually come from an unmatched upstream join or a failed type cast. The same check applies to `ITEM_ID`, and to the users and items datasets.
+
 ### ValueError: Items dataset required for Universal scorer
 
 **Solution**: Provide an items dataset or switch to Independent scorer.

{scikit_rec-0.4 → scikit_rec-0.4.2}/docs/user-guide/capability-matrix.md

@@ -38,7 +38,7 @@ Models fall into three **training / scoring planes**. Each plane uses different
 | **UniversalScorer** | **Yes** (factory yields `TabularUniversalScorer`) | **Yes** (`EmbeddingUniversalScorer`) | **No** (use `SequentialScorer`) |
 | **IndependentScorer** | **Yes** (single or dict of estimators) | **No** (raises at init) | **No** |
 | **MulticlassScorer** | **Yes** | **No** (raises at init) | **No** |
-| **MultioutputScorer** | **Yes** — accepts both `BaseClassifier` (e.g. `MultiOutputClassifierEstimator`, binary-only — multi-class targets rejected at fit) and `BaseRegressor` (e.g. `MultiOutputRegressorEstimator`, continuous targets) | **No** (raises at init) | **No** |
+| **MultioutputScorer** | **Yes** — `BaseClassifier` (binary-only; multi-class rejected at fit) or `BaseRegressor`. Per-label: `MultiOutputClassifierEstimator` / `MultiOutputRegressorEstimator` (N independent boosters). Joint single-booster: `JointXGBMultiOutputClassifierEstimator` / `JointXGBMultiOutputRegressorEstimator`. sklearn tree ensembles (RandomForest/ExtraTrees) are joint multi-output via the `SklearnUniversal*` wrappers. See [per-label vs joint](scorers.md#per-label-vs-joint-estimators). | **No** (raises at init) | **No** |
 | **MixedTypeMultiTargetScorer** | **Yes** — accepts any `MultiTargetEstimator` (joint MLP, joint Transformer, or independent). Heterogeneous per-target types: binary + regression + multiclass + multilabel groups in one model. See [decision rule](decision-rule.md) for per-target metric dispatch. | **No** (raises at init via Protocol check) | **No** |
 | **SequentialScorer** | **No** | **No** | **Yes** |
 | **HierarchicalScorer** | **No** | **No** | **Yes** (HRNN estimators) |
@@ -46,6 +46,19 @@ Models fall into three **training / scoring planes**. Each plane uses different
 
 ---
 
+## Estimator config knobs (tabular)
+
+These `estimator_config` keys apply to the sklearn-API tabular estimators (XGBoost / LightGBM / sklearn wrappers, single- and multi-target). All are introspectable via `capability_matrix()` so external callers (e.g. the agent) stay in lockstep.
+
+| Config path | Values | Applies to | `capability_matrix()` key |
+|---|---|---|---|
+| `weights.sample_weight` | `'balanced'` (class-balanced at fit), a callable `fn(y)->weights`, or an explicit array (default: uniform) | All sklearn-API estimators, all scorers (XGB/LightGBM/sklearn; single- & multi-target). For early stopping, `'balanced'`/callable also weight the eval set; explicit arrays are train-only. | `weights_config_keys` |
+| `weights.fit_params` | dict of static kwargs forwarded to the wrapped `fit` (`feature_weights`, `base_margin`, custom objective, `callbacks`, …) | All sklearn-API estimators | `weights_config_keys` |
+| `weights.action_weight`, `weights.item_sample_weights` | recsys item/action weighting (composes multiplicatively with `sample_weight`) | `WeightedXGBClassifierEstimator` path | `weights_config_keys` |
+| `multioutput_strategy` | `'per_label'` (default; N independent boosters) or `'joint'` (one joint XGBoost booster) | `scorer_type="multioutput"` only. `'joint'` is **XGBoost-only** and **non-tuned-only** (no HPO wrapper); pair with `xgboost.multi_strategy='multi_output_tree'` for cross-label learning (CPU-only) or `'one_output_per_tree'` (GPU; per-label-equivalent). | `multioutput_strategy_types` |
+
+---
+
 ## `recommend()` vs `recommend_online()`
 
 | Recommender | `recommend()` | `recommend_online()` | Notes |
@@ -91,9 +104,11 @@ Retriever is **optional** on these classes. `SequentialRecommender`’s public c
 | Support | Details |
 |---------|---------|
 | **Estimator** | In the shipped code, **`BatchXGBClassifierEstimator`** implements `_batch_fit_model` (see `skrec/estimator/classification/xgb_classifier.py`). Other estimators use in-memory `fit` unless extended. |
-| **Training** | `coordinate_training` uses the batch path when `estimator.support_batch_training()` is true: **`interactions_ds` required**; **`items_ds` required** for partitioned catalogue setup; validation datasets must satisfy the same rules as tabular validation (e.g. `valid_users_ds` when users + valid interactions). |
+| **Partitioned layout** | Partitioned datasets (local or S3) are read recursively; `_`/`.` directories such as Spark's `_temporary` are skipped. In Hive-style `key=value/` directories, only declared keys become columns: `ITEM_ID` (required) and any key the client schema declares. Other keys such as `month=` or `dt=` are ignored, so they never become features implicitly; declare them in the client schema to use them. |
+| **Training** | `coordinate_training` uses the batch path when `scorer.support_batch_training()` is true (default: delegates to the estimator): **`interactions_ds` required**; **`items_ds` required** for partitioned catalogue setup; validation datasets must satisfy the same rules as tabular validation (e.g. `valid_users_ds` when users + valid interactions). `train()` does not load the whole interactions dataset in batch mode (only one partition, for column names); retrievers and GCSL load it on demand. Each partition gets the recommender's outcome-column handling as it is read. |
 | **Embedding** | **No** batch-training branch for `BaseEmbeddingEstimator` in the same iterator style. |
 | **Sequential** | **`support_batch_training()` is False** for `SequentialEstimator`. |
+| **IndependentScorer** | **Yes**, when every per-item estimator supports batch training (mixing batch and in-memory estimators raises `TypeError`). If the interactions are partitioned into `ITEM_ID=<value>/` directories, each item trains straight from its own files with no copy (read once to train, plus once up front when the binary-label check applies); a file whose `ITEM_ID` column disagrees with its directory raises. Otherwise one pass over the partitions writes each item's rows to temporary per-item parquet chunks (buffered, so roughly one file per item), a local-disk copy of the interactions, under `batch_chunk_dir` (`IndependentScorer(..., batch_chunk_dir=...)` or `scorer_config`; default: the system temp directory). Items with no interactions are dropped. `items_ds` is required. |
 
 ---
 

{scikit_rec-0.4 → scikit_rec-0.4.2}/docs/user-guide/estimators.md

@@ -24,8 +24,29 @@ For continuous outcomes (revenue, time-spent, rating):
 
 ### Multi-output Estimators
 
-- **`MultiOutputClassifierEstimator`** - Wrapper for multi-output classification (multiple **binary numeric** targets per user — values strictly in `{0, 1}`). Pairs with `MultioutputScorer` in classifier mode. The scorer-level `MultioutputScorer._validate_targets` (early, before the wrapper sees the data) enforces the strict `{0, 1}` value contract — strings and signed-integer encodings like `{-1, 1}` are rejected there. Bool columns ARE accepted (Python `True == 1` / `False == 0` in set membership, so `{True, False}` collapses to `{0, 1}`). The wrapper's own `_validate_binary_targets` (defense-in-depth pre-flight scan, so the wrapper is safe to use standalone) enforces the per-target cardinality contract — exactly two unique values per column, neither single-class nor 3+-class. See [scorer migration paths](scorers.md#migration-paths-for-multi-class-targets).
-- **`MultiOutputRegressorEstimator`** - Wrapper for multi-output regression (multiple continuous targets per user). Pairs with `MultioutputScorer` in regressor mode for predictions like per-user revenue, engagement minutes, click counts, etc.
+- **`MultiOutputClassifierEstimator`** - Wrapper for multi-output classification (multiple **binary numeric** targets per user — values strictly in `{0, 1}`). Pairs with `MultioutputScorer` in classifier mode. Fits **one separate booster per target** (`sklearn.MultiOutputClassifier`). The scorer-level `MultioutputScorer._validate_targets` (early, before the wrapper sees the data) enforces the strict `{0, 1}` value contract — strings and signed-integer encodings like `{-1, 1}` are rejected there. Bool columns ARE accepted (Python `True == 1` / `False == 0` in set membership, so `{True, False}` collapses to `{0, 1}`). The wrapper's own `_validate_binary_targets` (defense-in-depth pre-flight scan, so the wrapper is safe to use standalone) enforces the per-target cardinality contract — exactly two unique values per column, neither single-class nor 3+-class. See [scorer migration paths](scorers.md#migration-paths-for-multi-class-targets).
+- **`MultiOutputRegressorEstimator`** - Wrapper for multi-output regression (multiple continuous targets per user). Fits one separate booster per target. Pairs with `MultioutputScorer` in regressor mode for predictions like per-user revenue, engagement minutes, click counts, etc.
+- **`JointXGBMultiOutputClassifierEstimator`** - A **single joint XGBoost booster** over all N binary labels (vs N independent boosters above). Pairs with `MultioutputScorer` classifier mode; reshapes XGBoost's `(n, N)` `predict_proba` into the per-label list the scorer expects. `multi_strategy='one_output_per_tree'` (default, GPU-capable) does **not** share structure across labels; `multi_strategy='multi_output_tree'` (vector leaf, CPU-only) does — that's the only mode with genuine cross-label learning. See [Per-label vs joint estimators](scorers.md#per-label-vs-joint-estimators).
+- **`JointXGBMultiOutputRegressorEstimator`** - The regressor analogue: a single joint XGBoost booster over N continuous targets, for `MultioutputScorer` regressor mode (no reshape needed — `predict` is already `(n, N)`).
+- **Note on `multi_strategy`:** "joint" means one model artifact; it does **not** automatically mean cross-target learning. Only `multi_output_tree` (or sklearn tree ensembles below) shares tree structure across targets. None of these condition one target on another's *value* — for that, use the conditional estimators under `MixedTypeMultiTargetScorer`.
+- **sklearn tree ensembles (`RandomForestClassifier`, `ExtraTreesClassifier`, regressors)** are joint multi-output **for free**: they natively accept a 2-D target matrix, grow multi-output trees that share structure across all targets **by default**, and their multilabel `predict_proba` already returns the list-of-blocks layout `MultioutputScorer` expects. Use them through the plain `SklearnUniversalClassifierEstimator` / `SklearnUniversalRegressorEstimator` (2-D `y`) — no dedicated estimator needed.
+
+### Class weighting & fit-time parameters
+
+Every sklearn-API estimator (XGBoost / LightGBM / sklearn wrappers, single- and multi-target) takes two optional constructor args (and matching `set_sample_weight` / `set_fit_params` setters):
+
+- **`sample_weight`** — a row-weight strategy: `'balanced'` (computes `compute_sample_weight('balanced', y)` at fit time — the production class-balancing recipe), a callable `fn(y) -> weights`, or an explicit per-row array. Defaults to uniform.
+- **`fit_params`** — a dict of static kwargs forwarded verbatim to the wrapped model's `fit` (`feature_weights`, `base_margin`, a custom objective, `callbacks`, …).
+
+```python
+# class-balanced multiclass (firmographics-industry recipe)
+estimator = XGBClassifierEstimator(
+    {"n_estimators": 426, "objective": "multi:softprob"},
+    sample_weight="balanced",
+)
+```
+
+This is the general replacement for ad-hoc weighting; the row weights are resolved against `y` at fit time, so they stay aligned through the scorer pipeline. (`WeightedXGBClassifierEstimator`'s item/action weighting still exists and composes multiplicatively with a `'balanced'` strategy.)
 
 ### Embedding Estimators
 

{scikit_rec-0.4 → scikit_rec-0.4.2}/docs/user-guide/scorers.md

@@ -72,6 +72,19 @@ scorer = IndependentScorer(estimator)
 
 **When to use**: When you don't have item features, or each item needs a specialized model.
 
+**Batch training** (data larger than memory): pass a batch-capable estimator such as `BatchXGBClassifierEstimator`, either one estimator (copied per item) or a dict with one per item. Don't mix batch and in-memory estimators in one dict. `items_ds` is required, to supply the item list. Each item trains from only its own rows:
+
+- If the interactions are partitioned into `ITEM_ID=<value>/` directories (e.g. Spark `partitionBy("ITEM_ID")`), each item reads its own files directly, with no copy.
+- Otherwise one pass over the partitions writes each item's rows to temporary parquet files, a local-disk copy of the interactions. Choose where with `IndependentScorer(estimator, batch_chunk_dir="/big/volume")` or `scorer_config: {batch_chunk_dir: ...}`.
+
+```python
+from skrec.estimator.classification.xgb_classifier import BatchXGBClassifierEstimator
+
+scorer = IndependentScorer(BatchXGBClassifierEstimator({"objective": "binary:logistic"}))
+```
+
+See [Batch (partitioned) training](capability-matrix.md#batch-partitioned-training) for details.
+
 ---
 
 ## 3. MulticlassScorer
@@ -143,6 +156,86 @@ estimator = MultiOutputRegressorEstimator(
 scorer = MultioutputScorer(estimator)
 ```
 
+### Per-label vs joint estimators
+
+`MultioutputScorer` is agnostic to *how* the N targets are modeled — only to the
+output shape. Two model structures are supported:
+
+- **Per-label (N independent models).** `MultiOutputClassifierEstimator` /
+  `MultiOutputRegressorEstimator` wrap `sklearn.MultiOutputClassifier` /
+  `MultiOutputRegressor`, which fit **one separate booster per target**. Simple
+  and robust; no signal is shared across targets.
+- **Joint (one model over all targets).** `JointXGBMultiOutputClassifierEstimator`
+  (classifier mode) and `JointXGBMultiOutputRegressorEstimator` (regressor mode)
+  train a **single XGBoost booster** on the 2-D target matrix. This matches a
+  production `num_target=N` recipe and trains/serves one artifact.
+
+  ```python
+  from skrec.estimator.classification.joint_xgb_multioutput import (
+      JointXGBMultiOutputClassifierEstimator,
+  )
+  # one joint booster over all binary labels
+  scorer = MultioutputScorer(JointXGBMultiOutputClassifierEstimator({"n_estimators": 300}))
+  ```
+
+  > **"Joint" ≠ cross-label learning by default.** XGBoost's `multi_strategy`
+  > decides whether targets share tree structure:
+  > - `'one_output_per_tree'` (**default**): separate trees per target inside one
+  >   jointly-boosted model. **GPU-capable. No cross-label learning** — modeling-wise
+  >   close to per-label.
+  > - `'multi_output_tree'` (vector leaf): splits chosen on the summed gradient
+  >   across all targets, so targets share structure. **Genuine cross-label
+  >   learning, but CPU-only.** Pass `params={'multi_strategy': 'multi_output_tree'}`
+  >   to opt in; the estimator logs that it's active + CPU-only and warns if a GPU
+  >   `device`/`tree_method` was also set.
+
+- **sklearn tree ensembles are joint for free.** `RandomForestClassifier` /
+  `ExtraTreesClassifier` (and their regressors) natively accept a 2-D target
+  matrix and grow **multi-output trees that share structure across all targets by
+  default** (splits chosen on the averaged criterion across targets — genuine
+  shared-representation learning). Their multilabel `predict_proba` already returns
+  the list-of-blocks layout the scorer expects, so they work through the plain
+  `SklearnUniversalClassifierEstimator` / `SklearnUniversalRegressorEstimator` with
+  **no dedicated estimator**:
+
+  ```python
+  from sklearn.ensemble import RandomForestClassifier
+  from skrec.estimator.classification.sklearn_universal_classifier import (
+      SklearnUniversalClassifierEstimator,
+  )
+  scorer = MultioutputScorer(
+      SklearnUniversalClassifierEstimator(RandomForestClassifier, {"n_estimators": 200})
+  )
+  ```
+
+  (Note: shared *structure* across targets is not the same as label *conditioning*
+  — none of these read one target's value to predict another. For real-time-label
+  conditioning use the `MixedTypeMultiTargetScorer` conditional estimators.)
+
+### Class weighting and fit-time parameters
+
+All sklearn-API estimators (XGBoost / LightGBM / sklearn wrappers, single- and
+multi-target) accept a generic fit-time passthrough — no estimator-specific
+plumbing:
+
+- `sample_weight`: a row-weight strategy — `'balanced'`
+  (`compute_sample_weight('balanced', y)` computed at fit time, the production
+  firmographics recipe), a callable `fn(y) -> weights`, or an explicit array.
+  Defaults to uniform.
+- `fit_params`: a dict of static kwargs forwarded verbatim to the underlying
+  `fit` (`feature_weights`, `base_margin`, a custom objective, `callbacks`, …).
+
+```python
+JointXGBMultiOutputClassifierEstimator({"n_estimators": 300}, sample_weight="balanced")
+```
+
+### Tree-count pinning vs early stopping
+
+To pin the number of trees (e.g. reproduce a production `best_iteration`), set
+`n_estimators` in `params` and **omit** `early_stopping_rounds`. An XGBoost
+`eval_set` is used only when validation data (`X_valid`) is passed to `fit`; with
+no validation set, training runs the full pinned `n_estimators`.
+
 **Dataset Requirements**:
 - ⚠️ **Interactions**: **One row per user only**
 - ❌ **Users**: Not allowed (pass user features as plain columns inside interactions)
@@ -222,11 +315,11 @@ Under `CONSTANT`, `recommender.scorer.degenerate_targets` exposes the manifest o
 
 ### Migration paths for multi-class targets
 
-Targets with 3+ classes are rejected at fit time. Choose one:
+`MultioutputScorer` rejects multi-class targets (3+ classes per `ITEM_<name>`) at fit time. Pick the path that fits your shape:
 
-1. **Single multi-class target** → use [`MulticlassScorer`](#3-multiclassscorer) in long format.
-2. **Multiple multi-class targets** → one-hot encode each into binary columns (e.g. `ITEM_X` with classes `{A, B, C}` becomes `ITEM_X_A`, `ITEM_X_B`, `ITEM_X_C`, each binary).
-3. **Heterogeneous target types (mix of binary, regression, multi-class)** → use [`MixedTypeMultiTargetScorer`](#5-mixedtypemultitargetscorer) below.
+1. **Wide format, any mix of multi-class + binary + regression + multilabel** → use [`MixedTypeMultiTargetScorer`](#5-mixedtypemultitargetscorer) below. Multi-class targets are first-class via `TargetType.MULTICLASS`; class labels are preserved end-to-end (no manual one-hot encoding, no label-encoder round-trips). This is the recommended path for new wide-format multi-target work.
+2. **Single multi-class target in long format** → use [`MulticlassScorer`](#3-multiclassscorer). Best when you have `(USER_ID, ITEM_ID)` rows and `ITEM_ID` itself is the class label.
+3. **Legacy compatibility (stay on `MultioutputScorer`)** → one-hot encode each multi-class column into binary columns (e.g. `ITEM_X` with classes `{A, B, C}` becomes `ITEM_X_A`, `ITEM_X_B`, `ITEM_X_C`, each binary). Only choose this if you have an existing `MultioutputScorer` pipeline you don't want to rewrite — option #1 handles the same data without the encoding step.
 
 **Pros**:
 - Multi-label binary classification with cross-target ranking semantics

{scikit_rec-0.4 → scikit_rec-0.4.2}/docs/user-guide/training.md

@@ -236,6 +236,10 @@ estimator = XGBClassifierEstimator({"random_state": 42, ...})
 - Use fewer estimator iterations
 - Enable GPU training if available
 
+### Issue: Data does not fit in memory
+
+**Solution**: Use batch training with a partitioned dataset and a batch-capable estimator such as `BatchXGBClassifierEstimator`, with `UniversalScorer` or `IndependentScorer`. See [Batch (partitioned) training](capability-matrix.md#batch-partitioned-training) and [Partitioned Datasets](../getting-started/datasets.md#partitioned-datasets).
+
 ### Issue: Poor validation performance
 
 **Solution**: