NeuralNetworks 0.2.5__py3-none-any.whl → 0.2.8__py3-none-any.whl

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/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/MLP/__init__.py

@@ -1,99 +1,8 @@
 # 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
 # (at your option) any later version.
 
-from ..Dependances import norm_list, nn
-from .FourierFeatures import encode
-from .Layers import create_layers
-from .inference import infer
-
-class MLP (nn.Module):
-    """
-    Multi-Layer Perceptron avec encodage de Fourier optionnel.
-
-    Cette classe implémente un MLP configurable, pouvant intégrer un ou
-    plusieurs encodages de Fourier en entrée afin d'améliorer la capacité
-    de représentation sur des signaux à haute fréquence.
-
-    Parameters
-    ----------
-    input_size : int, optional
-        Dimension des entrées du réseau. Default: 1.
-    output_size : int, optional
-        Dimension des sorties du réseau. Default: 1.
-    hidden_layers : list[int], optional
-        Liste des tailles des couches cachées. Default: [1].
-    sigmas : list[float] ou None, optional
-        Paramètres sigma pour les encodages de Fourier. Si `None`,
-        aucun encodage de Fourier n'est utilisé.
-    fourier_input_size : int, optional
-        WIP
-    nb_fourier : int, optional
-        Nombre de composantes de Fourier par encodage. Default: 8.
-    norm : str, optional
-        Nom de la fonction d'activation à utiliser. Default: "Relu".
-    name : str, optional
-        Nom du réseau. Default: "Net".
-    """
-
-    def __init__ (
-        self,
-        input_size = 1,
-        output_size = 1,
-        hidden_layers = [1],
-        sigmas = None,
-        fourier_input_size = 2,
-        nb_fourier = 8,
-        norm = "Relu",
-        name = "Net"):
-        super ().__init__ ()
-
-        # --- Activation ---
-        self.norm = norm_list.get (norm)
-        if self.norm is None:
-            print (f"Warning: '{norm}' not recognized, falling back to 'Relu'")
-            self.norm = norm_list.get ("Relu")
-
-        # --- Attributs ---
-        self.losses = []
-        self.learnings = []
-        self.name = name
-        
-        ## --- Encodage Fourier ou passthrough ---
-        self.encodings, self.f = encode (
-            input_size,
-            output_size,
-            sigmas,
-            fourier_input_size,
-            nb_fourier
-        )
-            
-        # --- Construction du réseau ---
-        self.model = create_layers (
-            input_size,
-            output_size,
-            hidden_layers,
-            sigmas,
-            fourier_input_size,
-            nb_fourier,
-            self.norm
-        )
-
-    def forward (self, x):
-        """
-        Effectue une passe avant du réseau.
-
-        Parameters
-        ----------
-        x : torch.Tensor
-            Entrées du réseau de shape `(N, input_size)`.
-
-        Returns
-        -------
-        torch.Tensor
-            Sortie du MLP de shape `(N, output_size)`.
-        """
-        return infer (self, x)
+from .MLP import MLP

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/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/Trainer/__init__.py

@@ -1,51 +1,8 @@
 # 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
 # (at your option) any later version.
 
-from ..Dependances import crit_list, optim_list
-from .train import train_f
-from .sample_data import sample_data
-
-class Trainer:
-
-    def __init__(self,
-        *nets,
-        inputs,
-        outputs,
-        test_size = None,
-        optim = 'Adam',
-        init_lr = 0.01,
-        crit = 'MSE',
-        batch_size = float):
-
-        self.batch_size = batch_size
-        self.nets = nets
-        self.init_lr = init_lr
-
-        self.X_train, self.X_test, self.y_train, self.y_test = sample_data (
-            inputs,
-            outputs,
-            test_size
-        )
-
-        # --- Fonction de perte ---
-        self.crit = crit_list.get(crit)
-        if self.crit is None:
-            print(f"Warning: '{self.crit}' not recognized, falling back to 'MSE'")
-            self.crit = crit_list.get("MSE")
-
-        # --- Sélection de l’optimiseur ---
-        self.optims = []
-        for net in nets:
-            params = [{"params": net.parameters(), "lr": self.init_lr}]
-            new_optim = optim_list(params).get(optim)
-            if new_optim is None:
-                print(f"Warning: '{optim}' not recognized, falling back to 'Adam'")
-                new_optim = optim_list(params).get("Adam")
-            self.optims.append(new_optim)
-
-    def train (self, num_epochs = 1500, activate_tqdm = True):
-        train_f (self, num_epochs, activate_tqdm)
+from .Trainer import Trainer

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/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/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