masamlp 0.1.0__tar.gz

masamlp-0.1.0/.gitignore

@@ -0,0 +1,12 @@
+.claude/
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.venv/
+.pytest_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+site/

masamlp-0.1.0/CHANGELOG.md

@@ -0,0 +1,46 @@
+# Changelog
+
+## 0.1.0 (2026-07-02)
+
+Initial release.
+
+- `MasaRegressor` / `MasaClassifier` sklearn-compatible estimators with
+  `fit(X, y, sample_weight=..., eval_set=...)`, early stopping on any metric,
+  and directory-format save/load.
+- Models: `resnet` and `ft_transformer` (Gorishniy et al. 2021), `realmlp`
+  (Holzmüller et al. 2024, TD-S architecture with the full training recipe
+  in `masamlp.realmlp_params`), `tab_transformer` (Huang et al. 2020),
+  `danet` (Chen et al. AAAI 2022), `tabr` (retrieval-augmented, Gorishniy
+  et al. 2023), `modernnca` (Ye et al. 2024, soft-nearest-neighbor),
+  `gandalf` (Joseph & Raj 2022, GFLU with t-softmax feature masks),
+  `grn` (stacked TFT Gated Residual Networks), and `lnn` (experimental
+  CfC-based liquid network for static tabular data), plus a
+  `register_model` hook for custom architectures (token-based models via
+  `embedding_kind = "tokens"`).
+- `n_ens` seed ensembling on both estimators (pytabkit semantics: members
+  seeded `random_state + i`, predictions averaged on the transformed scale);
+  save/load stores all members. `ens_mode="vectorized"` trains all members
+  in one vmapped forward/backward (torch.func) for BatchNorm-free models,
+  with per-member best-epoch tracking.
+- Full RealMLP-TD recipe via `masamlp.realmlp_td_params(task)`: parametric
+  activations (`act_lr_factor`), flat_cos-scheduled dropout and weight decay
+  (`weight_decay_schedule`, zero decay on biases), PBLD embedding lr factor,
+  and `cat_encoding="hybrid"` (one-hot up to 9 categories, embeddings of
+  size 8 above).
+- RealMLP insights as composable estimator options: `numeric_scaler="rssc"`,
+  `cat_encoding="onehot"`, numeric embedding zoo
+  (`num_embedding="pbld"/"plr"/"pl"/"periodic"`), learnable input scaling
+  (`num_scaling`), `lr_scheduler="coslog4"` with per-group learning-rate
+  factors, `optimizer_betas`, and regression `clip_predictions`.
+- Objective plugin system: per-sample torch losses with a uniform
+  sample-weight contract; built-ins for regression (squared error, MAE,
+  Huber, quantile, Poisson) and classification (binary logistic, multiclass
+  softmax, both with label smoothing).
+- Metric plugin system ported from repleafgbm (`get_metric` / `make_metric`).
+- Built-in preprocessing: quantile/standard/robust numeric scaling, median
+  imputation, categorical index encoding with embeddings.
+- Device support: CPU, CUDA (bf16 AMP, optional `torch.compile`), and MPS,
+  behind `device="auto"`. Verified on Colab T4 (docs/verdicts/).
+- DANet made GPU-practical (KI-009): the grouped 1x1 conv is computed as a
+  batched einsum over the same parameters and GhostBatchNorm's training
+  path is fused — 50x on T4, 14x on CPU, bit-for-bit state_dict compatible.

masamlp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Masaya Kawamata
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

masamlp-0.1.0/PKG-INFO

