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

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

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

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

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

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

@@ -1,10 +1,9 @@
 from __future__ import annotations
 
-import json
-import os
 import pickle
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
+from pathlib import Path
 from typing import Callable
 
 import matplotlib.pyplot as plt
@@ -20,35 +19,6 @@ from ..plot_losses import plot_losses
 from ..types import Array
 
 
-@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):
     """
@@ -71,7 +41,7 @@ class ModelConfig(ABC, Summary):
         ...
 
 
-class Model(ABC, ModelRecord):
+class Model(ABC):
     """
     Base class orchestrating the training and testing loop.
 
@@ -124,6 +94,7 @@ class Model(ABC, ModelRecord):
             print(f"        epoch n°{epoch_idx + 1} out of {self.nb_epochs}")
             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
@@ -131,8 +102,17 @@ class Model(ABC, ModelRecord):
                 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()
 
+    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
+
     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)
@@ -142,24 +122,27 @@ class Model(ABC, ModelRecord):
 
         print(f"    {self.id} accuracy : {self.test_accuracy}, loss : {self.test_loss}")
 
-    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)
+    def save_loss(self, save_dir: Path) -> None:
+        save_dir.mkdir(parents=True, exist_ok=True)
+        save_path = save_dir / self.LOSS_FILE
+
         df = pd.DataFrame({
             'training_loss': self.training_loss
         })
         df.to_csv(save_path)
 
-    def save_weights(self, save_dir: str) -> None:
-        save_path = os.path.join(save_dir, self.WEIGHTS_FILE)
+    def save_weights(self, save_dir: Path) -> None:
+        save_dir.mkdir(parents=True, exist_ok=True)
+        save_path = save_dir / self.WEIGHTS_FILE
+
         params_dict = self.neural_network.get_params()
-        with open(save_path, 'wb') as f:
+        with save_path.open('wb') as f:
             pickle.dump(params_dict, f)
 
-    def load_weights(self, load_dir: str) -> None:
+    def load_weights(self, load_dir: Path) -> 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:
+        load_path = load_dir / self.WEIGHTS_FILE
+        with load_path.open('rb') as f:
             params_dict = pickle.load(f)
 
         self.neural_network.init_params(params_dict)

{zeroth_learn-0.2.3 → zeroth_learn-0.2.4}/zeroth/abstract/summary.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import dataclasses
-import os
+from pathlib import Path
 from typing import Any
 
 
@@ -9,14 +9,10 @@ class Summary:
     def summary(self, file=None) -> None:
         print(self._summary(self, indent=0), file=file)
 
-    def save(self, save_dir: str) -> None:
+    def save(self, path: Path) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
 
-        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:
+        with path.open("w", encoding="utf-8") as f:
             print(self._summary(self, indent=0), file=f)
 
     @classmethod

{zeroth_learn-0.2.3 → zeroth_learn-0.2.4}/zeroth/experiment.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import itertools
-import os
+from pathlib import Path
 from dataclasses import dataclass, replace
 from typing import Union
 
@@ -28,7 +28,6 @@ class ExperimentConfig(Summary):
     data_creator: DataCreator
     variations: list[VariationConfig]
 
-
     def instantiate(self) -> Experiment:
         return Experiment(self)
 
@@ -74,31 +73,32 @@ class Experiment:
         for model in self.models:
             model.test()
 
-    def save_df(self, save_dir: str) -> None:
+    def save_df(self, save_dir: Path) -> None:
         """
         saves the models parameters and their args
         """
-        os.makedirs(save_dir, exist_ok=True)
+        save_dir.mkdir(parents=True, exist_ok=True)
+        save_path = save_dir / self.ACCURACY_FILE
         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")
+        df.to_csv(save_path)
 
-    def save_weights(self, save_dir: str) -> None:
+    def save_weights(self, save_dir: Path) -> None:
         for i, model in enumerate(self.models):
-            save_path = os.path.join(save_dir, model.name)
+            save_path = save_dir / model.name
             model.save_weights(save_path)
 
-    def save_configs(self, save_dir: str) -> None:
+    def save_configs(self, save_dir: Path) -> None:
 
-        config_path = os.path.join(save_dir, self.CONFIG_FILE)
+        config_path = 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)
+            save_path = save_dir / model.name
             model.config.save(save_path)
 
 

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

