dnaty 5.2.0__py3-none-any.whl

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__ = "5.2.0"
+
+from dnaty.compress import compress, CompressResult
+from dnaty.evolution.evolver import DnatyEvolver
+
+__all__ = ["compress", "CompressResult", "DnatyEvolver", "__version__"]

dnaty/analysis/__init__.py

@@ -0,0 +1 @@
+

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),
+    }

dnaty/compress.py

@@ -0,0 +1,177 @@
+"""
+dNATY compress — public API for model compression via evolutionary NAS.
+
+Usage:
+    from dnaty import compress
+
+    result = compress(model, train_data, target_flops=0.5)
+    print(f"Compressed {result.flops_reduction_pct:.1f}% FLOPs, acc={result.accuracy:.4f}")
+    result.model  # ready-to-use compressed PyTorch model
+"""
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Optional
+
+import torch
+import torch.nn as nn
+
+
+@dataclass
+class CompressResult:
+    model: nn.Module
+    original_flops: int
+    compressed_flops: int
+    original_params: int
+    compressed_params: int
+    accuracy: float
+    flops_reduction: float      # e.g. 0.465 = 46.5% less FLOPs
+    generations: int
+    arch: list[int] = field(default_factory=list)   # hidden layer sizes found
+
+    @property
+    def flops_reduction_pct(self) -> float:
+        return self.flops_reduction * 100
+
+    @property
+    def params_reduction_pct(self) -> float:
+        if self.original_params == 0:
+            return 0.0
+        return (1.0 - self.compressed_params / self.original_params) * 100
+
+    def summary(self) -> str:
+        return (
+            f"CompressResult | arch={self.arch} | "
+            f"FLOPs -{self.flops_reduction_pct:.1f}% "
+            f"({self.original_flops:,} -> {self.compressed_flops:,}) | "
+            f"params -{self.params_reduction_pct:.1f}% "
+            f"({self.original_params:,} -> {self.compressed_params:,}) | "
+            f"acc={self.accuracy:.4f}"
+        )
+
+
+def compress(
+    model: nn.Module,
+    train_data,
+    *,
+    target_flops: float = 0.5,
+    n_generations: int = 30,
+    n_pop: int = 15,
+    device: Optional[str] = None,
+    verbose: bool = True,
+    seed: Optional[int] = None,
+) -> CompressResult:
+    """
+    Find a smaller, faster architecture for the same task using evolutionary NAS.
+
+    dNATY searches architectures guided by episodic memory — operators that
+    helped before are tried more often. The search is Pareto-optimal: it
+    maximises accuracy and minimises FLOPs/params simultaneously.
+
+    Works best with MLP models (nn.Linear layers). The search starts from
+    the architecture inferred from ``model`` and evolves from there.
+
+    Args:
+        model:          Any PyTorch nn.Module containing nn.Linear layers.
+        train_data:     DataLoader or FastDataset used to train and evaluate
+                        candidate architectures.
+        target_flops:   Target FLOPs as fraction of original (0.5 = 50% less).
+                        Controls lambda2 pressure — lower = more compression.
+        n_generations:  Evolutionary generations to run (30 is a good default).
+        n_pop:          Population size (15 balances diversity vs. speed).
+        device:         'cpu' or 'cuda'. Auto-detected when None.
+        verbose:        Print generation-by-generation progress.
+        seed:           Fix for reproducibility.
+
+    Returns:
+        CompressResult with the best model found and compression metrics.
+
+    Example:
+        >>> from dnaty import compress
+        >>> from dnaty.experiments.fast_dataset import FastDataset
+        >>> ds = FastDataset("MNIST", device="cpu", train_subset=10_000)
+        >>> model = ... # your trained PyTorch model
+        >>> result = compress(model, ds, target_flops=0.5, n_generations=30)
+        >>> print(result.summary())
+    """
+    import numpy as np
+    from dnaty.evolution.evolver import DnatyEvolver
+    from dnaty.core.individual import Individual
+
+    if device is None:
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+
+    if seed is not None:
+        torch.manual_seed(seed)
+        np.random.seed(seed)
+
+    layer_sizes = _infer_layer_sizes(model)
+    input_size  = layer_sizes[0]
+    n_classes   = layer_sizes[-1]
+    init_hidden = layer_sizes[1:-1]
+
+    lambda2 = 3e-6  # strong enough to drive real compression, weak enough to preserve acc
+
+    evolver = DnatyEvolver(
+        n_pop=n_pop,
+        n_generations=n_generations,
+        t_local=3,
+        input_size=input_size,
+        n_classes=n_classes,
+        init_hidden=init_hidden,
+        device=device,
+        verbose=verbose,
+        lambda2=lambda2,
+    )
+
+    # Baseline: measure the original model before search
+    orig_ind    = Individual(model)
+    orig_flops  = orig_ind.count_flops()
+    orig_params = orig_ind.count_params()
+
+    # Disable early stopping so all generations run — with large datasets
+    # accuracy plateaus fast and early stop would fire before FLOPs reduction happens.
+    evolver.run(train_data, train_data, early_stop_patience=n_generations)
+
+    # Select most-compressed individual from Pareto population with acc >= 95%.
+    # run() returns max-accuracy individual, but the population contains the full
+    # Pareto front — smaller models that still meet the accuracy floor live there.
+    acc_floor = 0.95
+    candidates = [ind for ind in evolver.population if ind.acc >= acc_floor]
+    if not candidates:
+        candidates = evolver.population
+    best = min(candidates, key=lambda ind: ind.count_flops())
+
+    compressed_flops  = best.count_flops()
+    compressed_params = best.count_params()
+
+    # layer_sizes on DynamicMLP includes input (e.g. [784, 512, 128]).
+    # arch is hidden-only so callers reconstruct with: DynamicMLP([784] + arch, ...)
+    full_sizes = list(getattr(best.model, "layer_sizes", [input_size] + init_hidden))
+    arch = full_sizes[1:]
+
+    return CompressResult(
+        model=best.model,
+        original_flops=orig_flops,
+        compressed_flops=compressed_flops,
+        original_params=orig_params,
+        compressed_params=compressed_params,
+        accuracy=best.acc,
+        flops_reduction=max(0.0, 1.0 - compressed_flops / max(orig_flops, 1)),
+        generations=n_generations,
+        arch=arch,
+    )
+
+
+def _infer_layer_sizes(model: nn.Module) -> list[int]:
+    """Extract [in, h1, h2, ..., out] from a Linear-based model."""
+    sizes: list[int] = []
+    for m in model.modules():
+        if isinstance(m, nn.Linear):
+            if not sizes:
+                sizes.append(m.in_features)
+            sizes.append(m.out_features)
+    if len(sizes) < 2:
+        raise ValueError(
+            "Cannot infer architecture: model must contain at least one nn.Linear layer."
+        )
+    return sizes

