bioopt 0.1.0__py3-none-any.whl

bioopt/__init__.py

@@ -0,0 +1,37 @@
+"""bioopt - Bio-inspired optimization algorithms.
+
+A collection of nature-inspired optimization algorithms for
+machine learning and scientific computing.
+
+Categories:
+    - swarm: Swarm intelligence algorithms (PSO, ACO, ABC, GWO, FA, WOA)
+    - evolutionary: Evolutionary algorithms (coming soon)
+    - physics: Physics-based algorithms (coming soon)
+
+Usage:
+    >>> from bioopt.swarm import PSO
+    >>> pso = PSO(n_agents=30, bounds=[(-5, 5)] * 10)
+    >>> best_pos, best_fit = pso.optimize(objective_fn, iterations=100)
+"""
+
+__version__ = "0.1.0"
+__author__ = "Rehan Guha"
+
+from bioopt.base import BaseOptimizer, BoundsError, OptimizationError
+from bioopt.utils import (
+    BenchmarkFunctions,
+    flatten_params,
+    make_bounds_uniform,
+    unflatten_params,
+)
+
+__all__ = [
+    "__version__",
+    "BaseOptimizer",
+    "BoundsError",
+    "OptimizationError",
+    "BenchmarkFunctions",
+    "flatten_params",
+    "unflatten_params",
+    "make_bounds_uniform",
+]

bioopt/adapters/__init__.py

@@ -0,0 +1,6 @@
+"""Adapters for deep learning frameworks.
+
+Optional adapters for integrating biopt optimizers with:
+- PyTorch (bioopt.adapters.pytorch)
+- TensorFlow (bioopt.adapters.tensorflow)
+"""

bioopt/adapters/pytorch.py

@@ -0,0 +1,89 @@
+"""PyTorch adapter for biopt optimization algorithms."""
+
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+import numpy as np
+
+try:
+    import torch
+    import torch.nn as nn
+    from torch.utils.data import DataLoader
+except ImportError:
+    raise ImportError("PyTorch is required. Install with: pip install bioopt[pytorch]")
+
+from bioopt.base import BaseOptimizer
+from bioopt.utils import flatten_params, unflatten_params
+
+
+class PyTorchAdapter:
+    """Adapter for using biopt optimizers with PyTorch models."""
+
+    def __init__(self, model: nn.Module, device: Optional[str] = None):
+        self.model = model
+        self.device = device or next(model.parameters()).device
+        self.param_shapes: Dict[str, Tuple[int, ...]] = {}
+        self.param_names: List[str] = []
+        for name, param in model.named_parameters():
+            self.param_shapes[name] = param.shape
+            self.param_names.append(name)
+        self.n_params = sum(int(np.prod(s)) for s in self.param_shapes.values())
+
+    def flat_to_model(self, flat_weights: np.ndarray) -> None:
+        if len(flat_weights) != self.n_params:
+            raise ValueError(f"Expected {self.n_params} parameters, got {len(flat_weights)}")
+        shapes = [self.param_shapes[name] for name in self.param_names]
+        param_list = unflatten_params(flat_weights, shapes)
+        with torch.no_grad():
+            for i, (name, param) in enumerate(self.model.named_parameters()):
+                param.copy_(torch.from_numpy(param_list[i]).to(dtype=param.dtype, device=self.device))
+
+    def model_to_flat(self) -> np.ndarray:
+        params = [p.detach().cpu().numpy() for _, p in self.model.named_parameters()]
+        return flatten_params(params)
+
+    def get_bounds(self, default_low: float = -5.0, default_high: float = 5.0,
+                   per_param_bounds: Optional[Dict[str, Tuple[float, float]]] = None) -> List[Tuple[float, float]]:
+        bounds = []
+        for name in self.param_names:
+            n_elements = int(np.prod(self.param_shapes[name]))
+            if per_param_bounds and name in per_param_bounds:
+                low, high = per_param_bounds[name]
+            else:
+                low, high = default_low, default_high
+            bounds.extend([(low, high)] * n_elements)
+        return bounds
+
+    def evaluate(self, flat_weights: np.ndarray, loss_fn: Callable,
+                 dataloader: Optional[DataLoader] = None,
+                 inputs: Optional[torch.Tensor] = None,
+                 targets: Optional[torch.Tensor] = None, **kwargs) -> float:
+        self.flat_to_model(flat_weights)
+        self.model.eval()
+        with torch.no_grad():
+            if dataloader is not None:
+                total_loss, n_batches = 0.0, 0
+                for batch_inputs, batch_targets in dataloader:
+                    outputs = self.model(batch_inputs.to(self.device))
+                    loss = loss_fn(outputs, batch_targets.to(self.device), **kwargs)
+                    total_loss += loss.item() if isinstance(loss, torch.Tensor) else float(loss)
+                    n_batches += 1
+                return total_loss / n_batches if n_batches > 0 else float("inf")
+            elif inputs is not None and targets is not None:
+                outputs = self.model(inputs.to(self.device))
+                loss = loss_fn(outputs, targets.to(self.device), **kwargs)
+                return loss.item() if isinstance(loss, torch.Tensor) else float(loss)
+            else:
+                loss = loss_fn(self.model, dataloader, **kwargs)
+                return loss.item() if isinstance(loss, torch.Tensor) else float(loss)
+
+    def optimize(self, optimizer: BaseOptimizer, loss_fn: Callable,
+                 dataloader: Optional[DataLoader] = None,
+                 inputs: Optional[torch.Tensor] = None,
+                 targets: Optional[torch.Tensor] = None,
+                 iterations: int = 100, verbose: bool = False,
+                 callback: Optional[Callable] = None, **kwargs) -> Tuple[np.ndarray, float]:
+        def objective_fn(flat_weights: np.ndarray) -> float:
+            return self.evaluate(flat_weights, loss_fn, dataloader, inputs, targets)
+        best_weights, best_loss = optimizer.optimize(objective_fn, iterations=iterations, verbose=verbose, callback=callback, **kwargs)
+        self.flat_to_model(best_weights)
+        return best_weights, best_loss

