NeuralNetworks 0.2.5__tar.gz → 0.2.8__tar.gz

{neuralnetworks-0.2.5 → neuralnetworks-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: NeuralNetworks
-Version: 0.2.5
+Version: 0.2.8
 Summary: Multi-Layer Perceptrons with multi-Fourier encoding, variable learning rate, visualization and PyTorch compilation
 Author-email: Alexandre Brun <alexandre51160@gmail.com>
 License: GPL-3.0-or-later
@@ -12,20 +12,13 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy>=1.25
-Requires-Dist: matplotlib>=3.10
-Requires-Dist: tqdm>=4.66
-Requires-Dist: torch<3.0,>=2.9.1
-Requires-Dist: torchvision<1.0,>=0.24
-Requires-Dist: torchaudio<3.0,>=2.9
-Requires-Dist: torchmetrics>=1.8
-Requires-Dist: visualtorch>=0.2
-Requires-Dist: random-fourier-features-pytorch>=1.0
-Requires-Dist: IPython>=8.16
-Requires-Dist: requests
-Requires-Dist: airfrans
-Requires-Dist: scipy
-Requires-Dist: pandas
+Requires-Dist: torch
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: onnx
+Requires-Dist: onnx-simplifier
+Requires-Dist: tqdm
+Requires-Dist: visualtorch
 Dynamic: license-file
 
 # NeuralNetworks Module

{neuralnetworks-0.2.5 → neuralnetworks-0.2.8}/pyproject.toml

@@ -19,20 +19,13 @@ classifiers = [
 ]
 
 dependencies = [
-    "numpy>=1.25",
-    "matplotlib>=3.10",
-    "tqdm>=4.66",
-    "torch>=2.9.1,<3.0",
-    "torchvision>=0.24,<1.0",
-    "torchaudio>=2.9,<3.0",
-    "torchmetrics>=1.8",
-    "visualtorch>=0.2",
-    "random-fourier-features-pytorch>=1.0",
-    "IPython>=8.16",
-    "requests",
-    "airfrans",
-    "scipy",
-    "pandas"
+    "torch",
+    "numpy",
+    "matplotlib",
+    "onnx",
+    "onnx-simplifier",
+    "tqdm",
+    "visualtorch"
 ]
 
 [project.urls]

neuralnetworks-0.2.8/src/NeuralNetworks/MLP/MLP.py

@@ -0,0 +1,64 @@
+# NeuralNetworks - Multi-Layer Perceptrons avec encodage Fourier
+# Copyright (C) 2025 - 2026 Alexandre Brun
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+from ._MLP_tools import encode, create_layers, torch
+from .._shared import Module
+
+class MLP (Module):
+    """
+    Réseau de neurones MLP avec encodage optionnel de type Fourier.
+    """
+    def __init__ (self                    ,
+        input_size         : int  = 1     , # Dimension d'entrée
+        output_size        : int  = 1     , # Dimension de sortie
+        hidden_layers      : list = [1]   , # Tailles des couches cachées
+        sigmas             : list = None  , # Répartition des fréquences
+        fourier_input_size : int  = 1     , # Dimension d'entrée pour l'encodage Fourier
+        nb_fourier         : int  = 8     , # Nombre de composantes Fourier
+        norm               : str  = "Relu", # Fonction d'activation / normalisation
+        name               : str  = "Net"): # Nom du modèle
+
+        """   Donnés de reconstruction de l'objet   """
+        super ().__init__ (name                     , #
+            input_size         = input_size         , # 
+            output_size        = output_size        , # 
+            hidden_layers      = hidden_layers      , # 
+            sigmas = 0 if sigmas is None else sigmas, # 
+            fourier_input_size = fourier_input_size , #       
+            nb_fourier         = nb_fourier         , #
+            norm               = norm               , #
+            name               = name               ) #
+
+        self.encodings, self.f = encode (
+            input_size         = input_size        , # Couche d'adaptation d'entrée
+            output_size        = output_size       , # Couche d'adaptation de sortie
+            sigmas             = sigmas            , # Répartition des fréquences
+            fourier_input_size = fourier_input_size, # Encode les premiers inputs
+            nb_fourier         = nb_fourier          # Attribue les fréquences
+        )
+        self.model             = create_layers (
+            input_size         = input_size        , # Créé une couche d'entrée
+            output_size        = output_size       , # Créé une couche de sortie
+            hidden_layers      = hidden_layers     , # Créé des couches intermédiaires
+            sigmas             = sigmas            , # Répartition des fréquences
+            fourier_input_size = fourier_input_size, # Dimension d'encodage Fourier
+            nb_fourier         = nb_fourier        , # Nombre de composantes Fourier
+            norm               = norm                # Fonction d'activation
+        )
+    def _forward (self, x : torch.Tensor):
+        """
+        Forward pass interne avec concaténation des encodages.
+        """
+        results_list = [self.model (encoding (x)) for encoding in self.encodings]
+        return self.f (torch.cat (results_list, dim = 1))
+
+    @property
+    def _dummy_input(self):
+        """
+        Données d'entrées pour enregistrement en .onnx
+        """
+        return torch.randn(1, self.Reconstruction_data["input_size"])

neuralnetworks-0.2.8/src/NeuralNetworks/MLP/_MLP_tools.py

@@ -0,0 +1,74 @@
+# NeuralNetworks - Multi-Layer Perceptrons avec encodage Fourier
+# Copyright (C) 2025 - 2026 Alexandre Brun
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+from .._Dependances import torch, nn, np, pi2, norms, device
+
+def create_layers(
+    input_size         : int , #
+    output_size        : int , #
+    hidden_layers      : int , #
+    sigmas             : list, #
+    fourier_input_size : int , #
+    nb_fourier         : int , #
+    norm               : str): #
+
+    if fourier_input_size > input_size:
+        raise Exception ("fourier_input_size > input_size impossible")
+    if sigmas is None or isinstance(sigmas, int) or (
+    isinstance(sigmas, np.ndarray) and sigmas.ndim == 0):
+        layer_list = [
+            nn.Linear (input_size, hidden_layers [0]),
+            norms.get (norm)
+        ]
+    else:
+        layer_list = [
+            nn.Linear (2*nb_fourier + input_size-fourier_input_size, hidden_layers [0]),
+            norms.get (norm)
+        ]
+
+    for k in range (len (hidden_layers) - 1):
+        layer_list.extend ([
+            nn.Linear (hidden_layers [k], hidden_layers [k + 1]),
+            norms.get (norm)
+        ])
+    layer_list.append (nn.Linear (hidden_layers [-1], output_size))
+
+    return nn.Sequential (*layer_list)
+
+class FourierEncoding (nn.Module):
+
+    def __init__ (self,
+        nb_fourier         : int   , # 
+        fourier_input_size : int   , #
+        sigma              : float): #
+        super ().__init__ ()
+
+        self.B = nn.Parameter (torch.randn (nb_fourier, fourier_input_size) * sigma)
+        self.size = fourier_input_size
+
+    def forward (self, x : torch.Tensor):
+        x_fourier, x_rest = x.split([self.size, x.shape[-1] - self.size], dim=-1)
+        vp = pi2 * x_fourier @ self.B.T
+        return torch.cat ((torch.cos(vp), torch.sin(vp), x_rest), dim = -1)
+
+def encode (
+    input_size         : int , #
+    output_size        : int , #
+    sigmas             : list, #
+    fourier_input_size : int , #
+    nb_fourier         : int): #
+
+    if sigmas is None or isinstance(sigmas, int) or (
+    isinstance(sigmas, np.ndarray) and sigmas.ndim == 0):
+        return nn.ModuleList ([nn.Identity ()]), nn.Identity ()
+
+    size = fourier_input_size
+
+    return (
+        nn.ModuleList ([FourierEncoding (nb_fourier, size, sigma) for sigma in sigmas]),
+        nn.Linear (len (sigmas) * output_size, output_size)
+    )

neuralnetworks-0.2.8/src/NeuralNetworks/MLP/__init__.py

@@ -0,0 +1,8 @@
+# NeuralNetworks - Multi-Layer Perceptrons avec encodage Fourier
+# Copyright (C) 2025 - 2026 Alexandre Brun
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+from .MLP import MLP

neuralnetworks-0.2.8/src/NeuralNetworks/Trainer/Trainer.py

@@ -0,0 +1,98 @@
+# NeuralNetworks - Multi-Layer Perceptrons avec encodage Fourier
+# Copyright (C) 2025 - 2026 Alexandre Brun
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+from ._Trainer_tools import device
+from ._Trainer_tools import init_Trainer, init_train
+from ._Trainer_tools import epoch_logic, update_lr, update_trakers
+from ._Trainer_tools import torch, trange
+
+from .._shared import Module
+
+class Trainer:
+    """
+    Objet de gestion d'entrainement de modèle.
+    """
+    def __init__(self                    ,
+        *nets            : Module        , # Modèles à entraîner
+        inputs           : torch.Tensor  , # Données d'entrée
+        outputs          : torch.Tensor  , # Données de sortie
+        init_train_size  : float = 0.01  , # Fraction du dataset initiale
+        final_train_size : float = 1.0   , # Fraction du dataset finale
+        optim            : str   = 'Adam', # Nom de l'optimiseur
+        init_lr          : float = 1e-3  , # Learning rate initial
+        final_lr         : float = 1e-5  , # Learning rate final
+        crit             : str   = 'MSE' , # Fonction de coût
+        batch_size       : int   = 1024 ): # Taille des batchs
+        """
+        Initialise l'entraîneur.
+        """
+        self.nets   , self.batch_size  = nets, batch_size
+        self.init_train_size, self.final_train_size = init_train_size, final_train_size
+        self.init_lr, self.final_lr = init_lr, final_lr
+        self.inputs , self.outputs  = inputs , outputs
+        self.crit   , self.optim_list, self.name       = init_Trainer (
+                                            nets       = nets      , # Lie les modèles
+                                            crit       = crit      , # Critères
+                                            optim      = optim     , # Optimiseurs         
+                                            init_lr    = init_lr   , # Ajoute au nom
+                                            batch_size = batch_size  # Ajoute au nom
+        )
+    def train (self                 ,
+        num_epochs   : int  = 1500  , # Nombre d'époques
+        disable_tqdm : bool = False , # Désactive la barre de progression
+        benchmark    : bool = False): # Mode benchmark
+        """
+        Lance l'entraînement des modèles.
+        """
+        outputs_size         = self.outputs.size ( ) [1]
+        self.inputs, self.outputs, train_losses, train_lrs, n_samples = init_train (
+            inputs           = self.inputs          , # Envoi sur le device
+            outputs          = self.outputs         , # Envoi sur le device
+            init_train_size  = self.init_train_size , # Fraction du dataset initiale
+            final_train_size = self.final_train_size, # Fraction du dataset finale
+            num_epochs       = num_epochs           , # Utile pour learning rates
+            benchmark        = benchmark              # Active le mode benchmark
+        )
+        for k, net in enumerate (self.nets):
+            net = net.to (device)                 # Envoi du réseau sur le device
+            net.train ()
+            for epoch in trange (num_epochs     , # Nombre d'époques à effectuer
+                desc    = f"Training {net.name}", # Paramètre d'affichage
+                unit    = "epoch"               , # Paramètre d'affichage
+                disable = disable_tqdm         ): # Paramètre d'affichage
+                epoch_logic (
+                    net          = net                , # Réseau courant
+                    epoch        = epoch              , # Epoque actuelle
+                    train_losses = train_losses       , # Résidus de l'entrainement
+                    n_samples    = n_samples [epoch]  , # Taille des mini-batchs
+                    inputs       = self.inputs        , # Données d'entrée
+                    outputs      = self.outputs       , # Données de sortie
+                    outputs_size = outputs_size       , # Nombre de sorties
+                    batch_size   = self.batch_size    , # Taille du batch
+                    optim        = self.optim_list [k], # Calcul des gradients
+                    crit         = self.crit            # Calcul des résidus
+                )
+                update_lr (
+                    init_lr      = self.init_lr       , # Learning rate initial
+                    final_lr     = self.final_lr      , # Learning rate final
+                    optim        = self.optim_list [k], # Met à jour le learning rate
+                    outputs_size = outputs_size       , # Nombre de sorties
+                    train_losses = train_losses       , # Résidus de l'entrainement
+                    train_lrs    = train_lrs          , # lrs de l'entrainement
+                    epoch        = epoch                # Epoque actuelle
+                )
+            net = net.to   (torch.device ("cpu")) # Envoi du réseau sur le cpu
+            update_trakers (
+                net          = net         ,      # Réseau courant
+                train_losses = train_losses,      # Met à jour la liste de résidus
+                train_lrs    = train_lrs   )      # Met à jour la liste de lr
+            net.eval ()
+        self.inputs  = self.inputs.to  (torch.device ("cpu")) # Envoi sur le cpu
+        self.outputs = self.outputs.to (torch.device ("cpu")) # Envoi sur le cpu
+        torch.cuda.empty_cache ( )                            # Vide le cache
+    def __repr__ (self):
+        return self.name

neuralnetworks-0.2.8/src/NeuralNetworks/Trainer/_Trainer_tools.py

@@ -0,0 +1,155 @@
+# NeuralNetworks- Multi-Layer Perceptrons avec encodage Fourier
+# Copyright (C) 2025 - 2026 Alexandre Brun
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+from .._Dependances import torch, trange, scaler, autocast
+from .._Dependances import device, dev, crits, optims
+from .._shared import Module
+
+def epoch_logic (
+    net          : Module                , # Réseau courant
+    epoch        : int                   , # Epoche actuelle
+    train_losses : torch.Tensor          , # Résidus de l'entrainement
+    n_samples    : int                   , # Nombre de donnés à prendre
+    inputs       : torch.Tensor          , # Données d'entrée
+    outputs      : torch.Tensor          , # Données de sortie
+    outputs_size : int                   , # Nombre de sorties
+    batch_size   : int                   , # Taille des batchs
+    optim        : torch.optim           , # Optimiseur utilisé
+    crit         : torch.nn.modules.loss): # Critère de loss utilisé
+    """
+    Effectue une époque d'entraînement sur des mini-batchs.
+    """
+
+    perm = torch.randperm (n_samples, device=device, requires_grad=False)
+    
+    for i in range (0, n_samples, batch_size):
+        idx = perm [i : i + batch_size]
+        optim.zero_grad (set_to_none = True)
+        
+        with autocast (dev):
+            all_loss = crit( net.train_forward(inputs[idx]), outputs[idx] ).mean(dim=0)
+
+        scaler.scale  ( all_loss.mean() ).backward ()
+        scaler.step   (optim)
+        scaler.update (     )
+        
+        train_losses[epoch].add_(all_loss.detach())
+
+def generate_learning_rate (Nb_iter : int ):
+    """
+    Génère une courbe de learning rate lisse.
+    """
+
+    infl = int (0.1 * Nb_iter)
+
+    lr_curve = torch.empty(Nb_iter, device=device)
+
+    t = torch.linspace(0.0, 1.0, infl, device=device, requires_grad=False)
+    t4 = t*t; t3 = t4*t; t4.mul_(t4) ; t5 = t4*t
+    lr_curve[:infl] = 1 - 0.5 * (6*t5 - 15*t4 + 10*t3)
+
+    t = torch.linspace(0.0, 1.0, Nb_iter - infl, device=device, requires_grad=False)
+    t4 = t*t; t3 = t4*t; t4.mul_(t4) ; t5 = t4*t
+    lr_curve[infl:]  =    0.5 * (1 - 6*t5 - 15*t4 + 10*t3)
+
+    return lr_curve
+
+def update_lr (
+    init_lr      : float       , # Learning rate initial
+    final_lr     : float       , # Learning rate final
+    optim        : torch.optim , # Optimiseur utilisé
+    outputs_size : int         , # Nombre de sorties
+    train_losses : torch.Tensor, # Derniers résidus
+    train_lrs    : torch.Tensor, # Learning rates
+    epoch        : int        ): # Epoque courante
+    """
+    Calcule un learning rate adaptatif basé sur les pertes récentes.
+    """
+    
+    if epoch >= 1:
+        x = train_losses[max(0, epoch-10):epoch].min(dim=0).values.max()
+    else:
+        x = train_losses[:1].min(dim=0).values.max()
+
+    y, u9 = x.clone(), x.clone() 
+
+    y.mul_(y); y.mul_(y) 
+    u9.mul_(-2); u9.add_(1); u9.addcmul_(x, x, value=1); u9.mul_(u9); u9.mul_(u9)
+    
+    y.sub_(u9); y.add_(1.0); y.mul_(0.5)
+
+    train_lrs[epoch].clamp_min_(y)
+    train_lrs[epoch].mul_(init_lr - final_lr).add_(final_lr)
+
+    for param_group in optim.param_groups:
+        param_group ['lr'] = train_lrs[epoch].item()
+
+def update_trakers (
+    net          : Module       , # Réseau courant
+    train_losses : torch.Tensor , # Résidus
+    train_lrs    : torch.Tensor): # Learning rates
+    """
+    Met à jour l'historique des pertes et le learning rate du modèle.
+    """
+
+    net.losses    += train_losses.cpu().tolist()
+    net.learnings += train_lrs.cpu().tolist()
+
+        
+def init_train (
+    inputs           : torch.Tensor, # Données d'entrée
+    outputs          : torch.Tensor, # Données de sortie
+    init_train_size  : float       , # Proportion de données initiale
+    final_train_size : float       , # Proportion de données finale
+    num_epochs       : int         , # Nombre d'époques
+    benchmark        : bool       ): # Activation du mode benchmark
+    """
+    Prépare les données et l'environnement d'entraînement.
+    """
+
+    torch.backends.cudnn.benchmark    = benchmark
+    torch.autograd.set_detect_anomaly  (benchmark)
+    torch.autograd.profiler.profile    (benchmark)
+    torch.use_deterministic_algorithms (benchmark)
+
+
+    n_samples = torch.linspace(
+        inputs.size(0) * init_train_size,
+        inputs.size(0) * final_train_size,
+        num_epochs, device = device, requires_grad=False
+    ).ceil().int()
+
+    inputs  = inputs.to  (device)
+    outputs = outputs.to (device)
+
+    train_lrs    = generate_learning_rate (num_epochs)
+    train_losses = torch.zeros(
+        (num_epochs, outputs.size(1)), device=device, requires_grad=False
+    )
+    
+    torch.cuda.empty_cache ()
+    return inputs, outputs,train_losses, train_lrs, n_samples
+
+def init_Trainer (
+    nets       : list , # Modèles à entraîner
+    crit       : str  , # Fonction de coût
+    optim      : str  , # Optimiseur utilisé
+    init_lr    : float, # Learning rate initial
+    batch_size : int ): # Taille des batchs
+    """
+    Initialise le critère de perte et les optimiseurs.
+    """
+    name =  f"| optim      : {optim}\n"
+    name += f"| crit       : {crit}\n"
+    name += f"| init_lr    : {init_lr}\n"
+    name += f"| batch_size : {batch_size}"
+
+    optim_list = []
+    for net in nets:
+        param = [{"params" : net.parameters (), "lr" : init_lr}]
+        optim_list.append( optims.get (optim) (param))
+    return crits.get (crit), optim_list, name

neuralnetworks-0.2.8/src/NeuralNetworks/Trainer/__init__.py

@@ -0,0 +1,8 @@
+# NeuralNetworks - Multi-Layer Perceptrons avec encodage Fourier
+# Copyright (C) 2025 - 2026 Alexandre Brun
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+from .Trainer import Trainer

neuralnetworks-0.2.8/src/NeuralNetworks/VAE/VAE.py

@@ -0,0 +1,114 @@
+# NeuralNetworks - Multi-Layer Perceptrons avec encodage Fourier
+# Copyright (C) 2025 - 2026 Alexandre Brun
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+from .._Dependances import *
+from .._shared import Module
+
+class VAE(Module):
+    def __init__(self                           , #
+        imsize          : int                   , #
+        latentsize      : int                   , #
+        labelsize       : int                   , #
+        channels        : list = [16, 32, 16, 8], #
+        linear_channels : list = [100]          , #
+        name            : str  = "encoder"      , #
+        norm            : str  = "Relu"         , #
+        norm_cc         : str  = "Relu"        ): #
+
+        super().__init__(name                , #
+            imsize          = imsize         , #
+            latentsize      = latentsize     , #
+            labelsize       = labelsize      , #
+            channels        = channels       , #
+            linear_channels = linear_channels, #
+            name            = name           , #
+            norm            = norm           , #
+            norm_cc         = norm_cc        ) #
+
+        self.imsize     = imsize
+        self.latentsize = latentsize
+        self.labelsize  = labelsize
+        
+        # Start latent conv channels
+        if norm is None:
+            self.norm = nn.Identity()
+        else:
+            self.norm = norms.get(norm)
+
+        if norm_cc is None:
+            self.norm_cc = nn.Identity()
+        else:
+            self.norm_cc = norms.get(norm_cc)
+        
+        # ----- Encoder -----
+        Elayers = []
+        in_ch = 1  # grayscale input
+        for out_ch in channels:
+            Elayers.append(nn.Conv2d(in_ch, out_ch, kernel_size=3, stride=1, padding=1))
+            Elayers.append(self.norm_cc)
+            Elayers.append(nn.MaxPool2d(kernel_size=3, stride=3, padding=1))
+            in_ch = out_ch
+
+        # Compute final flattened size dynamically
+        with torch.no_grad():
+            dummy = torch.zeros(1, 1, imsize, imsize)
+            for layer in Elayers:
+                dummy = layer(dummy)
+            flat_dim = dummy.numel()
+            del dummy
+        
+        Elayers.append(nn.Flatten())
+        Elayers.append(nn.Linear(flat_dim, linear_channels[0]))#(cl_nbr+1) * int(imsize/2**cl_nbr)**2, latentsize * 30))
+        Elayers.append(self.norm)
+        Elayers.append(nn.Linear(linear_channels[0], latentsize))
+        Elayers.append(self.norm)
+        self.Emodel = nn.Sequential(*Elayers)
+        
+        # ----- Decoder -----
+        Dlayers = []
+        Dlayers.append(nn.Linear(latentsize, int((labelsize+latentsize)/2)))
+        Dlayers.append(self.norm)
+        Dlayers.append(nn.Linear(int((labelsize+latentsize)/2), int((labelsize+latentsize))))
+        Dlayers.append(self.norm)
+        Dlayers.append(nn.Linear(int((labelsize+latentsize)), int((labelsize+latentsize))))
+        Dlayers.append(self.norm)
+        Dlayers.append(nn.Linear(int((labelsize+latentsize)), labelsize))
+        Dlayers.append(self.norm)
+     
+        self.Dmodel = nn.Sequential(*Dlayers)
+
+    def encode(self, inputs):
+        image = np.array(inputs)
+        inputs = tensorise(inputs).to(device)
+        
+        if image.ndim == 4:
+            x = inputs
+        elif inputs.ndim == 3:        # [H, W, C]? Or [C, H, W]?
+            x = inputs.unsqueeze(0) # → [1, C, H, W]
+        elif image.ndim == 2:      # [H, W]
+            x = inputs.unsqueeze(0).unsqueeze(0)  # → [1, 1, H, W]
+        inputs = inputs.to('cpu')
+
+        self.Emodel = self.Emodel.to(device)
+        output = self.Emodel(x).flatten()
+        self.Emodel = self.Emodel.to('cpu')
+        return output
+                                                
+    def decode(self, vector):
+        vector = tensorise(vector).to(device)
+        x = vector.view(1, 1, 1, self.latentsize)   # batch=1, channels=8, h=1, w=1
+        vector = tensorise(vector).to('cpu')
+        self.Dmodel = self.Dmodel.to(device)
+        output = self.Dmodel(x).cpu().detach().numpy()[0][0]
+        self.Dmodel = self.Dmodel.to('cpu')
+        return output
+
+    def _forward (self, x):
+        return self.Dmodel(x)
+
+    def train_forward (self, x):
+        return self.Dmodel(self.Emodel(x))

neuralnetworks-0.2.8/src/NeuralNetworks/VAE/_VAE_tools.py

@@ -0,0 +1,6 @@
+# NeuralNetworks - Multi-Layer Perceptrons avec encodage Fourier
+# Copyright (C) 2025 - 2026 Alexandre Brun
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.

neuralnetworks-0.2.8/src/NeuralNetworks/VAE/__init__.py

@@ -0,0 +1,8 @@
+# NeuralNetworksBeta - Multi-Layer Perceptrons avec encodage Fouriertsize
+# Copyright (C) 2025 - 2026 Alexandre Brun
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+from .VAE import VAE

neuralnetworks-0.2.5/src/NeuralNetworks/Dependances/matplot.py → neuralnetworks-0.2.8/src/NeuralNetworks/_Dependances/__init__.py

@@ -1,5 +1,5 @@
 # NeuralNetworks - Multi-Layer Perceptrons avec encodage Fourier
-# Copyright (C) 2026 Alexandre Brun
+# Copyright (C) 2025 - 2026 Alexandre Brun
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
@@ -7,19 +7,19 @@
 
 import matplotlib.pyplot as plt
 from matplotlib.gridspec import GridSpec
+from matplotlib.ticker import FixedLocator
 
 plt.rcParams['figure.facecolor'] = (0,0,0,0)
 plt.rcParams['axes.facecolor']   = (0,0,0,0)
-grey_color = "#888888"
+plt.rcParams['axes.grid']  = True
 
-# Style général du texte et axes
-plt.rcParams['text.color']       = grey_color
-plt.rcParams['axes.labelcolor']  = grey_color
-plt.rcParams['xtick.color']      = grey_color
-plt.rcParams['ytick.color']      = grey_color
-plt.rcParams['axes.edgecolor']   = grey_color
-plt.rcParams['axes.titlecolor']  = grey_color
+from .pytorch import *
+from .tools import *
 
-# Activation de la grille globale
-plt.rcParams['axes.grid']  = True
-plt.rcParams['grid.color'] = grey_color
+import numpy as np
+
+from tqdm.auto import trange, tqdm
+
+
+import onnx
+from onnxsim import simplify