dnaty/core/__init__.py

@@ -0,0 +1 @@
+

dnaty/core/arch.py

@@ -0,0 +1,85 @@
+"""
+Representação da arquitetura como grafo dirigido acíclico (DAG).
+A_i = (V_i, E_i, φ_i, Ω_i)
+"""
+from __future__ import annotations
+import torch
+import torch.nn as nn
+import numpy as np
+from copy import deepcopy
+
+
+ACTIVATIONS = {
+    "relu": nn.ReLU,
+    "tanh": nn.Tanh,
+    "gelu": nn.GELU,
+    "sigmoid": nn.Sigmoid,
+}
+
+_innovation_counter = 0
+
+
+def next_innovation() -> int:
+    global _innovation_counter
+    _innovation_counter += 1
+    return _innovation_counter
+
+
+class DynamicMLP(nn.Module):
+    """
+    MLP com arquitetura mutável. Representado como lista de camadas lineares.
+    Suporta os 8 operadores densos + skip connections.
+    """
+
+    def __init__(self, layer_sizes: list[int], activations: list[str] | None = None, n_classes: int = 10):
+        super().__init__()
+        self.layer_sizes = list(layer_sizes)
+        self.n_classes = n_classes
+        self.activations = activations or ["relu"] * (len(layer_sizes) - 1)
+        self.innovation_ids = [next_innovation() for _ in range(len(layer_sizes) - 1)]
+        self._build()
+
+    def _build(self) -> None:
+        layers = []
+        for i in range(len(self.layer_sizes) - 1):
+            layers.append(nn.Linear(self.layer_sizes[i], self.layer_sizes[i + 1]))
+            # BatchNorm antes da ativação — estabiliza treino, permite LR maior
+            layers.append(nn.BatchNorm1d(self.layer_sizes[i + 1]))
+            act = self.activations[i] if i < len(self.activations) else "relu"
+            layers.append(ACTIVATIONS.get(act, nn.ReLU)())
+        layers.append(nn.Linear(self.layer_sizes[-1], self.n_classes))
+        self.net = nn.Sequential(*layers)
+        self.skip_connections: list[tuple[int, int, nn.Linear]] = []
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = x.view(x.size(0), -1)
+        layer_outputs = [x]
+        idx = 0
+        for i in range(len(self.layer_sizes) - 1):
+            linear = self.net[idx]
+            bn     = self.net[idx + 1]
+            act    = self.net[idx + 2]
+            out = act(bn(linear(layer_outputs[-1])))
+            for src, dst, proj in self.skip_connections:
+                if dst == i + 1 and src < len(layer_outputs):
+                    skip_in = layer_outputs[src]
+                    if proj is not None:
+                        skip_in = proj(skip_in)
+                    if skip_in.shape == out.shape:
+                        out = out + skip_in
+            layer_outputs.append(out)
+            idx += 3  # Linear + BN + Activation
+        return self.net[idx](layer_outputs[-1])
+
+    def count_params(self) -> int:
+        return sum(p.numel() for p in self.parameters())
+
+    def count_flops(self) -> int:
+        flops = 0
+        for i in range(len(self.layer_sizes) - 1):
+            flops += 2 * self.layer_sizes[i] * self.layer_sizes[i + 1]
+        flops += 2 * self.layer_sizes[-1] * self.n_classes
+        return flops
+
+    def is_valid(self) -> bool:
+        return all(s > 0 for s in self.layer_sizes) and len(self.layer_sizes) >= 2