bioopt/adapters/tensorflow.py

@@ -0,0 +1,263 @@
+"""TensorFlow adapter for bioopt optimization algorithms.
+
+Provides integration with TensorFlow/Keras models by converting model parameters
+to flat vectors and back, enabling gradient-free optimization of neural networks.
+
+Usage:
+    >>> from bioopt.swarm import PSO
+    >>> from bioopt.adapters.tensorflow import TensorFlowAdapter
+    >>> 
+    >>> model = tf.keras.Sequential([...])
+    >>> adapter = TensorFlowAdapter(model)
+    >>> 
+    >>> pso = PSO(n_agents=30, bounds=adapter.get_bounds())
+    >>> best_weights, best_loss = adapter.optimize(
+    ...     pso, loss_fn, dataset, iterations=50
+    ... )
+"""
+
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+import numpy as np
+
+try:
+    import tensorflow as tf
+    from tensorflow import keras
+except ImportError:
+    raise ImportError(
+        "TensorFlow is required for this module. Install with: pip install bioopt[tensorflow]"
+    )
+
+from bioopt.base import BaseOptimizer
+from bioopt.utils import flatten_params, unflatten_params
+
+
+class TensorFlowAdapter:
+    """Adapter for using biopt optimizers with TensorFlow/Keras models.
+    
+    Converts TensorFlow model parameters to/from flat numpy arrays
+    so that swarm intelligence algorithms can optimize them.
+    
+    Parameters
+    ----------
+    model : tf.keras.Model
+        TensorFlow/Keras model to optimize.
+        
+    Attributes
+    ----------
+    model : tf.keras.Model
+        Reference to the model being optimized.
+    param_shapes : dict
+        Dictionary mapping parameter names to their shapes.
+    n_params : int
+        Total number of parameters in the model.
+    """
+    
+    def __init__(self, model: keras.Model):
+        self.model = model
+        self.param_shapes: Dict[str, Tuple[int, ...]] = {}
+        self.param_names: List[str] = []
+        
+        for var in model.trainable_variables:
+            self.param_shapes[var.name] = var.shape
+            self.param_names.append(var.name)
+        
+        self.n_params = sum(int(np.prod(s)) for s in self.param_shapes.values())
+    
+    def get_weights_list(self) -> List[np.ndarray]:
+        """Get model weights as a list of numpy arrays."""
+        return [w.numpy() for w in self.model.trainable_variables]
+    
+    def flat_to_model(self, flat_weights: np.ndarray) -> None:
+        """Set model parameters from a flat array.
+        
+        Parameters
+        ----------
+        flat_weights : ndarray of shape (n_params,)
+            Flattened parameter vector.
+        """
+        if len(flat_weights) != self.n_params:
+            raise ValueError(
+                f"Expected {self.n_params} parameters, got {len(flat_weights)}"
+            )
+        
+        shapes = [self.param_shapes[name] for name in self.param_names]
+        param_list = unflatten_params(flat_weights, shapes)
+        
+        for i, var in enumerate(self.model.trainable_variables):
+            var.assign(tf.constant(param_list[i], dtype=var.dtype))
+    
+    def model_to_flat(self) -> np.ndarray:
+        """Get current model parameters as a flat array.
+        
+        Returns
+        -------
+        flat : ndarray of shape (n_params,)
+            Flattened parameter vector.
+        """
+        weights = self.get_weights_list()
+        return flatten_params(weights)
+    
+    def get_bounds(
+        self,
+        default_low: float = -5.0,
+        default_high: float = 5.0,
+        per_param_bounds: Optional[Dict[str, Tuple[float, float]]] = None,
+    ) -> List[Tuple[float, float]]:
+        """Get bounds for all model parameters.
+        
+        Parameters
+        ----------
+        default_low : float
+            Default lower bound.
+        default_high : float
+            Default upper bound.
+        per_param_bounds : dict, optional
+            Per-parameter bounds as {name: (low, high)}.
+            Parameters not specified use default bounds.
+            
+        Returns
+        -------
+        bounds : list of tuples
+            Bounds for each parameter in flat array.
+        """
+        bounds = []
+        for name in self.param_names:
+            shape = self.param_shapes[name]
+            n_elements = int(np.prod(shape))
+            
+            if per_param_bounds and name in per_param_bounds:
+                low, high = per_param_bounds[name]
+            else:
+                low, high = default_low, default_high
+            
+            bounds.extend([(low, high)] * n_elements)
+        
+        return bounds
+    
+    def evaluate(
+        self,
+        flat_weights: np.ndarray,
+        loss_fn: Callable,
+        dataset: Optional[tf.data.Dataset] = None,
+        inputs: Optional[tf.Tensor] = None,
+        targets: Optional[tf.Tensor] = None,
+        **kwargs
+    ) -> float:
+        """Evaluate the model with given weights on a loss function.
+        
+        Parameters
+        ----------
+        flat_weights : ndarray
+            Flattened parameter vector.
+        loss_fn : callable
+            Loss function. Can be:
+            - A function that takes (outputs, targets) and returns loss
+            - A function that takes (model, dataset) and returns loss
+        dataset : tf.data.Dataset, optional
+            Dataset for evaluation.
+        inputs : tf.Tensor, optional
+            Input tensor for direct evaluation.
+        targets : tf.Tensor, optional
+            Target tensor for direct evaluation.
+        **kwargs : dict
+            Additional arguments passed to loss_fn.
+            
+        Returns
+        -------
+        loss : float
+            Computed loss value.
+        """
+        self.flat_to_model(flat_weights)
+        
+        if dataset is not None:
+            total_loss = 0.0
+            n_batches = 0
+            for batch_inputs, batch_targets in dataset:
+                outputs = self.model(batch_inputs, training=False)
+                loss = loss_fn(outputs, batch_targets, **kwargs)
+                if isinstance(loss, tf.Tensor):
+                    loss = loss.numpy()
+                total_loss += float(loss)
+                n_batches += 1
+            return total_loss / n_batches if n_batches > 0 else float("inf")
+        
+        elif inputs is not None and targets is not None:
+            outputs = self.model(inputs, training=False)
+            loss = loss_fn(outputs, targets, **kwargs)
+            if isinstance(loss, tf.Tensor):
+                loss = loss.numpy()
+            return float(loss)
+        
+        else:
+            loss = loss_fn(self.model, dataset, **kwargs)
+            if isinstance(loss, tf.Tensor):
+                loss = loss.numpy()
+            return float(loss)
+    
+    def optimize(
+        self,
+        optimizer: BaseOptimizer,
+        loss_fn: Callable,
+        dataset: Optional[tf.data.Dataset] = None,
+        inputs: Optional[tf.Tensor] = None,
+        targets: Optional[tf.Tensor] = None,
+        iterations: int = 100,
+        verbose: bool = False,
+        callback: Optional[Callable] = None,
+        **kwargs
+    ) -> Tuple[np.ndarray, float]:
+        """Run optimizer to find best model weights.
+        
+        Parameters
+        ----------
+        optimizer : BaseOptimizer
+            A biopt optimizer (PSO, GWO, etc.).
+        loss_fn : callable
+            Loss function for evaluation.
+        dataset : tf.data.Dataset, optional
+            Dataset for evaluation.
+        inputs : tf.Tensor, optional
+            Input tensor for direct evaluation.
+        targets : tf.Tensor, optional
+            Target tensor for direct evaluation.
+        iterations : int
+            Number of optimization iterations.
+        verbose : bool
+            Print progress.
+        callback : callable, optional
+            Callback function called with (iteration, best_weights, best_loss).
+        **kwargs : dict
+            Additional arguments passed to optimizer.optimize().
+            
+        Returns
+        -------
+        best_weights : ndarray
+            Best parameter vector found.
+        best_loss : float
+            Best loss achieved.
+        """
+        def objective_fn(flat_weights: np.ndarray) -> float:
+            return self.evaluate(flat_weights, loss_fn, dataset, inputs, targets)
+        
+        best_weights, best_loss = optimizer.optimize(
+            objective_fn, iterations=iterations, verbose=verbose, callback=callback, **kwargs
+        )
+        
+        self.flat_to_model(best_weights)
+        
+        return best_weights, best_loss
+    
+    def get_weight_statistics(self) -> Dict[str, Any]:
+        """Get statistics about current model weights."""
+        stats = {}
+        for var in self.model.trainable_variables:
+            w = var.numpy()
+            stats[var.name] = {
+                "mean": float(np.mean(w)),
+                "std": float(np.std(w)),
+                "min": float(np.min(w)),
+                "max": float(np.max(w)),
+                "norm": float(np.linalg.norm(w)),
+            }
+        return stats

