zeroth-learn 0.2.1__tar.gz → 0.2.3__tar.gz

{zeroth_learn-0.2.1/zeroth_learn.egg-info → zeroth_learn-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zeroth-learn
-Version: 0.2.1
+Version: 0.2.3
 Requires-Dist: numpy
 Requires-Dist: pandas
 Requires-Dist: matplotlib

{zeroth_learn-0.2.1 → zeroth_learn-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "zeroth-learn"
-version = "0.2.1"
+version = "0.2.3"
 dependencies = [
     "numpy",
     "pandas",

{zeroth_learn-0.2.1 → zeroth_learn-0.2.3}/zeroth/abstract/__init__.py

@@ -4,7 +4,7 @@ from .data_creator import DataCreator
 from .loss import Loss
 from .metric import Metric
 from .model import Model, ModelConfig
-from .neural_network import NeuralNetworkConfig, LayerConfig, NeuralNetwork
+from .neural_network import NeuralNetworkConfig, NeuralNetwork
 from .optimizer import Optimizer
 from .perturbation_matrix import PerturbationMatrix
 from .summary import Summary

{zeroth_learn-0.2.1 → zeroth_learn-0.2.3}/zeroth/abstract/model.py

@@ -7,6 +7,7 @@ from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from typing import Callable
 
+import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
 
@@ -17,9 +18,37 @@ from .summary import Summary
 from ..data import Data
 from ..plot_losses import plot_losses
 from ..types import Array
-from ..utils.dataclasses_utils import config_serializer
 
 
+@dataclass
+class ModelRecord:
+    name: str
+    id: dict
+    training_loss: Array
+
+    @classmethod
+    def load(cls, model_dir_path: str):
+        config_path = os.path.join(model_dir_path, "config.json")
+        with open(config_path, "r") as f:
+            config = json.load(f)
+
+        loss_path = os.path.join(model_dir_path, LOSS_FILE)
+        df_loss = pd.read_csv(loss_path)
+
+        return cls(
+            id=config.get("id", {}),
+            name=config.get("name", "Unknown"),
+            training_loss=df_loss["training_loss"].values
+        )
+
+    def plot_loss(self, smooth_fraction: float = 0.05) -> plt.Figure:
+        fig = plot_losses(dimension=0,
+                          models=[self],
+                          title=self.name,
+                          smooth_fraction=smooth_fraction)
+        plt.close(fig)
+        return fig
+
 @dataclass(frozen=True, kw_only=True)
 class ModelConfig(ABC, Summary):
     """
@@ -38,11 +67,11 @@ class ModelConfig(ABC, Summary):
     nb_epochs: int = 1
 
     @abstractmethod
-    def instantiate(self) -> Model:
+    def instantiate(self, data: Data) -> Model:
         ...
 
 
-class Model(ABC):
+class Model(ABC, ModelRecord):
     """
     Base class orchestrating the training and testing loop.
 
@@ -50,14 +79,19 @@ class Model(ABC):
     regardless of the underlying engine (Backpropagation or zeroth_order).
     """
 
+    LOSS_FILE: str = "training_loss.csv"
+    WEIGHTS_FILE: str = "weights.pkl"
+    CONFIG_FILE: str = "config.json"
+
     neural_network: BlackBox
     optimizer: Optimizer
 
-    def __init__(self, config: ModelConfig):
+    def __init__(self, config: ModelConfig, data: Data):
         self.config = config
 
         self.name: str = config.name
         self.id: dict = config.id
+        self.data: Data = data
         self.loss: Loss = config.loss
         self.metric: Callable = config.metric
         self.batch_size: int = config.batch_size
@@ -67,11 +101,10 @@ class Model(ABC):
         self.test_loss: float = float("nan")
         self.test_accuracy: float = float("nan")
 
-    def train(self, data: Data, nb_print: int = 0) -> None:
+    def train(self, nb_print: int = 0) -> None:
         """Runs the training loop over the dataset.
 
         Args:
-            data (Data): The dataset object containing train/test sets.
             nb_print (int): Number of progress updates to print per epoch.
 
         Returns:
@@ -79,30 +112,29 @@ class Model(ABC):
         """
         print(f"    Training {self.id} Model")
 
-        data.batch_size = self.batch_size
-        nb_batches = len(data)
+        self.data.batch_size = self.batch_size
+        nb_batches = len(self.data)
 
         self.training_loss = np.zeros(self.nb_epochs * nb_batches, dtype=np.float64)
+
+        nb_print = nb_batches if nb_print == -1 else nb_print
         print_indexes = np.linspace(0, nb_batches - 1, nb_print).astype(int)
 
         for epoch_idx in range(self.nb_epochs):
             print(f"        epoch n°{epoch_idx + 1} out of {self.nb_epochs}")
-            data.permutation()
-            data.batch_size = self.batch_size
-            for batch_idx, (X_train, Y_train) in enumerate(data):
+            self.data.permutation()
+            self.data.batch_size = self.batch_size
+            for batch_idx, (X_train, Y_train) in enumerate(self.data):
                 avg_loss = self.optimizer.do_descent(self.neural_network, self.loss, X_train, Y_train)
                 self.training_loss[epoch_idx * nb_batches + batch_idx] = avg_loss
 
                 if batch_idx in print_indexes:
                     print(f"            batch n°{batch_idx + 1} out of {nb_batches}, "
                           f"loss : {np.round(self.training_loss[epoch_idx * nb_batches + batch_idx], 3)}")
-            self.test(data)
-
-    def plot_loss(self, save_path: str = None, smooth_fraction: float = 0) -> None:
-        plot_losses(dimension=0, models=[self], title=self.name, save_path=save_path, smooth_fraction=smooth_fraction)
+            self.test()
 
-    def test(self, data: Data) -> None:
-        X_test, Y_true = data.X_test, data.Y_test  # (in, batch), (out, batch)
+    def test(self) -> None:
+        X_test, Y_true = self.data.X_test, self.data.Y_test  # (in, batch), (out, batch)
         Y_pred = self.neural_network(X_test)  # (out, batch)
 
         self.test_accuracy = self.metric(Y_pred, Y_true)
@@ -110,26 +142,23 @@ class Model(ABC):
 
         print(f"    {self.id} accuracy : {self.test_accuracy}, loss : {self.test_loss}")
 
-    def save_weights(self, save_path: str) -> None:
-        os.makedirs(os.path.dirname(save_path), exist_ok=True)
-        params_dict = self.neural_network.get_params()
-        with open(save_path, 'wb') as f:
-            pickle.dump(params_dict, f)
-
-    def save_config(self, save_path: str) -> None:
-        os.makedirs(os.path.dirname(save_path), exist_ok=True)
-        with open(save_path, "w") as f:
-            json.dump(self.config, f, default=config_serializer, indent=4)
-
-    def save_loss(self, save_path: str) -> None:
-        os.makedirs(os.path.dirname(save_path), exist_ok=True)
+    def save_loss(self, save_dir: str) -> None:
+        save_path = os.path.join(save_dir, self.LOSS_FILE)
+        os.makedirs(os.path.dirname(save_dir), exist_ok=True)
         df = pd.DataFrame({
             'training_loss': self.training_loss
         })
         df.to_csv(save_path)
 
-    def load_weights(self, load_path: str) -> None:
+    def save_weights(self, save_dir: str) -> None:
+        save_path = os.path.join(save_dir, self.WEIGHTS_FILE)
+        params_dict = self.neural_network.get_params()
+        with open(save_path, 'wb') as f:
+            pickle.dump(params_dict, f)
+
+    def load_weights(self, load_dir: str) -> None:
         """Restaure les paramètres depuis un fichier pickle."""
+        load_path = os.path.join(load_dir, self.WEIGHTS_FILE)
         with open(load_path, 'rb') as f:
             params_dict = pickle.load(f)
 

zeroth_learn-0.2.3/zeroth/abstract/neural_network.py

@@ -0,0 +1,20 @@
+from abc import ABC
+from dataclasses import dataclass
+
+from .activation import Activation
+from .summary import Summary
+
+
+@dataclass(frozen=True)
+class NeuralNetworkConfig(Summary):
+    name: str
+    hidden_dims: list[int]
+    activations: list[Activation]
+
+
+class NeuralNetwork(ABC):
+    def __init__(self, config: NeuralNetworkConfig, input_dim: int, output_dim: int):
+        self.name: str = config.name
+        self.nb_layers: int = len(config.activations)
+        self.input_dim: int = input_dim
+        self.output_dim: int = output_dim

zeroth_learn-0.2.3/zeroth/abstract/summary.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import dataclasses
+import os
+from typing import Any
+
+
+class Summary:
+    def summary(self, file=None) -> None:
+        print(self._summary(self, indent=0), file=file)
+
+    def save(self, save_dir: str) -> None:
+
+        save_path = os.path.join(save_dir, "config.txt")
+
+        if os.path.dirname(save_path):
+            os.makedirs(os.path.dirname(save_path), exist_ok=True)
+
+        with open(save_path, "w", encoding="utf-8") as f:
+            print(self._summary(self, indent=0), file=f)
+
+    @classmethod
+    def load(cls, path: str, context: dict = None) -> Summary:
+        with open(path, "r") as f:
+            code = "".join(l for l in f)
+        return eval(code.strip(), {"__builtins__": __builtins__}, context)
+
+    def _summary(self, obj: Any, indent: int) -> str:
+        shift = "    " * indent
+        next_shift = "    " * (indent + 1)
+
+        if dataclasses.is_dataclass(obj):
+            cls_name = obj.__class__.__name__
+            items = []
+            for f in dataclasses.fields(obj):
+                val = getattr(obj, f.name)
+                formatted_val = self._summary(val, indent + 1)
+                items.append(f"{next_shift}{f.name}={formatted_val.lstrip()}")
+
+            content = ",\n".join(items)
+            return f"{cls_name}(\n{content}\n{shift})"
+
+        elif isinstance(obj, list):
+            if not obj: return "[]"
+            items = [self._summary(item, indent + 1) for item in obj]
+            content = ",\n".join([f"{next_shift}{item.lstrip()}" for item in items])
+            return f"[\n{content}\n{shift}]"
+
+        elif isinstance(obj, dict):
+            if not obj: return "{}"
+            items = [f"{next_shift}{repr(k)}: {self._summary(v, indent + 1).lstrip()}" for k, v in obj.items()]
+            content = ",\n".join(items)
+            return f"{{\n{content}\n{shift}}}"
+
+        else:
+            return repr(obj)

zeroth_learn-0.2.3/zeroth/all.py

@@ -0,0 +1,12 @@
+# noinspection PyUnresolvedReferences
+from .losses import *
+# noinspection PyUnresolvedReferences
+from .abstract import *
+# noinspection PyUnresolvedReferences
+from .zeroth_order import *
+# noinspection PyUnresolvedReferences
+from .first_order import *
+# noinspection PyUnresolvedReferences
+from .experiment import *
+# noinspection PyUnresolvedReferences
+from .utils import *

{zeroth_learn-0.2.1 → zeroth_learn-0.2.3}/zeroth/data.py

@@ -6,13 +6,17 @@ from .types import Array
 
 
 class Data:
-    def __init__(self, raw_X_train: Array, raw_Y_train: Array, raw_X_test: Array, raw_Y_test: Array) -> None:
+    def __init__(self, raw_X_train: Array, raw_Y_train: Array, raw_X_test: Array, raw_Y_test: Array,
+                 nb_class: int = 0) -> None:
         self.raw_X_train: Array = raw_X_train
         self.raw_Y_train: Array = raw_Y_train
         self.X_test: Array = raw_X_test
         self.Y_test: Array = raw_Y_test
 
         self.nb_data: int = raw_X_train.shape[0]
+        self.input_dim: int = self.raw_X_train.shape[1]
+        self.output_dim: int = self.raw_Y_train.shape[1] if nb_class == 0 else nb_class
+
         self.batch_size: int | None = None
 
         self.indices: np.ndarray = np.arange(self.nb_data)

zeroth_learn-0.2.3/zeroth/experiment.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import itertools
+import os
+from dataclasses import dataclass, replace
+from typing import Union
+
+import matplotlib.pyplot as plt
+import pandas as pd
+
+from .abstract import Model, ModelConfig, DataCreator, Summary
+from .data import Data
+from .plot_losses import plot_losses
+from .utils.dataclasses_utils import get_name, set_value_by_path
+
+
+@dataclass(frozen=True)
+class VariationConfig:
+    name: str
+    param: list[str]
+    values: Union[list, list[list]]
+
+
+@dataclass(frozen=True)
+class ExperimentConfig(Summary):
+    name: str
+    base_model: ModelConfig
+    data_creator: DataCreator
+    variations: list[VariationConfig]
+
+
+    def instantiate(self) -> Experiment:
+        return Experiment(self)
+
+
+class Experiment:
+    """Manages the full lifecycle of a deep learning experiment.
+
+    It handles data loading, model instantiation, training loops, and results visualization.
+
+    Attributes:
+        name (str): Name of the experiment
+        models (list[Model]): List of models to train/compare
+        data (Data): The dataset wrapper.
+    """
+
+    ACCURACY_FILE: str = "models_accuracy.csv"
+    CONFIG_FILE: str = "config.txt"
+
+    def __init__(self, config: ExperimentConfig) -> None:
+        self.config = config
+        self.name: str = config.name
+        self.base_model_config: ModelConfig = config.base_model
+        self.data = config.data_creator()
+        self.models: list[Model] = generate_models(config.base_model, config.variations, self.data)
+
+    def train_models(self, nb_print: int) -> None:
+        print(f"Training Models")
+        for model in self.models:
+            model.train(nb_print)
+
+    def plot_losses(self, title: str, plot_dimension: int, smooth_fraction: float = 0) -> plt.Figure:
+        fig = plot_losses(title=title,
+                          dimension=plot_dimension,
+                          models=self.models,
+                          smooth_fraction=smooth_fraction)
+
+        plt.close(fig)
+
+        return fig
+
+    def test_models(self) -> None:
+        print(f"Testing Models")
+        for model in self.models:
+            model.test()
+
+    def save_df(self, save_dir: str) -> None:
+        """
+        saves the models parameters and their args
+        """
+        os.makedirs(save_dir, exist_ok=True)
+        print(f"    Saving results to: {save_dir}")
+
+        data = [model.id | {"test_loss": model.test_loss, "test_accuracy": model.test_accuracy}
+                for model in self.models]
+
+        df = pd.DataFrame(data)
+        df.to_csv(os.path.join(save_dir, self.ACCURACY_FILE), index_label="iteration")
+
+    def save_weights(self, save_dir: str) -> None:
+        for i, model in enumerate(self.models):
+            save_path = os.path.join(save_dir, model.name)
+            model.save_weights(save_path)
+
+    def save_configs(self, save_dir: str) -> None:
+
+        config_path = os.path.join(save_dir, self.CONFIG_FILE)
+        self.config.save(config_path)
+
+        for i, model in enumerate(self.models):
+            save_path = os.path.join(save_dir, model.name)
+            model.config.save(save_path)
+
+
+def generate_models(base_model: ModelConfig, variations: list[VariationConfig], data: Data) -> list[Model]:
+    models = []
+
+    values_lists = [v.values for v in variations]
+
+    for combination in itertools.product(*values_lists):
+        id_ = {}
+        current_model = base_model
+
+        for var_config, current_vals in zip(variations, combination):
+            id_[var_config.name] = get_name(current_vals[0])
+
+            for path, val in zip(var_config.param, current_vals):
+                current_model = set_value_by_path(current_model, path, val)
+
+        current_model = replace(current_model, id=id_)
+        models.append(current_model.instantiate(data))
+
+    return models

{zeroth_learn-0.2.1 → zeroth_learn-0.2.3}/zeroth/first_order/layer.py

@@ -15,7 +15,7 @@ class Layer:
         A (Array): Activated output. Shape (batch_size, output_dim).
     """
 
-    def __init__(self, output_dim: int, input_dim: int, activation: Activation) -> None:
+    def __init__(self, input_dim: int, output_dim: int, activation: Activation) -> None:
         """Initializes the layer with random weights and zeros biases.
 
         Args:

{zeroth_learn-0.2.1 → zeroth_learn-0.2.3}/zeroth/first_order/model.py

@@ -5,6 +5,7 @@ from dataclasses import dataclass
 from .neural_network import FirstOrderNeuralNetwork
 from .optimizers import FirstOrderOptimizerConfig, FirstOrderOptimizer
 from ..abstract import ModelConfig, Model, NeuralNetworkConfig
+from ..data import Data
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -12,13 +13,14 @@ class FirstOrderModelConfig(ModelConfig):
     neural_network_config: NeuralNetworkConfig
     optimizer_config: FirstOrderOptimizerConfig
 
-    def instantiate(self) -> FirstOrderModel:
-        return FirstOrderModel(self)
+    def instantiate(self, data: Data) -> FirstOrderModel:
+        return FirstOrderModel(self, data)
 
 
 class FirstOrderModel(Model):
-    def __init__(self, config: FirstOrderModelConfig) -> None:
-        super().__init__(config)
+    def __init__(self, config: FirstOrderModelConfig, data: Data) -> None:
+        super().__init__(config, data)
 
-        self.neural_network: FirstOrderNeuralNetwork = FirstOrderNeuralNetwork(config.neural_network_config)
+        self.neural_network: FirstOrderNeuralNetwork = FirstOrderNeuralNetwork(config.neural_network_config,
+                                                                               data.input_dim, data.output_dim)
         self.optimizer: FirstOrderOptimizer = config.optimizer_config.instantiate()

{zeroth_learn-0.2.1 → zeroth_learn-0.2.3}/zeroth/first_order/neural_network.py

@@ -1,6 +1,5 @@
 from .layer import Layer
 from ..abstract.neural_network import NeuralNetwork, NeuralNetworkConfig
-
 from ..types import Array
 
 
@@ -12,13 +11,16 @@ class FirstOrderNeuralNetwork(NeuralNetwork):
         nb_layers (int): Number of layers.
     """
 
-    def __init__(self, config: NeuralNetworkConfig) -> None:
-        super().__init__(config)
+    def __init__(self, config: NeuralNetworkConfig, input_dim: int, output_dim: int) -> None:
+        super().__init__(config, input_dim, output_dim)
+
         self.layers: list[Layer] = []
-        for layer_config in config.layers_config:
-            self.layers.append(Layer(layer_config.output_dim,
-                                     layer_config.input_dim,
-                                     layer_config.activation))
+        network_dimensions = [input_dim] + config.hidden_dims + [output_dim]
+
+        for i in range(self.nb_layers):
+            self.layers.append(Layer(network_dimensions[i],
+                                     network_dimensions[i + 1],
+                                     config.activations[i]))
 
     def __call__(self, X: Array) -> Array:
         return self.forward(X)

{zeroth_learn-0.2.1 → zeroth_learn-0.2.3}/zeroth/first_order/optimizers.py

@@ -30,6 +30,7 @@ class FirstOrderSGDConfig(FirstOrderOptimizerConfig):
 
 @dataclass(frozen=True)
 class FirstOrderAdamConfig(FirstOrderSGDConfig):
+    name = "Adam"
     beta1: float
     beta2: float
     epsilon: float
@@ -45,8 +46,6 @@ class FirstOrderOptimizer(Optimizer):
 
 
 class FirstOrderSGD(FirstOrderOptimizer):
-    """Abstract base class for gradient descent optimizers using first_order."""
-
     def __init__(self, config: FirstOrderSGDConfig) -> None:
         self.learning_rate: float = config.learning_rate
 
@@ -97,13 +96,11 @@ class FirstOrderSGD(FirstOrderOptimizer):
 
 
 class FirstOrderAdam(FirstOrderSGD):
-    name = "Adam"
     """Implements the Adam optimization algorithm.
 
     Adam (Adaptive Moment Estimation) stores moving averages of the gradients (m)
     and squared gradients (v) to adapt the learning rate for each parameter.
     """
-
     def __init__(self, config: FirstOrderAdamConfig) -> None:
         super().__init__(config)
         self.beta1: float = config.beta1

{zeroth_learn-0.2.1 → zeroth_learn-0.2.3}/zeroth/plot_losses.py

@@ -11,7 +11,7 @@ from matplotlib.axes import Axes
 from .types import Array
 
 if TYPE_CHECKING:
-    from .abstract.model import Model
+    from .abstract.model import ModelRecord
 
 
 def set_style() -> None:
@@ -80,7 +80,7 @@ def smooth_curve(loss: Array, window_length: int) -> Array:
     return np.exp(pd.Series(np.log(loss)).ewm(span=window_length, adjust=True).mean())
 
 
-def plot_0d(models: list[Model], title: str, smooth_fraction: float = 50) -> None:
+def plot_0d(models: list[ModelRecord], title: str, smooth_fraction: float = 50) -> plt.Figure:
     """
     Plots a single graph overlaying multiple models that share the same hyperparameters.
     """
@@ -105,14 +105,17 @@ def plot_0d(models: list[Model], title: str, smooth_fraction: float = 50) -> Non
         fig.legend(handles, labels, loc='lower center', ncol=len(handles),
                    bbox_to_anchor=(0.5, 0), frameon=False, fontsize=9)
 
+    return fig
 
-def plot_1d(models: list[Model], title: str, key: str, smooth_fraction: float = 50) -> None:
+
+def plot_1d(models: list[ModelRecord], title: str, key: str, smooth_fraction: float = 50) -> plt.Figure:
     """
     Plots a row of subplots, varying one hyperparameter (key) across columns.
     """
-
+    print(len(models), [model.id for model in models])
     cols = list(dict.fromkeys([m.id[key] for m in models]))
     n_models = len(cols)
+    print(cols, n_models)
     fig, axs = plt.subplots(1, n_models, figsize=(4.5 * n_models, 3.5), sharey=True)
 
     for i, val in enumerate(cols):
@@ -141,8 +144,10 @@ def plot_1d(models: list[Model], title: str, key: str, smooth_fraction: float =
         fig.legend(handles, labels, loc='lower center', ncol=len(handles),
                    bbox_to_anchor=(0.5, 0), frameon=False, fontsize=9)
 
+    return fig
 
-def plot_2d(models: list[Model], title: str, row_key: str, col_key: str, smooth_fraction: float) -> None:
+
+def plot_2d(models: list[ModelRecord], title: str, row_key: str, col_key: str, smooth_fraction: float) -> plt.Figure:
     """
     Plots a grid of subplots varying two hyperparameters: one across rows, one across columns.
 
@@ -191,32 +196,30 @@ def plot_2d(models: list[Model], title: str, row_key: str, col_key: str, smooth_
     fig.text(0.5, 0.07, "Training steps", ha='center', fontsize=10)
     fig.text(0.02, 0.5, "Training loss", va='center', rotation='vertical', fontsize=10)
 
+    return fig
+
 
-def plot_losses(dimension: int, models: list[Model], title: str, smooth_fraction: float, save_path: str = None) -> None:
+def plot_losses(title: str, dimension: int, models: list[ModelRecord], smooth_fraction: float) -> plt.Figure:
     """
     Main entry point for plotting. Automatically detects if the plot should be 0D, 1D, or 2D
     based on the number of variation parameters.
 
     Args:
+        title (str): The title of the plot.
         dimension (int): dimension of the plot
         models (list): List of model objects.
-        title (str): The title of the plot.
-        save_path (str, optional): File path to save the figure (e.g., 'plot.png').
         smooth_fraction (int): span for smoothing.
     """
     set_style()
 
     keys = list(models[0].id.keys())
 
-    if dimension == 0:
-        plot_0d(models, title, smooth_fraction)
-    elif dimension == 1:
-        plot_1d(models, title, keys[0], smooth_fraction)
-    else:
-        plot_2d(models, title, keys[0], keys[1], smooth_fraction)
-
-    if save_path:
-        plt.savefig(save_path, dpi=300, bbox_inches="tight")
-        print(f"Plot saved to {save_path}")
+    match dimension:
+        case 0:
+            fig = plot_0d(models, title, smooth_fraction)
+        case 1:
+            fig = plot_1d(models, title, keys[0], smooth_fraction)
+        case _:
+            fig = plot_2d(models, title, keys[0], keys[1], smooth_fraction)
 
-    plt.show()
+    return fig

zeroth_learn-0.2.3/zeroth/utils/__init__.py

@@ -0,0 +1,4 @@
+from .activation_functions import *
+from .dataclasses_utils import *
+from .metrics import *
+from .perturbation_matrices import *

{zeroth_learn-0.2.1 → zeroth_learn-0.2.3}/zeroth/utils/dataclasses_utils.py

@@ -1,4 +1,4 @@
-from dataclasses import is_dataclass, asdict, replace
+from dataclasses import replace
 from typing import Any
 
 
@@ -26,9 +26,17 @@ def set_value_by_path(obj: Any, path: str, value: Any) -> Any:
     return replace(obj, **{field: value})
 
 
+from dataclasses import is_dataclass, fields
+
+
 def config_serializer(obj: Any):
     if is_dataclass(obj):
-        return asdict(obj)
+        data = {f.name: getattr(obj, f.name) for f in fields(obj)}
+        return {obj.__class__.__name__: data}
+
+    if hasattr(obj, "__class__") and obj.__class__.__module__ != "builtins":
+        return repr(obj)
+
     if callable(obj):
         return getattr(obj, "__name__", str(obj))
 

{zeroth_learn-0.2.1 → zeroth_learn-0.2.3}/zeroth/zeroth_order/model.py

@@ -6,6 +6,7 @@ from .gradient_estimators import GradientEstimatorConfig, GradientEstimator
 from .neural_network.neural_network import ZerothOrderNeuralNetwork
 from .optimizers import ZerothOrderOptimizerConfig, ZerothOrderOptimizer
 from ..abstract import Model, ModelConfig, NeuralNetworkConfig
+from ..data import Data
 
 
 @dataclass(frozen=True)
@@ -14,15 +15,16 @@ class ZerothOrderModelConfig(ModelConfig):
     optimizer_config: ZerothOrderOptimizerConfig
     gradient_estimator_config: GradientEstimatorConfig
 
-    def instantiate(self) -> ZerothOrderModel:
-        return ZerothOrderModel(self)
+    def instantiate(self, data: Data) -> ZerothOrderModel:
+        return ZerothOrderModel(self, data)
 
 
 class ZerothOrderModel(Model):
-    def __init__(self, config: ZerothOrderModelConfig) -> None:
-        super().__init__(config)
+    def __init__(self, config: ZerothOrderModelConfig, data: Data) -> None:
+        super().__init__(config, data)
 
-        self.neural_network: ZerothOrderNeuralNetwork = ZerothOrderNeuralNetwork(config.neural_network_config)
+        self.neural_network: ZerothOrderNeuralNetwork = ZerothOrderNeuralNetwork(config.neural_network_config,
+                                                                                 data.input_dim, data.output_dim)
         nb_params = self.neural_network.params.nb_params
         self.gradient_estimator: GradientEstimator = config.gradient_estimator_config.instantiate(nb_params)
         self.optimizer: ZerothOrderOptimizer = config.optimizer_config.instantiate(self.gradient_estimator)

{zeroth_learn-0.2.1 → zeroth_learn-0.2.3}/zeroth/zeroth_order/neural_network/neural_network.py

@@ -12,13 +12,16 @@ class ZerothOrderNeuralNetwork(NeuralNetwork, ZerothOrderBlackBox):
         params (ParameterManager): Handler for flattening/reshaping weights (Theta <-> Ws/Bs).
     """
 
-    def __init__(self, config: NeuralNetworkConfig) -> None:
-        super().__init__(config)
+    def __init__(self, config: NeuralNetworkConfig, input_dim: int, output_dim: int) -> None:
+        super().__init__(config, input_dim, output_dim)
         self.params: ParameterManager = ParameterManager()
-        for layer_config in config.layers_config:
-            self.params.push_layer(layer_config.output_dim,
-                                   layer_config.input_dim,
-                                   layer_config.activation)
+
+        network_dimensions = [input_dim] + config.hidden_dims + [output_dim]
+
+        for i in range(self.nb_layers):
+            self.params.push_layer(network_dimensions[i],
+                                   network_dimensions[i + 1],
+                                   config.activations[i])
 
     def __call__(self, X: Array) -> Array:
         return self.forward(X)

{zeroth_learn-0.2.1 → zeroth_learn-0.2.3}/zeroth/zeroth_order/neural_network/parameter_manager.py

@@ -30,7 +30,7 @@ class ParameterManager:
         self.nb_params: int = 0
         self.Theta: Array = np.array([])
 
-    def push_layer(self, output_dim: int, input_dim: int | None = None, f: Activation = ReLU()) -> None:
+    def push_layer(self, input_dim: int, output_dim: int, f: Activation = ReLU()) -> None:
         """Adds a layer to the structure and updates the flat Theta vector.
 
         Args:

{zeroth_learn-0.2.1 → zeroth_learn-0.2.3}/zeroth/zeroth_order/optimizers.py

@@ -97,14 +97,13 @@ class ZerothOrderSGD(ZerothOrderOptimizer):
 
 
 class ZerothOrderAdam(ZerothOrderSGD):
-    name = "Adam"
     """Adaptive Moment Estimation (Adam) adapted for zeroth_order gradient estimates.
 
     Note:
         Since zeroth_order gradients are noisy approximations, Adam is often very effective
         as its momentum terms (m, v) help smooth out the noise over time.
     """
-
+    name = "Adam"
     def __init__(self, config: ZerothOrderAdamConfig, gradient_estimator: GradientEstimator) -> None:
         self.beta1: float = config.beta1
         self.beta2: float = config.beta2

{zeroth_learn-0.2.1 → zeroth_learn-0.2.3/zeroth_learn.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zeroth-learn
-Version: 0.2.1
+Version: 0.2.3
 Requires-Dist: numpy
 Requires-Dist: pandas
 Requires-Dist: matplotlib

{zeroth_learn-0.2.1 → zeroth_learn-0.2.3}/zeroth_learn.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ MANIFEST.in
 README.md
 pyproject.toml
 zeroth/__init__.py
+zeroth/all.py
 zeroth/data.py
 zeroth/experiment.py
 zeroth/paths.py

zeroth_learn-0.2.1/zeroth/abstract/neural_network.py

@@ -1,26 +0,0 @@
-from abc import ABC
-from dataclasses import dataclass
-
-from .activation import Activation
-from .summary import Summary
-
-
-@dataclass(frozen=True)
-class LayerConfig(Summary):
-    input_dim: int
-    output_dim: int
-    activation: Activation
-
-
-@dataclass(frozen=True)
-class NeuralNetworkConfig(Summary):
-    name: str
-    layers_config: list[LayerConfig]
-
-
-class NeuralNetwork(ABC):
-    def __init__(self, config: NeuralNetworkConfig):
-        self.name: str = config.name
-        self.nb_layers: int = len(config.layers_config)
-        self.input_dim: int = config.layers_config[0].input_dim
-        self.output_dim: int = config.layers_config[-1].output_dim

zeroth_learn-0.2.1/zeroth/abstract/summary.py

@@ -1,13 +0,0 @@
-import json
-
-from ..utils.dataclasses_utils import config_serializer
-
-
-class Summary:
-    def summary(self) -> None:
-        summary = json.dumps(
-            self,
-            default=config_serializer,
-            indent=4
-        )
-        print(summary)

zeroth_learn-0.2.1/zeroth/experiment.py

@@ -1,151 +0,0 @@
-from __future__ import annotations
-
-import itertools
-import os
-from dataclasses import dataclass, replace
-from typing import Union
-
-import pandas as pd
-
-from .abstract import Model, ModelConfig, DataCreator, Summary
-from .data import Data
-from .plot_losses import plot_losses
-from .utils.dataclasses_utils import get_name, set_value_by_path
-
-
-@dataclass(frozen=True)
-class VariationConfig:
-    name: str
-    param: list[str]
-    values: Union[list, list[list]]
-
-
-@dataclass(frozen=True)
-class ExperimentConfig(Summary):
-    name: str
-    title: str
-    base_model: ModelConfig
-    variations: list[VariationConfig]
-    data_creator: DataCreator
-    plot_dimension: int
-    smooth_fraction: float
-
-    def instantiate(self) -> Experiment:
-        return Experiment(self)
-
-
-class Experiment:
-    """Manages the full lifecycle of a deep learning experiment.
-
-    It handles data loading, model instantiation, training loops, and results visualization.
-
-    Attributes:
-        name (str): Name of the experiment
-        title (str): Title of the graphs
-        models (list[Model]): List of models to train/compare
-        data (Data): The dataset wrapper.
-    """
-
-    def __init__(self, config: ExperimentConfig):
-        self.config = config
-        self.name: str = config.name
-        self.title: str = config.title
-        self.base_model_config: ModelConfig = config.base_model
-        self.models: list[Model] = generate_models(config.base_model, config.variations)
-        self.data: Data = config.data_creator()
-        self.plot_dimension: int = config.plot_dimension
-        self.smooth_fraction: float = config.smooth_fraction
-
-        self.save_dir = os.path.join("experiments", self.name)
-
-    def launch(self, do_train: bool, do_test: bool, nb_print_train: int, do_plot_train: bool, do_save: bool) -> None:
-        """
-        Executes the experiment pipeline.
-
-        Args:
-            do_train (bool): Whether to run the training loop.
-            do_test (bool): Whether to run evaluation on test set.
-            nb_print_train (int): Number of logs to print during training.
-            do_plot_train (bool): If True, plots loss curves after training.
-            do_save (bool): if True, saves the plots and dataframes
-        """
-        print(f"### Launching Experiment : {self.name} ###")
-        if do_train:
-            self.train(nb_print=nb_print_train, do_plot=do_plot_train, do_save=do_save)
-        if do_test:
-            self.test()
-        if do_save:
-            self.save_df()
-            self.save_weights()
-
-    def train(self, nb_print: int, do_plot: bool, do_save: bool):
-        for model in self.models:
-            model.train(self.data, nb_print)
-
-        if do_plot:
-            plot_path = None
-            if do_save:
-                os.makedirs(self.save_dir, exist_ok=True)
-                plot_path = os.path.join(self.save_dir, "training_losses.png")
-
-            plot_losses(dimension=self.plot_dimension,
-                        models=self.models,
-                        title=self.title,
-                        smooth_fraction=self.smooth_fraction,
-                        save_path=plot_path)
-
-    def test(self) -> None:
-        for model in self.models:
-            model.test(self.data)
-
-    def save_df(self) -> None:
-        """
-        saves the models parameters and their args
-        """
-        os.makedirs(self.save_dir, exist_ok=True)
-        print(f"    Saving results to: {self.save_dir}")
-
-        data = [model.id | {"test_loss": model.test_loss, "test_accuracy": model.test_accuracy}
-                for model in self.models]
-
-        df = pd.DataFrame(data)
-        df.to_csv(os.path.join(self.save_dir, "models_accuracy.csv"), index_label="iteration")
-
-    def save_weights(self) -> None:
-        weights_dir = os.path.join(self.save_dir, "models")
-        os.makedirs(weights_dir, exist_ok=True)
-        print(f"    Saving weights to: {weights_dir}")
-
-        for i, model in enumerate(self.models):
-            model_dir = os.path.join(weights_dir, f"{model.get_folder_name()}")
-
-            weights_path = os.path.join(model_dir, "weights.pkl")
-            model.save_weights(weights_path)
-
-            config_path = os.path.join(model_dir, "config.json")
-            model.save_config(config_path)
-
-            loss_path = os.path.join(model_dir, "training_loss.csv")
-            model.save_loss(loss_path)
-
-
-def generate_models(base_model: ModelConfig, variations: list[VariationConfig]) -> list[Model]:
-    models = []
-
-    values_lists = [v.values for v in variations]
-
-    for combination in itertools.product(*values_lists):
-        id_ = {}
-        current_model = base_model
-
-        for var_config, current_vals in zip(variations, combination):
-
-            id_[var_config.name] = get_name(current_vals[0])
-
-            for path, val in zip(var_config.param, current_vals):
-                current_model = set_value_by_path(current_model, path, val)
-
-        current_model = replace(current_model, id=id_)
-        models.append(current_model.instantiate())
-
-    return models