fbtseg 0.2.0__tar.gz

fbtseg-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Roberto Angelo Fernandes Santos
+
+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.

fbtseg-0.2.0/PKG-INFO

@@ -0,0 +1,216 @@
+Metadata-Version: 2.4
+Name: fbtseg
+Version: 0.2.0
+Summary: Find Best Tree Segmentation — estimador de segmentação binária fiel ao Capítulo 4 da tese (Santos, UFPE 2010)
+Author-email: Roberto Angelo Fernandes Santos <rafss@hotmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/RobertoASantos/FBT-Segmentation
+Project-URL: Source, https://github.com/RobertoASantos/FBT-Segmentation
+Keywords: machine-learning,segmentation,model-tree,binary-classification,risk-modeling,credit-scoring,fbtseg,riskseg
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scipy
+Requires-Dist: scikit-learn
+Requires-Dist: requests
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# fbtseg
+
+[![PyPI version](https://img.shields.io/pypi/v/fbtseg.svg)](https://pypi.org/project/fbtseg/)
+[![Python](https://img.shields.io/pypi/pyversions/fbtseg.svg)](https://pypi.org/project/fbtseg/)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Implementação em Python do método **FBTSeg** (*Find Best Tree
+Segmentation*, originalmente nomeado RISKSEG) proposto na tese de
+Roberto Angelo Fernandes Santos (UFPE, 2010) e nos artigos
+[ICAI 2012](docs/reference/ICAI2012-rafs-proceed.pdf) e
+[ICTAI 2012](docs/reference/ICTAI2012-Submitted-140-FBTSeg.pdf).
+Estimador sklearn-compatível, focado em alvo binário e reprodução fiel
+dos resultados publicados.
+
+## Instalação
+
+```bash
+pip install fbtseg
+```
+
+ou em modo desenvolvimento:
+
+```bash
+pip install -e .[test]
+```
+
+## Uso rápido
+
+```python
+from fbtseg import FBTSeg, article_uci_preset
+
+model = article_uci_preset(categorical_features=("workclass", "education"))
+model.fit(X_train, y_train)
+proba = model.predict_proba(X_test)[:, 1]
+print(model.plot_model_tree())
+summary = model.get_summary()
+```
+
+Custom:
+
+```python
+from fbtseg import FBTSeg
+
+model = FBTSeg(
+    max_depth=3,
+    min_samples_leaf=0.05,
+    metric="error",
+    top_k_variables=1,                  # rQtdeVarTeste
+    n_numeric_bins=4,                   # rQtdeDivisoes
+    grouping_features=("education",),    # rUsaBlocos
+    max_group_size=2,                    # rQtdeBlocos
+    combiner_method="stacking",          # ou 'marginal_odds'
+    prediction_mode="leaf",              # 'leaf' | 'pair_combiner' | 'cascade' | 'global_stacking'
+    drop_split_feature_in_children=True,
+)
+model.fit(X_train, y_train)
+```
+
+## Como funciona
+
+Em cada nó terminal o método:
+
+1. Faz **screening fatorial** — uma regressão por variável candidata,
+   incluindo dummies da variável, efeitos principais e interações.
+2. Para a(s) melhor(es) variável(eis), testa **segmentações binárias**
+   (categoria-vs-complemento ou grupo de categorias).
+3. Treina **especialistas** para cada segmento e os combina por
+   `Stacking` ou `Marginal Odds`.
+4. **Aceita a divisão** se ela melhora a métrica D em validação interna
+   (com tolerância configurável de ganho mínimo / perda máxima).
+5. Recorre nos filhos até atingir profundidade máxima ou esgotar
+   candidatos.
+
+A predição é vetorizada por folha (1 chamada a `predict_proba` por
+folha, não 1 por linha) — 50× a 3000× mais rápida que implementações
+ingênuas.
+
+## CLI
+
+```bash
+# Treinar e salvar
+fbtseg fit --dataset chess --preset article_uci --output-dir runs/chess
+
+# CSV próprio
+fbtseg fit --csv data.csv --target y --preset thesis \
+    --categorical cat_col_1 cat_col_2
+
+# Predição com modelo salvo
+fbtseg predict --model runs/chess/model.pkl --csv new_data.csv --output preds.csv
+```
+
+## Reprodução do paper ICAI 2012
+
+```bash
+# Tabela 1 do paper — Linear/Logistic/MLP × bases UCI
+python scripts/run_paper_table_replication.py --datasets chess magic spambase german \
+    --n-splits 3 --output-dir artifacts/paper_table
+
+# Datasets sintéticos do ICTAI 2012
+python scripts/validate_ictai_synthetic.py --datasets 1 2 3 4 \
+    --sizes 1000 3000 5000 --n-replications 10
+```
+
+### Destaques de fidelidade
+
+| Dataset | Base | Paper Simple | Paper FBTSeg | fbtseg Simple | fbtseg |
+|---|---|---:|---:|---:|---:|
+| Chess | Logistic | 2.60% | 1.02% | 2.41% | **1.41%** |
+| Magic | Logistic | 20.98% | 18.69% | 20.96% | **16.07%** |
+| Magic | Linear | 32.03% | 16.06% | 21.61% | **16.93%** |
+| Spambase | Linear | 14.89% | 13.51% | 11.15% | **10.45%** |
+
+Detalhes em [docs/paper_table_replicated.md](docs/paper_table_replicated.md).
+
+## Estrutura do repositório
+
+```
+fbtseg/             # pacote (estimator, views, tree, combiners, metrics, base_learners, datasets, CLI)
+tests/              # testes (33 cobrindo fit, predict, presets, base learners, métricas)
+scripts/            # scripts de reprodução dos experimentos
+docs/               # documentação + reference (tese + 2 PDFs)
+artifacts/          # resultados de execuções
+trash/v1/           # implementação anterior (V1), preservada para auditoria histórica
+```
+
+## Documentação
+
+- [docs/fbtseg.md](docs/fbtseg.md): API completa + mapeamento parâmetros tese ↔ código.
+- [docs/paper_table_replicated.md](docs/paper_table_replicated.md): replicação da Tabela 1 do ICAI 2012.
+- [docs/benchmark_final.md](docs/benchmark_final.md): benchmark fbtseg vs LR.
+- [docs/examples/quickstart.py](docs/examples/quickstart.py): notebook linear executável.
+- [CHANGELOG.md](CHANGELOG.md): histórico de versões.
+
+## Licença
+
+[MIT](LICENSE). Use, copie, modifique e distribua livremente.
+
+## Citação
+
+Se você usa este pacote em pesquisa, cite a tese e/ou os artigos:
+
+```bibtex
+@phdthesis{santos2010metodo,
+  author = {Santos, Roberto Angelo Fernandes},
+  title  = {Um Método para Segmentação de Preditores},
+  school = {Universidade Federal de Pernambuco},
+  year   = {2010},
+  url    = {http://www.cin.ufpe.br/~roberto/AlunosPG/Teses/2010-PhD-Roberto.zip},
+}
+
+@inproceedings{santos2012comparing,
+  author    = {Santos, Roberto Angelo Fernandes and Barros, Roberto Souto Maior de},
+  title     = {Comparing Segmentation Methods with Different Base Classifiers},
+  booktitle = {Proceedings of the 2012 International Conference on Artificial Intelligence (ICAI 2012)},
+  year      = {2012},
+}
+
+@inproceedings{santos2012fbtseg,
+  author    = {Santos, Roberto Angelo Fernandes and Barros, Roberto Souto Maior de},
+  title     = {Comparing FBTSeg and NNTree Implementations with Established Ensemble Methods},
+  booktitle = {Proceedings of the 24th IEEE International Conference on Tools with Artificial Intelligence (ICTAI 2012)},
+  year      = {2012},
+}
+```
+
+## Referências
+
+- **SANTOS, R. A. F.** *Um Método para Segmentação de Preditores.* Tese
+  (Doutorado em Ciência da Computação) — Centro de Informática, UFPE,
+  Recife, 2010. Orientador: Prof. Dr. Roberto Souto Maior de Barros.
+  ([docx](docs/reference/Tese_Roberto_Final_Biblioteca.docx))
+- **SANTOS, R. A. F.; BARROS, R. S. M.** Comparing Segmentation Methods
+  with Different Base Classifiers. *In:* Proceedings of the
+  International Conference on Artificial Intelligence (ICAI), Las
+  Vegas, USA, 2012.
+  ([PDF](docs/reference/ICAI2012-rafs-proceed.pdf))
+- **SANTOS, R. A. F.; BARROS, R. S. M.** Comparing FBTSeg and NNTree
+  Implementations with Established Ensemble Methods. *In:* Proceedings
+  of the IEEE International Conference on Tools with Artificial
+  Intelligence (ICTAI), Athens, Greece, 2012.
+  ([PDF](docs/reference/ICTAI2012-Submitted-140-FBTSeg.pdf))
+
+Para citações completas (BibTeX) e referências secundárias citadas
+pelos artigos (Wolpert 1992 — Stacking, Thomas et al. 2002 — Marginal
+Odds, Maji 2008 — NNTree, etc.), veja
+[docs/references.md](docs/references.md).

fbtseg-0.2.0/README.md

@@ -0,0 +1,186 @@
+# fbtseg
+
+[![PyPI version](https://img.shields.io/pypi/v/fbtseg.svg)](https://pypi.org/project/fbtseg/)
+[![Python](https://img.shields.io/pypi/pyversions/fbtseg.svg)](https://pypi.org/project/fbtseg/)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Implementação em Python do método **FBTSeg** (*Find Best Tree
+Segmentation*, originalmente nomeado RISKSEG) proposto na tese de
+Roberto Angelo Fernandes Santos (UFPE, 2010) e nos artigos
+[ICAI 2012](docs/reference/ICAI2012-rafs-proceed.pdf) e
+[ICTAI 2012](docs/reference/ICTAI2012-Submitted-140-FBTSeg.pdf).
+Estimador sklearn-compatível, focado em alvo binário e reprodução fiel
+dos resultados publicados.
+
+## Instalação
+
+```bash
+pip install fbtseg
+```
+
+ou em modo desenvolvimento:
+
+```bash
+pip install -e .[test]
+```
+
+## Uso rápido
+
+```python
+from fbtseg import FBTSeg, article_uci_preset
+
+model = article_uci_preset(categorical_features=("workclass", "education"))
+model.fit(X_train, y_train)
+proba = model.predict_proba(X_test)[:, 1]
+print(model.plot_model_tree())
+summary = model.get_summary()
+```
+
+Custom:
+
+```python
+from fbtseg import FBTSeg
+
+model = FBTSeg(
+    max_depth=3,
+    min_samples_leaf=0.05,
+    metric="error",
+    top_k_variables=1,                  # rQtdeVarTeste
+    n_numeric_bins=4,                   # rQtdeDivisoes
+    grouping_features=("education",),    # rUsaBlocos
+    max_group_size=2,                    # rQtdeBlocos
+    combiner_method="stacking",          # ou 'marginal_odds'
+    prediction_mode="leaf",              # 'leaf' | 'pair_combiner' | 'cascade' | 'global_stacking'
+    drop_split_feature_in_children=True,
+)
+model.fit(X_train, y_train)
+```
+
+## Como funciona
+
+Em cada nó terminal o método:
+
+1. Faz **screening fatorial** — uma regressão por variável candidata,
+   incluindo dummies da variável, efeitos principais e interações.
+2. Para a(s) melhor(es) variável(eis), testa **segmentações binárias**
+   (categoria-vs-complemento ou grupo de categorias).
+3. Treina **especialistas** para cada segmento e os combina por
+   `Stacking` ou `Marginal Odds`.
+4. **Aceita a divisão** se ela melhora a métrica D em validação interna
+   (com tolerância configurável de ganho mínimo / perda máxima).
+5. Recorre nos filhos até atingir profundidade máxima ou esgotar
+   candidatos.
+
+A predição é vetorizada por folha (1 chamada a `predict_proba` por
+folha, não 1 por linha) — 50× a 3000× mais rápida que implementações
+ingênuas.
+
+## CLI
+
+```bash
+# Treinar e salvar
+fbtseg fit --dataset chess --preset article_uci --output-dir runs/chess
+
+# CSV próprio
+fbtseg fit --csv data.csv --target y --preset thesis \
+    --categorical cat_col_1 cat_col_2
+
+# Predição com modelo salvo
+fbtseg predict --model runs/chess/model.pkl --csv new_data.csv --output preds.csv
+```
+
+## Reprodução do paper ICAI 2012
+
+```bash
+# Tabela 1 do paper — Linear/Logistic/MLP × bases UCI
+python scripts/run_paper_table_replication.py --datasets chess magic spambase german \
+    --n-splits 3 --output-dir artifacts/paper_table
+
+# Datasets sintéticos do ICTAI 2012
+python scripts/validate_ictai_synthetic.py --datasets 1 2 3 4 \
+    --sizes 1000 3000 5000 --n-replications 10
+```
+
+### Destaques de fidelidade
+
+| Dataset | Base | Paper Simple | Paper FBTSeg | fbtseg Simple | fbtseg |
+|---|---|---:|---:|---:|---:|
+| Chess | Logistic | 2.60% | 1.02% | 2.41% | **1.41%** |
+| Magic | Logistic | 20.98% | 18.69% | 20.96% | **16.07%** |
+| Magic | Linear | 32.03% | 16.06% | 21.61% | **16.93%** |
+| Spambase | Linear | 14.89% | 13.51% | 11.15% | **10.45%** |
+
+Detalhes em [docs/paper_table_replicated.md](docs/paper_table_replicated.md).
+
+## Estrutura do repositório
+
+```
+fbtseg/             # pacote (estimator, views, tree, combiners, metrics, base_learners, datasets, CLI)
+tests/              # testes (33 cobrindo fit, predict, presets, base learners, métricas)
+scripts/            # scripts de reprodução dos experimentos
+docs/               # documentação + reference (tese + 2 PDFs)
+artifacts/          # resultados de execuções
+trash/v1/           # implementação anterior (V1), preservada para auditoria histórica
+```
+
+## Documentação
+
+- [docs/fbtseg.md](docs/fbtseg.md): API completa + mapeamento parâmetros tese ↔ código.
+- [docs/paper_table_replicated.md](docs/paper_table_replicated.md): replicação da Tabela 1 do ICAI 2012.
+- [docs/benchmark_final.md](docs/benchmark_final.md): benchmark fbtseg vs LR.
+- [docs/examples/quickstart.py](docs/examples/quickstart.py): notebook linear executável.
+- [CHANGELOG.md](CHANGELOG.md): histórico de versões.
+
+## Licença
+
+[MIT](LICENSE). Use, copie, modifique e distribua livremente.
+
+## Citação
+
+Se você usa este pacote em pesquisa, cite a tese e/ou os artigos:
+
+```bibtex
+@phdthesis{santos2010metodo,
+  author = {Santos, Roberto Angelo Fernandes},
+  title  = {Um Método para Segmentação de Preditores},
+  school = {Universidade Federal de Pernambuco},
+  year   = {2010},
+  url    = {http://www.cin.ufpe.br/~roberto/AlunosPG/Teses/2010-PhD-Roberto.zip},
+}
+
+@inproceedings{santos2012comparing,
+  author    = {Santos, Roberto Angelo Fernandes and Barros, Roberto Souto Maior de},
+  title     = {Comparing Segmentation Methods with Different Base Classifiers},
+  booktitle = {Proceedings of the 2012 International Conference on Artificial Intelligence (ICAI 2012)},
+  year      = {2012},
+}
+
+@inproceedings{santos2012fbtseg,
+  author    = {Santos, Roberto Angelo Fernandes and Barros, Roberto Souto Maior de},
+  title     = {Comparing FBTSeg and NNTree Implementations with Established Ensemble Methods},
+  booktitle = {Proceedings of the 24th IEEE International Conference on Tools with Artificial Intelligence (ICTAI 2012)},
+  year      = {2012},
+}
+```
+
+## Referências
+
+- **SANTOS, R. A. F.** *Um Método para Segmentação de Preditores.* Tese
+  (Doutorado em Ciência da Computação) — Centro de Informática, UFPE,
+  Recife, 2010. Orientador: Prof. Dr. Roberto Souto Maior de Barros.
+  ([docx](docs/reference/Tese_Roberto_Final_Biblioteca.docx))
+- **SANTOS, R. A. F.; BARROS, R. S. M.** Comparing Segmentation Methods
+  with Different Base Classifiers. *In:* Proceedings of the
+  International Conference on Artificial Intelligence (ICAI), Las
+  Vegas, USA, 2012.
+  ([PDF](docs/reference/ICAI2012-rafs-proceed.pdf))
+- **SANTOS, R. A. F.; BARROS, R. S. M.** Comparing FBTSeg and NNTree
+  Implementations with Established Ensemble Methods. *In:* Proceedings
+  of the IEEE International Conference on Tools with Artificial
+  Intelligence (ICTAI), Athens, Greece, 2012.
+  ([PDF](docs/reference/ICTAI2012-Submitted-140-FBTSeg.pdf))
+
+Para citações completas (BibTeX) e referências secundárias citadas
+pelos artigos (Wolpert 1992 — Stacking, Thomas et al. 2002 — Marginal
+Odds, Maji 2008 — NNTree, etc.), veja
+[docs/references.md](docs/references.md).

fbtseg-0.2.0/fbtseg/__init__.py

@@ -0,0 +1,68 @@
+"""fbtseg — Find Best Tree Segmentation.
+
+Implementacao do metodo de segmentacao binaria recursiva descrito por
+Roberto Santos & Roberto Barros (UFPE, ICAI 2012 e ICTAI 2012). A
+estrategia em cada no terminal e:
+
+1. Screening fatorial das variaveis candidatas (regressao com interacoes).
+2. Teste de cada categoria/grupo da variavel escolhida.
+3. Treino de classificadores especialistas para cada segmento.
+4. Combinacao por Stacking ou Marginal Odds.
+5. Aceitacao do split conforme ganho minimo / perda maxima.
+
+Estimador binario, sklearn-compativel, com predicao vetorizada.
+
+Importacoes principais:
+
+- `FBTSeg` (alias `RiskSegV2` por compatibilidade): estimador principal.
+- `thesis_preset`, `article_uci_preset`, `article_synthetic_preset`:
+    presets fieis a tese, ICAI 2012 e ICTAI 2012 respectivamente.
+- `LinearProbabilityClassifier`: base learner usado para replicar a
+    config "Linear" do paper.
+- `load_article_dataset`, `article_specs`, `get_spec`: loaders das 5
+    bases UCI usadas pelo paper.
+"""
+
+from .base_learners import LinearProbabilityClassifier
+from .combiners import MarginalOddsCombiner, StackingCombiner, build_combiner
+from .datasets import DatasetSpec, article_specs, get_spec, load_article_dataset
+from .estimator import (
+    RiskSegV2,
+    article_synthetic_preset,
+    article_uci_preset,
+    thesis_preset,
+)
+from .metrics import all_metrics, metric_score
+from .tree import Node, collect_leaves, collect_nodes, route_observations, route_pair_parent
+from .views import ModelView, SegView
+
+# Alias publico (FBTSeg = nome do paper; RiskSegV2 = nome herdado da V2)
+FBTSeg = RiskSegV2
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "FBTSeg",
+    "RiskSegV2",
+    "thesis_preset",
+    "article_uci_preset",
+    "article_synthetic_preset",
+    "LinearProbabilityClassifier",
+    "DatasetSpec",
+    "article_specs",
+    "get_spec",
+    "load_article_dataset",
+    "SegView",
+    "ModelView",
+    "StackingCombiner",
+    "MarginalOddsCombiner",
+    "build_combiner",
+    "metric_score",
+    "all_metrics",
+    "Node",
+    "collect_leaves",
+    "collect_nodes",
+    "route_observations",
+    "route_pair_parent",
+    "__version__",
+]

fbtseg-0.2.0/fbtseg/__main__.py

@@ -0,0 +1,5 @@
+"""Entry-point para `python -m fbtseg`."""
+from .cli import main
+
+if __name__ == "__main__":
+    main()

fbtseg-0.2.0/fbtseg/base_learners.py

@@ -0,0 +1,87 @@
+"""Base learners adicionais para uso no `FBTSeg`.
+
+O paper ICAI 2012 (Santos & Barros, 2012a) compara FBTSeg cruzado com
+**três** base learners diferentes:
+
+- **Regressão Logística** (LR sem regularização) — disponível
+  diretamente via `sklearn.linear_model.LogisticRegression(penalty=None)`.
+- **Regressão Linear** (probabilidade linear, com clip em [0, 1]) —
+  exportada aqui como `LinearProbabilityClassifier`.
+- **MLP Neural Network** — usar `sklearn.neural_network.MLPClassifier`
+  diretamente. O `FBTSeg._fit_clone` tolera estimadores que não
+  aceitam `sample_weight` (cai no caminho sem peso).
+
+A intuição por trás de oferecer Regressão Linear como base: é o pior
+classificador entre os três no agregado, MAS é exatamente onde o
+FBTSeg mostra os ganhos mais dramáticos (Magic 32% → 16% no paper,
+porque a segmentação compensa a incapacidade da regressão linear de
+modelar interações).
+
+Referências (`docs/references.md`):
+- SANTOS & BARROS, 2012 (ICAI) — Seção 2, Seção 3 (base learners).
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from sklearn.base import BaseEstimator, ClassifierMixin
+from sklearn.linear_model import LinearRegression
+
+
+class LinearProbabilityClassifier(ClassifierMixin, BaseEstimator):
+    """Regressão linear ajustada contra `y` em {0, 1}, com escore truncado.
+
+    Replica a configuração "Linear Regression" do artigo ICAI 2012,
+    onde o alvo dicotômico é tratado como contínuo num modelo linear
+    e a probabilidade prevista é o output cru, **truncado em [0, 1]**
+    para virar uma probabilidade válida (modelo de probabilidade
+    linear, MPL).
+
+    Limitações conhecidas:
+    - extrapola para fora de [0, 1] sem o clip;
+    - heterocedástico por construção;
+    - mas é o que o paper usou e é por isso que está aqui.
+
+    Compatível com a API sklearn: `fit`, `predict_proba`, `predict`,
+    `decision_function`, suporta `clone()`.
+    """
+
+    def __init__(self):
+        # Sem hiperparâmetros — manter `__init__` vazio é importante
+        # para que `sklearn.base.clone()` funcione sem warning.
+        pass
+
+    def fit(self, X, y, sample_weight=None):
+        X = np.asarray(X, dtype=float)
+        y = np.asarray(y, dtype=float)
+        # Convenção sklearn: `classes_` ordenado.
+        self.classes_ = np.array(sorted(np.unique(y).astype(int)))
+        if self.classes_.size < 2:
+            # Caso degenerado: só uma classe. Vira "classificador constante".
+            self.constant_ = float(y.mean()) if y.size else 0.5
+            self._fitted = "constant"
+            return self
+        self.model_ = LinearRegression()
+        if sample_weight is not None:
+            self.model_.fit(X, y, sample_weight=sample_weight)
+        else:
+            self.model_.fit(X, y)
+        self._fitted = "linear"
+        return self
+
+    def predict_proba(self, X):
+        """Devolve `[1-p, p]` com `p = clip(linear(X), 0, 1)`."""
+        X = np.asarray(X, dtype=float)
+        if self._fitted == "constant":
+            n = X.shape[0]
+            return np.full((n, 2), [1 - self.constant_, self.constant_], dtype=float)
+        # Escore cru da regressão linear, truncado em [0, 1].
+        p1 = np.clip(self.model_.predict(X), 0.0, 1.0)
+        return np.column_stack([1.0 - p1, p1])
+
+    def predict(self, X):
+        return (self.predict_proba(X)[:, 1] >= 0.5).astype(int)
+
+    def decision_function(self, X):
+        """Escore (probabilidade da classe positiva) — sem truncamento explícito."""
+        return self.predict_proba(X)[:, 1]