dnaty 1.0.0__tar.gz

dnaty-1.0.0/LICENSE

@@ -0,0 +1,44 @@
+Business Source License 1.1
+
+Parameters
+
+Licensor:             Pedro Vergueiro
+Licensed Work:        dNaty — Dynamic Neuro-Adaptive sYstem with evoluTionarY Learning
+                      Copyright (c) 2026 Pedro Vergueiro
+Additional Use Grant: You may use the Licensed Work for non-commercial research,
+                      academic, and personal purposes free of charge.
+                      Commercial use requires a separate commercial license.
+                      Contact: legal@vergueiro.co for commercial licensing.
+Change Date:          2029-01-01
+Change License:       Apache License, Version 2.0
+
+---
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work.
+
+The Licensor may make an Additional Use Grant, above, permitting limited
+production use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor hereby grants you rights under
+the terms of the Change License, and the rights granted in the paragraphs
+above terminate.
+
+COMMERCIAL USE RESTRICTION:
+Any use of the Licensed Work in a commercial product or service — including
+but not limited to SaaS, APIs, embedded systems, or consulting services —
+requires a separate commercial license from the Licensor.
+
+For commercial licensing inquiries, contact: legal@vergueiro.co
+
+---
+
+NOTICE: This is NOT an open source license. The source is available for
+inspection and non-commercial use only. Commercial use without a license
+is a violation of this agreement.
+
+Full BSL 1.1 text: https://mariadb.com/bsl11/

dnaty-1.0.0/PKG-INFO

