Metadata-Version: 2.4
Name: ml-lab-toolkit
Version: 1.0.0
Summary: A professional Python library implementing core machine learning algorithms from ML lab experiments.
Author: ML Lab Toolkit Contributors
License-Expression: MIT
Project-URL: Homepage, https://github.com/your-username/ml-lab-toolkit
Project-URL: Repository, https://github.com/your-username/ml-lab-toolkit
Project-URL: Documentation, https://github.com/your-username/ml-lab-toolkit#readme
Keywords: machine-learning,pca,knn,find-s,naive-bayes,k-means,decision-tree,regression
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Education
Classifier: Intended Audience :: Science/Research
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Classifier: Typing :: Typed
Requires-Python: >=3.9
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: numpy>=1.24.0
Provides-Extra: dev
Requires-Dist: build>=1.0.0; extra == "dev"
Requires-Dist: pytest>=7.4.0; extra == "dev"
Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
Requires-Dist: twine>=4.0.0; extra == "dev"
Dynamic: license-file

# ML Lab Toolkit

A production-ready Python library implementing core machine learning algorithms from ML lab experiments. Install worldwide with:

```bash
pip install ml-lab-toolkit
```

## Installation

```bash
pip install ml-lab-toolkit
```

Development install:

```bash
git clone https://github.com/your-username/ml-lab-toolkit.git
cd ml-lab-toolkit
pip install -e ".[dev]"
```

## Quick Start

```python
from mllab import PCA, KNN, FindS, LWR
from mllab import LinearRegression, PolynomialRegression
from mllab import DecisionTree, NaiveBayes, KMeans
import numpy as np

X = np.random.randn(50, 4)
pca = PCA(n_components=2)
X_reduced = pca.fit_transform(X)

knn = KNN(n_neighbors=3)
knn.fit(X[:30], np.random.randint(0, 2, 30))
predictions = knn.predict(X[30:])
```

## Algorithms

| Module | Class | Description |
|--------|-------|-------------|
| `mllab.pca` | `PCA` | Principal Component Analysis |
| `mllab.find_s` | `FindS` | Find-S concept learning |
| `mllab.knn` | `KNN` | k-Nearest Neighbors classifier |
| `mllab.lwr` | `LWR` | Locally Weighted Regression |
| `mllab.linear_regression` | `LinearRegression` | Ordinary least squares regression |
| `mllab.polynomial_regression` | `PolynomialRegression` | Polynomial feature regression |
| `mllab.decision_tree` | `DecisionTree` | Entropy-based decision tree |
| `mllab.naive_bayes` | `NaiveBayes` | Gaussian Naive Bayes |
| `mllab.kmeans` | `KMeans` | K-Means clustering |

## Usage Examples

### PCA (Experiment 3)

```python
from mllab import PCA
import numpy as np

X = np.random.randn(150, 4)
model = PCA(n_components=2, standardize=True)
X_2d = model.fit_transform(X)
print(model.explained_variance_ratio_)
```

### Find-S (Experiment 4)

```python
from mllab import FindS

model = FindS(positive_label="Yes")
model.fit(X_attributes, y_labels)
print(model.hypothesis_)
```

### KNN (Experiment 5)

```python
from mllab import KNN

model = KNN(n_neighbors=5)
model.fit(X_train, y_train)
accuracy = model.score(X_test, y_test)
```

### LWR (Experiment 6)

```python
from mllab import LWR

model = LWR(tau=1.0)
model.fit(x_train, y_train)
y_pred = model.predict(x_test)
```

### Linear & Polynomial Regression (Experiment 7)

```python
from mllab import LinearRegression, PolynomialRegression

linear = LinearRegression().fit(X, y)
poly = PolynomialRegression(degree=3).fit(X, y)
```

### Decision Tree (Experiment 8)

```python
from mllab import DecisionTree

tree = DecisionTree(max_depth=7)
tree.fit(X_train, y_train)
predictions = tree.predict(X_test)
```

### Naive Bayes (Experiment 9)

```python
from mllab import NaiveBayes

nb = NaiveBayes().fit(X_train, y_train)
accuracy = nb.score(X_test, y_test)
```

### K-Means (Experiment 10)

```python
from mllab import KMeans

kmeans = KMeans(n_clusters=2, random_state=42)
labels = kmeans.fit_predict(X)
```

## API Documentation

All estimators follow a scikit-learn-like API:

- `fit(X, y)` — train the model
- `predict(X)` — generate predictions
- `score(X, y)` — evaluate performance (where applicable)
- `fit_transform(X)` — fit and transform (PCA)
- `fit_predict(X)` — fit and return labels (KMeans)

Shared utilities live in `mllab.utils`:

- `StandardScaler`
- `as_2d_array`, `as_1d_array`
- `euclidean_distances`

## Project Structure

```
ml-lab-toolkit/
├── src/mllab/
│   ├── pca.py
│   ├── find_s.py
│   ├── knn.py
│   ├── lwr.py
│   ├── linear_regression.py
│   ├── polynomial_regression.py
│   ├── decision_tree.py
│   ├── naive_bayes.py
│   ├── kmeans.py
│   └── utils/
├── examples/
├── tests/
├── pyproject.toml
├── requirements.txt
└── README.md
```

## Running Tests

```bash
pytest -v
```

## Building for PyPI

```bash
pip install build twine
python -m build
twine check dist/*
```

## Publishing to PyPI

1. Create accounts on [PyPI](https://pypi.org) and [TestPyPI](https://test.pypi.org).
2. Generate an API token.
3. Build the package:

```bash
python -m build
```

4. Upload to TestPyPI first:

```bash
twine upload --repository testpypi dist/*
pip install -i https://test.pypi.org/simple/ ml-lab-toolkit
```

5. Upload to PyPI:

```bash
twine upload dist/*
```

6. Verify installation:

```bash
pip install ml-lab-toolkit
python -c "from mllab import PCA, KNN; print('OK')"
```

## License

MIT License. See [LICENSE](LICENSE).