@@ -11,7 +11,7 @@ from matplotlib.axes import Axes
 from .types import Array
 
 if TYPE_CHECKING:
-    from .abstract.model import ModelRecord
+    from .abstract.model import Model
 
 
 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[ModelRecord], title: str, smooth_fraction: float = 50) -> plt.Figure:
+def plot_0d(models: list[Model], title: str, smooth_fraction: float = 50) -> plt.Figure:
     """
     Plots a single graph overlaying multiple models that share the same hyperparameters.
     """
@@ -108,7 +108,7 @@ def plot_0d(models: list[ModelRecord], title: str, smooth_fraction: float = 50)
     return fig
 
 
-def plot_1d(models: list[ModelRecord], title: str, key: str, smooth_fraction: float = 50) -> plt.Figure:
+def plot_1d(models: list[Model], title: str, key: str, smooth_fraction: float = 50) -> plt.Figure:
     """
     Plots a row of subplots, varying one hyperparameter (key) across columns.
     """
@@ -147,7 +147,7 @@ def plot_1d(models: list[ModelRecord], title: str, key: str, smooth_fraction: fl
     return fig
 
 
-def plot_2d(models: list[ModelRecord], title: str, row_key: str, col_key: str, smooth_fraction: float) -> plt.Figure:
+def plot_2d(models: list[Model], 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.
 
@@ -199,7 +199,7 @@ def plot_2d(models: list[ModelRecord], title: str, row_key: str, col_key: str, s
     return fig
 
 
-def plot_losses(title: str, dimension: int, models: list[ModelRecord], smooth_fraction: float) -> plt.Figure:
+def plot_losses(title: str, dimension: int, models: list[Model], 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.

{zeroth_learn-0.2.3 → zeroth_learn-0.2.4}/zeroth/zeroth_order/gradient_estimators.py

@@ -27,7 +27,7 @@ class GlobalFiniteDifferenceConfig(GradientEstimatorConfig):
     dA: float
 
     def instantiate(self, nb_params) -> GlobalFiniteDifference:
-        return GlobalFiniteDifference(self, nb_params)
+        return GlobalFiniteDifference(self.dA, nb_params)
 
 
 @dataclass(frozen=True)
@@ -36,7 +36,7 @@ class PartialFiniteDifferenceConfig(GradientEstimatorConfig):
     indexes: list[int]
 
     def instantiate(self, nb_params) -> PartialFiniteDifference:
-        return PartialFiniteDifference(self, nb_params)
+        return PartialFiniteDifference(self.dA, self.indexes, nb_params)
 
 
 @dataclass(frozen=True)
@@ -46,7 +46,7 @@ class SimultaneousPerturbationConfig(GradientEstimatorConfig):
     get_perturbation_matrix: PerturbationMatrix
 
     def instantiate(self, nb_params: int) -> SimultaneousPerturbation:
-        return SimultaneousPerturbation(self, nb_params)
+        return SimultaneousPerturbation(self.dA, self.nb_perturbations, self.get_perturbation_matrix, nb_params)
 
 
 class GradientEstimator(ABC):
@@ -89,12 +89,12 @@ class NullGradientEstimator(GradientEstimator):
 
 
 class GlobalFiniteDifference(GradientEstimator):
-    def __init__(self, config: GlobalFiniteDifferenceConfig, nb_params: int) -> None:
+    def __init__(self, dA: float, nb_params: int) -> None:
         self.nb_params: int = nb_params
-        self.dA: float = config.dA
+        self.dA: float = dA
 
         self.perturbation_matrix: Array = np.vstack((np.zeros((1, self.nb_params)), np.eye(nb_params)))
-        self.Ps: Array = config.dA * self.perturbation_matrix
+        self.Ps: Array = dA * self.perturbation_matrix
 
     def perturb(self, Theta: Array) -> Array:
         return Theta + self.Ps
@@ -105,16 +105,16 @@ class GlobalFiniteDifference(GradientEstimator):
 
 
 class PartialFiniteDifference(GradientEstimator):
-    def __init__(self, config: PartialFiniteDifferenceConfig, nb_params: int) -> None:
+    def __init__(self, dA: float, indexes: list[int], nb_params: int) -> None:
         self.nb_params: int = nb_params
-        self.dA: float = config.dA
-        self.indexes = config.indexes
-        self.nb_perturbations = len(config.indexes)
+        self.dA: float = dA
+        self.indexes: list[int] = indexes
+        self.nb_perturbations: int = len(indexes)
 
         self.perturbation_matrix: Array = np.zeros((self.nb_perturbations + 1, self.nb_params))
         self.perturbation_matrix[range(1, self.nb_perturbations + 1), self.indexes] = 1
 
-        self.Ps: Array = config.dA * self.perturbation_matrix
+        self.Ps: Array = dA * self.perturbation_matrix
 
     def perturb(self, Theta: Array) -> Array:
         return Theta + self.Ps
@@ -125,11 +125,11 @@ class PartialFiniteDifference(GradientEstimator):
 
 
 class SimultaneousPerturbation(GradientEstimator):
-    def __init__(self, config: SimultaneousPerturbationConfig, nb_params: int) -> None:
+    def __init__(self, dA: float, nb_perturbations: int, get_perturbation_matrix: PerturbationMatrix, nb_params: int) -> None:
         self.nb_params: int = nb_params
-        self.dA: float = config.dA
-        self.nb_perturbations: int = config.nb_perturbations
-        self.get_perturbation_matrix: PerturbationMatrix = config.get_perturbation_matrix
+        self.dA: float = dA
+        self.nb_perturbations: int = nb_perturbations
+        self.get_perturbation_matrix: PerturbationMatrix = get_perturbation_matrix
 
         nb_copies = 3
         self.Ps_extended: Array = np.vstack((np.zeros((1, self.nb_params * nb_copies)),

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

@@ -24,7 +24,7 @@ class ZerothOrderSGDConfig(ZerothOrderOptimizerConfig):
     learning_rate: float
 
     def instantiate(self, gradient_estimator: GradientEstimator) -> ZerothOrderSGD:
-        return ZerothOrderSGD(self, gradient_estimator)
+        return ZerothOrderSGD(self.learning_rate, gradient_estimator)
 
 
 @dataclass(frozen=True)
@@ -35,7 +35,7 @@ class ZerothOrderAdamConfig(ZerothOrderSGDConfig):
     epsilon: float
 
     def instantiate(self, gradient_estimator: GradientEstimator) -> ZerothOrderAdam:
-        return ZerothOrderAdam(self, gradient_estimator)
+        return ZerothOrderAdam(self.learning_rate, self.beta1, self.beta2, self.epsilon, gradient_estimator)
 
 
 class ZerothOrderOptimizer(Optimizer):
@@ -60,9 +60,9 @@ class ZerothOrderSGD(ZerothOrderOptimizer):
     the gradient by evaluating the loss on perturbed versions of the parameters.
     """
 
-    def __init__(self, config: ZerothOrderSGDConfig, gradient_estimator: GradientEstimator) -> None:
-        self.learning_rate = config.learning_rate
-        self.gradient_estimator = gradient_estimator
+    def __init__(self, learning_rate: float, gradient_estimator: GradientEstimator) -> None:
+        self.learning_rate: float = learning_rate
+        self.gradient_estimator: GradientEstimator = gradient_estimator
 
     def do_descent(self, blackbox: ZerothOrderBlackBox, loss: Loss, X: Array, Y_true: Array) -> float:
         """Performs one optimization step using zeroth_order.
@@ -104,16 +104,16 @@ class ZerothOrderAdam(ZerothOrderSGD):
         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
-        self.epsilon: float = config.epsilon
-        self.beta1t: float = config.beta1
-        self.beta2t: float = config.beta2
+    def __init__(self, learning_rate: float, beta1: float, beta2: float, epsilon: float, gradient_estimator: GradientEstimator) -> None:
+        self.beta1: float = beta1
+        self.beta2: float = beta2
+        self.epsilon: float = epsilon
+        self.beta1t: float = beta1
+        self.beta2t: float = beta2
         self.m: Array = np.array([0])
         self.v: Array = np.array([0])
 
-        super().__init__(config, gradient_estimator)
+        super().__init__(learning_rate, gradient_estimator)
 
     def _apply_update_rule(self, grad: Array) -> Array:
         self.m = self.beta1 * self.m + (1 - self.beta1) * grad

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

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