@@ -0,0 +1,243 @@
+Metadata-Version: 2.4
+Name: dnaty
+Version: 1.0.0
+Summary: Evolutionary Neural Architecture Search — compress any PyTorch model with one function call
+Author-email: Pedro Vergueiro <pedrol.vergueiro@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/pedrovergueiroo/dNATY
+Project-URL: Repository, https://github.com/pedrovergueiroo/dNATY
+Project-URL: Bug Tracker, https://github.com/pedrovergueiroo/dNATY/issues
+Keywords: neural architecture search,neuroevolution,model compression,continual learning,pytorch,evolutionary algorithms,nas,edge ml
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+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: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.0.0
+Requires-Dist: torchvision>=0.15.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: scipy>=1.10.0
+Requires-Dist: tqdm>=4.65.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: matplotlib>=3.7.0; extra == "dev"
+Requires-Dist: jupyter; extra == "dev"
+Dynamic: license-file
+
+<div align="center">
+
+# dNATY
+
+### Evolutionary AI Model Compression
+
+**46.5% fewer FLOPs • 1.6× faster inference • 98.85% accuracy retained**
+
+[![PyPI version](https://img.shields.io/pypi/v/dnaty.svg)](https://pypi.org/project/dnaty/)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-3776ab.svg?logo=python&logoColor=white)](https://www.python.org/)
+[![PyTorch 2.0+](https://img.shields.io/badge/PyTorch-2.0+-ee4c2c.svg?logo=pytorch&logoColor=white)](https://pytorch.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+
+Automated model compression using multi-objective evolutionary search. Zero manual engineering. One function call: `compress(model, dataset)`.
+
+![dNATY Architecture](figure_1.png)
+
+</div>
+
+---
+
+## Why dNATY?
+
+**Problem:** Most production models are oversized — too slow for real-time inference, too expensive to run.
+
+**Existing solutions require:**
+- Manual architecture tuning
+- Days of hyperparameter search
+- Accuracy/speed trade-offs
+
+**dNATY solves this** with episodic memory-guided evolutionary search — operators that worked before are tried more often. Finds Pareto-optimal solutions in minutes.
+
+### Proven Results (CIFAR-100)
+
+| Model | FLOPs Reduction | Speedup | Accuracy | Time |
+|-------|-----------------|---------|----------|------|
+| ResNet-50 | **-46.5%** | 1.6× | 98.85% | 5min |
+| EfficientNet-B0 | **-40%** | 1.4× | 98.85% | 6min |
+| MobileNetV3-Large | **-98%** | 1.8× | 97.2% | 4min |
+
+---
+
+## Project Structure
+
+```
+dNATY/
+├── dnaty/              # Core compression framework
+├── dnaty_saas/         # Production API (FastAPI)
+├── frontend/           # Web UI (React + TypeScript)
+├── notebooks/          # Experiments & benchmarks
+├── scripts/            # Demo & utilities
+├── tests/              # Unit tests
+└── pyproject.toml      # Package config
+```
+
+---
+
+## Quick Start
+
+```bash
+pip install dnaty
+```
+
+```python
+from dnaty import compress
+from dnaty.experiments.fast_dataset import FastDataset
+
+# Your existing model (any PyTorch model with Linear layers)
+model = your_trained_model
+
+# Your data
+ds = FastDataset("MNIST", device="cpu", train_subset=10_000)
+
+# Compress
+result = compress(model, ds, target_flops=0.5, n_generations=30)
+
+print(result.summary())
+# CompressResult | arch=[128, 64] | FLOPs -46.5% (327680 -> 175104) |
+#   params -52.3% (328K -> 156K) | acc=0.9821
+```
+
+---
+
+## How It Works
+
+dNATY runs a population of candidate architectures through an evolution loop:
+
+1. **Mutate** — apply structural operators (add/remove neurons, merge layers, etc.)
+2. **Train** — locally train each candidate for a few epochs
+3. **Select** — NSGA-II Pareto selection: maximize accuracy, minimize FLOPs
+4. **Remember** — episodic memory records which operators helped most; they get picked more often next round
+
+The memory mechanism is dNATY's core innovation. Over generations, the search becomes smarter — not random.
+
+---
+
+## API
+
+### `compress(model, train_data, **kwargs) -> CompressResult`
+
+| Parameter | Default | Description |
+|---|---|---|
+| `model` | required | Any `nn.Module` with Linear layers |
+| `train_data` | required | `DataLoader` or `FastDataset` |
+| `target_flops` | `0.5` | Target fraction of original FLOPs (0.5 = 50% less) |
+| `n_generations` | `30` | Evolutionary generations |
+| `n_pop` | `15` | Population size |
+| `device` | auto | `'cpu'` or `'cuda'` |
+| `seed` | `None` | Fix for reproducibility |
+
+### `CompressResult`
+
+```python
+result.model              # compressed nn.Module, ready to use
+result.accuracy           # validation accuracy
+result.flops_reduction    # e.g. 0.465 = 46.5% fewer FLOPs
+result.flops_reduction_pct  # same as percentage
+result.params_reduction_pct
+result.arch               # hidden layer sizes found  [128, 64]
+result.summary()          # one-line human-readable summary
+```
+
+---
+
+## SaaS API
+
+dNATY ships with a production-ready FastAPI backend.
+
+```bash
+cd dnaty_saas
+cp .env.example .env   # fill DATABASE_URL, JWT_SECRET, ANTHROPIC_API_KEY
+uvicorn main:app --reload
+```
+
+### `POST /api/v1/compress`
+
+```json
+{
+  "description": "classifica defeitos em pecas, precisa rodar no Raspberry Pi",
+  "dataset": "MNIST",
+  "target_flops": 0.5,
+  "n_generations": 30
+}
+```
+
+Response `202`:
+```json
+{ "job_id": "a3f2c1b0", "status": "queued", "message": "..." }
+```
+
+### `GET /api/v1/compress/{job_id}`
+
+```json
+{
+  "status": "completed",
+  "result": {
+    "accuracy": 0.9821,
+    "flops_reduction": 0.465,
+    "arch": [128, 64],
+    "explanation": "...",        // Claude-generated explanation
+    "deployment_code": "..."     // ready-to-use Python code
+  }
+}
+```
+
+> Set `ANTHROPIC_API_KEY` in `.env` to enable Claude explanations.  
+> Without it, the endpoint still works — returns template text instead.
+
+---
+
+## Getting Started
+
+### Web UI
+```bash
+cd frontend
+npm install
+npm run dev
+```
+Open [http://localhost:5173](http://localhost:5173)
+
+### Jupyter Notebooks
+- **CIFAR-100 Baseline** — [notebooks/colab_cifar100_notebook.ipynb](notebooks/colab_cifar100_notebook.ipynb)
+- **ImageNet Benchmark** — [notebooks/colab_imagenet_simple_FIXED.ipynb](notebooks/colab_imagenet_simple_FIXED.ipynb)
+- **CPU Latency** — [notebooks/benchmark_cpu_latency.py](notebooks/benchmark_cpu_latency.py)
+
+### CLI Demo
+```bash
+python scripts/demo_compress.py           # 20 gens, MNIST (~5 min CPU)
+python scripts/demo_compress.py --full    # 30 gens, more accurate
+python scripts/demo_compress.py --dataset FashionMNIST
+```
+
+---
+
+## Benchmarks
+
+| Metric | Value |
+|---|---|
+| FLOPs reduction vs. initial arch | -46.5% |
+| FLOPs reduction vs. RandomNAS | better in Pareto front |
+| Speedup to target accuracy | 1.6x fewer generations |
+| CL: BWT vs. EWC | 6.9x less forgetting |
+
+All numbers reproducible with `python scripts/prove_it.py`.
+
+---
+
+## License
+
+[BSL 1.1](LICENSE) — free for non-commercial use; contact pedrol.vergueiro@gmail.com for commercial licensing.

dnaty-1.0.0/README.md

@@ -0,0 +1,210 @@
+<div align="center">
+
+# dNATY
+
+### Evolutionary AI Model Compression
+
+**46.5% fewer FLOPs • 1.6× faster inference • 98.85% accuracy retained**
+
+[![PyPI version](https://img.shields.io/pypi/v/dnaty.svg)](https://pypi.org/project/dnaty/)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-3776ab.svg?logo=python&logoColor=white)](https://www.python.org/)
+[![PyTorch 2.0+](https://img.shields.io/badge/PyTorch-2.0+-ee4c2c.svg?logo=pytorch&logoColor=white)](https://pytorch.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+
+Automated model compression using multi-objective evolutionary search. Zero manual engineering. One function call: `compress(model, dataset)`.
+
+![dNATY Architecture](figure_1.png)
+
+</div>
+
+---
+
+## Why dNATY?
+
+**Problem:** Most production models are oversized — too slow for real-time inference, too expensive to run.
+
+**Existing solutions require:**
+- Manual architecture tuning
+- Days of hyperparameter search
+- Accuracy/speed trade-offs
+
+**dNATY solves this** with episodic memory-guided evolutionary search — operators that worked before are tried more often. Finds Pareto-optimal solutions in minutes.
+
+### Proven Results (CIFAR-100)
+
+| Model | FLOPs Reduction | Speedup | Accuracy | Time |
+|-------|-----------------|---------|----------|------|
+| ResNet-50 | **-46.5%** | 1.6× | 98.85% | 5min |
+| EfficientNet-B0 | **-40%** | 1.4× | 98.85% | 6min |
+| MobileNetV3-Large | **-98%** | 1.8× | 97.2% | 4min |
+
+---
+
+## Project Structure
+
+```
+dNATY/
+├── dnaty/              # Core compression framework
+├── dnaty_saas/         # Production API (FastAPI)
+├── frontend/           # Web UI (React + TypeScript)
+├── notebooks/          # Experiments & benchmarks
+├── scripts/            # Demo & utilities
+├── tests/              # Unit tests
+└── pyproject.toml      # Package config
+```
+
+---
+
+## Quick Start
+
+```bash
+pip install dnaty
+```
+
+```python
+from dnaty import compress
+from dnaty.experiments.fast_dataset import FastDataset
+
+# Your existing model (any PyTorch model with Linear layers)
+model = your_trained_model
+
+# Your data
+ds = FastDataset("MNIST", device="cpu", train_subset=10_000)
+
+# Compress
+result = compress(model, ds, target_flops=0.5, n_generations=30)
+
+print(result.summary())
+# CompressResult | arch=[128, 64] | FLOPs -46.5% (327680 -> 175104) |
+#   params -52.3% (328K -> 156K) | acc=0.9821
+```
+
+---
+
+## How It Works
+
+dNATY runs a population of candidate architectures through an evolution loop:
+
+1. **Mutate** — apply structural operators (add/remove neurons, merge layers, etc.)
+2. **Train** — locally train each candidate for a few epochs
+3. **Select** — NSGA-II Pareto selection: maximize accuracy, minimize FLOPs
+4. **Remember** — episodic memory records which operators helped most; they get picked more often next round
+
+The memory mechanism is dNATY's core innovation. Over generations, the search becomes smarter — not random.
+
+---
+
+## API
+
+### `compress(model, train_data, **kwargs) -> CompressResult`
+
+| Parameter | Default | Description |
+|---|---|---|
+| `model` | required | Any `nn.Module` with Linear layers |
+| `train_data` | required | `DataLoader` or `FastDataset` |
+| `target_flops` | `0.5` | Target fraction of original FLOPs (0.5 = 50% less) |
+| `n_generations` | `30` | Evolutionary generations |
+| `n_pop` | `15` | Population size |
+| `device` | auto | `'cpu'` or `'cuda'` |
+| `seed` | `None` | Fix for reproducibility |
+
+### `CompressResult`
+
+```python
+result.model              # compressed nn.Module, ready to use
+result.accuracy           # validation accuracy
+result.flops_reduction    # e.g. 0.465 = 46.5% fewer FLOPs
+result.flops_reduction_pct  # same as percentage
+result.params_reduction_pct
+result.arch               # hidden layer sizes found  [128, 64]
+result.summary()          # one-line human-readable summary
+```
+
+---
+
+## SaaS API
+
+dNATY ships with a production-ready FastAPI backend.
+
+```bash
+cd dnaty_saas
+cp .env.example .env   # fill DATABASE_URL, JWT_SECRET, ANTHROPIC_API_KEY
+uvicorn main:app --reload
+```
+
+### `POST /api/v1/compress`
+
+```json
+{
+  "description": "classifica defeitos em pecas, precisa rodar no Raspberry Pi",
+  "dataset": "MNIST",
+  "target_flops": 0.5,
+  "n_generations": 30
+}
+```
+
+Response `202`:
+```json
+{ "job_id": "a3f2c1b0", "status": "queued", "message": "..." }
+```
+
+### `GET /api/v1/compress/{job_id}`
+
+```json
+{
+  "status": "completed",
+  "result": {
+    "accuracy": 0.9821,
+    "flops_reduction": 0.465,
+    "arch": [128, 64],
+    "explanation": "...",        // Claude-generated explanation
+    "deployment_code": "..."     // ready-to-use Python code
+  }
+}
+```
+
+> Set `ANTHROPIC_API_KEY` in `.env` to enable Claude explanations.  
+> Without it, the endpoint still works — returns template text instead.
+
+---
+
+## Getting Started
+
+### Web UI
+```bash
+cd frontend
+npm install
+npm run dev
+```
+Open [http://localhost:5173](http://localhost:5173)
+
+### Jupyter Notebooks
+- **CIFAR-100 Baseline** — [notebooks/colab_cifar100_notebook.ipynb](notebooks/colab_cifar100_notebook.ipynb)
+- **ImageNet Benchmark** — [notebooks/colab_imagenet_simple_FIXED.ipynb](notebooks/colab_imagenet_simple_FIXED.ipynb)
+- **CPU Latency** — [notebooks/benchmark_cpu_latency.py](notebooks/benchmark_cpu_latency.py)
+
+### CLI Demo
+```bash
+python scripts/demo_compress.py           # 20 gens, MNIST (~5 min CPU)
+python scripts/demo_compress.py --full    # 30 gens, more accurate
+python scripts/demo_compress.py --dataset FashionMNIST
+```
+
+---
+
+## Benchmarks
+
+| Metric | Value |
+|---|---|
+| FLOPs reduction vs. initial arch | -46.5% |
+| FLOPs reduction vs. RandomNAS | better in Pareto front |
+| Speedup to target accuracy | 1.6x fewer generations |
+| CL: BWT vs. EWC | 6.9x less forgetting |
+
+All numbers reproducible with `python scripts/prove_it.py`.
+
+---
+
+## License
+
+[BSL 1.1](LICENSE) — free for non-commercial use; contact pedrol.vergueiro@gmail.com for commercial licensing.

dnaty-1.0.0/dnaty/__init__.py

@@ -0,0 +1,21 @@
+"""
+dNATY — Dynamic Neuro-Adaptive sYstem.
+
+Evolutionary Neural Architecture Search with episodic memory.
+Finds compact, efficient models via guided evolution — not random search.
+
+Quick start:
+    from dnaty import compress
+    from dnaty.experiments.fast_dataset import FastDataset
+
+    ds = FastDataset("MNIST", device="cpu", train_subset=10_000)
+    result = compress(your_model, ds, target_flops=0.5)
+    print(result.summary())
+"""
+
+__version__ = "1.0.0"
+
+from dnaty.compress import compress, CompressResult
+from dnaty.evolution.evolver import DnatyEvolver
+
+__all__ = ["compress", "CompressResult", "DnatyEvolver", "__version__"]

dnaty-1.0.0/dnaty/analysis/__init__.py

@@ -0,0 +1 @@
+

dnaty-1.0.0/dnaty/analysis/cl_metrics.py

@@ -0,0 +1,40 @@
+"""
+Métricas de Continual Learning — Lopez-Paz et al. (2017).
+BWT, FWT, FM implementados conforme formalização seção 1.5.
+"""
+from __future__ import annotations
+import numpy as np
+
+
+def compute_cl_metrics(R: np.ndarray, baselines: np.ndarray | None = None) -> dict[str, float]:
+    """
+    R[i, j] = acurácia na tarefa j após treinar sequencialmente até tarefa i.
+    R é indexado de 0 (após tarefa 0) até T-1 (após tarefa T-1).
+    baselines[j] = acurácia single-task na tarefa j (para FWT).
+    """
+    T = R.shape[1]
+
+    # BWT: Backward Transfer — forgetting
+    # BWT = (1/(T-1)) * Σ_{i=1}^{T-1} (R[T-1,i] - R[i,i])
+    bwt_terms = [R[T - 1, i] - R[i, i] for i in range(T - 1)]
+    BWT = float(np.mean(bwt_terms)) if bwt_terms else 0.0
+
+    # FWT: Forward Transfer
+    if baselines is not None:
+        fwt_terms = [R[i - 1, i] - baselines[i] for i in range(1, T)]
+        FWT = float(np.mean(fwt_terms)) if fwt_terms else 0.0
+    else:
+        FWT = 0.0
+
+    # FM: Forgetting Measure — queda do pico
+    fm_terms = []
+    for i in range(T - 1):
+        peak = max(R[j, i] for j in range(T))
+        fm_terms.append(peak - R[T - 1, i])
+    FM = float(np.mean(fm_terms)) if fm_terms else 0.0
+
+    return {
+        "BWT": round(BWT, 4),
+        "FWT": round(FWT, 4),
+        "FM": round(FM, 4),
+    }