bioopt/base.py

@@ -0,0 +1,251 @@
+"""Base optimizer class for bio-inspired optimization algorithms."""
+
+from abc import ABC, abstractmethod
+from typing import Callable, List, Optional, Tuple, Union
+
+import numpy as np
+
+
+class BoundsError(Exception):
+    """Raised when bounds are invalid."""
+    pass
+
+
+class OptimizationError(Exception):
+    """Raised when optimization fails."""
+    pass
+
+
+class BaseOptimizer(ABC):
+    """
+    Abstract base class for all bio-inspired optimization algorithms.
+    
+    Provides a common interface with bounds handling, fitness tracking,
+    and a standardized optimize() method.
+    
+    Parameters
+    ----------
+    n_agents : int
+        Number of agents/particles/solutions in the population.
+    bounds : list of tuple
+        Search space bounds as [(min, max), ...] for each dimension.
+    seed : int, optional
+        Random seed for reproducibility.
+        
+    Attributes
+    ----------
+    best_position : ndarray
+        Best position found during optimization.
+    best_fitness : float
+        Best fitness value found during optimization.
+    fitness_history : list
+        History of best fitness values per iteration.
+    """
+
+    def __init__(
+        self,
+        n_agents: int,
+        bounds: Union[List[Tuple[float, float]], np.ndarray],
+        seed: Optional[int] = None,
+    ):
+        self.n_agents = n_agents
+        self.bounds = np.array(bounds, dtype=np.float64)
+        self.seed = seed
+        self.rng = np.random.RandomState(seed)
+        
+        self.best_position: Optional[np.ndarray] = None
+        self.best_fitness: float = np.inf
+        self.fitness_history: List[float] = []
+        
+        self._validate_bounds()
+    
+    def _validate_bounds(self):
+        """Validate that bounds are properly formatted."""
+        if self.bounds.ndim != 2 or self.bounds.shape[1] != 2:
+            raise BoundsError(
+                f"Bounds must be 2D with shape (n_dims, 2), got {self.bounds.shape}"
+            )
+        if np.any(self.bounds[:, 0] >= self.bounds[:, 1]):
+            raise BoundsError("All lower bounds must be less than upper bounds.")
+    
+    @property
+    def n_dims(self) -> int:
+        """Number of dimensions in the search space."""
+        return self.bounds.shape[0]
+    
+    def initialize_population(self) -> np.ndarray:
+        """
+        Initialize population uniformly within bounds.
+        
+        Returns
+        -------
+        population : ndarray of shape (n_agents, n_dims)
+        """
+        return self.rng.uniform(
+            self.bounds[:, 0],
+            self.bounds[:, 1],
+            size=(self.n_agents, self.n_dims)
+        )
+    
+    def clip_to_bounds(self, positions: np.ndarray) -> np.ndarray:
+        """
+        Clip positions to stay within bounds.
+        
+        Parameters
+        ----------
+        positions : ndarray of shape (n_agents, n_dims)
+        
+        Returns
+        -------
+        clipped : ndarray of same shape
+        """
+        return np.clip(positions, self.bounds[:, 0], self.bounds[:, 1])
+    
+    def evaluate(
+        self,
+        positions: np.ndarray,
+        objective_fn: Callable[[np.ndarray], float]
+    ) -> np.ndarray:
+        """
+        Evaluate fitness for all positions.
+        
+        Parameters
+        ----------
+        positions : ndarray of shape (n_agents, n_dims)
+        objective_fn : callable
+            Function that takes a 1D array and returns a scalar fitness value.
+            
+        Returns
+        -------
+        fitness : ndarray of shape (n_agents,)
+        """
+        return np.array([objective_fn(pos) for pos in positions])
+    
+    def update_best(
+        self,
+        positions: np.ndarray,
+        fitness: np.ndarray
+    ) -> None:
+        """
+        Update global best position and fitness.
+        
+        Parameters
+        ----------
+        positions : ndarray of shape (n_agents, n_dims)
+        fitness : ndarray of shape (n_agents,)
+        """
+        best_idx = np.argmin(fitness)
+        if fitness[best_idx] < self.best_fitness:
+            self.best_fitness = float(fitness[best_idx])
+            self.best_position = positions[best_idx].copy()
+    
+    @abstractmethod
+    def step(
+        self,
+        positions: np.ndarray,
+        fitness: np.ndarray,
+        iteration: int,
+        **kwargs
+    ) -> np.ndarray:
+        """
+        Perform one iteration step of the algorithm.
+        
+        Parameters
+        ----------
+        positions : ndarray of shape (n_agents, n_dims)
+            Current positions of all agents.
+        fitness : ndarray of shape (n_agents,)
+            Current fitness values.
+        iteration : int
+            Current iteration number.
+        **kwargs : dict
+            Additional algorithm-specific parameters.
+            
+        Returns
+        -------
+        new_positions : ndarray of shape (n_agents, n_dims)
+        """
+        pass
+    
+    def optimize(
+        self,
+        objective_fn: Callable[[np.ndarray], float],
+        iterations: int = 100,
+        verbose: bool = False,
+        callback: Optional[Callable[[int, np.ndarray, float], None]] = None,
+        **kwargs
+    ) -> Tuple[np.ndarray, float]:
+        """
+        Run the optimization.
+        
+        Parameters
+        ----------
+        objective_fn : callable
+            The objective function to minimize. Takes a 1D array and returns a scalar.
+        iterations : int
+            Number of iterations to run.
+        verbose : bool
+            If True, print progress information.
+        callback : callable, optional
+            Function called after each iteration with signature
+            (iteration, best_position, best_fitness).
+        **kwargs : dict
+            Additional algorithm-specific parameters.
+            
+        Returns
+        -------
+        best_position : ndarray
+            Best position found.
+        best_fitness : float
+            Best fitness value found.
+        """
+        # Initialize
+        positions = self.initialize_population()
+        fitness = self.evaluate(positions, objective_fn)
+        self.update_best(positions, fitness)
+        self.fitness_history = [self.best_fitness]
+        
+        if verbose:
+            print(f"Iter 0: Best Fitness = {self.best_fitness:.6e}")
+        
+        if callback is not None:
+            callback(0, self.best_position, self.best_fitness)
+        
+        # Main loop
+        for i in range(1, iterations + 1):
+            positions = self.step(positions, fitness, i, **kwargs)
+            positions = self.clip_to_bounds(positions)
+            fitness = self.evaluate(positions, objective_fn)
+            self.update_best(positions, fitness)
+            self.fitness_history.append(self.best_fitness)
+            
+            if verbose:
+                print(f"Iter {i}: Best Fitness = {self.best_fitness:.6e}")
+            
+            if callback is not None:
+                callback(i, self.best_position, self.best_fitness)
+        
+        return self.best_position, self.best_fitness
+    
+    def reset(self) -> None:
+        """Reset optimizer state for a fresh optimization run."""
+        self.best_position = None
+        self.best_fitness = np.inf
+        self.fitness_history = []
+        self.rng = np.random.RandomState(self.seed)
+    
+    def get_state(self) -> dict:
+        """Get optimizer state for checkpointing."""
+        return {
+            "best_position": self.best_position,
+            "best_fitness": self.best_fitness,
+            "fitness_history": self.fitness_history,
+            "rng_state": self.rng.get_state(),
+        }
+    
+    def set_state(self, state: dict) -> None:
+        """Restore optimizer state from checkpoint."""
+        self.best_position = state["best_position"]
+        self.best_fitness = state["best_fitness"]
+        self.fitness_history = state["fitness_history"]
+        self.rng.set_state(state["rng_state"])

bioopt/swarm/__init__.py

@@ -0,0 +1,31 @@
+"""Swarm intelligence algorithms.
+
+Available algorithms:
+- PSO: Particle Swarm Optimization
+- ACO: Ant Colony Optimization (Continuous, using KDE)
+- ABC: Artificial Bee Colony
+- GWO: Grey Wolf Optimizer
+- FA: Firefly Algorithm
+- WOA: Whale Optimization Algorithm
+
+Usage:
+    >>> from bioopt.swarm import PSO, ACO, GWO
+    >>> pso = PSO(n_agents=30, bounds=[(-5, 5)] * 10)
+    >>> best_pos, best_fit = pso.optimize(objective_fn, iterations=100)
+"""
+
+from bioopt.swarm.pso import PSO
+from bioopt.swarm.aco import ACO
+from bioopt.swarm.abc import ABC
+from bioopt.swarm.gwo import GWO
+from bioopt.swarm.fa import FA
+from bioopt.swarm.woa import WOA
+
+__all__ = [
+    "PSO",
+    "ACO",
+    "ABC",
+    "GWO",
+    "FA",
+    "WOA",
+]