dnaty/core/arch_cnn.py

@@ -0,0 +1,140 @@
+"""
+DynamicCNN — arquitetura CNN mutável para CIFAR-10.
+Suporta blocos Conv2D+BN+ReLU e depthwise separable.
+"""
+from __future__ import annotations
+import torch
+import torch.nn as nn
+import numpy as np
+from copy import deepcopy
+
+
+class ConvBlock(nn.Module):
+    """Conv2D + BatchNorm + ReLU — bloco padrão."""
+    def __init__(self, in_ch: int, out_ch: int, kernel: int = 3, stride: int = 1):
+        super().__init__()
+        pad = kernel // 2
+        self.block = nn.Sequential(
+            nn.Conv2d(in_ch, out_ch, kernel, stride=stride, padding=pad, bias=False),
+            nn.BatchNorm2d(out_ch),
+            nn.ReLU(inplace=True),
+        )
+        self.in_ch = in_ch
+        self.out_ch = out_ch
+        self.stride = stride
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.block(x)
+
+
+class DepthwiseSepBlock(nn.Module):
+    """Depthwise Separable Conv — MobileNet style. k² vezes menos FLOPs."""
+    def __init__(self, in_ch: int, out_ch: int, stride: int = 1):
+        super().__init__()
+        self.block = nn.Sequential(
+            # Depthwise
+            nn.Conv2d(in_ch, in_ch, 3, stride=stride, padding=1, groups=in_ch, bias=False),
+            nn.BatchNorm2d(in_ch),
+            nn.ReLU(inplace=True),
+            # Pointwise
+            nn.Conv2d(in_ch, out_ch, 1, bias=False),
+            nn.BatchNorm2d(out_ch),
+            nn.ReLU(inplace=True),
+        )
+        self.in_ch = in_ch
+        self.out_ch = out_ch
+        self.stride = stride
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.block(x)
+
+
+class DynamicCNN(nn.Module):
+    """
+    CNN com arquitetura mutável para CIFAR-10 (32×32×3).
+    Estrutura: [ConvBlocks] → GlobalAvgPool → [FC layers] → classifier
+    """
+
+    def __init__(
+        self,
+        conv_configs: list[dict] | None = None,
+        fc_sizes: list[int] | None = None,
+        n_classes: int = 10,
+        in_channels: int = 3,
+    ):
+        super().__init__()
+        self.n_classes = n_classes
+        self.in_channels = in_channels
+
+        # Config padrão: 3 blocos conv progressivos
+        if conv_configs is None:
+            conv_configs = [
+                {"type": "conv", "in_ch": 3,  "out_ch": 32, "stride": 1},
+                {"type": "conv", "in_ch": 32, "out_ch": 64, "stride": 2},
+                {"type": "conv", "in_ch": 64, "out_ch": 64, "stride": 2},
+            ]
+        if fc_sizes is None:
+            fc_sizes = [128]
+
+        self.conv_configs = list(conv_configs)
+        self.fc_sizes = list(fc_sizes)
+        self._build()
+
+    def _build(self) -> None:
+        # Blocos convolucionais
+        conv_layers = []
+        for cfg in self.conv_configs:
+            if cfg["type"] == "depthwise":
+                conv_layers.append(DepthwiseSepBlock(cfg["in_ch"], cfg["out_ch"], cfg.get("stride", 1)))
+            else:
+                conv_layers.append(ConvBlock(cfg["in_ch"], cfg["out_ch"], cfg.get("kernel", 3), cfg.get("stride", 1)))
+        self.conv_layers = nn.ModuleList(conv_layers)
+        self.pool = nn.AdaptiveAvgPool2d(1)  # → (B, C, 1, 1)
+
+        # Camadas FC
+        last_ch = self.conv_configs[-1]["out_ch"] if self.conv_configs else self.in_channels
+        fc_layers = []
+        prev = last_ch
+        for h in self.fc_sizes:
+            fc_layers += [nn.Linear(prev, h), nn.ReLU(inplace=True)]
+            prev = h
+        self.fc = nn.Sequential(*fc_layers)
+        self.classifier = nn.Linear(prev, self.n_classes)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        for layer in self.conv_layers:
+            x = layer(x)
+        x = self.pool(x)
+        x = x.view(x.size(0), -1)
+        x = self.fc(x)
+        return self.classifier(x)
+
+    def count_params(self) -> int:
+        return sum(p.numel() for p in self.parameters())
+
+    def count_flops(self) -> int:
+        """Estimativa de FLOPs para input 32×32."""
+        flops = 0
+        h, w = 32, 32
+        for cfg in self.conv_configs:
+            k = cfg.get("kernel", 3)
+            s = cfg.get("stride", 1)
+            if cfg["type"] == "depthwise":
+                # Depthwise: k²×C_in×H×W + C_in×C_out×H×W (pointwise)
+                flops += k * k * cfg["in_ch"] * (h // s) * (w // s)
+                flops += cfg["in_ch"] * cfg["out_ch"] * (h // s) * (w // s)
+            else:
+                flops += k * k * cfg["in_ch"] * cfg["out_ch"] * (h // s) * (w // s)
+            h, w = h // s, w // s
+        last_ch = self.conv_configs[-1]["out_ch"] if self.conv_configs else self.in_channels
+        prev = last_ch
+        for sz in self.fc_sizes:
+            flops += 2 * prev * sz
+            prev = sz
+        flops += 2 * prev * self.n_classes
+        return flops
+
+    def is_valid(self) -> bool:
+        return len(self.conv_configs) >= 1 and all(
+            c["in_ch"] > 0 and c["out_ch"] > 0 for c in self.conv_configs
+        )

dnaty/core/individual.py

@@ -0,0 +1,34 @@
+"""
+Indivíduo dNaty: M_i = (θ_i, A_i, 𝓜_i)
+"""
+from __future__ import annotations
+from copy import deepcopy
+import torch
+from dnaty.core.arch import DynamicMLP
+from dnaty.core.memory import EpisodicMemory
+
+
+class Individual:
+    def __init__(self, model: DynamicMLP, memory: EpisodicMemory | None = None):
+        self.model = model
+        self.memory = memory or EpisodicMemory()
+        self.last_op: str = "init"
+        self.fitness: tuple[float, float, float] = (0.0, 0.0, 0.0)  # (acc, -cost, -sharp)
+        self.acc: float = 0.0
+        self.last_grad_norm: float = 0.0
+        self.last_delta_loss: float = 0.0
+
+    def clone(self) -> "Individual":
+        new_model = deepcopy(self.model)
+        new_mem = deepcopy(self.memory)
+        ind = Individual(new_model, new_mem)
+        ind.last_op = self.last_op
+        ind.fitness = self.fitness
+        ind.acc = self.acc
+        return ind
+
+    def count_params(self) -> int:
+        return self.model.count_params()
+
+    def count_flops(self) -> int:
+        return self.model.count_flops()

dnaty/core/memory.py

@@ -0,0 +1,88 @@
+"""
+EpisodicMemory — componente central do dNaty.
+Implementa eq. 1.4: acumulação com decaimento temporal γ.
+Otimizado: scores acumulados incrementalmente (O(1) por update vs O(n) antes).
+"""
+from __future__ import annotations
+from dataclasses import dataclass
+import numpy as np
+
+
+@dataclass
+class Experience:
+    operator: str
+    delta_loss: float
+    gradient_norm: float
+    generation: int
+    weight: float = 1.0
+    timestamp: int = 0
+
+    @property
+    def impact(self) -> float:
+        """𝟙[ΔL < 0] · |ΔL| · ‖∇L‖ — só experiências que melhoraram."""
+        if self.delta_loss >= 0:
+            return 0.0
+        return abs(self.delta_loss) * self.gradient_norm
+
+
+class EpisodicMemory:
+    """
+    Memória episódica com decaimento temporal γ.
+    Scores acumulados incrementalmente — O(1) por update, O(|ops|) por query.
+    """
+
+    def __init__(self, max_size: int = 500, decay_gamma: float = 0.99):
+        self.experiences: list[Experience] = []
+        self.max_size = max_size
+        self.gamma = decay_gamma
+        self._step = 0
+        # Scores acumulados por operador — atualização incremental
+        self._scores: dict[str, float] = {}
+
+    def update(self, exp: Experience) -> None:
+        # Decaimento global dos scores acumulados — O(|ops|) não O(|mem|)
+        for op in self._scores:
+            self._scores[op] *= self.gamma
+
+        imp = exp.impact
+        if imp > 0:
+            self._scores[exp.operator] = self._scores.get(exp.operator, 0.0) + imp
+
+        exp.timestamp = self._step
+        self._step += 1
+        self.experiences.append(exp)
+
+        if len(self.experiences) > self.max_size:
+            self._prune()
+
+    def _prune(self) -> None:
+        # Remove as experiências mais antigas/irrelevantes
+        # Recalcula scores do zero após prune
+        self.experiences.sort(
+            key=lambda e: e.impact * (self.gamma ** max(0, self._step - e.timestamp)),
+            reverse=True,
+        )
+        self.experiences = self.experiences[:self.max_size]
+        # Recalcular scores
+        self._scores = {}
+        for e in self.experiences:
+            if e.impact > 0:
+                decay = self.gamma ** max(0, self._step - e.timestamp)
+                self._scores[e.operator] = self._scores.get(e.operator, 0.0) + e.impact * decay
+
+    def query_mutation_probs(self, operators: list[str], tau: float = 1.0) -> dict[str, float]:
+        """Softmax sobre scores acumulados — O(|ops|)."""
+        vals = np.array(
+            [self._scores.get(op, 0.0) for op in operators], dtype=np.float64
+        ) / max(tau, 1e-8)
+        vals -= vals.max()
+        exp_vals = np.exp(vals)
+        probs = exp_vals / exp_vals.sum()
+        return {op: float(p) for op, p in zip(operators, probs)}
+
+    def operator_counts(self, operators: list[str]) -> dict[str, int]:
+        counts: dict[str, int] = {op: 0 for op in operators}
+        for e in self.experiences:
+            if e.operator in counts and e.impact > 0:
+                counts[e.operator] += 1
+        return counts

dnaty/evolution/__init__.py

@@ -0,0 +1 @@
+