@@ -0,0 +1,201 @@
+Metadata-Version: 2.4
+Name: masamlp
+Version: 0.1.0
+Summary: Extensible tabular deep learning: TabularResNet, DANet, and TabularLNN with first-class sample_weight, custom objectives, and custom metrics.
+Project-URL: Homepage, https://github.com/Matapanino/masamlp
+Project-URL: Repository, https://github.com/Matapanino/masamlp
+Author-email: Masaya Kawamata <mkawamata038@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: danet,deep-learning,machine-learning,pytorch,resnet,tabular
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.23
+Requires-Dist: pandas>=1.5
+Requires-Dist: scikit-learn>=1.2
+Requires-Dist: torch>=2.1
+Provides-Extra: bench
+Requires-Dist: lightgbm>=4.0; extra == 'bench'
+Requires-Dist: optuna>=3; extra == 'bench'
+Requires-Dist: pytabkit>=1.5; extra == 'bench'
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=4; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: pdoc>=14; extra == 'docs'
+Description-Content-Type: text/markdown
+
+# masaMLP
+
+![CI](https://github.com/Matapanino/masamlp/actions/workflows/ci.yml/badge.svg)
+![PyPI](https://img.shields.io/pypi/v/masamlp.svg)
+![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)
+
+**Extensible tabular deep learning** — TabularResNet, DANet, and TabularLNN
+behind sklearn-compatible estimators with first-class **sample_weight**,
+**custom objectives**, **custom metrics**, and **early stopping on any
+metric**. The sibling library of
+[repleafgbm](https://github.com/Matapanino/repleafgbm) (same author, same API
+philosophy), for the neural side of tabular ML.
+
+> **Status: alpha (0.1.x).** Built with heavy use of
+> [Claude Code](https://claude.com/claude-code) (coding and architecture
+> design).
+
+## Why masaMLP
+
+Excellent tabular DL libraries exist — [pytabkit](https://github.com/dholzmueller/pytabkit)
+ships state-of-the-art models like RealMLP and TabM, and
+[rtdl](https://github.com/yandex-research/rtdl) provides reference modules.
+What they don't make easy is *extension*: `sample_weight` in `fit`, custom
+training losses, custom evaluation metrics, and early stopping driven by
+them. masaMLP is built around exactly those hooks:
+
+- **`fit(X, y, sample_weight=..., eval_set=...)`** — LightGBM-style, sklearn
+  compatible. Weights flow through a single reduction
+  `(loss * w).sum() / w.sum()` that every objective shares.
+- **Custom objectives** are per-sample torch losses — a plain function (or
+  `nn.Module` with trainable parameters). Because the trainer owns the
+  weighted reduction, your loss gets correct `sample_weight` and
+  `class_weight` handling for free.
+- **Custom metrics** are plain NumPy callables via `make_metric`, and any of
+  them (minimize or maximize) can drive early stopping with best-epoch weight
+  restoration.
+- **Multiclass, multioutput regression, class_weight, label smoothing**
+  supported natively; built-in preprocessing (quantile scaling, missing
+  values, categorical embeddings) so DataFrames go straight into `fit`.
+- **CPU / CUDA / MPS** behind `device="auto"`: device-resident tensors with
+  no DataLoader overhead, automatic full-batch mode for small data, bf16 AMP
+  on CUDA, opt-in `torch.compile` with eager fallback.
+
+masaMLP deliberately does *not* try to re-benchmark the field — see
+[docs/attribution.md](docs/attribution.md) for the research and libraries it
+builds on.
+
+## Models
+
+| name | source | notes |
+|---|---|---|
+| `resnet` | Gorishniy et al. 2021 (arXiv:2106.11959) | default; strong baseline |
+| `realmlp` | Holzmüller et al. 2024 (arXiv:2407.04491) | RealMLP-TD-S architecture (scaling layer, NTP linear layers, SELU/Mish); pair with `masamlp.realmlp_params(task)` for the full training recipe |
+| `ft_transformer` | Gorishniy et al. 2021 (arXiv:2106.11959) | feature tokens + [CLS] + PreNorm/ReGLU transformer, per the rtdl reference |
+| `tab_transformer` | Huang et al. 2020 (arXiv:2012.06678) | transformer over categorical tokens; numerics bypass (or embed via `num_embedding`) |
+| `danet` | Chen et al. AAAI 2022 (arXiv:2112.02962) | Abstract Layers with learnable sparse feature groups (in-house entmax15) |
+| `tabr` | Gorishniy et al. 2023 (arXiv:2307.14338) | retrieval-augmented: nearest training rows are aggregated into each prediction |
+| `modernnca` | Ye et al. 2024 (arXiv:2407.03257) | soft-nearest-neighbor aggregation with stochastic candidate sampling; pairs well with `num_embedding="plr-lite"` |
+| `gandalf` | Joseph & Raj 2022 (arXiv:2207.08548) | GFLU stages: learnable sparse feature masks (t-softmax) with GRU-style gating; exposes `feature_importances()` |
+| `grn` | GRN blocks from TFT, Lim et al. 2021 (arXiv:1912.09363) | stack of Gated Residual Networks over embedded features (masaMLP's own composition) |
+| `lnn` | CfC cells, Hasani et al. 2022 | **experimental** liquid-network adaptation for static tabular data — see [docs/lnn.md](docs/lnn.md) |
+
+Third-party architectures plug in with `register_model` and get the whole
+estimator surface (weights, objectives, metrics, early stopping) for free.
+
+### RealMLP insights are composable options
+
+The tricks from the RealMLP paper are estimator-level options usable with
+*any* model (`lnn` included), not baked into one architecture:
+
+- `numeric_scaler="rssc"` — robust scale + smooth clip preprocessing
+- `cat_encoding="onehot"` — RealMLP-style one-hot (binary → ±1, missing → 0)
+- `num_embedding="pbld" | "plr" | "plr-lite" | "pl" | "periodic"` — the
+  numeric embedding zoo (arXiv:2203.05556 + PBLD); token models
+  (`ft_transformer`, `tab_transformer`) use the same options as feature
+  tokenizers
+- `model_params={"num_scaling": True}` — learnable per-feature input scale
+- `lr_scheduler="coslog4"`, `optimizer_betas=(0.9, 0.95)` — the training
+  schedule
+- `clip_predictions=True` (regressor) — clip to the observed target range
+- `n_ens=k` — seed ensembling as in pytabkit's RealMLP: k members trained
+  with seeds `random_state + i`, predictions averaged on the probability /
+  value scale; works with every model including the retrieval ones.
+  `ens_mode="vectorized"` trains all members in one vmapped forward/backward
+  (`torch.func`) for BatchNorm-free models — pytabkit's speed trick
+- `weight_decay_schedule="flat_cos"` — RealMLP-TD's scheduled weight decay
+  (param groups can opt out, e.g. biases)
+- `masamlp.realmlp_td_params(task)` — the **full RealMLP-TD recipe**:
+  parametric activations, flat_cos-scheduled dropout and weight decay, PBLD
+  embeddings with their own lr factor, and hybrid categorical encoding
+  (one-hot ≤ 9 categories, embeddings above)
+
+```python
+from masamlp import MasaClassifier, realmlp_params
+
+clf = MasaClassifier(**realmlp_params("classification"))    # the TD-S recipe
+clf = MasaClassifier(**{**realmlp_params("classification"),
+                        "num_embedding": "pbld"})           # toward RealMLP-TD
+```
+
+## Install
+
+```bash
+pip install masamlp        # torch, numpy, pandas, scikit-learn
+```
+
+## Quickstart
+
+```python
+import numpy as np
+from masamlp import MasaClassifier, make_metric
+
+def f1(y_true, y_proba):
+    pred = y_proba >= 0.5
+    tp = np.sum(pred & (y_true == 1))
+    return 2 * tp / max(pred.sum() + (y_true == 1).sum(), 1)
+
+clf = MasaClassifier(
+    model="resnet",
+    eval_metric=make_metric(f1, name="f1", minimize=False),
+    early_stopping_rounds=15,
+    class_weight="balanced",
+)
+clf.fit(X_train, y_train, sample_weight=w_train, eval_set=[(X_val, y_val)])
+proba = clf.predict_proba(X_test)
+print(clf.best_iteration_, clf.best_score_, clf.evals_result_["valid_0"]["f1"][:3])
+```
+
+Custom objective (regression, asymmetric loss):
+
+```python
+import torch
+from masamlp import MasaRegressor
+
+def asymmetric_mse(y_true, raw_pred):          # -> per-sample (n,) tensor
+    err = raw_pred - y_true                    # raw_pred: (n, out_dim)
+    return torch.where(err < 0, 4.0 * err**2, err**2).mean(dim=1)
+
+reg = MasaRegressor(model="danet", objective=asymmetric_mse)
+reg.fit(X, y, sample_weight=w)                 # weights just work
+```
+
+Save/load is a plain directory (`manifest.json` + tensors, loaded with
+`weights_only=True` — no pickle execution):
+
+```python
+reg.save_model("model_dir")
+reg2 = MasaRegressor.load_model("model_dir")
+```
+
+## Devices
+
+`device="auto"` resolves cuda > mps > cpu. CUDA gets bf16 AMP by default and
+optional `compile=True`; MPS and CPU train in float32. Details and caveats:
+[docs/devices.md](docs/devices.md).
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+bash scripts/check.sh      # ruff + pytest + examples/quickstart.py
+```
+
+Development rules live in [CLAUDE.md](CLAUDE.md); roadmap in
+[docs/roadmap.md](docs/roadmap.md).
+
+## License
+
+MIT. Architecture attributions: [docs/attribution.md](docs/attribution.md).

masamlp-0.1.0/README.md

@@ -0,0 +1,169 @@
+# masaMLP
+
+![CI](https://github.com/Matapanino/masamlp/actions/workflows/ci.yml/badge.svg)
+![PyPI](https://img.shields.io/pypi/v/masamlp.svg)
+![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)
+
+**Extensible tabular deep learning** — TabularResNet, DANet, and TabularLNN
+behind sklearn-compatible estimators with first-class **sample_weight**,
+**custom objectives**, **custom metrics**, and **early stopping on any
+metric**. The sibling library of
+[repleafgbm](https://github.com/Matapanino/repleafgbm) (same author, same API
+philosophy), for the neural side of tabular ML.
+
+> **Status: alpha (0.1.x).** Built with heavy use of
+> [Claude Code](https://claude.com/claude-code) (coding and architecture
+> design).
+
+## Why masaMLP
+
+Excellent tabular DL libraries exist — [pytabkit](https://github.com/dholzmueller/pytabkit)
+ships state-of-the-art models like RealMLP and TabM, and
+[rtdl](https://github.com/yandex-research/rtdl) provides reference modules.
+What they don't make easy is *extension*: `sample_weight` in `fit`, custom
+training losses, custom evaluation metrics, and early stopping driven by
+them. masaMLP is built around exactly those hooks:
+
+- **`fit(X, y, sample_weight=..., eval_set=...)`** — LightGBM-style, sklearn
+  compatible. Weights flow through a single reduction
+  `(loss * w).sum() / w.sum()` that every objective shares.
+- **Custom objectives** are per-sample torch losses — a plain function (or
+  `nn.Module` with trainable parameters). Because the trainer owns the
+  weighted reduction, your loss gets correct `sample_weight` and
+  `class_weight` handling for free.
+- **Custom metrics** are plain NumPy callables via `make_metric`, and any of
+  them (minimize or maximize) can drive early stopping with best-epoch weight
+  restoration.
+- **Multiclass, multioutput regression, class_weight, label smoothing**
+  supported natively; built-in preprocessing (quantile scaling, missing
+  values, categorical embeddings) so DataFrames go straight into `fit`.
+- **CPU / CUDA / MPS** behind `device="auto"`: device-resident tensors with
+  no DataLoader overhead, automatic full-batch mode for small data, bf16 AMP
+  on CUDA, opt-in `torch.compile` with eager fallback.
+
+masaMLP deliberately does *not* try to re-benchmark the field — see
+[docs/attribution.md](docs/attribution.md) for the research and libraries it
+builds on.
+
+## Models
+
+| name | source | notes |
+|---|---|---|
+| `resnet` | Gorishniy et al. 2021 (arXiv:2106.11959) | default; strong baseline |
+| `realmlp` | Holzmüller et al. 2024 (arXiv:2407.04491) | RealMLP-TD-S architecture (scaling layer, NTP linear layers, SELU/Mish); pair with `masamlp.realmlp_params(task)` for the full training recipe |
+| `ft_transformer` | Gorishniy et al. 2021 (arXiv:2106.11959) | feature tokens + [CLS] + PreNorm/ReGLU transformer, per the rtdl reference |
+| `tab_transformer` | Huang et al. 2020 (arXiv:2012.06678) | transformer over categorical tokens; numerics bypass (or embed via `num_embedding`) |
+| `danet` | Chen et al. AAAI 2022 (arXiv:2112.02962) | Abstract Layers with learnable sparse feature groups (in-house entmax15) |
+| `tabr` | Gorishniy et al. 2023 (arXiv:2307.14338) | retrieval-augmented: nearest training rows are aggregated into each prediction |
+| `modernnca` | Ye et al. 2024 (arXiv:2407.03257) | soft-nearest-neighbor aggregation with stochastic candidate sampling; pairs well with `num_embedding="plr-lite"` |
+| `gandalf` | Joseph & Raj 2022 (arXiv:2207.08548) | GFLU stages: learnable sparse feature masks (t-softmax) with GRU-style gating; exposes `feature_importances()` |
+| `grn` | GRN blocks from TFT, Lim et al. 2021 (arXiv:1912.09363) | stack of Gated Residual Networks over embedded features (masaMLP's own composition) |
+| `lnn` | CfC cells, Hasani et al. 2022 | **experimental** liquid-network adaptation for static tabular data — see [docs/lnn.md](docs/lnn.md) |
+
+Third-party architectures plug in with `register_model` and get the whole
+estimator surface (weights, objectives, metrics, early stopping) for free.
+
+### RealMLP insights are composable options
+
+The tricks from the RealMLP paper are estimator-level options usable with
+*any* model (`lnn` included), not baked into one architecture:
+
+- `numeric_scaler="rssc"` — robust scale + smooth clip preprocessing
+- `cat_encoding="onehot"` — RealMLP-style one-hot (binary → ±1, missing → 0)
+- `num_embedding="pbld" | "plr" | "plr-lite" | "pl" | "periodic"` — the
+  numeric embedding zoo (arXiv:2203.05556 + PBLD); token models
+  (`ft_transformer`, `tab_transformer`) use the same options as feature
+  tokenizers
+- `model_params={"num_scaling": True}` — learnable per-feature input scale
+- `lr_scheduler="coslog4"`, `optimizer_betas=(0.9, 0.95)` — the training
+  schedule
+- `clip_predictions=True` (regressor) — clip to the observed target range
+- `n_ens=k` — seed ensembling as in pytabkit's RealMLP: k members trained
+  with seeds `random_state + i`, predictions averaged on the probability /
+  value scale; works with every model including the retrieval ones.
+  `ens_mode="vectorized"` trains all members in one vmapped forward/backward
+  (`torch.func`) for BatchNorm-free models — pytabkit's speed trick
+- `weight_decay_schedule="flat_cos"` — RealMLP-TD's scheduled weight decay
+  (param groups can opt out, e.g. biases)
+- `masamlp.realmlp_td_params(task)` — the **full RealMLP-TD recipe**:
+  parametric activations, flat_cos-scheduled dropout and weight decay, PBLD
+  embeddings with their own lr factor, and hybrid categorical encoding
+  (one-hot ≤ 9 categories, embeddings above)
+
+```python
+from masamlp import MasaClassifier, realmlp_params
+
+clf = MasaClassifier(**realmlp_params("classification"))    # the TD-S recipe
+clf = MasaClassifier(**{**realmlp_params("classification"),
+                        "num_embedding": "pbld"})           # toward RealMLP-TD
+```
+
+## Install
+
+```bash
+pip install masamlp        # torch, numpy, pandas, scikit-learn
+```
+
+## Quickstart
+
+```python
+import numpy as np
+from masamlp import MasaClassifier, make_metric
+
+def f1(y_true, y_proba):
+    pred = y_proba >= 0.5
+    tp = np.sum(pred & (y_true == 1))
+    return 2 * tp / max(pred.sum() + (y_true == 1).sum(), 1)
+
+clf = MasaClassifier(
+    model="resnet",
+    eval_metric=make_metric(f1, name="f1", minimize=False),
+    early_stopping_rounds=15,
+    class_weight="balanced",
+)
+clf.fit(X_train, y_train, sample_weight=w_train, eval_set=[(X_val, y_val)])
+proba = clf.predict_proba(X_test)
+print(clf.best_iteration_, clf.best_score_, clf.evals_result_["valid_0"]["f1"][:3])
+```
+
+Custom objective (regression, asymmetric loss):
+
+```python
+import torch
+from masamlp import MasaRegressor
+
+def asymmetric_mse(y_true, raw_pred):          # -> per-sample (n,) tensor
+    err = raw_pred - y_true                    # raw_pred: (n, out_dim)
+    return torch.where(err < 0, 4.0 * err**2, err**2).mean(dim=1)
+
+reg = MasaRegressor(model="danet", objective=asymmetric_mse)
+reg.fit(X, y, sample_weight=w)                 # weights just work
+```
+
+Save/load is a plain directory (`manifest.json` + tensors, loaded with
+`weights_only=True` — no pickle execution):
+
+```python
+reg.save_model("model_dir")
+reg2 = MasaRegressor.load_model("model_dir")
+```
+
+## Devices
+
+`device="auto"` resolves cuda > mps > cpu. CUDA gets bf16 AMP by default and
+optional `compile=True`; MPS and CPU train in float32. Details and caveats:
+[docs/devices.md](docs/devices.md).
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+bash scripts/check.sh      # ruff + pytest + examples/quickstart.py
+```
+
+Development rules live in [CLAUDE.md](CLAUDE.md); roadmap in
+[docs/roadmap.md](docs/roadmap.md).
+
+## License
+
+MIT. Architecture attributions: [docs/attribution.md](docs/attribution.md).

masamlp-0.1.0/benchmarks/README.md

@@ -0,0 +1,23 @@
+# Benchmarks
+
+Not shipped with the package; the library (`src/`) never imports anything
+here.
+
+- `parity_realmlp.py` — the honesty check: masamlp's RealMLP-TD-S recipe vs
+  the author's standalone reference implementation (vendored under
+  `vendor/`, MIT) on california housing and adult, with sklearn's
+  HistGradientBoosting as an anchor. Expected outcome: comparable metrics
+  (same recipe, different shuffling details), not bitwise equality.
+- `model_zoo.py` — every registered model on the same two datasets with its
+  recommended knobs. Single seed, capped epochs, subsampled rows, no HPO:
+  a smoke-level leaderboard, not a paper-grade ranking.
+
+Run from the repo root:
+
+```bash
+PYTHONPATH=src python3 benchmarks/parity_realmlp.py
+PYTHONPATH=src python3 benchmarks/model_zoo.py
+```
+
+If OpenML downloads fail with SSL errors (framework Python on macOS):
+`export SSL_CERT_FILE=$(python -m certifi)`.

masamlp-0.1.0/pyproject.toml

@@ -0,0 +1,59 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "masamlp"
+version = "0.1.0"
+description = "Extensible tabular deep learning: TabularResNet, DANet, and TabularLNN with first-class sample_weight, custom objectives, and custom metrics."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Masaya Kawamata", email = "mkawamata038@gmail.com" }]
+keywords = ["tabular", "deep-learning", "pytorch", "machine-learning", "resnet", "danet"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "torch>=2.1",
+    "numpy>=1.23",
+    "pandas>=1.5",
+    "scikit-learn>=1.2",
+]
+
+[project.optional-dependencies]
+# Benchmark tooling only; the library (src/) never imports these.
+bench = ["lightgbm>=4.0", "pytabkit>=1.5", "optuna>=3"]
+# API reference generation (scripts/build_docs.sh).
+docs = ["pdoc>=14"]
+dev = ["pytest>=7.0", "pytest-cov>=4", "ruff>=0.4"]
+
+[project.urls]
+Homepage = "https://github.com/Matapanino/masamlp"
+Repository = "https://github.com/Matapanino/masamlp"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/masamlp"]
+# Ship the PEP 561 marker so type checkers honour the inline annotations.
+force-include = { "src/masamlp/py.typed" = "masamlp/py.typed" }
+
+[tool.hatch.build.targets.sdist]
+include = ["src/masamlp", "tests", "pyproject.toml", "README.md", "LICENSE", "CHANGELOG.md"]
+
+[tool.ruff]
+line-length = 100
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "UP", "B"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-q"
+filterwarnings = [
+    "ignore:.*torch.compile.*:UserWarning",
+]

masamlp-0.1.0/src/masamlp/__init__.py

@@ -0,0 +1,44 @@
+"""masaMLP: extensible tabular deep learning.
+
+TabularResNet, DANet, and TabularLNN behind sklearn-compatible estimators
+with first-class sample_weight, custom objectives, custom metrics, and early
+stopping on any metric — the sibling library of repleafgbm.
+"""
+
+from masamlp.classifier import MasaClassifier
+from masamlp.core.metrics import BaseMetric, get_metric, make_metric
+from masamlp.core.objectives import (
+    BaseObjective,
+    BinaryLogistic,
+    Huber,
+    MulticlassSoftmax,
+    PoissonRegression,
+    Quantile,
+    get_objective,
+    make_objective,
+)
+from masamlp.models import register_model
+from masamlp.presets import realmlp_params, realmlp_td_params
+from masamlp.regressor import MasaRegressor
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "MasaRegressor",
+    "MasaClassifier",
+    "BaseMetric",
+    "get_metric",
+    "make_metric",
+    "BaseObjective",
+    "get_objective",
+    "make_objective",
+    "Huber",
+    "Quantile",
+    "PoissonRegression",
+    "BinaryLogistic",
+    "MulticlassSoftmax",
+    "register_model",
+    "realmlp_params",
+    "realmlp_td_params",
+    "__version__",
+]