tlmnet 0.1.0__tar.gz

tlmnet-0.1.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2023 - 2026, Carlson Research, LLC
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

tlmnet-0.1.0/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: tlmnet
+Version: 0.1.0
+Summary: Ternary Linear Models via Exact MILP Solvers
+Author-email: "Carlson Research, LLC" <rolf@hrolfrc.com>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/carlson-research/tlmnet
+Project-URL: Repository, https://github.com/carlson-research/tlmnet
+Project-URL: Documentation, https://carlson-research.github.io/tlmnet/
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: scipy>=1.10.0
+Requires-Dist: scikit-learn>=1.6.0
+Requires-Dist: joblib>=1.3.0
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0.0; extra == "dev"
+Requires-Dist: sphinx>=7.0.0; extra == "dev"
+Requires-Dist: pydata-sphinx-theme>=0.15.0; extra == "dev"
+Requires-Dist: sphinx-gallery; extra == "dev"
+Requires-Dist: numpydoc; extra == "dev"
+Requires-Dist: nbsphinx; extra == "dev"
+Requires-Dist: pandoc; extra == "dev"
+Requires-Dist: mypy>=1.8.0; extra == "dev"
+Requires-Dist: pre-commit<3.8.0; extra == "dev"
+Requires-Dist: build>=1.0.0; extra == "dev"
+Requires-Dist: twine>=5.0.0; extra == "dev"
+Dynamic: license-file
+
+# tlmnet
+
+[![CI](https://github.com/carlson-research/tlmnet/actions/workflows/tests.yml/badge.svg)](https://github.com/carlson-research/tlmnet/actions)
+[![PyPI Version](https://img.shields.io/pypi/v/tlmnet.svg)](https://pypi.org/project/tlmnet/)
+[![Python Version](https://img.shields.io/pypi/pyversions/tlmnet.svg)](https://pypi.org/project/tlmnet/)
+[![Documentation](https://img.shields.io/badge/docs-GitHub%20Pages-blue)](https://carlson-research.github.io/tlmnet/)
+[![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://github.com/carlson-research/tlmnet/blob/main/LICENSE)
+
+`tlmnet` provides exact Mixed-Integer Linear Programming (MILP) solvers for Quantized Statistical Learning with Ternary Linear Models (TLMs).
+
+By restricting coefficients to discrete ternary values ($w_j \in \{-1, 0, 1\}$), it constructs globally optimal, sparse, and interpretable classifiers compliant with Scikit-Learn 1.6+ API standards.
+
+## Features
+
+* **Exact Discrete Weights:** Solves for ternary coefficients $w_j \in \{-1, 0, 1\}$ directly using branch-and-bound optimization via `scipy.optimize.milp`.
+* **Exact $L_0$ Cardinality Constraints:** Enforces strict integer feature selection budgets ($\sum \vert{}w_j\vert{} \le k$) using `max_features`.
+* **Native Sparse Data Support:** Efficiently processes high-dimensional `scipy.sparse` matrices (`CSR`, `CSC`, `COO`) using sparse block constraint assembly.
+* **Scikit-Learn Compatibility:** Plugs directly into `Pipeline`, `OneVsRestClassifier`, `GridSearchCV`, and standard estimator workflows.
+* **Timeout & Incumbent Recovery:** Automatically returns the best feasible integer solution found if the solver reaches `time_limit` before proving global optimality.
+
+## Installation
+
+Install `tlmnet` directly from PyPI:
+
+```bash
+pip install tlmnet
+```
+
+## Quick Start Example
+
+```python
+from tlmnet import TlmMilpClassifier
+from sklearn.datasets import make_classification
+from sklearn.model_selection import train_test_split
+from sklearn.pipeline import make_pipeline
+from sklearn.preprocessing import StandardScaler
+
+# Generate synthetic classification dataset
+X, y = make_classification(
+    n_samples=200, n_features=15, n_informative=5, random_state=42
+)
+X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
+
+# Build pipeline with standardization and exact MILP classification
+clf = make_pipeline(
+    StandardScaler(),
+    TlmMilpClassifier(max_features=5, C=1.0, time_limit=30.0)
+)
+clf.fit(X_train, y_train)
+
+# Inspect model properties
+tlm_model = clf.named_steps["tlmmilpclassifier"]
+print("Ternary Coefficients:", tlm_model.coef_)
+print("Test Accuracy:", clf.score(X_test, y_test))
+
+```
+
+## License
+
+This project is licensed under the BSD-3-Clause License.
+
+## Authors
+
+* **Author & Maintainer**: Rolf Carlson (rolf@hrolfrc.com)

tlmnet-0.1.0/README.md

@@ -0,0 +1,64 @@
+# tlmnet
+
+[![CI](https://github.com/carlson-research/tlmnet/actions/workflows/tests.yml/badge.svg)](https://github.com/carlson-research/tlmnet/actions)
+[![PyPI Version](https://img.shields.io/pypi/v/tlmnet.svg)](https://pypi.org/project/tlmnet/)
+[![Python Version](https://img.shields.io/pypi/pyversions/tlmnet.svg)](https://pypi.org/project/tlmnet/)
+[![Documentation](https://img.shields.io/badge/docs-GitHub%20Pages-blue)](https://carlson-research.github.io/tlmnet/)
+[![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://github.com/carlson-research/tlmnet/blob/main/LICENSE)
+
+`tlmnet` provides exact Mixed-Integer Linear Programming (MILP) solvers for Quantized Statistical Learning with Ternary Linear Models (TLMs).
+
+By restricting coefficients to discrete ternary values ($w_j \in \{-1, 0, 1\}$), it constructs globally optimal, sparse, and interpretable classifiers compliant with Scikit-Learn 1.6+ API standards.
+
+## Features
+
+* **Exact Discrete Weights:** Solves for ternary coefficients $w_j \in \{-1, 0, 1\}$ directly using branch-and-bound optimization via `scipy.optimize.milp`.
+* **Exact $L_0$ Cardinality Constraints:** Enforces strict integer feature selection budgets ($\sum \vert{}w_j\vert{} \le k$) using `max_features`.
+* **Native Sparse Data Support:** Efficiently processes high-dimensional `scipy.sparse` matrices (`CSR`, `CSC`, `COO`) using sparse block constraint assembly.
+* **Scikit-Learn Compatibility:** Plugs directly into `Pipeline`, `OneVsRestClassifier`, `GridSearchCV`, and standard estimator workflows.
+* **Timeout & Incumbent Recovery:** Automatically returns the best feasible integer solution found if the solver reaches `time_limit` before proving global optimality.
+
+## Installation
+
+Install `tlmnet` directly from PyPI:
+
+```bash
+pip install tlmnet
+```
+
+## Quick Start Example
+
+```python
+from tlmnet import TlmMilpClassifier
+from sklearn.datasets import make_classification
+from sklearn.model_selection import train_test_split
+from sklearn.pipeline import make_pipeline
+from sklearn.preprocessing import StandardScaler
+
+# Generate synthetic classification dataset
+X, y = make_classification(
+    n_samples=200, n_features=15, n_informative=5, random_state=42
+)
+X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
+
+# Build pipeline with standardization and exact MILP classification
+clf = make_pipeline(
+    StandardScaler(),
+    TlmMilpClassifier(max_features=5, C=1.0, time_limit=30.0)
+)
+clf.fit(X_train, y_train)
+
+# Inspect model properties
+tlm_model = clf.named_steps["tlmmilpclassifier"]
+print("Ternary Coefficients:", tlm_model.coef_)
+print("Test Accuracy:", clf.score(X_test, y_test))
+
+```
+
+## License
+
+This project is licensed under the BSD-3-Clause License.
+
+## Authors
+
+* **Author & Maintainer**: Rolf Carlson (rolf@hrolfrc.com)

tlmnet-0.1.0/pyproject.toml

@@ -0,0 +1,99 @@
+# pip install -e ".[dev]"
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tlmnet"
+dynamic = ["version"]
+description = "Ternary Linear Models via Exact MILP Solvers"
+readme = "README.md"
+authors = [
+    {name = "Carlson Research, LLC", email = "rolf@hrolfrc.com"}
+]
+license = "BSD-3-Clause"
+requires-python = ">=3.11"
+dependencies = [
+    "numpy>=1.24.0",
+    "scipy>=1.10.0",
+    "scikit-learn>=1.6.0",
+    "joblib>=1.3.0",
+    "pandas",
+    "matplotlib",
+]
+
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Information Analysis",
+]
+
+[project.urls]
+Homepage = "https://github.com/carlson-research/tlmnet"
+Repository = "https://github.com/carlson-research/tlmnet"
+Documentation = "https://carlson-research.github.io/tlmnet/"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=5.0.0",
+    "sphinx>=7.0.0",
+    "pydata-sphinx-theme>=0.15.0",
+    "sphinx-gallery",
+    "numpydoc",
+    "nbsphinx",
+    "pandoc",
+    "mypy>=1.8.0",
+    "pre-commit<3.8.0",
+    "build>=1.0.0",
+    "twine>=5.0.0",
+]
+
+[tool.coverage.run]
+source = ["src/tlmnet"]
+omit = [
+    "src/tlmnet/__main__.py",
+]
+
+[tool.setuptools.dynamic]
+version = {attr = "tlmnet._version.__version__"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["tlmnet*"]
+
+[tool.pytest.ini_options]
+filterwarnings = [
+    "ignore:Passing a non-Collection iterable to parametrize is deprecated:pytest.PytestRemovedIn10Warning",
+]
+addopts = "--doctest-modules"
+pythonpath = [".", "src"]
+testpaths = ["tests", "src"]
+
+[tool.ruff]
+line-length = 88
+src = ["src", "tests"]
+
+[tool.mypy]
+python_version = "3.12"
+exclude = ["docs/auto_examples/"]
+warn_return_any = false
+warn_unused_configs = true
+ignore_missing_imports = true
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "if self.debug:",
+    "if settings.DEBUG",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if 0:",
+    "if __name__ == .__main__.:",
+    "if self.verbose:"
+]
+show_missing = true

tlmnet-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tlmnet-0.1.0/src/tlmnet/__init__.py

@@ -0,0 +1,4 @@
+from ._version import __version__
+from .milp import TlmMilpClassifier
+
+__all__ = ["TlmMilpClassifier", "__version__"]

tlmnet-0.1.0/src/tlmnet/_version.py

@@ -0,0 +1,3 @@
+"""Version definition for dynamic pyproject.toml linking."""
+
+__version__ = "0.1.0"

tlmnet-0.1.0/src/tlmnet/milp.py

@@ -0,0 +1,161 @@
+import numpy as np
+import scipy.sparse as sp
+from scipy.optimize import Bounds, LinearConstraint, milp
+from sklearn.base import BaseEstimator, ClassifierMixin
+from sklearn.utils.multiclass import type_of_target, unique_labels
+from sklearn.utils.validation import check_is_fitted, validate_data
+
+
+class TlmMilpClassifier(ClassifierMixin, BaseEstimator):
+    """Exact Ternary Linear Model Classifier using Mixed-Integer Linear Programming (MILP).
+
+    Solves for w_j in {-1, 0, 1} using decision variable splitting w_j = u_j - v_j.
+    Natively supports sparse data constraints via scipy.sparse block matrices.
+    """
+
+    def __init__(
+        self, max_features=None, C=1.0, time_limit=60.0, mip_rel_gap=1e-4, verbose=False
+    ):
+        self.max_features = max_features
+        self.C = C
+        self.time_limit = time_limit
+        self.mip_rel_gap = mip_rel_gap
+        self.verbose = verbose
+
+    def _more_tags(self):
+        return {"poor_score": True, "binary_only": True}
+
+    def __sklearn_tags__(self):
+        tags = super().__sklearn_tags__()
+        tags.classifier_tags.poor_score = True
+        tags.classifier_tags.multi_class = False
+        tags.input_tags.sparse = (
+            True  # Tell Scikit-Learn we natively accept sparse matrices
+        )
+        tags.estimator_type = "classifier"
+        return tags
+
+    def fit(self, X, y):
+        if y is None:
+            raise ValueError("requires y to be passed, but the target y is None")
+
+        # 1. Validate data; natively accept sparse inputs (CSR/CSC/COO)
+        X, y = validate_data(
+            self, X=X, y=y, accept_sparse=["csr", "csc", "coo"], reset=True
+        )
+
+        # 2. Check target type
+        y_type = type_of_target(y)
+        if y_type == "unknown":
+            raise ValueError("Unknown label type: target y must be binary.")
+        if y_type != "binary":
+            raise ValueError(
+                f"Only binary classification is supported. The type of target is {y_type}."
+            )
+
+        self.classes_ = unique_labels(y)
+        if len(self.classes_) < 2:
+            raise ValueError(
+                f"This solver needs samples of at least 2 classes in the data, "
+                f"but the data contains only one class: {self.classes_[0]}"
+            )
+
+        n_samples, n_features = X.shape
+
+        # Convert y to {-1, +1}
+        y_binary = np.where(y == self.classes_[1], 1, -1)
+
+        # Decision Variables: 2*p (weights) + n (slacks)
+        c = np.zeros(2 * n_features + n_samples)
+        c[2 * n_features :] = self.C
+
+        integrality = np.concatenate([np.ones(2 * n_features), np.zeros(n_samples)])
+        lb = np.zeros(2 * n_features + n_samples)
+        ub = np.concatenate([np.ones(2 * n_features), np.full(n_samples, np.inf)])
+        bounds = Bounds(lb, ub)
+
+        constraints = []
+
+        # 1. Mutually Exclusive Ternary Constraint (Sparse)
+        row_exc = np.repeat(np.arange(n_features), 2)
+        col_exc = np.arange(2 * n_features)
+        data_exc = np.ones(2 * n_features)
+
+        A_exc_left = sp.coo_matrix(
+            (data_exc, (row_exc, col_exc)), shape=(n_features, 2 * n_features)
+        )
+        A_exc_right = sp.csr_matrix((n_features, n_samples))
+        A_exclusive = sp.hstack([A_exc_left, A_exc_right])
+        constraints.append(LinearConstraint(A_exclusive, -np.inf, 1))
+
+        # 2. Classification Margin Constraint (Sparse)
+        if not sp.issparse(X):
+            X_sparse = sp.csr_matrix(X)
+        else:
+            X_sparse = X
+
+        # Multiply rows of X by y efficiently
+        Y_diag = sp.diags(y_binary, dtype=float)
+        X_y = Y_diag @ X_sparse
+        X_y = X_y.tocoo()
+
+        # Interleave u and v coefficients
+        row_u, col_u, data_u = X_y.row, 2 * X_y.col, X_y.data
+        row_v, col_v, data_v = X_y.row, 2 * X_y.col + 1, -X_y.data
+
+        row_margin = np.concatenate([row_u, row_v])
+        col_margin = np.concatenate([col_u, col_v])
+        data_margin = np.concatenate([data_u, data_v])
+
+        A_margin_left = sp.coo_matrix(
+            (data_margin, (row_margin, col_margin)), shape=(n_samples, 2 * n_features)
+        )
+        A_margin_right = sp.eye(n_samples, format="coo")
+        A_margin = sp.hstack([A_margin_left, A_margin_right])
+
+        constraints.append(LinearConstraint(A_margin, 1.0, np.inf))
+
+        # 3. L0 Sparsity Budget (Sparse)
+        if self.max_features is not None:
+            A_sparse_left = sp.csr_matrix(np.ones((1, 2 * n_features)))
+            A_sparse_right = sp.csr_matrix((1, n_samples))
+            A_sparse_const = sp.hstack([A_sparse_left, A_sparse_right])
+            constraints.append(LinearConstraint(A_sparse_const, 0, self.max_features))
+
+        # Solve MILP with expanded options
+        options = {
+            "time_limit": self.time_limit,
+            "mip_rel_gap": self.mip_rel_gap,
+            "disp": self.verbose,
+        }
+        res = milp(
+            c=c,
+            integrality=integrality,
+            bounds=bounds,
+            constraints=constraints,
+            options=options,
+        )
+
+        # Status 0 = Optimal, Status 1 = Time Limit Reached (but res.x might exist!)
+        if res.status in (0, 1) and res.x is not None:
+            u_opt = np.round(res.x[: 2 * n_features : 2])
+            v_opt = np.round(res.x[1 : 2 * n_features : 2])
+        else:
+            # Only fail to all zeros if it's proven infeasible (Status 2) or unbounded (Status 3)
+            u_opt = np.zeros(n_features)
+            v_opt = np.zeros(n_features)
+
+        self.coef_ = u_opt - v_opt
+        self.intercept_ = 0.0
+
+        return self
+
+    def decision_function(self, X):
+        """Predict confidence scores for samples."""
+        check_is_fitted(self)
+        X = validate_data(self, X=X, accept_sparse=["csr", "csc", "coo"], reset=False)
+        return X @ self.coef_
+
+    def predict(self, X):
+        scores = self.decision_function(X)
+        return np.where(scores >= 0, self.classes_[1], self.classes_[0])

tlmnet-0.1.0/src/tlmnet.egg-info/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: tlmnet
+Version: 0.1.0
+Summary: Ternary Linear Models via Exact MILP Solvers
+Author-email: "Carlson Research, LLC" <rolf@hrolfrc.com>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/carlson-research/tlmnet
+Project-URL: Repository, https://github.com/carlson-research/tlmnet
+Project-URL: Documentation, https://carlson-research.github.io/tlmnet/
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: scipy>=1.10.0
+Requires-Dist: scikit-learn>=1.6.0
+Requires-Dist: joblib>=1.3.0
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0.0; extra == "dev"
+Requires-Dist: sphinx>=7.0.0; extra == "dev"
+Requires-Dist: pydata-sphinx-theme>=0.15.0; extra == "dev"
+Requires-Dist: sphinx-gallery; extra == "dev"
+Requires-Dist: numpydoc; extra == "dev"
+Requires-Dist: nbsphinx; extra == "dev"
+Requires-Dist: pandoc; extra == "dev"
+Requires-Dist: mypy>=1.8.0; extra == "dev"
+Requires-Dist: pre-commit<3.8.0; extra == "dev"
+Requires-Dist: build>=1.0.0; extra == "dev"
+Requires-Dist: twine>=5.0.0; extra == "dev"
+Dynamic: license-file
+
+# tlmnet
+
+[![CI](https://github.com/carlson-research/tlmnet/actions/workflows/tests.yml/badge.svg)](https://github.com/carlson-research/tlmnet/actions)
+[![PyPI Version](https://img.shields.io/pypi/v/tlmnet.svg)](https://pypi.org/project/tlmnet/)
+[![Python Version](https://img.shields.io/pypi/pyversions/tlmnet.svg)](https://pypi.org/project/tlmnet/)
+[![Documentation](https://img.shields.io/badge/docs-GitHub%20Pages-blue)](https://carlson-research.github.io/tlmnet/)
+[![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://github.com/carlson-research/tlmnet/blob/main/LICENSE)
+
+`tlmnet` provides exact Mixed-Integer Linear Programming (MILP) solvers for Quantized Statistical Learning with Ternary Linear Models (TLMs).
+
+By restricting coefficients to discrete ternary values ($w_j \in \{-1, 0, 1\}$), it constructs globally optimal, sparse, and interpretable classifiers compliant with Scikit-Learn 1.6+ API standards.
+
+## Features
+
+* **Exact Discrete Weights:** Solves for ternary coefficients $w_j \in \{-1, 0, 1\}$ directly using branch-and-bound optimization via `scipy.optimize.milp`.
+* **Exact $L_0$ Cardinality Constraints:** Enforces strict integer feature selection budgets ($\sum \vert{}w_j\vert{} \le k$) using `max_features`.
+* **Native Sparse Data Support:** Efficiently processes high-dimensional `scipy.sparse` matrices (`CSR`, `CSC`, `COO`) using sparse block constraint assembly.
+* **Scikit-Learn Compatibility:** Plugs directly into `Pipeline`, `OneVsRestClassifier`, `GridSearchCV`, and standard estimator workflows.
+* **Timeout & Incumbent Recovery:** Automatically returns the best feasible integer solution found if the solver reaches `time_limit` before proving global optimality.
+
+## Installation
+
+Install `tlmnet` directly from PyPI:
+
+```bash
+pip install tlmnet
+```
+
+## Quick Start Example
+
+```python
+from tlmnet import TlmMilpClassifier
+from sklearn.datasets import make_classification
+from sklearn.model_selection import train_test_split
+from sklearn.pipeline import make_pipeline
+from sklearn.preprocessing import StandardScaler
+
+# Generate synthetic classification dataset
+X, y = make_classification(
+    n_samples=200, n_features=15, n_informative=5, random_state=42
+)
+X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
+
+# Build pipeline with standardization and exact MILP classification
+clf = make_pipeline(
+    StandardScaler(),
+    TlmMilpClassifier(max_features=5, C=1.0, time_limit=30.0)
+)
+clf.fit(X_train, y_train)
+
+# Inspect model properties
+tlm_model = clf.named_steps["tlmmilpclassifier"]
+print("Ternary Coefficients:", tlm_model.coef_)
+print("Test Accuracy:", clf.score(X_test, y_test))
+
+```
+
+## License
+
+This project is licensed under the BSD-3-Clause License.
+
+## Authors
+
+* **Author & Maintainer**: Rolf Carlson (rolf@hrolfrc.com)

tlmnet-0.1.0/src/tlmnet.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/tlmnet/__init__.py
+src/tlmnet/_version.py
+src/tlmnet/milp.py
+src/tlmnet.egg-info/PKG-INFO
+src/tlmnet.egg-info/SOURCES.txt
+src/tlmnet.egg-info/dependency_links.txt
+src/tlmnet.egg-info/requires.txt
+src/tlmnet.egg-info/top_level.txt

tlmnet-0.1.0/src/tlmnet.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tlmnet-0.1.0/src/tlmnet.egg-info/requires.txt

@@ -0,0 +1,20 @@
+numpy>=1.24.0
+scipy>=1.10.0
+scikit-learn>=1.6.0
+joblib>=1.3.0
+pandas
+matplotlib
+
+[dev]
+pytest>=8.0.0
+pytest-cov>=5.0.0
+sphinx>=7.0.0
+pydata-sphinx-theme>=0.15.0
+sphinx-gallery
+numpydoc
+nbsphinx
+pandoc
+mypy>=1.8.0
+pre-commit<3.8.0
+build>=1.0.0
+twine>=5.0.0

tlmnet-0.1.0/src/tlmnet.egg-info/top_level.txt

@@ -0,0 +1 @@
+tlmnet